brainclaw 0.29.2 → 1.5.3

package/docs/quickstart.md

@@ -1,87 +1,174 @@
 # Quickstart
 
-## The fastest way to start
+Get brainclaw running in your project in under 5 minutes.
 
-Ask your coding agent:
+> **Joining a project that already has `.brainclaw/`?** Use [quickstart-existing-project.md](quickstart-existing-project.md) instead — this page is for setting up a new project from scratch.
 
-> "Install brainclaw and initialize it in this project."
+If you're about to cut a release that changes the CLI, MCP, or context surface, run the checklist in [release-maintenance.md](release-maintenance.md) before publishing a local pack or npm build.
 
-The agent will run `brainclaw setup` and `brainclaw init`, detect your environment, write the right config files, and activate MCP. After reloading, brainclaw tools become available.
-
-If you prefer doing it manually:
+## Step 1: Install
 
 ```bash
 npm install -g brainclaw
+```
+
+Requires Node.js 20+. Verify with `brainclaw --version`.
+
+## Step 2: Initialize your project
+
+```bash
+cd your-project
 brainclaw init
 ```
 
-`init` creates the user store if needed (no separate `setup` step required), initializes the project, detects your agent, and writes all integration files.
+**What happens:**
+- Creates `.brainclaw/` directory (project memory store)
+- Detects your coding agent (Claude Code, Codex, Cursor, Copilot, Cline, Mistral Vibe, etc.)
+- Writes MCP configuration for the detected agent
+- Writes instruction files (`CLAUDE.md`, `AGENTS.md`, `.cursor/rules/brainclaw.md`, etc.)
+- Installs session hooks (if supported by your agent)
+- Adds `.brainclaw/` to `.gitignore`
 
-## What happens after init
+If you have multiple repos, use `brainclaw setup --yes` instead — it scans your project directories and initializes everything at once.
 
-Once initialized, your agent can:
+## Step 3: Restart your agent
 
-1. **See project context** — constraints, decisions, traps, plans, handoffs
-2. **Coordinate with other agents** — claim files before editing, check who's working where
-3. **Build shared memory** — record observations, create plans, track work
-4. **Resume across sessions** — the next agent (or the same one tomorrow) picks up where you left off
+Your coding agent needs to reload to pick up the new MCP configuration.
 
-## For agents with MCP (most agents)
+| Agent | How to reload |
+|-------|---------------|
+| **Claude Code** | Restart the CLI session or VS Code window |
+| **Cursor** | Cmd/Ctrl+Shift+P → "Reload Window" |
+| **Codex** | Start a new `codex` session |
+| **Cline** | Reload VS Code window |
+| **Windsurf** | Reload the editor |
+| **Copilot** | Reload VS Code window (uses instruction file, not MCP) |
 
-This is the primary path. The agent calls brainclaw tools directly.
+## Step 4: Verify it works
+
+After reloading, tell your agent:
 
 ```text
-bclaw_session_start   → identify yourself, see the board
-bclaw_get_context     → load relevant memory for your target scope
-bclaw_claim           → signal what you're about to edit
-bclaw_write_note      → record observations during work
-bclaw_session_end     → clean up claims and update plans
+Call bclaw_work with intent "resume" to check that brainclaw is connected.
+```
+
+The agent should respond with session info, project context, and available tools. If it does, brainclaw is connected.
+
+From the CLI, you can also verify:
+
+```bash
+brainclaw status          # active sessions, claims, plans
+brainclaw agent-board     # what each agent sees
+brainclaw context         # current project memory
 ```
 
-Instruction files like `CLAUDE.md` or `.cursor/rules/brainclaw.md` provide the protocol and constraints. The live state (plans, claims, traps) comes through MCP.
+## Step 5: Start using brainclaw
+
+### For agents with MCP (most agents)
+
+This is the primary path. Your agent calls brainclaw tools directly during work:
 
-## For agents without MCP (Copilot)
+| Tool | What it does |
+|------|-------------|
+| `bclaw_work(intent)` | Start a session, load context, claim scope — all in one call |
+| `bclaw_coordinate(intent, agents)` | Assign work, consult, request review, open an ideation loop, reroute, or summarize |
+| `bclaw_context(kind, path?)` | Read memory / execution / board / delta — narrow to a path when given |
+| `bclaw_claim(scope)` | Claim a file/directory before editing (prevents conflicts) |
+| `bclaw_write_note(text)` | Record an observation, decision, or trap during work |
+| `bclaw_session_end(narrative)` | Close session, release claims, hand off cleanly |
 
