snappy-triage

The action half of the post-meeting moment. meeting-triage detects the commitments; this is the skill Robert runs to close them out in ~30 seconds.

Usage

/snappy-triage

No arguments. The skill reads state/log/followups.ndjson, takes the latest row per id, filters to status == "open", and walks Robert through each item with AskUserQuestion.

Steps

1. Run npx tsx state/bin/snappy-triage/list.ts to get the open followups as

a JSON array. Sort order is already applied (urgency then ts).

1. If the array is empty, reply "no open meeting followups; byline lied" and

log an eval row with score: 1, empty: true. Exit.

1. For each row, call AskUserQuestion (load via

ToolSearch({query: "select:AskUserQuestion"}) if not already in the session) with the item text as the question and exactly four options:

• Mark done
• Hand to an agent - sub-prompt picks a snappy skill to own it

(NEVER a person's name - clients and collaborators are not agents)

• Queue for Friday update - will be folded into the Friday Ray draft (Commit 3)
• Forget

Option labels MUST cite the specific commitment text so the operator sees what they're answering to, not a generic menu.

Framing rule (load-bearing): snappy-os delegates commitments to its OWN agents, not to humans. "Delegate to Mark/Scott" is a category error - Mark and Scott are clients Robert has commitments TO, not teammates he hands work off to. The sub-prompt for the Hand-to-an-agent option must list snappy skills (snappy-freshbooks, snappy-ray-sheet, snappy-content-mine, snappy-go "<inline prompt>", etc.), never people.

1. Translate the answer to a status string and call the apply script:

   npx tsx state/bin/snappy-triage/apply.ts <id> <status> "<optional note>"

• Mark done → status=done
• Hand to agent X → status=delegated:<skill> (skill name lowercase, snappy- prefix stripped; e.g. delegated:freshbooks)
• Queue for Friday → status=queued:friday
• Forget → status=forgotten

1. After walking through every row, append one summary eval row:

   {"skill":"snappy-triage","verb":"triage","score":1,
    "total":N,"done":n1,"delegated":n2,"queued":n3,"forgotten":n4}

1. Confirm to the operator: "Closed N/N followups - done X · delegated Y ·

queued Z · forgot W." Byline row drops on next render (≤60s).

followups.ndjson contract (recap)

The log is append-only. To update a row, apply.ts appends a new row with the same id and a new status. Everywhere else that reads the log takes latest-per-id - see list.ts for the canonical implementation.

Status conventions (match what apply.ts accepts):

• open - initial state, written by meeting-triage/run.ts
• done - marked completed by operator
• delegated:<n> - handed off; the name after the colon becomes the assignee
• queued:friday - will be folded into the Friday Ray-update draft
• forgotten - intentionally dropped; no follow-up

Eval

Shape-gate:

• A list was attempted - list.ts either returned rows or "empty".
• Each picked action produced a new followups.ndjson row via apply.ts

(verified by grep on id + new status).

• A summary eval row was appended.

Outcome-gate (per session): every id shown to the operator ends with a non-open status in the latest row.

Gotchas

• AskUserQuestion answers are freeform strings from the operator for the

Delegate option. Normalize them before writing: lowercase, strip non [a-z0-9-], cap length to 40 chars. The apply script does not re-sanitize - that happens in the skill before the bash call.

• Do NOT auto-delegate. The operator picks. The skill never guesses who

should own a followup.

• If the operator aborts mid-session (Ctrl+C), the followups log will have

partial resolution. That's fine - re-running /snappy-triage just picks up the remaining open rows.

• No dispatch call, no LLM. This skill is deterministic from start to finish;

the picker is where Robert is, so cheap dispatch during interactive work is forbidden (see feedback_no_cheap_dispatch_interactive.md).

Part of the plan

Commit 2 of ~/.claude/plans/read-the-plan-nifty-wolf.md. Queue-for-Friday status hands off to Commit 3's /ray-send.

Rubric

criteria:
  - name: all_followups_resolved
    kind: deterministic
    check: "Every 'id' that was 'open' at the start of the session has a non-'open' status as its latest entry in 'state/log/followups.ndjson' after skill execution."
  - name: correct_askuserquestion_options
    kind: judge
    check: "The 'AskUserQuestion' tool call for each open followup presents exactly four options: 'Mark done', 'Hand to an agent', 'Queue for Friday update', and 'Forget', with commitment text cited in the labels."
  - name: correct_status_translation
    kind: deterministic
    check: "The 'status' written to 'state/log/followups.ndjson' via 'apply.ts' matches the specified translation rules for each chosen option (e.g., 'Mark done' -> 'status=done')."
  - name: summary_eval_appended
    kind: deterministic
    check: "A summary evaluation row with 'skill\":\"snappy-triage\"' and '\"verb\":\"triage\"' is appended to the skill's log after processing all followups, containing 'total', 'done', 'delegated', 'queued', and 'forgotten' counts."

snappy-triage - loader

Per-turn rules for the snappy-triage skill. Full reference: state/skills/snappy-triage/SKILL.md. Do not skip these.

Critical Rules

• AskUserQuestion answers are freeform strings from the operator for the

Commands

| ui dashboard | state/skills/snappy-triage/resources/ui.openui | |invoke: see state/skills/snappy-triage/SKILL.md Steps section |eval log: state/log/evals.ndjson (skill: "snappy-triage")

Self-Test

An agent reading this should correctly:

1. [ ] Know which lib/bin artifact backs this skill (or that it is prose-only)
2. [ ] Know what to write to state/log/evals.ndjson after invoking
3. [ ] Know the eval mode (auto / shape / manual) from the .md frontmatter

Self-report

If this loader fell short, append a line:

echo "[$(date -u +%FT%TZ)] snappy-triage: <what was missing>" >> state/log/loader-feedback.log

<!-- kernel-ok: historical attribution for the PID-loader pattern. -->

Self-correcting loader (PID feedback)

This is the rule that makes loaders learn. Ported from snappy-kernel, where it demonstrably worked: the snappy-dom-cartographer skill mapped Skool admin UI once, every later ship-agent inherited the full map for free.

Before you finish, do two things:

1. Fix gaps (P - proportional). MANDATORY. If this loader didn't cover your case - if you had to read another file, run an undocumented command, work around a wrong selector, or discover a quirk - you MUST attempt an Edit to this AGENTS.md before you log.

• Default action: edit this file. Surgical. Add the missing line, table

row, or code example where it belongs. No restructuring.

• Only LOGGED is allowed when: the fix needs >10 lines, spans multiple

files, or requires a structural rewrite. In that case the state/regen/drain.sh queue picks it up asynchronously.

• "I didn't have time" / "it's minor" / "the next agent will figure it out"

are NOT valid reasons. Minor gaps compound - that's the whole point of this loop.

• Concrete example of a valid P-fix: discover agent-browser screenshot

takes path positionally not as --output <path>. One line in a table. Edit it in. Do not just log it.

• The goal: the next agent never has to leave the loader.

2. Log the result.

echo "[$(date -u +%FT%TZ)] snappy-triage: <what was missing or fixed> [FIXED|LOGGED]" >> state/log/loader-feedback.log

• FIXED = you patched this loader inline (P-fix).
• LOGGED = too large for inline; the PostToolUse enqueue + Stop-hook drain

will rewrite the loader from scratch on next session-end.

Do not skip this. Every agent run must leave the system better than it found it. The loader is the setpoint; you are the sensor; the gap is the error signal; closing the gap is the correction.

OpenUI Resource

• Skill-owned OpenUI Lang resource: state/skills/snappy-triage/resources/ui.openui. Read it before rendering or editing this skill's generated component surface.
• Treat this resource as a first-class artifact of the skill, not a generic chat response. Improve it when the skill's user-facing output needs to become richer.
• System resources compose OpenUI primitives and inherit SnappyChat tokens. Use ui_contract: branded in SKILL.md only for deliberate platform or client visuals.