Claude opencode Skill

minutes-mirror

Self-coaching analysis of your own behavior across meetings — talk-time ratio, filler words, hedging language, monologue length, energy patterns, and (when meetings are tagged via /minutes-tag) what your behavior in winning meetings looks like vs losing ones. Use this whenever th

LLM Mart · 0 points · 20 views 1 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download silverstein-minutes-.agents_skills_minutes_minutes-mirror-e56450a.zip · 10 KB
silverstein/minutes 1501 165 forks MIT Updated 9h ago
Part of silverstein/minutes — 155 skills

Install

skills CLI npx skills add https://github.com/silverstein/minutes/tree/main/.agents/skills/minutes/minutes-mirror
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install silverstein-minutes@llmmart
Git git clone https://github.com/silverstein/minutes.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole silverstein/minutes collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Skill Path

Before running helper scripts or opening bundled references, set:

export MINUTES_SKILLS_ROOT="$(git rev-parse --show-toplevel)/.agents/skills/minutes"
export MINUTES_SKILL_ROOT="$MINUTES_SKILLS_ROOT/minutes-mirror"

/minutes-mirror

Self-coaching analysis based on your own meeting transcripts. Two modes:

  • Single-meeting mode — review a specific meeting and surface what you did, what was unusual for you, and one concrete thing to try next time.
  • Pattern mode — surface trends across the last 30 days, including (if meetings are tagged) what behaviors correlate with winning vs losing.

The point is not to roast you. The point is to give you a kind, evidence-based mirror to behaviors that are usually invisible to you because you're inside them.

How it works

Phase 0: Identify "you"

Mirror needs to know which speaker label in the transcript is the user. Real transcripts use one of two formats:

  • Enrolled users: [Mat 0:00] Hey there. — first-name labels from voice enrollment
  • Non-enrolled users: [SPEAKER_0 0:00] Hey there. — generic labels from diarization

Either way, mirror needs to know which label maps to the user. Check sources in order:

1. Enrolled voice profile:

minutes voices --json 2>/dev/null

Returns a JSON array of enrolled profiles. The user's profile is the one with source: "self-enrollment" (or the first one if there's only one). Use the name field as the speaker label to look for in transcripts. Example response:

[{"person_slug": "mat", "name": "Mat", "source": "self-enrollment", ...}]

→ Speaker label is Mat.

2. Cached self name(s):

cat ~/.minutes/config/self.txt 2>/dev/null

The cache may contain multiple labels, one per line (e.g., Mat, Mat S., MAT_SILVERSTEIN) — match any of them. People often appear under multiple labels across transcripts.

3. Ask once and cache: If neither source returns a name, ask via AskUserQuestion: "Which speaker label in your transcripts is you? You can give multiple if you appear under different names (e.g., 'Mat, Mat S., MAT_SILVERSTEIN')."

Cache the answer (comma-separated input → one label per line):

mkdir -p ~/.minutes/config
printf '%s\n' <label1> <label2> ... > ~/.minutes/config/self.txt

This is a one-time setup cost. Don't ask again on future runs. If the user later mentions they have a new label, they can re-edit the file or re-run with mirror reset-self.

Phase 1: Pick a mode

Single-meeting mode triggers on: "review my last meeting", "how did I do", "mirror that call", "feedback on the Sarah call".

Pattern mode triggers on: "show my patterns", "trends", "across all meetings", "coach me", "what do my winning meetings look like".

If ambiguous, default to single-meeting mode on the most recent meeting — it's fast, useful, and obviously what most people mean.

Phase 2a: Single-meeting analysis

Find the target meeting (filter to meetings, not voice memos — talk-time analysis on a solo memo is meaningless):

minutes list --content-type meeting --limit 5

Require exit status 0. If the user named a specific meeting, use bounded search to identify its exact path; otherwise pick the most recent list result. Paths are hints, not retained capabilities.

Compute the metrics with the bundled helper script, not by counting in-context. LLMs are bad at exact token counting; the script does it deterministically with regex and basic string ops.

set -o pipefail
minutes get "<exact path>" | \
python3 "$MINUTES_SKILL_ROOT/scripts/mirror_metrics.py" \
  - \
  --self "$(cat ~/.minutes/config/self.txt 2>/dev/null | paste -sd, -)"

Require both sides of the pipeline to exit successfully. The helper receives only the exact native-authorized bytes over stdin; never pass it a meeting path.

The --self flag takes a comma-separated list of speaker labels (e.g., Mat,Mat S.,SPEAKER_3). Use the labels you cached in Phase 0.

The script outputs JSON to stdout with these fields:

