@rpamis/comet 0.4.0-beta.1 → 0.4.0-beta.11

package/dist/domains/comet-classic/classic-state-command.js

@@ -1,18 +1,24 @@
 import { spawnSync } from 'child_process';
-import { randomUUID } from 'crypto';
-import { existsSync, promises as fs } from 'fs';
+import { promises as fs } from 'fs';
 import path from 'path';
 import { Document, parseDocument } from 'yaml';
+import { clearCurrentChange, resolveCurrentChange, selectCurrentChange, } from './classic-current-change.js';
+import { driftBlockedMessage, evaluateBranchBinding, healBoundBranch, isGitWorkTree, liveGitBranch, requiresBranchBinding, resolveBranchBinding, unboundDetachedMessage, } from './classic-branch-binding.js';
 import { collectClassicEvidence } from './classic-evidence.js';
-import { openSpecChangeNameError, resolveClassicChangeDirectory } from './classic-paths.js';
+import { ensureClassicActiveChangeDirectory, openSpecChangeNameError, resolveClassicChangeDirectory, } from './classic-paths.js';
+import { assertClassicLayoutWritable, assertClassicLayoutReadable } from './classic-layout.js';
+import { classicCommandInvocationCwd, classicCommandProjectRoot, withClassicCommandContext, } from './classic-command-context.js';
 import { resolveClassicStepId } from './classic-resolver.js';
-import { transitionClassicRuntimeRun } from './classic-runtime-run.js';
+import { transitionClassicRuntimeRun, validateClassicRuntimeRun } from './classic-runtime-run.js';
 import { appendClassicStateEvent } from './classic-state-events.js';
 import { CLASSIC_WIRE_KEYS, RUN_WIRE_KEYS, parseClassicStateDocument, } from './classic-state.js';
 import { readClassicState, writeClassicState } from './classic-store.js';
 import { CLASSIC_TRANSITION_EVENTS, applyClassicTransition, } from './classic-transitions.js';
 import { readRunState } from '../../domains/engine/state.js';
 import { appendTrajectory, readTrajectory } from '../../domains/engine/run-store.js';
+import { recordCommandCheck } from './classic-command-checks.js';
+import { readClassicConfigValue } from './classic-project-config.js';
+import { classicProjectFileNonempty, classicProjectTargetExists, inspectClassicProjectTarget, readClassicProjectFile, writeClassicProjectText, } from './classic-protected-path.js';
 const GREEN = '\u001b[32m';
 const RED = '\u001b[31m';
 const YELLOW = '\u001b[33m';
