/note

description: Add a note to the active task - progress, decisions, context. --session (aliases --snapshot, --pre-compact, --compact) writes a resume-grade session snapshot without ending the session. --team writes a fact or a decision into the standing team's file.
argument-hint: "[free text|--session|--team [text]]"

Task Note

Add a note to the active task. For mid-work documentation - progress updates, research findings, decisions, context for future sessions.

**This is a utility, not a flow step.** Main flow handles documentation automatically:

• `/lets:commit` records commits to the task
• `/lets:done` documents task completion
• `/lets:end` saves session progress

Use `/lets:note` when you want to add extra context that doesn't fit those flows.

> **IMPORTANT:** If the spec below invokes any deferred tool (e.g. `AskUserQuestion`), you MUST load and call it as specified. Never skip the call, never substitute a default answer of your own — the tool invocation is part of the contract. This is critical.

Usage

/lets:note                  # interactive - pick a note type, add to the active task
/lets:note <free text>      # use the text directly as the note (infer type)
/lets:note --session        # RESUME snapshot of the whole session (aliases: --snapshot, --pre-compact, --compact)
/lets:note --team [text]    # team worktree: a decision -> the team file's Decisions, a fact -> its Standing knowledge

Step 0: Argument Parsing

**If `--session` (aliases `--snapshot`, `--pre-compact`, `--compact`) is passed** -> run **Session Snapshot Mode** (below) INSTEAD of Steps 3-4: no type prompt, produce ONE recovery-grade snapshot. Do NOT run Step 1's interactive task prompt - the `session-snapshot` skill owns task detection (file-primary: ambiguity -> file only, no prompt), keeping this byte-identical to `/lets:end --session`. Then show the output below, NOT the generic Output box (no separate verify - the skill returns the path + task id, and `/lets:end` likewise just delegates and stops).

**If `--team` is passed** -> run **Team Note Mode** (below) INSTEAD of Steps 1-6: no task is needed and none is prompted for, no tracker verb runs. Then show its output, NOT the generic Output box.

**Otherwise** -> normal flow (Steps 1-6).

When to Use

• Research findings: "Investigated X, found Y"
• Design decisions: "Chose approach A because..."
• Blocker discovered: "Can't proceed until Z"
• Context dump: "Important info for next session"

Step 1: Active Task Detection

Use the **detect-task** skill to find the active task: `Skill(skill: "lets:detect-task")`. If no active task or multiple tasks found - ask user which task to add a note to.

Step 2: Review Current State

**Tracker protocol:** `Skill(skill: "lets:protocol-tracker")` before this and any later `lets-tracker` block here, unless its text is in your current context.

show task=<task-id>          # returns {id,title,status,url,description}
comment-list task=<task-id>

Read the full description and all comments. Check existing comments to avoid duplicating info.

Step 3: Ask What to Note

If not obvious from conversation context, use **AskUserQuestion**:

AskUserQuestion(
  questions=[{
    question: "What kind of note?",
    header: "Note type",
    options: [
      { label: "Progress", description: "What's done and what remains" },
      { label: "Decision", description: "Record a choice and reasoning" },
      { label: "Research", description: "Findings and recommendations" },
      { label: "Blocker", description: "What's blocking and possible solutions" }
    ],
    multiSelect: false
  }]
)

**Other** (free text) -> use as note content directly, infer type.

Step 4: Add Note

The orchestrator composes the note body into a temp file, then submits it via `body-file=` (`lets:protocol-tracker` "Bodies"):

LETS_PROJECT_ROOT=$(git rev-parse --show-toplevel); mkdir -p "$LETS_PROJECT_ROOT/.lets/cache"
cat > "$LETS_PROJECT_ROOT/.lets/cache/note-<task-id>.md" <<EOF
## {Note type} $(date +%Y-%m-%d)

{content based on type}
EOF

comment-add task=<task-id> body-file=.lets/cache/note-<task-id>.md

Note Templates

**Progress:**

## Progress {date}

### Done
- {what was completed}

### Remaining
- {what's left to do}

**Decision:**

## Decision {date}

**Chose:** {option}
**Over:** {alternatives}
**Because:** {reasoning}

**Research:**

## Research {date}

### Findings
- {key discoveries}

### Recommendation
- {suggested approach}

**Blocker:**

## Blocker {date}

**Issue:** {what's blocking}
**Impact:** {what can't proceed}
**Options:** {possible solutions}

Step 5: Record Scope Change (if needed)

If the task scope or understanding changed significantly, record it as a comment (never overwrite the description):

comment-add task=<task-id> body="[scope-change] <what changed and why>"

Step 6: Verify

show task=<task-id>

Team Note Mode (`--team`)

The manual twin of `/lets:done`'s promote step for a standing team's notebook: a fact or a decision that comes up mid-task goes into the team file now, so a later task of the team reads it, and the promote step at task close skips it.

1. **Team worktree only.** Run `lets worktree info --json`. No top-level `team` -> one line `Not a team worktree - --team writes nothing; /lets:note adds it to the task.` and stop. The file is `.lets/teams/<team>.md`. The lead is its only writer; a member proposes an entry in a `FOR lead` block instead. 2. **What.** The text after `--team`; none -> the latest decision or fact in this conversation; nothing clear -> ask in words what the note should say, and wait. 3. **Where.** A decision (who chose what, over what) -> `## 8. Decisions`, as `- {YYYY-MM-DD} {who decided}: {what} - {why}`. A fact that outlives the task -> `## 9. Standing knowledge`, as `- {YYYY-MM-DD} ({task-i