@lsctech/polaris 0.3.28 → 0.4.0

package/dist/agent-plugin/args.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSlashCommandArgs = validateSlashCommandArgs;
+/**
+ * Validate positional arguments against the command's declared arg spec.
+ *
+ * Rules:
+ * - `--help` / `-h` anywhere in argv returns a help request (no validation).
+ * - Required positional arguments must be present.
+ * - No more positional arguments than declared are accepted.
+ * - Empty strings are treated as a type mismatch.
+ */
+function validateSlashCommandArgs(command, argv = []) {
+    const help = argv.includes("--help") || argv.includes("-h");
+    if (help) {
+        return { ok: true, value: { command, positional: [], help: true } };
+    }
+    const positional = argv.filter((arg) => !arg.startsWith("-"));
+    const requiredCount = command.args.filter((arg) => arg.required).length;
+    const maxCount = command.args.length;
+    if (positional.length < requiredCount) {
+        return {
+            ok: false,
+            error: {
+                kind: "arity",
+                message: `/${command.name} requires ${requiredCount} positional argument(s) but received ${positional.length}.`,
+            },
+        };
+    }
+    if (positional.length > maxCount) {
+        return {
+            ok: false,
+            error: {
+                kind: "arity",
+                message: `/${command.name} accepts at most ${maxCount} positional argument(s) but received ${positional.length}.`,
+            },
+        };
+    }
+    for (const value of positional) {
+        if (value.trim() === "") {
+            return {
+                ok: false,
+                error: {
+                    kind: "type",
+                    message: `Arguments to /${command.name} must be non-empty strings.`,
+                },
+            };
+        }
+    }
+    // ponytail: support optional typed args (e.g. number, enum) when the manifest
+    // adds a `type` field; for now only string/empty-string checks are required.
+    if (hasTypedArgs(command.args)) {
+        for (let i = 0; i < positional.length; i++) {
+            const arg = command.args[i];
+            const value = positional[i];
+            if (arg.type && !validateArgType(value, arg.type)) {
+                return {
+                    ok: false,
+                    error: {
+                        kind: "type",
+                        message: `Argument \`${arg.name}\` for /${command.name} must be a valid ${arg.type}.`,
+                    },
+                };
+            }
+        }
+    }
+    return { ok: true, value: { command, positional, help: false } };
+}
+function hasTypedArgs(args) {
+    return args.some((arg) => arg.type !== undefined);
+}
+function validateArgType(value, type) {
+    if (type === "identifier") {
+        return /^[A-Za-z0-9_-]+$/.test(value);
+    }
+    return true;
+}

