Meeting capture — record mic + system audio, take timestamped notes, transcribe locally, distill into vault-connected notes.

version
0.1.2
GitHub stars
57

Install

/plugin install aside@margins

Run it inside Claude Code after adding the marketplace with /plugin marketplace add jshph/aside.

Contents

Discovered from source

Skills 2

Margins — Connected Note

Start with the latest Margins session unless the user selects another session or supplies evidence directly. Turn that evidence into a useful note, consult existing Workspace notes when they can improve it, and save the approved result in the Workspace Home destination. A pinned BB @Meeting is an explicit selection; use the BB tools described below for that session. The job is complete when the user approves the draft and the note is saved.

Inputs and output

latest is the normal starting point. A stable session id selects a different Margins session. A transcript or memo path, text supplied in the conversation, or an audio file is an explicit override when the user wants to work from something else. Audio is available when the capability report in step 1 lists audio under distillation.inputs.

The output is a reviewed Markdown note in the Workspace Home Source, under its reviewed note_folder when one is configured. Machine state and imported-audio artifacts stay under the Workspace state_dir; never create .margins inside a notes Source.

BB @Meeting handoff

When a BB message carries <margins-context-v1>, use its exact workspaceId, sessionId, and memoRevision. The meeting mention pins that session; do not resolve latest or query a local CLI, which may point at another store. Read context, memo, and transcript with margins_bb_meeting_read, continuing from nextOffset until each part is complete. Use the returned Home Source and destination for the note. If the transcript is pending, wait for the server's transcript. A memo-only checkpoint has no usable spoken timeline. Use a full transcript only when it is terminal; do not write a final note from an active live meeting.

After saving an approved note under the returned Home Source, call margins_bb_note_link with the same pinned IDs and memo revision, the returned homeSourceId, the path relative to homeRoot, and the association's current revision (or 0 when absent). This records the reference, not the note body. If the user requested a draft in chat only, do not link a file. Follow the BB connected-note skill when it is available for the full host procedure. For this BB route, use the pinned tool evidence and ordinary Home Source files for context; skip the local CLI resolution, transcript, recall, and destination commands below.

1. Find Margins and check the Workspace

Resolve whichever Margins command is available, then use that command throughout the workflow:

MARGINS_CLI="${MARGINS_CLI_BIN:-$(command -v margins || command -v margins-public)}"
"$MARGINS_CLI" capabilities
"$MARGINS_CLI" workspace status --json
"$MARGINS_CLI" sync --json

If no command is available, stop and ask the user to install Margins. A supplied MARGINS_CLI_BIN is the absolute executable for this workflow; keep using it. Read the Workspace id, home, and state_dir from status. If no Workspace is ready, follow "$MARGINS_CLI" guide workspace-setup, then return here after a recall query succeeds. If sync reports an unavailable Source, tell the user which Source failed and continue only when the remaining evidence is enough to ground the note. Do not modify Margins state directly.

2. Resolve the session evidence

Resolve latest directly; do not list every session first. Replace latest with a stable session id only when the user selects another session:

"$MARGINS_CLI" --workspace "<workspace-id>" transcript latest --format json

Use the returned body as the factual record. Read memo_path when it is present; the memo records what the user noticed or cared about. Preserve speaker names, timestamps, decisions, risks, and action items. If saved_note_path already names a note, show it to the user before replacing or duplicating it.

For a TUI session started with margins new, the memo contains timestamped lines captured while the user listened. Preserve the raw memo, including later untimed reflections; do not rewrite it as a finished note. Capture may still be finishing transcription after the TUI closes. For view="pending", wait for the server transcript. Use a view="full" body only when terminal="true"; a terminal *.live-transcript.json checkpoint is usable without re-running ASR. For other non-live results with incomplete="true" or terminal="false", run process once, then read the transcript again. If it remains incomplete, disclose the gap and do not present its partial body as complete. Do not process an active live meeting for a final note. Memo-only bodies without spoken timeline lines are not usable transcripts. If speaker labels are generic, ask for identities before attributing claims to named people.

If the transcript command has no usable body, ask Margins which files belong to the same session. Use the same latest or stable session id as above:

"$MARGINS_CLI" --workspace "<workspace-id>" artifacts latest

Run recent only when the user needs to browse or disambiguate sessions:

"$MARGINS_CLI" --workspace "<workspace-id>" recent

Use these commands rather than searching hidden Margins files for artifacts. If a registered recording has no usable transcript after capture finishes and capabilities reports audio processing, run "$MARGINS_CLI" --workspace "<workspace-id>" process "<session-id>" once, then read the transcript again. Use --align-only only when the user asks to rebuild alignment from an existing transcript. If no session exists and the user has not supplied other evidence, ask for a transcript, memo, text, or supported audio file.

