@kuznai/inception-engine 0.18.0 → 0.20.0

package/dist/{core → src/core}/revert.js

@@ -3,6 +3,7 @@ import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { logger } from "../logger.js";
 import { compileAgentDefinitionReverts, compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, } from "./adapters/index.js";
 import { revertTomlMcpPatch } from "./adapters/toml.js";
+import { applyUndoPatch } from "./merge-patch.js";
 import { lookupDeployment, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
@@ -112,24 +113,6 @@ async function readJsonConfig(filePath) {
     }
     return parsed;
 }
-function isPlainObject(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function applyUndoPatch(current, undoPatch) {
-    const restored = { ...current };
-    for (const [key, originalValue] of Object.entries(undoPatch)) {
-        if (originalValue === null) {
-            delete restored[key];
-        }
-        else if (isPlainObject(originalValue) && isPlainObject(restored[key])) {
-            restored[key] = applyUndoPatch(restored[key], originalValue);
-        }
-        else {
-            restored[key] = originalValue;
-        }
-    }
-    return restored;
-}
 function lstatOutcome(err) {
     if (err.code === "ENOENT") {
         return { outcome: "skip" };
@@ -138,11 +121,9 @@ function lstatOutcome(err) {
     return { outcome: "fail", error: msg };
 }
 export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
-    let succeeded = 0;
-    let skipped = 0;
     const failed = [];
     const planned = [];
-    const counts = { succeeded, skipped };
+    const counts = { succeeded: 0, skipped: 0 };
     for (const action of actions) {
         let result;
         switch (action.kind) {
@@ -159,23 +140,104 @@ export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
                 result = await revertTomlPatch(action, dryRun, verbose, home, planned, deps);
                 break;
             case "frontmatter-emit":
-                // Frontmatter-emit files are fully managed by inception — revert
-                // deletes the file, same as a file-write revert.
-                result = await revertFileWrite({
-                    kind: "file-write",
-                    skill: action.skill,
-                    agent: action.agent,
-                    target: action.target,
-                }, dryRun, verbose, home, planned, deps);
+                result = await revertFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
                 break;
-            default:
+            default: {
                 throw new Error(`Unhandled revert action kind: ${action.kind}`);
+            }
         }
         recordOutcome(result, action, counts, failed);
     }
-    succeeded = counts.succeeded;
-    skipped = counts.skipped;
-    return { succeeded, skipped, failed, planned };
+    return {
+        succeeded: counts.succeeded,
+        skipped: counts.skipped,
+        failed,
+        planned,
+    };
+}
+function isManagedFrontmatterEntry(entry, action) {
+    return (entry !== null &&
+        entry.kind === "frontmatter-emit" &&
+        entry.skill === action.skill &&
+        entry.agent === action.agent);
+}
+async function loadManagedFrontmatterEntry(action, home, deps) {
+    const entry = await lookupDeployment(home, action.target, deps.registry);
+    return isManagedFrontmatterEntry(entry, action) ? entry : null;
+}
+function planFrontmatterRevert(action, frontmatterEntry, planned) {
+    planned.push({
+        verb: "unapply-patch",
+        kind: "frontmatter-emit",
+        skill: action.skill,
+        agent: action.agent,
+        target: action.target,
+        patch: frontmatterEntry.undoPatch,
+    });
+    return { outcome: "ok" };
+}
+async function applyFrontmatterRevert(action, frontmatterEntry) {
+    const frontmatterAdapter = await import("./adapters/frontmatter.js");
+    const current = await frontmatterAdapter.readFrontmatterDocumentFile(action.target);
+    const restoredFrontmatter = applyUndoPatch(current.attributes, frontmatterEntry.undoPatch ?? {});
+    const shouldDeleteFile = frontmatterEntry.created === true &&
+        !frontmatterEntry.hadFrontmatter &&
+        Object.keys(restoredFrontmatter).length === 0 &&
+        current.body.trim() === "";
+    if (shouldDeleteFile) {
+        await unlink(action.target);
+        return { shouldDeleteFile };
+    }
+    const restoredContent = frontmatterAdapter.buildMarkdownDocument(restoredFrontmatter, current.body, { hasFrontmatter: frontmatterEntry.hadFrontmatter ?? false });
+    await writeFile(action.target, restoredContent, "utf-8");
+    return { shouldDeleteFile };
+}
+async function revertFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    try {
+        await lstat(action.target);
+    }
+    catch (err) {
+        const result = lstatOutcome(err);
+        if (result.outcome === "skip") {
+            logger.skip(label, "(not found, skipping)");
+            return result;
+        }
+        logger.fail(label, result.error);
+        return result;
+    }
+    const frontmatterEntry = await loadManagedFrontmatterEntry(action, home, deps);
+    if (!frontmatterEntry) {
+        logger.warn(label, `skipping: ${action.target} is not in the deployment registry — not managed by inception-engine`);
+        return { outcome: "skip" };
+    }
+    if (!frontmatterEntry.undoPatch) {
+        return revertFileWrite({
+            kind: "file-write",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        }, dryRun, verbose, home, planned, deps);
+    }
+    if (dryRun) {
+        return planFrontmatterRevert(action, frontmatterEntry, planned);
+    }
+    try {
+        const { shouldDeleteFile } = await applyFrontmatterRevert(action, frontmatterEntry);
+        await unregisterDeployment(home, action.target, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(shouldDeleteFile
+                ? `removed: ${action.target}`
+                : `unapplied frontmatter patch from: ${action.target}`);
+        }
+        return { outcome: "ok" };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { outcome: "fail", error: msg };
+    }
 }
 async function executeRevertAction(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;

package/dist/{core → src/core}/runtime-paths.d.ts

@@ -1,8 +1,9 @@
 import path from "node:path";
 export interface RuntimePaths {
     appdata: string;
+    localAppdata: string;
     xdgConfig: string;
 }
 export declare function getPathApi(root: string): typeof path.posix | typeof path.win32;
 export declare function resolveRuntimePaths(home: string): RuntimePaths;
-export declare function resolveTargetTemplate(template: string, home: string, repo?: string): string;
+export declare function resolveTargetTemplate(template: string, home: string, repo?: string, workspace?: string): string;

package/dist/{core → src/core}/runtime-paths.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config|repo)\}(?<suffix>(?:[\\/].*)?)$/;
+const TARGET_TEMPLATE_RE = /^\{(home|appdata|local_appdata|xdg_config|repo|workspace)\}(?<suffix>(?:[\\/].*)?)$/;
 export function getPathApi(root) {
     if (root.includes("\\") || /^[a-zA-Z]:/.test(root)) {
         return path.win32;
@@ -22,49 +22,56 @@ function isSameOrDescendantPath(candidate, root) {
 }
 export function resolveRuntimePaths(home) {
     const appdataRaw = process.env.APPDATA;
+    const localAppdataRaw = process.env.LOCALAPPDATA;
     const homePathApi = getPathApi(home);
     const appdata = appdataRaw && getPathApi(appdataRaw).isAbsolute(appdataRaw)
         ? appdataRaw
         : homePathApi.join(home, "AppData", "Roaming");
+    const localAppdata = localAppdataRaw && getPathApi(localAppdataRaw).isAbsolute(localAppdataRaw)
+        ? localAppdataRaw
+        : homePathApi.join(home, "AppData", "Local");
     const xdgRaw = process.env.XDG_CONFIG_HOME;
     const xdgConfig = xdgRaw && getPathApi(xdgRaw).isAbsolute(xdgRaw)
         ? xdgRaw
         : homePathApi.join(home, ".config");
-    return { appdata, xdgConfig };
+    return { appdata, localAppdata, xdgConfig };
 }
-export function resolveTargetTemplate(template, home, repo) {
-    const { appdata, xdgConfig } = resolveRuntimePaths(home);
+function resolveVfsPlaceholder(root, template, suffix, repo, workspace) {
+    const rootPath = root === "repo" ? repo : (workspace ?? repo);
+    if (!rootPath) {
+        throw new Error(`Target template uses {${root}} but no ${root} directory was provided: ${template}`);
+    }
+    const segments = suffix.split(/[\\/]+/).filter(Boolean);
+    const rootPathApi = getPathApi(rootPath);
+    const resolved = segments.length === 0 ? rootPath : rootPathApi.join(rootPath, ...segments);
+    if (!isSameOrDescendantPath(resolved, rootPath)) {
+        throw new Error(`Target template resolves outside its placeholder root: ${template}`);
+    }
+    return suffix === "" ? rootPath : `${rootPath}${suffix}`;
+}
+export function resolveTargetTemplate(template, home, repo, workspace) {
+    const { appdata, localAppdata, xdgConfig } = resolveRuntimePaths(home);
     const match = TARGET_TEMPLATE_RE.exec(template);
     if (!match) {
         throw new Error(`Invalid target template: ${template}`);
     }
     const root = match[1];
-    if (root === "repo") {
-        if (!repo) {
-            throw new Error(`Target template uses {repo} but no manifest directory was provided: ${template}`);
-        }
-        const suffix = match.groups?.suffix ?? "";
-        const segments = suffix.split(/[\\/]+/).filter(Boolean);
-        const repoPathApi = getPathApi(repo);
-        const resolved = segments.length === 0 ? repo : repoPathApi.join(repo, ...segments);
-        if (!isSameOrDescendantPath(resolved, repo)) {
-            throw new Error(`Target template resolves outside its placeholder root: ${template}`);
-        }
-        return suffix === "" ? repo : `${repo}${suffix}`;
+    const suffix = match.groups?.suffix ?? "";
+    if (root === "repo" || root === "workspace") {
+        return resolveVfsPlaceholder(root, template, suffix, repo, workspace);
     }
     const baseByRoot = {
         home,
         appdata,
+        local_appdata: localAppdata,
         xdg_config: xdgConfig,
     };
-    const suffix = match.groups?.suffix ?? "";
+    const base = baseByRoot[root];
     const segments = suffix.split(/[\\/]+/).filter(Boolean);
-    const pathApi = getPathApi(baseByRoot[root]);
-    const resolved = segments.length === 0
-        ? baseByRoot[root]
-        : pathApi.join(baseByRoot[root], ...segments);
-    if (!isSameOrDescendantPath(resolved, baseByRoot[root])) {
+    const pathApi = getPathApi(base);
+    const resolved = segments.length === 0 ? base : pathApi.join(base, ...segments);
+    if (!isSameOrDescendantPath(resolved, base)) {
         throw new Error(`Target template resolves outside its placeholder root: ${template}`);
     }
-    return suffix === "" ? baseByRoot[root] : `${baseByRoot[root]}${suffix}`;
+    return suffix === "" ? base : `${base}${suffix}`;
 }

package/dist/{core → src/core}/validation.d.ts

@@ -1,7 +1,16 @@
+import type { AgentId } from "../schemas/manifest.ts";
 export declare function sourceAccessError(err: unknown, sourcePath: string): string;
 export declare function validateSourcePath(source: string, skillPath: string, resolvedSourceDir: string, realRoot: string): Promise<void>;
 export declare function validateSourceFile(sourcePath: string, manifestPath: string): Promise<void>;
 export declare function validateMcpServerConfigShape(config: Record<string, unknown>, entryName: string, agentId: string): void;
 export declare function validatePermissionsConfigShape(config: Record<string, unknown>, entryName: string, agentId: string): void;
 export declare function validateAgentRuleMarkdownPath(manifestPath: string, agentId: string): void;
-export declare function validateSkillDefinitionFile(sourcePath: string, manifestPath: string): Promise<void>;
+export declare function validateSkillDefinitionFile(sourcePath: string, manifestPath: string): Promise<{
+    attributes: Record<string, unknown>;
+    body: string;
+}>;
+/**
+ * Validates that an instruction file (agentRules or agentDefinitions) meets
+ * the structural requirements of the target agent.
+ */
+export declare function validateInstructionFileRequirements(sourcePath: string, manifestPath: string, agentId: AgentId): Promise<void>;

package/dist/{core → src/core}/validation.js

@@ -1,5 +1,6 @@
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
+import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { parseFrontmatterDocument } from "./adapters/frontmatter.js";
 export function sourceAccessError(err, sourcePath) {
@@ -134,6 +135,23 @@ function validateCodexPermissions(config, entryName) {
         throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "codex" must define "approval_policy" as one of: ${CODEX_APPROVAL_POLICY_VALUES.join(", ")}`);
     }
 }
+function validateOpenCodePermissions(config, entryName) {
+    rejectUnknownKeys(config, ["permissions"], entryName, "opencode");
+    const perms = config.permissions;
+    if (perms === undefined)
+        return;
+    if (typeof perms !== "object" || perms === null || Array.isArray(perms)) {
+        throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "opencode" must define "permissions" as an object`);
+    }
+    const permsObj = perms;
+    for (const key of ["allow", "ask", "deny"]) {
+        const val = permsObj[key];
+        if (val !== undefined &&
+            (!Array.isArray(val) || val.some((item) => typeof item !== "string"))) {
+            throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "opencode" must define "permissions.${key}" as an array of strings when present`);
+        }
+    }
+}
 export function validatePermissionsConfigShape(config, entryName, agentId) {
     if (agentId === "claude-code") {
         validateClaudeCodePermissions(config, entryName);
@@ -141,6 +159,9 @@ export function validatePermissionsConfigShape(config, entryName, agentId) {
     else if (agentId === "codex") {
         validateCodexPermissions(config, entryName);
     }
+    else if (agentId === "opencode") {
+        validateOpenCodePermissions(config, entryName);
+    }
 }
 export function validateAgentRuleMarkdownPath(manifestPath, agentId) {
     const extension = path.extname(manifestPath).toLowerCase();
@@ -166,9 +187,11 @@ export async function validateSkillDefinitionFile(sourcePath, manifestPath) {
         throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md is missing the closing --- frontmatter delimiter`);
     }
     let attributes;
+    let body;
     try {
         const parsed = parseFrontmatterDocument(raw);
         attributes = parsed.attributes;
+        body = parsed.body;
     }
     catch (err) {
         throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md has malformed YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`);
@@ -187,4 +210,56 @@ export async function validateSkillDefinitionFile(sourcePath, manifestPath) {
     };
     validateField("name");
     validateField("description");
+    return { attributes, body };
+}
+function validateGithubCopilotRequirements(attributes, manifestPath) {
+    const hasTools = Object.hasOwn(attributes, "tools");
+    const hasInstructions = Object.hasOwn(attributes, "instructions");
+    if (!(hasTools || hasInstructions)) {
+        throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "github-copilot" must define "tools" or "instructions" in frontmatter`);
+    }
+}
+function validateAntigravityRequirements(attributes, manifestPath) {
+    const mcpServers = attributes["mcp-servers"] ?? attributes.mcpServers;
+    if (mcpServers === undefined)
+        return;
+    if (typeof mcpServers !== "object" ||
+        mcpServers === null ||
+        Array.isArray(mcpServers)) {
+        throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "antigravity" must define "mcp-servers" as an object`);
+    }
+    for (const [name, config] of Object.entries(mcpServers)) {
+        if (typeof config !== "object" ||
+            config === null ||
+            Array.isArray(config)) {
+            throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "antigravity" has malformed MCP server config for "${name}"`);
+        }
+        validateMcpServerConfigShape(config, name, "antigravity");
+    }
+}
+/**
+ * Validates that an instruction file (agentRules or agentDefinitions) meets
+ * the structural requirements of the target agent.
+ */
+export async function validateInstructionFileRequirements(sourcePath, manifestPath, agentId) {
+    const requiresFrontmatter = AGENT_REGISTRY_BY_ID[agentId]?.instructionFrontmatterRequired === true;
+    if (!requiresFrontmatter)
+        return;
+    let attributes;
+    try {
+        const result = await validateSkillDefinitionFile(sourcePath, manifestPath);
+        attributes = result.attributes;
+    }
+    catch (err) {
+        if (err instanceof UserError) {
+            throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "${agentId}" failed structural validation: ${err.message}`);
+        }
+        throw err;
+    }
+    if (agentId === "github-copilot") {
+        validateGithubCopilotRequirements(attributes, manifestPath);
+    }
+    else if (agentId === "antigravity") {
+        validateAntigravityRequirements(attributes, manifestPath);
+    }
 }

package/dist/src/formatters.d.ts

@@ -0,0 +1,5 @@
+import type { PlannedChange } from "./types.ts";
+/**
+ * Groups and formats the dry-run plan by agent.
+ */
+export declare function formatDryRunPlan(planned: PlannedChange[]): string;

package/dist/src/formatters.js

@@ -0,0 +1,58 @@
+import { styleText } from "node:util";
+/**
+ * Groups and formats the dry-run plan by agent.
+ */
+export function formatDryRunPlan(planned) {
+    if (planned.length === 0)
+        return "";
+    const groups = new Map();
+    for (const change of planned) {
+        const list = groups.get(change.agent) ?? [];
+        list.push(change);
+        groups.set(change.agent, list);
+    }
+    const sortedAgents = Array.from(groups.keys()).sort();
+    const output = [];
+    for (const agent of sortedAgents) {
+        output.push(styleText(["bold", "yellow"], agent));
+        const changes = groups.get(agent);
+        if (!changes)
+            continue;
+        for (const change of changes) {
+            output.push(formatPlannedChange(change));
+        }
+        output.push("");
+    }
+    return output.join("\n");
+}
+function formatPlannedChange(change) {
+    const icon = styleText("cyan", "○");
+    const kind = styleText("dim", `[${change.kind}]`);
+    const lines = [
+        `  ${icon} ${kind} ${change.verb} ${styleText("bold", change.skill)}`,
+    ];
+    if (change.source !== undefined) {
+        lines.push(`    source: ${styleText("dim", change.source)}`);
+    }
+    lines.push(`    target: ${styleText("dim", change.target)}`);
+    const detail = formatChangeDetail(change);
+    if (detail) {
+        lines.push(`    ${detail}`);
+    }
+    return lines.join("\n");
+}
+function formatChangeDetail(change) {
+    if (change.verb === "patch-config" && change.patch !== undefined) {
+        return `patch:  ${styleText("dim", JSON.stringify(change.patch))}`;
+    }
+    if (change.verb === "unapply-patch" && change.patch !== undefined) {
+        return `undo:   ${styleText("dim", JSON.stringify(change.patch))}`;
+    }
+    if (change.verb === "patch-toml" && change.patch !== undefined) {
+        return `patch:  ${styleText("dim", JSON.stringify(change.patch))}`;
+    }
+    if (change.verb === "emit-frontmatter" && change.frontmatter !== undefined) {
+        return `frontmatter: ${styleText("dim", JSON.stringify(change.frontmatter))}`;
+    }
+    return null;
+}

package/dist/{index.js → src/index.js}

@@ -10,6 +10,7 @@ import { runPreflight } from "./core/preflight.js";
 import { resolveHome } from "./core/resolve.js";
 import { executeRevert, planRevert, planRevertAll } from "./core/revert.js";
 import { UserError } from "./errors.js";
+import { formatDryRunPlan } from "./formatters.js";
 import { dryRunPrefix, logger } from "./logger.js";
 import { AgentListSchema } from "./schemas/manifest.js";
 const USAGE = `
@@ -26,7 +27,7 @@ Commands:
   init <directory>    Scan a directory for skill folders and generate inception.json
 
 Options:
-  --dry-run        Show what would be done without doing it
+  --plan           Show what would be done without doing it
   --agents <list>  Comma-separated list of agent IDs to target
   --force          (init only) Overwrite an existing inception.json
   --verbose        Show detailed output
@@ -55,7 +56,7 @@ function parseCLI(argv) {
             args,
             allowPositionals: true,
             options: {
-                "dry-run": { type: "boolean", default: false },
+                plan: { type: "boolean", default: false },
                 verbose: { type: "boolean", default: false },
                 debug: { type: "boolean", default: false },
                 help: { type: "boolean", default: false },
@@ -107,7 +108,7 @@ function parseCLI(argv) {
     return {
         command,
         directory: path.resolve(rawDir),
-        dryRun: values["dry-run"],
+        dryRun: (values.plan || values["dry-run"]),
         agents,
         verbose: values.verbose,
         debug: values.debug,
@@ -136,21 +137,6 @@ async function main() {
     }
     return runRevert(options, manifest, home);
 }
-function renderDryRunPlan(planned) {
-    for (const change of planned) {
-        logger.plan(`[${change.agent}] ${change.verb}  ${change.skill}`);
-        if (change.source !== undefined) {
-            logger.detail(`source: ${change.source}`);
-        }
-        logger.detail(`target: ${change.target}`);
-        if (change.verb === "patch-config" && change.patch !== undefined) {
-            logger.detail(`patch:  ${JSON.stringify(change.patch)}`);
-        }
-        else if (change.verb === "unapply-patch" && change.patch !== undefined) {
-            logger.detail(`undo:   ${JSON.stringify(change.patch)}`);
-        }
-    }
-}
 async function runDeploy(options, manifest, home) {
     let detectedAgents;
     if (options.agents) {
@@ -187,9 +173,8 @@ async function runDeploy(options, manifest, home) {
     const { succeeded, failed, planned } = await executeDeploy(actions, options.dryRun, options.verbose, home);
     if (options.dryRun) {
         logger.info("");
-        renderDryRunPlan(planned);
-        logger.info("");
-        logger.info(`${planned.length} action(s) would be applied (dry-run)`);
+        logger.info(formatDryRunPlan(planned));
+        logger.info(`${planned.length} action(s) would be applied (plan)`);
         return 0;
     }
     logger.info("");
@@ -212,9 +197,8 @@ async function runRevert(options, manifest, home) {
     const { succeeded, skipped, failed, planned } = await executeRevert(actions, options.dryRun, options.verbose, home);
     if (options.dryRun) {
         logger.info("");
-        renderDryRunPlan(planned);
-        logger.info("");
-        logger.info(`${planned.length} action(s) would be removed (dry-run)`);
+        logger.info(formatDryRunPlan(planned));
+        logger.info(`${planned.length} action(s) would be removed (plan)`);
         return 0;
     }
     logger.info("");

package/dist/src/logger.js

@@ -0,0 +1,62 @@
+import process from "node:process";
+import { styleText } from "node:util";
+export function createLogger() {
+    let silent = false;
+    return {
+        fail(label, msg) {
+            if (!silent) {
+                const icon = styleText("red", "✗");
+                process.stderr.write(`  ${icon} ${label}: ${msg}\n`);
+            }
+        },
+        ok(label) {
+            if (!silent) {
+                const icon = styleText("green", "✓");
+                process.stdout.write(`  ${icon} ${label}\n`);
+            }
+        },
+        skip(label, note) {
+            if (!silent) {
+                const icon = styleText("yellow", "-");
+                process.stdout.write(`  ${icon} ${label} ${note}\n`);
+            }
+        },
+        plan(label) {
+            if (!silent) {
+                const icon = styleText("cyan", "○");
+                process.stdout.write(`  ${icon} ${label}\n`);
+            }
+        },
+        warn(label, msg) {
+            if (!silent) {
+                const icon = styleText("yellow", "!");
+                process.stdout.write(`  ${icon} ${label}: ${msg}\n`);
+            }
+        },
+        info(msg) {
+            if (!silent)
+                process.stdout.write(`${msg}\n`);
+        },
+        error(msg) {
+            if (!silent)
+                process.stderr.write(`${msg}\n`);
+        },
+        errorRaw(value) {
+            if (!silent)
+                console.error(value);
+        },
+        detail(msg) {
+            if (!silent)
+                process.stdout.write(`    ${msg}\n`);
+        },
+        silence() {
+            silent = true;
+        },
+    };
+}
+export const logger = createLogger();
+export function dryRunPrefix(dryRun) {
+    if (!dryRun)
+        return "";
+    return styleText("cyan", "[plan] ");
+}

package/dist/{schemas → src/schemas}/manifest.d.ts

@@ -59,6 +59,11 @@ export declare const McpServerEntrySchema: z.ZodObject<{
         "github-copilot": "github-copilot";
     }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        global: "global";
+        repo: "repo";
+        workspace: "workspace";
+    }>>;
 }, z.core.$strip>;
 export declare const AgentRuleEntrySchema: z.ZodObject<{
     name: z.ZodString;
@@ -74,6 +79,7 @@ export declare const AgentRuleEntrySchema: z.ZodObject<{
     scope: z.ZodDefault<z.ZodEnum<{
         global: "global";
         repo: "repo";
+        workspace: "workspace";
     }>>;
 }, z.core.$strip>;
 export declare const PermissionsEntrySchema: z.ZodObject<{
@@ -99,6 +105,11 @@ export declare const AgentDefinitionEntrySchema: z.ZodObject<{
         "github-copilot": "github-copilot";
     }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     path: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        global: "global";
+        repo: "repo";
+        workspace: "workspace";
+    }>>;
 }, z.core.$strip>;
 export declare const ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
@@ -150,6 +161,11 @@ export declare const ManifestSchema: z.ZodObject<{
             "github-copilot": "github-copilot";
         }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
         config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            global: "global";
+            repo: "repo";
+            workspace: "workspace";
+        }>>;
     }, z.core.$strip>>>;
     agentRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -165,6 +181,7 @@ export declare const ManifestSchema: z.ZodObject<{
         scope: z.ZodDefault<z.ZodEnum<{
             global: "global";
             repo: "repo";
+            workspace: "workspace";
         }>>;
     }, z.core.$strip>>>;
     permissions: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -190,6 +207,11 @@ export declare const ManifestSchema: z.ZodObject<{
             "github-copilot": "github-copilot";
         }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
         path: z.ZodString;
+        scope: z.ZodDefault<z.ZodEnum<{
+            global: "global";
+            repo: "repo";
+            workspace: "workspace";
+        }>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type SkillEntry = z.infer<typeof SkillEntrySchema>;