@winspan/claude-forge 8.54.4 → 9.12.0

package/dist/cli/commands/decisions.js

@@ -0,0 +1,706 @@
+/**
+ * `cf decisions` — manage decision lifecycle (decision-flow-overhaul 2026-05-28)
+ *
+ * Subcommands:
+ *   cf decisions list [--status <s>] [--session-id <id>] [--json]
+ *     List decisions, optionally filtered by status / session.
+ *
+ *   cf decisions show <id> [--json]
+ *     Show full detail for a single decision row.
+ *
+ *   cf decisions update --id <id> [--options-json <json>] [--recommendation <text>]
+ *                       [--risks-json <json>] [--open-questions-json <json>]
+ *                       [--doc <path>] [--json]
+ *     Called by decision-maker agent after writing the decision doc.
+ *     Fills back options/recommendation/risks/open_questions into the DB.
+ *
+ *   cf decisions approve <id> [--json]
+ *     Mark a decision resolved (status='resolved'). Can also be triggered
+ *     from the Web UI.
+ *
+ *   cf decisions outcome <id> --result <success|failed|partial> [--note <text>] [--json]
+ *   cf decisions outcome --list-pending [--json]
+ *     (decision-maker optimization Batch 1.2, decision a5d5a85b) Back-fill the
+ *     implementation outcome of an already-approved (status='resolved')
+ *     decision, or list resolved decisions whose outcome is not yet filled.
+ *
+ *   cf decisions register --doc <path> [--session-id <id>] [--source <s>]
+ *                         [--project-path <path>] [--json]
+ *     (C1 Phase 2, spec 0854) Register an existing spec file as a kind='spec'
+ *     decisions row so the user can short-circuit approve it with bare `批准
+ *     <token>`. Absorbs the retired `cf spec register` semantics.
+ *
+ * Design:
+ *   - Session id resolution: --session-id flag > $CLAUDE_SESSION_ID env > DB lookup
+ *   - JSON output mode for agent / scripting callers
+ *   - Exit 0 on all success/no-op paths; exit 1 on error
+ */
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { SQLiteStorage } from '../../core/storage/sqlite.js';
+import { ConfigManager } from '../../core/config.js';
+import { expandPath } from '../../core/utils/path.js';
+import { resolveSessionId } from '../utils/resolve-session.js';
+import { DECISION_OUTCOMES } from '../../core/storage/decisions.js';
+import { isAgentSpawnToolName } from '../../daemon/services/decision-hint.js';
+function resolveIo(io) {
+    return {
+        log: io.log ?? ((m) => console.log(m)),
+        warn: io.warn ?? ((m) => console.error(m)),
+        error: io.error ?? ((m) => console.error(m)),
+    };
+}
+function openStorage(injected) {
+    if (injected)
+        return { storage: injected, own: false };
+    const config = new ConfigManager().get();
+    const dbPath = expandPath(config.storage.path);
+    return { storage: new SQLiteStorage(dbPath), own: true };
+}
+// ── Command registration ─────────────────────────────────────────────────
+export function register(program) {
+    const cmd = program
+        .command('decisions')
+        .description('Manage decision lifecycle (decision-flow-overhaul 2026-05-28)');
+    // ── list ─────────────────────────────────────────────────────────────
+    cmd
+        .command('list')
+        .description('List decisions')
+        .option('--status <status>', 'Filter by status (advisory|pending|resolved|bypassed|expired)')
+        .option('--session-id <id>', 'Filter by session id')
+        .option('--json', 'Output JSON')
+        .action((opts) => {
+        process.exitCode = runList(opts);
+    });
+    // ── show ─────────────────────────────────────────────────────────────
+    cmd
+        .command('show <id>')
+        .description('Show a single decision by id')
+        .option('--json', 'Output JSON')
+        .action((id, opts) => {
+        process.exitCode = runShow(id, opts);
+    });
+    // ── update ────────────────────────────────────────────────────────────
+    cmd
+        .command('update')
+        .description('Fill back decision content (called by decision-maker agent)')
+        .requiredOption('--id <id>', 'Decision id (8-char)')
+        .option('--options-json <json>', 'JSON array of options [{name,what,pros,cons,loc,risk}]')
+        .option('--recommendation <text>', 'Recommended option + rationale')
+        .option('--risks-json <json>', 'JSON array of risk strings')
+        .option('--open-questions-json <json>', 'JSON array of open question strings')
+        .option('--doc <path>', 'Relative path to the decision doc under docs/design/')
+        .option('--recommended-agents <agents>', 'Comma-separated agent ids recommended by decision-maker')
+        .option('--recommended-skills <skills>', 'Comma-separated skill ids recommended by decision-maker')
+        .option('--json', 'Output JSON')
+        .action((opts) => {
+        process.exitCode = runUpdate(opts);
+    });
+    // ── approve ───────────────────────────────────────────────────────────
+    cmd
+        .command('approve <id>')
+        .description('Approve a decision (status → resolved)')
+        .option('--reason <text>', 'Justification for the approve. REQUIRED when no decision-maker spawn ' +
+        'trace exists within ±5min of the approve — this is the Option B ' +
+        '(decision b95e0956) self-aware bypass gate.')
+        .option('--json', 'Output JSON')
+        .action((id, opts) => {
+        process.exitCode = runApprove(id, opts);
+    });
+    // ── outcome (decision-maker optimization Batch 1.2, decision a5d5a85b) ──
+    // Back-fill the implementation outcome of an already-approved decision, or
+    // list resolved decisions whose outcome is not yet filled (--list-pending).
+    cmd
+        .command('outcome [id]')
+        .description('Back-fill a decision implementation outcome, or list those pending back-fill')
+        .option('--result <result>', `Outcome: ${DECISION_OUTCOMES.join(' | ')}`)
+        .option('--note <text>', 'Free-text note about the outcome (not persisted; logged only)')
+        .option('--list-pending', 'List resolved decisions whose outcome is not yet filled')
+        .option('--json', 'Output JSON')
+        .action((id, opts) => {
+        process.exitCode = runOutcome({ ...opts, id });
+    });
+    // ── register (C1 Phase 2, spec 0854) ───────────────────────────────────
+    // Register an existing spec file as a decisions kind='spec' row so users
+    // can short-circuit approve it with bare `批准 <token>`. Absorbs the old
+    // `cf spec register` semantics into the decisions subsystem.
+    cmd
+        .command('register')
+        .description('Register a spec file in decisions (kind=spec) for bare 批准 approval')
+        .requiredOption('--doc <path>', 'Path to the spec file (relative to project or absolute)')
+        .option('--session-id <id>', 'Session id to attach the spec to (defaults to $CLAUDE_SESSION_ID env var)')
+        .option('--source <source>', `Origin: 'planner' | 'manual' | 'decision' (default 'manual')`, 'manual')
+        .option('--project-path <path>', 'Project root used to resolve the doc path (defaults to cwd)')
+        .option('--json', 'Output JSON instead of human-readable text')
+        .action((opts) => {
+        process.exitCode = runRegisterSpec(opts);
+    });
+}
+// ── runList ──────────────────────────────────────────────────────────────
+export function runList(opts, io = {}, injectedStorage) {
+    const { log, error } = resolveIo(io);
+    const { storage, own } = openStorage(injectedStorage);
+    try {
+        const filter = {};
+        if (opts.status)
+            filter.status = opts.status;
+        if (opts.sessionId)
+            filter.session_id = opts.sessionId;
+        const rows = storage.listDecisions(filter);
+        if (opts.json) {
+            log(JSON.stringify(rows));
+        }
+        else {
+            if (rows.length === 0) {
+                log('No decisions found.');
+            }
+            else {
+                for (const r of rows) {
+                    log(`${r.id}  ${r.status.padEnd(8)}  ` +
+                        `${r.session_id.slice(0, 8)}...  ${r.created_at}`);
+                    if (r.recommendation)
+                        log(`         recommendation: ${r.recommendation.slice(0, 80)}`);
+                }
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        error(`Error: ${err}`);
+        return 1;
+    }
+    finally {
+        if (own)
+            storage.close();
+    }
+}
+// ── runShow ──────────────────────────────────────────────────────────────
+export function runShow(id, opts, io = {}, injectedStorage) {
+    const { log, error } = resolveIo(io);
+    const { storage, own } = openStorage(injectedStorage);
+    try {
+        const row = storage.getDecision(id);
+        if (!row) {
+            error(`Decision not found: ${id}`);
+            return 1;
+        }
+        if (opts.json) {
+            log(JSON.stringify(row));
+        }
+        else {
+            log(`id:             ${row.id}`);
+            log(`status:         ${row.status}`);
+            log(`session_id:     ${row.session_id}`);
+            log(`project_path:   ${row.project_path}`);
+            log(`suggested_agent: ${row.suggested_agent ?? '(none)'}`);
+            log(`created_at:     ${row.created_at}`);
+            log(`expires_at:     ${row.expires_at}`);
+            if (row.approved_at)
+                log(`approved_at:    ${row.approved_at} (by ${row.approved_by})`);
+            if (row.decision_doc_path)
+                log(`doc:            ${row.decision_doc_path}`);
+            log('');
+            log(`trigger_prompt: ${row.trigger_prompt}`);
+            log('');
+            if (row.options_json) {
+                log('options:');
+                try {
+                    const opts2 = JSON.parse(row.options_json);
+                    for (const o of opts2)
+                        log(`  - ${o.name}`);
+                }
+                catch {
+                    log(`  (raw) ${row.options_json}`);
+                }
+            }
+            if (row.recommendation)
+                log(`\nrecommendation: ${row.recommendation}`);
+            if (row.risks_json) {
+                log('\nrisks:');
+                try {
+                    const risks = JSON.parse(row.risks_json);
+                    for (const r2 of risks)
+                        log(`  - ${r2}`);
+                }
+                catch {
+                    log(`  (raw) ${row.risks_json}`);
+                }
+            }
+            if (row.open_questions_json) {
+                log('\nopen questions:');
+                try {
+                    const oqs = JSON.parse(row.open_questions_json);
+                    for (const q of oqs)
+                        log(`  - ${q}`);
+                }
+                catch {
+                    log(`  (raw) ${row.open_questions_json}`);
+                }
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        error(`Error: ${err}`);
+        return 1;
+    }
+    finally {
+        if (own)
+            storage.close();
+    }
+}
+// ── runUpdate ─────────────────────────────────────────────────────────────
+export function runUpdate(opts, io = {}, injectedStorage) {
+    const { log, error } = resolveIo(io);
+    const { storage, own } = openStorage(injectedStorage);
+    try {
+        const existing = storage.getDecision(opts.id);
+        if (!existing) {
+            error(`Decision not found: ${opts.id}`);
+            return 1;
+        }
+        // Validate JSON fields if provided
+        for (const [label, val] of [
+            ['--options-json', opts.optionsJson],
+            ['--risks-json', opts.risksJson],
+            ['--open-questions-json', opts.openQuestionsJson],
+        ]) {
+            if (val !== undefined) {
+                try {
+                    JSON.parse(val);
+                }
+                catch {
+                    error(`Error: ${label} is not valid JSON`);
+                    return 1;
+                }
+            }
+        }
+        storage.updateDecision(opts.id, {
+            options_json: opts.optionsJson ?? undefined,
+            recommendation: opts.recommendation ?? undefined,
+            risks_json: opts.risksJson ?? undefined,
+            open_questions_json: opts.openQuestionsJson ?? undefined,
+            decision_doc_path: opts.doc ?? undefined,
+            recommended_agents: opts.recommendedAgents ?? undefined,
+            recommended_skills: opts.recommendedSkills ?? undefined,
+        });
+        if (opts.json) {
+            log(JSON.stringify({ ok: true, id: opts.id }));
+        }
+        else {
+            log(`Decision ${opts.id} updated.`);
+        }
+        return 0;
+    }
+    catch (err) {
+        error(`Error: ${err}`);
+        return 1;
+    }
+    finally {
+        if (own)
+            storage.close();
+    }
+}
+// ── runApprove ────────────────────────────────────────────────────────────
+/**
+ * Option B (decision b95e0956, 2026-05-29) — window for the "decision-maker
+ * spawn trace" lookup. Approves with a Task spawn of subagent_type='decision-maker'
+ * within ±MAKER_TRACE_WINDOW_MS of `now` are auto-tagged
+ * `bypass_reason='via decision-maker'`; everything else REQUIRES `--reason`.
+ */
+export const MAKER_TRACE_WINDOW_MS = 5 * 60 * 1000; // ±5 min
+/**
+ * Look for a recent PreToolUse Task event whose tool_input.subagent_type is
+ * 'decision-maker' within ±MAKER_TRACE_WINDOW_MS of `nowMs` for the given
+ * session. Returns true when found (i.e. the approve is NOT a bypass).
+ *
+ * Optional `session_id` filter limits scope to the row's session; omitting it
+ * is a safety fallback for legacy approves that don't know which session
+ * spawned them (rare — Web UI always knows; CLI usually does too).
+ */
+export function findRecentDecisionMakerSpawn(storage, session_id, nowMs = Date.now()) {
+    if (!session_id)
+        return false;
+    const sinceIso = new Date(nowMs - MAKER_TRACE_WINDOW_MS).toISOString();
+    try {
+        const rows = storage.queryEvents({
+            session_id,
+            hook_type: 'PreToolUse',
+            since: sinceIso,
+            limit: 200,
+        });
+        for (const ev of rows) {
+            // Bug P1 (decision e888352d, 2026-06-10) — accept both 'Agent' (current
+            // Claude Code) and 'Task' (legacy CC) so this approve-trace lookup does
+            // not silently miss every real spawn. Shared helper keeps it in lock-step
+            // with the daemon cooldown gate.
+            if (!isAgentSpawnToolName(ev.tool_name))
+                continue;
+            const input = (ev.tool_input ?? {});
+            const sub = typeof input['subagent_type'] === 'string' ? input['subagent_type'] : '';
+            if (sub === 'decision-maker')
+                return true;
+        }
+    }
+    catch {
+        // Fail-silent — if storage lookup blows up we degrade to "no trace found"
+        // which forces an explicit --reason. Safer than auto-allowing.
+    }
+    return false;
+}
+export function runApprove(id, opts, io = {}, injectedStorage) {
+    const { log, error } = resolveIo(io);
+    const { storage, own } = openStorage(injectedStorage);
+    try {
+        const existing = storage.getDecision(id);
+        if (!existing) {
+            error(`Decision not found: ${id}`);
+            return 1;
+        }
+        if (existing.status === 'resolved') {
+            if (opts.json) {
+                log(JSON.stringify({ ok: true, id, already_approved: true }));
+            }
+            else {
+                log(`Decision ${id} is already approved.`);
+            }
+            return 0;
+        }
+        // Option B (decision b95e0956) — bypass governance gate.
+        //
+        // Look for a decision-maker spawn trace in the row's session within ±5 min.
+        // If found → auto-fill bypass_reason='via decision-maker', flag=0.
+        // If NOT found → --reason is REQUIRED; otherwise abort with code 1.
+        const sawMakerSpawn = findRecentDecisionMakerSpawn(storage, existing.session_id);
+        let bypass_flag;
+        let bypass_reason;
+        if (sawMakerSpawn) {
+            bypass_flag = 0;
+            bypass_reason = opts.reason?.trim() || 'via decision-maker';
+        }
+        else {
+            const reason = opts.reason?.trim();
+            if (!reason) {
+                error('Error: --reason <text> is required when approving without a ' +
+                    'decision-maker spawn trace (Option B / decision b95e0956). ' +
+                    'Either spawn decision-maker first, or pass `--reason "<why>"` ' +
+                    'to record an explicit self-aware bypass justification.');
+                return 1;
+            }
+            bypass_flag = 1;
+            bypass_reason = reason;
+        }
+        storage.approveDecision(id, 'user', undefined, { bypass_flag, bypass_reason });
+        if (opts.json) {
+            log(JSON.stringify({
+                ok: true,
+                id,
+                approved: true,
+                bypass_flag,
+                bypass_reason,
+            }));
+        }
+        else {
+            log(`Decision ${id} approved (status=resolved, bypass_flag=${bypass_flag}, ` +
+                `reason="${bypass_reason}").`);
+        }
+        return 0;
+    }
+    catch (err) {
+        error(`Error: ${err}`);
+        return 1;
+    }
+    finally {
+        if (own)
+            storage.close();
+    }
+}
+// ── runOutcome (decision-maker optimization Batch 1.2, decision a5d5a85b) ────
+/**
+ * Back-fill the implementation outcome of an already-approved decision, or list
+ * resolved decisions whose outcome is not yet filled.
+ *
+ * Two mutually-exclusive modes:
+ *   - `--list-pending`: list decisions with status='resolved' AND outcome IS
+ *     NULL (id is ignored). Supports --json.
+ *   - back-fill: requires `id` + `--result <success|failed|partial>`. The
+ *     decision must exist and be status='resolved' (back-fill only makes sense
+ *     for approved decisions). `--result` is validated against
+ *     DECISION_OUTCOMES (single source of truth). `--note` is accepted for UX
+ *     but NOT persisted (no storage field) — only echoed in the confirmation.
+ *
+ * Neither mode satisfied (no id and no --list-pending) → usage error, exit 1.
+ *
+ * Exported for unit tests; returns exit code instead of process.exit.
+ */
+export function runOutcome(opts, io = {}, injectedStorage) {
+    const { log, error } = resolveIo(io);
+    // ── --list-pending mode ──────────────────────────────────────────────
+    if (opts.listPending) {
+        const { storage, own } = openStorage(injectedStorage);
+        try {
+            // Storage has no outcome-is-null filter; pull resolved rows then filter.
+            const resolved = storage.listDecisions({ status: 'resolved' });
+            const pending = resolved.filter((r) => r.outcome === null);
+            if (opts.json) {
+                log(JSON.stringify(pending));
+            }
+            else if (pending.length === 0) {
+                log('No resolved decisions awaiting outcome back-fill.');
+            }
+            else {
+                for (const r of pending) {
+                    log(`${r.id}  resolved  ` +
+                        `${r.session_id.slice(0, 8)}...  ${r.created_at}`);
+                    if (r.recommendation)
+                        log(`         recommendation: ${r.recommendation.slice(0, 80)}`);
+                }
+            }
+            return 0;
+        }
+        catch (err) {
+            error(`Error: ${err}`);
+            return 1;
+        }
+        finally {
+            if (own)
+                storage.close();
+        }
+    }
+    // ── back-fill mode ───────────────────────────────────────────────────
+    if (!opts.id) {
+        error('Error: usage — provide an <id> with --result <result> to back-fill, ' +
+            'or --list-pending to list resolved decisions awaiting an outcome.');
+        return 1;
+    }
+    if (!opts.result) {
+        error(`Error: --result <${DECISION_OUTCOMES.join('|')}> is required`);
+        return 1;
+    }
+    if (!DECISION_OUTCOMES.includes(opts.result)) {
+        error(`Error: invalid --result "${opts.result}" — must be one of ` +
+            `${DECISION_OUTCOMES.join(', ')}`);
+        return 1;
+    }
+    const result = opts.result;
+    const { storage, own } = openStorage(injectedStorage);
+    try {
+        const existing = storage.getDecision(opts.id);
+        if (!existing) {
+            error(`Decision not found: ${opts.id}`);
+            return 1;
+        }
+        // Bug P0 (decision e888352d, 2026-06-10) — outcome back-fill now also
+        // accepts 'advisory' decisions, not just 'resolved'. Advisory is the
+        // default mint status for daemon-minted kind='decision' rows (decision
+        // 93e8fff1); audit/advisory decisions (e.g. the full-link audit itself)
+        // are never explicitly chat-approved, so requiring status='resolved'
+        // left them with no way to record a closed-loop outcome — pure 空转.
+        //
+        // 'pending' (legacy open), 'bypassed', and 'expired' are still rejected:
+        // a bypassed/expired decision was deliberately abandoned and recording an
+        // implementation outcome on it is meaningless.
+        if (existing.status !== 'resolved' && existing.status !== 'advisory') {
+            error(`Error: decision ${opts.id} has status='${existing.status}' — outcome ` +
+                `back-fill is only valid for approved (status='resolved') or ` +
+                `advisory (daemon-minted) decisions.`);
+            return 1;
+        }
+        storage.writeDecisionOutcome(opts.id, result);
+        // When the decision was still 'advisory', recording an implementation
+        // outcome means it has been acted on — transition it to 'resolved' so the
+        // lifecycle stays coherent (no row left in 'advisory' with a non-null
+        // outcome) and `--list-pending` / outcome-nudge accounting stays correct.
+        // approveDecision is idempotent and only flips rows that are not already
+        // resolved, so a row that was already resolved is untouched here.
+        let advisoryResolved = false;
+        if (existing.status === 'advisory') {
+            storage.approveDecision(opts.id, 'outcome-backfill', undefined, {
+                bypass_flag: 0,
+                bypass_reason: 'resolved via outcome back-fill (advisory decision)',
+            });
+            advisoryResolved = true;
+        }
+        if (opts.json) {
+            log(JSON.stringify({
+                ok: true,
+                id: opts.id,
+                outcome: result,
+                ...(advisoryResolved ? { resolved_from_advisory: true } : {}),
+            }));
+        }
+        else {
+            const noteSuffix = opts.note ? ` (note: ${opts.note})` : '';
+            const advisorySuffix = advisoryResolved
+                ? ' (advisory → resolved)'
+                : '';
+            log(`Decision ${opts.id} outcome set to '${result}'.${advisorySuffix}${noteSuffix}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        error(`Error: ${err}`);
+        return 1;
+    }
+    finally {
+        if (own)
+            storage.close();
+    }
+}
+// ── runRegisterSpec (C1 Phase 2, spec 0854) ─────────────────────────────────
+/** Valid `--source` values for `cf decisions register` (no 'auto'; that was a
+ *  dead SpecGenerator origin and is not a valid manual/agent source here). */
+const VALID_SPEC_SOURCES = new Set(['planner', 'manual', 'decision']);
+/**
+ * Register an existing spec file as a decisions kind='spec' row.
+ *
+ * Mints the SAME 8-hex SHA1 token shape as `cf spec register`
+ * (createHash('sha1')...slice(0,8)) so the `批准 <token>` regex/UX never
+ * changes. Idempotent on spec_path: a second register of the same doc returns
+ * exit 0 + already_registered=true (Q5: never hard-fail — planner Step 4.5).
+ *
+ * Exported for unit tests; returns exit code instead of process.exit.
+ */
+export function runRegisterSpec(opts, io = {}, injectedStorage) {
+    const { log, warn, error } = resolveIo(io);
+    // ── Validate inputs ──────────────────────────────────────────────────
+    if (!opts.doc) {
+        error('Error: --doc is required');
+        return 1;
+    }
+    const source = (opts.source ?? 'manual').toLowerCase();
+    if (!VALID_SPEC_SOURCES.has(source)) {
+        error(`Error: invalid --source "${opts.source}" (must be 'planner' | 'manual' | 'decision')`);
+        return 1;
+    }
+    const projectPath = opts.projectPath ?? process.cwd();
+    const absDocPath = path.isAbsolute(opts.doc)
+        ? opts.doc
+        : path.resolve(projectPath, opts.doc);
+    if (!existsSync(absDocPath)) {
+        error(`Error: spec file not found at ${absDocPath}`);
+        return 1;
+    }
+    // Store project-relative so the approval message displays a clean path.
+    const relDocPath = path.isAbsolute(opts.doc)
+        ? path.relative(projectPath, absDocPath)
+        : opts.doc;
+    const { storage, own } = openStorage(injectedStorage);
+    try {
+        // ── Session id: shared flag → env → DB lookup fallback (Q3). ───────
+        const resolved = resolveSessionId(storage, {
+            sessionId: opts.sessionId,
+            projectPath,
+        });
+        if (!resolved.sessionId) {
+            error(`Error: no active session found for project ${projectPath} — ` +
+                `pass --session-id explicitly or set CLAUDE_SESSION_ID env var`);
+            return 1;
+        }
+        const sessionId = resolved.sessionId;
+        // ── Idempotency: probe by spec_path (decision_doc_path). ───────────
+        const existing = storage.findSpecByPath(relDocPath);
+        if (existing) {
+            if (opts.json) {
+                log(JSON.stringify({
+                    ok: true,
+                    already_registered: true,
+                    token: existing.approval_token,
+                    spec_path: existing.decision_doc_path,
+                    source: existing.spec_source,
+                    id: existing.id,
+                    kind: 'spec',
+                }));
+            }
+            else {
+                warn(`Spec already registered: ${relDocPath} ` +
+                    `(token=${existing.approval_token}, source=${existing.spec_source})`);
+            }
+            return 0;
+        }
+        // ── Mint 8-hex SHA1 token (same algorithm as `cf spec register`). ──
+        const token = createHash('sha1')
+            .update(`${absDocPath}:${new Date().toISOString()}:${process.pid}`)
+            .digest('hex')
+            .slice(0, 8);
+        const intentJson = JSON.stringify({
+            source: 'cli-decisions-register',
+            suggested_agent: source === 'decision' ? 'decision-maker' : 'planner',
+        });
+        try {
+            const id = storage.registerSpec({
+                session_id: sessionId,
+                project_path: projectPath,
+                prompt_text: '(registered via `cf decisions register`)',
+                spec_path: relDocPath,
+                approval_token: token,
+                spec_source: source,
+                spec_intent_json: intentJson,
+            });
+            const summary = {
+                ok: true,
+                already_registered: false,
+                id,
+                token,
+                spec_path: relDocPath,
+                source,
+                kind: 'spec',
+                session_id: sessionId,
+                session_id_source: resolved.source,
+            };
+            if (opts.json) {
+                log(JSON.stringify(summary));
+            }
+            else {
+                log(`✓ Registered spec @ ${relDocPath}\n` +
+                    `  token:      ${token}\n` +
+                    `  session_id: ${sessionId} (from ${resolved.source})\n` +
+                    `  source:     ${source}\n` +
+                    `  id:         ${id}\n` +
+                    `  kind:       spec\n` +
+                    `\nUser can now reply '批准' / '同意' / 'approve ${token}' to short-circuit.`);
+            }
+            return 0;
+        }
+        catch (err) {
+            // UNIQUE constraint race (between findSpecByPath probe and INSERT on the
+            // partial-unique approval_token index). Q5: still don't hard-fail — warn
+            // and exit 0 so the agent continues. Re-probe to surface the live token.
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('UNIQUE constraint failed')) {
+                const re = storage.findSpecByPath(relDocPath);
+                if (re) {
+                    if (opts.json) {
+                        log(JSON.stringify({
+                            ok: true,
+                            already_registered: true,
+                            token: re.approval_token,
+                            spec_path: re.decision_doc_path,
+                            source: re.spec_source,
+                            id: re.id,
+                            kind: 'spec',
+                            race: true,
+                        }));
+                    }
+                    else {
+                        warn(`Spec already registered (UNIQUE race): ${relDocPath} ` +
+                            `(token=${re.approval_token})`);
+                    }
+                    return 0;
+                }
+            }
+            error(`Error: failed to register spec — ${msg}`);
+            return 1;
+        }
+    }
+    catch (err) {
+        error(`Error: ${err}`);
+        return 1;
+    }
+    finally {
+        if (own)
+            storage.close();
+    }
+}
+//# sourceMappingURL=decisions.js.map