agentic-workflow-manager 9.7.0 → 9.8.0

package/dist/src/core/admission/registry-contracts.js

@@ -0,0 +1,290 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumedRegistryContracts = consumedRegistryContracts;
+exports.registryCompatibility = registryCompatibility;
+exports.admitRegistryPlan = admitRegistryPlan;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const providers_1 = require("../../providers");
+const registry_1 = require("../renderers/registry");
+const registries_1 = require("../registries");
+const native_bridge_1 = require("../secure-fs/native-bridge");
+const json_1 = require("../plan/json");
+const cli_version_1 = require("../cli-version");
+const versioning_1 = require("../versioning");
+const check_1 = require("../currentness/check");
+const run_1 = require("../../commands/sensors/run");
+const index_1 = require("./index");
+const FRAMEWORK_CONTRACTS = ['using-awm', 'writing-plans', 'development-process', 'subagent-driven-development', 'executing-plans', 'post-implementation-qa', 'post-implementation-docs', 'harness-retro', 'finishing-a-development-branch'];
+const MAX_CONTRACT_BYTES = 1024 * 1024;
+const MAX_MANIFEST_BYTES = 256 * 1024;
+const MAX_DIRECTORY_ENTRIES = 10000;
+function unknown(message) {
+    return { provenance: 'unknown', consumedRegistryComponents: [], provenanceDiagnostic: { code: 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED', message: `${message} Repair the installed runtime artifact or registry provenance before dispatch.` } };
+}
+function within(root, candidate) {
+    const relative = path_1.default.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path_1.default.sep}`) && relative !== '..' && !path_1.default.isAbsolute(relative));
+}
+function physicalDirectory(directory) {
+    const physical = fs_1.default.realpathSync.native(directory);
+    if (!fs_1.default.lstatSync(physical).isDirectory())
+        throw new Error('path is not a directory');
+    const handle = fs_1.default.opendirSync(physical);
+    try {
+        let entries = 0;
+        while (handle.readSync() !== null)
+            if (++entries > MAX_DIRECTORY_ENTRIES)
+                throw new Error('directory entry limit exceeded');
+    }
+    finally {
+        handle.closeSync();
+    }
+    return physical;
+}
+function filesystemIdentity(file) {
+    const stat = fs_1.default.lstatSync(file, { bigint: true });
+    if (stat.isSymbolicLink() || stat.ino === 0n)
+        throw new Error('filesystem identity is unavailable');
+    return `${stat.dev.toString()}:${stat.ino.toString()}`;
+}
+/** Native descriptor bytes plus exact bigint leaf identity are observed only
+ * in memory. No source body or new journal snapshot is persisted. */
+function contractFileIdentity(file) {
+    const before = fs_1.default.lstatSync(file, { bigint: true });
+    if (!before.isFile() || before.isSymbolicLink() || before.ino === 0n)
+        throw new Error('contract identity is unavailable');
+    const bytes = native_bridge_1.secureFs.readRegularFile(file, MAX_CONTRACT_BYTES).bytes;
+    const after = fs_1.default.lstatSync(file, { bigint: true });
+    if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino
+        || before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs)
+        throw new Error('contract identity changed during inspection');
+    return crypto_1.default.createHash('sha256').update(`${before.dev.toString()}:${before.ino.toString()}\0`).update(bytes).digest('hex');
+}
+/** ENOENT proves absence only when the nearest existing parent is readable.
+ * A dangling/replaced ancestor never certifies an empty provider install. */
+function directoryExists(directory) {
+    let current = directory;
+    while (true) {
+        try {
+            fs_1.default.lstatSync(current);
+            physicalDirectory(current);
+            return current === directory;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            const parent = path_1.default.dirname(current);
+            if (parent === current)
+                throw error;
+            // An existing dangling symlink causes realpath ENOENT; do not
+            // continue above it as though the requested install were absent.
+            try {
+                if (fs_1.default.lstatSync(current).isSymbolicLink())
+                    throw new Error('dangling directory ancestor');
+            }
+            catch (inspection) {
+                if (inspection.code !== 'ENOENT')
+                    throw inspection;
+            }
+            current = parent;
+        }
+    }
+}
+/** Physical sources AND actual provider artifacts define consumption. Copied
+ * rendered artifacts have no owner proof; a basename is never provenance. */
+function consumedRegistryContracts(report, cwd, registries, target) {
+    if (report.state !== 'valid')
+        return unknown('A validated compact plan is required.');
+    if (!Array.isArray(registries) || registries.length > 256)
+        return unknown('Registry inventory is invalid or unbounded.');
+    let root;
+    try {
+        root = physicalDirectory(path_1.default.resolve(cwd));
+    }
+    catch {
+        return unknown('Project root provenance is unavailable.');
+    }
+    const physicalRegistries = [];
+    for (const registry of registries) {
+        try {
+            if (!registry || typeof registry.name !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}$/.test(registry.name)
+                || typeof registry.contentRoot !== 'string' || registry.contentRoot.length > 4096
+                || typeof registry.remote !== 'string' || registry.remote.length > 4096)
+                throw new Error('invalid registry identity');
+            const physicalRoot = physicalDirectory(registry.contentRoot);
+            physicalRegistries.push({ name: registry.name, root: physicalRoot, identity: filesystemIdentity(physicalRoot), remote: registry.remote });
+        }
+        catch {
+            const name = typeof registry?.name === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}$/.test(registry.name) ? registry.name : 'unknown';
+            return unknown(`Registry ${name} root cannot be inspected.`);
+        }
+    }
+    const consumed = new Set();
+    const identities = [];
+    for (const source of report.manifest.sources) {
+        try {
+            const file = fs_1.default.realpathSync.native(path_1.default.resolve(root, source.path));
+            if (!within(root, file))
+                return unknown(`Plan source ${source.path} escapes its physical project root.`);
+            identities.push(JSON.stringify(['source', source.id, contractFileIdentity(file)]));
+            for (const registry of physicalRegistries)
+                if (within(registry.root, file))
+                    consumed.add(`registry:${registry.name}`);
+        }
+        catch {
+            return unknown(`Plan source ${source.path} cannot be inspected as a bounded regular file.`);
+        }
+    }
+    const provider = (0, providers_1.providerFor)(target);
+    const directories = [provider.skill.global, path_1.default.resolve(root, provider.skill.local)].filter((directory) => directory !== null);
+    for (const directory of directories) {
+        try {
+            if (!directoryExists(directory))
+                continue;
+        }
+        catch {
+            return unknown(`Provider ${target} install directory ${directory} is unsafe or unreadable.`);
+        }
+        for (const contract of FRAMEWORK_CONTRACTS) {
+            const artifact = path_1.default.join(directory, (0, registry_1.renderedFilename)(contract, provider.skill.renderer));
+            try {
+                fs_1.default.lstatSync(artifact);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                return unknown(`Runtime artifact ${artifact} cannot be inspected.`);
+            }
+            const declaredFile = provider.skill.renderer === 'link' ? path_1.default.join(artifact, 'SKILL.md') : artifact;
+            try {
+                const file = fs_1.default.realpathSync.native(declaredFile);
+                const identity = contractFileIdentity(file);
+                const owners = physicalRegistries.filter(registry => within(registry.root, file));
+                if (owners.length !== 1)
+                    return unknown(`Runtime artifact ${artifact} has no unique physical registry owner (copied/rendered content is not ownership proof).`);
+                consumed.add(`registry:${owners[0].name}`);
+                identities.push(JSON.stringify(['artifact', target, contract, provider.skill.renderer, identity]));
+            }
+            catch {
+                return unknown(`Runtime artifact ${artifact} is dangling, nonregular, unreadable or unbounded.`);
+            }
+        }
+    }
+    for (const registry of physicalRegistries)
+        if (consumed.has(`registry:${registry.name}`))
+            identities.push(JSON.stringify(['registry', registry.name, registry.identity, registry.remote]));
+    return { provenance: 'proven', consumedRegistryComponents: [...consumed].sort(), identityDigest: crypto_1.default.createHash('sha256').update(identities.sort().join('\0')).digest('hex') };
+}
+/** Only the declared CLI floor is consumed here, not a new registry catalog.
+ * The native bounded/no-follow read prevents stat/read races and body leaks. */
+function registryCompatibility(registries, consumed) {
+    const diagnostics = [];
+    const current = (0, cli_version_1.cliVersion)();
+    for (const registry of registries) {
+        const component = `registry:${registry.name}`;
+        if (!consumed.includes(component))
+            continue;
+        try {
+            const physicalRoot = physicalDirectory(registry.contentRoot);
+            const manifest = path_1.default.join(physicalRoot, registries_1.REGISTRY_MANIFEST_NAME);
+            try {
+                fs_1.default.lstatSync(manifest);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            const bytes = native_bridge_1.secureFs.readRegularFile(manifest, MAX_MANIFEST_BYTES).bytes;
+            const raw = (0, json_1.parseJsonNoDuplicate)(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                throw new Error('manifest must be a JSON object');
+            const min = raw.minCliVersion;
+            if (min !== undefined && (typeof min !== 'string' || !/^v?\d+\.\d+\.\d+$/.test(min)
+                || min.replace(/^v/, '').split('.').some(part => !Number.isSafeInteger(Number(part)))))
+                throw new Error('invalid CLI floor');
+            if (typeof min === 'string' && (0, versioning_1.compareSemver)(current, min) < 0)
+                diagnostics.push({ code: 'ADMISSION_REGISTRY_CLI_INCOMPATIBLE', message: `${component} requires CLI >= ${min}; installed CLI is ${current}. Update the CLI before dispatch.` });
+        }
+        catch {
+            diagnostics.push({ code: 'ADMISSION_REGISTRY_COMPATIBILITY_UNVERIFIABLE', message: `${component} manifest compatibility could not be verified as bounded regular JSON. Repair the registry before dispatch.` });
+        }
+    }
+    return diagnostics;
+}
+/** One admission authority for the public command AND actual watch dispatch.
+ * No empirical execution occurs before provenance/currentness/CLI-floor gates. */
+async function admitRegistryPlan(input, dependencies = {}) {
+    const admission = dependencies.admitPlan ?? index_1.admitPlan;
+    if (input.plan.state !== 'valid' || !(0, providers_1.isAgentTarget)(input.provider) || (input.enabledAgents && !input.enabledAgents.includes(input.provider))
+        || (input.executionMode !== undefined && input.executionMode !== 'interactivo' && input.executionMode !== 'desatendido'))
+        return admission(input);
+    let registries = [];
+    let scope;
+    const inventory = dependencies.listRegistries ?? registries_1.listRegistries;
+    const target = input.provider;
+    try {
+        registries = inventory();
+        scope = consumedRegistryContracts(input.plan, input.cwd, registries, target);
+    }
+    catch {
+        scope = unknown('Registry inventory cannot be read.');
+    }
+    const refresh = () => {
+        try {
+            const refreshedRegistries = inventory();
+            const refreshed = consumedRegistryContracts(input.plan, input.cwd, refreshedRegistries, target);
+            const previousComponents = scope.consumedRegistryComponents.join('\0');
+            const previousIdentity = scope.identityDigest;
+            registries = refreshedRegistries;
+            scope = refreshed.provenance === 'unknown' ? refreshed
+                : refreshed.consumedRegistryComponents.join('\0') !== previousComponents || refreshed.identityDigest !== previousIdentity
+                    ? unknown('Consumed registry ownership changed during an asynchronous admission observation. Re-run actual currentness and read-only plan admission.') : refreshed;
+            if (scope.provenanceDiagnostic)
+                scope = { ...scope, provenanceDiagnostic: { ...scope.provenanceDiagnostic, message: `${scope.provenanceDiagnostic.message} Re-run actual currentness after repair.` } };
+        }
+        catch {
+            scope = unknown('Registry inventory changed or cannot be read after asynchronous admission. Re-run actual currentness.');
+        }
+        return scope.provenance === 'proven';
+    };
+    const compose = async (fields) => {
+        const report = await admission({ ...input, provenance: scope.provenance, consumedRegistryComponents: scope.consumedRegistryComponents, ...fields });
+        if (scope.provenanceDiagnostic && report.diagnostics.some(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED')) {
+            return { ...report, diagnostics: report.diagnostics.map(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED' ? scope.provenanceDiagnostic : diagnostic) };
+        }
+        return report;
+    };
+    let currentness = input.currentness;
+    let compatibilityDiagnostics;
+    if (input.requireCurrent) {
+        if (scope.provenance !== 'proven')
+            return compose({});
+        currentness = currentness ?? await (dependencies.checkCurrentness ?? check_1.checkCurrentness)(input.cwd);
+        if (!refresh())
+            return compose({ currentness });
+        // A missing sensor input stages composition before capability resolution.
+        const currentnessGate = await compose({ currentness, verifySensors: true, sensors: undefined });
+        if (currentnessGate.currentness !== 'current')
+            return currentnessGate;
+        compatibilityDiagnostics = registryCompatibility(registries, scope.consumedRegistryComponents);
+        const compatibilityGate = await compose({ currentness, compatibilityDiagnostics, verifySensors: true, sensors: undefined });
+        if (compatibilityGate.currentness !== 'current')
+            return compatibilityGate;
+    }
+    const sensors = input.verifySensors ? input.sensors ?? await (dependencies.runSensors ?? run_1.runSensors)({ cwd: input.cwd, all: true, readOnly: true }) : undefined;
+    if (input.requireCurrent && input.verifySensors) {
+        if (!refresh())
+            return compose({ currentness, sensors });
+        const currentnessGate = await compose({ currentness, verifySensors: true, sensors: undefined });
+        if (currentnessGate.currentness !== 'current')
+            return currentnessGate;
+        compatibilityDiagnostics = registryCompatibility(registries, scope.consumedRegistryComponents);
+    }
+    return compose({ currentness, compatibilityDiagnostics, sensors });
+}

package/dist/src/core/bundle-install.js

@@ -28,8 +28,8 @@ function bundleArtifacts(b, contentDir) {
     // estructural sobre la ruta ya resuelta.
     const refs = [];
     for (const s of b.skills) {
-        (0, artifact_name_1.assertSafeArtifactName)(s.name, 'skill');
-        refs.push({ name: s.name, type: 'skill', installName: s.name, sourcePath: path_1.default.join(contentDir, 'skills', s.name) });
+        (0, artifact_name_1.assertSafeArtifactName)(s, 'skill');
+        refs.push({ name: s, type: 'skill', installName: s, sourcePath: path_1.default.join(contentDir, 'skills', s) });
     }
     for (const w of b.workflows) {
         (0, artifact_name_1.assertSafeArtifactName)(w, 'workflow');

package/dist/src/core/bundles.js

@@ -4,15 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readCatalog = readCatalog;
+exports.inspectBundles = inspectBundles;
+exports.createBundleDiagnosticReporter = createBundleDiagnosticReporter;
 exports.discoverBundles = discoverBundles;
 exports.resolveBundleSkills = resolveBundleSkills;
 exports.resolveBundleAgents = resolveBundleAgents;
 exports.defaultScopeForBundle = defaultScopeForBundle;
+exports.inspectAllBundles = inspectAllBundles;
 exports.discoverAllBundles = discoverAllBundles;
 exports.resolveBundleClosure = resolveBundleClosure;
 const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
 const path_1 = __importDefault(require("path"));
 const registries_1 = require("./registries");
+const text_1 = require("./text");
 function catalogPath(contentDir) {
     return path_1.default.join(contentDir, 'catalog.json');
 }
@@ -85,29 +90,63 @@ function readCatalog(contentDir) {
     // TypeError opaco mas adelante; se descarta aca, nombrando el archivo.
     return bundles.filter((entry) => entry !== null && typeof entry === 'object' && typeof entry.source === 'string');
 }
-/** Tolera `skills` ausente o mal formado: lo que no sea un array se trata como
- *  vacio en vez de tirar `(raw ?? []).map is not a function`, y cada entrada se
- *  valida individualmente. */
-function normalizeSkillRefs(raw) {
-    if (!Array.isArray(raw))
-        return [];
-    return raw.flatMap((s) => {
-        if (typeof s === 'string')
-            return [{ name: s, onSignal: false }];
-        if (s !== null && typeof s === 'object' && typeof s.name === 'string') {
-            return [{ name: s.name, onSignal: s.onSignal === true }];
+function safeManifestIdentity(manifestPath) {
+    const sanitized = (0, text_1.sanitizeDiagnosticText)(manifestPath);
+    if (sanitized.length <= 240)
+        return sanitized;
+    const suffix = crypto_1.default.createHash('sha256').update(sanitized).digest('hex').slice(0, 16);
+    return `${sanitized.slice(0, 220)}…#${suffix}`;
+}
+function boundedDiagnostic(diagnostic) {
+    return (0, text_1.sanitizeDiagnosticText)(diagnostic).slice(0, 512);
+}
+/** Normaliza la única forma de compatibilidad CLI 9 antes de que el manifest
+ * alcance consumidores operativos. Los objetos nunca salen de este límite. */
+function normalizeSkillRefs(raw, manifestPath) {
+    const identity = safeManifestIdentity(manifestPath);
+    if (!Array.isArray(raw)) {
+        throw new Error(`${identity}: "skills" must be an array.`);
+    }
+    const skills = [];
+    let legacyCount = 0;
+    raw.forEach((ref, index) => {
+        const location = `${identity}: skills[${index}]`;
+        if (typeof ref === 'string') {
+            if (ref === '')
+                throw new Error(`${location} must be a non-empty string.`);
+            skills.push(ref);
+            return;
         }
-        return [];
+        if (ref === null || typeof ref !== 'object' || Array.isArray(ref)) {
+            throw new Error(`${location} must be a non-empty string or a supported legacy object.`);
+        }
+        const legacy = ref;
+        const keys = Object.keys(legacy);
+        if (!keys.every((key) => key === 'name' || key === 'onSignal')) {
+            throw new Error(`${location} legacy object may contain only "name" and optional "onSignal".`);
+        }
+        if (typeof legacy.name !== 'string' || legacy.name === '') {
+            throw new Error(`${location} legacy object "name" must be a non-empty string.`);
+        }
+        if (legacy.onSignal !== undefined && typeof legacy.onSignal !== 'boolean') {
+            throw new Error(`${location} legacy object "onSignal" must be a boolean.`);
+        }
+        skills.push(legacy.name);
+        legacyCount++;
     });
+    const diagnostics = legacyCount === 0 ? [] : [boundedDiagnostic(`${identity}: ${legacyCount} legacy object skill reference(s) accepted for CLI 9; ` +
+            'replace with canonical skills: ["skill-name"]. Legacy object support is removed in v10.')];
+    return { skills, diagnostics };
 }
 /** Array de strings, o vacio. Cualquier otra forma en el contenido del registry
  *  se ignora en vez de propagarse hasta un crash aguas abajo. */
 function stringArray(raw) {
     return Array.isArray(raw) ? raw.filter((v) => typeof v === 'string') : [];
 }
-function discoverBundles(contentDir) {
+function inspectBundles(contentDir) {
     const entries = readCatalog(contentDir);
     const bundles = [];
+    const diagnostics = [];
     for (const entry of entries) {
         const manifestPath = bundleManifestPath(contentDir, entry.source);
         if (!(0, registries_1.assertRegularRegistryFile)(manifestPath))
@@ -128,6 +167,8 @@ function discoverBundles(contentDir) {
         if (typeof m.name !== 'string' || m.name === '') {
             throw new Error(`${manifestPath}: "name" must be a non-empty string.`);
         }
+        const normalizedSkills = normalizeSkillRefs(m.skills, manifestPath);
+        diagnostics.push(...normalizedSkills.diagnostics);
         bundles.push({
             name: m.name,
             description: typeof m.description === 'string' ? m.description : '',
@@ -135,13 +176,36 @@ function discoverBundles(contentDir) {
             scope: m.scope ?? 'project',
             visibility: m.visibility ?? 'public',
             dependsOn: stringArray(m.dependsOn),
-            skills: normalizeSkillRefs(m.skills),
+            skills: normalizedSkills.skills,
             workflows: stringArray(m.workflows),
             agents: stringArray(m.agents),
             contentRoot: contentDir,
         });
     }
-    return bundles;
+    return { bundles, diagnostics };
+}
+/** Creates the command-scoped CLI reporter used by discovery facades. */
+function createBundleDiagnosticReporter(write = (message) => console.error(message)) {
+    const emitted = new Set();
+    return (diagnostic) => {
+        const safeDiagnostic = boundedDiagnostic(diagnostic);
+        if (emitted.has(safeDiagnostic))
+            return;
+        emitted.add(safeDiagnostic);
+        write(`warning: ${safeDiagnostic}`);
+    };
+}
+const defaultBundleDiagnosticReporter = createBundleDiagnosticReporter();
+function reportDiagnostics(diagnostics, reporter) {
+    const emit = reporter ?? defaultBundleDiagnosticReporter;
+    for (const diagnostic of new Set(diagnostics))
+        emit(diagnostic);
+}
+/** Compatibility facade for callers that only need bundle definitions. */
+function discoverBundles(contentDir, reporter) {
+    const result = inspectBundles(contentDir);
+    reportDiagnostics(result.diagnostics, reporter);
+    return result.bundles;
 }
 function resolveBundleSkills(bundleName, bundles) {
     const byName = new Map(bundles.map((b) => [b.name, b]));
@@ -157,7 +221,7 @@ function resolveBundleSkills(bundleName, bundles) {
         for (const dep of b.dependsOn)
             visit(dep);
         for (const s of b.skills)
-            skills.add(s.name);
+            skills.add(s);
     };
     visit(bundleName);
     return Array.from(skills);
@@ -192,11 +256,14 @@ function defaultScopeForBundle(scope) {
 /** Descubre bundles de TODOS los roots (base + registries adicionales).
  *  Colisión de nombre entre roots: override declarado en awm-registry.json
  *  del root posterior → reemplaza; no declarado → error nombrando ambas fuentes. */
-function discoverAllBundles(roots = (0, registries_1.contentRoots)()) {
+function inspectAllBundles(roots = (0, registries_1.contentRoots)()) {
     const byName = new Map();
+    const diagnostics = [];
     for (const root of roots) {
         const overrides = (0, registries_1.readRegistryManifest)(root).overrides;
-        for (const b of discoverBundles(root)) {
+        const result = inspectBundles(root);
+        diagnostics.push(...result.diagnostics);
+        for (const b of result.bundles) {
             const prev = byName.get(b.name);
             if (!prev) {
                 byName.set(b.name, b);
@@ -210,7 +277,13 @@ function discoverAllBundles(roots = (0, registries_1.contentRoots)()) {
                 `Remove or rename one of them, or declare "${b.name}" in "overrides" of the later registry's awm-registry.json.`);
         }
     }
-    return Array.from(byName.values());
+    return { bundles: Array.from(byName.values()), diagnostics: Array.from(new Set(diagnostics)) };
+}
+/** Compatibility facade for callers that only need bundle definitions. */
+function discoverAllBundles(roots = (0, registries_1.contentRoots)(), reporter) {
+    const result = inspectAllBundles(roots);
+    reportDiagnostics(result.diagnostics, reporter);
+    return result.bundles;
 }
 /**
  * Resolves the dependency closure of a bundle in deps-first order, deduped.

package/dist/src/core/diagnostics/context.js

@@ -307,7 +307,7 @@ function gatherProject(root, bundles, agent = 'claude-code') {
 }
 function gatherContext(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
-    const bundles = opts.bundles ?? (0, bundles_1.discoverAllBundles)();
+    const bundles = opts.bundles ?? (0, bundles_1.discoverAllBundles)(undefined, opts.reporter);
     const agent = opts.agent ?? 'claude-code';
     const root = (0, profile_1.findProjectRoot)(cwd);
     const agents = opts.agents ?? [agent];

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

@@ -23,7 +23,7 @@ function runExport(opts) {
     }
     const roots = opts.roots ?? (0, registries_1.contentRoots)();
     const outDir = path_1.default.join(opts.out ?? path_1.default.join(process.cwd(), 'awm-export'), target);
-    const resolution = (0, resolve_1.resolveExport)(opts.name, roots);
+    const resolution = (0, resolve_1.resolveExport)(opts.name, roots, opts.reporter);
     fs_1.default.mkdirSync(outDir, { recursive: true });
     const exported = [];
     let zipAvailable = true;

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

@@ -44,8 +44,8 @@ function assertOverrideConsistency(s) {
         throw new Error(`Inconsistent metadata for skill "${s.name}": ${OVERRIDE_FILE} exists but SKILL.md does not declare portable: true.`);
     }
 }
-function resolveExport(requested, roots) {
-    const bundles = (0, bundles_1.discoverAllBundles)(roots);
+function resolveExport(requested, roots, reporter) {
+    const bundles = (0, bundles_1.discoverAllBundles)(roots, reporter);
     if (bundles.some((b) => b.name === requested)) {
         const skills = [];
         const skipped = [];

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileUnattendedRecovery = reconcileUnattendedRecovery;
 exports.resolveWorkingDirectory = resolveWorkingDirectory;
 exports.computeFingerprint = computeFingerprint;
 const crypto_1 = __importDefault(require("crypto"));
@@ -19,8 +20,41 @@ function sha(parts) {
 // 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).
+/** Git's textual plumbing is hashed, never streamed to a terminal. Keep its
+ * memory bounded even for hostile repositories; an incomplete listing must
+ * fail recovery rather than certify a partial fingerprint. */
+const MAX_GIT_OUTPUT_BYTES = 16 * 1024 * 1024;
 function git(cwd, args) {
-    return (0, child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8', maxBuffer: Infinity, stdio: process_1.EXEC_STDIO });
+    try {
+        return (0, child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8', maxBuffer: MAX_GIT_OUTPUT_BYTES, stdio: process_1.EXEC_STDIO });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOBUFS' || error.message.includes('maxBuffer')) {
+            throw new Error(`git fingerprint output exceeded ${MAX_GIT_OUTPUT_BYTES} bytes`);
+        }
+        throw error;
+    }
+}
+function reconcileUnattendedRecovery(input) {
+    const activeJobIds = [...new Set(input.activeJobIds)].sort();
+    const result = (state, nextAction, diagnostics) => ({ state, nextAction, activeJobIds, diagnostics });
+    if (input.journalCorrupt || input.journal === null)
+        return result('blocked', 'repair-journal', ['journal-corrupt-or-missing']);
+    const binding = input.journal.schema === 2 ? input.journal.planBinding : undefined;
+    if (!binding || binding.path !== input.plan.path || binding.digest !== input.plan.digest || binding.schema !== input.plan.schema || binding.executionMode !== 'desatendido')
+        return result('blocked', 'rebind-plan', ['journal-plan-binding-stale']);
+    if (input.git !== 'current')
+        return result('blocked', 'reconcile-git', ['git-fingerprint-changed']);
+    if (activeJobIds.length > 0)
+        return result('ready', 'reconcile-active-jobs', []);
+    if (input.verdicts !== 'current')
+        return result('blocked', 'repair-verdicts', [`verdicts-${input.verdicts}`]);
+    if (input.tests !== 'pass')
+        return result('blocked', 'run-tests', [`tests-${input.tests}`]);
+    if (input.sensors !== 'pass')
+        return result('blocked', 'run-sensors', [`sensors-${input.sensors}`]);
+    return result('ready', 'select-work', []);
 }
 function resolveWorkingDirectory(repoRoot, cwdRel) {
     if (typeof cwdRel !== 'string' || cwdRel.length === 0)

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

@@ -13,6 +13,7 @@ exports.acksDir = acksDir;
 exports.logsDir = logsDir;
 exports.eventsPath = eventsPath;
 exports.exportDir = exportDir;
+exports.bindingPlanPath = bindingPlanPath;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 function branchSlug(branch) {
@@ -63,3 +64,13 @@ function eventsPath(repoRoot, branch) {
 function exportDir(repoRoot, branch) {
     return path_1.default.join(journalDir(repoRoot, branch), 'export');
 }
+/** A persisted binding path is always a normalized repository-relative POSIX path. */
+function bindingPlanPath(planPath) {
+    if (typeof planPath !== 'string' || planPath.length === 0 || planPath.length > 4096 || /[\u0000-\u001F\u007F-\u009F]/.test(planPath))
+        throw new Error('plan path inválido para binding');
+    const normalized = path_1.default.posix.normalize(planPath.replace(/\\/g, '/'));
+    if (path_1.default.posix.isAbsolute(normalized) || path_1.default.win32.isAbsolute(planPath) || normalized === '..' || normalized.startsWith('../') || normalized === '.') {
+        throw new Error('plan path fuera del repositorio para binding');
+    }
+    return normalized;
+}