Field Meaning
total_words, self_words, other_words Word counts (split-on-whitespace)
talk_ratio self_words / total_words as a 0–1 float
self_turn_count, other_turn_count Number of speaker turns
speakers All distinct speaker labels seen in the transcript
filler_count, filler_per_100_words Filler-word hits in self speech (um, uh, like, you know, basically, literally, kinda, right?)
hedging_count, hedging_per_100_words Hedging hits in self speech (maybe, kind of, sort of, i think, i guess, possibly, somewhat, a little, perhaps, sorry to). The word just is intentionally excluded — too many false positives.
question_count, questions_per_5min Self questions (? count)
duration_minutes From last timestamp if present, else word-count estimate at 150 wpm
longest_monologue Longest uninterrupted self stretch: word count, seconds estimate, first 8 words, start time
longest_listen Same shape, but for the longest stretch where you didn't speak
outcome Supported frontmatter outcome (won, lost, stalled, great, noise), or null

The script exits non-zero on errors (file missing, no diarized turns, no self labels matched). On exit code 3 ("no turns matched any self label"), it tells you which speaker labels it found in the transcript — re-run with one of those, or update ~/.minutes/config/self.txt.

Compute your baseline from the last ~10 bounded list results. For each path, repeat the native minutes get to stdin pipeline above and require both commands to succeed. Never enumerate or open the meeting directory directly. Average the metrics. If you have fewer than 5 successful meetings, say so explicitly — "Baseline computed from only N meetings, treat with caution" — instead of pretending the comparison is meaningful.

Once you have current-meeting metrics + baseline, flag anything >25% off baseline as worth noting.

Output format:

## Mirror: <meeting title> · <date>

**Talk time**: You spoke <X>% of the time. (Your 30-day average: <Y>%.) <flag if abnormal>
**Longest monologue**: ~<N> seconds on "<topic>". <one-line judgment: was it earned (you were asked to explain something complex) or was it dominance?>
**Longest you listened**: ~<N> seconds during "<topic>". <one-line: what did they reveal?>
**Filler words**: <N> per 100 words. (Average: <Y>.)
**Hedging**: <N> per 100 words. (Average: <Y>.) <flag specific moments if you hedged on price, scope, or commitment>
**Questions asked**: <N>. <one-line: was this discovery, close, or update?>

### What stood out
<2–3 specific moments worth re-reading. Quote a short line from the transcript and say why it matters. Be specific — "You hedged the moment Sarah pushed on price ('I mean, I think we could maybe…')" beats "you hedged sometimes".>

### One thing to try next time
<Exactly one. Concrete. Achievable in the next call. Not a personality change — a behavior change. Falsifiable so the next mirror can verify it.>

Phase 2b: Pattern mode

Run across the last 30 days (or whatever window the user gives you).

Run minutes list --content-type meeting --limit 50, require exit status 0, and filter its JSON results to the requested window. Retrieve each selected meeting only through the native minutes get to stdin pipeline above.

Compute the same per-meeting metrics across every successfully authorized normal meeting in the window. Then look for patterns:

Behavioral patterns (always available):

  • Trend in talk ratio over time (going up = dominating more, going down = listening more)
  • Topics that correlate with high talk ratio (where do you steamroll?)
  • Topics that correlate with high hedging (where do you lose authority?)
  • Filler word rate by time-of-day (fatigue curve?)
  • Day-of-week patterns (worse on Mondays?)
  • Meeting length patterns (do your >45-min meetings degrade?)

Outcome correlations (only if meetings are tagged via /minutes-tag):

Standard outcome tags that mirror correlates: won, lost, stalled, great, noise. These mirror the set defined by /minutes-tag — if that skill ever adds new standard tags, update mirror to recognize them too. Custom (non-standard) tags are ignored for correlation analysis.

The helper includes a bounded outcome field (won, lost, stalled, great, noise, or null) from the same authorized bytes. If every result is null, skip the outcome-correlation section. Otherwise group only those returned values and compare metrics across groups:

  • "In meetings you tagged won, your average talk ratio was 38%. In lost meetings, 67%."
  • "In stalled meetings, your hedging rate was 2× your baseline."
  • "Every meeting you tagged great had ≥12 questions from you in the first 10 minutes."

Minimum data thresholds:

  • Behavioral patterns need ≥5 meetings in the window to be meaningful. Below that, single-meeting mode is more honest.
  • Outcome correlations need ≥3 meetings per tag group. Below that, it's noise.
  • If thresholds aren't met, surface what you can compute and tell the user explicitly: "Tag more meetings via /minutes-tag and I can show you what wins look like."

Output format:

## Mirror: 30-day patterns

**You've been in <N> meetings.** Here's what I see:

### Talk patterns
<2–3 bullets, specific>

### Where you hedge
<2–3 bullets with specific topics>

