agentic-workflow-manager 9.6.0 → 9.7.0

package/README.md

@@ -69,6 +69,8 @@ and one JSON argv integration command. Start or resume with `awm watch`; inspect
 `awm track status`. Track workers commit only their assigned files and request
 `awm track join`. The plan supervisor freezes and merges tracks, runs global QA once on the
 final HEAD, executes the canonical integration job once, then applies the interlock.
+`awm track remove` requests a safe cancellation of the complete cohort; only demonstrably
+owned resources are removed before returning to serial execution.
 
 Any missing declaration, overlap, global file class, unavailable worktree, or failed
 preparation degrades to serial with an event naming the cause. `BLOCKED` means ownership or

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

@@ -15,7 +15,9 @@ function runContextOrchestrators(collected, opts) {
         // un usuario que tipee el nombre declarado exacto (con un caracter que el saneo
         // quita, p.ej. `_` o un byte de control) se lleva un falso "not composed" (R3.5/R3.6).
         const verifyNormalized = (0, text_1.sanitizeDeclaredField)(opts.verify);
-        const found = composed.some((o) => o.name === verifyNormalized);
+        // A dropped raw identity must not borrow a retained declaration's sanitized name.
+        const found = !collected.droppedNames.includes(opts.verify)
+            && composed.some((o) => o.name === verifyNormalized);
         if (!found) {
             const available = composed.map((o) => o.name).join(', ') || '(none)';
             return {

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

@@ -104,14 +104,10 @@ function registerTrackCommand(program) {
         }
         process.stdout.write(JSON.stringify({ requestId: r.requestId, idempotencyKey: r.idempotencyKey, qaHeadSha: r.qaHeadSha }, null, 2) + '\n');
     });
-    // NO IMPLEMENTADO del lado del supervisor: no hay handler para `track-teardown-request`,
-    // así que la request se emite y el supervisor la RECHAZA (`request-rejected-invalid`).
-    // La descripción lo dice en vez de prometer un desmantelamiento que no ocurre — hasta
-    // este release afirmaba que el supervisor desmantelaba worktree/rama, y no lo hacía.
-    // El teardown que sí funciona es el automático de la degradación a serial
-    // (`begin-teardown` desde `FALLBACK_PENDING`), que no pasa por este verbo.
+    // Request-only: el supervisor persiste la intención, cancela la cohorte completa y
+    // reutiliza el teardown fail-closed antes de volver a ejecución serial.
     track.command('remove')
-        .description('NO IMPLEMENTADO: emite track-teardown-request, que el supervisor todavía no sabe aplicar y rechaza')
+        .description('emite track-teardown-request — cancela la cohorte y solicita teardown seguro antes del fallback serial')
         .requiredOption('--generation <token>', 'token de la generacion vigente')
         .argument('<trackId>')
         .action((trackId, opts) => {

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

@@ -250,6 +250,21 @@ function applyRequestToState(s, env, digest, repoRoot) {
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: trackId });
         return;
     }
+    if (env.kind === 'track-teardown-request') {
+        const p = env.payload;
+        if (typeof p.trackId !== 'string' || p.trackId.length === 0)
+            throw new Error('track-teardown-request requiere trackId');
+        const trackId = p.trackId;
+        const ref = s.tracks?.find((t) => t.trackId === trackId);
+        if (ref === undefined)
+            throw new Error(`track-teardown-request: track desconocido: ${trackId}`);
+        if (s.tracks === undefined || s.tracks.length < 2 || s.cohortPhase === undefined) {
+            throw new Error('track-teardown-request requiere una cohorte válida de al menos dos tracks');
+        }
+        ref.teardownRequested = true;
+        (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: trackId });
+        return;
+    }
     if (env.kind === 'track-freeze-request') {
         // R5.2/R6.3 (Task 10): request administrativa CROSS-JOURNAL — el
         // supervisor del PLAN la emite directamente al `requestsDir` de ESTE

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

@@ -135,13 +135,22 @@ function applyProtocolToState(state, protocol) {
     // `expectedPlanHeadSha` incorrecto.
     if (protocol.planHeadSha !== undefined)
         next.cohortPlanHeadSha = protocol.planHeadSha;
-    // R7/C3 (Task 12): mismo criterio que `cohortPlanHeadSha` arriba — valores
-    // que solo avanzan (nunca retroceden a `undefined` una vez fijados por
-    // `reconcileProtocol`).
-    if (protocol.globalQaHeadSha !== undefined)
-        next.globalQaHeadSha = protocol.globalQaHeadSha;
-    if (protocol.finalIntegrationJobId !== undefined)
-        next.finalIntegrationJobId = protocol.finalIntegrationJobId;
+    // R7/C3 (Task 12): los valores finales normalmente solo avanzan, salvo
+    // que fallback abandone explícitamente esa ruta. En ese caso el reducer
+    // ya invalidó su evidencia y el mirror durable DEBE borrarla también;
+    // conservarla permitiría que un restart reconstruyera un protocolo que
+    // contradice los tracks en teardown.
+    if (protocol.cohortPhase === 'FALLBACK_PENDING') {
+        next.globalQaHeadSha = undefined;
+        next.finalIntegrationJobId = undefined;
+        next.qaFinalizeRequested = undefined;
+    }
+    else {
+        if (protocol.globalQaHeadSha !== undefined)
+            next.globalQaHeadSha = protocol.globalQaHeadSha;
+        if (protocol.finalIntegrationJobId !== undefined)
+            next.finalIntegrationJobId = protocol.finalIntegrationJobId;
+    }
     if (protocol.fallbackReason !== undefined)
         next.cohortFallbackReason = protocol.fallbackReason;
     next.tracks = (next.tracks ?? []).map((ref) => {
@@ -818,6 +827,46 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
         if (s.tracks === undefined || s.tracks.length < 2 || s.cohortPhase === undefined) {
             return { state: s, effectExecuted: null };
         }
+        // La request de teardown se consume en dos pasos durables, igual que
+        // join: `apply.ts` solo deja el marcador y este reconciler traduce la
+        // intención al reducer. BLOCKED, SERIAL y COMPLETE no admiten nueva
+        // transición: limpiar únicamente el marcador preserva el estado seguro.
+        const pendingTeardown = (s.tracks ?? []).find((track) => track.teardownRequested === true);
+        if (pendingTeardown !== undefined) {
+            const moot = ['BLOCKED', 'SERIAL', 'COMPLETE'].includes(s.cohortPhase);
+            if (moot) {
+                const next = structuredClone(s);
+                for (const track of next.tracks ?? [])
+                    if (track.trackId === pendingTeardown.trackId)
+                        track.teardownRequested = undefined;
+                s = persist(planRoot, branch, next);
+                (0, store_1.appendEvent)(planRoot, branch, {
+                    kind: 'track-teardown-moot', trackId: pendingTeardown.trackId, phase: s.cohortPhase,
+                });
+                return { state: s, effectExecuted: null };
+            }
+            const protocolBefore = toProtocol(s, maxParallel);
+            const observed = (0, protocol_1.reconcileProtocol)(protocolBefore, { kind: 'teardown-requested', trackId: pendingTeardown.trackId });
+            const next = applyProtocolToState(s, observed);
+            for (const track of next.tracks ?? [])
+                if (track.trackId === pendingTeardown.trackId)
+                    track.teardownRequested = undefined;
+            s = persist(planRoot, branch, next);
+            // El lock pertenece al proceso vivo que alcanzó la integración.
+            // Al abandonar FINAL_INTERLOCK debe soltarse en este mismo proceso;
+            // tras un crash el lease muerto se reclama por identidad al iniciar.
+            if (protocolBefore.cohortPhase === 'FINAL_INTERLOCK' && s.cohortPhase === 'FALLBACK_PENDING') {
+                runtime.releaseIntegrationLockIfHeld();
+            }
+            (0, store_1.appendEvent)(planRoot, branch, {
+                kind: 'track-teardown-observed', trackId: pendingTeardown.trackId,
+                phase: s.tracks?.find((t) => t.trackId === pendingTeardown.trackId)?.phase,
+            });
+            // El marcador es una frontera durable por sí mismo. No se consume
+            // otro marcador ni se entra a begin-teardown hasta la siguiente
+            // llamada, para que un crash conserve el resto de las requests.
+            return { state: s, effectExecuted: null };
+        }
         // El pedido de join del controller (`joinRequested`, marcado declarativamente al
         // consumir `track-join-request`) se convierte ACÁ en la observación que el reducer
         // entiende. La regla de si eso mueve la fase vive en `reconcileProtocol` (solo

package/dist/src/core/discovery.js

@@ -34,6 +34,73 @@ function readArtifactDescription(filePath) {
         return '';
     }
 }
+function inspectSkillDirectory(parent, expected) {
+    const stat = fs_1.default.lstatSync(parent, { bigint: true });
+    if (stat.isSymbolicLink())
+        throw new Error(`${parent}: must not be a symbolic link`);
+    if (!stat.isDirectory())
+        throw new Error(`${parent}: must be a directory`);
+    if (typeof stat.dev !== 'bigint' || typeof stat.ino !== 'bigint' || stat.dev < 0n || stat.ino <= 0n) {
+        throw new Error(`${parent}: directory identity is unobservable`);
+    }
+    if (expected && (stat.dev !== expected.dev || stat.ino !== expected.ino)) {
+        throw new Error(`${parent}: directory identity changed after inspection`);
+    }
+    return stat;
+}
+/** CTX-CONSTITUTION-052: bind the inspected leaf to its observable parent chain. */
+function readSkillDescription(file) {
+    const absolute = path_1.default.resolve(file);
+    const parents = [];
+    for (let parent = path_1.default.dirname(absolute);; parent = path_1.default.dirname(parent)) {
+        parents.unshift(parent);
+        if (parent === path_1.default.dirname(parent))
+            break;
+    }
+    const inspectedParents = parents.map(parent => ({ path: parent, stat: inspectSkillDirectory(parent) }));
+    const validateParents = () => {
+        for (const parent of inspectedParents)
+            inspectSkillDirectory(parent.path, parent.stat);
+    };
+    let inspected;
+    try {
+        inspected = fs_1.default.lstatSync(file, { bigint: true });
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    // A parent swapped before leaf lstat must not establish a new trusted identity.
+    validateParents();
+    if (inspected.isSymbolicLink())
+        throw new Error('must not be a symbolic link');
+    if (!inspected.isFile())
+        throw new Error('must be a regular file');
+    if (typeof inspected.dev !== 'bigint' || typeof inspected.ino !== 'bigint'
+        || typeof inspected.size !== 'bigint' || inspected.dev < 0n
+        || inspected.ino <= 0n || inspected.size < 0n) {
+        throw new Error('file identity or size is unobservable');
+    }
+    const flags = fs_1.default.constants.O_RDONLY | (fs_1.default.constants.O_NOFOLLOW ?? 0) | (fs_1.default.constants.O_NONBLOCK ?? 0);
+    const fd = fs_1.default.openSync(file, flags);
+    try {
+        const opened = fs_1.default.fstatSync(fd, { bigint: true });
+        if (!opened.isFile())
+            throw new Error('must be a regular file');
+        if (opened.dev !== inspected.dev || opened.ino !== inspected.ino || opened.size !== inspected.size) {
+            throw new Error('file identity or size changed after inspection');
+        }
+        // Reject substitutions observable after open, while retaining descriptor authority.
+        validateParents();
+        const raw = fs_1.default.readFileSync(fd, 'utf-8');
+        const frontmatter = (0, frontmatter_2.matchFrontmatterBlock)(raw);
+        return frontmatter === null ? '' : (0, frontmatter_2.readFrontmatterDescription)(frontmatter);
+    }
+    finally {
+        fs_1.default.closeSync(fd);
+    }
+}
 function collisionError(kind, name, first, second) {
     return new Error(`Artifact name collision: ${kind} "${name}" exists in both ${first} and ${second}. ` +
         `Remove or rename one of them, or declare "${name}" in "overrides" of the later registry's awm-registry.json.`);
@@ -54,7 +121,7 @@ function mergeEntry(kind, byName, entry, rootOverrides) {
 }
 /**
  * Scans skills directories across all provided content roots and returns all valid skills.
- * A valid skill is a directory that contains a SKILL.md file.
+ * A valid skill is a directory that contains a regular, non-symlink SKILL.md file.
  * Throws on name collision across roots unless the later root declares the name in its awm-registry.json overrides.
  */
 function discoverSkills(roots = (0, registries_1.contentRoots)()) {
@@ -68,12 +135,20 @@ function discoverSkills(roots = (0, registries_1.contentRoots)()) {
             if (!entry.isDirectory())
                 continue;
             const skillPath = path_1.default.join(dir, entry.name);
-            if (!fs_1.default.existsSync(path_1.default.join(skillPath, 'SKILL.md')))
-                continue;
+            const skillFile = path_1.default.join(skillPath, 'SKILL.md');
+            let description;
+            try {
+                description = readSkillDescription(skillFile);
+                if (description === null)
+                    continue;
+            }
+            catch (e) {
+                throw new Error(`${skillFile}: cannot read (${e instanceof Error ? e.message : String(e)})`);
+            }
             mergeEntry('skill', byName, {
                 name: entry.name,
                 path: skillPath,
-                description: readArtifactDescription(path_1.default.join(skillPath, 'SKILL.md')),
+                description,
             }, overrides);
         }
     }

package/dist/src/core/journal/types.js

@@ -246,6 +246,7 @@ function isWellFormedTrackRef(x) {
         && (x.supervisorProcessRef === undefined || isWellFormedProcessRef(x.supervisorProcessRef))
         && (x.joinIntent === undefined || isWellFormedJoinIntent(x.joinIntent))
         && (x.teardownIntent === undefined || isWellFormedTeardownIntent(x.teardownIntent))
+        && (x.teardownRequested === undefined || typeof x.teardownRequested === 'boolean')
         && (x.joinedCommitSha === undefined || typeof x.joinedCommitSha === 'string')
         && (x.blockedReason === undefined || typeof x.blockedReason === 'string');
 }

package/dist/src/core/orchestrators.js

@@ -17,6 +17,7 @@ exports.collectAndWarn = collectAndWarn;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const registries_1 = require("./registries");
+const discovery_1 = require("./discovery");
 const text_1 = require("./text");
 const ALLOWED_FIELDS = ['name', 'appliesWhen', 'terminatesTo'];
 // These fields are semantically short (a short identity, a short trigger condition, a
@@ -24,6 +25,24 @@ const ALLOWED_FIELDS = ['name', 'appliesWhen', 'terminatesTo'];
 // untrusted input whose fields flow straight into the AI-provider context payload, so an
 // unbounded string here would let a crafted registry bloat/DoS that context.
 const MAX_FIELD_LENGTH = 500;
+function discoverDeclaredSkillNames() {
+    let names = new Set();
+    const diagnostics = [];
+    const acceptedRoots = [];
+    for (const root of (0, registries_1.contentRoots)()) {
+        try {
+            // Admit the entire root only after global collision/override resolution succeeds.
+            const skills = (0, discovery_1.discoverSkills)([...acceptedRoots, root]);
+            names = new Set(skills.map((skill) => skill.name));
+            acceptedRoots.push(root);
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            diagnostics.push(`${(0, text_1.sanitizeDiagnosticText)(root)}: orchestrator skill discovery unavailable (${(0, text_1.sanitizeDiagnosticText)(message)})`);
+        }
+    }
+    return { names, diagnostics };
+}
 function readDeclaredOrchestrators(root) {
     const file = path_1.default.join(root, registries_1.REGISTRY_MANIFEST_NAME);
     // Shares the same trust boundary as readRegistryManifest (registries.ts): a manifest
@@ -35,7 +54,7 @@ function readDeclaredOrchestrators(root) {
         exists = (0, registries_1.assertRegularRegistryFile)(file);
     }
     catch (e) {
-        return { orchestrators: [], diagnostics: [`${file}: ${e instanceof Error ? e.message : String(e)}`] };
+        return { orchestrators: [], diagnostics: [(0, text_1.sanitizeDiagnosticText)(`${file}: ${e instanceof Error ? e.message : String(e)}`)] };
     }
     if (!exists)
         return { orchestrators: [], diagnostics: [] };
@@ -44,28 +63,27 @@ function readDeclaredOrchestrators(root) {
         contents = fs_1.default.readFileSync(file, 'utf-8');
     }
     catch (e) {
-        return { orchestrators: [], diagnostics: [`${file}: cannot read manifest (${e instanceof Error ? e.message : String(e)})`] };
+        return { orchestrators: [], diagnostics: [(0, text_1.sanitizeDiagnosticText)(`${file}: cannot read manifest (${e instanceof Error ? e.message : String(e)})`)] };
     }
     let raw;
     try {
         raw = JSON.parse(contents);
     }
     catch (e) {
-        return { orchestrators: [], diagnostics: [`${file}: manifest is not valid JSON (${e instanceof Error ? e.message : String(e)})`] };
+        return { orchestrators: [], diagnostics: [(0, text_1.sanitizeDiagnosticText)(`${file}: manifest is not valid JSON (${e instanceof Error ? e.message : String(e)})`)] };
     }
     const decl = raw?.orchestrator;
     if (decl === undefined)
         return { orchestrators: [], diagnostics: [] };
     if (typeof decl !== 'object' || decl === null || Array.isArray(decl)) {
-        return { orchestrators: [], diagnostics: [`${file}: "orchestrator" must be an object`] };
+        return { orchestrators: [], diagnostics: [(0, text_1.sanitizeDiagnosticText)(`${file}: "orchestrator" must be an object`)] };
     }
     const problems = [];
     const entries = decl;
     for (const key of Object.keys(entries)) {
         if (!ALLOWED_FIELDS.includes(key)) {
-            // key comes straight from an untrusted registry's JSON — JSON.stringify keeps the
-            // diagnostic single-line and unambiguous even if the key contains newlines or other
-            // control characters, which would otherwise let a crafted key forge extra log lines.
+            // Quote keys unambiguously; sanitize the complete diagnostic below because
+            // JSON.stringify preserves Unicode line separators and C1 controls.
             problems.push(`unknown field ${JSON.stringify(key)} — the contract admits only ${ALLOWED_FIELDS.join(', ')}`);
         }
     }
@@ -79,7 +97,7 @@ function readDeclaredOrchestrators(root) {
         }
     }
     if (problems.length > 0) {
-        return { orchestrators: [], diagnostics: [`${file}: invalid "orchestrator" declaration — ${problems.join('; ')}`] };
+        return { orchestrators: [], diagnostics: [(0, text_1.sanitizeDiagnosticText)(`${file}: invalid "orchestrator" declaration — ${problems.join('; ')}`)] };
     }
     return {
         orchestrators: [{
@@ -126,13 +144,19 @@ function readDeclaredOrchestrators(root) {
  */
 function collectDeclaredOrchestrators() {
     const declared = [];
-    const diagnostics = [];
+    const droppedNames = [];
+    const { names: availableSkillNames, diagnostics } = discoverDeclaredSkillNames();
     const seenNames = new Set();
     const seenSanitizedNames = new Set();
     for (const reg of (0, registries_1.listRegistries)()) {
         const r = readDeclaredOrchestrators(reg.contentRoot);
         for (const orch of r.orchestrators) {
             const file = path_1.default.join(reg.contentRoot, registries_1.REGISTRY_MANIFEST_NAME);
+            if (!availableSkillNames.has(orch.name)) {
+                droppedNames.push(orch.name);
+                diagnostics.push(`${(0, text_1.sanitizeDiagnosticText)(file)}: orchestrator declaration dropped because skill "${(0, text_1.sanitizeDiagnosticText)(orch.name)}" is not discoverable in configured safe registries`);
+                continue;
+            }
             if (seenNames.has(orch.name)) {
                 diagnostics.push(`${file}: orchestrator "${(0, text_1.stripControlChars)(orch.name)}" duplicates one already declared by an earlier registry — shadowed duplicate dropped`);
                 continue;
@@ -149,7 +173,7 @@ function collectDeclaredOrchestrators() {
         }
         diagnostics.push(...r.diagnostics);
     }
-    return { declared, diagnostics };
+    return { declared, diagnostics, droppedNames };
 }
 /** Recolecta declarados y emite sus diagnosticos como warnings. Punto unico usado por
  *  `InjectionOrchestrator.inputFor`/`statusInputFor` y por `commands/hooks/claude.ts`

package/dist/src/core/text.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripControlChars = stripControlChars;
+exports.sanitizeDiagnosticText = sanitizeDiagnosticText;
 exports.sanitizeDeclaredField = sanitizeDeclaredField;
 // cli/src/core/text.ts
 /** Neutraliza bytes de control C0 (incluyendo ESC `\x1b`) y DEL de texto que
@@ -16,6 +17,12 @@ function stripControlChars(text) {
     // eslint-disable-next-line no-control-regex -- necesitamos matchear C0 deliberadamente
     return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
 }
+/** Keeps an untrusted diagnostic field on one terminal line, without changing
+ * the whitespace policy for multiline public text or composed markdown. */
+function sanitizeDiagnosticText(text) {
+    // eslint-disable-next-line no-control-regex -- remove all C0/C1 controls, including terminal escape bytes
+    return text.replace(/\r\n|[\r\n\t\u2028\u2029]/g, ' ').replace(/[\x00-\x1f\x7f-\x9f]/g, '');
+}
 /**
  * Neutraliza marcado markdown (colapsa `\r?\n` a un espacio y quita
  * `` ` * _ # < > ``) de contenido no confiable antes de interpolarlo en un

package/dist/src/core/tracks/git.js

@@ -136,13 +136,25 @@ function ownedWorktreeExists(repo, worktreePath, branch) {
  *  worktree (contenido de filesystem que SÍ podría ser ajeno), una branch es
  *  solo un ref; nada más crea una con ese nombre exacto. */
 function branchExists(repo, branch) {
+    // `show-ref --quiet` puede devolver 1 tanto para una ref ausente como
+    // para un repositorio que ni siquiera pudo abrirse. Primero probamos que
+    // git puede identificar el repositorio; solo después status 1 significa
+    // honestamente "la branch no existe".
+    try {
+        git(repo, ['rev-parse', '--git-dir']);
+    }
+    catch (error) {
+        throw new Error(`branchExists: repo de ${branch} indemostrable: ${error.message}`);
+    }
     try {
         git(repo, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
-        return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        if (error.status === 1)
+            return false;
+        throw new Error(`branchExists: existencia de ${branch} indemostrable: ${error.message}`);
     }
+    return true;
 }
 /** Task 9 (paso BRANCH_REMOVED, Task 13 endurece el guard — R4.10/C9): borra
  *  la branch local determinista de un track SOLO después de que su worktree

package/dist/src/core/tracks/protocol.js

@@ -269,7 +269,25 @@ function nextProtocolEffect(s) {
 }
 function reconcileProtocol(s, observation) {
     const out = structuredClone(s);
-    if (observation.kind === 'prepare-failed') {
+    if (observation.kind === 'teardown-requested') {
+        const requested = out.tracks[observation.trackId];
+        if (requested === undefined)
+            throw new Error(`track desconocido: ${observation.trackId}`);
+        if (out.cohortPhase !== 'BLOCKED' && out.cohortPhase !== 'SERIAL' && out.cohortPhase !== 'COMPLETE'
+            && out.cohortPhase !== 'FALLBACK_PENDING') {
+            out.cohortPhase = 'FALLBACK_PENDING';
+            out.fallbackReason = `controller-requested:${observation.trackId}`;
+            // La evidencia de QA/integración describe la ruta de finalización
+            // que acabamos de abandonar. Debe desaparecer ANTES de mover los
+            // tracks a teardown: de otro modo el invariante de integración
+            // final ve evidence viva junto a tracks no mergeados y rechaza la
+            // transición segura hacia fallback.
+            out.globalQaHeadSha = undefined;
+            out.finalIntegrationJobId = undefined;
+            markTeardownRequested(out.tracks);
+        }
+    }
+    else if (observation.kind === 'prepare-failed') {
         out.cohortPhase = 'FALLBACK_PENDING';
         out.fallbackReason = `prepare-failed:${observation.trackId}`;
         markTeardownRequested(out.tracks);
@@ -295,10 +313,11 @@ function reconcileProtocol(s, observation) {
             // `decideTeardown` documenta para BLOCKED: solo el operador lo
             // saca de acá.
             const t = out.tracks[observation.trackId];
-            if (t !== undefined) {
-                t.phase = 'BLOCKED';
-                t.blockedReason = observation.detail;
-            }
+            if (t === undefined)
+                throw new Error(`track desconocido: ${observation.trackId}`);
+            t.phase = 'BLOCKED';
+            t.blockedReason = observation.detail;
+            out.cohortPhase = 'BLOCKED';
         }
         // effect-failed fuera de PREPARING/begin-teardown: sin transición definida todavía (no ejercitado por T1).
     }
@@ -351,6 +370,7 @@ function reconcileProtocol(s, observation) {
         if (decision === 'block-foreign') {
             t.phase = 'BLOCKED';
             t.blockedReason = observation.foreignSupervisor ? 'identidad de supervisor ajena' : 'worktree preexistente ajeno';
+            out.cohortPhase = 'BLOCKED';
         }
         else if (decision === 'accept-supervisor-stopped') {
             t.phase = 'SUPERVISOR_STOPPED';
@@ -432,7 +452,7 @@ function reconcileProtocol(s, observation) {
 }
 function observeProtocolEffect(s, effect, observation) {
     if (observation.kind === 'effect-failed' || observation.kind === 'prepare-failed' || observation.kind === 'join-observation'
-        || observation.kind === 'freeze-observation' || observation.kind === 'join-requested'
+        || observation.kind === 'freeze-observation' || observation.kind === 'join-requested' || observation.kind === 'teardown-requested'
         || observation.kind === 'supervisor-observed' || observation.kind === 'worktree-observed'
         || observation.kind === 'teardown-observation'
         || observation.kind === 'global-qa-pass'

package/dist/tests/commands/context.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const context_1 = require("../../src/commands/context");
-const collected = (declared, diagnostics = []) => ({ declared, diagnostics });
+const collected = (declared, diagnostics = []) => ({ declared, diagnostics, droppedNames: [] });
 const uno = { name: 'mi-proceso', appliesWhen: 'cuando hay una tarea', terminatesTo: 'development-process' };
 describe('awm context orchestrators', () => {
     it('lista los orquestadores compuestos', () => {
@@ -55,6 +55,14 @@ describe('awm context orchestrators', () => {
         const r = (0, context_1.runContextOrchestrators)(collected([uno]), { json: false, verify: 'de-verdad-no-existe' });
         expect(r.code).toBe(2);
     });
+    it('--verify rejects a dropped raw identity that sanitizes to a retained name', () => {
+        const input = {
+            ...collected([{ name: 'foobar', appliesWhen: 'x', terminatesTo: 'y' }]),
+            droppedNames: ['foo_bar'],
+        };
+        expect((0, context_1.runContextOrchestrators)(input, { json: false, verify: 'foo_bar' }).code).toBe(2);
+        expect((0, context_1.runContextOrchestrators)(input, { json: false, verify: 'foobar' }).code).toBe(0);
+    });
     it('sanea bytes de control antes de escribir a la terminal', () => {
         const hostil = { name: 'x\x1b[31m', appliesWhen: 'w\x07', terminatesTo: 't\x00' };
         const r = (0, context_1.runContextOrchestrators)(collected([hostil]), { json: false });

package/dist/tests/commands/hooks/install.test.js

@@ -186,6 +186,8 @@ describe('installHook (happy path + merge)', () => {
         fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "{}"', { mode: 0o755 });
         fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
         fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills', 'mi-proceso'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills', 'mi-proceso', 'SKILL.md'), '---\nname: mi-proceso\n---\n');
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'mi-proceso', appliesWhen: 'al arrancar', terminatesTo: 'development-process' } }));
         installHook({ agent: 'claude-code', registryRoot, installMethod: 'symlink' });
         const content = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm', 'hooks', 'using-awm.md'), 'utf-8');
@@ -246,6 +248,8 @@ describe('installHook (happy path + merge)', () => {
         fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "{}"', { mode: 0o755 });
         fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
         fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills', 'proceso-valido'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills', 'proceso-valido', 'SKILL.md'), '---\nname: proceso-valido\n---\n');
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'proceso-valido', appliesWhen: 'al arrancar', terminatesTo: 'development-process' } }));
         const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
         let result;

package/dist/tests/commands/hooks/resync.test.js

@@ -101,6 +101,8 @@ describe('resyncInstalledHooks', () => {
         fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "{}"', { mode: 0o755 });
         fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
         fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills', 'mi-proceso'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills', 'mi-proceso', 'SKILL.md'), '---\nname: mi-proceso\n---\n');
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'mi-proceso', appliesWhen: 'al arrancar', terminatesTo: 'development-process' } }));
         const { installHook } = require('../../../src/commands/hooks/install');
         installHook({ agent: 'claude-code', registryRoot, installMethod: 'symlink' });

package/dist/tests/commands/track/verbs.test.js

@@ -103,6 +103,12 @@ describe('awm track — verbos mutantes son request-only (R6.1)', () => {
         expect(git(repo, ['rev-parse', 'HEAD'])).toBe(beforeHead);
         expect(fs_1.default.readFileSync((0, paths_1.statePath)(repo, branch), 'utf8')).toBe(beforeState);
     });
+    test('remove se anuncia como cancelación request-only soportada (TR-REQ-10)', async () => {
+        const out = await runCli(repo, ['track', 'remove', '--help']);
+        expect(out.exitCode).toBe(0);
+        expect(out.out).toContain('cancela la cohorte');
+        expect(out.out).not.toContain('NO IMPLEMENTADO');
+    });
     // `finalize` es PLAN-scoped y sin <trackId>, así que no entra en las matrices de
     // add/join/remove — pero comparte con ellas la propiedad que define a la superficie:
     // emite una request y no toca Git ni state.json.

package/dist/tests/commands/watch/apply.test.js

@@ -126,7 +126,7 @@ describe('aplicacion transaccional de requests', () => {
         expect(Object.keys((0, store_1.readJournal)(repo, 'rama').state.jobs)).toHaveLength(1); // sin duplicados
     });
     test('register-entity CREA task con VerificationPlan y ReviewObligations; cycle-plan y dispatch (R1.4/R1.4b)', () => {
-        (0, requests_1.emitRequest)(repo, 'rama', {
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
             kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
             payload: {
                 entity: 'task', taskId: 'T1', title: 'implementar',
@@ -513,20 +513,57 @@ describe('aplicacion transaccional de requests', () => {
         expect(out.rejectedInvalid).toBe(1);
         expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
     });
-    test('un kind SIN handler falla cerrado: rechazo visible, no un `applied` que borra el archivo', () => {
-        // `track-teardown-request` es un kind real, emitido por `awm track remove`, que hoy
-        // no tiene handler en el supervisor. Antes de este cambio se contaba como aplicado y
-        // desaparecía sin dejar rastro; ahora queda registrado como problema y el archivo se
-        // conserva con sufijo `.rejected`, que es lo que permite darse cuenta.
-        const r = (0, requests_1.emitRequest)(repo, 'rama', {
-            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-1',
+    test('track-teardown-request persiste intención sin mover fase ni cohorte', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-alpha',
             payload: { trackId: 'alpha' },
         });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tracks[0].teardownRequested).toBe(true);
+        expect(state.tracks[0].phase).toBe('ACTIVE');
+        expect(state.cohortPhase).toBe('JOINING');
+        expect(state.appliedRequests[request.requestId]).toMatchObject({ outcome: 'applied', resultRef: 'alpha' });
+    });
+    test.each([
+        ['ausente', {}],
+        ['vacio', { trackId: '' }],
+        ['malformado', { trackId: 42 }],
+        ['desconocido', { trackId: 'no-existe' }],
+    ])('track-teardown-request %s se rechaza visiblemente sin mutar el track', (_case, payload) => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: `teardown-${_case}`,
+            payload,
+        });
         const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
         expect(out.applied).toBe(0);
         expect(out.rejectedInvalid).toBe(1);
         expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
-        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems.some((p) => p.kind === 'rejected')).toBe(true);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tracks).toEqual([{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }]);
+        expect(state.cohortPhase).toBe('JOINING');
+    });
+    test('track-teardown-request se rechaza si la cohorte no puede reconciliarse', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-invalid-cohort',
+            payload: { trackId: 'alpha' },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${request.file}.rejected`)).toBe(true);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tracks[0].teardownRequested).toBeUndefined();
     });
     test('track-finalize-request persiste el autoreporte del controller (qaFinalizeRequested) — puramente declarativo (R7.2)', () => {
         (0, requests_1.emitRequest)(repo, 'rama', {