-The instruction file (`.github/copilot-instructions.md`) contains everything: constraints, active plans, traps, and decisions. Use the brainclaw-context skill to refresh.
+The facades `bclaw_work` and `bclaw_coordinate` are the recommended entry points — they handle session setup, context loading, and claim management automatically. For entity reads and writes (plans, decisions, traps, handoffs, candidates, etc.), use the canonical grammar: `bclaw_find` / `bclaw_get` / `bclaw_create` / `bclaw_update` / `bclaw_remove` / `bclaw_transition`.
 
-Regenerate the instruction file when project memory changes:
+### For autonomous agents (no MCP)
+
+Autonomous agents (OpenClaw, NanoClaw, NemoClaw, PicoClaw, ZeroClaw) operate from a SKILL.md file generated by brainclaw. For Tier B/C agents that have MCP but no hooks (Cursor, Cline, Windsurf, Copilot, Continue, Kilocode, Mistral Vibe, etc.), an opt-in `.live.md` companion (regenerated on session-end and handoff) carries plans, claims, traps, candidates, and handoffs as a parity backstop.
+
+Regenerate when project memory changes:
 
 ```bash
 brainclaw export --detect --write
 ```
 
+### Human operators (CLI)
+
+The CLI is for inspection, scripting, and fallback:
+
+```bash
+brainclaw plan create "Implement auth module" --priority high
+brainclaw plan list
+brainclaw claim list
+brainclaw context --for src/auth/routes.ts
+brainclaw export --detect --write    # regenerate all instruction files
+```
+
 ## Onboarding an existing project
 
 If the repo already has code, brainclaw can extract context from it:
 
 ```bash
-brainclaw bootstrap --json        # see what brainclaw detected
-brainclaw bootstrap --apply       # import into memory
+brainclaw bootstrap --json     # preview: CI patterns, ADRs, Docker, branches, tags
+brainclaw bootstrap --apply    # import detected signals into memory
 ```
 
-Or let your agent drive the conversation — it can call `bclaw_bootstrap`, review the detected signals, ask you about gaps, and structure the results into brainclaw memory.
+Or let your agent drive it:
 
-## Desktop AI surfaces
+```text
+Call bclaw_bootstrap to detect project signals, then review what was found.
+```
 
-brainclaw can also track work for desktop AI tools on your machine (ChatGPT Desktop, Claude Desktop, Gemini CLI) as a project-scoped task queue:
+## Common scenarios
 