### Energy & timing
<observations about time-of-day, fatigue, day-of-week>

### Win/loss correlation
<only if ≥3 tagged meetings per outcome — otherwise skip this section entirely>

### One thing to try this week
<Exactly one. Concrete. Falsifiable.>

Phase 3: Closing ritual

End with two beats:

  1. Specific experiment — Restate the "one thing to try" as a concrete test. "Try cutting your hedging in your next 3 meetings. I'll measure it when you ask me to mirror again."

  2. Tag nudge (only if no meetings have an outcome: field yet) — "After your next meeting, run /minutes-tag won|lost|stalled so I can correlate behavior with outcomes over time. ~10 tagged meetings is when the patterns get sharp."

Gotchas

  • Long-transcript accuracy degrades. LLMs are bad at exact token counting. For transcripts >5000 words, your filler-word and hedging counts are estimates, not measurements. Either say so in the output ("≈14 fillers, sampled from 3 segments") or sample three 1500-word segments (start, middle, end) and extrapolate. Don't pretend you exactly counted 8327 words.
  • This is coaching, not roasting. Be specific, evidence-based, and kind. Quote actual lines from the transcript before making any judgment about tone or behavior. Never make claims you can't point to evidence for. The user is looking at themselves here — be the coach you'd want.
  • Speaker identification can fail. If transcripts use generic labels like SPEAKER_0/SPEAKER_1 and the user hasn't enrolled their voice, the analysis can't know which speaker is them. Ask once per machine, cache forever in ~/.minutes/config/self.txt.
  • Don't fake metrics. If a transcript has no speaker diarization (one big block, no speaker labels), say so and offer pattern mode across other meetings instead. Don't compute talk-time on a transcript without speakers — the number will be wrong and the user will lose trust in everything else.
  • Word-count duration estimates are rough. 150 wpm is the convention. Use timestamps when present in the transcript; fall back to word count when not. Always say "≈" or "" so the user knows it's an estimate.
  • Avoid corporate language. Don't say "your engagement scores" or "talk-time KPI". Talk like a coach who actually cares: "you spoke 58% of the time" not "talk-time metric: 0.58".
  • Pattern mode needs at least 5 meetings. Below that, single-meeting mode is more honest. Don't surface "trends" from 2 data points.
  • Outcome correlations need at least 3 per group. Below that, it's noise. Tell the user the threshold and how to reach it.
  • Don't pathologize high talk time. Sometimes talking 70% is correct — it's a presentation, you're delivering bad news, you're explaining something complex to a non-expert. Compare to baseline and note context. Don't treat any number as automatically bad.
  • The "one thing" must be testable. "Be more confident" is useless. "Cut hedging words from your next 3 close calls" is testable. The user will either do it or not, and the next mirror should be able to verify.
  • Never compare across users. Mirror is a mirror to this user, not a benchmark vs anyone else. Don't say "the average sales rep talks 45%". Compare the user only to themselves.
  • Hedging matters most around price, scope, and commitment. A general filler-word count is interesting; flagging that the user hedged the moment Sarah pushed on price is useful. Surface where the hedging happened, not just how much.
Files (minutes)
  • agents
    • openai.yaml 900 B 
      interface:
  display_name: "Minutes Mirror"
  short_description: "Self-coaching analysis of your own behavior across meetings — talk-time ratio, filler words, hedging language, monologue length, energy patterns, and (when meetings are tagged via /minutes-tag) what your behavior in winning meetings looks like vs losing ones. Use this whenever the user says \"how did I do\", \"review my last meeting\", \"mirror\", \"self-review\", \"show my patterns\", \"coach me\", \"where am I weak\", \"talk time\", \"am I improving\", \"what do I do in meetings I win\", \"feedback on me\", or asks for any kind of personal feedback on their own meeting behavior. This is the rare skill that gives the user a mirror to their own habits — surface it whenever they show curiosity about their own performance, even if they don't use the word \"mirror\"."
  default_prompt: "Use Minutes Mirror for this task."
  • scripts
    • mirror_metrics.py 11.2 KB 
      #!/usr/bin/env python3
