@kuznai/inception-engine 0.12.0 → 0.14.0

package/dist/core/deploy.js

@@ -4,10 +4,12 @@ import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
+import { writeFrontmatterFile } from "./adapters/frontmatter.js";
 import { compileAdapterActions } from "./adapters/index.js";
+import { applyTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
-import { resolveTargetTemplate } from "./runtime-paths.js";
+import { getPathApi, resolveTargetTemplate } from "./runtime-paths.js";
 import { sourceAccessError, validateSkillDefinitionFile, validateSourceFile, validateSourcePath, } from "./validation.js";
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -80,14 +82,30 @@ function detectCollisions(actions) {
     }
     return warnings;
 }
-function detectAmbiguities(detectedAgents) {
+function detectAmbiguities(detectedAgents, actions, home) {
     const warnings = [];
-    if (detectedAgents.includes("gemini-cli") &&
-        detectedAgents.includes("antigravity")) {
-        warnings.push({
-            kind: "ambiguity",
-            message: 'Both "gemini-cli" and "antigravity" share the ~/.gemini/ base directory. antigravity skill support is implementation-only. Verify that deployed skill paths do not conflict.',
+    const hasGeminiCli = detectedAgents.includes("gemini-cli");
+    const hasAntigravity = detectedAgents.includes("antigravity");
+    if (hasGeminiCli && hasAntigravity) {
+        const homePathApi = getPathApi(home);
+        const sharedGeminiMd = homePathApi.join(home, ".gemini", "GEMINI.md");
+        const sharedSettings = homePathApi.join(home, ".gemini", "settings.json");
+        // Normalize paths for comparison to handle case-insensitivity on Windows
+        const normalize = (pathStr) => homePathApi === path.win32
+            ? pathStr.toLowerCase()
+            : pathStr;
+        const normalizedGeminiMd = normalize(sharedGeminiMd);
+        const normalizedSettings = normalize(sharedSettings);
+        const targetsShared = actions.some((a) => {
+            const normalizedTarget = normalize(a.target);
+            return normalizedTarget === normalizedGeminiMd || normalizedTarget === normalizedSettings;
         });
+        if (targetsShared) {
+            warnings.push({
+                kind: "ambiguity",
+                message: "Both 'gemini-cli' and 'antigravity' are active, and a deployment targets a shared surface (~/.gemini/GEMINI.md or settings.json). Because Antigravity treats GEMINI.md as an Agent Blueprint, changes intended for one runtime may unexpectedly affect the other.",
+            });
+        }
     }
     return warnings;
 }
@@ -143,7 +161,7 @@ async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, real
     }
     return actions;
 }
-function planConfigPatchActions(manifest, detectedAgents, home) {
+function planConfigPatchActions(manifest, detectedAgents, home, repo) {
     const actions = [];
     for (const configEntry of manifest.configs ?? []) {
         for (const agentId of configEntry.agents) {
@@ -156,7 +174,7 @@ function planConfigPatchActions(manifest, detectedAgents, home) {
                 kind: "config-patch",
                 skill: configEntry.name,
                 agent: agentId,
-                target: resolveTargetTemplate(configEntry.target, home),
+                target: resolveTargetTemplate(configEntry.target, home, repo),
                 patch: configEntry.patch,
                 confidence: agent.provenance.skills,
             });
@@ -176,56 +194,44 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     const actions = [
         ...(await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
         ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
-        ...planConfigPatchActions(manifest, detectedAgents, home),
+        ...planConfigPatchActions(manifest, detectedAgents, home, resolvedSourceDir),
     ];
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, resolvedSourceDir);
     actions.push(...adapterResult.actions);
     const warnings = [
-        ...detectAmbiguities(detectedAgents),
+        ...detectAmbiguities(detectedAgents, actions, home),
         ...detectCollisions(actions),
         ...adapterResult.warnings,
     ];
     return { actions, warnings };
 }
+async function dispatchDeployAction(action, dryRun, verbose, home, planned, deps) {
+    switch (action.kind) {
+        case "skill-dir":
+            return deploySkillDir(action, dryRun, verbose, home, planned, deps);
+        case "file-write":
+            return deployFileWrite(action, dryRun, verbose, home, planned, deps);
+        case "config-patch":
+            return deployConfigPatch(action, dryRun, verbose, home, planned, deps);
+        case "toml-patch":
+            return deployTomlPatch(action, dryRun, verbose, home, planned, deps);
+        case "frontmatter-emit":
+            return deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
+        default:
+            throw new Error(`Unhandled deploy action kind: ${action.kind}`);
+    }
+}
 export async function executeDeploy(actions, dryRun, verbose, home, deps = {}) {
     let succeeded = 0;
     const failed = [];
     const planned = [];
     for (const action of actions) {
-        switch (action.kind) {
-            case "skill-dir": {
-                const result = await deploySkillDir(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            case "file-write": {
-                const result = await deployFileWrite(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            case "config-patch": {
-                const result = await deployConfigPatch(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            default: {
-                throw new Error(`Unhandled deploy action kind: ${action}`);
-            }
+        const result = await dispatchDeployAction(action, dryRun, verbose, home, planned, deps);
+        if (result.error === null) {
+            succeeded++;
+        }
+        else {
+            failed.push({ action, error: result.error });
         }
     }
     return { succeeded, failed, planned };
@@ -593,3 +599,87 @@ async function backupExisting(targetPath, verbose, home, expected, deps) {
     await rename(targetPath, backupPath);
     return backupPath;
 }
+async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (dryRun) {
+        planned.push({
+            verb: "patch-toml",
+            kind: "toml-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            confidence: action.confidence,
+        });
+        return { error: null };
+    }
+    try {
+        // Guard against double-patching by a different skill/agent.
+        const existingEntry = await lookupDeployment(home, action.target, deps.registry);
+        if (existingEntry &&
+            (existingEntry.skill !== action.skill ||
+                existingEntry.agent !== action.agent)) {
+            throw new Error(`Config "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to double-patch`);
+        }
+        await applyTomlMcpPatch(action.target, action.skill, action.config);
+        await registerDeployment(home, action.target, {
+            kind: "config-patch",
+            patch: { mcpServers: { [action.skill]: action.config } },
+            undoPatch: { mcpServers: { [action.skill]: null } },
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`patch-toml: wrote [mcpServers.${action.skill}] to ${action.target}`);
+        }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
+async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (dryRun) {
+        planned.push({
+            verb: "emit-frontmatter",
+            kind: "frontmatter-emit",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            frontmatter: action.frontmatter,
+            confidence: action.confidence,
+        });
+        return { error: null };
+    }
+    try {
+        // Guard against double-patching by a different skill/agent.
+        const existingEntry = await lookupDeployment(home, action.target, deps.registry);
+        if (existingEntry &&
+            (existingEntry.skill !== action.skill ||
+                existingEntry.agent !== action.agent)) {
+            throw new Error(`File "${action.target}" is already managed by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to overwrite`);
+        }
+        await writeFrontmatterFile(action.target, action.frontmatter, {
+            preserveBody: true,
+        });
+        await registerDeployment(home, action.target, {
+            kind: "file-write",
+            source: action.target,
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`emit-frontmatter: wrote ${action.target}`);
+        }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}

package/dist/core/init.js

@@ -3,6 +3,29 @@ import path from "node:path";
 import { dryRunPrefix, logger } from "../logger.js";
 import { AGENT_IDS } from "../schemas/manifest.js";
 const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+// Ordered list: first match wins. Catch-all is applied at call site.
+const AGENT_RULES_FILE_PATTERNS = [
+    {
+        fileNames: ["claude.md", "claude-instructions.md"],
+        agents: ["claude-code"],
+    },
+    {
+        fileNames: ["agents.md", "agents-instructions.md"],
+        agents: ["codex", "opencode"],
+    },
+    {
+        fileNames: ["gemini.md", "gemini-instructions.md"],
+        agents: ["gemini-cli", "antigravity"],
+    },
+    { fileNames: ["copilot-instructions.md"], agents: ["github-copilot"] },
+];
+// Conventional subdirectory names to scan one level deep for .md files.
+const AGENT_RULES_SUBDIRS = [
+    "rules",
+    "instructions",
+    ".github",
+    ".agents/rules",
+];
 async function findSkillDirs(baseDir, dir, found) {
     let entries;
     try {
@@ -52,6 +75,91 @@ function buildSkills(found, agents) {
     }
     return skills;
 }
+function defaultAgentsForFile(fileName, fallback) {
+    const lower = fileName.toLowerCase();
+    for (const { fileNames, agents } of AGENT_RULES_FILE_PATTERNS) {
+        if (fileNames.includes(lower))
+            return agents;
+    }
+    return fallback;
+}
+function isInsideSkillDir(relPath, skillDirRelPaths) {
+    const parentRelPath = path.dirname(relPath).split(path.sep).join("/");
+    if (skillDirRelPaths.has(parentRelPath))
+        return true;
+    return [...skillDirRelPaths].some((sp) => parentRelPath === sp || parentRelPath.startsWith(`${sp}/`));
+}
+function deriveAgentRulesName(relPath, fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    const baseName = path.basename(fileName, ext);
+    const rawName = baseName.toLowerCase().replace(/[^a-zA-Z0-9._-]/g, "-");
+    if (!SAFE_NAME_RE.test(rawName)) {
+        logger.warn("init", `Skipping "${relPath}": could not derive a valid agentRules name`);
+        return null;
+    }
+    return rawName;
+}
+async function scanDirForMarkdown(dir, baseDir, skillDirRelPaths, seen, candidates) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true, encoding: "utf-8" });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const ext = path.extname(entry.name).toLowerCase();
+        if (ext !== ".md" && ext !== ".markdown")
+            continue;
+        const absPath = path.join(dir, entry.name);
+        const relPath = path.relative(baseDir, absPath).split(path.sep).join("/");
+        if (seen.has(relPath) || isInsideSkillDir(relPath, skillDirRelPaths))
+            continue;
+        const name = deriveAgentRulesName(relPath, entry.name);
+        if (name === null)
+            continue;
+        seen.add(relPath);
+        candidates.push({ relPath, name, defaultAgents: [] });
+    }
+}
+async function findAgentRulesCandidates(baseDir, skillDirRelPaths) {
+    const candidates = [];
+    const seen = new Set();
+    await scanDirForMarkdown(baseDir, baseDir, skillDirRelPaths, seen, candidates);
+    for (const subdir of AGENT_RULES_SUBDIRS) {
+        await scanDirForMarkdown(path.join(baseDir, subdir), baseDir, skillDirRelPaths, seen, candidates);
+    }
+    return candidates;
+}
+function buildAgentRules(candidates, activeAgents, skillNamesSeen) {
+    const rules = [];
+    const namesSeen = new Set(skillNamesSeen);
+    for (const { relPath, name: rawName } of candidates) {
+        const fileName = path.basename(relPath);
+        const defaultAgents = defaultAgentsForFile(fileName, activeAgents);
+        // Intersect with active agents; fall back to full active list if empty
+        const intersection = defaultAgents.filter((a) => activeAgents.includes(a));
+        const agents = intersection.length > 0 ? intersection : activeAgents;
+        // Resolve name collision with skill names
+        let name = rawName;
+        if (namesSeen.has(name)) {
+            const candidate = `${name}-rules`;
+            if (SAFE_NAME_RE.test(candidate)) {
+                logger.warn("init", `agentRules name "${name}" collides with a skill name; using "${candidate}"`);
+                name = candidate;
+            }
+            else {
+                logger.warn("init", `Skipping "${relPath}": name "${name}" collides with a skill name and fallback is invalid`);
+                continue;
+            }
+        }
+        namesSeen.add(name);
+        rules.push({ name, path: relPath, agents });
+    }
+    return rules;
+}
 async function manifestExists(manifestPath) {
     try {
         await access(manifestPath);
@@ -73,27 +181,38 @@ export async function runInit(options) {
     await findSkillDirs(directory, directory, found);
     if (found.length === 0) {
         logger.info("No skill directories found (looking for directories containing SKILL.md).");
-        return 0;
     }
     const skills = buildSkills(found, agents);
-    if (skills.length === 0) {
-        logger.info("No skills could be added to the manifest.");
-        return 0;
-    }
-    const manifest = { skills, mcpServers: [], agentRules: [] };
+    const skillNamesSeen = new Set(skills.map((s) => s.name));
+    const skillDirRelPaths = new Set(found.map((f) => f.relPath));
+    const agentRulesCandidates = await findAgentRulesCandidates(directory, skillDirRelPaths);
+    const agentRules = buildAgentRules(agentRulesCandidates, agents, skillNamesSeen);
+    const manifest = {
+        skills,
+        files: [],
+        configs: [],
+        mcpServers: [],
+        agentRules,
+    };
     const json = `${JSON.stringify(manifest, null, 2)}\n`;
     if (dryRun) {
-        logger.info(`${dryRunPrefix(true)}Would write ${manifestPath} with ${skills.length} skill(s):`);
+        logger.info(`${dryRunPrefix(true)}Would write ${manifestPath} with ${skills.length} skill(s) and ${agentRules.length} agentRule(s):`);
         logger.info("");
         logger.info(json);
         return 0;
     }
     await writeFile(manifestPath, json, "utf-8");
-    logger.info(`Generated ${manifestPath} with ${skills.length} skill(s).`);
+    logger.info(`Generated ${manifestPath} with ${skills.length} skill(s) and ${agentRules.length} agentRule(s).`);
     if (verbose) {
         for (const s of skills) {
             logger.detail(`${s.name}  →  ${s.path}`);
         }
+        if (agentRules.length > 0) {
+            logger.detail("agentRules:");
+            for (const r of agentRules) {
+                logger.detail(`  ${r.name}  →  ${r.path}  [${r.agents.join(", ")}]`);
+            }
+        }
     }
     return 0;
 }

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): string;
+export declare function resolvePlaceholders(segments: string[], skillName: string, home: string, repo?: string): string;

package/dist/core/resolve.js

@@ -96,13 +96,14 @@ export function resolveAgentSkillPath(agent, skillName, home) {
 export function resolveAgentDetectPath(agent, home) {
     return resolveAgentDetectPathFor(agent, home, getPlatformKey());
 }
-export function resolvePlaceholders(segments, skillName, home) {
+export function resolvePlaceholders(segments, skillName, home, repo) {
     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("{xdg_config}", xdgConfig)
+        .replace("{repo}", repo ?? ""));
     const root = resolved.find((segment) => segment.length > 0) ?? home;
     return getPathApi(root).join(...resolved);
 }

package/dist/core/revert.d.ts

@@ -1,7 +1,7 @@
 import type { AgentId, Manifest, PlannedChange, RevertAction } from "../types.ts";
 import { type RegistryPersistence } from "./ownership.ts";
-export declare function planRevert(manifest: Manifest, detectedAgents: AgentId[], home: string): RevertAction[];
-export declare function planRevertAll(manifest: Manifest, home: string): RevertAction[];
+export declare function planRevert(manifest: Manifest, detectedAgents: AgentId[], home: string, repo?: string): RevertAction[];
+export declare function planRevertAll(manifest: Manifest, home: string, repo?: string): RevertAction[];
 export declare function executeRevert(actions: RevertAction[], dryRun: boolean, verbose: boolean, home: string, deps?: RevertDependencies): Promise<{
     succeeded: number;
     skipped: number;

package/dist/core/revert.js

@@ -2,6 +2,7 @@ import { lstat, readFile, rm, unlink, writeFile } from "node:fs/promises";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { logger } from "../logger.js";
 import { compileAgentRuleReverts, compileMcpServerReverts, } from "./adapters/index.js";
+import { revertTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
@@ -62,22 +63,22 @@ function buildConfigPatchReverts(manifest, home, agentFilter) {
     }
     return actions;
 }
-export function planRevert(manifest, detectedAgents, home) {
+export function planRevert(manifest, detectedAgents, home, repo) {
     return [
         ...buildSkillDirReverts(manifest, home, detectedAgents),
         ...buildFileWriteReverts(manifest, home, detectedAgents),
         ...buildConfigPatchReverts(manifest, home, detectedAgents),
-        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, detectedAgents, home)),
-        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, detectedAgents, home)),
+        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, detectedAgents, home, repo)),
+        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, detectedAgents, home, repo)),
     ];
 }
-export function planRevertAll(manifest, home) {
+export function planRevertAll(manifest, home, repo) {
     return [
         ...buildSkillDirReverts(manifest, home, null),
         ...buildFileWriteReverts(manifest, home, null),
         ...buildConfigPatchReverts(manifest, home, null),
-        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, null, home)),
-        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, null, home)),
+        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, null, home, repo)),
+        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, null, home, repo)),
     ];
 }
 function recordOutcome(result, action, counts, failed) {
@@ -148,8 +149,21 @@ export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
             case "config-patch":
                 result = await revertConfigPatch(action, dryRun, verbose, home, planned, deps);
                 break;
+            case "toml-patch":
+                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);
+                break;
             default:
-                throw new Error(`Unhandled revert action kind: ${action}`);
+                throw new Error(`Unhandled revert action kind: ${action.kind}`);
         }
         recordOutcome(result, action, counts, failed);
     }
@@ -316,3 +330,50 @@ async function revertConfigPatch(action, dryRun, verbose, home, planned, deps) {
         return { outcome: "fail", error: msg };
     }
 }
+async function revertTomlPatch(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 entry = await lookupDeployment(home, action.target, deps.registry);
+    if (!entry ||
+        entry.kind !== "config-patch" ||
+        entry.skill !== action.skill ||
+        entry.agent !== action.agent) {
+        logger.warn(label, `skipping: ${action.target} is not in the deployment registry — not managed by inception-engine`);
+        return { outcome: "skip" };
+    }
+    if (dryRun) {
+        planned.push({
+            verb: "unapply-patch",
+            kind: "toml-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        });
+        return { outcome: "ok" };
+    }
+    try {
+        await revertTomlMcpPatch(action.target, action.skill);
+        await unregisterDeployment(home, action.target, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`removed [mcpServers.${action.skill}] 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 };
+    }
+}

package/dist/core/runtime-paths.d.ts

@@ -5,4 +5,4 @@ export interface RuntimePaths {
 }
 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): string;
+export declare function resolveTargetTemplate(template: string, home: string, repo?: 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)\}(?<suffix>(?:[\\/].*)?)$/;
+const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config|repo)\}(?<suffix>(?:[\\/].*)?)$/;
 export function getPathApi(root) {
     if (root.includes("\\") || /^[a-zA-Z]:/.test(root)) {
         return path.win32;
@@ -32,18 +32,31 @@ export function resolveRuntimePaths(home) {
         : homePathApi.join(home, ".config");
     return { appdata, xdgConfig };
 }
-export function resolveTargetTemplate(template, home) {
+export function resolveTargetTemplate(template, home, repo) {
     const { appdata, 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 baseByRoot = {
         home,
         appdata,
         xdg_config: xdgConfig,
     };
-    const root = match[1];
     const suffix = match.groups?.suffix ?? "";
     const segments = suffix.split(/[\\/]+/).filter(Boolean);
     const pathApi = getPathApi(baseByRoot[root]);

package/dist/schemas/manifest.js

@@ -13,7 +13,9 @@ const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 // Target templates must be rooted at a known placeholder and may only add
 // descendant path segments beneath that root. e.g. "{home}/.claude/settings.json"
 // is valid, while "{home}/../.ssh/config" is rejected.
-const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config)\}(?:[\\/].*)?$/;
+// {repo} resolves to the manifest directory at deploy time, enabling repo-local
+// targets (e.g. Antigravity's .agents/rules/ surface).
+const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config|repo)\}(?:[\\/].*)?$/;
 // Standalone schema used for type derivation and single-ID validation (e.g. index.ts).
 export const AgentIdSchema = z.enum(AGENT_IDS);
 // Used inside SkillEntrySchema.agents so that enum failures embed the received
@@ -53,7 +55,7 @@ const targetTemplateField = z
     .string({ message: "target must be a non-empty string" })
     .min(1, { message: "target must be a non-empty string" })
     .refine((t) => TARGET_TEMPLATE_RE.test(t), {
-    message: "target must start with a known placeholder: {home}, {appdata}, or {xdg_config}",
+    message: "target must start with a known placeholder: {home}, {appdata}, {xdg_config}, or {repo}",
 })
     .refine((t) => !t.split(/[\\/]+/).includes(".."), {
     message: "target must not escape its placeholder root",