package/dist/agent-plugin/claude-generator.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHIM_VERSION = void 0;
+exports.generateClaudeShim = generateClaudeShim;
+exports.generateAllClaudeShims = generateAllClaudeShims;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const commands_js_1 = require("./commands.js");
+/**
+ * Host-specific shim generator for Claude Code (.claude/commands/).
+ *
+ * Reads the neutral SLASH_COMMANDS manifest and writes one
+ * `.claude/commands/polaris-<verb>.md` file per verb.
+ *
+ * Skill-backed verbs route through the existing packet+chain path:
+ *   1. Read .polaris/skills/<skill>/SKILL.md
+ *   2. Run `polaris skill packet <skill>`
+ *   3. Execute the chain
+ *
+ * CLI-backed verbs delegate directly to the real CLI command.
+ *
+ * Version stamp: each shim carries a `<!-- polaris-shim-version: <version> -->` comment
+ * so the sync command (child 4) can detect drift.
+ */
+/** Version string baked into every generated shim. */
+exports.SHIM_VERSION = "1";
+/**
+ * Generate the markdown body for a Claude Code slash-command shim.
+ * Host specifics are isolated here; the manifest itself is neutral.
+ */
+function generateClaudeShim(command) {
+    const argUsage = command.args.length > 0
+        ? command.args.map((a) => (a.required ? `<${a.name}>` : `[${a.name}]`)).join(" ")
+        : "";
+    const usage = argUsage ? `/${command.name} ${argUsage}` : `/${command.name}`;
+    if (command.kind === "skill") {
+        const argLines = command.args.length > 0
+            ? command.args
+                .map((a) => `- \`${a.name}\`${a.required ? " (required)" : " (optional)"} — ${a.description}`)
+                .join("\n")
+            : "None.";
+        return `<!-- polaris-shim-version: ${exports.SHIM_VERSION} -->
+# /${command.name}
+
+${command.description}
+
+## Usage
+
+\`\`\`text
+${usage}
+\`\`\`
+
+## Arguments
+
+${argLines}
+
+## Routing
+
+This slash command is a shim around the **${command.skill}** Polaris skill packet.
+It does not implement a parallel runtime — it routes through the existing packet+chain path.
+
+See \`${command.routing}\` for the full routing protocol and skill directory resolution.
+
+## Execution
+
+1. Look up \`/${command.name}\` in \`${command.routing}\` to find the target skill directory.
+2. Read \`.polaris/skills/<target-skill>/SKILL.md\` — it is the authoritative instruction source.
+3. Run the skill bootloader:
+   \`\`\`bash
+   polaris skill packet ${command.skill}${command.args.length > 0 ? " $ARGUMENTS" : ""}
+   \`\`\`
+   Do not begin work until a packet is returned.
+   If no packet is produced, stop and report: **Polaris could not authorize this run.**
+4. Execute the chain as instructed in the packet.
+`;
+    }
+    // CLI-backed command
+    const argLines = command.args.length > 0
+        ? command.args
+            .map((a) => `- \`${a.name}\`${a.required ? " (required)" : " (optional)"} — ${a.description}`)
+            .join("\n")
+        : "None.";
+    return `<!-- polaris-shim-version: ${exports.SHIM_VERSION} -->
+# /${command.name}
+
+${command.description}
+
+## Usage
+
+\`\`\`text
+${usage}
+\`\`\`
+
+## Arguments
+
+${argLines}
+
+## Execution
+
+Run the following CLI command:
+
+\`\`\`bash
+${command.command}
+\`\`\`
+`;
+}
+/**
+ * Write all Claude Code shim files to `outDir` (default: `.claude/commands`).
+ * Creates the directory if it does not exist.
+ * Returns the list of files written.
+ */
+function generateAllClaudeShims(outDir = ".claude/commands") {
+    fs.mkdirSync(outDir, { recursive: true });
+    const written = [];
+    const seen = new Set();
+    for (const command of commands_js_1.SLASH_COMMANDS) {
+        if (seen.has(command.name))
+            continue;
+        seen.add(command.name);
+        const filePath = path.join(outDir, `${command.name}.md`);
+        fs.writeFileSync(filePath, generateClaudeShim(command), "utf8");
+        written.push(filePath);
+    }
+    return written;
+}

package/dist/agent-plugin/commands.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLASH_COMMAND_BY_NAME = exports.SLASH_COMMANDS = void 0;
+exports.resolveSlashCommand = resolveSlashCommand;
+exports.SLASH_COMMANDS = [
+    {
+        name: "polaris-run",
+        kind: "skill",
+        skill: "run",
+        routing: ".polaris/skills/ROUTING.md",
+        args: [
+            {
+                name: "cluster_id",
+                required: true,
+                description: "Cluster ID to execute (e.g., POL-257)",
+            },
+        ],
+        description: "Execute a Polaris run cluster via the Foreman skill packet",
+    },
+    {
+        name: "polaris-analyze",
+        kind: "skill",
+        skill: "analyze",
+        routing: ".polaris/skills/ROUTING.md",
+        args: [
+            {
+                name: "cluster_id",
+                required: true,
+                description: "Cluster ID to analyze (e.g., POL-257)",
+            },
+        ],
+        description: "Analyze a cluster and produce an implementation plan via the Analyst skill packet",
+    },
+    {
+        name: "polaris-init",
+        kind: "cli",
+        command: "polaris init",
+        args: [],
+        description: "Initialize a new Polaris workspace",
+    },
+    {
+        name: "polaris-adopt",
+        kind: "cli",
+        command: "polaris adopt",
+        args: [],
+        description: "Adopt Polaris into an existing repository",
+    },
+    {
+        name: "polaris-reconcile",
+        kind: "skill",
+        skill: "triage",
+        routing: ".polaris/skills/ROUTING.md",
+        args: [
+            {
+                name: "target",
+                required: true,
+                description: "Reconciliation target (e.g., smartdocs or a cluster ID)",
+            },
+        ],
+        description: "Reconcile project cognition via the triage skill packet",
+    },
+    {
+        name: "polaris-status",
+        kind: "cli",
+        command: "polaris status",
+        args: [],
+        description: "Print the current Polaris loop run state summary",
+    },
+];
+exports.SLASH_COMMAND_BY_NAME = Object.fromEntries(exports.SLASH_COMMANDS.map((command) => [command.name, command]));
+function resolveSlashCommand(name) {
+    return exports.SLASH_COMMAND_BY_NAME[name];
+}

