omniagent 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,15 +1,131 @@
 #!/usr/bin/env node
-import { constants, realpathSync } from "node:fs";
-import { pathToFileURL } from "node:url";
+import { constants, realpathSync, existsSync, readFileSync } from "node:fs";
+import { pathToFileURL, fileURLToPath } from "node:url";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { stat, access, readFile, mkdir, writeFile, readdir, rm, rename } from "node:fs/promises";
+import { stat, rm, readdir, access, readFile, mkdir, writeFile, rename } from "node:fs/promises";
 import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import os from "node:os";
 import { createInterface } from "node:readline/promises";
 import { TextDecoder } from "node:util";
-import { createHash } from "node:crypto";
-import os from "node:os";
 import { spawn } from "node:child_process";
+async function pathExists$2(candidate) {
+  try {
+    await stat(candidate);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findUp(startDir, markerRelativePath) {
+  let current = path.resolve(startDir);
+  let previous = "";
+  while (current !== previous) {
+    if (await pathExists$2(path.join(current, markerRelativePath))) {
+      return current;
+    }
+    previous = current;
+    current = path.dirname(current);
+  }
+  return null;
+}
+async function findRepoRoot(startDir) {
+  const gitRoot = await findUp(startDir, ".git");
+  if (gitRoot) {
+    return gitRoot;
+  }
+  return await findUp(startDir, "package.json");
+}
+function hashIdentifier$3(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+async function pathExists$1(candidate) {
+  try {
+    await stat(candidate);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listRepoSlashCommandManifestPaths(repoRoot) {
+  const matches = [];
+  const stack = [repoRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry2 of entries) {
+      const childPath = path.join(current, entry2.name);
+      if (entry2.isDirectory()) {
+        stack.push(childPath);
+        continue;
+      }
+      if (entry2.isFile() && entry2.name === ".omniagent-slash-commands.toml") {
+        matches.push(childPath);
+      }
+    }
+  }
+  return matches;
+}
+function resolveRepoScopedStatePaths(repoRoot, homeDir) {
+  const repoHash = hashIdentifier$3(repoRoot);
+  return [
+    path.join(homeDir, ".omniagent", "state", "managed-outputs", "projects", repoHash),
+    path.join(homeDir, ".omniagent", "state", "instructions", "projects", repoHash),
+    path.join(homeDir, ".omniagent", "state", "subagents", "projects", repoHash),
+    path.join(homeDir, ".omniagent", "state", "slash-commands", "projects", repoHash),
+    path.join(homeDir, ".omniagent", "state", "ignore-rules", "projects", `${repoHash}.json`),
+    path.join(homeDir, ".omniagent", "slash-commands", "projects", repoHash),
+    path.join(homeDir, ".omniagent", "slash-commands", "skills", "projects", repoHash),
+    path.join(repoRoot, ".omniagent", "slash-commands")
+  ];
+}
+async function resetProjectState(repoRoot, homeDir = os.homedir()) {
+  const candidates = [
+    ...resolveRepoScopedStatePaths(repoRoot, homeDir),
+    ...await listRepoSlashCommandManifestPaths(repoRoot)
+  ];
+  const uniqueCandidates = Array.from(new Set(candidates));
+  const removedPaths = [];
+  for (const candidate of uniqueCandidates) {
+    if (!await pathExists$1(candidate)) {
+      continue;
+    }
+    await rm(candidate, { recursive: true, force: true });
+    removedPaths.push(candidate);
+  }
+  return { removedPaths };
+}
+const resetStateCommand = {
+  command: "reset-state",
+  describe: "Reset omniagent project state for the current repository",
+  handler: async () => {
+    const startDir = process.cwd();
+    const repoRoot = await findRepoRoot(startDir);
+    if (!repoRoot) {
+      console.error("Error: Could not find a project root from the current directory.");
+      process.exit(1);
+      return;
+    }
+    const result = await resetProjectState(repoRoot);
+    if (result.removedPaths.length === 0) {
+      console.log(`No project state found for: ${repoRoot}`);
+      return;
+    }
+    console.log(`Reset project state for: ${repoRoot}`);
+    console.log(`Removed ${result.removedPaths.length} path(s).`);
+  }
+};
+const devCommand = {
+  command: "dev <command>",
+  describe: "Developer utilities",
+  builder: (yargs2) => yargs2.command(resetStateCommand).demandCommand(1, "Specify a dev command.").strictCommands(),
+  handler: () => {
+  }
+};
 const echoCommand = {
   command: "echo [message]",
   describe: "Echo a message with optional repetition and prefix",
@@ -718,6 +834,74 @@ const codexTarget = {
     }
   }
 };
+const FRONTMATTER_MARKER$2 = "---";
+function stripFrontmatterFields(contents, keysToRemove) {
+  const lines = contents.split(/\r?\n/);
+  if (lines[0]?.trim() !== FRONTMATTER_MARKER$2) {
+    return contents;
+  }
+  let endIndex = -1;
+  for (let i = 1; i < lines.length; i += 1) {
+    if (lines[i].trim() === FRONTMATTER_MARKER$2) {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return contents;
+  }
+  const normalizedKeys = new Set(Array.from(keysToRemove).map((key) => key.toLowerCase()));
+  const frontmatterLines = lines.slice(1, endIndex);
+  const filtered = [];
+  let skippingList = false;
+  for (const line of frontmatterLines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (skippingList) {
+      if (match && !normalizedKeys.has(match[1].toLowerCase())) {
+        skippingList = false;
+      } else if (!match) {
+        const shouldSkip = trimmed === "" || trimmed.startsWith("-") || trimmed.startsWith("#");
+        if (shouldSkip) {
+          continue;
+        }
+        skippingList = false;
+      } else {
+        continue;
+      }
+    }
+    if (match) {
+      const [, key, rawValue] = match;
+      if (normalizedKeys.has(key.toLowerCase())) {
+        const rest = rawValue.trim();
+        if (!rest || rest.startsWith("#")) {
+          skippingList = true;
+        }
+        continue;
+      }
+    }
+    if (!skippingList) {
+      filtered.push(line);
+    }
+  }
+  const eol = contents.includes("\r\n") ? "\r\n" : "\n";
+  const outputLines = [lines[0], ...filtered, ...lines.slice(endIndex)];
+  return outputLines.join(eol);
+}
+const TARGET_FRONTMATTER_KEYS$3 = /* @__PURE__ */ new Set(["targets", "targetagents"]);
+function isSlashCommandLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const command = value;
+  return typeof command.name === "string" && typeof command.rawContents === "string";
+}
+function renderPromptReference(agentName) {
+  return `---
+agent: ${JSON.stringify(agentName)}
+---
+`;
+}
 const copilotTarget = {
   id: "copilot",
   displayName: "GitHub Copilot CLI",
@@ -740,13 +924,41 @@ const copilotTarget = {
   },
   outputs: {
     skills: "{repoRoot}/.github/skills/{itemName}",
-    subagents: {
-      path: "{repoRoot}/.github/skills/{itemName}",
-      fallback: { mode: "convert", targetType: "skills" }
-    },
+    subagents: "{repoRoot}/.github/agents/{itemName}.agent.md",
     commands: {
-      projectPath: "{repoRoot}/.github/skills/{itemName}",
-      fallback: { mode: "convert", targetType: "skills" }
+      projectPath: "{repoRoot}/.github/agents/{itemName}.agent.md",
+      converter: {
+        id: "copilot-command-to-agent-and-prompt",
+        convert: (item, context) => {
+          if (!isSlashCommandLike(item)) {
+            return { error: "Invalid slash command payload for Copilot conversion." };
+          }
+          const agentPath = path.join(
+            context.repoRoot,
+            ".github",
+            "agents",
+            `${item.name}.agent.md`
+          );
+          const promptPath = path.join(
+            context.repoRoot,
+            ".github",
+            "prompts",
+            `${item.name}.prompt.md`
+          );
+          return {
+            outputs: [
+              {
+                outputPath: agentPath,
+                content: stripFrontmatterFields(item.rawContents, TARGET_FRONTMATTER_KEYS$3)
+              },
+              {
+                outputPath: promptPath,
+                content: renderPromptReference(item.name)
+              }
+            ]
+          };
+        }
+      }
     },
     instructions: {
       filename: "AGENTS.md",
@@ -812,7 +1024,7 @@ const BUILTIN_TARGETS = [
   copilotTarget
 ];
 Object.freeze(BUILTIN_TARGETS.map((target) => target.id));
-const FRONTMATTER_MARKER$2 = "---";
+const FRONTMATTER_MARKER$1 = "---";
 function parseScalar$1(rawValue) {
   const trimmed = rawValue.trim();
   if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
@@ -864,12 +1076,12 @@ function parseFrontmatter(lines) {
 }
 function extractFrontmatter$1(contents) {
   const lines = contents.split(/\r?\n/);
-  if (lines[0]?.trim() !== FRONTMATTER_MARKER$2) {
+  if (lines[0]?.trim() !== FRONTMATTER_MARKER$1) {
     return { frontmatter: {}, body: contents.trimEnd() };
   }
   let endIndex = -1;
   for (let i = 1; i < lines.length; i += 1) {
-    if (lines[i].trim() === FRONTMATTER_MARKER$2) {
+    if (lines[i].trim() === FRONTMATTER_MARKER$1) {
       endIndex = i;
       break;
     }
@@ -933,6 +1145,7 @@ function parseInstructionFrontmatter(options) {
     resolvedOutputDir
   };
 }
+const RESERVED_MANAGED_SOURCE_DIRS = /* @__PURE__ */ new Set(["skills", "commands", "agents", "instructions"]);
 function isTemplateFile(fileName) {
   if (!fileName.toLowerCase().endsWith(".md")) {
     return false;
@@ -962,6 +1175,19 @@ async function listTemplateFiles(root) {
   }
   return files;
 }
+function isInReservedManagedSourceDir(filePath, repoRoot, agentsDir) {
+  const templatesRoot = resolveAgentsDirPath(repoRoot, agentsDir);
+  const relative = path.relative(templatesRoot, filePath);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return false;
+  }
+  const segments = relative.split(path.sep).filter(Boolean);
+  if (segments.length < 2) {
+    return false;
+  }
+  const first = segments[0] === ".local" ? segments[1] : segments[0];
+  return first ? RESERVED_MANAGED_SOURCE_DIRS.has(first) : false;
+}
 async function scanInstructionTemplateSources(options) {
   const includeLocal = options.includeLocal ?? true;
   const templatesRoot = resolveAgentsDirPath(options.repoRoot, options.agentsDir);
@@ -973,6 +1199,9 @@ async function scanInstructionTemplateSources(options) {
   }
   const entries = [];
   for (const filePath of templateFiles) {
+    if (isInReservedManagedSourceDir(filePath, options.repoRoot, options.agentsDir)) {
+      continue;
+    }
     const markerType = detectLocalMarker$1(filePath);
     const sourceType = markerType ? "local" : "shared";
     if (!includeLocal && sourceType === "local") {
@@ -1630,59 +1859,456 @@ async function writeManagedOutputs(repoRoot, manifest, homeDir) {
   await writeFile(manifestPath, `${JSON.stringify({ entries: sorted }, null, 2)}
 `, "utf8");
 }
-const FRONTMATTER_MARKER$1 = "---";
-function stripFrontmatterFields(contents, keysToRemove) {
-  const lines = contents.split(/\r?\n/);
-  if (lines[0]?.trim() !== FRONTMATTER_MARKER$1) {
-    return contents;
+const SCRIPT_TAG_DEFINITIONS = [
+  { kind: "nodejs", openTag: "<nodejs>", closeTag: "</nodejs>" },
+  { kind: "shell", openTag: "<shell>", closeTag: "</shell>" }
+];
+const SCRIPT_HEARTBEAT_INTERVAL_MS = 3e4;
+const PREVIEW_LIMIT = 200;
+const WINDOWS_DEFAULT_SHELL = "cmd.exe";
+const POSIX_DEFAULT_SHELL = "/bin/sh";
+const RUNNER_SOURCE = String.raw`
+import path from "node:path";
+import { writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+
+const encoded = process.env.OMNIAGENT_SCRIPT_B64 ?? "";
+const sourceLabel = process.env.OMNIAGENT_SCRIPT_SOURCE ?? "template";
+const sourcePathValue = process.env.OMNIAGENT_SCRIPT_TEMPLATE_PATH ?? sourceLabel;
+const script = Buffer.from(encoded, "base64").toString("utf8");
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+const sourcePath = path.isAbsolute(sourcePathValue)
+	? sourcePathValue
+	: path.resolve(process.cwd(), sourcePathValue);
+const __filename = sourcePath;
+const __dirname = path.dirname(__filename);
+const require = createRequire(__filename);
+
+function encodeResult(value) {
+	if (value === undefined) {
+		return { kind: "undefined" };
+	}
+	if (value === null) {
+		return { kind: "null" };
+	}
+	const valueType = typeof value;
+	if (valueType === "string") {
+		return { kind: "string", value };
+	}
+	if (valueType === "number") {
+		return { kind: "number", value };
+	}
+	if (valueType === "boolean") {
+		return { kind: "boolean", value };
+	}
+	if (valueType === "bigint") {
+		return { kind: "bigint", value: value.toString() };
+	}
+	if (valueType === "symbol") {
+		return { kind: "symbol", value: String(value) };
+	}
+	if (valueType === "function") {
+		return { kind: "function", value: String(value) };
+	}
+	try {
+		return { kind: "json", value: JSON.stringify(value) };
+	} catch {
+		return { kind: "coerced", value: String(value) };
+	}
+}
+
+async function main() {
+	try {
+		const wrapped = script + "\n//# sourceURL=" + sourceLabel;
+		const fn = new AsyncFunction("require", "__dirname", "__filename", wrapped);
+		const result = await fn(require, __dirname, __filename);
+		writeFileSync(3, JSON.stringify({ ok: true, payload: encodeResult(result) }), "utf8");
+	} catch (error) {
+		const message =
+			error instanceof Error
+				? (error.stack ?? error.message)
+				: String(error);
+		writeFileSync(3, JSON.stringify({ ok: false, error: message }), "utf8");
+		process.exitCode = 1;
+	}
+}
+
+await main();
+`;
+class TemplateScriptExecutionError extends Error {
+  templatePath;
+  blockId;
+  constructor(message, options) {
+    super(message);
+    this.name = "TemplateScriptExecutionError";
+    this.templatePath = options.templatePath;
+    this.blockId = options.blockId ?? null;
   }
-  let endIndex = -1;
-  for (let i = 1; i < lines.length; i += 1) {
-    if (lines[i].trim() === FRONTMATTER_MARKER$1) {
-      endIndex = i;
+}
+function formatParseError(templatePath, message) {
+  return new TemplateScriptExecutionError(
+    `Invalid template script markup in ${templatePath}: ${message}`,
+    { templatePath }
+  );
+}
+function createStillRunningWarning(options) {
+  return {
+    code: "still_running",
+    message: `Template script is still running for ${options.templatePath} (${options.blockId}).`,
+    templatePath: options.templatePath,
+    blockId: options.blockId
+  };
+}
+function appendWarning(runtime, warning) {
+  runtime.warnings.push(warning);
+  runtime.onWarning?.(warning);
+}
+function emitVerbose(runtime, message) {
+  if (!runtime.verbose) {
+    return;
+  }
+  runtime.onVerbose?.(message);
+}
+function hasTemplateScriptMarkup(content) {
+  return SCRIPT_TAG_DEFINITIONS.some((definition) => content.includes(definition.openTag));
+}
+function findNextScriptToken(content, cursor) {
+  let nextToken = null;
+  for (const definition of SCRIPT_TAG_DEFINITIONS) {
+    const openIndex = content.indexOf(definition.openTag, cursor);
+    if (openIndex !== -1 && (!nextToken || openIndex < nextToken.index)) {
+      nextToken = {
+        index: openIndex,
+        kind: "open",
+        definition
+      };
+    }
+    const closeIndex = content.indexOf(definition.closeTag, cursor);
+    if (closeIndex !== -1 && (!nextToken || closeIndex < nextToken.index)) {
+      nextToken = {
+        index: closeIndex,
+        kind: "close",
+        definition
+      };
+    }
+  }
+  return nextToken;
+}
+function resolveShellInvocation() {
+  if (process.platform === "win32") {
+    const command2 = process.env.ComSpec?.trim() || WINDOWS_DEFAULT_SHELL;
+    return { command: command2, args: ["/d", "/s", "/c"] };
+  }
+  const command = process.env.SHELL?.trim() || POSIX_DEFAULT_SHELL;
+  return { command, args: ["-c"] };
+}
+function normalizeScriptResult(payload) {
+  if (payload.kind === "undefined" || payload.kind === "null") {
+    return { renderedText: "", resultKind: "empty" };
+  }
+  if (payload.kind === "string") {
+    return { renderedText: payload.value, resultKind: "string" };
+  }
+  if (payload.kind === "json") {
+    return { renderedText: payload.value, resultKind: "json" };
+  }
+  if (payload.kind === "coerced") {
+    return { renderedText: payload.value, resultKind: "coerced" };
+  }
+  return {
+    renderedText: String(payload.value ?? ""),
+    resultKind: "coerced"
+  };
+}
+function markReusedExecutions(runtime, blockIds) {
+  for (const blockId of blockIds) {
+    const existing = runtime.scriptExecutions.get(blockId);
+    if (!existing) {
+      continue;
+    }
+    runtime.scriptExecutions.set(blockId, {
+      ...existing,
+      reusedAcrossTargets: true
+    });
+  }
+}
+function parseTemplateScripts(templatePath, content) {
+  const blocks = [];
+  let cursor = 0;
+  let index = 0;
+  while (cursor < content.length) {
+    const nextToken = findNextScriptToken(content, cursor);
+    if (!nextToken) {
       break;
     }
+    if (nextToken.kind === "close") {
+      throw formatParseError(
+        templatePath,
+        `closing ${nextToken.definition.closeTag} appears before an opening tag`
+      );
+    }
+    const { definition } = nextToken;
+    const scriptStart = nextToken.index + definition.openTag.length;
+    const closeIndex = content.indexOf(definition.closeTag, scriptStart);
+    if (closeIndex === -1) {
+      throw formatParseError(templatePath, `missing closing ${definition.closeTag} tag`);
+    }
+    const scriptBody = content.slice(scriptStart, closeIndex);
+    if (hasTemplateScriptMarkup(scriptBody)) {
+      throw formatParseError(templatePath, "nested template script blocks are not supported");
+    }
+    blocks.push({
+      blockId: `${templatePath}#${index}`,
+      templatePath,
+      index,
+      evaluator: definition.kind,
+      scriptBody,
+      startOffset: nextToken.index,
+      endOffset: closeIndex + definition.closeTag.length
+    });
+    index += 1;
+    cursor = closeIndex + definition.closeTag.length;
+  }
+  return { blocks };
+}
+async function executeNodeJsScriptBlock(options) {
+  const { block, runtime } = options;
+  const child = spawn(process.execPath, ["--input-type=module", "--eval", RUNNER_SOURCE], {
+    cwd: runtime.cwd,
+    env: {
+      ...process.env,
+      OMNIAGENT_SCRIPT_B64: Buffer.from(block.scriptBody, "utf8").toString("base64"),
+      OMNIAGENT_SCRIPT_SOURCE: options.blockLabel,
+      OMNIAGENT_SCRIPT_TEMPLATE_PATH: block.templatePath
+    },
+    // Ignore child stdout to prevent scripts with heavy console output from deadlocking on pipe backpressure.
+    stdio: ["ignore", "ignore", "pipe", "pipe"]
+  });
+  let stderr = "";
+  let responseRaw = "";
+  const stderrPipe = child.stderr;
+  if (stderrPipe) {
+    stderrPipe.setEncoding("utf8");
+    stderrPipe.on("data", (chunk) => {
+      stderr += chunk;
+    });
   }
-  if (endIndex === -1) {
-    return contents;
+  const resultPipe = child.stdio[3];
+  if (resultPipe) {
+    resultPipe.setEncoding("utf8");
+    resultPipe.on("data", (chunk) => {
+      responseRaw += chunk;
+    });
   }
-  const normalizedKeys = new Set(Array.from(keysToRemove).map((key) => key.toLowerCase()));
-  const frontmatterLines = lines.slice(1, endIndex);
-  const filtered = [];
-  let skippingList = false;
-  for (const line of frontmatterLines) {
-    const trimmed = line.trim();
-    const match = trimmed.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
-    if (skippingList) {
-      if (match && !normalizedKeys.has(match[1].toLowerCase())) {
-        skippingList = false;
-      } else if (!match) {
-        const shouldSkip = trimmed === "" || trimmed.startsWith("-") || trimmed.startsWith("#");
-        if (shouldSkip) {
-          continue;
-        }
-        skippingList = false;
-      } else {
-        continue;
-      }
+  const exitCode = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => resolve(code ?? 1));
+  });
+  const parsed = responseRaw.trim();
+  let response = null;
+  if (parsed.length > 0) {
+    try {
+      response = JSON.parse(parsed);
+    } catch {
+      response = null;
     }
-    if (match) {
-      const [, key, rawValue] = match;
-      if (normalizedKeys.has(key.toLowerCase())) {
-        const rest = rawValue.trim();
-        if (!rest || rest.startsWith("#")) {
-          skippingList = true;
-        }
-        continue;
+  }
+  if (exitCode !== 0) {
+    const message = response && !response.ok ? response.error : stderr.trim() || `Script process exited with code ${exitCode}.`;
+    throw new TemplateScriptExecutionError(
+      `Template script failed in ${block.templatePath} (${block.blockId}): ${message}`,
+      { templatePath: block.templatePath, blockId: block.blockId }
+    );
+  }
+  if (!response || !response.ok) {
+    throw new TemplateScriptExecutionError(
+      `Template script failed in ${block.templatePath} (${block.blockId}): invalid runner response`,
+      { templatePath: block.templatePath, blockId: block.blockId }
+    );
+  }
+  const normalized = normalizeScriptResult(response.payload);
+  return normalized;
+}
+async function executeShellScriptBlock(options) {
+  const { block, runtime } = options;
+  const shell = resolveShellInvocation();
+  const child = spawn(shell.command, [...shell.args, block.scriptBody], {
+    cwd: runtime.cwd,
+    env: {
+      ...process.env
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout = "";
+  let stderr = "";
+  const stdoutPipe = child.stdout;
+  if (stdoutPipe) {
+    stdoutPipe.setEncoding("utf8");
+    stdoutPipe.on("data", (chunk) => {
+      stdout += chunk;
+    });
+  }
+  const stderrPipe = child.stderr;
+  if (stderrPipe) {
+    stderrPipe.setEncoding("utf8");
+    stderrPipe.on("data", (chunk) => {
+      stderr += chunk;
+    });
+  }
+  const exitCode = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => resolve(code ?? 1));
+  });
+  if (exitCode !== 0) {
+    const message = stderr.trim() || `Script process exited with code ${exitCode}.`;
+    throw new TemplateScriptExecutionError(
+      `Template script failed in ${block.templatePath} (${block.blockId}): ${message}`,
+      { templatePath: block.templatePath, blockId: block.blockId }
+    );
+  }
+  return {
+    renderedText: stdout,
+    resultKind: stdout.length > 0 ? "string" : "empty"
+  };
+}
+async function executeScriptBlock(options) {
+  const { block, runtime } = options;
+  const startTime = Date.now();
+  const blockLabel = `${block.templatePath}#${block.index}`;
+  emitVerbose(runtime, `Evaluating template script ${blockLabel} (${block.evaluator}).`);
+  let warningTimer = null;
+  if (runtime.heartbeatIntervalMs > 0) {
+    warningTimer = setInterval(() => {
+      appendWarning(
+        runtime,
+        createStillRunningWarning({
+          templatePath: block.templatePath,
+          blockId: block.blockId
+        })
+      );
+    }, runtime.heartbeatIntervalMs);
+    warningTimer.unref();
+  }
+  try {
+    const executed = block.evaluator === "shell" ? await executeShellScriptBlock({ block, runtime }) : await executeNodeJsScriptBlock({ block, runtime, blockLabel });
+    const durationMs = Date.now() - startTime;
+    emitVerbose(
+      runtime,
+      `Finished template script ${blockLabel} (${block.evaluator}) in ${durationMs}ms.`
+    );
+    return { ...executed, durationMs };
+  } finally {
+    if (warningTimer) {
+      clearInterval(warningTimer);
+    }
+  }
+}
+async function evaluateTemplateScriptsUncached(request) {
+  const { content, templatePath, runtime } = request;
+  const parsed = parseTemplateScripts(templatePath, content);
+  if (parsed.blocks.length === 0) {
+    return {
+      renderedContent: content,
+      blockIds: []
+    };
+  }
+  let output = "";
+  let cursor = 0;
+  const blockIds = [];
+  for (const block of parsed.blocks) {
+    output += content.slice(cursor, block.startOffset);
+    cursor = block.endOffset;
+    blockIds.push(block.blockId);
+    runtime.scriptExecutions.set(block.blockId, {
+      blockId: block.blockId,
+      templatePath,
+      status: "running",
+      reusedAcrossTargets: false
+    });
+    try {
+      const executed = await executeScriptBlock({ block, runtime });
+      output += executed.renderedText;
+      runtime.scriptExecutions.set(block.blockId, {
+        blockId: block.blockId,
+        templatePath,
+        status: "succeeded",
+        resultKind: executed.resultKind,
+        renderedPreview: executed.renderedText.slice(0, PREVIEW_LIMIT),
+        durationMs: executed.durationMs,
+        reusedAcrossTargets: false
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      runtime.scriptExecutions.set(block.blockId, {
+        blockId: block.blockId,
+        templatePath,
+        status: "failed",
+        errorMessage: message,
+        reusedAcrossTargets: false
+      });
+      if (!runtime.failedTemplatePath) {
+        runtime.failedTemplatePath = templatePath;
+        runtime.failedBlockId = block.blockId;
+      }
+      if (error instanceof TemplateScriptExecutionError) {
+        throw error;
       }
+      throw new TemplateScriptExecutionError(message, {
+        templatePath,
+        blockId: block.blockId
+      });
     }
-    if (!skippingList) {
-      filtered.push(line);
+  }
+  output += content.slice(cursor);
+  return {
+    renderedContent: output,
+    blockIds
+  };
+}
+function createTemplateScriptRuntime(options = {}) {
+  return {
+    runId: options.runId ?? randomUUID(),
+    verbose: options.verbose ?? false,
+    heartbeatIntervalMs: options.heartbeatIntervalMs ?? SCRIPT_HEARTBEAT_INTERVAL_MS,
+    cwd: options.cwd ?? process.cwd(),
+    cache: /* @__PURE__ */ new Map(),
+    usageCounts: /* @__PURE__ */ new Map(),
+    scriptExecutions: /* @__PURE__ */ new Map(),
+    warnings: [],
+    failedTemplatePath: null,
+    failedBlockId: null,
+    onWarning: options.onWarning,
+    onVerbose: options.onVerbose
+  };
+}
+async function evaluateTemplateScripts(request) {
+  const usageCount = (request.runtime.usageCounts.get(request.templatePath) ?? 0) + 1;
+  request.runtime.usageCounts.set(request.templatePath, usageCount);
+  const existing = request.runtime.cache.get(request.templatePath);
+  if (existing) {
+    const cached = await existing;
+    if (usageCount > 1 && cached.blockIds.length > 0) {
+      markReusedExecutions(request.runtime, cached.blockIds);
     }
+    return cached.renderedContent;
+  }
+  const evaluationPromise = evaluateTemplateScriptsUncached(request);
+  request.runtime.cache.set(request.templatePath, evaluationPromise);
+  try {
+    const evaluated = await evaluationPromise;
+    if (usageCount > 1 && evaluated.blockIds.length > 0) {
+      markReusedExecutions(request.runtime, evaluated.blockIds);
+    }
+    return evaluated.renderedContent;
+  } catch (error) {
+    request.runtime.cache.delete(request.templatePath);
+    throw error;
   }
-  const eol = contents.includes("\r\n") ? "\r\n" : "\n";
-  const outputLines = [lines[0], ...filtered, ...lines.slice(endIndex)];
-  return outputLines.join(eol);
+}
+function listTemplateScriptExecutions(runtime) {
+  return [...runtime.scriptExecutions.values()].sort(
+    (left, right) => left.blockId.localeCompare(right.blockId)
+  );
 }
 const utf8Decoder$1 = new TextDecoder("utf-8", { fatal: true });
 const TARGET_FRONTMATTER_KEYS$2 = /* @__PURE__ */ new Set(["targets", "targetagents"]);
@@ -1736,46 +2362,152 @@ async function writeOutputFile(outputPath, content) {
   await writeFile(outputPath, buffer);
   return { status: existing ? "updated" : "created", contentHash };
 }
-async function copySkillDirectory(options) {
-  await mkdir(options.destination, { recursive: true });
-  const entries = await readdir(options.source, { withFileTypes: true });
-  const selectedSkillFile = options.skillFileName.toLowerCase();
-  const outputSkillFile = options.outputFileName;
-  for (const entry2 of entries) {
-    const sourcePath = path.join(options.source, entry2.name);
-    const entryLowerName = entry2.name.toLowerCase();
-    const isSkillFile = entryLowerName === "skill.md" || entryLowerName === "skill.local.md";
-    if (isSkillFile && entryLowerName !== selectedSkillFile) {
+function markerRank(markerType) {
+  if (markerType === "path") {
+    return 2;
+  }
+  if (markerType === "suffix") {
+    return 1;
+  }
+  return 0;
+}
+function normalizeLocalRelativeFilePath(relativePath) {
+  const parts = relativePath.split(path.sep).filter(Boolean);
+  if (parts.length === 0) {
+    return { normalizedPath: relativePath, markerType: null };
+  }
+  const directoryParts = parts.slice(0, -1);
+  const fileName = parts[parts.length - 1];
+  let hasPathMarker = false;
+  const normalizedDirectories = [];
+  for (const part of directoryParts) {
+    if (part === ".local") {
+      hasPathMarker = true;
       continue;
     }
-    const destinationPath = isSkillFile ? path.join(options.destination, outputSkillFile) : path.join(options.destination, entry2.name);
-    if (entry2.isDirectory()) {
-      await copySkillDirectory({
-        ...options,
-        source: sourcePath,
-        destination: path.join(options.destination, entry2.name)
-      });
-      continue;
+    const { baseName, hadLocalSuffix } = stripLocalPathSuffix(part);
+    if (hadLocalSuffix) {
+      hasPathMarker = true;
     }
-    if (!entry2.isFile()) {
+    if (!baseName) {
       continue;
     }
-    const buffer = await readFile(sourcePath);
+    normalizedDirectories.push(baseName);
+  }
+  let normalizedFileName = fileName;
+  const isEnvPrefixedFile = fileName.toLowerCase().startsWith(".env");
+  const extension = path.extname(fileName);
+  let strippedSuffix = {
+    outputFileName: fileName,
+    hadLocalSuffix: false
+  };
+  if (!isEnvPrefixedFile) {
+    strippedSuffix = stripLocalSuffix(fileName, extension);
+    if (strippedSuffix.hadLocalSuffix) {
+      normalizedFileName = strippedSuffix.outputFileName;
+    }
+    const strippedPath = stripLocalPathSuffix(normalizedFileName);
+    if (strippedPath.hadLocalSuffix) {
+      hasPathMarker = true;
+      normalizedFileName = strippedPath.baseName;
+    }
+  }
+  const normalizedParts = [...normalizedDirectories, normalizedFileName].filter(Boolean);
+  const markerType = hasPathMarker ? "path" : strippedSuffix.hadLocalSuffix ? "suffix" : null;
+  return {
+    normalizedPath: normalizedParts.join(path.sep),
+    markerType
+  };
+}
+async function collectSkillCopyCandidates(options) {
+  const selectedSkillFile = options.skillFileName.toLowerCase();
+  const candidates = [];
+  const walk = async (currentSource, relativePrefix = "") => {
+    const entries = await readdir(currentSource, { withFileTypes: true });
+    for (const entry2 of entries) {
+      const sourcePath = path.join(currentSource, entry2.name);
+      const relativePath = relativePrefix ? path.join(relativePrefix, entry2.name) : entry2.name;
+      if (entry2.isDirectory()) {
+        await walk(sourcePath, relativePath);
+        continue;
+      }
+      if (!entry2.isFile()) {
+        continue;
+      }
+      const entryLowerName = entry2.name.toLowerCase();
+      const isSkillFile = entryLowerName === "skill.md" || entryLowerName === "skill.local.md";
+      if (isSkillFile && entryLowerName !== selectedSkillFile) {
+        continue;
+      }
+      const detectedMarker = detectLocalMarkerFromPath(relativePath) ?? (options.sourceType === "local" && options.markerType === "path" ? "path" : null);
+      if (isSkillFile) {
+        candidates.push({
+          sourcePath,
+          destinationPath: path.join(options.destination, options.outputFileName),
+          isSkillFile: true,
+          markerRank: markerRank(detectedMarker)
+        });
+        continue;
+      }
+      const normalized = normalizeLocalRelativeFilePath(relativePath);
+      if (!normalized.normalizedPath) {
+        continue;
+      }
+      const marker = normalized.markerType ?? detectedMarker;
+      candidates.push({
+        sourcePath,
+        destinationPath: path.join(options.destination, normalized.normalizedPath),
+        isSkillFile: false,
+        markerRank: markerRank(marker)
+      });
+    }
+  };
+  await walk(options.source);
+  return candidates;
+}
+async function copySkillDirectory(options) {
+  await mkdir(options.destination, { recursive: true });
+  const candidates = await collectSkillCopyCandidates({
+    source: options.source,
+    destination: options.destination,
+    skillFileName: options.skillFileName,
+    outputFileName: options.outputFileName,
+    sourceType: options.sourceType,
+    markerType: options.markerType
+  });
+  const winnerByOutputPath = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = path.normalize(candidate.destinationPath).replace(/\\/g, "/").toLowerCase();
+    const existing = winnerByOutputPath.get(key);
+    if (!existing || candidate.markerRank > existing.markerRank || candidate.markerRank === existing.markerRank && candidate.sourcePath.localeCompare(existing.sourcePath) > 0) {
+      winnerByOutputPath.set(key, candidate);
+    }
+  }
+  const winners = [...winnerByOutputPath.values()].sort(
+    (left, right) => left.destinationPath.localeCompare(right.destinationPath)
+  );
+  for (const winner of winners) {
+    const buffer = await readFile(winner.sourcePath);
     const decoded = decodeUtf8$1(buffer);
     if (decoded === null) {
-      await mkdir(path.dirname(destinationPath), { recursive: true });
-      await writeFile(destinationPath, buffer);
+      await mkdir(path.dirname(winner.destinationPath), { recursive: true });
+      await writeFile(winner.destinationPath, buffer);
       continue;
     }
-    const templated = applyAgentTemplating({
+    const withScripts = options.templateScriptRuntime ? await evaluateTemplateScripts({
+      templatePath: winner.sourcePath,
       content: decoded,
+      runtime: options.templateScriptRuntime
+    }) : decoded;
+    const templated = applyAgentTemplating({
+      content: withScripts,
       target: options.targetId,
       validAgents: options.validAgents,
-      sourcePath
+      sourcePath: winner.sourcePath
     });
-    const output = isSkillFile ? stripFrontmatterFields(templated, TARGET_FRONTMATTER_KEYS$2) : templated;
-    await mkdir(path.dirname(destinationPath), { recursive: true });
-    await writeFile(destinationPath, output, "utf8");
+    const output = winner.isSkillFile ? stripFrontmatterFields(templated, TARGET_FRONTMATTER_KEYS$2) : templated;
+    await mkdir(path.dirname(winner.destinationPath), { recursive: true });
+    await writeFile(winner.destinationPath, output, "utf8");
   }
 }
 const defaultSkillWriter = {
@@ -1791,7 +2523,10 @@ const defaultSkillWriter = {
       targetId: options.context.targetId,
       validAgents: options.context.validAgents,
       skillFileName: item.skillFileName,
-      outputFileName: item.outputFileName
+      outputFileName: item.outputFileName,
+      sourceType: item.sourceType,
+      markerType: item.markerType,
+      templateScriptRuntime: options.context.templateScriptRuntime
     });
     return { status: "created" };
   }
@@ -1803,8 +2538,13 @@ const defaultSubagentWriter = {
     if (!item) {
       return writeOutputFile(options.outputPath, options.content);
     }
-    const templated = applyAgentTemplating({
+    const withScripts = options.context.templateScriptRuntime ? await evaluateTemplateScripts({
+      templatePath: item.sourcePath,
       content: item.rawContents,
+      runtime: options.context.templateScriptRuntime
+    }) : item.rawContents;
+    const templated = applyAgentTemplating({
+      content: withScripts,
       target: options.context.targetId,
       validAgents: options.context.validAgents,
       sourcePath: item.sourcePath
@@ -1888,6 +2628,10 @@ function formatDisplayPath$4(repoRoot, absolutePath) {
   const isWithinRepo = relative && !relative.startsWith("..") && !path.isAbsolute(relative);
   return isWithinRepo ? relative : absolutePath;
 }
+function isWithinDirectory(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
 function sortCandidates(candidates) {
   return [...candidates].sort(
     (left, right) => left.source.sourcePath.localeCompare(right.source.sourcePath)
@@ -2023,6 +2767,7 @@ function normalizeInstructionTargets(targets) {
   return resolved;
 }
 async function syncInstructions(request) {
+  const templateScriptRuntime = request.templateScriptRuntime ?? createTemplateScriptRuntime({ cwd: request.repoRoot });
   const targets = normalizeInstructionTargets(request.targets);
   const includeLocal = !(request.excludeLocal ?? false);
   const summarySourcePath = request.repoRoot;
@@ -2134,8 +2879,13 @@ async function syncInstructions(request) {
       });
       const outputPath = resolveInstructionOutputPath(resolvedOutputDir, filename);
       const key = buildOutputKey(outputPath, selection.group);
-      const content = applyAgentTemplating({
+      const withScripts = templateScriptRuntime ? await evaluateTemplateScripts({
+        templatePath: template.sourcePath,
         content: template.body,
+        runtime: templateScriptRuntime
+      }) : template.body;
+      const content = applyAgentTemplating({
+        content: withScripts,
         target: targetName,
         validAgents: request.validAgents,
         sourcePath: template.sourcePath
@@ -2391,7 +3141,8 @@ async function syncInstructions(request) {
           homeDir,
           targetId: candidate.targetName,
           outputType: "instructions",
-          validAgents: request.validAgents
+          validAgents: request.validAgents,
+          templateScriptRuntime
         }
       });
       recordCount(groupResult.counts, writeResult.status);
@@ -2433,8 +3184,12 @@ async function syncInstructions(request) {
   };
   for (const [key, entry2] of previousEntries) {
     const group = resolveInstructionTargetGroup(entry2.targetName);
+    if (isWithinDirectory(agentsRoot, entry2.outputPath)) {
+      mergedEntries.set(key, entry2);
+      continue;
+    }
     const groupSelected = activeGroups.has(group);
-    if (!groupSelected) {
+    if (!groupSelected && !removeMissing) {
       mergedEntries.set(key, entry2);
       continue;
     }
@@ -2533,17 +3288,26 @@ async function syncInstructions(request) {
   if (managedManifest.entries.length > 0 || nextManaged.size > 0) {
     const updatedEntries = [];
     for (const entry2 of managedManifest.entries) {
-      if (entry2.sourceType !== "instruction" || !selectedTargetIds.has(entry2.targetId)) {
+      if (entry2.sourceType !== "instruction") {
         updatedEntries.push(entry2);
         continue;
       }
+      if (isWithinDirectory(agentsRoot, entry2.outputPath)) {
+        updatedEntries.push(entry2);
+        continue;
+      }
+      const targetSelected = selectedTargetIds.has(entry2.targetId);
       const key = buildManagedOutputKey(entry2);
       if (nextManaged.has(key)) {
         continue;
       }
+      if (!targetSelected && !removeMissing) {
+        updatedEntries.push(entry2);
+        continue;
+      }
       const activeSources = activeSourcesByTarget.get(entry2.targetId);
       const sourceStillActive = activeSources?.has(entry2.sourceId) ?? false;
-      if (!removeMissing || sourceStillActive) {
+      if (targetSelected && (!removeMissing || sourceStillActive)) {
         updatedEntries.push(entry2);
         continue;
       }
@@ -2623,33 +3387,6 @@ async function syncInstructions(request) {
     sourceCounts
   };
 }
-async function pathExists$1(candidate) {
-  try {
-    await stat(candidate);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findUp(startDir, markerRelativePath) {
-  let current = path.resolve(startDir);
-  let previous = "";
-  while (current !== previous) {
-    if (await pathExists$1(path.join(current, markerRelativePath))) {
-      return current;
-    }
-    previous = current;
-    current = path.dirname(current);
-  }
-  return null;
-}
-async function findRepoRoot(startDir) {
-  const gitRoot = await findUp(startDir, ".git");
-  if (gitRoot) {
-    return gitRoot;
-  }
-  return await findUp(startDir, "package.json");
-}
 async function readDirectoryStats(directory) {
   try {
     return await stat(directory);
@@ -2704,8 +3441,8 @@ function resolveSkillName(frontmatter, fallback) {
   }
   return fallback;
 }
-function normalizeSkillKey$1(name) {
-  return name.trim().toLowerCase();
+function normalizeSkillKey$1(relativePath) {
+  return path.normalize(relativePath).replace(/\\/g, "/").toLowerCase();
 }
 function resolveSkillRelativePath(skillsRoot, directoryPath) {
   const relativePath = path.relative(skillsRoot, directoryPath);
@@ -2868,7 +3605,7 @@ async function loadSkillCatalog(repoRoot, options = {}) {
     shared: sharedSkills,
     localPath: localPathSkills,
     localSuffix: localSuffixSkills,
-    key: (skill) => normalizeSkillKey$1(skill.name)
+    key: (skill) => normalizeSkillKey$1(skill.relativePath)
   });
   const skills = includeLocal ? [...sharedEffectiveSkills, ...localEffectiveSkills] : sharedSkills;
   return {
@@ -2921,6 +3658,7 @@ function buildInvalidTargetWarnings$2(skills) {
   return warnings;
 }
 async function syncSkills(request) {
+  const templateScriptRuntime = request.templateScriptRuntime ?? createTemplateScriptRuntime({ cwd: request.repoRoot });
   const sourcePath = resolveSharedCategoryRoot(request.repoRoot, "skills", request.agentsDir);
   const skillTargets = request.targets.filter(
     (target) => normalizeOutputDefinition(target.outputs.skills) !== null
@@ -3143,7 +3881,9 @@ async function syncSkills(request) {
         directoryPath: selected.skill.directoryPath,
         skillFileName: selected.skill.skillFileName,
         outputFileName: selected.skill.outputFileName,
-        sourcePath: selected.skill.sourcePath
+        sourcePath: selected.skill.sourcePath,
+        sourceType: selected.skill.sourceType,
+        markerType: selected.skill.markerType
       };
       await writer.write({
         outputPath: selected.outputPath,
@@ -3155,7 +3895,8 @@ async function syncSkills(request) {
           homeDir,
           targetId: target.id,
           outputType: "skills",
-          validAgents: request.validAgents
+          validAgents: request.validAgents,
+          templateScriptRuntime
         }
       });
       const checksum = await hashOutputPath(selected.outputPath);
@@ -3787,9 +4528,14 @@ function buildInvalidTargetWarnings$1(commands) {
   }
   return warnings;
 }
-function applyTemplatingToCommand(command, targetName, validAgents) {
-  const templatedContents = applyAgentTemplating({
+async function applyTemplatingToCommand(command, targetName, validAgents, runtime) {
+  const withScripts = runtime ? await evaluateTemplateScripts({
+    templatePath: command.sourcePath,
     content: command.rawContents,
+    runtime
+  }) : command.rawContents;
+  const templatedContents = applyAgentTemplating({
+    content: withScripts,
     target: targetName,
     validAgents,
     sourcePath: command.sourcePath
@@ -3847,6 +4593,7 @@ async function ensureBackupPath(outputPath) {
   }
 }
 async function syncSlashCommands(request) {
+  const templateScriptRuntime = request.templateScriptRuntime ?? createTemplateScriptRuntime({ cwd: request.repoRoot });
   const catalog = await loadCommandCatalog(request.repoRoot, {
     includeLocal: !request.excludeLocal,
     agentsDir: request.agentsDir,
@@ -3989,40 +4736,32 @@ async function syncSlashCommands(request) {
         });
         commandPaths = [{ location: "project", path: path.join(basePath, "SKILL.md") }];
       } else {
-        if (commandDef.projectPath) {
-          const resolved = resolveCommandOutputPath({
-            template: commandDef.projectPath,
-            context: {
-              repoRoot: request.repoRoot,
-              agentsDir: agentsDirPath,
-              homeDir,
-              targetId: target.id,
-              itemName: command.name,
-              commandLocation: "project"
-            },
-            item: command,
-            baseDir: request.repoRoot
-          });
-          commandPaths.push({ location: "project", path: resolved });
-        }
-        if (commandDef.userPath) {
+        const preferredLocation = commandDef.projectPath ? "project" : "user";
+        const preferredTemplate = preferredLocation === "project" ? commandDef.projectPath : commandDef.userPath;
+        const baseDir = preferredLocation === "project" ? request.repoRoot : homeDir;
+        if (preferredTemplate) {
           const resolved = resolveCommandOutputPath({
-            template: commandDef.userPath,
+            template: preferredTemplate,
             context: {
               repoRoot: request.repoRoot,
               agentsDir: agentsDirPath,
               homeDir,
               targetId: target.id,
               itemName: command.name,
-              commandLocation: "user"
+              commandLocation: preferredLocation
             },
             item: command,
-            baseDir: homeDir
+            baseDir
           });
-          commandPaths.push({ location: "user", path: resolved });
+          commandPaths.push({ location: preferredLocation, path: resolved });
         }
       }
-      const templated = applyTemplatingToCommand(command, target.id, validAgents);
+      const templated = await applyTemplatingToCommand(
+        command,
+        target.id,
+        validAgents,
+        templateScriptRuntime
+      );
       const writer = resolveWriter(commandDef.writer, writerRegistry);
       const converter = resolveConverter(commandDef.converter, converterRegistry);
       for (const entry2 of commandPaths) {
@@ -4159,7 +4898,8 @@ async function syncSlashCommands(request) {
             targetId: target.id,
             outputType: "commands",
             commandLocation: selected.location,
-            validAgents
+            validAgents,
+            templateScriptRuntime
           }
         });
         const checksum = writeResult.contentHash ?? await hashOutputPath(selected.outputPath);
@@ -4764,6 +5504,7 @@ function formatSubagentSummary(summary, jsonOutput) {
   return lines.join("\n");
 }
 async function syncSubagents(request) {
+  const templateScriptRuntime = request.templateScriptRuntime ?? createTemplateScriptRuntime({ cwd: request.repoRoot });
   const catalog = await loadSubagentCatalog(request.repoRoot, {
     includeLocal: !request.excludeLocal,
     agentsDir: request.agentsDir,
@@ -5044,7 +5785,8 @@ async function syncSubagents(request) {
           homeDir,
           targetId: target.id,
           outputType: "subagents",
-          validAgents
+          validAgents,
+          templateScriptRuntime
         }
       });
       const checksum = selected.outputKind === "skill" ? await hashOutputPath(selected.outputPath) : writeResult.contentHash ?? await hashOutputPath(selected.outputPath);
@@ -6007,6 +6749,147 @@ function formatLocalItemsOutput(items, repoRoot, jsonOutput) {
   }
   return lines.join("\n");
 }
+function hasTemplateScripts(content) {
+  return hasTemplateScriptMarkup(content);
+}
+function addTemplateScriptSource(sources, templatePath, content) {
+  if (!hasTemplateScripts(content)) {
+    return;
+  }
+  if (sources.has(templatePath)) {
+    return;
+  }
+  sources.set(templatePath, content);
+}
+function intersectsTargets(targets, selectedTargetIds) {
+  return targets.some((target) => selectedTargetIds.has(target));
+}
+async function listAllFiles(root) {
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry2 of entries) {
+    const entryPath = path.join(root, entry2.name);
+    if (entry2.isDirectory()) {
+      files.push(...await listAllFiles(entryPath));
+      continue;
+    }
+    if (entry2.isFile()) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+async function gatherTemplateScriptSources(options) {
+  const selectedSkillTargetIds = new Set(options.selectedSkillTargets.map((target) => target.id));
+  const selectedCommandTargetIds = new Set(
+    options.selectedCommandTargets.map((target) => target.id)
+  );
+  const selectedSubagentTargetIds = new Set(
+    options.selectedSubagentTargets.map((target) => target.id)
+  );
+  const selectedInstructionTargetIds = new Set(
+    options.selectedInstructionTargets.map((target) => target.id)
+  );
+  const sources = /* @__PURE__ */ new Map();
+  if (options.commandsAvailable && options.selectedCommandTargets.length > 0) {
+    const commandCatalog = await loadCommandCatalog(options.repoRoot, {
+      includeLocal: !options.excludeLocalCommands,
+      agentsDir: options.agentsDir,
+      resolveTargetName: options.resolveTargetName
+    });
+    for (const command of commandCatalog.commands) {
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: command.targetAgents,
+        overrideOnly: options.overrideOnly,
+        overrideSkip: options.overrideSkip,
+        allTargets: options.allTargetIds
+      });
+      if (!intersectsTargets(effectiveTargets, selectedCommandTargetIds)) {
+        continue;
+      }
+      addTemplateScriptSource(sources, command.sourcePath, command.rawContents);
+    }
+  }
+  if (options.selectedSubagentTargets.length > 0) {
+    const subagentCatalog = await loadSubagentCatalog(options.repoRoot, {
+      includeLocal: !options.excludeLocalAgents,
+      agentsDir: options.agentsDir,
+      resolveTargetName: options.resolveTargetName
+    });
+    for (const subagent of subagentCatalog.subagents) {
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: subagent.targetAgents,
+        overrideOnly: options.overrideOnly,
+        overrideSkip: options.overrideSkip,
+        allTargets: options.allTargetIds
+      });
+      if (!intersectsTargets(effectiveTargets, selectedSubagentTargetIds)) {
+        continue;
+      }
+      addTemplateScriptSource(sources, subagent.sourcePath, subagent.rawContents);
+    }
+  }
+  if (options.selectedInstructionTargets.length > 0) {
+    const templateCatalog = await loadInstructionTemplateCatalog({
+      repoRoot: options.repoRoot,
+      includeLocal: !options.excludeLocalInstructions,
+      agentsDir: options.agentsDir,
+      resolveTargetName: options.resolveTargetName
+    });
+    for (const template of templateCatalog.templates) {
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: template.targets,
+        overrideOnly: options.overrideOnly,
+        overrideSkip: options.overrideSkip,
+        allTargets: options.allTargetIds
+      });
+      if (!intersectsTargets(effectiveTargets, selectedInstructionTargetIds)) {
+        continue;
+      }
+      addTemplateScriptSource(sources, template.sourcePath, template.body);
+    }
+  }
+  if (options.skillsAvailable && options.selectedSkillTargets.length > 0) {
+    const skillCatalog = await loadSkillCatalog(options.repoRoot, {
+      includeLocal: !options.excludeLocalSkills,
+      agentsDir: options.agentsDir,
+      resolveTargetName: options.resolveTargetName
+    });
+    for (const skill of skillCatalog.skills) {
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: skill.targetAgents,
+        overrideOnly: options.overrideOnly,
+        overrideSkip: options.overrideSkip,
+        allTargets: options.allTargetIds
+      });
+      if (!intersectsTargets(effectiveTargets, selectedSkillTargetIds)) {
+        continue;
+      }
+      const files = await listAllFiles(skill.directoryPath);
+      for (const filePath of files) {
+        const buffer = await readFile(filePath);
+        const decoded = decodeUtf8(buffer);
+        if (decoded === null) {
+          continue;
+        }
+        addTemplateScriptSource(sources, filePath, decoded);
+      }
+    }
+  }
+  return [...sources.entries()].map(([templatePath, content]) => ({ templatePath, content })).sort((left, right) => left.templatePath.localeCompare(right.templatePath));
+}
+function buildSyncRunMetadata(options) {
+  const warnings = [...options.runtime.warnings];
+  return {
+    runId: options.runtime.runId,
+    status: options.status,
+    failedTemplatePath: options.runtime.failedTemplatePath,
+    failedBlockId: options.runtime.failedBlockId,
+    partialOutputsWritten: options.partialOutputsWritten,
+    scriptExecutions: listTemplateScriptExecutions(options.runtime),
+    warnings
+  };
+}
 async function assertSourceDirectory(sourcePath) {
   try {
     const stats = await stat(sourcePath);
@@ -6284,7 +7167,7 @@ function logNonInteractiveNotices(options) {
       logWithChannel(`${target.displayName} commands are user-only.`, options.jsonOutput);
     } else if (hasUser && hasProject) {
       logWithChannel(
-        `${target.displayName} commands will be written to project and user locations.`,
+        `${target.displayName} commands prefer the project location (user path is fallback-only).`,
         options.jsonOutput
       );
     }
@@ -6344,7 +7227,7 @@ function buildCommandSummary(sourcePath, targets, status, message, excludedLocal
   return {
     sourcePath,
     results: normalizedTargets.map((target) => {
-      const verb = "Skipped";
+      const verb = status === "failed" ? "Failed" : "Skipped";
       return {
         targetName: target.id,
         status,
@@ -6367,7 +7250,7 @@ function buildSkillsSummary(repoRoot, sourcePath, targets, status, reason, exclu
   const results = normalizeTargets(targets).map((target) => ({
     targetName: target.id,
     status,
-    message: `${"Skipped"} ${sourceDisplay} for ${target.displayName}: ${reason}`,
+    message: `${status === "failed" ? "Failed" : "Skipped"} ${sourceDisplay} for ${target.displayName}: ${reason}`,
     error: reason
   }));
   return buildSummary(sourcePath, results, [], {
@@ -6405,6 +7288,27 @@ function buildInstructionsSummary(repoRoot, targets, status, message, excludedLo
     }
   };
 }
+function buildSubagentSummary(targets, status, message, excludedLocal, sourcePath) {
+  const results = normalizeTargets(targets).map((target) => ({
+    targetName: target.id,
+    status,
+    message: `${"Failed"} ${target.displayName}: ${message}`,
+    error: message,
+    counts: { created: 0, updated: 0, removed: 0, converted: 0, skipped: 0 },
+    warnings: []
+  }));
+  return {
+    sourcePath,
+    results,
+    warnings: [],
+    hadFailures: status === "failed",
+    sourceCounts: {
+      shared: 0,
+      local: 0,
+      excludedLocal
+    }
+  };
+}
 function mergeWarnings(existing, additions) {
   if (additions.length === 0) {
     return existing;
@@ -6473,9 +7377,29 @@ function buildAvailabilitySubagentWarnings(skips) {
 function emitSyncSummary(options) {
   const { combined, jsonOutput, repoRoot, agentsDir, ignoreRules } = options;
   if (jsonOutput) {
-    console.log(JSON.stringify(combined, null, 2));
+    console.log(
+      JSON.stringify(
+        {
+          ...combined,
+          runId: combined.syncRun.runId,
+          status: combined.syncRun.status,
+          failedTemplatePath: combined.syncRun.failedTemplatePath,
+          failedBlockId: combined.syncRun.failedBlockId,
+          partialOutputsWritten: combined.syncRun.partialOutputsWritten,
+          scriptExecutions: combined.syncRun.scriptExecutions,
+          warnings: combined.syncRun.warnings
+        },
+        null,
+        2
+      )
+    );
   } else {
     const outputs = [];
+    if (combined.syncRun.status === "failed" && combined.syncRun.failedTemplatePath && combined.syncRun.failedBlockId) {
+      outputs.push(
+        `Failed template script: ${combined.syncRun.failedTemplatePath} (${combined.syncRun.failedBlockId})`
+      );
+    }
     const instructionOutput = formatInstructionSummary(combined.instructions);
     if (instructionOutput.length > 0) {
       outputs.push(instructionOutput);
@@ -6496,6 +7420,9 @@ function emitSyncSummary(options) {
       const warningRules = ignoreRules ?? buildAgentsIgnoreRules(repoRoot, agentsDir);
       outputs.push(`Warning: Missing ignore rules for local sources (${warningRules.join(", ")}).`);
     }
+    for (const warning of combined.syncRun.warnings) {
+      outputs.push(`Warning: ${warning.message}`);
+    }
     if (outputs.length > 0) {
       console.log(outputs.join("\n"));
     }
@@ -6543,6 +7470,10 @@ const syncCommand = {
     type: "string",
     choices: ["overwrite", "rename", "skip"],
     describe: "Conflict resolution strategy for slash commands"
+  }).option("verbose", {
+    type: "boolean",
+    default: false,
+    describe: "Show per-script execution telemetry during sync"
   }).option("json", {
     type: "boolean",
     default: false,
@@ -6553,7 +7484,7 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
   ).example("omniagent sync", "Sync available targets (auto-detects agent CLIs on PATH)").example("omniagent sync --skip <target>", "Skip a target").example("omniagent sync --only <target>", "Sync only one target").example("omniagent sync --agentsDir ./my-custom-agents", "Use a custom agents directory").example("omniagent sync --exclude-local", "Sync shared sources only").example(
     "omniagent sync --exclude-local=skills,commands",
     "Exclude local skills and commands"
-  ).example("omniagent sync --list-local", "List detected local items").example("omniagent sync --yes", "Accept defaults and apply changes").example("omniagent sync --json", "Output a JSON summary"),
+  ).example("omniagent sync --list-local", "List detected local items").example("omniagent sync --yes", "Accept defaults and apply changes").example("omniagent sync --verbose", "Show per-script execution telemetry").example("omniagent sync --json", "Output a JSON summary"),
   handler: async (argv) => {
     try {
       const skipList = parseList(argv.skip);
@@ -6573,9 +7504,21 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
       const excludeLocalAgents = excludeLocalCategories.has("agents");
       const excludeLocalInstructions = excludeLocalCategories.has("instructions");
       const jsonOutput = argv.json ?? false;
+      const verboseOutput = argv.verbose ?? false;
       const yes = argv.yes ?? false;
       const removeMissing = argv.removeMissing ?? true;
       const listLocal = argv.listLocal ?? false;
+      let partialOutputsWritten = false;
+      const scriptRuntime = createTemplateScriptRuntime({
+        verbose: verboseOutput,
+        cwd: process.cwd(),
+        onWarning: (warning) => {
+          logWithChannel(`Warning: ${warning.message}`, jsonOutput);
+        },
+        onVerbose: (message) => {
+          logWithChannel(message, jsonOutput);
+        }
+      });
       const startDir = process.cwd();
       const repoRoot = await findRepoRoot(startDir);
       if (!repoRoot) {
@@ -6585,6 +7528,7 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
         process.exit(1);
         return;
       }
+      scriptRuntime.cwd = repoRoot;
       const agentsDirResolution = resolveAgentsDir(repoRoot, argv.agentsDir);
       if (agentsDirResolution.source === "override") {
         const validation2 = await validateAgentsDir(repoRoot, argv.agentsDir);
@@ -6802,7 +7746,12 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
           subagents: subagentSummary2,
           commands: commandsSummary2,
           hadFailures: false,
-          missingIgnoreRules: false
+          missingIgnoreRules: false,
+          syncRun: buildSyncRunMetadata({
+            runtime: scriptRuntime,
+            status: "completed",
+            partialOutputsWritten
+          })
         };
         emitSyncSummary({
           combined: combined2,
@@ -6860,6 +7809,90 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
         process.exit(1);
         return;
       }
+      try {
+        const scriptSources = await gatherTemplateScriptSources({
+          repoRoot,
+          agentsDir,
+          allTargetIds: resolved.targets.map((target) => target.id),
+          resolveTargetName,
+          overrideOnly,
+          overrideSkip,
+          excludeLocalSkills,
+          excludeLocalCommands,
+          excludeLocalAgents,
+          excludeLocalInstructions,
+          selectedSkillTargets,
+          selectedCommandTargets,
+          selectedSubagentTargets,
+          selectedInstructionTargets,
+          skillsAvailable: hasSkillsToSync,
+          commandsAvailable: hasCommandsToSync
+        });
+        for (const source of scriptSources) {
+          await evaluateTemplateScripts({
+            templatePath: source.templatePath,
+            content: source.content,
+            runtime: scriptRuntime
+          });
+        }
+      } catch (error) {
+        if (error instanceof TemplateScriptExecutionError) {
+          const warning = {
+            code: "sync_warning",
+            message: error.message,
+            templatePath: error.templatePath,
+            blockId: error.blockId
+          };
+          scriptRuntime.warnings.push(warning);
+          const combined2 = {
+            instructions: buildInstructionsSummary(
+              repoRoot,
+              selectedInstructionTargets,
+              "failed",
+              error.message,
+              excludeLocalInstructions
+            ),
+            skills: buildSkillsSummary(
+              repoRoot,
+              skillsSourcePath,
+              selectedSkillTargets,
+              "failed",
+              error.message,
+              excludeLocalSkills
+            ),
+            subagents: buildSubagentSummary(
+              selectedSubagentTargets,
+              "failed",
+              error.message,
+              excludeLocalAgents,
+              subagentsSourcePath
+            ),
+            commands: buildCommandSummary(
+              commandsSourcePath,
+              selectedCommandTargets,
+              "failed",
+              error.message,
+              excludeLocalCommands
+            ),
+            hadFailures: true,
+            missingIgnoreRules: false,
+            syncRun: buildSyncRunMetadata({
+              runtime: scriptRuntime,
+              status: "failed",
+              partialOutputsWritten
+            })
+          };
+          emitSyncSummary({
+            combined: combined2,
+            jsonOutput,
+            repoRoot,
+            agentsDir,
+            ignoreRules: null
+          });
+          return;
+        }
+        throw error;
+      }
       let missingIgnoreRules = false;
       let ignoreRules = null;
       if (hasLocalItems) {
@@ -6892,6 +7925,7 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
           }
         }
       }
+      partialOutputsWritten = true;
       let commandsSummary;
       if (selectedCommandTargets.length === 0) {
         commandsSummary = {
@@ -6930,7 +7964,8 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
           validAgents,
           excludeLocal: excludeLocalCommands,
           resolveTargetName,
-          hooks: globalHooks
+          hooks: globalHooks,
+          templateScriptRuntime: scriptRuntime
         });
       }
       if (availabilityCommandSkips.length > 0) {
@@ -6951,7 +7986,8 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
         excludeLocal: excludeLocalAgents,
         includeLocalSkills,
         resolveTargetName,
-        hooks: globalHooks
+        hooks: globalHooks,
+        templateScriptRuntime: scriptRuntime
       });
       if (availabilitySubagentSkips.length > 0) {
         const subagentWarnings = mergeWarnings(
@@ -7000,6 +8036,7 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
             validAgents,
             resolveTargetName,
             hooks: globalHooks,
+            templateScriptRuntime: scriptRuntime,
             confirmRemoval
           });
         } catch (error) {
@@ -7057,7 +8094,8 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
           excludeLocal: excludeLocalSkills,
           removeMissing,
           resolveTargetName,
-          hooks: globalHooks
+          hooks: globalHooks,
+          templateScriptRuntime: scriptRuntime
         });
       }
       if (availabilitySkillSkips.length > 0) {
@@ -7071,13 +8109,19 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
           results: [...skillsSummary.results, ...availabilitySkillResults]
         };
       }
+      const hadFailures = instructionsSummary.hadFailures || skillsSummary.hadFailures || subagentSummary.hadFailures || commandsSummary.hadFailures;
       const combined = {
         instructions: instructionsSummary,
         skills: skillsSummary,
         subagents: subagentSummary,
         commands: commandsSummary,
-        hadFailures: instructionsSummary.hadFailures || skillsSummary.hadFailures || subagentSummary.hadFailures || commandsSummary.hadFailures,
-        missingIgnoreRules
+        hadFailures,
+        missingIgnoreRules,
+        syncRun: buildSyncRunMetadata({
+          runtime: scriptRuntime,
+          status: hadFailures ? "failed" : "completed",
+          partialOutputsWritten
+        })
       };
       emitSyncSummary({
         combined,
@@ -7092,6 +8136,11 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
         process.exit(1);
         return;
       }
+      if (error instanceof TemplateScriptExecutionError) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+        return;
+      }
       throw error;
     }
   }
@@ -7745,8 +8794,28 @@ async function runShim(argv, runtime = {}) {
     return exitCodeFor("execution-error");
   }
 }
-const VERSION = "0.1.0";
-const KNOWN_COMMANDS = /* @__PURE__ */ new Set(["hello", "greet", "echo", "sync"]);
+function resolveVersion() {
+  const packageJsonPaths = [
+    fileURLToPath(new URL("../package.json", import.meta.url)),
+    fileURLToPath(new URL("../../package.json", import.meta.url))
+  ];
+  for (const packageJsonPath of packageJsonPaths) {
+    if (!existsSync(packageJsonPath)) {
+      continue;
+    }
+    try {
+      const contents = readFileSync(packageJsonPath, "utf8");
+      const parsed = JSON.parse(contents);
+      if (typeof parsed.version === "string" && parsed.version.trim().length > 0) {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+const VERSION = resolveVersion();
+const KNOWN_COMMANDS = /* @__PURE__ */ new Set(["hello", "greet", "echo", "sync", "dev"]);
 const SHIM_CAPABILITIES = [
   "Capabilities by agent:",
   "  codex: approval, sandbox, output, model, web",
@@ -7796,7 +8865,7 @@ function runCli(argv = process.argv, options = {}) {
     console.error(formatError(message, args));
     const exitCode = isCommandInvocation(args) ? 1 : 2;
     process.exit(exitCode);
-  }).command(helloCommand).command(greetCommand).command(echoCommand).command(syncCommand).command(
+  }).command(helloCommand).command(greetCommand).command(echoCommand).command(syncCommand).command(devCommand).command(
     "$0",
     "omniagent CLI",
     (yargsInstance) => yargsInstance.usage("omniagent [flags] --agent <target-id> [-- <agent flags>]").example("omniagent --agent codex", "Start an interactive session (default mode).").example('omniagent -p "Summarize the repo" --agent codex', "Run a one-shot prompt.").example("omniagent --agent codex -- --some-flag", "Pass through agent-specific flags.").option("prompt", {