"""
mirror_metrics.py — Deterministic behavioral metrics from a meeting transcript.

Used by the /minutes-mirror skill to avoid LLM token-counting errors.
The skill calls this script via Bash and consumes the JSON output.

Usage:
    mirror_metrics.py <meeting_file.md> --self "Mat,Mat S.,MAT_SILVERSTEIN"
    minutes get <meeting-path> | mirror_metrics.py - --self "Mat"

Self labels are matched case-insensitively against the speaker label inside
[NAME 0:00] markers in the transcript section. Multiple labels can be passed
comma-separated for users who appear under different names across meetings.

Output: JSON to stdout with talk_ratio, fillers, hedging, monologue, etc.
Errors: JSON to stderr with non-zero exit code.

Requires: Python 3.8+, stdlib only. No external dependencies.
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from pathlib import Path

# Filler words counted in self speech.
FILLERS = (
    "um", "uh", "like", "you know", "basically", "literally", "kinda", "right?",
)

# Hedging language counted in self speech. "just" is intentionally excluded —
# its false-positive rate is too high ("just want to confirm" is not hedging).
HEDGES = (
    "maybe", "kind of", "sort of", "i think", "i guess", "possibly",
    "somewhat", "a little", "perhaps", "sorry to",
)

# Speaker turn markers. Real Minutes transcripts use two distinct formats and
# mirror needs to handle both:
#
#   1. Bracket form (from local whisper + diarization):
#        [Mat 0:00] Hello
#        [Mat S. 0:00] Hello          ← multi-word label
#        [SPEAKER_3 12:34] Hello
#        [Mat S.] Hello               ← no timestamp
#
#   2. Bold form (from imported/cleaned transcripts):
#        **Hiro Protagonist**: Hello
#        **Y.T.**: Hello
#        **Name** 12:34: Hello        ← optional timestamp before the colon
#
# Both capture groups are non-greedy so the optional timestamp can claim any
# trailing `\s+\d+:\d+`, leaving multi-word names intact in group 1.
BRACKET_SPEAKER_RE = re.compile(r"^\[(.+?)(?:\s+(\d+:\d+(?::\d+)?))?\]\s*(.*)$")
BOLD_SPEAKER_RE = re.compile(r"^\*\*(.+?)\*\*(?:\s+(\d+:\d+(?::\d+)?))?\s*:\s*(.*)$")
TRANSCRIPT_HEADER_RE = re.compile(r"^##\s*Transcript\s*$", re.MULTILINE | re.IGNORECASE)
NEXT_SECTION_RE = re.compile(r"^##\s+\S", re.MULTILINE)  # next top-level section after transcript


def parse_self_labels(arg: str) -> set[str]:
    return {label.strip().lower() for label in arg.split(",") if label.strip()}


def extract_transcript(content: str) -> str:
    """Return the text between `## Transcript` and the next top-level section.

    Without the end-bound, trailing sections like `## Action Items` or
    `## Decisions` get appended to the final speaker turn (via parse_turns'
    non-speaker-line continuation logic) and pollute talk-time/monologue
    metrics. Stop at the next `##` heading to keep the transcript clean.
    """
    start_match = TRANSCRIPT_HEADER_RE.search(content)
    if not start_match:
        return content
    body = content[start_match.end():]
    end_match = NEXT_SECTION_RE.search(body)
    if end_match:
        return body[: end_match.start()]
    return body


def parse_time_to_seconds(time_str: str | None) -> int | None:
    if not time_str:
        return None
    parts = time_str.split(":")
    try:
        if len(parts) == 2:
            return int(parts[0]) * 60 + int(parts[1])
        if len(parts) == 3:
            return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2])
    except ValueError:
        return None
    return None


def match_speaker_line(line: str):
    """Try each speaker marker format in turn. Returns the first match or None.

    Bracket form is checked first because it's more common in locally-recorded
    Minutes transcripts. Bold form handles imported/cleaned transcripts.
    """
    return BRACKET_SPEAKER_RE.match(line) or BOLD_SPEAKER_RE.match(line)


def parse_turns(transcript: str, self_labels: set[str]) -> list[dict]:
    turns: list[dict] = []
    current: dict | None = None
    for raw in transcript.splitlines():
        line = raw.strip()
        match = match_speaker_line(line)
        if match:
            if current is not None:
                turns.append(current)
            speaker = match.group(1).strip()
            current = {
                "speaker": speaker,
                "time": match.group(2),
                "text": match.group(3) or "",
                "is_self": speaker.lower() in self_labels,
            }
        elif current is not None and line:
            current["text"] += " " + line
    if current is not None:
        turns.append(current)
    return turns


def count_pattern_hits(text: str, patterns: tuple[str, ...]) -> int:
    text_lower = text.lower()
    total = 0
    for pattern in patterns:
        if " " in pattern or pattern.endswith("?"):
            total += text_lower.count(pattern)
        else:
            total += len(re.findall(rf"\b{re.escape(pattern)}\b", text_lower))
    return total


def estimate_seconds_from_words(word_count: int) -> int:
    # ~150 wpm conversational speech.
    return round(word_count / 150.0 * 60)


def compute_metrics(turns: list[dict]) -> dict:
    total_words = 0
    self_words = 0
    other_words = 0
    self_filler = 0
    self_hedging = 0
    self_questions = 0
    speakers: set[str] = set()

    # Stretch tracking for monologue detection: collapse consecutive same-side turns.
    stretches: list[dict] = []
    current_stretch: dict | None = None

    for turn in turns:
        speakers.add(turn["speaker"])
        words = turn["text"].split()
        wc = len(words)
        total_words += wc

        if turn["is_self"]:
            self_words += wc
            self_filler += count_pattern_hits(turn["text"], FILLERS)
            self_hedging += count_pattern_hits(turn["text"], HEDGES)
            self_questions += turn["text"].count("?")
        else:
            other_words += wc

        side = "self" if turn["is_self"] else "other"
        if current_stretch is None or current_stretch["side"] != side:
            if current_stretch is not None:
                stretches.append(current_stretch)
            current_stretch = {
                "side": side,
                "word_count": wc,
                "first_words": " ".join(words[:8]),
                "start_time": turn.get("time"),
            }
        else:
            current_stretch["word_count"] += wc
    if current_stretch is not None:
        stretches.append(current_stretch)

    self_stretches = [s for s in stretches if s["side"] == "self"]
    other_stretches = [s for s in stretches if s["side"] == "other"]
    longest_monologue = max(self_stretches, key=lambda s: s["word_count"], default=None)
    longest_listen = max(other_stretches, key=lambda s: s["word_count"], default=None)

    # Duration: use last timestamped turn if available, else estimate from words.
    last_seconds = None
    for turn in reversed(turns):
        secs = parse_time_to_seconds(turn.get("time"))
        if secs is not None:
            last_seconds = secs
            break
    duration_minutes = (last_seconds / 60.0) if last_seconds else (total_words / 150.0)
    duration_minutes = max(duration_minutes, 0.1)  # avoid div-by-zero

    talk_ratio = (self_words / total_words) if total_words > 0 else 0.0

    def per_100(count: int) -> float:
        return round(count * 100 / self_words, 2) if self_words > 0 else 0.0

    def stretch_summary(s: dict | None) -> dict | None:
        if not s:
            return None
        return {
            "word_count": s["word_count"],
            "seconds_estimate": estimate_seconds_from_words(s["word_count"]),
            "first_words": s["first_words"],
            "start_time": s["start_time"],
        }

    return {
        "total_words": total_words,
        "self_words": self_words,
        "other_words": other_words,
        "talk_ratio": round(talk_ratio, 3),
        "self_turn_count": sum(1 for t in turns if t["is_self"]),
        "other_turn_count": sum(1 for t in turns if not t["is_self"]),
        "speakers": sorted(speakers),
        "filler_count": self_filler,
        "filler_per_100_words": per_100(self_filler),
        "hedging_count": self_hedging,
        "hedging_per_100_words": per_100(self_hedging),
        "question_count": self_questions,
        "questions_per_5min": round(self_questions * 5 / duration_minutes, 2),
        "duration_minutes": round(duration_minutes, 1),
        "longest_monologue": stretch_summary(longest_monologue),
        "longest_listen": stretch_summary(longest_listen),
    }


def extract_outcome(content: str) -> str | None:
    """Return one supported frontmatter outcome without parsing arbitrary YAML."""
    lines = content.splitlines()
    if not lines or lines[0].strip() != "---":
        return None
    try:
        closing = next(index for index, line in enumerate(lines[1:], 1) if line.strip() == "---")
    except StopIteration:
        return None
    frontmatter = "\n".join(lines[1:closing])
    match = re.search(
        r"^outcome:\s*(won|lost|stalled|great|noise)\s*$",
        frontmatter,
        re.MULTILINE | re.IGNORECASE,
    )
    return match.group(1).lower() if match else None


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "meeting_file",
        type=Path,
        help="Path to a meeting markdown file, or - for native-authorized stdin",
    )
    parser.add_argument(
        "--self",
        required=True,
        dest="self_labels",
        help="Comma-separated speaker labels for the user (case-insensitive)",
    )
    args = parser.parse_args()

    stdin_mode = str(args.meeting_file) == "-"
    if not stdin_mode and not args.meeting_file.exists():
        print(json.dumps({"error": f"file not found: {args.meeting_file}"}), file=sys.stderr)
        return 1

    self_labels = parse_self_labels(args.self_labels)
    if not self_labels:
        print(json.dumps({"error": "--self must contain at least one label"}), file=sys.stderr)
        return 1

    content = (
        sys.stdin.read()
        if stdin_mode
        else args.meeting_file.read_text(encoding="utf-8", errors="strict")
    )
    transcript = extract_transcript(content)
    turns = parse_turns(transcript, self_labels)

    if not turns:
        print(
            json.dumps(
                {
                    "error": "no diarized speaker turns found",
                    "hint": "transcript may be a single block without [NAME 0:00] markers",
                }
            ),
            file=sys.stderr,
        )
        return 2

    self_matches = sum(1 for t in turns if t["is_self"])
    if self_matches == 0:
        print(
            json.dumps(
                {
                    "error": "no turns matched any self label",
                    "self_labels": sorted(self_labels),
                    "speakers_found": sorted({t["speaker"] for t in turns}),
                    "hint": "check that --self matches the speaker labels in the transcript",
                }
            ),
            file=sys.stderr,
        )
        return 3

    metrics = compute_metrics(turns)
    metrics["outcome"] = extract_outcome(content)
    print(json.dumps(metrics, indent=2))
    return 0


if __name__ == "__main__":
    sys.exit(main())
  • SKILL.md 13.6 KB 
    ---
name: minutes-mirror
description: Self-coaching analysis of your own behavior across meetings — talk-time ratio, filler words, hedging language, monologue length, energy patterns, and (when meetings are tagged via /minutes-tag) what your behavior in winning meetings looks like vs losing ones. Use this whenever the user says "how did I do", "review my last meeting", "mirror", "self-review", "show my patterns", "coach me", "where am I weak", "talk time", "am I improving", "what do I do in meetings I win", "feedback on me", or asks for any kind of personal feedback on their own meeting behavior. This is the rare skill that gives the user a mirror to their own habits — surface it whenever they show curiosity about their own performance, even if they don't use the word "mirror".
---

## Skill Path

Before running helper scripts or opening bundled references, set:

```bash
export MINUTES_SKILLS_ROOT="$(git rev-parse --show-toplevel)/.agents/skills/minutes"
export MINUTES_SKILL_ROOT="$MINUTES_SKILLS_ROOT/minutes-mirror"
```

# /minutes-mirror

Self-coaching analysis based on your own meeting transcripts. Two modes:

- **Single-meeting mode** — review a specific meeting and surface what you did, what was unusual for you, and one concrete thing to try next time.
- **Pattern mode** — surface trends across the last 30 days, including (if meetings are tagged) what behaviors correlate with winning vs losing.

The point is not to roast you. The point is to give you a kind, evidence-based mirror to behaviors that are usually invisible to you because you're inside them.

## How it works

### Phase 0: Identify "you"

Mirror needs to know which speaker label in the transcript is the user. Real transcripts use one of two formats:

- **Enrolled users**: `[Mat 0:00] Hey there.` — first-name labels from voice enrollment
- **Non-enrolled users**: `[SPEAKER_0 0:00] Hey there.` — generic labels from diarization

Either way, mirror needs to know which label maps to the user. Check sources in order:

**1. Enrolled voice profile:**
```bash
minutes voices --json 2>/dev/null
```

Returns a JSON array of enrolled profiles. The user's profile is the one with `source: "self-enrollment"` (or the first one if there's only one). Use the `name` field as the speaker label to look for in transcripts. Example response:

```json
[{"person_slug": "mat", "name": "Mat", "source": "self-enrollment", ...}]
```

→ Speaker label is `Mat`.

**2. Cached self name(s):**
```bash
cat ~/.minutes/config/self.txt 2>/dev/null
```

The cache may contain **multiple labels**, one per line (e.g., `Mat`, `Mat S.`, `MAT_SILVERSTEIN`) — match any of them. People often appear under multiple labels across transcripts.

**3. Ask once and cache:**
If neither source returns a name, ask via AskUserQuestion: "Which speaker label in your transcripts is you? You can give multiple if you appear under different names (e.g., 'Mat, Mat S., MAT_SILVERSTEIN')."

Cache the answer (comma-separated input → one label per line):
```bash
mkdir -p ~/.minutes/config
printf '%s\n' <label1> <label2> ... > ~/.minutes/config/self.txt
```

This is a one-time setup cost. Don't ask again on future runs. If the user later mentions they have a new label, they can re-edit the file or re-run with `mirror reset-self`.

### Phase 1: Pick a mode

**Single-meeting mode** triggers on: "review my last meeting", "how did I do", "mirror that call", "feedback on the Sarah call".

**Pattern mode** triggers on: "show my patterns", "trends", "across all meetings", "coach me", "what do my winning meetings look like".

If ambiguous, default to **single-meeting mode on the most recent meeting** — it's fast, useful, and obviously what most people mean.

### Phase 2a: Single-meeting analysis

Find the target meeting (filter to meetings, not voice memos — talk-time analysis on a solo memo is meaningless):
```bash
minutes list --content-type meeting --limit 5
```
Require exit status 0. If the user named a specific meeting, use bounded search
to identify its exact path; otherwise pick the most recent list result. Paths
are hints, not retained capabilities.

**Compute the metrics with the bundled helper script**, not by counting in-context. LLMs are bad at exact token counting; the script does it deterministically with regex and basic string ops.

```bash
set -o pipefail
minutes get "<exact path>" | \
python3 "$MINUTES_SKILL_ROOT/scripts/mirror_metrics.py" \
  - \
  --self "$(cat ~/.minutes/config/self.txt 2>/dev/null | paste -sd, -)"
```

Require both sides of the pipeline to exit successfully. The helper receives
only the exact native-authorized bytes over stdin; never pass it a meeting path.

The `--self` flag takes a comma-separated list of speaker labels (e.g., `Mat,Mat S.,SPEAKER_3`). Use the labels you cached in Phase 0.

The script outputs JSON to stdout with these fields:

| Field | Meaning |
|---|---|
| `total_words`, `self_words`, `other_words` | Word counts (split-on-whitespace) |
| `talk_ratio` | `self_words / total_words` as a 0–1 float |
| `self_turn_count`, `other_turn_count` | Number of speaker turns |
| `speakers` | All distinct speaker labels seen in the transcript |
| `filler_count`, `filler_per_100_words` | Filler-word hits in self speech (`um`, `uh`, `like`, `you know`, `basically`, `literally`, `kinda`, `right?`) |
| `hedging_count`, `hedging_per_100_words` | Hedging hits in self speech (`maybe`, `kind of`, `sort of`, `i think`, `i guess`, `possibly`, `somewhat`, `a little`, `perhaps`, `sorry to`). The word `just` is intentionally excluded — too many false positives. |
| `question_count`, `questions_per_5min` | Self questions (`?` count) |
| `duration_minutes` | From last timestamp if present, else word-count estimate at 150 wpm |
| `longest_monologue` | Longest uninterrupted self stretch: word count, seconds estimate, first 8 words, start time |
| `longest_listen` | Same shape, but for the longest stretch where you didn't speak |
| `outcome` | Supported frontmatter outcome (`won`, `lost`, `stalled`, `great`, `noise`), or null |

The script exits non-zero on errors (file missing, no diarized turns, no self labels matched). On exit code 3 ("no turns matched any self label"), it tells you which speaker labels it found in the transcript — re-run with one of those, or update `~/.minutes/config/self.txt`.

**Compute your baseline from the last ~10 bounded list results.** For each path,
repeat the native `minutes get` to stdin pipeline above and require both commands
to succeed. Never enumerate or open the meeting directory directly. Average the
metrics. If you have fewer than 5 successful meetings, say so explicitly —
"Baseline computed from only N meetings, treat with caution" — instead of
pretending the comparison is meaningful.

Once you have current-meeting metrics + baseline, flag anything >25% off baseline as worth noting.

**Output format:**

```markdown
## Mirror: <meeting title> · <date>

**Talk time**: You spoke <X>% of the time. (Your 30-day average: <Y>%.) <flag if abnormal>
**Longest monologue**: ~<N> seconds on "<topic>". <one-line judgment: was it earned (you were asked to explain something complex) or was it dominance?>
**Longest you listened**: ~<N> seconds during "<topic>". <one-line: what did they reveal?>
**Filler words**: <N> per 100 words. (Average: <Y>.)
**Hedging**: <N> per 100 words. (Average: <Y>.) <flag specific moments if you hedged on price, scope, or commitment>
**Questions asked**: <N>. <one-line: was this discovery, close, or update?>

### What stood out
<2–3 specific moments worth re-reading. Quote a short line from the transcript and say why it matters. Be specific — "You hedged the moment Sarah pushed on price ('I mean, I think we could maybe…')" beats "you hedged sometimes".>

### One thing to try next time
<Exactly one. Concrete. Achievable in the next call. Not a personality change — a behavior change. Falsifiable so the next mirror can verify it.>
```

### Phase 2b: Pattern mode

Run across the last 30 days (or whatever window the user gives you).

Run `minutes list --content-type meeting --limit 50`, require exit status 0,
and filter its JSON results to the requested window. Retrieve each selected
meeting only through the native `minutes get` to stdin pipeline above.

Compute the same per-meeting metrics across every successfully authorized normal
meeting in the window. Then look for patterns:

**Behavioral patterns** (always available):
- Trend in talk ratio over time (going up = dominating more, going down = listening more)
- Topics that correlate with high talk ratio (where do you steamroll?)
- Topics that correlate with high hedging (where do you lose authority?)
- Filler word rate by time-of-day (fatigue curve?)
- Day-of-week patterns (worse on Mondays?)
- Meeting length patterns (do your >45-min meetings degrade?)

**Outcome correlations** (only if meetings are tagged via `/minutes-tag`):

Standard outcome tags that mirror correlates: `won`, `lost`, `stalled`, `great`, `noise`. These mirror the set defined by `/minutes-tag` — if that skill ever adds new standard tags, update mirror to recognize them too. Custom (non-standard) tags are ignored for correlation analysis.

The helper includes a bounded `outcome` field (`won`, `lost`, `stalled`,
`great`, `noise`, or null) from the same authorized bytes. If every result is
null, skip the outcome-correlation section. Otherwise group only those returned
values and compare metrics across groups:

- "In meetings you tagged **won**, your average talk ratio was 38%. In **lost** meetings, 67%."
- "In **stalled** meetings, your hedging rate was 2× your baseline."
- "Every meeting you tagged **great** had ≥12 questions from you in the first 10 minutes."

**Minimum data thresholds:**
- **Behavioral patterns** need ≥5 meetings in the window to be meaningful. Below that, single-meeting mode is more honest.
- **Outcome correlations** need ≥3 meetings per tag group. Below that, it's noise.
- If thresholds aren't met, surface what you can compute and tell the user explicitly: "Tag more meetings via `/minutes-tag` and I can show you what wins look like."

**Output format:**

```markdown
## Mirror: 30-day patterns

**You've been in <N> meetings.** Here's what I see:

### Talk patterns
<2–3 bullets, specific>

### Where you hedge
<2–3 bullets with specific topics>

### Energy & timing
<observations about time-of-day, fatigue, day-of-week>

### Win/loss correlation
<only if ≥3 tagged meetings per outcome — otherwise skip this section entirely>

### One thing to try this week
<Exactly one. Concrete. Falsifiable.>
```

### Phase 3: Closing ritual

End with two beats:

1. **Specific experiment** — Restate the "one thing to try" as a concrete test. "Try cutting your hedging in your next 3 meetings. I'll measure it when you ask me to mirror again."

2. **Tag nudge** (only if no meetings have an `outcome:` field yet) — "After your next meeting, run `/minutes-tag won|lost|stalled` so I can correlate behavior with outcomes over time. ~10 tagged meetings is when the patterns get sharp."

## Gotchas

- **Long-transcript accuracy degrades.** LLMs are bad at exact token counting. For transcripts >5000 words, your filler-word and hedging counts are estimates, not measurements. Either say so in the output ("≈14 fillers, sampled from 3 segments") or sample three 1500-word segments (start, middle, end) and extrapolate. Don't pretend you exactly counted 8327 words.
- **This is coaching, not roasting.** Be specific, evidence-based, and kind. Quote actual lines from the transcript before making any judgment about tone or behavior. Never make claims you can't point to evidence for. The user is looking at themselves here — be the coach you'd want.
- **Speaker identification can fail.** If transcripts use generic labels like SPEAKER_0/SPEAKER_1 and the user hasn't enrolled their voice, the analysis can't know which speaker is them. Ask once per machine, cache forever in `~/.minutes/config/self.txt`.
- **Don't fake metrics.** If a transcript has no speaker diarization (one big block, no speaker labels), say so and offer pattern mode across other meetings instead. Don't compute talk-time on a transcript without speakers — the number will be wrong and the user will lose trust in everything else.
- **Word-count duration estimates are rough.** ~150 wpm is the convention. Use timestamps when present in the transcript; fall back to word count when not. Always say "≈" or "~" so the user knows it's an estimate.
- **Avoid corporate language.** Don't say "your engagement scores" or "talk-time KPI". Talk like a coach who actually cares: "you spoke 58% of the time" not "talk-time metric: 0.58".
- **Pattern mode needs at least 5 meetings.** Below that, single-meeting mode is more honest. Don't surface "trends" from 2 data points.
- **Outcome correlations need at least 3 per group.** Below that, it's noise. Tell the user the threshold and how to reach it.
- **Don't pathologize high talk time.** Sometimes talking 70% is correct — it's a presentation, you're delivering bad news, you're explaining something complex to a non-expert. Compare to baseline and note context. Don't treat any number as automatically bad.
- **The "one thing" must be testable.** "Be more confident" is useless. "Cut hedging words from your next 3 close calls" is testable. The user will either do it or not, and the next mirror should be able to verify.
- **Never compare across users.** Mirror is a mirror to **this** user, not a benchmark vs anyone else. Don't say "the average sales rep talks 45%". Compare the user only to themselves.
- **Hedging matters most around price, scope, and commitment.** A general filler-word count is interesting; flagging that the user hedged the moment Sarah pushed on price is useful. Surface where the hedging happened, not just how much.

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related

Claude Prompt
Tighten-my-prose editing prompt
Claude Skill
Adversarial code-review skill for Claude
Claude Workflow
Deep-research workflow (fan-out + verify)
Claude Skill
Conventional-commit writer for Claude