agentic-workflow-manager 9.16.1 → 9.18.0

package/dist/src/commands/registry/doctor.js

@@ -0,0 +1,428 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorExitCode = doctorExitCode;
+exports.doctorRegistry = doctorRegistry;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const catalog_1 = require("../../core/facts/catalog");
+const needs_1 = require("../../core/facts/needs");
+const types_1 = require("../../core/facts/types");
+const bundles_1 = require("../../core/bundles");
+const registries_1 = require("../../core/registries");
+const versioning_1 = require("../../core/versioning");
+/** Exit code for CLI: structural failures → 1; advisories alone → 0. */
+function doctorExitCode(report) {
+    return report.structural.length ? 1 : 0;
+}
+/** Capability ids the doctor understands in v1; others are advisory (forward-compatible). */
+const KNOWN_CAPABILITY_IDS = new Set(['facts']);
+const CAPABILITIES_HEADER_RE = /^\|\s*id\s*\|\s*status\s*\|\s*notes\s*\|$/i;
+const HOME_PATH_RE = /(^|[^\w])~(\/|\\)/;
+const USERS_PATH_RE = /\/Users\/[^/\s]+/;
+const ADVISORY_CAP = 50;
+const STORE_BASENAMES = new Set(['values.json', 'meta.json']);
+function isMissing(error) {
+    return error?.code === 'ENOENT';
+}
+function walkRegularFiles(root, visit) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === '.git' || entry.name === 'node_modules')
+                continue;
+            const abs = path_1.default.join(dir, entry.name);
+            let stat;
+            try {
+                stat = fs_1.default.lstatSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                stack.push(abs);
+                continue;
+            }
+            if (stat.isFile()) {
+                visit(abs, path_1.default.relative(root, abs));
+            }
+        }
+    }
+}
+function parseCapabilitiesIndex(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const headingIdx = lines.findIndex((l) => /^##\s+Capabilities\s*$/i.test(l.trim()));
+    if (headingIdx === -1) {
+        return { rows: [], errors: ['REGISTRY.md missing ## Capabilities section'] };
+    }
+    let headerIdx = -1;
+    for (let i = headingIdx + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (/^##\s+/.test(line))
+            break;
+        if (CAPABILITIES_HEADER_RE.test(line)) {
+            headerIdx = i;
+            break;
+        }
+    }
+    if (headerIdx === -1) {
+        return {
+            rows: [],
+            errors: ['REGISTRY.md Capabilities index missing | id | status | notes | header'],
+        };
+    }
+    const rows = [];
+    const errors = [];
+    const seen = new Set();
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line === '')
+            continue;
+        if (/^##\s+/.test(line))
+            break;
+        if (!line.startsWith('|'))
+            continue;
+        if (/^\|\s*-+/.test(line))
+            continue; // separator row
+        const cells = line
+            .replace(/^\|/, '')
+            .replace(/\|$/, '')
+            .split('|')
+            .map((c) => c.trim());
+        if (cells.length < 3) {
+            errors.push(`Capabilities row malformed: ${line}`);
+            continue;
+        }
+        const id = cells[0];
+        if (id === '') {
+            errors.push('Capabilities table has empty id');
+            continue;
+        }
+        if (seen.has(id)) {
+            errors.push(`Capabilities table duplicate id "${id}"`);
+            continue;
+        }
+        seen.add(id);
+        rows.push({ id, status: cells[1] ?? '', notes: cells[2] ?? '' });
+    }
+    return { rows, errors };
+}
+/** Collect readable regular SKILL.md paths; symlink / non-regular / unreadable → structural. */
+function collectSkillMdPaths(root, structural) {
+    const skillsRoot = path_1.default.join(root, 'skills');
+    const out = [];
+    if (!fs_1.default.existsSync(skillsRoot))
+        return out;
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(skillsRoot, { withFileTypes: true });
+    }
+    catch (e) {
+        structural.push(`Cannot read skills/: ${e instanceof Error ? e.message : String(e)}`);
+        return out;
+    }
+    for (const entry of entries) {
+        const skillDir = path_1.default.join(skillsRoot, entry.name);
+        const relDir = path_1.default.relative(root, skillDir);
+        let dirStat;
+        try {
+            dirStat = fs_1.default.lstatSync(skillDir);
+        }
+        catch (e) {
+            structural.push(`Cannot inspect skill path ${relDir}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
+        if (dirStat.isSymbolicLink()) {
+            structural.push(`Skill path ${relDir} must not be a symbolic link (fail closed)`);
+            continue;
+        }
+        if (!dirStat.isDirectory()) {
+            // Scaffold tracks empty skills/ with .gitkeep so git clone keeps the
+            // content dir (RF-4.1). Other loose files remain structural.
+            if (entry.name === '.gitkeep' && dirStat.isFile())
+                continue;
+            structural.push(`Skill path ${relDir} must be a regular directory (fail closed)`);
+            continue;
+        }
+        const skillMd = path_1.default.join(skillDir, 'SKILL.md');
+        const relMd = path_1.default.relative(root, skillMd);
+        let mdStat;
+        try {
+            mdStat = fs_1.default.lstatSync(skillMd);
+        }
+        catch (error) {
+            if (isMissing(error))
+                continue;
+            structural.push(`Cannot inspect ${relMd}: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        if (mdStat.isSymbolicLink()) {
+            structural.push(`${relMd} must not be a symbolic link (fail closed)`);
+            continue;
+        }
+        if (!mdStat.isFile()) {
+            structural.push(`${relMd} must be a regular file (fail closed)`);
+            continue;
+        }
+        try {
+            fs_1.default.accessSync(skillMd, fs_1.default.constants.R_OK);
+        }
+        catch (e) {
+            structural.push(`Unreadable ${relMd}: ${e instanceof Error ? e.message : String(e)} (fail closed)`);
+            continue;
+        }
+        out.push(skillMd);
+    }
+    return out;
+}
+/**
+ * RF-4.5: store files under the registry tree are structural.
+ * Symlink entries named `environments`, or basename `values.json`/`meta.json`, are structural
+ * even when the walk does not follow the link.
+ */
+function scanEnvStoreInTree(root, structural) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === '.git' || entry.name === 'node_modules')
+                continue;
+            const abs = path_1.default.join(dir, entry.name);
+            const rel = path_1.default.relative(root, abs);
+            let stat;
+            try {
+                stat = fs_1.default.lstatSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isSymbolicLink()) {
+                if (entry.name === 'environments' || STORE_BASENAMES.has(entry.name)) {
+                    structural.push(`Environment store symlink must not live in the registry tree: ${rel} (RF-4.5)`);
+                }
+                continue;
+            }
+            if (stat.isDirectory()) {
+                stack.push(abs);
+                continue;
+            }
+            if (stat.isFile()) {
+                const parts = rel.split(/[/\\]/);
+                if (parts.includes('environments') && STORE_BASENAMES.has(entry.name)) {
+                    structural.push(`Environment store file must not live in the registry tree: ${rel} (RF-4.5)`);
+                }
+            }
+        }
+    }
+}
+function scanProsePathHints(root, advisories) {
+    const skillsRoot = path_1.default.join(root, 'skills');
+    if (!fs_1.default.existsSync(skillsRoot))
+        return;
+    walkRegularFiles(skillsRoot, (abs, rel) => {
+        if (!abs.endsWith('.md'))
+            return;
+        if (advisories.length >= ADVISORY_CAP)
+            return;
+        let text;
+        try {
+            text = fs_1.default.readFileSync(abs, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        for (const line of text.split(/\r?\n/)) {
+            if (advisories.length >= ADVISORY_CAP)
+                return;
+            if (HOME_PATH_RE.test(line) || USERS_PATH_RE.test(line)) {
+                advisories.push(`Possible machine path in ${rel}: prefer a fact (e.g. ~/Developments or /Users/…)`);
+                break;
+            }
+        }
+    });
+}
+function checkVersionCoherence(root, structural) {
+    let entries;
+    try {
+        entries = (0, bundles_1.readCatalog)(root);
+    }
+    catch (e) {
+        structural.push(`catalog.json unreadable: ${e instanceof Error ? e.message : String(e)}`);
+        return;
+    }
+    for (const entry of entries) {
+        if (typeof entry.version !== 'string')
+            continue;
+        const bundlePath = path_1.default.join(root, entry.source, 'bundle.json');
+        let stat;
+        try {
+            stat = fs_1.default.lstatSync(bundlePath);
+        }
+        catch (error) {
+            if (isMissing(error))
+                continue;
+            structural.push(`Cannot inspect ${path_1.default.relative(root, bundlePath)}`);
+            continue;
+        }
+        if (!stat.isFile() || stat.isSymbolicLink())
+            continue;
+        let raw;
+        try {
+            raw = JSON.parse(fs_1.default.readFileSync(bundlePath, 'utf-8'));
+        }
+        catch (e) {
+            structural.push(`bundle.json invalid at ${path_1.default.relative(root, bundlePath)}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
+        const bundleVersion = raw !== null && typeof raw === 'object' && typeof raw.version === 'string'
+            ? raw.version
+            : undefined;
+        if (bundleVersion !== undefined && bundleVersion !== entry.version) {
+            structural.push(`Bundle "${entry.name}" version skew: catalog=${entry.version} bundle.json=${bundleVersion} (RF-4.7)`);
+        }
+    }
+}
+/**
+ * Structural + advisory audit of a registry tree. Path-only API (RF-5.1) — schema/doctor are the gates.
+ */
+function doctorRegistry(root) {
+    const structural = [];
+    const advisories = [];
+    if (typeof root !== 'string' || root.trim() === '') {
+        return {
+            structural: ['Registry root must be a non-empty string'],
+            advisories,
+        };
+    }
+    const resolvedRoot = path_1.default.resolve(root);
+    if (!fs_1.default.existsSync(resolvedRoot) || !fs_1.default.statSync(resolvedRoot).isDirectory()) {
+        return { structural: [`Registry root does not exist or is not a directory: ${resolvedRoot}`], advisories };
+    }
+    let manifestMin;
+    try {
+        const manifest = (0, registries_1.readRegistryManifest)(resolvedRoot);
+        manifestMin = manifest.minCliVersion;
+    }
+    catch (e) {
+        structural.push(`awm-registry.json invalid: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const handbookPath = path_1.default.join(resolvedRoot, 'REGISTRY.md');
+    if (!fs_1.default.existsSync(handbookPath)) {
+        structural.push('missing REGISTRY.md');
+    }
+    else {
+        let handbook;
+        try {
+            handbook = fs_1.default.readFileSync(handbookPath, 'utf-8');
+        }
+        catch (e) {
+            structural.push(`Cannot read REGISTRY.md: ${e instanceof Error ? e.message : String(e)}`);
+            handbook = '';
+        }
+        if (handbook) {
+            const caps = parseCapabilitiesIndex(handbook);
+            structural.push(...caps.errors);
+            for (const row of caps.rows) {
+                if (!KNOWN_CAPABILITY_IDS.has(row.id)) {
+                    if (advisories.length < ADVISORY_CAP) {
+                        advisories.push(`Unknown capability id "${row.id}" in REGISTRY.md (advisory; RF-4.6)`);
+                    }
+                }
+            }
+        }
+    }
+    checkVersionCoherence(resolvedRoot, structural);
+    scanEnvStoreInTree(resolvedRoot, structural);
+    const factsPath = path_1.default.join(resolvedRoot, 'facts.json');
+    let catalog = null;
+    let factsPresent = false;
+    try {
+        const factsStat = fs_1.default.lstatSync(factsPath);
+        factsPresent = true;
+        if (factsStat.isSymbolicLink()) {
+            structural.push('facts.json must not be a symbolic link (regular-file guard)');
+        }
+        else if (!factsStat.isFile()) {
+            structural.push('facts.json must be a regular file');
+        }
+        else {
+            try {
+                catalog = (0, catalog_1.parseFactsCatalog)(factsPath);
+            }
+            catch (e) {
+                structural.push(`facts.json invalid: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+    }
+    catch (error) {
+        if (!isMissing(error)) {
+            structural.push(`Cannot inspect facts.json: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const skillPaths = collectSkillMdPaths(resolvedRoot, structural);
+    let anyNeeds = false;
+    for (const skillMd of skillPaths) {
+        let needs;
+        try {
+            needs = (0, needs_1.readSkillNeeds)(skillMd);
+        }
+        catch (e) {
+            if (e instanceof types_1.SkillNeedsError) {
+                structural.push(e.message);
+                continue;
+            }
+            structural.push(`Cannot read needs from ${path_1.default.relative(resolvedRoot, skillMd)}`);
+            continue;
+        }
+        if (needs.length === 0)
+            continue;
+        anyNeeds = true;
+        if (!catalog) {
+            const reason = factsPresent
+                ? 'facts.json is invalid/unreadable'
+                : 'facts.json is missing';
+            structural.push(`Skill ${path_1.default.relative(resolvedRoot, skillMd)} declares needs but ${reason} (fail closed)`);
+            continue;
+        }
+        const orphans = (0, needs_1.findOrphanNeeds)(needs, catalog);
+        for (const id of orphans) {
+            structural.push(`Orphan need "${id}" in ${path_1.default.relative(resolvedRoot, skillMd)} — not in facts.json (RF-1.3)`);
+        }
+    }
+    if (factsPresent || anyNeeds) {
+        if (!manifestMin) {
+            structural.push(`minCliVersion required when facts/needs are present (must be >= ${types_1.FACTS_MIN_CLI_VERSION}) (RF-4.8)`);
+        }
+        else {
+            try {
+                if ((0, versioning_1.compareSemver)(manifestMin, types_1.FACTS_MIN_CLI_VERSION) < 0) {
+                    structural.push(`minCliVersion ${manifestMin} is below FACTS_MIN_CLI_VERSION ${types_1.FACTS_MIN_CLI_VERSION} (RF-4.8)`);
+                }
+            }
+            catch (e) {
+                structural.push(`minCliVersion unreadable for facts gate: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+    }
+    scanProsePathHints(resolvedRoot, advisories);
+    return { structural, advisories };
+}

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

@@ -8,6 +8,7 @@ exports.registerRegistryCommand = registerRegistryCommand;
 const fs_1 = __importDefault(require("fs"));
 const prompts_1 = require("@clack/prompts");
 const picocolors_1 = __importDefault(require("picocolors"));
+const path_1 = __importDefault(require("path"));
 const registries_1 = require("../../core/registries");
 const discovery_1 = require("../../core/discovery");
 const bundles_1 = require("../../core/bundles");
@@ -16,10 +17,22 @@ const regenerate_1 = require("../../core/context/regenerate");
 const add_1 = require("./add");
 const remove_1 = require("./remove");
 const status_1 = require("./status");
+const doctor_1 = require("./doctor");
+const scaffold_1 = require("./scaffold");
 const config_1 = require("../../utils/config");
 const profile_1 = require("../../core/profile");
 const providers_1 = require("../../providers");
 const install_bundles_1 = require("./install-bundles");
+function resolveDoctorTarget(nameOrPath) {
+    if (!nameOrPath) {
+        throw new Error('Specify a registry name or path: awm registry doctor <name|path>');
+    }
+    const asPath = path_1.default.resolve(nameOrPath);
+    if (fs_1.default.existsSync(asPath) && fs_1.default.statSync(asPath).isDirectory()) {
+        return asPath;
+    }
+    return (0, registries_1.registryContentRoot)(nameOrPath);
+}
 function registerRegistryCommand(program) {
     const reg = program.command('registry').description('manage additional content registries (team/personal)');
     reg.command('add <remote>')
@@ -173,4 +186,43 @@ function registerRegistryCommand(program) {
         }
         (0, prompts_1.outro)(`✅ Registry ${picocolors_1.default.cyan(name)} removed.`);
     });
+    reg.command('scaffold <dir>')
+        .description('create a minimal registry layout (handbook + facts) that passes doctor')
+        .action((dir) => {
+        (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Scaffold Registry ')));
+        const result = (0, scaffold_1.scaffoldRegistry)(dir);
+        if (!result.ok) {
+            console.error(picocolors_1.default.red(result.error));
+            process.exit(1);
+            return;
+        }
+        (0, prompts_1.outro)(`✅ Registry scaffolded at ${picocolors_1.default.cyan(result.dir)}. Run ${picocolors_1.default.cyan('awm registry doctor ' + result.dir)} to audit.`);
+    });
+    reg.command('doctor [nameOrPath]')
+        .description('audit a registry tree (structural failures vs advisories)')
+        .action((nameOrPath) => {
+        let root;
+        try {
+            root = resolveDoctorTarget(nameOrPath);
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(e instanceof Error ? e.message : String(e)));
+            process.exit(1);
+            return;
+        }
+        const report = (0, doctor_1.doctorRegistry)(root);
+        for (const msg of report.structural) {
+            console.error(picocolors_1.default.red(`structural: ${msg}`));
+        }
+        for (const msg of report.advisories) {
+            console.warn(picocolors_1.default.yellow(`advisory: ${msg}`));
+        }
+        if (report.structural.length === 0 && report.advisories.length === 0) {
+            console.log(picocolors_1.default.green(`Registry doctor: ok (${root})`));
+        }
+        else if (report.structural.length === 0) {
+            console.log(picocolors_1.default.green(`Registry doctor: ok with ${report.advisories.length} advisory(ies)`));
+        }
+        process.exit((0, doctor_1.doctorExitCode)(report));
+    });
 }

package/dist/src/commands/registry/scaffold.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldRegistry = scaffoldRegistry;
+// cli/src/commands/registry/scaffold.ts
+// Logic for `awm registry scaffold`, separated from commander wiring.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const types_1 = require("../../core/facts/types");
+function writeJson(write, file, value) {
+    write(file, JSON.stringify(value, null, 2) + '\n');
+}
+function handbookFor(name) {
+    return `# ${name}
+
+## Capabilities
+| id | status | notes |
+|----|--------|-------|
+| facts | active | see ## Capability: facts |
+
+## Capability: facts
+
+Declare operator/machine facts in \`facts.json\`. Skills may list \`needs\` in
+frontmatter; values live in the machine-local environment store
+(\`AWM_HOME/environments/\`), never in this registry tree.
+
+- Add fact definitions under \`facts\` in \`facts.json\` (\`schemaVersion: 1\`).
+- Keep \`minCliVersion\` in \`awm-registry.json\` at or above the CLI version that
+  understands facts.
+- Run \`awm registry doctor\` before publishing — structural failures block; advisories do not.
+`;
+}
+function writeScaffoldTree(root, name, write) {
+    writeJson(write, path_1.default.join(root, 'awm-registry.json'), {
+        overrides: [],
+        minCliVersion: types_1.FACTS_MIN_CLI_VERSION,
+    });
+    writeJson(write, path_1.default.join(root, 'catalog.json'), {
+        version: 1,
+        bundles: [],
+    });
+    const skillsDir = path_1.default.join(root, 'skills');
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    // Track skills/ in git — an empty dir is dropped on clone and then
+    // validateRegistryLayout / awm registry add reject the tree (RF-4.1).
+    write(path_1.default.join(skillsDir, '.gitkeep'), '');
+    writeJson(write, path_1.default.join(root, 'facts.json'), {
+        schemaVersion: 1,
+        facts: {},
+    });
+    write(path_1.default.join(root, 'REGISTRY.md'), handbookFor(name));
+}
+/**
+ * Create a minimal registry tree that passes structural `doctorRegistry`.
+ * Atomic (RF-4.3): write into a temp sibling, then rename into place; on
+ * failure remove only the staging dir so an empty preexisting target stays
+ * empty (retryable) and a missing target stays absent.
+ */
+function scaffoldRegistry(dir, opts = {}) {
+    if (typeof dir !== 'string' || dir.trim() === '') {
+        return { ok: false, error: 'scaffold target directory is required' };
+    }
+    const abs = path_1.default.resolve(dir);
+    const write = opts.writeFileSync ?? ((file, data) => fs_1.default.writeFileSync(file, data));
+    let targetExistsEmpty = false;
+    if (fs_1.default.existsSync(abs)) {
+        let stat;
+        try {
+            stat = fs_1.default.lstatSync(abs);
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: `Cannot inspect target ${abs}: ${e instanceof Error ? e.message : String(e)}`,
+            };
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            return { ok: false, error: `Target exists and is not a directory: ${abs}` };
+        }
+        if (fs_1.default.readdirSync(abs).length > 0) {
+            return {
+                ok: false,
+                error: `Target directory is not empty — refuse to overwrite: ${abs}`,
+            };
+        }
+        targetExistsEmpty = true;
+    }
+    const parent = path_1.default.dirname(abs);
+    let staging;
+    try {
+        fs_1.default.mkdirSync(parent, { recursive: true });
+        staging = fs_1.default.mkdtempSync(path_1.default.join(parent, '.awm-scaffold-'));
+        const name = path_1.default.basename(abs) || 'registry';
+        // Always stage first so mid-fail never leaves a partial target (RF-4.3).
+        writeScaffoldTree(staging, name, write);
+        if (targetExistsEmpty) {
+            // Never rmdir the empty shell before contents land. Write into abs
+            // directly from the validated staging pattern, then drop staging.
+            try {
+                writeScaffoldTree(abs, name, write);
+            }
+            catch (writeErr) {
+                // Best-effort: remove what we wrote into the preexisting empty
+                // dir without deleting the empty shell itself.
+                try {
+                    for (const entry of fs_1.default.readdirSync(abs)) {
+                        fs_1.default.rmSync(path_1.default.join(abs, entry), { recursive: true, force: true });
+                    }
+                }
+                catch {
+                    // best-effort
+                }
+                throw writeErr;
+            }
+            fs_1.default.rmSync(staging, { recursive: true, force: true });
+            staging = undefined;
+            return { ok: true, dir: abs };
+        }
+        // Target does not exist: atomic rename of staging into place.
+        fs_1.default.renameSync(staging, abs);
+        staging = undefined;
+        return { ok: true, dir: abs };
+    }
+    catch (e) {
+        if (staging) {
+            try {
+                fs_1.default.rmSync(staging, { recursive: true, force: true });
+            }
+            catch {
+                // best-effort cleanup; surface the original write error
+            }
+        }
+        return {
+            ok: false,
+            error: `Scaffold failed: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+}

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

@@ -209,7 +209,8 @@ function applySensorBootstrap(plan) {
     if (plan.manifest.mode === 'project-sensors') {
         if (!plan.source)
             throw new Error('project-sensors bootstrap plan requires its resolved source');
-        (0, materialize_1.materializePortableSensors)({ projectRoot: plan.projectRoot, pack: plan.manifest.pack, source: plan.source, ...(plan.manifest.packageRoot ? { packageRoot: plan.manifest.packageRoot } : {}), sensors: plan.manifest.sensors, configure: plan.configure !== false });
+        const packBound = (0, manifest_1.asPackBoundProjectSensors)(plan.manifest);
+        (0, materialize_1.materializePortableSensors)({ projectRoot: plan.projectRoot, pack: packBound.pack, source: plan.source, ...(packBound.packageRoot ? { packageRoot: packBound.packageRoot } : {}), sensors: packBound.sensors, configure: plan.configure !== false });
         return 'created';
     }
     const parsed = (0, manifest_1.parseSensorManifest)(plan.manifest, 'bootstrap declaration');