agentic-workflow-manager 3.4.0 → 3.6.0

package/dist/src/core/export/pack.js

@@ -13,6 +13,12 @@ exports.packSkill = packSkill;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
+// stdio explicito: sin esto, spawnSync relayea el stderr del `zip` hijo hacia
+// el stderr del proceso llamante (default `inheritStderr` de Node cuando no
+// se pasa `stdio`) — si ese fd fuera un pipe roto/destruido, el relay mismo
+// dispara un EPIPE no catcheable que crashea al llamante (mismo bug de raiz
+// que motivo EXEC_STDIO en core/journal/process.ts).
+const EXEC_STDIO = ['ignore', 'pipe', 'pipe'];
 /** Refuses symlinks anywhere in the tree — copying/zipping them could dereference
  * into content outside the registry (info-leak) or embed a broken/unexpected
  * link for the recipient. Exported artifacts are plain files only. */
@@ -28,7 +34,7 @@ function assertNoSymlinks(dir) {
 }
 /** Capa 1: binario `zip` del sistema. ENOENT → missing (capa 2: carpeta). */
 const defaultZip = (cwd, zipName, folderName) => {
-    const r = (0, child_process_1.spawnSync)('zip', ['-r', '-q', zipName, folderName], { cwd });
+    const r = (0, child_process_1.spawnSync)('zip', ['-r', '-q', zipName, folderName], { cwd, stdio: EXEC_STDIO });
     if (r.error && r.error.code === 'ENOENT') {
         return { ok: false, missing: true };
     }

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterFor = adapterFor;
+const process_1 = require("./process");
+const RESUME_PROMPT_PREFIX = 'Sos el orquestador SDD de este repo. Corre `awm job reconcile` y ejecuta ';
+function baseSafeToReplace(ref) {
+    return (0, process_1.refIsAlive)(ref) ? 'indeterminate' : 'safe';
+}
+const codexAdapter = {
+    provider: 'codex',
+    launchArgv: (resumePrompt) => ['codex', 'exec', `${RESUME_PROMPT_PREFIX}${resumePrompt}`],
+    activity: process_1.activitySnapshot,
+    safeToReplace: baseSafeToReplace,
+};
+const claudeAdapter = {
+    provider: 'claude-code',
+    launchArgv: (resumePrompt) => ['claude', '-p', `${RESUME_PROMPT_PREFIX}${resumePrompt}`],
+    activity: process_1.activitySnapshot,
+    safeToReplace: baseSafeToReplace,
+};
+function adapterFor(provider) {
+    if (provider === 'codex')
+        return codexAdapter;
+    if (provider === 'claude-code')
+        return claudeAdapter;
+    throw new Error(`provider desconocido: ${provider} (validos: codex, claude-code)`);
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkingDirectory = resolveWorkingDirectory;
+exports.computeFingerprint = computeFingerprint;
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const process_1 = require("./process");
+function sha(parts) {
+    return crypto_1.default.createHash('sha256').update(parts.join('\0')).digest('hex');
+}
+// Sin ceiling de maxBuffer: repos grandes (`ls-files` / `ls-files --stage` en
+// miles de archivos) pueden superar el default de Node (1MB) y abortar con ENOBUFS.
+// stdio explicito (ver EXEC_STDIO en process.ts): sin esto, execFileSync relayea
+// el stderr de git hacia el stderr DEL SUPERVISOR — si ese fd es un pipe roto, el
+// relay dispara un EPIPE no catcheable que crashea el proceso ENTERO (este helper
+// backea computeFingerprint, invocado en CADA tick via FingerprintNow/computeGate).
+function git(cwd, args) {
+    return (0, child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8', maxBuffer: Infinity, stdio: process_1.EXEC_STDIO });
+}
+function resolveWorkingDirectory(repoRoot, cwdRel) {
+    if (typeof cwdRel !== 'string' || cwdRel.length === 0)
+        throw new Error('cwd relativo requerido');
+    const relative = path_1.default.normalize(cwdRel);
+    if (path_1.default.isAbsolute(relative) || relative === '..' || relative.startsWith(`..${path_1.default.sep}`)) {
+        throw new Error(`cwd fuera del repo: ${JSON.stringify(cwdRel)}`);
+    }
+    const root = fs_1.default.realpathSync(repoRoot);
+    let cursor = root;
+    for (const segment of relative.split(path_1.default.sep).filter((part) => part !== '.')) {
+        cursor = path_1.default.join(cursor, segment);
+        const stat = fs_1.default.lstatSync(cursor);
+        if (stat.isSymbolicLink())
+            throw new Error(`cwd contiene symlink no permitido: ${JSON.stringify(cwdRel)}`);
+    }
+    const absolute = fs_1.default.realpathSync(path_1.default.join(root, relative));
+    if (absolute !== root && !absolute.startsWith(`${root}${path_1.default.sep}`))
+        throw new Error(`cwd fuera del repo: ${JSON.stringify(cwdRel)}`);
+    if (!fs_1.default.statSync(absolute).isDirectory())
+        throw new Error(`cwd no es directorio: ${JSON.stringify(cwdRel)}`);
+    return { relative: relative.split(path_1.default.sep).join('/'), absolute };
+}
+/** El journal jamás invalida evidencia: .awm/ queda fuera de toda expansión. */
+const EXCLUDE_JOURNAL = ':(exclude).awm';
+/** Componentes SEPARADOS (design R3.4, bloqueador 7 de la review):
+ *  argv exacto + cwd relativo REAL + HEAD + índice real (`ls-files --stage`
+ *  hasheado) + digest de contenido por archivo tracked/untracked/deleted. */
+function computeFingerprint(repoRoot, argv, pathGlobs, cwdRel) {
+    if (!Array.isArray(argv) || argv.length === 0)
+        throw new Error('argv vacio');
+    const cwdNorm = resolveWorkingDirectory(repoRoot, cwdRel).relative;
+    const commandDigest = sha(argv);
+    const head = git(repoRoot, ['rev-parse', 'HEAD']).trim();
+    const pathspecs = pathGlobs.length > 0 ? pathGlobs : ['.'];
+    // Índice REAL: modos + blobs + stages + paths — un cambio staged-only con
+    // worktree idéntico produce salida distinta aquí. Sin -z a propósito: esta
+    // salida se hashea completa como texto opaco, nunca se separa en paths
+    // individuales, así que el quoting de core.quotePath es inofensivo aquí
+    // (a diferencia de expandedPaths abajo, cuyos paths SÍ se re-extraen para
+    // pasarlos a `hash-object` — por eso ese caso sí necesita -z).
+    const indexRaw = git(repoRoot, ['ls-files', '--stage', '--', ...pathspecs, EXCLUDE_JOURNAL]);
+    const indexDigest = sha([indexRaw]);
+    const expandedPaths = git(repoRoot, ['ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', ...pathspecs, EXCLUDE_JOURNAL])
+        .split('\0').filter(Boolean).sort();
+    const perFile = expandedPaths.map((p) => {
+        try {
+            return `${p}:${git(repoRoot, ['hash-object', '--', p]).trim()}`;
+        }
+        catch {
+            return `${p}:deleted`; // listado pero ilegible/borrado del worktree: cuenta como cambio
+        }
+    });
+    const declaredPaths = pathGlobs.length > 0 ? pathGlobs : ['.'];
+    const fingerprint = sha([commandDigest, `cwd:${cwdNorm}`, `paths:${JSON.stringify(declaredPaths)}`, `head:${head}`, `index:${indexDigest}`, ...perFile]);
+    return { fingerprint, commandDigest, expandedPaths };
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.branchSlug = branchSlug;
+exports.journalDir = journalDir;
+exports.supervisorLockPath = supervisorLockPath;
+exports.statePath = statePath;
+exports.requestsDir = requestsDir;
+exports.acksDir = acksDir;
+exports.logsDir = logsDir;
+exports.eventsPath = eventsPath;
+exports.exportDir = exportDir;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function branchSlug(branch) {
+    if (!branch || branch === '.' || branch.includes('..')) {
+        throw new Error(`branch inválida para slug: ${JSON.stringify(branch)}`);
+    }
+    // Escapa PRIMERO el propio caracter de escape (_), despues / y \ — así
+    // ningún guion bajo literal sobrevive sin escapar, lo que hace la
+    // codificación biyectiva: dos ramas distintas nunca pueden colisionar
+    // (bloqueador encontrado en code-quality review de Task 3).
+    return branch
+        .replace(/_/g, '_5F')
+        .replace(/\//g, '_2F')
+        .replace(/\\/g, '_5C');
+}
+function journalDir(repoRoot, branch) {
+    return path_1.default.join(repoRoot, '.awm', 'journal', branchSlug(branch));
+}
+/** Lock único por worktree FÍSICO: clavado por realpath, fuera del dir de rama
+ *  (design R1.1, bloqueante v5-5: dos ramas jamás toman locks distintos sobre
+ *  el mismo árbol). */
+function supervisorLockPath(repoRoot) {
+    return path_1.default.join(fs_1.default.realpathSync(repoRoot), '.awm', 'journal', 'supervisor.lock');
+}
+function statePath(repoRoot, branch) {
+    return path_1.default.join(journalDir(repoRoot, branch), 'state.json');
+}
+function requestsDir(repoRoot, branch) {
+    return path_1.default.join(journalDir(repoRoot, branch), 'requests');
+}
+function acksDir(repoRoot, branch) {
+    return path_1.default.join(journalDir(repoRoot, branch), 'acks');
+}
+function logsDir(repoRoot, branch) {
+    return path_1.default.join(journalDir(repoRoot, branch), 'logs');
+}
+function eventsPath(repoRoot, branch) {
+    return path_1.default.join(journalDir(repoRoot, branch), 'events.jsonl');
+}
+function exportDir(repoRoot, branch) {
+    return path_1.default.join(journalDir(repoRoot, branch), 'export');
+}

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

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXEC_STDIO = exports.NONCE_ENV = void 0;
+exports.argvDigest = argvDigest;
+exports.psArgsDigestOf = psArgsDigestOf;
+exports.captureRefFor = captureRefFor;
+exports.captureSelfRef = captureSelfRef;
+exports.spawnStructured = spawnStructured;
+exports.refIsAlive = refIsAlive;
+exports.processStatesAreGone = processStatesAreGone;
+exports.groupIsGone = groupIsGone;
+exports.activitySnapshot = activitySnapshot;
+exports.terminateGroupConfirmed = terminateGroupConfirmed;
+exports.terminatePreviouslyOwnedGroup = terminatePreviouslyOwnedGroup;
+const crypto_1 = __importDefault(require("crypto"));
+const child_process_1 = require("child_process");
+exports.NONCE_ENV = 'AWM_SPAWN_NONCE';
+/** Contrato dual, a proposito (tomo 3 rondas de fixes reales llegar aca —
+ *  ver historial de Task 10): devuelve `null` SOLO cuando `ps` corrio y
+ *  confirmo positivamente que el pid no existe (exit status 1). Cualquier
+ *  otro fallo (ENOENT del binario, permisos, error transitorio) se
+ *  RELANZA — nunca se traduce a `null`, porque un `null` aca significaria
+ *  "muerte confirmada" para cualquier caller que no distinga los casos.
+ *  Hay DOS formas correctas de consumir esto, segun el contexto:
+ *  - Declaracion de muerte (`refIsAlive`, `activitySnapshot`): el caller
+ *    DEBE envolver en su propio try/catch y fallar A FAVOR de "vivo" —
+ *    nunca asumir muerto por un throw. El silencio jamas es prueba.
+ *  - Captura de identidad en spawn (`captureRefFor`, `stablePsArgs`): usar
+ *    `psFieldSafe` en vez de esta funcion — ahi "no se pudo determinar" ya
+ *    tiene un fallback seguro documentado ('unknown'), sin riesgo de
+ *    declarar muerte por error. */
+/** stdio explicito en TODOS los execFileSync de este archivo (ver EXEC_STDIO):
+ *  sin esto, `execFileSync` por defecto hace `inheritStderr` — relayea el
+ *  stderr del subproceso hacia el stderr DEL PROCESO LLAMANTE. Si ese stderr
+ *  llegara a ser un pipe roto/destruido (ej. wrapper detached, ver
+ *  spawnStructured), el relay mismo dispara el EPIPE que crashea al
+ *  llamante — el mismo bug de raiz, reintroducido via esta funcion en vez
+ *  de via el spawn del hijo. Con stdio explicito ('pipe' para stdout/stderr)
+ *  ese relay jamas ocurre: `execFileSync` captura el stderr del subproceso
+ *  internamente y listo, sin tocar el fd real del proceso actual. */
+exports.EXEC_STDIO = ['ignore', 'pipe', 'pipe'];
+function psField(pid, field) {
+    try {
+        const out = (0, child_process_1.execFileSync)('ps', ['-o', `${field}=`, '-p', String(pid)], { encoding: 'utf8', stdio: exports.EXEC_STDIO }).trim();
+        return out.length > 0 ? out : null;
+    }
+    catch (error) {
+        const status = error.status;
+        if (status === 1)
+            return null; // ps corrio y confirmo: el pid no existe
+        throw error; // ps no pudo ejecutarse (ENOENT/permisos/etc): NO es prueba de nada
+    }
+}
+function sleepSync(seconds) {
+    try {
+        (0, child_process_1.execFileSync)('sleep', [seconds], { stdio: exports.EXEC_STDIO });
+    }
+    catch { /* sin sleep: seguimos */ }
+}
+/** Variante de psField para contextos de CAPTURA de identidad (spawn time):
+ *  aqui "no se pudo determinar" ya tiene un fallback seguro documentado
+ *  ('unknown') — no es un contexto de declaracion de muerte, asi que
+ *  cualquier fallo de ps se traga, igual que siempre. */
+function psFieldSafe(pid, field) {
+    try {
+        return psField(pid, field);
+    }
+    catch {
+        return null;
+    }
+}
+/** ps args estable: dos lecturas consecutivas iguales (evita capturar el
+ *  estado pre-exec del fork). null si el proceso ya no existe O si ps
+ *  fallo en ejecutarse (via psFieldSafe) — ambos casos son "no se pudo
+ *  determinar" aca, sin riesgo: este es un contexto de captura, no de
+ *  declaracion de muerte. */
+function stablePsArgs(pid) {
+    for (let i = 0; i < 5; i++) {
+        const a = psFieldSafe(pid, 'args');
+        if (a === null)
+            return null;
+        sleepSync('0.05');
+        const b = psFieldSafe(pid, 'args');
+        if (b === a)
+            return a;
+    }
+    return psFieldSafe(pid, 'args');
+}
+function argvDigest(argv) {
+    return crypto_1.default.createHash('sha256').update(argv.join('\0')).digest('hex').slice(0, 16);
+}
+/** EXPORTADA pero hereda el contrato crudo de psField (throws si ps falla
+ *  en ejecutarse, mas alla de "pid no existe"). Hoy el unico caller es
+ *  refIsAlive, que ya envuelve en su propio try/catch fail-safe — cualquier
+ *  caller NUEVO que la use standalone debe hacer lo mismo (ver comentario
+ *  de psField) o usar psFieldSafe si esta en un contexto de captura. */
+function identityDigest(psArgs, spawnNonce, requestedArgvDigest) {
+    return crypto_1.default.createHash('sha256').update(`${psArgs}\0${spawnNonce}\0${requestedArgvDigest}`).digest('hex').slice(0, 16);
+}
+function psArgsDigestOf(pid, spawnNonce = '', requestedArgvDigest = '') {
+    const args = psField(pid, 'args');
+    if (args === null)
+        return null;
+    return identityDigest(args, spawnNonce, requestedArgvDigest);
+}
+/** Captura la identidad COMPLETA de un pid recien spawneado (R2.1):
+ *  startTime + pgid reales de ps + digest de `ps -o args=` estable. */
+function captureRefFor(pid, nonce, argv) {
+    let start = null;
+    for (let i = 0; i < 5 && start === null; i++) {
+        start = psFieldSafe(pid, 'lstart');
+        if (start === null)
+            sleepSync('0.05');
+    }
+    const pgid = psFieldSafe(pid, 'pgid');
+    const args = stablePsArgs(pid);
+    const requestedArgvDigest = argvDigest(argv);
+    return {
+        pid,
+        startTime: start ?? 'unknown',
+        spawnNonce: nonce,
+        argvDigest: requestedArgvDigest,
+        processGroup: pgid !== null ? Number(pgid) : pid,
+        // Liga nonce + argv solicitado con la observacion real de ps. Alterar
+        // cualquier miembro de la tupla invalida la identidad completa.
+        psArgsDigest: args !== null ? identityDigest(args, nonce, requestedArgvDigest) : 'unknown',
+    };
+}
+/** Identidad del proceso ACTUAL (la usa el wrapper externo y el lock). */
+function captureSelfRef(nonce) {
+    return captureRefFor(process.pid, nonce, process.argv);
+}
+/** Ejecucion segura (design R4.7): executable+argv como array, shell:false,
+ *  nonce por entorno (referencia, no valor persistido), grupo propio (detached). */
+function spawnStructured(argv, cwd, nonce, extraEnv = {}) {
+    const [exe, ...args] = argv;
+    const child = (0, child_process_1.spawn)(exe, args, {
+        cwd, shell: false, detached: true,
+        env: { ...process.env, [exports.NONCE_ENV]: nonce, ...extraEnv },
+        // stdio:'ignore' completo (nada de pipes): un pipe destruido/abandonado
+        // por el padre puede EPIPE-crashear al hijo si este escribe a su propio
+        // stdout/stderr despues (ver defaultWrapperSpawner) — el hijo maneja su
+        // stdio propio, el padre no necesita capturarlo.
+        stdio: 'ignore',
+    });
+    if (child.pid === undefined)
+        throw new Error(`spawn fallo para ${exe}`);
+    return { child, ref: captureRefFor(child.pid, nonce, argv) };
+}
+/** Vivo Y con la MISMA identidad — tupla completa, nunca PID solo (R2.1,
+ *  bloqueador 6): startTime + pgid + digest de ps args. */
+function refIsAlive(ref) {
+    try {
+        const stat = psField(ref.pid, 'stat');
+        if (stat === null || stat.startsWith('Z'))
+            return false; // zombie = proceso terminado, solo espera reap
+        const start = psField(ref.pid, 'lstart');
+        if (start === null || start !== ref.startTime)
+            return false;
+        const pgid = psField(ref.pid, 'pgid');
+        if (pgid === null || Number(pgid) !== ref.processGroup)
+            return false;
+        const argsDig = psArgsDigestOf(ref.pid, ref.spawnNonce, ref.argvDigest);
+        if (argsDig === null || argsDig !== ref.psArgsDigest)
+            return false;
+        return true;
+    }
+    catch {
+        // ps no pudo ejecutarse: sin evidencia, jamas declarar muerte — se
+        // trata como vivo (R2.1, bloqueador de Task 10: silencio no es prueba).
+        return true;
+    }
+}
+/** true <=> pgrep no encuentra miembros ejecutables en el grupo. Los zombies
+ *  ya terminaron y solo esperan reap; no pueden responder seniales ni retener
+ *  trabajo. Un fallo de observacion devuelve false (R2.1). */
+function processStatesAreGone(states) {
+    return states.every((stat) => stat === null || stat.startsWith('Z'));
+}
+function groupIsGone(pgid) {
+    let pids;
+    try {
+        const out = (0, child_process_1.execFileSync)('pgrep', ['-g', String(pgid)], { encoding: 'utf8', stdio: exports.EXEC_STDIO });
+        pids = out.split('\n').filter(Boolean).map(Number).filter(Number.isInteger);
+    }
+    catch (error) {
+        const status = error.status;
+        return status === 1; // pgrep exit 1 = cero matches; cualquier otra cosa NO confirma
+    }
+    if (pids.length === 0)
+        return true;
+    try {
+        // `pgrep` tambien devuelve zombies. No pueden ejecutar, mantener FDs ni
+        // responder seniales; contarlos como vivos fuerza esperas completas y
+        // custodia falsa hasta que el parent haga reap. Solo un miembro no-zombie
+        // conserva ownership ejecutable del grupo.
+        return processStatesAreGone(pids.map((pid) => psField(pid, 'stat')));
+    }
+    catch {
+        return false; // sin observacion completa, falla cerrado
+    }
+}
+function activitySnapshot(ref) {
+    if (!refIsAlive(ref))
+        return null;
+    let cpu = '0';
+    try {
+        cpu = psField(ref.pid, 'time') ?? '0';
+    }
+    catch {
+        cpu = '0';
+    }
+    let groupSize = 1;
+    try {
+        groupSize = (0, child_process_1.execFileSync)('pgrep', ['-g', String(ref.processGroup)], { encoding: 'utf8', stdio: exports.EXEC_STDIO })
+            .split('\n').filter(Boolean).length;
+    }
+    catch {
+        groupSize = 1;
+    }
+    return { cpuTime: cpu, groupSize };
+}
+/** Escalera de gracia (design R4.2b): SIGTERM -> confirmar -> SIGKILL -> confirmar.
+ *  true <=> lider muerto por identidad Y grupo entero desaparecido (pgrep -g
+ *  vacio) — jamas confirmar solo el lider (bloqueador 6). */
+async function terminateGroupConfirmed(ref, opts) {
+    const waitUntilGone = async (maxMs) => {
+        const deadline = Date.now() + maxMs;
+        while (Date.now() < deadline) {
+            if (groupIsGone(ref.processGroup))
+                return true;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(25, Math.max(1, deadline - Date.now()))));
+        }
+        return groupIsGone(ref.processGroup);
+    };
+    if (groupIsGone(ref.processGroup))
+        return true;
+    // Un PGID ocupado con lider de identidad distinta NO es nuestro. Nunca
+    // usar la falta de match como autorizacion para senializar ese grupo.
+    if (!refIsAlive(ref))
+        return false;
+    try {
+        process.kill(-ref.processGroup, 'SIGTERM');
+    }
+    catch { /* grupo ya ausente */ }
+    if (await waitUntilGone(opts.termGraceMs))
+        return true;
+    try {
+        process.kill(-ref.processGroup, 'SIGKILL');
+    }
+    catch { /* idem */ }
+    return waitUntilGone(opts.killGraceMs);
+}
+/** Drena un grupo cuya propiedad fue capturada por el caller mientras el
+ * lider aun estaba vivo. Se usa inmediatamente tras el exit del lider para
+ * eliminar descendientes remanentes; el PGID no puede reutilizarse mientras
+ * esos miembros sigan presentes. */
+async function terminatePreviouslyOwnedGroup(ref, opts) {
+    const waitUntilGone = async (maxMs) => {
+        const deadline = Date.now() + maxMs;
+        while (Date.now() < deadline) {
+            if (groupIsGone(ref.processGroup))
+                return true;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(25, Math.max(1, deadline - Date.now()))));
+        }
+        return groupIsGone(ref.processGroup);
+    };
+    if (groupIsGone(ref.processGroup))
+        return true;
+    try {
+        process.kill(-ref.processGroup, 'SIGTERM');
+    }
+    catch { /* ya ausente */ }
+    if (await waitUntilGone(opts.termGraceMs))
+        return true;
+    try {
+        process.kill(-ref.processGroup, 'SIGKILL');
+    }
+    catch { /* ya ausente */ }
+    return waitUntilGone(opts.killGraceMs);
+}

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

@@ -0,0 +1,142 @@
+"use strict";
+// Redacción EN EL EMISOR, antes de cualquier escritura (design R2.3).
+// Patrones alineados con el sensor-pack de secretos del registry baseline.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactText = redactText;
+exports.findLiteralSecretFlag = findLiteralSecretFlag;
+exports.redactArgv = redactArgv;
+const SECRET_WORD = /(password|passwd|secret|api[-_]?key|apikey|token|credential)/i;
+// ASSIGNMENT (regex de único backtracking) tuvo 3 rondas de fallas reales:
+// sin cota => ReDoS cuadrático (corridas largas sin match, o muchas
+// ocurrencias sueltas del keyword sin separador); cotado en ambos lados =>
+// fuga de secretos con identificadores largos entre el keyword y el "=".
+// Sustituido por escaneo manual caracter-a-caracter: O(n) sin backtracking,
+// sin cota de longitud posible en ningún lado, inmune a ambos hallazgos.
+const KEYWORD_RE = /password|passwd|secret|api[-_]?key|apikey|token|credential/gi;
+const IDENT_CHAR = /[a-z0-9_-]/i;
+const WHITESPACE = /\s/;
+// Distinto de SECRET_WORD (substring, para nombres de flag reales): aquí el
+// keyword debe ser un segmento completo delimitado por -, _ o los bordes del
+// string. Se usa SOLO dentro de redactArgv para decidir hasta dónde extender
+// la redacción en cadena — nunca para decidir SI redactar: ver comentario en
+// redactArgv sobre por qué la ambigüedad siempre se resuelve redactando de
+// más, nunca de menos.
+const SECRET_FLAG_SEGMENT = /(^|[-_])(password|passwd|secret|api[-_]?key|apikey|token|credential)($|[-_])/i;
+function looksLikeSensitiveFlag(token) {
+    if (!token.startsWith('-'))
+        return false;
+    const eq = token.indexOf('=');
+    const flag = eq === -1 ? token : token.slice(0, eq);
+    return SECRET_FLAG_SEGMENT.test(flag.replace(/^-+/, ''));
+}
+function redactText(text) {
+    let result = '';
+    let cursor = 0;
+    KEYWORD_RE.lastIndex = 0;
+    let m;
+    while ((m = KEYWORD_RE.exec(text)) !== null) {
+        if (m.index < cursor)
+            continue;
+        let keyEnd = m.index + m[0].length;
+        while (keyEnd < text.length && IDENT_CHAR.test(text[keyEnd]))
+            keyEnd++;
+        let sepStart = keyEnd;
+        while (sepStart < text.length && WHITESPACE.test(text[sepStart]))
+            sepStart++;
+        if (sepStart >= text.length || (text[sepStart] !== '=' && text[sepStart] !== ':')) {
+            KEYWORD_RE.lastIndex = keyEnd;
+            continue;
+        }
+        let valueStart = sepStart + 1;
+        while (valueStart < text.length && WHITESPACE.test(text[valueStart]))
+            valueStart++;
+        if (valueStart >= text.length) {
+            KEYWORD_RE.lastIndex = keyEnd;
+            continue;
+        }
+        let valueEnd = valueStart;
+        while (valueEnd < text.length && !WHITESPACE.test(text[valueEnd]))
+            valueEnd++;
+        result += text.slice(cursor, valueStart) + '[REDACTED]';
+        cursor = valueEnd;
+        KEYWORD_RE.lastIndex = cursor;
+    }
+    result += text.slice(cursor);
+    return result;
+}
+/** Flag sensible que porta un secreto LITERAL (no una referencia `-env`):
+ *  la request se rechaza, no se persiste ni redactada (R2.3). Deliberadamente
+ *  NO intenta distinguir "el siguiente token es un flag hermano" de "es el
+ *  valor literal": el rechazo es todo-o-nada (emitRequest lanza antes de
+ *  persistir nada), así que la ambigüedad nunca importa — cualquier token
+ *  después de un flag sensible ya es motivo suficiente de rechazo.
+ *
+ *  LIMITACIÓN ACEPTADA (no es un bug pendiente): esta función solo reconoce
+ *  secretos cuyo NOMBRE de flag contiene una palabra clave (password/token/
+ *  secret/api-key/credential), sea con cualquier cantidad de guiones (-token, --token).
+ *  Mnemónicos de una sola letra sin texto ninguno (ej. `-p` de mysql, `-i` de
+ *  ssh, `-u` de curl) son indistinguibles de cualquier otro flag corto por
+ *  texto solo — cerrar ese caso exigiría una tabla fija de convenciones por
+ *  herramienta externa, que es enumeración no acotada y no pertenece a un
+ *  mecanismo genérico (ver CLAUDE.md, frontera genérico/específico). Si esto
+ *  resulta ser un problema real y recurrente en este proyecto, se resuelve
+ *  vía harness-retro con una regla específica, no aquí. */
+function findLiteralSecretFlag(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('-'))
+            continue;
+        const eq = arg.indexOf('=');
+        const flag = eq === -1 ? arg : arg.slice(0, eq);
+        const inlineValue = eq === -1 ? undefined : arg.slice(eq + 1);
+        if (!SECRET_WORD.test(flag))
+            continue;
+        if (/-env$/i.test(flag))
+            continue; // referencia, permitida (R4.7)
+        const value = inlineValue !== undefined ? inlineValue : argv[i + 1];
+        if (value !== undefined)
+            return flag;
+    }
+    return null;
+}
+/** A diferencia de findLiteralSecretFlag (todo-o-nada), esta función SÍ debe
+ *  devolver un array persistible — no puede simplemente rechazar. Cuando el
+ *  token que sigue a un flag sensible también PARECE un flag sensible, es
+ *  imposible distinguir por texto solo "es un flag hermano real" de "es el
+ *  valor literal (adversario) del flag anterior disfrazado de flag" — ambas
+ *  lecturas son indistinguibles sin un esquema de flags real (hallazgo de
+ *  spec-review, R2.3). Ante esa ambigüedad se redacta TODA la cadena de
+ *  tokens con forma de flag sensible más el token final que la cierra,
+ *  nunca menos: sobre-redactar un nombre de flag es un costo cosmético,
+ *  dejar pasar un secreto no lo es. */
+function redactArgv(argv) {
+    const out = [];
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        const eq = arg.indexOf('=');
+        const flag = eq === -1 ? arg : arg.slice(0, eq);
+        const isSensitive = arg.startsWith('-') && SECRET_WORD.test(flag) && !/-env$/i.test(flag);
+        if (!isSensitive) {
+            out.push(redactText(arg));
+            i++;
+            continue;
+        }
+        if (eq !== -1) {
+            out.push(`${flag}=[REDACTED]`);
+            i++;
+            continue;
+        }
+        out.push(arg);
+        i++;
+        while (i < argv.length && looksLikeSensitiveFlag(argv[i])) {
+            out.push('[REDACTED]');
+            i++;
+        }
+        if (i < argv.length) {
+            out.push('[REDACTED]');
+            i++;
+        }
+    }
+    return out;
+}