package/dist/agent-plugin/help.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUsage = generateUsage;
+exports.generateHelp = generateHelp;
+exports.generateErrorMessage = generateErrorMessage;
+exports.generateResponse = generateResponse;
+/**
+ * Help and error-message generation for slash-command invocations.
+ *
+ * Produces `--help`-style output directly from the neutral manifest so the
+ * same text can be used by any host shim. Error messages include the same
+ * help block so users see both the failure and the correct usage.
+ */
+/**
+ * Build a usage line from the command's arg spec.
+ * Required args are shown as `<name>`; optional as `[name]`.
+ */
+function generateUsage(command) {
+    const argUsage = command.args
+        .map((arg) => (arg.required ? `<${arg.name}>` : `[${arg.name}]`))
+        .join(" ");
+    return argUsage ? `/${command.name} ${argUsage}` : `/${command.name}`;
+}
+/**
+ * Generate `--help`-style output for a single manifest verb.
+ */
+function generateHelp(command) {
+    const argLines = command.args.length > 0
+        ? command.args
+            .map((arg) => `- \`${arg.name}\`${arg.required ? " (required)" : " (optional)"} — ${arg.description}`)
+            .join("\n")
+        : "None.";
+    return `/${command.name}
+
+${command.description}
+
+Usage:
+
+\`\`\`
+${generateUsage(command)}
+\`\`\`
+
+Arguments:
+
+${argLines}
+
+Use \`--help\` or \`-h\` to show this message.`;
+}
+/**
+ * Generate an error message that includes the command's help block.
+ */
+function generateErrorMessage(command, error) {
+    return `Error: ${error.message}
+
+${generateHelp(command)}`;
+}
+/**
+ * Convenience helper that returns the rendered message for a validation result.
+ * Returns `null` when the input is valid and no help/error text is needed.
+ */
+function generateResponse(command, result) {
+    if (!result.ok) {
+        return generateErrorMessage(command, result.error);
+    }
+    if (result.value.help) {
+        return generateHelp(command);
+    }
+    return null;
+}