@@ -23,8 +29,11 @@ const ARTIFACT_LANGUAGES = ['en', 'zh-CN'];
 const EVENTS = CLASSIC_TRANSITION_EVENTS;
 const MACHINE_OWNED_FIELDS = new Set([
     ...RUN_WIRE_KEYS,
+    'archive_confirmation',
+    'verify_failures',
     'classic_profile',
     'classic_migration',
+    'bound_branch',
 ]);
 const SETTABLE_FIELDS = new Set(CLASSIC_WIRE_KEYS.filter((field) => !MACHINE_OWNED_FIELDS.has(field)));
 const FIELD_ENUMS = {
@@ -36,11 +45,12 @@ const FIELD_ENUMS = {
     subagent_dispatch: ['null', 'confirmed'],
     tdd_mode: ['tdd', 'direct'],
     review_mode: ['off', 'standard', 'thorough'],
-    isolation: ['branch', 'worktree'],
+    isolation: ['current', 'branch', 'worktree'],
     verify_mode: ['light', 'full'],
     auto_transition: ['true', 'false'],
     verify_result: ['pending', 'pass', 'fail'],
     branch_status: ['pending', 'handled'],
+    archive_confirmation: ['pending', 'confirmed'],
     archived: ['true', 'false'],
     direct_override: ['true', 'false'],
     classic_profile: PROFILES,
@@ -56,7 +66,9 @@ const CLASSIC_FIELD_WIRE_NAMES = {
     phase: 'phase',
     verificationReport: 'verification_report',
     verifiedAt: 'verified_at',
+    archiveConfirmation: 'archive_confirmation',
     verifyResult: 'verify_result',
+    verifyFailures: 'verify_failures',
     workflow: 'workflow',
 };
 class CommandFailure extends Error {
@@ -116,37 +128,29 @@ function validateRelativePath(value, field) {
     }
 }
 async function exists(file) {
-    try {
-        await fs.access(file);
-        return true;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return false;
-        throw error;
-    }
+    const projectRoot = classicCommandProjectRoot();
+    return classicProjectTargetExists(projectRoot, file, {
+        label: `Classic project path ${path.relative(projectRoot, path.resolve(projectRoot, file)).replaceAll('\\', '/')}`,
+    });
 }
 async function nonempty(file) {
-    try {
-        return (await fs.stat(file)).size > 0;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return false;
-        throw error;
-    }
+    const projectRoot = classicCommandProjectRoot();
+    return classicProjectFileNonempty(projectRoot, file, `Classic project file ${path.relative(projectRoot, path.resolve(projectRoot, file)).replaceAll('\\', '/')}`);
 }
 async function changeDirectory(name) {
-    return resolveClassicChangeDirectory(name);
+    return resolveClassicChangeDirectory(name, classicCommandProjectRoot());
 }
 async function readDocument(file) {
     let source;
+    const projectRoot = classicCommandProjectRoot();
     try {
-        source = await fs.readFile(file, 'utf8');
+        source = await readClassicProjectFile(projectRoot, file, {
+            label: `Classic state ${path.relative(projectRoot, file).replaceAll('\\', '/')}`,
+        });
     }
     catch (error) {
         if (error.code === 'ENOENT') {
-            fail(`ERROR: .comet.yaml not found at ${path.relative(process.cwd(), file).replaceAll('\\', '/')}`);
+            fail(`ERROR: .comet.yaml not found at ${path.relative(projectRoot, file).replaceAll('\\', '/')}`);
         }
         throw error;
     }
@@ -156,16 +160,9 @@ async function readDocument(file) {
     return document;
 }
 async function atomicWrite(file, content) {
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    const temporary = `${file}.${randomUUID()}.tmp`;
-    try {
-        await fs.writeFile(temporary, content, 'utf8');
-        await fs.rename(temporary, file);
-    }
-    catch (error) {
-        await fs.rm(temporary, { force: true });
-        throw error;
-    }
+    await writeClassicProjectText(classicCommandProjectRoot(), file, content, {
+        label: 'Classic state write target',
+    });
 }
 function scalar(value) {
     if (value === null)
@@ -206,6 +203,10 @@ function nullableRecordBoolean(record, field) {
         return false;
     return null;
 }
+function nonNegativeRecordInteger(record, field, fallback = 0) {
+    const value = record[field];
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : fallback;
+}
 function sparseClassicState(record) {
     const workflow = enumRecordValue(record, 'workflow', PROFILES, 'full');
     return {
@@ -218,21 +219,22 @@ function sparseClassicState(record) {
         subagentDispatch: enumRecordValue(record, 'subagent_dispatch', ['confirmed'], null),
         tddMode: enumRecordValue(record, 'tdd_mode', ['tdd', 'direct'], null),
         reviewMode: enumRecordValue(record, 'review_mode', ['off', 'standard', 'thorough'], null),
-        isolation: enumRecordValue(record, 'isolation', ['branch', 'worktree'], null),
+        isolation: enumRecordValue(record, 'isolation', ['current', 'branch', 'worktree'], null),
+        boundBranch: nullableRecordString(record, 'bound_branch'),
         verifyMode: enumRecordValue(record, 'verify_mode', ['light', 'full'], null),
         autoTransition: nullableRecordBoolean(record, 'auto_transition'),
         baseRef: nullableRecordString(record, 'base_ref'),
         designDoc: nullableRecordString(record, 'design_doc'),
         plan: nullableRecordString(record, 'plan'),
         verifyResult: enumRecordValue(record, 'verify_result', ['pending', 'pass', 'fail'], 'pending'),
+        verifyFailures: nonNegativeRecordInteger(record, 'verify_failures'),
         verificationReport: nullableRecordString(record, 'verification_report'),
         branchStatus: enumRecordValue(record, 'branch_status', ['pending', 'handled'], null),
         createdAt: nullableRecordString(record, 'created_at'),
         verifiedAt: nullableRecordString(record, 'verified_at'),
+        archiveConfirmation: enumRecordValue(record, 'archive_confirmation', ['pending', 'confirmed'], null),
         archived: nullableRecordBoolean(record, 'archived') ?? false,
         directOverride: nullableRecordBoolean(record, 'direct_override'),
-        buildCommand: nullableRecordString(record, 'build_command'),
-        verifyCommand: nullableRecordString(record, 'verify_command'),
         handoffContext: nullableRecordString(record, 'handoff_context'),
         handoffHash: nullableRecordString(record, 'handoff_hash'),
         classicProfile: enumRecordValue(record, 'classic_profile', PROFILES, workflow),
@@ -240,19 +242,16 @@ function sparseClassicState(record) {
     };
 }
 async function projectConfigValue(field) {
-    const file = path.resolve('.comet', 'config.yaml');
-    if (!(await exists(file)))
-        return null;
-    const document = await readDocument(file);
-    const value = document.get(field);
-    return value === null || value === undefined ? null : scalar(value);
+    return (await readClassicConfigValue(field, { cwd: classicCommandProjectRoot() }))?.value ?? null;
 }
 async function projectLanguageDefault() {
     if (process.env.COMET_LANGUAGE)
         return validateLanguage(process.env.COMET_LANGUAGE, 'COMET_LANGUAGE');
-    const value = await projectConfigValue('language');
-    if (value)
-        return validateLanguage(value, '.comet/config.yaml');
+    const configured = await readClassicConfigValue('language', {
+        cwd: classicCommandProjectRoot(),
+    });
+    if (configured)
+        return validateLanguage(configured.value, configured.source);
     return 'en';
 }
 async function contextCompression() {
@@ -284,6 +283,10 @@ function gitOutput(args) {
 }
 async function stateFile(name) {
     const change = await changeDirectory(name);
+    await inspectClassicProjectTarget(classicCommandProjectRoot(), path.join(change.directory, '.comet'), {
+        label: `Classic runtime directory for ${name}`,
+        expected: 'directory',
+    });
     return {
         ...change,
         file: path.join(change.directory, '.comet.yaml'),
@@ -314,7 +317,7 @@ function parsedValue(field, value) {
         fail(`ERROR: Invalid value: '${value}'`);
     return document.get(field);
 }
-function validateSetValue(field, value) {
+async function validateSetValue(field, value) {
     if (field === 'language') {
         validateLanguage(value, 'language');
         return;
@@ -322,8 +325,15 @@ function validateSetValue(field, value) {
     const enumValues = FIELD_ENUMS[field];
     if (enumValues)
         validateEnum(value, enumValues);
-    if (PATH_FIELDS.has(field))
+    if (PATH_FIELDS.has(field)) {
         validateRelativePath(value, field);
+        if (value && value !== 'null') {
+            await inspectClassicProjectTarget(classicCommandProjectRoot(), value, {
+                label: `${field} artifact pointer`,
+                expected: 'file',
+            });
+        }
+    }
     if ((field === 'skill_hash' || field === 'handoff_hash') && !/^[a-f0-9]{64}$/u.test(value)) {
         fail(`ERROR: ${field} must be a sha256 hex digest`);
     }
@@ -333,7 +343,7 @@ function validateSetValue(field, value) {
 }
 async function setField(output, name, field, value, options = {}) {
     if (MACHINE_OWNED_FIELDS.has(field) && !options.machineOwned) {
-        fail(`ERROR: '${field}' is a machine-owned Run field and cannot be set directly`);
+        fail(`ERROR: '${field}' is a machine-owned field and cannot be set directly`);
     }
     if (!SETTABLE_FIELDS.has(field) && !MACHINE_OWNED_FIELDS.has(field)) {
         fail(`ERROR: Unknown field: '${field}'`);
@@ -343,10 +353,43 @@ async function setField(output, name, field, value, options = {}) {
             '  Use: comet-state.mjs transition <change-name> <event>\n' +
             '  Repair-only escape hatch: COMET_FORCE_PHASE=1 comet-state.mjs set <change-name> phase <value>');
     }
-    validateSetValue(field, value);
+    await validateSetValue(field, value);
     const { file, directory } = await stateFile(name);
     const document = await readDocument(file);
+    const previousRecord = (document.toJS() ?? {});
     document.set(field, parsedValue(field, value));
+    if (field === 'isolation') {
+        if (requiresBranchBinding(value)) {
+            const previousIsolation = typeof previousRecord.isolation === 'string' ? previousRecord.isolation : null;
+            const existing = previousRecord.bound_branch;
+            const alreadyBound = typeof existing === 'string' && existing !== '';
+            // Switching between workspace modes is an explicit new workspace
+            // decision and re-points the binding; repeating the same mode keeps
+            // the sticky binding that drift checks rely on.
+            if (!alreadyBound || previousIsolation !== value) {
+                const invocationCwd = classicCommandInvocationCwd();
+                const currentBranch = liveGitBranch(invocationCwd);
+                const verdict = evaluateBranchBinding({
+                    isolation: value,
+                    boundBranch: null,
+                    currentBranch,
+                    gitWorkTree: currentBranch === null ? isGitWorkTree(invocationCwd) : true,
+                });
+                if (verdict.status === 'needs-heal') {
+                    document.set('bound_branch', verdict.branch);
+                }
+                else if (verdict.status === 'unbound-detached') {
+                    fail(`ERROR: cannot bind isolation=${value} while HEAD is detached; checkout a branch first`);
+                }
+                else {
+                    document.set('bound_branch', null);
+                }
+            }
+        }
+        else {
+            document.set('bound_branch', null);
+        }
+    }
     const run = await readRunState(directory);
     const projection = parseClassicStateDocument(document.toJS(), run);
     if (projection.run) {
@@ -393,10 +436,11 @@ async function setField(output, name, field, value, options = {}) {
 async function init(output, name, workflow) {
     validateChangeName(name);
     validateEnum(workflow, PROFILES);
-    const { file, label, directory } = await stateFile(name);
+    const change = await ensureClassicActiveChangeDirectory(name, classicCommandProjectRoot());
+    const { label, directory } = change;
+    const file = path.join(directory, '.comet.yaml');
     if (await exists(file))
         fail(`ERROR: .comet.yaml already exists at ${label}/.comet.yaml`);
-    await fs.mkdir(directory, { recursive: true });
     const preset = workflow !== 'full';
     const reviewMode = preset ? 'off' : await reviewModeDefault();
     const document = new Document({
@@ -409,21 +453,23 @@ async function init(output, name, workflow) {
         subagent_dispatch: null,
         tdd_mode: preset ? 'direct' : null,
         review_mode: reviewMode,
-        isolation: preset ? 'branch' : null,
+        isolation: null,
         verify_mode: preset ? 'light' : null,
         auto_transition: (await autoTransition()) === 'true',
         base_ref: gitOutput(['rev-parse', '--verify', 'HEAD']),
         design_doc: null,
         plan: null,
         verify_result: 'pending',
+        verify_failures: 0,
         verification_report: null,
         branch_status: 'pending',
         created_at: new Date().toISOString().slice(0, 10),
         verified_at: null,
+        archive_confirmation: null,
         archived: false,
     });
     await atomicWrite(file, document.toString());
-    output.stderr.push(green(`Initialized: ${label}/.comet.yaml (workflow=${workflow})`));
+    output.stdout.push(green(`Initialized: ${label}/.comet.yaml (workflow=${workflow})`));
 }
 async function requirePhase(name, expected) {
     const actual = await readField(name, 'phase');
@@ -439,8 +485,9 @@ async function requireBuildDecisions(name) {
     const subagentDispatch = await readField(name, 'subagent_dispatch');
     const tddMode = await readField(name, 'tdd_mode');
     const reviewMode = await readField(name, 'review_mode');
-    if (!['branch', 'worktree'].includes(isolation)) {
-        fail(`ERROR: Cannot transition '${name}': isolation must be branch or worktree, got '${isolation || 'null'}'`);
+    const allowedIsolation = ['current', 'branch', 'worktree'];
+    if (!allowedIsolation.includes(isolation)) {
+        fail(`ERROR: Cannot transition '${name}': isolation must be current, branch, or worktree, got '${isolation || 'null'}'`);
     }
     if (!['subagent-driven-development', 'executing-plans', 'direct'].includes(buildMode)) {
         fail(`ERROR: Cannot transition '${name}': build_mode must be selected before leaving build, got '${buildMode || 'null'}'`);
@@ -550,13 +597,19 @@ async function transition(output, name, event) {
         if (!report || !(await exists(path.resolve(report)))) {
             fail(`ERROR: Cannot transition '${name}': verification_report must point to an existing report file`);
         }
-        if ((await readField(name, 'branch_status')) !== 'handled') {
-            fail(`ERROR: Cannot transition '${name}': branch_status must be handled`);
-        }
     }
     else if (event === 'verify-fail') {
         await requirePhase(name, 'verify');
     }
+    else if (event === 'archive-confirm') {
+        await requirePhase(name, 'archive');
+        if ((await readField(name, 'verify_result')) !== 'pass') {
+            fail(`ERROR: Cannot transition '${name}': verify_result must be pass before archiving`);
+        }
+        if ((await readField(name, 'archived')) === 'true') {
+            fail(`ERROR: Cannot transition '${name}': already archived`);
+        }
+    }
     else if (event === 'preset-escalate') {
         // preset (hotfix/tweak) → full: rewind phase to design so the agent can
         // supplement a Design Doc before continuing. Unlike verify-fail /
@@ -581,6 +634,9 @@ async function transition(output, name, event) {
         if ((await readField(name, 'verify_result')) !== 'pass') {
             fail(`ERROR: Cannot transition '${name}': verify_result must be pass before archiving`);
         }
+        if ((await readField(name, 'archive_confirmation')) !== 'confirmed') {
+            fail(`ERROR: Cannot transition '${name}': archive_confirmation must be confirmed before archiving`);
+        }
     }
     await applyTransitionEvent(output, name, event);
 }
@@ -623,10 +679,12 @@ async function taskCheckoff(output, taskFile, taskText) {
     validateRelativePath(taskFile, 'task file');
     if (!taskText)
         fail('ERROR: Task text cannot be empty');
-    const file = path.resolve(taskFile);
+    const file = path.resolve(classicCommandProjectRoot(), taskFile);
     if (!(await exists(file)))
         fail(`ERROR: Task file not found: ${taskFile}`);
-    const lines = (await fs.readFile(file, 'utf8')).split(/\r?\n/u);
+    const lines = (await readClassicProjectFile(classicCommandProjectRoot(), file, {
+        label: 'Classic task-checkoff file',
+    })).split(/\r?\n/u);
     const matches = lines.filter((line) => [`- [ ] ${taskText}`, `- [x] ${taskText}`, `- [X] ${taskText}`].includes(line));
     const checked = matches.filter((line) => /^- \[[xX]\] /u.test(line));
     if (matches.length !== 1) {
@@ -687,6 +745,32 @@ async function check(output, name, phase) {
         const archived = await readField(name, 'archived');
         (archived !== 'true' ? pass : reject)(`archived=${archived} (expected: not true)`);
     }
+    const binding = await resolveBranchBinding(directory, {
+        heal: true,
+        cwd: classicCommandInvocationCwd(),
+    });
+    if (binding.bindingRequired) {
+        switch (binding.status) {
+            case 'drift':
+                reject(driftBlockedMessage(name, binding.boundBranch, binding.currentBranch));
+                break;
+            case 'unbound-detached':
+                reject(unboundDetachedMessage(name));
+                break;
+            case 'healed':
+                pass(`bound_branch lazily set to ${binding.branch}`);
+                break;
+            case 'needs-heal':
+            case 'ok':
+            case 'not-applicable':
+                pass('bound_branch matches current branch');
+                break;
+            default: {
+                const exhaustive = binding;
+                throw new Error(`unhandled branch binding status: ${JSON.stringify(exhaustive)}`);
+            }
+        }
+    }
     output.stdout.push('');
     if (blocked) {
         output.stderr.push(red('BLOCKED — fix failing checks before proceeding'));
@@ -694,10 +778,10 @@ async function check(output, name, phase) {
     }
     output.stderr.push(green('ALL CHECKS PASSED — ready to proceed'));
 }
-function fieldStatus(field, value, file) {
+async function fieldStatus(field, value, file) {
     if (!value || value === 'null')
         return `  - ${field}: PENDING`;
-    if (file && !existsSync(path.resolve(file))) {
+    if (file && !(await exists(path.resolve(file)))) {
         return `  - ${field}: BROKEN (path ${value} does not exist)`;
     }
     return `  - ${field}: DONE (${value})`;
@@ -725,7 +809,7 @@ async function recoverDesign(output, name, directory) {
     const handoff = await readField(name, 'handoff_context');
     const hash = await readField(name, 'handoff_hash');
     const design = await readField(name, 'design_doc');
-    output.stdout.push('', '  Design progress:', fieldStatus('handoff_context', handoff, handoff), fieldStatus('handoff_hash', hash), fieldStatus('design_doc', design, design), '');
+    output.stdout.push('', '  Design progress:', await fieldStatus('handoff_context', handoff, handoff), await fieldStatus('handoff_hash', hash), await fieldStatus('design_doc', design, design), '');
     if (design && design !== 'null' && (await exists(path.resolve(design)))) {
         output.stdout.push('Recovery action: Design Doc already created and linked. Run guard to transition to build.');
     }
@@ -746,30 +830,34 @@ async function recoverBuild(output, name, directory, workflow) {
     const plan = await readField(name, 'plan');
     const decisions = [
         '  Build decisions:',
-        fieldStatus('isolation', isolation),
-        fieldStatus('build_mode', buildMode),
-        fieldStatus('build_pause', pause),
-        fieldStatus('tdd_mode', tdd),
-        fieldStatus('review_mode', review),
+        await fieldStatus('isolation', isolation),
+        await fieldStatus('build_mode', buildMode),
+        await fieldStatus('build_pause', pause),
+        await fieldStatus('tdd_mode', tdd),
+        await fieldStatus('review_mode', review),
     ];
     if (buildMode === 'subagent-driven-development' ||
         (subagentDispatch && subagentDispatch !== 'null')) {
-        decisions.push(fieldStatus('subagent_dispatch', subagentDispatch));
+        decisions.push(await fieldStatus('subagent_dispatch', subagentDispatch));
     }
-    output.stdout.push(...decisions, '', '  Plan:', fieldStatus('plan', plan, plan), '');
+    output.stdout.push(...decisions, '', '  Plan:', await fieldStatus('plan', plan, plan), '');
     const tasks = path.join(directory, 'tasks.md');
     if (!(await exists(tasks))) {
         output.stdout.push('  Tasks: tasks.md MISSING', '', 'Recovery action: tasks.md missing. Verify change directory integrity.');
         return;
     }
-    const lines = (await fs.readFile(tasks, 'utf8')).split(/\r?\n/u);
+    const lines = (await readClassicProjectFile(classicCommandProjectRoot(), tasks, {
+        label: 'Classic change tasks',
+    })).split(/\r?\n/u);
     const total = lines.filter((line) => /^\s*- \[[ xX]\] /u.test(line)).length;
     const done = lines.filter((line) => /^\s*- \[[xX]\] /u.test(line)).length;
     const pending = total - done;
     let planTotal = 0;
     let planDone = 0;
-    if (plan && plan !== 'null' && (await exists(path.resolve(plan)))) {
-        const planLines = (await fs.readFile(path.resolve(plan), 'utf8')).split(/\r?\n/u);
+    if (plan && plan !== 'null' && (await exists(plan))) {
+        const planLines = (await readClassicProjectFile(classicCommandProjectRoot(), plan, {
+            label: 'Classic build plan',
+        })).split(/\r?\n/u);
         planTotal = planLines.filter((line) => /^\s*- \[[ xX]\] /u.test(line)).length;
         planDone = planLines.filter((line) => /^\s*- \[[xX]\] /u.test(line)).length;
     }
@@ -802,7 +890,7 @@ function resolveBuildRecoveryAction(workflow, isolation, buildMode, pause, subag
         if (buildMode === 'subagent-driven-development' && (pending > 0 || planPending > 0)) {
             return subagentDispatch === 'confirmed'
                 ? 'Recovery action: Plan-ready pause is stale because build decisions are already selected. Clear build_pause to null, then inspect the first unchecked task (OpenSpec or plan additions) against recent git history/diff. If implemented, check it off; otherwise dispatch a real background subagent. Do not execute the pending task directly in the main window.'
-                : 'Recovery action: Plan-ready pause is stale and subagent dispatch is not confirmed. Confirm a real background subagent/Task/multi-agent dispatcher and set subagent_dispatch to confirmed, or set build_mode to executing-plans before continuing.';
+                : 'Recovery action: Plan-ready pause is stale and subagent dispatch is not confirmed. Return to /comet-build Step 2 capability preflight. Confirm a real background subagent/Task/multi-agent dispatcher and set subagent_dispatch to confirmed, or remove the unavailable mode and set build_mode to executing-plans before continuing.';
         }
         if (pending > 0 || planPending > 0) {
             return 'Recovery action: Plan-ready pause is stale because build decisions are already selected. Clear build_pause to null, then continue from the first unchecked task.';
@@ -825,7 +913,7 @@ function resolveBuildRecoveryAction(workflow, isolation, buildMode, pause, subag
         if (buildMode === 'subagent-driven-development') {
             return subagentDispatch === 'confirmed'
                 ? 'Recovery action: Read tasks.md and the Superpowers plan (which may include additions beyond OpenSpec), then inspect the first unchecked task against recent git history/diff. If implemented, check it off; otherwise dispatch a real background subagent. Do not execute the pending task directly in the main window.'
-                : 'Recovery action: Subagent dispatch is not confirmed. Confirm a real background subagent/Task/multi-agent dispatcher and set subagent_dispatch to confirmed, or set build_mode to executing-plans before continuing.';
+                : 'Recovery action: Subagent dispatch is not confirmed. Return to /comet-build Step 2 capability preflight. Confirm a real background subagent/Task/multi-agent dispatcher and set subagent_dispatch to confirmed, or remove the unavailable mode and set build_mode to executing-plans before continuing.';
         }
         return 'Recovery action: Read tasks.md and continue from first unchecked task.';
     }
@@ -833,7 +921,7 @@ function resolveBuildRecoveryAction(workflow, isolation, buildMode, pause, subag
         if (buildMode === 'subagent-driven-development') {
             return subagentDispatch === 'confirmed'
                 ? 'Recovery action: Read the Superpowers plan, then inspect the first unchecked Superpowers plan task against recent git history/diff. If implemented, check it off; otherwise dispatch a real background subagent. Do not execute the pending task directly in the main window.'
-                : 'Recovery action: Subagent dispatch is not confirmed. Confirm a real background subagent/Task/multi-agent dispatcher and set subagent_dispatch to confirmed, or set build_mode to executing-plans before continuing.';
+                : 'Recovery action: Subagent dispatch is not confirmed. Return to /comet-build Step 2 capability preflight. Confirm a real background subagent/Task/multi-agent dispatcher and set subagent_dispatch to confirmed, or remove the unavailable mode and set build_mode to executing-plans before continuing.';
         }
         return 'Recovery action: Read the Superpowers plan and continue from the first unchecked plan task.';
     }
@@ -841,17 +929,23 @@ function resolveBuildRecoveryAction(workflow, isolation, buildMode, pause, subag
 }
 async function recoverVerify(output, name) {
     const result = await readField(name, 'verify_result');
+    const failures = await readField(name, 'verify_failures');
     const mode = await readField(name, 'verify_mode');
     const report = await readField(name, 'verification_report');
     const branch = await readField(name, 'branch_status');
-    output.stdout.push('  Verification:', fieldStatus('verify_result', result), fieldStatus('verify_mode', mode), fieldStatus('verification_report', report, report), fieldStatus('branch_status', branch), '', result === 'pass' && branch === 'handled'
-        ? 'Recovery action: Verification complete. Run guard to transition to archive.'
+    output.stdout.push('  Verification:', await fieldStatus('verify_result', result), `  - verify_failures: ${failures || '0'}`, await fieldStatus('verify_mode', mode), await fieldStatus('verification_report', report, report), branch === 'handled'
+        ? '  - branch_status: LEGACY (handled before archive; archive still owns final closure)'
+        : '  - branch_status: DEFERRED (handled after the archive commit)', '', result === 'pass'
+        ? 'Recovery action: Verification complete. Continue to archive; branch handling happens after archive changes are committed.'
         : result === 'fail'
             ? 'Recovery action: Verification failed and rolled back to build. Resume from /comet-build.'
             : 'Recovery action: Verification not yet started or in progress. Run scale assessment then verify.');
 }
 async function recoverArchive(output, name) {
-    output.stdout.push('  Archive:', fieldStatus('verify_result', await readField(name, 'verify_result')), fieldStatus('archived', await readField(name, 'archived')), '', 'Recovery action: Run /comet-archive to complete archiving.');
+    const archiveConfirmation = await readField(name, 'archive_confirmation');
+    output.stdout.push('  Archive:', await fieldStatus('verify_result', await readField(name, 'verify_result')), await fieldStatus('archive_confirmation', archiveConfirmation), await fieldStatus('archived', await readField(name, 'archived')), '', archiveConfirmation === 'confirmed'
+        ? 'Recovery action: Archive is confirmed. Run /comet-archive to complete archiving.'
+        : 'Recovery action: Ask for final archive confirmation in /comet-archive before running the archive command.');
 }
 async function recover(output, name) {
     validateChangeName(name);
@@ -888,8 +982,11 @@ async function scale(output, name) {
         fail(`ERROR: .comet.yaml not found at ${label}/.comet.yaml`);
     const tasksFile = path.join(directory, 'tasks.md');
     const taskCount = (await exists(tasksFile))
-        ? (await fs.readFile(tasksFile, 'utf8')).split(/\r?\n/u).filter((line) => /^- \[/u.test(line))
-            .length
+        ? (await readClassicProjectFile(classicCommandProjectRoot(), tasksFile, {
+            label: 'Classic scale task file',
+        }))
+            .split(/\r?\n/u)
+            .filter((line) => /^- \[/u.test(line)).length
         : 0;
     const specs = path.join(directory, 'specs');
     let deltaSpecs = 0;
@@ -901,8 +998,10 @@ async function scale(output, name) {
     }
     const plan = await readField(name, 'plan');
     let baseRef = '';
-    if (plan && plan !== 'null' && (await exists(path.resolve(plan)))) {
-        const match = (await fs.readFile(path.resolve(plan), 'utf8')).match(/^base-ref:\s*(.+)$/mu);
+    if (plan && plan !== 'null' && (await exists(plan))) {
+        const match = (await readClassicProjectFile(classicCommandProjectRoot(), plan, {
+            label: 'Classic scale plan',
+        })).match(/^base-ref:\s*(.+)$/mu);
         baseRef = match?.[1].trim() ?? '';
     }
     if (!baseRef)
@@ -917,14 +1016,150 @@ async function scale(output, name) {
     await setField(new CommandOutput(), name, 'verify_mode', result);
     output.stderr.push(`=== Scale Assessment: ${name} ===`, `  Tasks: ${taskCount} (threshold: 3)`, `  Delta specs: ${deltaSpecs} capabilities (threshold: 1)`, `  Changed files: ${changedFiles} (threshold: 8)`, `  → Result: ${result}`, green(`[SCALE] verify_mode=${result}`));
 }
+function parseRecordCheckOptions(args) {
+    let command;
+    let exitCodeText;
+    let cwd;
+    for (let index = 0; index < args.length; index += 2) {
+        const option = args[index];
+        if (!['--command', '--exit-code', '--cwd'].includes(option)) {
+            fail(`ERROR: Unknown option: ${option}`);
+        }
+        const value = args[index + 1];
+        if (value === undefined)
+            fail(`ERROR: Missing value for option: ${option}`);
+        if (option === '--command')
+            command = value;
+        else if (option === '--exit-code')
+            exitCodeText = value;
+        else
+            cwd = value;
+    }
+    if (command === undefined)
+        fail('ERROR: Missing option: --command');
+    if (exitCodeText === undefined)
+        fail('ERROR: Missing option: --exit-code');
+    if (!/^-?\d+$/u.test(exitCodeText))
+        fail('ERROR: --exit-code must be an integer');
+    return { command, exitCode: Number(exitCodeText), ...(cwd === undefined ? {} : { cwd }) };
+}
+async function recordCheck(output, name, scopeText, args) {
+    validateChangeName(name);
+    if (scopeText !== 'build' && scopeText !== 'verify') {
+        fail(`ERROR: Invalid command check scope: '${scopeText}'`);
+    }
+    const options = parseRecordCheckOptions(args);
+    const { directory, file } = await stateFile(name);
+    const projectRoot = classicCommandProjectRoot();
+    const activeChangesDir = (await assertClassicLayoutReadable(projectRoot)).changesDir;
+    if (path.dirname(directory) !== activeChangesDir || !(await exists(file))) {
+        fail(`ERROR: command checks require an active change: ${name}`);
+    }
+    try {
+        const projection = await readClassicState(directory, { migrate: false });
+        if (!projection.classic || !projection.run) {
+            throw new Error('command checks require an existing synchronized Classic Run');
+        }
+        const { run } = await validateClassicRuntimeRun(directory, projection);
+        const recorded = await recordCommandCheck(projectRoot, directory, run, {
+            scope: scopeText,
+            ...options,
+            cwd: options.cwd ??
+                (path.relative(projectRoot, classicCommandInvocationCwd()).replaceAll('\\', '/') || '.'),
+        });
+        output.stderr.push(green(`[RECORDED] ${recorded.scope} exit=${recorded.exitCode} cwd=${recorded.cwd} command=${recorded.command}`));
+    }
+    catch (error) {
+        fail(`ERROR: ${error.message}`);
+    }
+}
 function required(args, count, usage) {
     if (args.length < count)
         fail(usage);
 }
-export const classicStateCommand = async (args) => {
+function requiredExact(args, count, usage) {
+    if (args.length !== count)
+        fail(usage);
+}
+const MUTATING_STATE_COMMANDS = new Set([
+    'init',
+    'set',
+    'transition',
+    'check',
+    'scale',
+    'record-check',
+    'rebind',
+    'select',
+    'clear-selection',
+]);
+async function assertStateCommandWritable(subcommand) {
+    if (!subcommand || !MUTATING_STATE_COMMANDS.has(subcommand))
+        return;
+    try {
+        await assertClassicLayoutWritable(classicCommandProjectRoot());
+    }
+    catch (error) {
+        fail(`ERROR: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function selectChange(output, name) {
+    validateChangeName(name);
+    try {
+        const selection = await selectCurrentChange(classicCommandProjectRoot(), name);
+        const boundBranch = await readField(name, 'bound_branch');
+        const bound = boundBranch && boundBranch !== 'null' ? boundBranch : null;
+        output.stderr.push(green(`[SELECTED] current change: ${selection.change}${bound ? ` (branch: ${bound})` : ''}`));
+    }
+    catch (error) {
+        fail(`ERROR: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function rebind(output, name) {
+    validateChangeName(name);
+    const { directory } = await stateFile(name);
+    const boundBranch = await readField(name, 'bound_branch');
+    if (!boundBranch || boundBranch === 'null') {
+        fail(`ERROR: '${name}' is not yet bound; use 'comet state set ${name} isolation <current|branch|worktree>' to establish the first binding`);
+    }
+    const branch = liveGitBranch(classicCommandInvocationCwd());
+    if (branch === null) {
+        fail('ERROR: cannot rebind while HEAD is detached; checkout a branch first');
+    }
+    const before = await readClassicState(directory);
+    if (!before.classic)
+        fail('ERROR: Classic state projection is missing');
+    await healBoundBranch(directory, branch);
+    const after = { ...before.classic, boundBranch: branch };
+    await appendClassicStateEvent(directory, {
+        change: name,
+        event: 'rebind',
+        source: 'comet-state',
+        from: before.classic,
+        to: after,
+        effects: [{ field: 'boundBranch', from: boundBranch, to: branch }],
+    });
+    output.stderr.push(green(`[REBIND] bound_branch: ${boundBranch} → ${branch}`));
+}
+async function currentChange(output) {
+    const resolution = await resolveCurrentChange(classicCommandProjectRoot());
+    if (resolution.status === 'selected') {
+        output.stdout.push(resolution.selection.change);
+        return;
+    }
+    if (resolution.status === 'missing') {
+        fail('ERROR: no current change selected\nUse: comet-state.mjs select <change-name>');
+    }
+    fail(`ERROR: current change selection is stale: ${resolution.reason}\nUse: comet-state.mjs select <change-name>`);
+}
+async function clearSelection(output) {
+    await clearCurrentChange(classicCommandProjectRoot());
+    output.stderr.push(green('[CLEARED] current change selection'));
+}
+export const classicStateCommand = async (args, options) => withClassicCommandContext(options, async () => {
     const output = new CommandOutput();
     try {
         const [subcommand, ...rest] = args;
+        await assertStateCommandWritable(subcommand);
         if (subcommand === 'init') {
             required(rest, 2, 'Usage: comet-state.mjs init <change-name> <workflow>');
             await init(output, rest[0], rest[1]);
@@ -954,10 +1189,30 @@ export const classicStateCommand = async (args) => {
             required(rest, 1, 'Usage: comet-state.mjs scale <change-name>');
             await scale(output, rest[0]);
         }
+        else if (subcommand === 'record-check') {
+            required(rest, 2, 'Usage: comet state record-check <change> <build|verify> --command <text> --exit-code <int> [--cwd <path>]');
+            await recordCheck(output, rest[0], rest[1], rest.slice(2));
+        }
         else if (subcommand === 'task-checkoff') {
             required(rest, 2, 'Usage: comet-state.mjs task-checkoff <file> <task-text>');
             await taskCheckoff(output, rest[0], rest[1]);
         }
+        else if (subcommand === 'rebind') {
+            requiredExact(rest, 1, 'Usage: comet-state.mjs rebind <change-name>');
+            await rebind(output, rest[0]);
+        }
+        else if (subcommand === 'select') {
+            requiredExact(rest, 1, 'Usage: comet-state.mjs select <change-name>');
+            await selectChange(output, rest[0]);
+        }
+        else if (subcommand === 'current') {
+            requiredExact(rest, 0, 'Usage: comet-state.mjs current');
+            await currentChange(output);
+        }
+        else if (subcommand === 'clear-selection') {
+            requiredExact(rest, 0, 'Usage: comet-state.mjs clear-selection');
+            await clearSelection(output);
+        }
         else if (subcommand === 'next') {
             required(rest, 1, 'Usage: comet-state.mjs next <change-name>');
             await next(output, rest[0]);
@@ -980,5 +1235,5 @@ export const classicStateCommand = async (args) => {
         }
         return output.result(error.exitCode);
     }
-};
+});
 //# sourceMappingURL=classic-state-command.js.map