agentic-workflow-manager 9.7.0 → 9.8.0

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`);
+    });
 }

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

@@ -6,40 +6,78 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectRequiredVerifiers = detectRequiredVerifiers;
 exports.ensureJournalGitignored = ensureJournalGitignored;
 exports.initWatch = initWatch;
+exports.rebindWatchPlan = rebindWatchPlan;
 // Bootstrap unico writer (R4.1) + validacion MECANICA plan-vs-repo (R1.4b,
 // bloqueador 5): la config real del repo determina los verificadores exigidos.
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const store_1 = require("../../core/journal/store");
+const paths_1 = require("../../core/journal/paths");
+const lock_1 = require("./lock");
+const validate_1 = require("../../core/plan/validate");
+const identity_1 = require("../../core/plan/identity");
+const native_bridge_1 = require("../../core/secure-fs/native-bridge");
+const MAX_VERIFIER_SCAN_DEPTH = 64;
+const MAX_VERIFIER_SCAN_ENTRIES = 10000;
+const MAX_PACKAGE_JSON_BYTES = 256 * 1024;
+const MAX_SENSORS_JSON_BYTES = 256 * 1024;
 function detectRequiredVerifiers(repoRoot) {
     const kinds = new Set();
-    const visit = (dir) => {
+    let visitedEntries = 0;
+    const visit = (dir, depth) => {
+        if (depth > MAX_VERIFIER_SCAN_DEPTH)
+            throw new Error('verifier scan depth limit exceeded');
         const sensors = path_1.default.join(dir, '.awm', 'sensors.json');
-        if (fs_1.default.existsSync(sensors))
-            kinds.add('sensors');
+        let sensorsPresent = false;
+        try {
+            fs_1.default.lstatSync(sensors);
+            sensorsPresent = true;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw new Error('verifier scan rejected sensors.json: unreadable path');
+        }
+        if (sensorsPresent) {
+            try {
+                const bytes = native_bridge_1.secureFs.readRegularFile(path_1.default.resolve(sensors), MAX_SENSORS_JSON_BYTES).bytes;
+                const config = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+                if (!config || typeof config !== 'object' || Array.isArray(config))
+                    throw new Error('sensors config must be a JSON object');
+                kinds.add('sensors');
+            }
+            catch (error) {
+                throw new Error(`verifier scan rejected sensors.json: ${error.message}`);
+            }
+        }
         let entries;
         try {
             entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
         }
-        catch {
-            return;
+        catch (error) {
+            throw new Error(`verifier scan cannot read ${dir}: ${error.message}`);
         }
         for (const entry of entries) {
-            if (entry.isSymbolicLink())
-                continue;
-            if (entry.isFile() && entry.name === 'package.json') {
+            if (++visitedEntries > MAX_VERIFIER_SCAN_ENTRIES)
+                throw new Error('verifier scan entry limit exceeded');
+            if (entry.name === 'package.json') {
                 try {
-                    const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, entry.name), 'utf8'));
+                    const packagePath = path_1.default.join(dir, entry.name);
+                    const bytes = native_bridge_1.secureFs.readRegularFile(path_1.default.resolve(packagePath), MAX_PACKAGE_JSON_BYTES).bytes;
+                    const pkg = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
                     if (typeof pkg === 'object' && pkg !== null && typeof pkg.scripts === 'object' && pkg.scripts !== null && typeof pkg.scripts.test === 'string')
                         kinds.add('test');
                 }
-                catch { /* package ilegible: no prueba disponibilidad */ }
+                catch (error) {
+                    throw new Error(`verifier scan rejected package.json: ${error.message}`);
+                }
             }
+            if (entry.isSymbolicLink())
+                continue;
             if (entry.isDirectory() && !['node_modules', '.git', '.awm'].includes(entry.name))
-                visit(path_1.default.join(dir, entry.name));
+                visit(path_1.default.join(dir, entry.name), depth + 1);
         }
     };
-    visit(repoRoot);
+    visit(repoRoot, 0);
     return ['test', 'sensors'].filter((kind) => kinds.has(kind));
 }
 /** El journal es gitignoreado (R1.1): sus escrituras jamas alteran fingerprints. */
@@ -47,19 +85,65 @@ function ensureJournalGitignored(repoRoot) {
     const gi = path_1.default.join(repoRoot, '.gitignore');
     let current = '';
     try {
+        if (fs_1.default.lstatSync(gi).isSymbolicLink())
+            throw new Error('.gitignore must not be a symlink');
         current = fs_1.default.readFileSync(gi, 'utf8');
     }
-    catch {
-        current = '';
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
     }
     if (!current.split('\n').some((l) => l.trim() === '.awm/' || l.trim() === '.awm')) {
         fs_1.default.writeFileSync(gi, current.length > 0 && !current.endsWith('\n') ? `${current}\n.awm/\n` : `${current}.awm/\n`);
     }
 }
-function initWatch(repoRoot, branch) {
-    ensureJournalGitignored(repoRoot);
-    (0, store_1.initJournal)(repoRoot, branch);
+const TERMINAL_JOB_STATES = new Set(['exited', 'cancelled']);
+function rebindBlocker(state) {
+    if (state === null)
+        return 'journal inexistente o corrupto';
+    const nonterminal = Object.values(state.jobs).filter(job => !TERMINAL_JOB_STATES.has(job.executionState));
+    if (nonterminal.length > 0)
+        return `hay jobs no terminales: ${nonterminal.map(job => job.id).join(', ')}`;
+    if (state.requestProblems.length > 0)
+        return 'hay conflictos durables de requests';
+    if (state.verdicts.some(verdict => verdict.result !== 'pass'))
+        return 'hay evidencia adversa durable';
+    if (state.fixes.some(fix => !fix.closed))
+        return 'hay fixes abiertos';
+    if (state.cycle.status === 'BLOCKED')
+        return 'el ciclo está bloqueado';
+    if (state.tracks?.some(track => track.phase !== 'REMOVED'))
+        return 'hay tracks no terminales';
+    return undefined;
+}
+function initWatch(repoRoot, branch, plan) {
+    if (plan) {
+        if (plan.report.state !== 'valid')
+            throw new Error('watch --init --plan requiere un plan compacto válido');
+        if (plan.report.executionMode !== 'desatendido')
+            throw new Error('watch --init --plan requiere un plan compacto desatendido');
+        if (plan.report.executionDigest)
+            (0, validate_1.verifiedPlanSnapshot)(plan.report);
+    }
+    if (plan && fs_1.default.existsSync((0, paths_1.statePath)(repoRoot, branch))) {
+        throw new Error('refusing to overwrite existing journal');
+    }
+    let planBinding;
+    if (plan) {
+        const report = plan.report;
+        planBinding = {
+            path: (0, paths_1.bindingPlanPath)(plan.path), digest: report.planDigest, schema: report.schema,
+            ...(report.executionDigest ? { executionDigest: report.executionDigest, executionIdentitySchema: identity_1.EXECUTION_IDENTITY_SCHEMA } : {}),
+            executionMode: 'desatendido', boundAt: new Date().toISOString(),
+        };
+    }
     const required = detectRequiredVerifiers(repoRoot);
+    (0, store_1.assertJournalInitPaths)(repoRoot, branch);
+    ensureJournalGitignored(repoRoot);
+    if (planBinding)
+        (0, store_1.initBoundJournal)(repoRoot, branch, planBinding, plan.report);
+    else
+        (0, store_1.initJournal)(repoRoot, branch);
     const r = (0, store_1.readJournal)(repoRoot, branch);
     if (r.corrupt || r.state === null)
         throw new Error('journal corrupto tras init: no se continua (R1.6)');
@@ -68,5 +152,52 @@ function initWatch(repoRoot, branch) {
         s.requiredVerifiers = required;
         (0, store_1.writeJournal)(repoRoot, branch, s);
     }
-    return { requiredVerifiers: required };
+    return { requiredVerifiers: required, ...(planBinding ? { planBinding } : {}) };
+}
+/**
+ * Intentional recovery route for a valid compact plan whose lifecycle update
+ * changed its digest.  It cannot initialize or overwrite a journal: only an
+ * existing schema-2 unattended binding for the exact canonical plan path is
+ * eligible, and all outstanding work/evidence conflicts fail closed.
+ */
+function rebindWatchPlan(repoRoot, branch, plan) {
+    if (plan.report.state !== 'valid')
+        throw new Error('watch rebind --plan requiere un plan compacto válido');
+    // The same exclusive lock used by the supervisor closes the interval
+    // between observing quiescence and publishing the recovered binding.
+    const lock = (0, lock_1.acquireLock)(repoRoot);
+    try {
+        const current = (0, store_1.readJournal)(repoRoot, branch);
+        if (current.corrupt || current.state === null || current.state.schema !== 2 || !current.state.planBinding) {
+            throw new Error('no existe un journal schema-2 desatendido para reconciliar');
+        }
+        const existing = current.state.planBinding;
+        const canonicalPath = (0, paths_1.bindingPlanPath)(plan.path);
+        if (existing.executionMode !== 'desatendido')
+            throw new Error('solo se reconcilia un binding desatendido');
+        if (existing.path !== canonicalPath)
+            throw new Error('rebind requiere la misma ruta canónica del plan');
+        if (existing.digest === plan.report.planDigest && existing.schema === plan.report.schema)
+            throw new Error('el binding ya está vigente');
+        const blocker = rebindBlocker(current.state);
+        if (blocker)
+            throw new Error(`rebind rechazado: ${blocker}`);
+        const report = plan.report;
+        if (!existing.executionDigest || existing.executionIdentitySchema !== identity_1.EXECUTION_IDENTITY_SCHEMA || !report.executionDigest)
+            throw new Error('rebind rechazado: ciclo en curso o histórico sin prueba de identidad de ejecución');
+        (0, validate_1.verifiedPlanSnapshot)(report);
+        if (report.executionDigest !== existing.executionDigest || report.executionMode !== existing.executionMode || report.schema !== existing.schema)
+            throw new Error('rebind rechazado: cambiaron requisitos o contenido de ejecución; la evidencia anterior no se conserva');
+        const binding = {
+            path: canonicalPath, digest: report.planDigest, schema: report.schema,
+            executionDigest: report.executionDigest,
+            executionIdentitySchema: identity_1.EXECUTION_IDENTITY_SCHEMA,
+            executionMode: 'desatendido', boundAt: new Date().toISOString(),
+        };
+        (0, store_1.rebindJournalPlan)(repoRoot, branch, binding, report);
+        return binding;
+    }
+    finally {
+        (0, lock_1.releaseLock)(repoRoot, lock);
+    }
 }