package/dist/agent-plugin/sync.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectShimDrift = detectShimDrift;
+exports.syncShims = syncShims;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const commands_js_1 = require("./commands.js");
+const claude_generator_js_1 = require("./claude-generator.js");
+/**
+ * Workspace sync and versioning for generated agent-plugin shims.
+ *
+ * Responsibilities:
+ * 1. Detect drift between on-disk shims and the current SLASH_COMMANDS manifest
+ *    / ROUTING.md (stale version stamps, missing files, orphaned files).
+ * 2. Regenerate and re-stamp all shims when called.
+ * 3. Integrate with the asset-install path (called from adopt-assets.ts).
+ */
+/** Pattern used to read the version stamp from a shim file. */
+const VERSION_STAMP_RE = /<!--\s*polaris-shim-version:\s*(\S+)\s*-->/;
+/**
+ * Inspect `outDir` and return a drift report comparing on-disk shims against
+ * the current SLASH_COMMANDS manifest and SHIM_VERSION.
+ */
+function detectShimDrift(outDir = ".claude/commands") {
+    const stale = [];
+    const missing = [];
+    const orphaned = [];
+    const expectedNames = new Set(commands_js_1.SLASH_COMMANDS.map((c) => `${c.name}.md`));
+    // Check each manifest command against the on-disk file
+    for (const command of commands_js_1.SLASH_COMMANDS) {
+        const filePath = path.join(outDir, `${command.name}.md`);
+        if (!fs.existsSync(filePath)) {
+            missing.push(command.name);
+            continue;
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        const match = VERSION_STAMP_RE.exec(content);
+        if (!match || match[1] !== claude_generator_js_1.SHIM_VERSION) {
+            stale.push(command.name);
+        }
+    }
+    // Check for orphaned shim files (on disk but not in manifest)
+    if (fs.existsSync(outDir)) {
+        for (const entry of fs.readdirSync(outDir)) {
+            if (!entry.endsWith(".md"))
+                continue;
+            if (!expectedNames.has(entry)) {
+                orphaned.push(entry.replace(/\.md$/, ""));
+            }
+        }
+    }
+    return {
+        stale,
+        missing,
+        orphaned,
+        hasDrift: stale.length > 0 || missing.length > 0 || orphaned.length > 0,
+    };
+}
+/**
+ * Regenerate all shims and return what was written plus the prior drift state.
+ *
+ * This is the primary entry point for both `polaris agent-plugin sync` and
+ * the adopt-assets install step.
+ */
+function syncShims(outDir = ".claude/commands") {
+    const drift = detectShimDrift(outDir);
+    const written = (0, claude_generator_js_1.generateAllClaudeShims)(outDir);
+    for (const name of drift.orphaned) {
+        const orphanPath = path.join(outDir, `${name}.md`);
+        if (fs.existsSync(orphanPath)) {
+            fs.rmSync(orphanPath);
+        }
+    }
+    return { written, drift };
+}

package/dist/cli/adopt-approve.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.persistApprovedAdoptionPlan = persistApprovedAdoptionPlan;
 exports.logAdoptionApprovalTelemetry = logAdoptionApprovalTelemetry;
 exports.promptApproval = promptApproval;
+exports.promptCategoryApproval = promptCategoryApproval;
+exports.requireApprovalGates = requireApprovalGates;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const promises_1 = require("node:readline/promises");
@@ -36,9 +38,10 @@ async function promptApproval(plan, options = {}) {
     const stdout = options.stdout ?? process.stdout;
     const stdin = options.stdin ?? process.stdin;
     const markdownPath = adoptionPlanMarkdownPath(repoRoot);
-    const markdown = (0, node_fs_1.existsSync)(markdownPath)
-        ? (0, node_fs_1.readFileSync)(markdownPath, "utf-8")
-        : (0, adoption_plan_js_1.renderAdoptionPlanMarkdown)(plan);
+    const markdown = options.markdown ??
+        ((0, node_fs_1.existsSync)(markdownPath)
+            ? (0, node_fs_1.readFileSync)(markdownPath, "utf-8")
+            : (0, adoption_plan_js_1.renderAdoptionPlanMarkdown)(plan));
     stdout.write(`${markdown.replace(/\s*$/, "")}\n\n`);
     const rl = (0, promises_1.createInterface)({
         input: stdin,
@@ -52,9 +55,126 @@ async function promptApproval(plan, options = {}) {
         rl.close();
     }
     if (response.trim().toLowerCase() === "y") {
-        persistApprovedAdoptionPlan(plan, repoRoot, options.now ?? new Date());
+        const approvalNow = options.now ?? new Date();
+        if (options.persist) {
+            options.persist(plan, repoRoot, approvalNow);
+        }
+        else {
+            persistApprovedAdoptionPlan(plan, repoRoot, approvalNow);
+        }
         return true;
     }
     stdout.write("Adoption aborted: explicit approval required.\n");
     return false;
 }
+/** Map of category → step categories in AdoptionStep */
+const CATEGORY_STEP_MAP = {
+    "doc-movement": ["smartdocs-migrate"],
+    "instruction-file": ["instruction-refactor"],
+    "graph-root": ["cognition-generate", "atlas-generate"],
+    "route-scaffold": ["scaffold"],
+};
+const CATEGORY_LABELS = {
+    "doc-movement": "Document Movement",
+    "instruction-file": "Instruction-File Changes",
+    "graph-root": "Graph-Root / Cognition Changes",
+    "route-scaffold": "Route Scaffolding",
+};
+/**
+ * Render a compact diff preview for the given steps.
+ */
+function renderStepDiff(steps) {
+    if (steps.length === 0)
+        return "  (no steps)\n";
+    return steps
+        .map((s) => {
+        const src = s.source_path ? ` ${s.source_path} →` : "";
+        const dst = s.dest_path ? ` ${s.dest_path}` : "";
+        const routing = s.routing ? ` [${s.routing}]` : "";
+        return `  ${s.action.toUpperCase()}${src}${dst}${routing}  — ${s.description}`;
+    })
+        .join("\n") + "\n";
+}
+/**
+ * Ask the operator for approval of a single mutation category.
+ * Returns true if approved, false if declined.
+ * Logs the decision via adoption telemetry.
+ */
+async function promptCategoryApproval(category, steps, options = {}) {
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const stdout = options.stdout ?? process.stdout;
+    const stdin = options.stdin ?? process.stdin;
+    const label = CATEGORY_LABELS[category];
+    const actionableSteps = steps.filter((s) => s.action !== "skip");
+    if (actionableSteps.length === 0)
+        return true;
+    stdout.write(`\n--- ${label} (${actionableSteps.length} step(s)) ---\n`);
+    stdout.write(renderStepDiff(actionableSteps));
+    const rl = (0, promises_1.createInterface)({ input: stdin, output: stdout });
+    let response = "";
+    try {
+        response = await rl.question(`Approve ${label}? [y/N] `);
+    }
+    finally {
+        rl.close();
+    }
+    const approved = response.trim().toLowerCase() === "y";
+    const now = (options.now ?? new Date()).toISOString();
+    logAdoptionApprovalTelemetry(repoRoot, {
+        event: "category-approval",
+        category,
+        approved,
+        step_count: actionableSteps.length,
+        timestamp: now,
+    });
+    if (!approved) {
+        stdout.write(`Adoption aborted: ${label} approval required.\n`);
+    }
+    return approved;
+}
+/**
+ * Fire approval gates for all four mutation categories in sequence.
+ * Returns false (and stops) at the first declined category.
+ *
+ * For non-interactive runs (no tty + no supplied stdin), returns false immediately
+ * unless `options.stdin` is explicitly set (which signals the caller supplied a context stream).
+ */
+async function requireApprovalGates(plan, options = {}) {
+    const stdin = options.stdin ?? process.stdin;
+    // Non-interactive guard: if stdin is not a TTY and the caller hasn't explicitly supplied one,
+    // block before mutation (acceptance criterion 2).
+    if (!options.nonInteractiveSafe && stdin === process.stdin && !process.stdin.isTTY) {
+        const stdout = options.stdout ?? process.stdout;
+        stdout.write("Adoption aborted: non-interactive run requires a supplied context file (--context) or explicit approval.\n");
+        logAdoptionApprovalTelemetry(options.repoRoot ?? process.cwd(), {
+            event: "category-approval-blocked",
+            reason: "non-interactive",
+            timestamp: new Date().toISOString(),
+        });
+        return false;
+    }
+    const categories = [
+        "route-scaffold",
+        "doc-movement",
+        "instruction-file",
+        "graph-root",
+    ];
+    for (const category of categories) {
+        const stepCategories = CATEGORY_STEP_MAP[category];
+        const steps = plan.steps.filter((s) => {
+            if (!stepCategories.includes(s.category))
+                return false;
+            // Doc-movement gate only fires for steps that migrateSmartDocs will execute
+            if (category === "doc-movement" && s.routing !== "candidate")
+                return false;
+            return true;
+        });
+        // Skip gate if no actionable steps in this category
+        if (steps.filter((s) => s.action !== "skip").length === 0)
+            continue;
+        const approved = await promptCategoryApproval(category, steps, options);
+        if (!approved)
+            return false;
+    }
+    return true;
+}

package/dist/cli/adopt-assets.js

@@ -6,6 +6,7 @@ exports.runGraphBuild = runGraphBuild;
 const node_fs_1 = require("node:fs");
 const node_child_process_1 = require("node:child_process");
 const node_path_1 = require("node:path");
+const sync_js_1 = require("../agent-plugin/sync.js");
 function isAncestorSymlink(repoRoot, relPath) {
     const parts = relPath.split("/").filter(Boolean);
     for (let i = 0; i < parts.length - 1; i++) {
@@ -168,7 +169,14 @@ function installWorkspaceAssets(repoRoot, workspaceDir) {
             installed.push(rulesRel);
         }
     }
-    return { installed, alreadyPresent, skipped, conflicted };
+    // 6. Agent-plugin shims (Claude Code commands)
+    const shimOutDir = (0, node_path_1.join)(repoRoot, ".claude", "commands");
+    if (isAncestorSymlink(repoRoot, ".claude/commands")) {
+        skipped.push(".claude/commands");
+        return { installed, alreadyPresent, skipped, conflicted };
+    }
+    const shimSync = (0, sync_js_1.syncShims)(shimOutDir);
+    return { installed, alreadyPresent, skipped, conflicted, shimSync };
 }
 function runGraphBuild(repoRoot) {
     try {