agentic-workflow-manager 9.7.1 → 9.9.0

package/dist/src/commands/sensors/status.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const paths_1 = require("../../core/paths");
 const contract_1 = require("./compatibility/contract");
 const discovery_1 = require("./compatibility/discovery");
+const live_1 = require("./compatibility/live");
 const resolve_1 = require("./compatibility/resolve");
 const project_1 = require("./project");
 const source_1 = require("./compatibility/source");
@@ -100,12 +101,13 @@ function resolveStaticV2Compatibility(cwd, manifest, source) {
     if (parsed.kind !== 'v2')
         throw new Error(`sensor pack "${manifest.pack}" does not provide a v2 compatibility contract`);
     const evidence = (0, discovery_1.discoverProjectEvidence)(cwd, parsed.pack);
+    const executionPack = (0, live_1.bindContainedRuntimeCommands)(parsed.pack, evidence.pythonEnvironmentRoot);
     const resolutionEvidence = {
         ...evidence,
         ...(manifest.packSelection === 'explicit' ? { packSelection: 'explicit' } : {}),
     };
-    const initial = (0, resolve_1.resolveProjectCompatibility)(parsed.pack, resolutionEvidence).sensors;
-    return Object.fromEntries(Object.entries(parsed.pack.sensors).map(([name, sensor]) => {
+    const initial = (0, resolve_1.resolveProjectCompatibility)(executionPack, resolutionEvidence).sensors;
+    return Object.fromEntries(Object.entries(executionPack.sensors).map(([name, sensor]) => {
         const variant = initial[name]?.variantId === null
             ? null
             : sensor.variants.find(candidate => candidate.id === initial[name]?.variantId) ?? null;
@@ -115,11 +117,11 @@ function resolveStaticV2Compatibility(cwd, manifest, source) {
         const probeStatus = variant?.probe.kind === 'config-present'
             ? (evidence.configFiles.length > 0 ? 'matched' : 'not-matched')
             : variant?.probe.kind === 'package-script-present'
-                ? (evidence.scripts.length > 0 ? 'matched' : 'not-matched')
+                ? (variant.probe.script !== undefined && evidence.scripts.includes(variant.probe.script) ? 'matched' : 'not-matched')
                 : undefined;
         return [name, probeStatus === undefined
                 ? initial[name]
-                : (0, resolve_1.resolveSensorCompatibility)(sensor, { ...resolutionEvidence, probe: { status: probeStatus } }, { pack: parsed.pack.name, sensor: name })];
+                : (0, resolve_1.resolveSensorCompatibility)(sensor, { ...resolutionEvidence, probe: { status: probeStatus } }, { pack: executionPack.name, sensor: name })];
     }));
 }
 function staticCompatibilityCheck(sensor, live) {

package/dist/src/commands/watch/apply.js

@@ -18,6 +18,8 @@ const paths_1 = require("../../core/journal/paths");
 const atomic_file_1 = require("../../core/atomic-file");
 const redact_1 = require("../../core/journal/redact");
 const git_1 = require("../../core/tracks/git");
+const types_1 = require("../../core/journal/types");
+const journal_1 = require("../../core/model-policy/journal");
 function now() { return new Date().toISOString(); }
 const VERIFICATION_KINDS = ['test', 'lint', 'sensors', 'review', 'qa', 'interlock', 'track-integration'];
 function verificationItems(value, field) {
@@ -110,6 +112,24 @@ function applyRequestToState(s, env, digest, repoRoot) {
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied' });
         return;
     }
+    if (env.kind === 'routing-reserve') {
+        const p = env.payload;
+        if (typeof p.obligationId !== 'string' || typeof p.lineageId !== 'string' || !(0, types_1.isRoutingEnvelope)(p.envelope) || typeof p.fingerprint !== 'string' || (p.at !== undefined && typeof p.at !== 'string'))
+            throw new Error('routing-reserve requiere payload estricto');
+        const reserved = (0, journal_1.reserveRoutingAttempt)(s, { obligationId: p.obligationId, lineageId: p.lineageId, envelope: p.envelope, fingerprint: p.fingerprint }, p.at ?? now());
+        Object.assign(s, reserved.state);
+        (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: reserved.attemptId });
+        return;
+    }
+    if (env.kind === 'routing-observe') {
+        const p = env.payload;
+        if (typeof p.attemptId !== 'string' || typeof p.nativeAgentId !== 'string' || (p.observed !== undefined && !(0, types_1.isRoutingSelection)(p.observed)) || (p.unavailableReason !== undefined && typeof p.unavailableReason !== 'string') || (p.at !== undefined && typeof p.at !== 'string'))
+            throw new Error('routing-observe requiere payload estricto');
+        const observed = (0, journal_1.observeRoutingAttempt)(s, { attemptId: p.attemptId, nativeAgentId: p.nativeAgentId, ...(p.observed === undefined ? {} : { observed: p.observed }), ...(p.unavailableReason === undefined ? {} : { unavailableReason: p.unavailableReason }) }, p.at ?? now());
+        Object.assign(s, observed);
+        (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: p.attemptId });
+        return;
+    }
     if (env.kind === 'job-request') {
         // get-or-create por idempotencyKey (RNF-T.7); duplicado => applyOutcome
         // registra el ALIAS con el mismo resultRef (Task 8).
@@ -449,11 +469,23 @@ function applyRequestToState(s, env, digest, repoRoot) {
         }
         if (!s.verdicts.some((v) => v.id === verdictId)) {
             const result = p.result;
+            if (p.routingAttemptId !== undefined) {
+                if (typeof p.routingAttemptId !== 'string')
+                    throw new Error('verdict routed requiere routingAttemptId valido');
+                const attempt = s.routingAttempts?.find(candidate => candidate.id === p.routingAttemptId);
+                if (!attempt || attempt.obligationId !== obligationId || attempt.state !== 'active')
+                    throw new Error('verdict routed requiere intento activo ligado a la obligacion');
+                attempt.state = result === 'pass' ? 'complete' : 'blocked';
+                attempt.verdict = result;
+                if (typeof p.reasonCode === 'string' && p.reasonCode.length > 0 && p.reasonCode.length <= 128)
+                    attempt.reasonCode = p.reasonCode;
+            }
             // R2.3: redaccion tambien en el `detail` de texto libre humano, no
             // solo en argv — antes de cualquier escritura durable.
             s.verdicts.push({
                 id: verdictId, obligationId, result, detail: (0, redact_1.redactText)(String(p.detail ?? '')), receivedAt: now(),
                 fingerprint: p.fingerprint, argv: verdictArgv, paths: verdictPaths, cwd: p.cwd,
+                ...(typeof p.routingAttemptId === 'string' ? { routingAttemptId: p.routingAttemptId } : {}),
             });
             for (const t of s.tasks) {
                 const o = t.reviewObligations.find((x) => x.id === obligationId);

package/dist/src/commands/watch/archive-unused.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchJournalStatus = watchJournalStatus;
+exports.archiveUnusedWatch = archiveUnusedWatch;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const types_1 = require("../../core/journal/types");
+const store_1 = require("../../core/journal/store");
+const paths_1 = require("../../core/journal/paths");
+const atomic_file_1 = require("../../core/atomic-file");
+const lock_1 = require("./lock");
+function controlledDirectory(directory) {
+    try {
+        const stat = fs_1.default.lstatSync(directory);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error(`unused bootstrap archive rejects unsafe directory: ${directory}`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+/** Read-only status of this branch, not directory-wide journal-first inference.
+ * A corrupt or linked tree is never reported as absence. No plan body, prompt,
+ * command argv or task/verdict content crosses this public observation. */
+function watchJournalStatus(repoRoot, branch) {
+    const file = (0, paths_1.statePath)(repoRoot, branch);
+    try {
+        for (const directory of [path_1.default.join(repoRoot, '.awm'), path_1.default.join(repoRoot, '.awm/journal'), (0, paths_1.journalDir)(repoRoot, branch)])
+            controlledDirectory(directory);
+        const stat = fs_1.default.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return { state: 'corrupt', bootstrapUnused: false };
+    }
+    catch (error) {
+        return { state: error.code === 'ENOENT' ? 'missing' : 'corrupt', bootstrapUnused: false };
+    }
+    const current = (0, store_1.readJournal)(repoRoot, branch);
+    if (current.corrupt || !current.state || current.state.branch !== branch)
+        return { state: 'corrupt', bootstrapUnused: false };
+    let bootstrapUnused = false;
+    try {
+        assertUnused(current.state);
+        assertUnusedTree(repoRoot, branch);
+        bootstrapUnused = true;
+    }
+    catch { /* recognized present journal, but never eligible by absence alone */ }
+    const binding = current.state.planBinding;
+    return {
+        state: 'present', cycleState: current.state.cycle.status, bootstrapUnused,
+        ...(binding ? { binding: { path: binding.path, digest: binding.digest, ...(binding.executionDigest ? { executionDigest: binding.executionDigest, executionIdentitySchema: binding.executionIdentitySchema } : {}), schema: binding.schema, executionMode: binding.executionMode, boundAt: binding.boundAt } } : {}),
+    };
+}
+/** Default-deny: only the exact unexecuted bootstrap shape is archivable.
+ * Future runtime fields automatically make this route ineligible. */
+function assertUnused(state) {
+    const initial = (0, types_1.emptyState)(state.branch);
+    const allowed = new Set([...Object.keys(initial), 'planBinding', 'planBindingHistory']);
+    const bootstrap = initial.cycle.nextAction;
+    if (state.schema !== 2 || !state.planBinding || state.cycle.status !== 'IN_PROGRESS'
+        || Object.keys(state).some(key => !allowed.has(key))
+        || Object.keys(state.cycle).some(key => !['status', 'startedAt', 'nextAction'].includes(key))
+        || JSON.stringify(state.cycle.nextAction) !== JSON.stringify(bootstrap)
+        || state.tasks.length !== 0 || state.cycleVerificationPlan.length !== 0
+        || state.generations.length !== 0 || state.dispatches.length !== 0
+        || Object.keys(state.jobs).length !== 0 || state.verdicts.length !== 0 || state.fixes.length !== 0
+        || Object.keys(state.appliedRequests).length !== 0 || state.requestProblems.length !== 0
+        || (state.custodyDecisions?.length ?? 0) !== 0) {
+        throw new Error('unused bootstrap requerido: el journal tiene ejecución, evidencia o estado no reconocido; no se archiva');
+    }
+}
+function assertUnusedTree(repoRoot, branch) {
+    const root = (0, paths_1.journalDir)(repoRoot, branch);
+    const emptyDirectories = new Set(['requests', 'acks', 'logs', 'export']);
+    for (const entry of fs_1.default.readdirSync(root, { withFileTypes: true })) {
+        const file = path_1.default.join(root, entry.name);
+        if (entry.isSymbolicLink())
+            throw new Error('unused bootstrap rejects symlink artifact');
+        if (entry.name === 'state.json' && entry.isFile())
+            continue;
+        if (emptyDirectories.has(entry.name) && entry.isDirectory() && fs_1.default.readdirSync(file).length === 0)
+            continue;
+        throw new Error(`unused bootstrap has runtime or unrecognized artifact: ${entry.name}`);
+    }
+}
+/** Remove ONLY an unused admission bootstrap from the active namespace by one
+ * recoverable rename. The archived state remains IN_PROGRESS, not COMPLETE;
+ * no task, verdict, cycle evidence, or claimed native execution is generated. */
+function archiveUnusedWatch(repoRoot, branch, planPath) {
+    const canonicalPlan = (0, paths_1.bindingPlanPath)(planPath);
+    const before = (0, store_1.readJournal)(repoRoot, branch);
+    if (before.corrupt || !before.state)
+        throw new Error('unused bootstrap journal inexistente, corrupto o inseguro');
+    const lockPath = (0, paths_1.supervisorLockPath)(repoRoot);
+    try {
+        if (fs_1.default.lstatSync(lockPath).isSymbolicLink())
+            throw new Error('unused bootstrap rejects symlink lock');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const archiveRoot = path_1.default.join(repoRoot, '.awm', 'journal-unused');
+    controlledDirectory(archiveRoot);
+    const lock = (0, lock_1.acquireLock)(repoRoot);
+    try {
+        (0, lock_1.verifyBranchInvariant)(repoRoot, branch);
+        const current = (0, store_1.readJournal)(repoRoot, branch);
+        if (current.corrupt || !current.state || current.state.branch !== branch)
+            throw new Error('unused bootstrap journal corrupto o de otra rama');
+        if (current.state.planBinding?.path !== canonicalPlan)
+            throw new Error('unused bootstrap requiere la misma ruta canónica del plan');
+        assertUnused(current.state);
+        assertUnusedTree(repoRoot, branch);
+        controlledDirectory(archiveRoot);
+        if (!fs_1.default.existsSync(archiveRoot))
+            fs_1.default.mkdirSync(archiveRoot, { mode: 0o700 });
+        controlledDirectory(archiveRoot);
+        (0, atomic_file_1.fsyncDirSync)(path_1.default.dirname(archiveRoot));
+        const source = (0, paths_1.journalDir)(repoRoot, branch);
+        const destination = path_1.default.join(archiveRoot, `${(0, paths_1.branchSlug)(branch)}.${crypto_1.default.randomUUID()}`);
+        if (fs_1.default.existsSync(destination))
+            throw new Error('unused bootstrap archive destination already exists');
+        // A single directory rename is the commit point; before it the source
+        // exists, after it the original byte-for-byte state is recoverable.
+        fs_1.default.renameSync(source, destination);
+        (0, atomic_file_1.fsyncDirSync)(archiveRoot);
+        (0, atomic_file_1.fsyncDirSync)(path_1.default.dirname(source));
+        return { archived: path_1.default.relative(repoRoot, destination).split(path_1.default.sep).join('/'), kind: 'unused-bootstrap', journalId: current.state.journalId };
+    }
+    finally {
+        (0, lock_1.releaseLock)(repoRoot, lock);
+    }
+}

package/dist/src/commands/watch/generations.js

@@ -88,22 +88,42 @@ function beginGeneration(repoRoot, branch) {
     return gen;
 }
 function promptForGeneration(gen) {
-    return `${gen.resumePrompt}\nGeneracion activa: ${gen.token}. Incluye --generation ${gen.token} en cada comando awm job.`;
+    if (!(0, types_1.isControllerRecoveryAction)(gen.resumeAction) || !/^[a-f0-9]{16}$/.test(gen.token))
+        throw new Error('recovery action invalida: no se persisten prompts libres');
+    const instructions = {
+        'resume-cycle': 'Retoma el plan del ciclo desde el journal.',
+        'resume-next-action': 'Retoma el next_action vigente del journal.',
+        'reconcile-active-jobs': 'Reconcilia los jobs activos existentes del journal sin duplicarlos.',
+    };
+    return `${instructions[gen.resumeAction.kind]}\nGeneracion activa: ${gen.token}. Incluye --generation ${gen.token} en cada comando awm job.`;
+}
+function recoveryAction(action) {
+    if (!(0, types_1.isControllerRecoveryAction)(action))
+        throw new Error('recovery action invalida: no se persisten prompts libres');
+    return { schema: action.schema, kind: action.kind };
 }
 /** Persiste el intent completo ANTES de delegarlo al wrapper. El wrapper usa
  * claim exclusivo por (controllerJobId, spawnNonce), por lo que reemitir este
  * mismo intent tras un crash nunca lanza dos controllers. */
-function launchControllerGeneration(repoRoot, branch, provider, resumePrompt, spawner = (0, runner_1.defaultWrapperSpawner)()) {
+function launchControllerGeneration(repoRoot, branch, provider, action, spawner = (0, runner_1.defaultWrapperSpawner)()) {
+    const requestedAction = recoveryAction(action);
     const s = requireState(repoRoot, branch);
     const gen = activeGeneration(s);
     if (gen === undefined)
         throw new Error('no hay generacion activa para lanzar');
+    if (gen.resumePrompt !== undefined)
+        throw new Error('generacion legacy con prompt: decision explicita requerida; no se reemite');
+    const adapter = (0, adapter_1.adapterFor)(gen.provider ?? provider);
     gen.controllerJobId = gen.controllerJobId ?? `controller-gen-${gen.n}`;
     gen.spawnNonce = gen.spawnNonce ?? crypto_1.default.randomBytes(8).toString('hex');
     gen.provider = gen.provider ?? provider;
-    gen.resumePrompt = gen.resumePrompt ?? resumePrompt;
+    gen.resumeAction = gen.resumeAction ?? requestedAction;
+    const argv = adapter.launchArgv(promptForGeneration(gen));
+    const digest = (0, process_1.argvDigest)(argv);
+    if (gen.launchArgvDigest !== undefined && gen.launchArgvDigest !== digest)
+        throw new Error('controller argv cambio: no se reemite el mismo nonce con otro comando');
+    gen.launchArgvDigest = digest;
     (0, store_1.writeJournal)(repoRoot, branch, s);
-    const argv = (0, adapter_1.adapterFor)(gen.provider).launchArgv(promptForGeneration(gen));
     const job = {
         id: gen.controllerJobId, fingerprint: `generation:${gen.token}`, commandDigest: `generation:${gen.token}`,
         argv, cwd: '.', paths: [], expandedPaths: [], executionState: 'spawn-intent',
@@ -140,8 +160,8 @@ function collectControllerGeneration(repoRoot, branch) {
     if (identity.jobId !== gen.controllerJobId || identity.nonce !== gen.spawnNonce
         || !(0, types_1.isWellFormedProcessRef)(identity.wrapper) || !(0, types_1.isWellFormedProcessRef)(identity.command)
         || identity.wrapper.spawnNonce !== gen.spawnNonce || identity.command.spawnNonce !== gen.spawnNonce
-        || gen.provider === undefined || gen.resumePrompt === undefined
-        || identity.command.argvDigest !== (0, process_1.argvDigest)((0, adapter_1.adapterFor)(gen.provider).launchArgv(promptForGeneration(gen))))
+        || gen.provider === undefined || gen.resumePrompt !== undefined || !(0, types_1.isControllerRecoveryAction)(gen.resumeAction)
+        || gen.launchArgvDigest === undefined || identity.command.argvDigest !== gen.launchArgvDigest)
         return false;
     const changed = gen.wrapperRef?.pid !== identity.wrapper.pid || gen.processRef?.pid !== identity.command.pid;
     gen.wrapperRef = identity.wrapper;
@@ -162,16 +182,19 @@ function controllerGenerationHasUnresolvedClaim(repoRoot, branch, gen) {
 /** Recupera tanto crash-before-spawn como crash-after-spawn-before-journal.
  * Claim sin identidad queda ambiguo y se conserva bajo custodia tras la gracia;
  * nunca se resuelve lanzando otro token/nonce a ciegas. */
-function ensureControllerGeneration(repoRoot, branch, provider, resumePrompt, spawner, ambiguityGraceMs) {
+function ensureControllerGeneration(repoRoot, branch, provider, action, spawner, ambiguityGraceMs) {
+    const requestedAction = recoveryAction(action);
     if (collectControllerGeneration(repoRoot, branch))
         return;
     let gen = activeGeneration(requireState(repoRoot, branch));
     if (gen === undefined)
         return;
+    if (gen.resumePrompt !== undefined)
+        throw new Error('generacion legacy con prompt: decision explicita requerida; no se reemite');
     if (gen.processRef !== undefined || gen.wrapperRef !== undefined)
         return;
     if (gen.controllerJobId === undefined || gen.spawnNonce === undefined) {
-        launchControllerGeneration(repoRoot, branch, provider, resumePrompt, spawner);
+        launchControllerGeneration(repoRoot, branch, provider, requestedAction, spawner);
         return;
     }
     const logs = (0, paths_1.logsDir)(repoRoot, branch);
@@ -194,7 +217,7 @@ function ensureControllerGeneration(repoRoot, branch, provider, resumePrompt, sp
     // El intent ya estaba durable pero el spawn no ocurrio: es seguro reemitir
     // exactamente el mismo nonce. Si el wrapper original solo estaba demorado,
     // su claim wx arbitra cual de ambos ejecuta.
-    launchControllerGeneration(repoRoot, branch, gen.provider ?? provider, gen.resumePrompt ?? resumePrompt, spawner);
+    launchControllerGeneration(repoRoot, branch, gen.provider ?? provider, gen.resumeAction ?? requestedAction, spawner);
 }
 /** Custodia (R4.5): ciclo BLOCKED con razon auditada. QUIEN NO HACE NADA:
  *  no mata, no relanza, no libera lock — el loop sigue vivo auditando. */

package/dist/src/commands/watch/index.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerWatchCommand = registerWatchCommand;
 const child_process_1 = require("child_process");
@@ -8,6 +11,11 @@ const process_1 = require("../../core/journal/process");
 const adapter_1 = require("../../core/journal/adapter");
 const context_1 = require("../../core/tracks/context");
 const concurrency_1 = require("../../core/tracks/concurrency");
+const validate_1 = require("../../core/plan/validate");
+const path_1 = __importDefault(require("path"));
+const archive_unused_1 = require("./archive-unused");
+const store_1 = require("../../core/journal/store");
+const fingerprint_1 = require("../../core/journal/fingerprint");
 function currentBranch(cwd) {
     // stdio explicito (ver EXEC_STDIO en journal/process.ts): evita el relay
     // default de execFileSync del stderr de git hacia el stderr del llamante,
@@ -23,11 +31,19 @@ function minutes(flag, raw) {
         throw new Error(`${flag} requiere un numero de minutos > 0`);
     return n * 60000;
 }
+function validPlanPath(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 4096 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
+}
+function planForBinding(repo, rawPath) {
+    const report = (0, validate_1.validatePlanFile)(rawPath, repo);
+    return { path: path_1.default.relative(repo, path_1.default.resolve(repo, rawPath)).replace(/\\/g, '/'), report };
+}
 function registerWatchCommand(program) {
-    program
+    const watch = program
         .command('watch')
         .description('supervisor durable: ejecuta jobs, releva controladores caidos, nunca mata trabajo vivo')
         .option('--init', 'bootstrap: crea el journal de la rama actual, detecta verificadores y sale')
+        .option('--plan <path>', 'plan compacto desatendido que se vincula al inicializar')
         .option('--provider <p>', adapter_1.WATCH_PROVIDERS.join(' | '), 'codex')
         .option('--heartbeat-timeout <min>', 'minutos de silencio de heartbeat', '5')
         .option('--activity-window <min>', 'minutos extra sin actividad de proceso', '10')
@@ -45,8 +61,24 @@ function registerWatchCommand(program) {
             process.stderr.write(`${e.message}\n`);
             process.exit(1);
         }
+        if (opts.plan !== undefined && !opts.init) {
+            process.stderr.write('--plan requiere --init\n');
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.init && opts.plan === undefined) {
+            process.stderr.write('watch --init requiere --plan con un plan compacto válido\n');
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.plan !== undefined && !validPlanPath(opts.plan)) {
+            process.stderr.write('--plan requiere un path sin caracteres de control\n');
+            process.exitCode = 1;
+            return;
+        }
         if (opts.init) {
-            const out = (0, init_1.initWatch)(repo, branch);
+            const plan = opts.plan === undefined ? undefined : planForBinding(repo, opts.plan);
+            const out = (0, init_1.initWatch)(repo, branch, plan);
             process.stdout.write(`journal inicializado para ${branch}; verificadores requeridos: ${JSON.stringify(out.requiredVerifiers)}\n`);
             return;
         }
@@ -70,4 +102,78 @@ function registerWatchCommand(program) {
         await (0, supervisor_1.runSupervisorLoop)(repo, branch, cfg);
         process.stdout.write('gate verde: ciclo COMPLETE — drenado, lock liberado, apagando\n');
     });
+    watch
+        .command('rebind')
+        .description('reconcilia intencionalmente el binding desatendido tras un cambio válido del ciclo del plan')
+        // `watch` conserva su --plan histórico para `watch --init --plan`.
+        // Commander lo asocia al padre incluso después del subcomando, por lo
+        // que este option es documental y la acción toma el valor del padre
+        // cuando corresponde; marcarlo required acá rechazaría una invocación
+        // válida antes de llegar a esa reconciliación explícita.
+        .option('--plan <path>', 'mismo plan compacto previamente vinculado; valida y conserva la historia antes de actualizar su digest')
+        .action((opts, command) => {
+        const repo = process.cwd();
+        const branch = currentBranch(repo);
+        try {
+            (0, context_1.resolveCommandContext)(repo, branch);
+        }
+        catch (e) {
+            process.stderr.write(`${e.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const plan = opts.plan ?? command.parent?.opts().plan;
+        if (!validPlanPath(plan)) {
+            process.stderr.write('--plan requiere un path sin caracteres de control\n');
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const binding = (0, init_1.rebindWatchPlan)(repo, branch, planForBinding(repo, plan));
+            process.stdout.write(`binding reconciliado para ${binding.path}; digest ${binding.digest}\n`);
+            const state = (0, store_1.readJournal)(repo, branch).state;
+            const staleJobs = Object.values(state.jobs).filter(job => job.verdict === 'pass' && (() => {
+                try {
+                    return (0, fingerprint_1.computeFingerprint)(repo, job.argv, job.paths, job.cwd).fingerprint !== job.fingerprint;
+                }
+                catch {
+                    return true;
+                }
+            })()).map(job => job.id);
+            if (staleJobs.length > 0) {
+                process.stdout.write(`stale-fingerprint: ${staleJobs.join(', ')}; el rebind no conserva PASS con fingerprint cambiado. Re-ejecutar las verificaciones afectadas mediante awm job request con generation, paths y satisfies originales; no repetir watch/rebind ni re-fingerprinting de evidencia anterior.\n`);
+            }
+        }
+        catch (e) {
+            process.stderr.write(`${e.message}\n`);
+            process.exitCode = 1;
+        }
+    });
+    watch.command('archive-unused')
+        .description('archiva recuperablemente solo un bootstrap no utilizado; nunca declara COMPLETE ni crea evidencia de ejecución')
+        .option('--plan <path>', 'mismo plan vinculado al bootstrap; no adopta evidencia de trabajo manual')
+        .action((opts, command) => {
+        const repo = process.cwd();
+        const branch = currentBranch(repo);
+        try {
+            (0, context_1.resolveCommandContext)(repo, branch);
+            const plan = opts.plan ?? command.parent?.opts().plan;
+            if (!validPlanPath(plan))
+                throw new Error('--plan requiere un path sin caracteres de control');
+            const relative = path_1.default.relative(repo, path_1.default.resolve(repo, plan)).replace(/\\/g, '/');
+            process.stdout.write(`${JSON.stringify((0, archive_unused_1.archiveUnusedWatch)(repo, branch, relative))}\n`);
+        }
+        catch (error) {
+            process.stderr.write(`${error.message}\n`);
+            process.exitCode = 1;
+        }
+    });
+    watch.command('journal-status')
+        .description('consulta read-only el journal de la rama actual: missing | corrupt | present; no exporta contenido')
+        .option('--json', 'estado estructural y metadata de binding, sin cuerpos ni evidencia inferida')
+        .action(() => {
+        const repo = process.cwd();
+        const branch = currentBranch(repo);
+        process.stdout.write(`${JSON.stringify((0, archive_unused_1.watchJournalStatus)(repo, branch))}\n`);
+    });
 }