Explicitly supplied evidence

For a transcript or memo path, read the file directly. If both are present, the transcript remains the primary factual record and the memo is the user's attention signal. Text supplied in the conversation can be used directly.

For audio, first confirm that distillation.inputs includes audio. Keep generated artifacts in Workspace state by using the explicit Workspace id:

"$MARGINS_CLI" --workspace "<workspace-id>" transcribe \
  "/absolute/path/to/audio" --name "<stable-name>" \
  [--memo "/absolute/path/to/memo.md"] [--speakers N]

Use the returned meeting id instead of latest in the transcript command above so imported audio follows the same evidence path without selecting a different session. If audio is not a reported input, ask for a transcript instead.

3. Retrieve useful prior context

Form focused queries from consequential, distinctive language in the input. Usually one to four searches are enough:

"$MARGINS_CLI" --workspace "<workspace-id>" recall --json "<specific query>"

recall returns matching excerpts with their note paths. Read the best three to five referenced notes when they could change the draft. Treat those matches as supporting evidence; the transcript or memo remains the primary factual record.

Use prior notes to confirm vocabulary, tags, people, and wikilinks. Do not invent a wikilink target or copy unrelated recall results into the note.

4. Draft the note

Read distillation-core.md next to this skill and apply its evidence priority, attribution, action-item, provenance, and writing rules. Choose the closest file from the adjacent templates/ directory; adapt its headings when the evidence requires it. The CLI installs both alongside this SKILL.md.

Produce a complete Markdown draft. Keep factual claims grounded in the input, separate settled decisions from open questions, and include only connections supported by recall evidence.

5. Review and write

Show the draft and ask for approval or changes. Once approved, read "$MARGINS_CLI" --workspace "<workspace-id>" workspace destination --json. Write under its destination, which is the Home Source plus any reviewed note_folder. Use existing naming conventions there. If none is evident, use a timestamp plus a specific 3–7 word title. If saved_note_path already names a note, read it first and preserve the user's edits; revise the reviewed note there rather than creating a duplicate.

Never write the finished note under state_dir, captures, or .margins. Report the saved path, the input evidence used, and the prior notes that materially informed the result.

Watermark — Live Meeting Feedback

Answer a time-sensitive question about the conversation currently being captured by Margins. Treat $ARGUMENTS as a natural-language prompt, not as command-line flags. The user may ask a direct question, offer a tentative interpretation, ask for words to say, or simply request the newest read.

This is a live feedback loop, not meeting distillation. Optimize for a fresh, speakable intervention while the conversation is still unfolding.

Runtime recommendation

Prefer a low-latency model with low reasoning effort and a small output budget for live invocations. Preserve the same behavioral contract when the host does not expose model or reasoning controls. Escalate to a stronger or slower model only when the prompt is unusually ambiguous or consequential; use the normal Margins distillation workflow for comprehensive post-meeting synthesis.

This is an execution preference, not a model requirement. Keeping the skill model-agnostic lets the command work across supported agent runtimes and avoids coupling its behavior to a model name that may change.

Core contract

  1. Fetch the current session and transcript immediately.
  2. Use the complete transcript view returned by the CLI, weighting the newest complete turn most heavily.
  3. Infer what kind of help the prompt calls for.
  4. Answer the question directly, grounded in the newest complete turn.
  5. Keep the first useful response short enough to use in the room.

Aim to return useful guidance within 15 seconds. Do not run recall, search the vault, inspect old notes, or delegate work before the first answer. Use the full transcript view returned by the single CLI call; do not perform a separate, slower reconstruction pass. Those extra operations improve retrospective synthesis but make live feedback arrive a turn late.

Fetch the freshest transcript

Run:

margins transcript --format json

The command resolves the active/recent session when no meeting id is supplied. Parse its JSON fields:

  • decoded_until_ms: the transcript watermark
  • live: whether capture is active
  • terminal: whether the transcript is final
  • body: the preferred transcript view
  • meeting_id: stable session identifier

If default resolution is ambiguous, run margins recent, choose the active or newest live session, then run:

margins transcript "<meeting-id>" --format json

Do not use --follow: the command should take one fresh snapshot and return. The user can invoke the skill again for the next watermark and transcript.

Run this command anew on every invocation. Transcription and transcript loading are cheap enough that the CLI should own freshness and reconstruction; do not maintain a hand-trimmed transcript window or treat the previous watermark as a read boundary. The returned body is the context for the answer, while the newest complete turn carries the most weight for what is timely now.

If the transcript is still live, reason from the newest complete turn and say briefly when the final words appear partial. If no live transcript is available, report that plainly and give the watermark or terminal state that is available.

