@kuznai/inception-engine 0.18.0 → 0.19.0

package/dist/core/preflight.js

@@ -1,33 +1,95 @@
-import { stat } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
+import { resolveRuntimePaths } from "./runtime-paths.js";
 const BUDGET_WARN_BYTES = 50 * 1024; // 50 KB
-function detectInstructionPrecedence(detectedAgents, manifest) {
+async function detectEnterpriseManagement(agentId, home) {
+    if (!AGENT_REGISTRY_BY_ID[agentId]?.enterprisePolicyDetection)
+        return null;
+    // Check for common GitHub Enterprise environment variables
+    if (process.env.GITHUB_ENTERPRISE_URL ||
+        process.env.GH_ENTERPRISE_TOKEN ||
+        process.env.GITHUB_TOKEN_TYPE === "enterprise") {
+        return "GitHub Enterprise environment variables detected. Enterprise policies may override local configurations.";
+    }
+    const { xdgConfig, localAppdata } = resolveRuntimePaths(home);
+    const configPath = process.platform === "win32"
+        ? path.join(localAppdata, "github-copilot", "hosts.json")
+        : path.join(xdgConfig, "github-copilot", "hosts.json");
+    try {
+        const content = await readFile(configPath, "utf8");
+        const hosts = JSON.parse(content);
+        const hostNames = Object.keys(hosts);
+        const enterpriseHosts = hostNames.filter((h) => h !== "github.com" && h !== "localhost");
+        if (enterpriseHosts.length > 0) {
+            return `GitHub Copilot is authenticated against enterprise host(s): ${enterpriseHosts.join(", ")}. Enterprise policies may override local configurations.`;
+        }
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT" &&
+            code !== "EACCES" &&
+            code !== "EPERM" &&
+            code !== undefined) {
+            throw err;
+        }
+    }
+    return null;
+}
+function groupRulesByPath(rulesForAgent) {
+    const entriesByPath = new Map();
+    for (const entry of rulesForAgent ?? []) {
+        const list = entriesByPath.get(entry.path) ?? [];
+        list.push({ name: entry.name, scope: entry.scope });
+        entriesByPath.set(entry.path, list);
+    }
+    return entriesByPath;
+}
+function detectScopeOverlaps(agentId, rulesForAgent) {
     const warnings = [];
-    for (const agentId of detectedAgents) {
-        const rulesForAgent = (manifest.agentRules ?? []).filter((e) => e.agents.includes(agentId));
-        const globalEntries = rulesForAgent.filter((e) => (e.scope ?? "global") === "global");
-        const repoEntries = rulesForAgent.filter((e) => e.scope === "repo");
-        if (globalEntries.length === 0 || repoEntries.length === 0)
+    const entriesByPath = groupRulesByPath(rulesForAgent);
+    for (const [path, list] of entriesByPath) {
+        const scopes = new Set(list.map((l) => l.scope));
+        if (scopes.size < 2)
             continue;
-        const globalPaths = new Set(globalEntries.map((e) => e.path));
-        for (const entry of repoEntries) {
-            if (globalPaths.has(entry.path)) {
-                warnings.push({
-                    kind: "precedence",
-                    message: `Agent "${agentId}" has agentRules entry "${entry.name}" deployed to both global and repo scope from the same source path "${entry.path}". The file will be written to two distinct targets — verify this is intentional and not a copy-paste mistake.`,
-                });
+        const scopeList = Array.from(scopes).sort();
+        for (let i = 0; i < scopeList.length; i++) {
+            for (let j = i + 1; j < scopeList.length; j++) {
+                const entryB = list.find((l) => l.scope === scopeList[j]);
+                if (entryB) {
+                    warnings.push({
+                        kind: "precedence",
+                        message: `Agent "${agentId}" has agentRules entry "${entryB.name}" deployed to both ${scopeList[i]} and ${scopeList[j]} scope from the same source path "${path}". The file will be written to two distinct targets — verify this is intentional and not a copy-paste mistake.`,
+                    });
+                }
             }
         }
-        const nonOverlapRepo = repoEntries.filter((e) => !globalPaths.has(e.path));
-        if (nonOverlapRepo.length > 0) {
-            const globalNames = globalEntries.map((e) => `"${e.name}"`).join(", ");
-            const repoNames = nonOverlapRepo.map((e) => `"${e.name}"`).join(", ");
-            warnings.push({
-                kind: "precedence",
-                message: `Agent "${agentId}" will have both global and repo instruction files active simultaneously: global [${globalNames}] and repo [${repoNames}]. Both will be loaded by the agent — ensure the content is intended to stack and does not conflict.`,
-            });
-        }
+    }
+    return warnings;
+}
+function detectMultipleActiveInstructionScopes(agentId, rulesForAgent) {
+    const activeScopes = Array.from(new Set((rulesForAgent ?? []).map((e) => e.scope))).sort();
+    if (activeScopes.length <= 1)
+        return [];
+    const scopeDescriptions = activeScopes
+        .map((s) => {
+        const entries = (rulesForAgent ?? []).filter((e) => e.scope === s);
+        return `${s} [${entries.map((e) => `"${e.name}"`).join(", ")}]`;
+    })
+        .join(" and ");
+    return [
+        {
+            kind: "precedence",
+            message: `Agent "${agentId}" will have multiple instruction files active simultaneously across ${activeScopes.length} scopes: ${scopeDescriptions}. All will be loaded by the agent — ensure the content is intended to stack and does not conflict.`,
+        },
+    ];
+}
+function detectInstructionPrecedence(detectedAgents, manifest) {
+    const warnings = [];
+    for (const agentId of detectedAgents) {
+        const rulesForAgent = (manifest.agentRules ?? []).filter((e) => e.agents.includes(agentId));
+        warnings.push(...detectScopeOverlaps(agentId, rulesForAgent));
+        warnings.push(...detectMultipleActiveInstructionScopes(agentId, rulesForAgent));
     }
     return warnings;
 }
@@ -67,7 +129,7 @@ async function detectInstructionBudgetRisk(detectedAgents, manifest, sourceDir)
     }
     return warnings;
 }
-export async function runPreflight(options, manifest, _home, detectedAgents) {
+export async function runPreflight(options, manifest, home, detectedAgents) {
     const warnings = [];
     for (const agentId of detectedAgents) {
         const agent = AGENT_REGISTRY_BY_ID[agentId];
@@ -85,7 +147,15 @@ export async function runPreflight(options, manifest, _home, detectedAgents) {
                 message: `Agent "${agentId}" skill support is provisional: behavior has not been independently verified.`,
             });
         }
-        if (agent.policyNote) {
+        const enterpriseWarning = await detectEnterpriseManagement(agentId, home);
+        if (enterpriseWarning) {
+            warnings.push({
+                kind: "policy",
+                message: `Agent "${agentId}": ${enterpriseWarning}`,
+            });
+        }
+        else if (agent.policyNote &&
+            !agent.policyNote.includes("Organization policies may override")) {
             warnings.push({
                 kind: "policy",
                 message: `Agent "${agentId}": ${agent.policyNote}`,

package/dist/core/resolve.d.ts

@@ -9,4 +9,4 @@ export declare function resolveAgentSkillPathFor(agent: AgentConfig, skillName:
 export declare function resolveAgentDetectPathFor(agent: AgentConfig, home: string, platform: "posix" | "windows"): string;
 export declare function resolveAgentSkillPath(agent: AgentConfig, skillName: string, home: string): string;
 export declare function resolveAgentDetectPath(agent: AgentConfig, home: string): string;
-export declare function resolvePlaceholders(segments: string[], skillName: string, home: string, repo?: string): string;
+export declare function resolvePlaceholders(segments: string[], skillName: string, home: string, repo?: string, workspace?: string): string;

package/dist/core/resolve.js

@@ -86,8 +86,10 @@ export function getDeployMethod() {
 }
 export function resolveAgentSkillPathFor(agent, skillName, home, platform) {
     if (!agent.skills) {
-        throw new Error(`Agent "${agent.id}" does not have a skills deployment path. ` +
-            `Deploy skills via another agent target that covers this agent natively (e.g. claude-code for github-copilot).`);
+        const hint = agent.skillsSurfaceKind?.kind === "shared-via"
+            ? ` Deploy skills via the "${agent.skillsSurfaceKind.via}" target, which covers this agent natively.`
+            : "";
+        throw new Error(`Agent "${agent.id}" does not have a skills deployment path.${hint}`);
     }
     return resolvePlaceholders(agent.skills[platform], skillName, home);
 }
@@ -100,14 +102,15 @@ export function resolveAgentSkillPath(agent, skillName, home) {
 export function resolveAgentDetectPath(agent, home) {
     return resolveAgentDetectPathFor(agent, home, getPlatformKey());
 }
-export function resolvePlaceholders(segments, skillName, home, repo) {
+export function resolvePlaceholders(segments, skillName, home, repo, workspace) {
     const { appdata, xdgConfig } = resolveRuntimePaths(home);
     const resolved = segments.map((seg) => seg
         .replace("{home}", home)
         .replace("{name}", skillName)
         .replace("{appdata}", appdata)
         .replace("{xdg_config}", xdgConfig)
-        .replace("{repo}", repo ?? ""));
+        .replace("{repo}", repo ?? "")
+        .replace("{workspace}", workspace ?? repo ?? ""));
     const root = resolved.find((segment) => segment.length > 0) ?? home;
     return getPathApi(root).join(...resolved);
 }

package/dist/core/revert.js

@@ -138,11 +138,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) {
@@ -168,14 +166,18 @@ export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
                     target: action.target,
                 }, 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,
+    };
 }
 async function executeRevertAction(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;

package/dist/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/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/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/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) {
@@ -166,9 +167,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 +190,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/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/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

@@ -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/logger.js

@@ -1,36 +1,37 @@
 import process from "node:process";
-const C = {
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    cyan: "\x1b[36m",
-    reset: "\x1b[0m",
-};
+import { styleText } from "node:util";
 export function createLogger() {
     let silent = false;
-    const tty = Boolean(process.stdout.isTTY);
-    const errTTY = Boolean(process.stderr.isTTY);
-    const c = (col, text, onTTY) => onTTY ? `${C[col]}${text}${C.reset}` : text;
     return {
         fail(label, msg) {
-            if (!silent)
-                process.stderr.write(`  ${c("red", "✗", errTTY)} ${label}: ${msg}\n`);
+            if (!silent) {
+                const icon = styleText("red", "✗");
+                process.stderr.write(`  ${icon} ${label}: ${msg}\n`);
+            }
         },
         ok(label) {
-            if (!silent)
-                process.stdout.write(`  ${c("green", "✓", tty)} ${label}\n`);
+            if (!silent) {
+                const icon = styleText("green", "✓");
+                process.stdout.write(`  ${icon} ${label}\n`);
+            }
         },
         skip(label, note) {
-            if (!silent)
-                process.stdout.write(`  ${c("yellow", "-", tty)} ${label} ${note}\n`);
+            if (!silent) {
+                const icon = styleText("yellow", "-");
+                process.stdout.write(`  ${icon} ${label} ${note}\n`);
+            }
         },
         plan(label) {
-            if (!silent)
-                process.stdout.write(`  ${c("cyan", "○", tty)} ${label}\n`);
+            if (!silent) {
+                const icon = styleText("cyan", "○");
+                process.stdout.write(`  ${icon} ${label}\n`);
+            }
         },
         warn(label, msg) {
-            if (!silent)
-                process.stdout.write(`  ${c("yellow", "!", tty)} ${label}: ${msg}\n`);
+            if (!silent) {
+                const icon = styleText("yellow", "!");
+                process.stdout.write(`  ${icon} ${label}: ${msg}\n`);
+            }
         },
         info(msg) {
             if (!silent)
@@ -57,5 +58,5 @@ export const logger = createLogger();
 export function dryRunPrefix(dryRun) {
     if (!dryRun)
         return "";
-    return process.stdout.isTTY ? `\x1b[36m[dry-run]\x1b[0m ` : `[dry-run] `;
+    return styleText("cyan", "[plan] ");
 }

package/dist/schemas/manifest.d.ts

@@ -74,6 +74,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<{
@@ -165,6 +166,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<{