agentic-workflow-manager 9.5.0 → 9.6.1

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

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planV2Migration = planV2Migration;
+exports.replaceV2ManifestWithV3 = replaceV2ManifestWithV3;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const contract_1 = require("./compatibility/contract");
+const manifest_1 = require("./compatibility/manifest");
+const safe_file_1 = require("./compatibility/safe-file");
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function sameSensorField(v2, v3, pick) {
+    const names = Object.keys(v2.sensors);
+    return names.length === Object.keys(v3.sensors).length
+        && names.every(name => name in v3.sensors && JSON.stringify(pick(v2.sensors[name])) === JSON.stringify(pick(v3.sensors[name])));
+}
+function compareV2Semantics(v2, v3, registry) {
+    return Object.freeze({
+        pack: v2.pack === v3.pack && v2.packSelection === v3.packSelection,
+        enabledDisabled: sameSensorField(v2, v3, sensor => sensor.enabled),
+        structuredCommands: sameSensorField(v2, v3, sensor => sensor.command),
+        assets: sameSensorField(v2, v3, sensor => sensor.assets),
+        timeouts: sameSensorField(v2, v3, sensor => sensor.timeout),
+        fast: sameSensorField(v2, v3, sensor => sensor.fast),
+        variants: sameSensorField(v2, v3, sensor => sensor.variantId),
+        policies: sameSensorField(v2, v3, sensor => sensor.policyRef),
+        sensorIdentityAndOrder: JSON.stringify(Object.keys(v2.sensors)) === JSON.stringify(Object.keys(v3.sensors)),
+        concurrency: v2.concurrency === v3.concurrency,
+        compatibilityEvidence: sameSensorField(v2, v3, sensor => sensor.initializedCompatibility),
+        packageRoot: v2.packageRoot === v3.packageRoot,
+        logicalSourceBinding: v3.source.registry === registry,
+    });
+}
+function allEquivalent(report) {
+    return Object.values(report).every(value => value === true);
+}
+function exactLogicalSource(input, pack) {
+    if (!isRecord(input))
+        throw new Error('v2 migration source is required');
+    if (input.kind === 'source-unavailable')
+        throw new Error('v2 migration source is unavailable');
+    if (input.kind === 'source-ambiguous')
+        throw new Error('v2 migration source is ambiguous');
+    if ((input.kind !== 'logical' && input.kind !== 'legacy-rebound') || !isRecord(input.source))
+        throw new Error('v2 migration source must be a unique logical resolution');
+    const source = input.source;
+    if (Object.keys(source).some(key => !['path', 'content', 'registry'].includes(key))
+        || typeof source.path !== 'string' || typeof source.content !== 'string' || !isRecord(source.registry)) {
+        throw new Error('v2 migration source must contain an exact resolved pack');
+    }
+    const registry = source.registry;
+    if (Object.keys(registry).some(key => !['name', 'remote', 'contentRoot'].includes(key))
+        || typeof registry.name !== 'string' || !/^[a-z][a-z0-9-]*$/.test(registry.name)
+        || typeof registry.remote !== 'string' || registry.remote.trim() === '' || /[\0\r\n]/.test(registry.remote)
+        || typeof registry.contentRoot !== 'string' || !path_1.default.isAbsolute(registry.contentRoot) || path_1.default.normalize(registry.contentRoot) !== registry.contentRoot) {
+        throw new Error('v2 migration source registry must be a stable logical registry');
+    }
+    // `resolveSensorSource` already selected and read this exact source. The
+    // migration planner consumes that immutable snapshot; re-canonicalizing its
+    // host directory would make a no-write plan depend on later filesystem state.
+    const expectedPath = path_1.default.join(registry.contentRoot, 'sensor-packs', pack, 'pack.json');
+    if (source.path !== expectedPath)
+        throw new Error('v2 migration source must contain an exact resolved pack');
+    let parsedSource;
+    try {
+        parsedSource = (0, contract_1.parseSensorPack)(JSON.parse(source.content), 'v2 migration resolved source');
+    }
+    catch {
+        throw new Error('v2 migration source exact v2 pack is invalid');
+    }
+    if (parsedSource.kind !== 'v2' || parsedSource.pack.name !== pack)
+        throw new Error('v2 migration source must contain the exact v2 pack');
+    return source;
+}
+function assertSourceCompatibleWithManifest(source, manifest) {
+    let parsedSource;
+    try {
+        parsedSource = (0, contract_1.parseSensorPack)(JSON.parse(source.content), 'v2 migration resolved source');
+    }
+    catch {
+        throw new Error('v2 migration source exact v2 pack is invalid');
+    }
+    if (parsedSource.kind !== 'v2' || parsedSource.pack.name !== manifest.pack) {
+        throw new Error('v2 migration source must contain the exact v2 pack');
+    }
+    for (const [name, sensor] of Object.entries(manifest.sensors)) {
+        const selected = parsedSource.pack.sensors[name];
+        if (!selected || !selected.variants.some(variant => variant.id === sensor.variantId)) {
+            throw new Error('v2 migration source is not compatible with selected manifest sensors');
+        }
+    }
+}
+function hasPhysicalSensorPath(value, registryRoots) {
+    if (typeof value === 'string') {
+        const normalized = path_1.default.posix.normalize(value.replace(/\\/g, '/')).toLowerCase();
+        const withoutWebUrls = value.replace(/https?:\/\/[^\s"']+/gi, '');
+        const roots = registryRoots
+            .filter((root) => typeof root === 'string' && root.length > 0)
+            .map(root => path_1.default.posix.normalize(root.replace(/\\/g, '/')).toLowerCase());
+        const hasAbsolutePathAtTokenBoundary = /(?:^|[^A-Za-z0-9_.~\/\\-])["']?(?:\/|\\|[A-Za-z]:|\/\/)/.test(withoutWebUrls);
+        return roots.some(root => normalized.includes(root))
+            || hasAbsolutePathAtTokenBoundary;
+    }
+    return Array.isArray(value) ? value.some(item => hasPhysicalSensorPath(item, registryRoots))
+        : isRecord(value) && Object.values(value).some(item => hasPhysicalSensorPath(item, registryRoots));
+}
+function inspectManifest(manifestPath, failure) {
+    let stat;
+    try {
+        stat = fs_1.default.lstatSync(manifestPath, { bigint: true });
+    }
+    catch {
+        throw failure('open');
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw failure('regular');
+    return { stat, ...(0, safe_file_1.readInspectedBoundedFileWithIdentity)(manifestPath, stat, 1024 * 1024, failure) };
+}
+function assertManifestUnchanged(manifestPath, original) {
+    const changed = () => new Error('v2 migration original manifest changed before commit');
+    const current = inspectManifest(manifestPath, () => changed());
+    if (current.stat.dev !== original.stat.dev || current.stat.ino !== original.stat.ino
+        || current.stat.size !== original.stat.size || !current.content.equals(original.content)) {
+        throw changed();
+    }
+}
+/** Build, but never persist, a portable v3 replacement for a validated v2 manifest. */
+function planV2Migration(input) {
+    if (!input || typeof input !== 'object')
+        throw new Error('v2 migration input is required');
+    const parsed = (0, manifest_1.parseSensorManifest)(input.manifest, 'v2 migration manifest');
+    if (parsed.kind !== 'v2')
+        throw new Error('v2 migration requires a v2 project-sensors manifest');
+    const source = exactLogicalSource(input.source, parsed.pack.pack);
+    assertSourceCompatibleWithManifest(source, parsed.pack);
+    if (hasPhysicalSensorPath(parsed.pack.sensors, [parsed.pack.registryRoot, source.registry.contentRoot])
+        || hasPhysicalSensorPath(parsed.pack.packageRoot, []))
+        throw new Error('v2 migration sensor semantics contain a physical path');
+    const candidate = {
+        schemaVersion: 3,
+        mode: 'project-sensors',
+        pack: parsed.pack.pack,
+        ...(parsed.pack.packSelection === 'explicit' ? { packSelection: 'explicit' } : {}),
+        source: { registry: source.registry.name },
+        ...(parsed.pack.packageRoot ? { packageRoot: parsed.pack.packageRoot } : {}),
+        sensors: parsed.pack.sensors,
+        ...(parsed.pack.concurrency ? { concurrency: parsed.pack.concurrency } : {}),
+    };
+    const validated = (0, manifest_1.parseSensorManifest)(candidate, 'v2 migration candidate');
+    if (validated.kind !== 'v3' || validated.pack.mode !== 'project-sensors') {
+        throw new Error('v2 migration candidate semantic mismatch');
+    }
+    const equivalence = compareV2Semantics(parsed.pack, validated.pack, source.registry.name);
+    if (!allEquivalent(equivalence))
+        throw new Error('v2 migration candidate semantic mismatch');
+    return { candidate: validated.pack, equivalent: true, equivalence };
+}
+/** Validate the old and new durable contracts, then atomically replace only the manifest. */
+function replaceV2ManifestWithV3(manifestPath, candidate, source) {
+    if (typeof manifestPath !== 'string' || !path_1.default.isAbsolute(manifestPath) || path_1.default.normalize(manifestPath) !== manifestPath
+        || manifestPath.includes('\0') || path_1.default.basename(manifestPath) !== 'sensors.json'
+        || path_1.default.basename(path_1.default.dirname(manifestPath)) !== '.awm') {
+        throw new Error('v2 migration manifest path must be the canonical project manifest <project>/.awm/sensors.json');
+    }
+    const manifestDirectory = path_1.default.dirname(manifestPath);
+    const projectRoot = path_1.default.dirname(manifestDirectory);
+    const destination = '.awm/sensors.json';
+    (0, safe_file_1.withProjectLease)(projectRoot, () => {
+        const originalFailure = (_reason) => new Error('v2 migration original manifest must be readable JSON');
+        let inspected;
+        let original;
+        try {
+            inspected = inspectManifest(manifestPath, originalFailure);
+            original = JSON.parse(inspected.content.toString('utf8'));
+        }
+        catch {
+            throw new Error('v2 migration original manifest must be readable JSON');
+        }
+        const before = (0, manifest_1.parseSensorManifest)(original, manifestPath);
+        const after = (0, manifest_1.parseSensorManifest)(candidate, 'v2 migration candidate');
+        if (before.kind !== 'v2' || after.kind !== 'v3' || after.pack.mode !== 'project-sensors') {
+            throw new Error('v2 migration candidate semantic mismatch');
+        }
+        const logicalSource = exactLogicalSource(source, before.pack.pack);
+        assertSourceCompatibleWithManifest(logicalSource, before.pack);
+        if (after.pack.source.registry !== logicalSource.registry.name) {
+            throw new Error('v2 migration candidate semantic mismatch');
+        }
+        if (hasPhysicalSensorPath(before.pack.sensors, [before.pack.registryRoot, logicalSource.registry.contentRoot])
+            || hasPhysicalSensorPath(after.pack.sensors, [before.pack.registryRoot, logicalSource.registry.contentRoot])
+            || hasPhysicalSensorPath(before.pack.packageRoot, []) || hasPhysicalSensorPath(after.pack.packageRoot, [])) {
+            throw new Error('v2 migration candidate contains a physical path');
+        }
+        if (!allEquivalent(compareV2Semantics(before.pack, after.pack, logicalSource.registry.name))) {
+            throw new Error('v2 migration candidate semantic mismatch');
+        }
+        // The native implementation reopens every ancestor without following links,
+        // verifies these exact bytes at the publication fence, and preserves a
+        // competing target instead of replacing it.
+        assertManifestUnchanged(manifestPath, inspected);
+        (0, safe_file_1.writeProjectFile)(projectRoot, destination, Buffer.from((0, manifest_1.serializeManifestV3)(after.pack), 'utf8'), {
+            mode: 'replace', expected: inspected.content, expectedIdentity: inspected.identity, createParents: false,
+        });
+    });
+}

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

@@ -16,7 +16,7 @@ Object.defineProperty(exports, "applyBaseline", { enumerable: true, get: functio
 const changed_1 = require("./changed");
 // Solo `detectStack` (puro, lee el arbol) — NO `initSensors`, que escribe. `run` es un
 // verbo de lectura: no debe tener a mano ninguna funcion capaz de mutar el proyecto.
-const init_1 = require("./init");
+const detection_1 = require("./detection");
 const live_1 = require("./compatibility/live");
 const contract_1 = require("./compatibility/contract");
 const source_1 = require("./compatibility/source");
@@ -67,7 +67,7 @@ function findManifestDir(startCwd) {
  * and failed on by preflight's `pack` check.
  */
 function detectPackDrift(manifestDir, manifest) {
-    const detection = (0, init_1.detectStack)(manifestDir);
+    const detection = (0, detection_1.detectStack)(manifestDir);
     if (manifest.pack !== 'generic' || detection.pack === 'generic')
         return { detection };
     return {

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/init/steps.js

@@ -23,7 +23,8 @@ exports.stepContextInjection = stepContextInjection;
 const registries_1 = require("../registries");
 const install_1 = require("../../commands/hooks/install");
 const bundle_install_1 = require("../bundle-install");
-const init_1 = require("../../commands/sensors/init");
+const bootstrap_1 = require("../../commands/sensors/bootstrap");
+const detection_1 = require("../../commands/sensors/detection");
 const profile_1 = require("../profile");
 const context_1 = require("../diagnostics/context");
 const detector_1 = require("./detector");
@@ -66,15 +67,15 @@ exports.defaultActions = {
         contentDir: o.contentDir,
     }),
     initSensors: async (o) => {
-        const result = await (0, init_1.initSensors)({ cwd: o.cwd, registryRoot: o.registryRoot, configure: o.configure });
-        // `unavailablePack`/`manifest` viajan a proposito: `stepSensors` los reporta.
-        // Este wrapper proyectaba solo `detection`, asi que cualquier hallazgo nuevo de
-        // initSensors moria aca en silencio antes de llegar al step que lo muestra.
-        return {
-            detection: result.detection,
-            manifest: { pack: result.manifest.pack },
-            ...(result.unavailablePack ? { unavailablePack: result.unavailablePack } : {}),
-        };
+        const plan = await (0, bootstrap_1.planSensorBootstrap)(o.cwd, { mode: 'project-sensors', registryRoot: o.registryRoot, configure: o.configure });
+        if (plan.kind === 'blocked')
+            throw new Error(`sensor bootstrap blocked: ${plan.reason}; ${plan.remedy}`);
+        if (plan.kind === 'migrate')
+            throw new Error('sensor init does not migrate an existing v2 manifest; run awm sensors bootstrap');
+        if (plan.kind === 'create')
+            (0, bootstrap_1.applySensorBootstrap)(plan);
+        const pack = plan.kind === 'create' && plan.manifest.mode === 'project-sensors' ? plan.manifest.pack : (0, detection_1.detectStack)(o.cwd).pack;
+        return { detection: { pack }, manifest: { pack } };
     },
     addExtension: (root, name) => { (0, profile_1.addExtension)(root, name); },
     ensureProfile: (root) => { (0, profile_1.ensureProfile)(root); },
@@ -325,7 +326,19 @@ async function stepSensors(d) {
         return ok('project.sensors', 'project', 'skipped', 'no project');
     if (proj.sensors.present)
         return ok('project.sensors', 'project', 'skipped');
-    const res = await d.actions.initSensors({ cwd: proj.root, registryRoot: d.sensorPacksRoot, configure: true });
+    if (!d.sensorPacksRoot)
+        return ok('project.sensors', 'project', 'skipped', 'no configured sensor-pack registry');
+    let res;
+    try {
+        res = await d.actions.initSensors({ cwd: proj.root, registryRoot: d.sensorPacksRoot, configure: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/^(?:source-unavailable|source-unsupported|registry-root-not-configured|sensor-variant-unresolvable):/.test(message)) {
+            return ok('project.sensors', 'project', 'skipped', message);
+        }
+        throw error;
+    }
     // A registry without the detected pack yields a fallback (or empty) manifest. The
     // step still succeeded — a manifest was written — but reporting a bare 'applied'
     // would let `awm init` hand back a quality gate that measures less than the

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`