Infer the feedback intent

Infer intent from both $ARGUMENTS and the latest conversation. These are reasoning lenses, not user-facing modes and not mutually exclusive:

  • Read — What is the other person seeking, reacting to, or opening up now?
  • Sanity check — Is the user's tentative interpretation supported by the latest exchange? Preserve useful nuance rather than returning a bare yes/no.
  • Steer — Should the user redirect, narrow, challenge, affirm, or let the thread continue?
  • Structure — What compact framework would organize the discussion now?
  • Tactical — What decision, scope boundary, question, owner, or next step should be surfaced before the moment passes?
  • Speakable wording — What sentence can the user say next?
  • Debrief — Only when the capture is terminal or the user explicitly asks how the meeting went; this may be somewhat broader, but remains distinct from full Margins distillation.

A prompt can imply several lenses. For example, a concern that the conversation is drifting may need a sanity check, a tactical scope judgment, and one sentence that redirects without shutting down the useful thread. Do not ask the user to choose a mode when their prompt and the transcript make the need legible.

Use prior interaction as coaching memory

Within the same agent conversation, retain:

  • the user's stated goal for the meeting;
  • decisions and frames already landed;
  • advice already given and whether the transcript shows it landed;
  • unresolved loops and promised follow-ups;
  • the previous decoded_until_ms.

On later invocations, call margins transcript --format json again and use the complete view it returns. The previous watermark helps explain what changed since the last request, but it does not constrain transcript retrieval or analysis. This keeps the answer grounded when a recent turn depends on an older decision, definition, or conversational thread.

Update an interpretation when new evidence warrants it. Do not preserve an old coaching frame merely for consistency.

Response shape

Lead with the outcome, not process narration. Normally use:

**Watermark:** ~MM:SS — one sentence on what changed.

Direct answer to the user's question in 1–3 sentences.

**Say:** “One concise sentence the user could actually say next.”

**Watch:** One risk, opening, or decision that may otherwise pass.

Adapt rather than mechanically filling every field:

  • Omit Say when the user asked only for a factual read.
  • Omit Watch when there is no meaningful secondary point.
  • For a requested structure, a small list or table can replace Say.
  • For a terminal debrief, use Landed, Tighten, and Carry forward if useful.

Keep the initial live answer around 80–180 words. A structure may run to roughly 250 words when the user explicitly needs something to walk through. Give one primary move rather than a menu of equally weighted possibilities.

Judgment principles

  • Distinguish what is timely from what is merely interesting. A divergent thread can be valuable and still be wrong for the present scope.
  • Answer the user's actual uncertainty. If they ask whether to steer away, make the call and explain the governing constraint.
  • Prefer a reusable rule plus one application over a long bespoke analysis.
  • Preserve the other person's agency. A good intervention can narrow scope without dismissing what they are exploring.
  • Convert vision into a decision, experiment, owner, or parked thread when the moment calls for tactical closure.
  • Label uncertainty caused by partial transcription, unclear speakers, or a stale watermark. Do not manufacture confidence from noisy live text.
  • Do not expose private reasoning or summarize unrelated parts of the meeting.

Pseudonymized examples

Tentative interpretation

Input:

/watermark the external-events idea feels hard to automate because quality is
the bottleneck—is that right? get the latest watermark and sanity-check me

Good behavior: inspect the latest turn, decide whether the interpretation is supported, distinguish signal detection from response quality if relevant, and offer one timely sentence. Do not launch a general research pass on automation.

Request for a structure

Input:

/watermark I think they want a high-level structure to walk through now—what
would organize this without dragging us into implementation?

Good behavior: infer the structure lens and return one compact framework tied to the themes now on the floor. Do not ask the user to rerun with a structure flag.

Scope and quantitative design

Input:

/watermark they are moving into quantitative design. should I steer away because
the cells may be too small, or surface something specific for scope?

Good behavior: make the steer-versus-surface judgment, identify the governing quantity constraint, and give one speakable intervention. Avoid solving the entire experiment design during the live response.

Tactical close

Input:

/watermark newest one—what tactical things should I make sure we land?

Good behavior: identify the few decisions, owners, or open loops most at risk of being lost before the meeting ends. Rank them; do not recap the full meeting.

Post-meeting reflection

Input:

/watermark we just finished. how did I do? I think the last section wandered and
wasn't useful for today's scope, though it may matter elsewhere

Good behavior: confirm the terminal watermark, assess what landed and what did not, distinguish divergence from waste, and recommend where to preserve any valuable off-scope insight. Keep full note creation in the separate Margins distillation workflow.

Sponsors

Details

Marketplace
jshph/aside
Category
Community

More from jshph/aside

All 2