-```bash
-brainclaw surface-task create "Generate hero visual" --target chatgpt --kind visual_asset
-brainclaw surface-task list
+The same primitives serve multiple workflows. Pick the one that matches what you're doing — full walkthroughs in [`concepts/multi-agent-workflows.md`](concepts/multi-agent-workflows.md).
+
+### Active orchestration — parallel lanes across agent instances
+
+```text
+brainclaw sequence create "feature-cycle" --items '[…]' --status active
+bclaw_dispatch(intent="execute", agents=[…])
+```
+
+The dispatcher creates one worktree + claim per lane and routes inbox messages by `claim_id`. Lanes with `hard_after` unblock as predecessors finish.
+
+### Agent switching — when an agent runs out of credits mid-task
+
+```text
+# On the outgoing agent:
+bclaw_session_end(narrative="Did X. Need to finish Y.")
+
+# On the next agent (same or different):
+bclaw_work(intent="resume")
 ```
 
-This keeps non-code work visible to the project without overloading the active coding agent.
+The new agent picks up the open plans, the latest handoff narrative, and the unfinished claims it can adopt. No re-explanation needed.
+
+### Project recovery — returning after weeks away
+
+```text
+bclaw_work(intent="resume")
+```
+
+Returns active plans, decisions taken since you left, active constraints, known traps, and where the last session stopped. Use `bclaw_context(kind="memory", profile="briefing")` for a narrower scope-focused view.
+
+### Team async — humans and agents sharing the same project
+
+Capture decisions, constraints, and traps as you discover them — they propagate to every teammate's agent on the next context read:
+
+```text
+bclaw_create(entity="decision",   data={ text: "…", outcome: "approved" })
+bclaw_create(entity="constraint", data={ text: "…", category: "security" })
+bclaw_create(entity="trap",       data={ text: "…", severity: "high" })
+```
 
-## Important: one agent at a time
+Hand off work for review with `bclaw_coordinate(intent="review", scope="…")`. Reviewers pick it up via `bclaw_read_inbox()`.
 
-brainclaw serializes all store mutations (file lock + MCP single-writer queue), so writes are safe. But running multiple agents in parallel on the same checkout can still cause Git conflicts and confusing state transitions.
+### One rule across all four
 
-Use brainclaw for sequential collaboration: one agent works, finishes, and the next one picks up from shared context. Use `bclaw_session_end` to hand off cleanly.
+Scope-level claim isolation is strict — only one active claim per scope at a time, regardless of agent type. That's how parallel work stays safe and async handoffs stay clean.
 
 ## Next reads
 
 - [integrations/overview.md](integrations/overview.md) — how brainclaw adapts to each agent
-- [integrations/mcp.md](integrations/mcp.md) — the dynamic runtime path
+- [integrations/mcp.md](integrations/mcp.md) — the MCP runtime path in detail
 - [concepts/memory.md](concepts/memory.md) — what project memory includes
 - [concepts/plans-and-claims.md](concepts/plans-and-claims.md) — coordination layer
 - [cli.md](cli.md) — full CLI reference

package/docs/release-maintenance.md

@@ -0,0 +1,79 @@
+# Release Maintenance
+
+Use this guide when a Brainclaw release changes the shipped CLI, MCP surface, context schema, or other operator-facing behavior.
+
+The goal is simple: if the product surface changed, the packaged docs and the anti-drift checks must change in the same branch before publishing.
+
+## When to run this checklist
+
+Run it before:
+
+- `brainclaw version --publish-local`
+- a merge that changes operator-visible behavior
+- a release candidate or local tarball build used for real agent testing
+
+Run it whenever a change affects one of these surfaces:
+
+- CLI commands, aliases, flags, help text, or examples
+- MCP tools, argument semantics, or read/write classification
+- context schema version or documented fields
+- packaged workflows such as worktrees, notes, plans, claims, bootstrap, or upgrade/reconcile flows
+
+## Release checklist
+
+1. Confirm the runtime surface that changed.
+   Check the relevant source files first, typically `src/cli.ts`, `src/commands/mcp.ts`, `src/commands/mcp-read-handlers.ts`, and `src/core/context.ts`.
+2. Update the packaged docs in the same branch.
+   At minimum touch the matching reference page in `docs/`, and update `README.md` if the change affects the product story or the primary entry path.
+3. Reconcile CLI and MCP wording.
+   If a concept exists on both surfaces, document the mapping explicitly. Example: `bclaw_write_note` ↔ `brainclaw runtime-note` / `brainclaw note create`.
+4. Re-check proposal versus shipped surface.
+   If a change is still design-only, keep it out of stable reference pages or mark it clearly as a proposal.
+5. Run the doc/reference verification before publishing.
+
+```bash
+npm run build:test
+node --test dist-test/tests/unit/docs-reference.test.js
+```
+
+6. Run targeted command tests for the changed surface.
+   Prefer focused tests over broad slow suites when the behavior is small and operator-facing.
+
+Examples from the current repo:
+
+```bash
+node --test dist-test/tests/unit/plan-resource-command.test.js
+node --test --test-name-pattern "accepts note create as an alias for runtime-note" dist-test/tests/collaboration.test.js
+```
+
+7. Only then publish or pack a local release.
+
+```bash
+brainclaw version --publish-local --release-notes "..."
+```
+
+## Minimum files to review
+
+This is the smallest practical review set for release-visible drift:
+
+- `README.md`
+- `docs/index.md`
+- `docs/cli.md`
+- `docs/integrations/mcp.md`
+- `docs/context-format.md`
+- `docs/context-format-changelog.md`
+- `tests/unit/docs-reference.test.ts`
+
+Add workflow-specific docs when needed, for example:
+
+- `docs/server-operations.md`
+- `docs/quickstart.md`
+- `docs/concepts/plans-and-claims.md`
+
+## What this checklist is trying to prevent
+
+- shipping a command that exists in code but not in `docs/cli.md`
+- claiming a feature is unavailable when the code already ships it
+- documenting a proposal as if it were stable product behavior
+- leaving MCP and CLI with different names for the same operator workflow
+- publishing a local tarball that agents test against while bundled docs still describe the previous surface

package/docs/review.md

@@ -23,6 +23,8 @@ runtime-note → reflect-runtime-note → review candidate → accept / reject
 3. review the candidate (`brainclaw review`)
 4. accept or reject it (`brainclaw accept` / `brainclaw reject`)
 
+For MCP-capable agents, `brainclaw runtime-note` maps to `bclaw_write_note`.
+
 ## Star and use signals
 
 Before formal review, candidates can accumulate signals:

package/docs/server-operations.md

@@ -0,0 +1,118 @@
+# Server And Remote Operations
+
+This guide is for complex operator environments such as DGX hosts, remote Linux servers, SSH-driven workflows, and multi-project workspaces where Brainclaw is not being used from a single local IDE.
+
+## When this guide matters
+
+Use this path when one or more of these are true:
+
+- Brainclaw runs on a remote machine over SSH
+- multiple repos or child projects live under one server workspace
+- different agents resume each other over time on the same host
+- the operator sometimes uses CLI directly instead of MCP
+
+## Recommended baseline
+
+Prefer a disciplined single-environment workflow on the server:
+
+1. choose one canonical checkout per active task
+2. initialize Brainclaw in the target project before starting coordination work
+3. avoid mixing multiple shells, PATH setups, or Node installations during the same session
+4. treat shared-checkout parallel editing as risky unless each session gets a dedicated worktree
+
+## Multi-project targeting
+
+If the server workspace contains several Brainclaw projects, resolve the target project first.
+
+```bash
+brainclaw switch --list
+brainclaw switch apps/trainer
+brainclaw status
+```
+
+You can also use:
+
+- `BRAINCLAW_PROJECT` for a shell-scoped default
+- `brainclaw --cwd <path> ...` for a one-off override
+
+The goal is to avoid writing memory into the wrong store when the operator is launched from a workspace root.
+
+## Recommended session flow
+
+For MCP-capable agents:
+
+1. `bclaw_work(intent="execute", scope=...)` — opens a session, loads context, and claims the scope (with a per-claim git worktree) in a single call. Returns a compact payload by default; pass `compact: false` for the full memory dump or call `bclaw_context(kind="memory")` after.
+2. `bclaw_context(kind="execution")` — when local tooling / brainclaw version visibility is needed (already loaded implicitly by `bclaw_work`).
+3. `bclaw_write_note` / `bclaw_create(entity=...)` / `bclaw_update(entity=...)` — record observations, plans, decisions, or traps via the canonical grammar.
+4. `bclaw_session_end(narrative=..., auto_release: true)` — close cleanly; releases active claims and hands off the session record.
+
+For direct CLI operation:
+
+```bash
+brainclaw session-start --agent codex
+brainclaw plan list --all
+brainclaw claim create "Investigate training config drift" --scope configs/training/
+brainclaw runtime-note "Observed host-specific CUDA mismatch on dgx-a"
+brainclaw session-end --auto-release
+```
+
+`brainclaw runtime-note` is the CLI equivalent of `bclaw_write_note`.
+`brainclaw note create "..."` is accepted as a resource-style alias if that fits the operator workflow better.
+
+## Isolation and worktrees
+
+The safest default remains sequential collaboration: one active agent per checkout, then handoff.
+
+If you need stronger isolation:
+
+```bash
+brainclaw worktree create feat/dgx-audit
+brainclaw worktree list
+```
+
+In MCP flows, `bclaw_claim` can also create a dedicated worktree automatically when supported by the current Brainclaw version and configuration.
+
+Use dedicated worktrees when:
+
+- two sessions need to touch the same repo without sharing a checkout
+- an operator wants to preserve a clean main checkout while an agent runs elsewhere
+- a remote machine hosts long-lived or resumable agent sessions
+
+## Plan and step semantics
+
+Be explicit about the difference between plan items and plan steps:
+
+- `brainclaw plan show <id>` reads a single plan item
+- `brainclaw plan get <id>` is accepted as a read alias, but `brainclaw plan show <id>` remains the canonical form
+- `brainclaw plan update <id>` expects a `pln_*` plan ID
+- `brainclaw complete-step <planId> <stepId>` is the canonical way to complete a step
+
+If you only have a step ID, inspect the parent plan first with `plan show` or `plan list --json`.
+
+## Notes, decisions, and traps
+
+Do not use `decision` as a workaround for a session observation.
+
+Use:
+
+- `brainclaw runtime-note` for in-session observations
+- `brainclaw reflect-runtime-note` when the note may deserve promotion
+- `brainclaw decision` only for a durable decision
+- `brainclaw trap` only for a reusable pitfall
+
+This keeps canonical memory cleaner on long-lived server projects.
+
+## Common failure modes
+
+- Wrong project selected: use `brainclaw switch --list` and verify `brainclaw status`
+- Shared-checkout collisions: prefer a worktree per session when parallel activity is unavoidable
+- Confusion between plan IDs and step IDs: use `plan show` before `plan update`
+- Lost operator observations: record them with `runtime-note` instead of temporary shell notes
+
+## Recommended reading
+
+- [quickstart.md](quickstart.md)
+- [cli.md](cli.md)
+- [integrations/mcp.md](integrations/mcp.md)
+- [concepts/plans-and-claims.md](concepts/plans-and-claims.md)
+- [concepts/runtime-notes.md](concepts/runtime-notes.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "0.29.2",
+  "version": "1.5.3",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "bin": {
@@ -9,6 +9,9 @@
   },
   "files": [
     "dist/**/*.js",
+    "dist/core/default-profiles/*.yaml",
+    "dist/brainclaw-vscode.vsix",
+    "dist/facts.json",
     "docs/**/*.md",
     "README.md",
     "LICENSE"
@@ -17,12 +20,19 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc && node dist/cli.js",
-    "build:test": "tsc -p tsconfig.test.json",
+    "clean:build": "node scripts/clean-build.mjs dist dist-test",
+    "clean:dist": "node scripts/clean-build.mjs dist",
+    "clean:dist-test": "node scripts/clean-build.mjs dist-test",
+    "build": "npm run clean:dist && tsc && node scripts/copy-default-profiles.mjs && node scripts/emit-site-facts.mjs && node scripts/build-vsix.mjs",
+    "build:cli": "npm run clean:dist && tsc && node scripts/copy-default-profiles.mjs && node scripts/emit-site-facts.mjs",
+    "dev": "npm run clean:dist && tsc && node scripts/copy-default-profiles.mjs && node dist/cli.js",
+    "dev:mcp": "tsc && node scripts/copy-default-profiles.mjs",
+    "build:mcp-schemas": "npm run clean:dist && tsc && node scripts/build-mcp-schemas.mjs",
+    "dev:link": "npm link && echo 'Symlink created: global brainclaw → local repo. MCP agents now use dist/ directly.'",
+    "build:test": "npm run build && npm run clean:dist-test && tsc -p tsconfig.test.json",
     "pack:check": "node scripts/check-pack.mjs",
     "test": "npm run build:test && node scripts/run-tests.mjs default",
     "test:unit": "npm run build:test && node scripts/run-tests.mjs unit",
@@ -44,17 +54,15 @@
   ],
   "license": "BUSL-1.1",
   "homepage": "https://brainclaw.dev",
-  "engines": {
-    "node": ">=18.0.0"
-  },
   "dependencies": {
-    "commander": "^13.1.0",
+    "commander": "^14.0.3",
     "yaml": "^2.7.1",
-    "zod": "^3.24.4"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^22.15.3",
+    "@types/node": "^24.12.2",
+    "ajv": "^8.20.0",
     "c8": "^11.0.0",
-    "typescript": "^5.8.3"
+    "typescript": "^6.0.3"
   }
 }

package/dist/commands/claude-desktop-extension.js

@@ -1,18 +0,0 @@
-import path from 'node:path';
-import { buildClaudeDesktopExtension, renderClaudeDesktopExtensionSummary, } from '../core/claude-desktop-extension.js';
-export function runClaudeDesktopExtension(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const result = buildClaudeDesktopExtension({
-        cwd,
-        workspaceDir: options.workspace ? path.resolve(cwd, options.workspace) : undefined,
-        outputFile: options.output ? path.resolve(cwd, options.output) : undefined,
-        projectRoot: options.projectRoot ? path.resolve(cwd, options.projectRoot) : undefined,
-        pack: options.pack,
-    });
-    if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    console.log(renderClaudeDesktopExtensionSummary(result));
-}
-//# sourceMappingURL=claude-desktop-extension.js.map

package/dist/commands/diff.js

@@ -1,99 +0,0 @@
-import { memoryExists, memoryPath, readFileSync, writeFileAtomic } from '../core/io.js';
-import { loadState } from '../core/state.js';
-import { listCandidates, listArchivedCandidates } from '../core/candidates.js';
-import { nowISO } from '../core/ids.js';
-export function runDiff(options = {}) {
-    if (!memoryExists()) {
-        console.error('Error: .memory/ not found. Run `team-memory init` first.');
-        process.exit(1);
-    }
-    const markerPath = memoryPath('.last-context');
-    const usingMarker = !options.since;
-    let since;
-    if (options.since) {
-        since = new Date(options.since);
-        if (isNaN(since.getTime())) {
-            console.error(`Error: invalid date '${options.since}'. Use ISO 8601 format, e.g. 2026-03-14T10:00:00Z`);
-            process.exit(1);
-        }
-    }
-    else {
-        try {
-            const ts = readFileSync(markerPath).trim();
-            since = new Date(ts);
-            if (isNaN(since.getTime()))
-                throw new Error('invalid date in .last-context');
-        }
-        catch {
-            console.error('Error: no --since date provided and no .last-context marker found.');
-            console.error('Hint: run `team-memory context` first to set the marker, or use:');
-            console.error('  team-memory diff --since <ISO date>');
-            process.exit(1);
-        }
-    }
-    const sinceISO = since.toISOString();
-    const state = loadState();
-    const makeEntry = (section, type) => (e) => ({
-        id: e.id, entry_type: type, section, text: e.text, created_at: e.created_at,
-    });
-    const stateEntries = [
-        ...state.active_constraints.filter(e => e.created_at > sinceISO).map(makeEntry('active_constraints', 'constraint')),
-        ...state.recent_decisions.filter(e => e.created_at > sinceISO).map(makeEntry('recent_decisions', 'decision')),
-        ...state.known_traps.filter(e => e.created_at > sinceISO).map(makeEntry('known_traps', 'trap')),
-        ...state.open_handoffs.filter(e => e.created_at > sinceISO).map(makeEntry('open_handoffs', 'handoff')),
-    ].sort((a, b) => a.created_at.localeCompare(b.created_at));
-    const newPending = listCandidates('pending').filter(c => c.created_at > sinceISO);
-    const newAccepted = listArchivedCandidates('accepted').filter(c => (c.resolved_at ?? c.created_at) > sinceISO);
-    const total = stateEntries.length + newPending.length + newAccepted.length;
-    if (options.json) {
-        console.log(JSON.stringify({
-            since: sinceISO,
-            checked_at: new Date().toISOString(),
-            total_changes: total,
-            state_entries: stateEntries,
-            new_candidates: newPending,
-            accepted_candidates: newAccepted,
-        }, null, 2));
-    }
-    else {
-        if (total === 0) {
-            console.log(`No changes in .memory/ since ${sinceISO}`);
-        }
-        else {
-            console.log(`Changes since ${sinceISO}:`);
-            console.log('');
-            if (stateEntries.length > 0) {
-                console.log(`New canonical entries (${stateEntries.length}):`);
-                for (const e of stateEntries) {
-                    console.log(`  + [${e.id}] (${e.entry_type}) ${e.text}`);
-                }
-            }
-            if (newPending.length > 0) {
-                if (stateEntries.length > 0)
-                    console.log('');
-                console.log(`New candidates pending review (${newPending.length}):`);
-                for (const c of newPending) {
-                    console.log(`  ? [${c.id}] (${c.type}) ${c.text}`);
-                }
-            }
-            if (newAccepted.length > 0) {
-                console.log('');
-                console.log(`Candidates accepted into memory (${newAccepted.length}):`);
-                for (const c of newAccepted) {
-                    console.log(`  \u2714 [${c.id}] (${c.type}) ${c.text}`);
-                }
-            }
-        }
-    }
-    // When called without explicit --since, advance the marker so the next
-    // diff (no --since) starts from here — acts as a cursor.
-    if (usingMarker) {
-        try {
-            writeFileAtomic(markerPath, nowISO());
-        }
-        catch {
-            // Non-fatal
-        }
-    }
-}
-//# sourceMappingURL=diff.js.map