relay-kit 0.2.0

package/dist/cli.js

@@ -0,0 +1,1343 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/ask.ts
+import path9 from "path";
+
+// src/core/clipboard.ts
+import { spawn } from "child_process";
+async function copyToClipboard(content) {
+  const command = process.platform === "win32" ? "clip" : process.platform === "darwin" ? "pbcopy" : "xclip";
+  const args = process.platform === "linux" ? ["-selection", "clipboard"] : [];
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: ["pipe", "ignore", "ignore"], windowsHide: true });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+    child.stdin.end(content);
+  });
+}
+
+// src/core/command-runner.ts
+import { exec } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/core/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/core/excludes.ts
+import path from "path";
+
+// src/core/constants.ts
+var RELAY_DIR = ".relay";
+var RELAYIGNORE_FILE = ".relayignore";
+var CONFIG_FILE = `${RELAY_DIR}/config.json`;
+var STATE_FILE = `${RELAY_DIR}/state.json`;
+var DEFAULT_HANDOFF_DIR = "docs/agent-handoffs";
+var DEFAULT_LANE = "main";
+var DEFAULT_MAX_DIFF_LINES = 500;
+var DEFAULT_MAX_LOG_LINES = 160;
+var AGENTS_START_MARKER = "<!-- relay-kit:start -->";
+var AGENTS_END_MARKER = "<!-- relay-kit:end -->";
+var DEFAULT_SKILLS = [
+  "relay-planner",
+  "relay-delegator",
+  "relay-escalation",
+  "relay-reviewer"
+];
+var EXCLUDED_NAMES = /* @__PURE__ */ new Set([
+  ".env",
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage"
+]);
+var EXCLUDED_GLOBS = [
+  ".env",
+  ".env.*",
+  "node_modules/",
+  "dist/",
+  "build/",
+  "coverage/",
+  ".git/",
+  "*.pem",
+  "*.key",
+  "*.crt",
+  "*.p12",
+  "*.log"
+];
+var DEFAULT_RELAYIGNORE_CONTENT = `# relay-kit context ignore rules
+.env
+.env.*
+node_modules/
+dist/
+build/
+coverage/
+.git/
+*.pem
+*.key
+*.crt
+*.p12
+*.log
+`;
+
+// src/core/excludes.ts
+function normalizePath(value) {
+  return value.replace(/\\/g, "/");
+}
+function isExcludedPath(candidate) {
+  const normalized = normalizePath(candidate);
+  const parts = normalized.split("/").filter(Boolean);
+  const basename = parts.at(-1) ?? normalized;
+  if (basename === ".env" || basename.startsWith(".env.")) {
+    return true;
+  }
+  if (/\.(pem|key|crt|p12|log)$/i.test(basename)) {
+    return true;
+  }
+  return parts.some((part) => EXCLUDED_NAMES.has(part));
+}
+function filterExcludedLines(text) {
+  return text.split(/\r?\n/).filter((line) => {
+    return !isExcludedPath(line);
+  }).join("\n").trim();
+}
+function assertInsideRoot(root, target) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedTarget = path.resolve(root, target);
+  const relative = path.relative(resolvedRoot, resolvedTarget);
+  if (relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative)) {
+    return resolvedTarget;
+  }
+  throw new Error(`Refusing to write outside project root: ${target}`);
+}
+
+// src/core/git.ts
+var execFileAsync = promisify(execFile);
+async function git(root, args) {
+  try {
+    const { stdout, stderr } = await execFileAsync("git", args, {
+      cwd: root,
+      maxBuffer: 1024 * 1024 * 5,
+      windowsHide: true
+    });
+    return `${stdout}${stderr}`.trim();
+  } catch (error) {
+    if (error && typeof error === "object" && "stdout" in error) {
+      const failed = error;
+      return `${failed.stdout ?? ""}${failed.stderr ?? ""}`.trim();
+    }
+    return "";
+  }
+}
+async function collectGitContext(root, options) {
+  const contextOptions = typeof options === "number" ? { maxDiffLines: options } : options;
+  const insideWorkTree = await git(root, ["rev-parse", "--is-inside-work-tree"]);
+  if (insideWorkTree.trim() !== "true") {
+    return {
+      branch: "(not a git repository)",
+      status: "",
+      diffStat: "",
+      diff: ""
+    };
+  }
+  const pathspecs = contextOptions.gitExcludePathspecs ?? [];
+  const branch = sanitizeGitText(await git(root, ["branch", "--show-current"]), contextOptions) || "(unknown)";
+  const status = sanitizeGitText(await git(root, ["status", "--short", "--", ".", ...pathspecs]), contextOptions);
+  const diffStat = sanitizeGitText(await git(root, ["diff", "--stat", "--", ".", ...pathspecs]), contextOptions);
+  const diff = sanitizeGitDiff(await git(root, ["diff", "--", ".", ...pathspecs]), contextOptions);
+  const truncatedDiff = truncateLines(diff, contextOptions.maxDiffLines);
+  return {
+    branch,
+    status,
+    diffStat,
+    diff: truncatedDiff
+  };
+}
+function truncateLines(text, maxLines) {
+  const lines = text.split(/\r?\n/);
+  if (lines.length <= maxLines) {
+    return text;
+  }
+  return `${lines.slice(0, maxLines).join("\n")}
+... truncated ${lines.length - maxLines} lines ...`;
+}
+function sanitizeGitText(text, options) {
+  const filtered = filterIgnoredLines(filterExcludedLines(text), options.shouldIgnorePath);
+  return applyRedaction(filtered, options).trim();
+}
+function sanitizeGitDiff(text, options) {
+  const filtered = filterIgnoredLines(filterIgnoredDiffBlocks(text, options.shouldIgnorePath), options.shouldIgnorePath);
+  return applyRedaction(filtered, options).trim();
+}
+function applyRedaction(text, options) {
+  return options.redactText ? options.redactText(text) : text;
+}
+function filterIgnoredLines(text, shouldIgnorePath) {
+  return text.split(/\r?\n/).filter((line) => !lineReferencesIgnoredPath(line, shouldIgnorePath ?? (() => false))).join("\n").trim();
+}
+function filterIgnoredDiffBlocks(text, shouldIgnorePath) {
+  const lines = text.split(/\r?\n/);
+  const kept = [];
+  let skipping = false;
+  const ignore = shouldIgnorePath ?? (() => false);
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      skipping = lineReferencesIgnoredPath(line, ignore);
+    }
+    if (!skipping) {
+      kept.push(line);
+    }
+  }
+  return kept.join("\n").trim();
+}
+function lineReferencesIgnoredPath(line, shouldIgnorePath) {
+  return extractCandidatePaths(line).some((candidate) => shouldIgnorePath(candidate) || isExcludedPath(candidate));
+}
+function extractCandidatePaths(line) {
+  const candidates = /* @__PURE__ */ new Set();
+  const statusPath = line.match(/^[ MADRCU?!]{1,2}\s+(.+)$/)?.[1];
+  if (statusPath) {
+    for (const part of statusPath.split(/\s+->\s+/)) {
+      candidates.add(stripGitPathDecorations(part));
+    }
+  }
+  const diffPaths = line.matchAll(/\b[ab]\/([^\s]+)/g);
+  for (const match of diffPaths) {
+    candidates.add(stripGitPathDecorations(match[1]));
+  }
+  const statPath = line.includes("|") ? line.split("|")[0]?.trim() : "";
+  if (statPath) {
+    candidates.add(stripGitPathDecorations(statPath));
+  }
+  return [...candidates].filter(Boolean);
+}
+function stripGitPathDecorations(value) {
+  return value.replace(/^"|"$/g, "").replace(/\\/g, "/").trim();
+}
+
+// src/core/command-runner.ts
+var execAsync = promisify2(exec);
+async function runShellCommand(root, command, options = { maxLogLines: 160 }) {
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: root,
+      maxBuffer: 1024 * 1024 * 2,
+      windowsHide: true
+    });
+    return { command, exitCode: 0, output: sanitizeCommandOutput(`${stdout}${stderr}`.trim(), options) };
+  } catch (error) {
+    const failed = error;
+    return {
+      command,
+      exitCode: typeof failed.code === "number" ? failed.code : 1,
+      output: sanitizeCommandOutput(`${failed.stdout ?? ""}${failed.stderr ?? ""}`.trim(), options)
+    };
+  }
+}
+function sanitizeCommandOutput(output2, options) {
+  const redacted = options.redactText ? options.redactText(output2) : output2;
+  return truncateLines(redacted, options.maxLogLines);
+}
+
+// src/core/config.ts
+import path3 from "path";
+
+// src/core/fs.ts
+import { constants as fsConstants } from "fs";
+import fs from "fs/promises";
+import path2 from "path";
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function readTextIfExists(filePath) {
+  if (!await pathExists(filePath)) {
+    return "";
+  }
+  return fs.readFile(filePath, "utf8");
+}
+async function readJsonIfExists(filePath) {
+  if (!await pathExists(filePath)) {
+    return void 0;
+  }
+  return JSON.parse(stripBom(await fs.readFile(filePath, "utf8")));
+}
+async function writeJsonFile(filePath, value) {
+  await ensureDir(path2.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function safeWriteFile(root, relativePath, content, options = {}) {
+  const target = assertInsideRoot(root, relativePath);
+  await ensureDir(path2.dirname(target));
+  if (!options.force && await pathExists(target)) {
+    throw new Error(`Refusing to overwrite existing file without --force: ${relativePath}`);
+  }
+  await fs.writeFile(target, content, "utf8");
+  return target;
+}
+async function copyDirectory(source, target, options = {}) {
+  if (!await pathExists(source)) {
+    throw new Error(`Missing source directory: ${source}`);
+  }
+  await ensureDir(target);
+  const entries = await fs.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path2.join(source, entry.name);
+    const targetPath = path2.join(target, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, targetPath, options);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!options.force && await pathExists(targetPath)) {
+      continue;
+    }
+    await fs.copyFile(sourcePath, targetPath);
+  }
+}
+function stripBom(value) {
+  return value.charCodeAt(0) === 65279 ? value.slice(1) : value;
+}
+
+// src/core/config.ts
+function createDefaultConfig(project, mode) {
+  return {
+    projectName: project.name,
+    language: "zh",
+    mode,
+    handoffDir: DEFAULT_HANDOFF_DIR,
+    openSpecDir: "openspec",
+    sourceDirs: ["src", "apps", "packages"],
+    packageManager: project.packageManager === "unknown" ? "auto" : project.packageManager,
+    devCommand: project.packageScripts.dev ? packageScript(project.packageManager, "dev") : "",
+    buildCommand: project.packageScripts.build ? packageScript(project.packageManager, "build") : "",
+    testCommand: project.packageScripts.test ? packageScript(project.packageManager, "test") : "",
+    defaultExecutor: "opencode",
+    defaultAdvisor: "",
+    maxDiffLines: DEFAULT_MAX_DIFF_LINES,
+    maxLogLines: DEFAULT_MAX_LOG_LINES,
+    includeGitDiff: true,
+    includeOpenSpec: mode === "openspec",
+    includePackageScripts: true,
+    runLayout: "runs-lanes",
+    defaultLane: DEFAULT_LANE,
+    excludePatterns: EXCLUDED_GLOBS,
+    skills: {
+      install: {
+        manager: true,
+        claudeProject: true,
+        codexProject: true,
+        claudeUser: false,
+        codexUser: false
+      },
+      enabled: ["relay-planner", "relay-delegator", "relay-escalation", "relay-reviewer"],
+      optional: ["relay-lane-planner", "relay-docs"]
+    }
+  };
+}
+async function loadConfig(root) {
+  const config = await readJsonIfExists(path3.join(root, CONFIG_FILE));
+  if (!config) {
+    throw new Error("Missing .relay/config.json. Run relay init first.");
+  }
+  return normalizeConfig(config);
+}
+async function writeConfig(root, config) {
+  await writeJsonFile(path3.join(root, CONFIG_FILE), config);
+}
+function packageScript(packageManager, script) {
+  const runner = packageManager === "unknown" ? "npm" : packageManager;
+  return `${runner} run ${script}`;
+}
+function normalizeConfig(config) {
+  return {
+    ...config,
+    maxDiffLines: config.maxDiffLines ?? DEFAULT_MAX_DIFF_LINES,
+    maxLogLines: config.maxLogLines ?? DEFAULT_MAX_LOG_LINES,
+    excludePatterns: config.excludePatterns ?? EXCLUDED_GLOBS
+  };
+}
+
+// src/core/relayignore.ts
+import path4 from "path";
+async function loadRelayIgnoreMatcher(root, extraPatterns = []) {
+  const relayIgnorePath = path4.join(root, RELAYIGNORE_FILE);
+  const hasRelayIgnore = await pathExists(relayIgnorePath);
+  const relayIgnorePatterns = hasRelayIgnore ? parseRelayIgnore(await readTextIfExists(relayIgnorePath)) : [];
+  const patterns = uniquePatterns([...EXCLUDED_GLOBS, ...extraPatterns, ...relayIgnorePatterns]);
+  const rules = patterns.map(parseRule).filter((rule) => Boolean(rule));
+  return {
+    hasRelayIgnore,
+    patterns,
+    gitExcludePathspecs: buildGitExcludePathspecs(rules),
+    shouldIgnorePath(candidate) {
+      const normalized = normalizePath2(candidate);
+      return rules.some((rule) => matchesRule(rule, normalized));
+    }
+  };
+}
+function parseRelayIgnore(content) {
+  return stripBom(content).split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).filter((line) => !line.startsWith("!"));
+}
+function normalizePath2(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+}
+function parseRule(rawPattern) {
+  const raw = rawPattern.trim();
+  if (!raw || raw.startsWith("#") || raw.startsWith("!")) {
+    return void 0;
+  }
+  const rootOnly = raw.startsWith("/");
+  const directory = raw.endsWith("/");
+  const pattern = normalizePath2(raw).replace(/\/$/, "");
+  if (!pattern) {
+    return void 0;
+  }
+  return {
+    pattern,
+    raw,
+    directory,
+    rootOnly,
+    hasGlob: pattern.includes("*")
+  };
+}
+function matchesRule(rule, candidate) {
+  const normalized = normalizePath2(candidate);
+  const parts = normalized.split("/").filter(Boolean);
+  if (rule.directory) {
+    if (rule.hasGlob || rule.pattern.includes("/")) {
+      return pathMatchesPattern(normalized, rule.pattern) || normalized.startsWith(`${rule.pattern}/`);
+    }
+    return parts.includes(rule.pattern);
+  }
+  if (rule.hasGlob) {
+    const target = rule.pattern.includes("/") || rule.rootOnly ? normalized : parts.at(-1) ?? normalized;
+    return pathMatchesPattern(target, rule.pattern);
+  }
+  if (rule.pattern.includes("/") || rule.rootOnly) {
+    return normalized === rule.pattern;
+  }
+  return parts.includes(rule.pattern);
+}
+function pathMatchesPattern(candidate, pattern) {
+  return globToRegExp(pattern).test(candidate);
+}
+function globToRegExp(pattern) {
+  const source = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`);
+}
+function buildGitExcludePathspecs(rules) {
+  const pathspecs = [];
+  for (const rule of rules) {
+    const pattern = gitGlobForRule(rule);
+    pathspecs.push(`:(exclude,glob)${pattern}`);
+    if (!rule.rootOnly && !pattern.startsWith("**/")) {
+      pathspecs.push(`:(exclude,glob)**/${pattern}`);
+    }
+  }
+  return [...new Set(pathspecs)];
+}
+function gitGlobForRule(rule) {
+  if (rule.directory) {
+    return `${rule.pattern}/**`;
+  }
+  return rule.pattern;
+}
+function uniquePatterns(patterns) {
+  return [...new Set(patterns.map((pattern) => pattern.trim()).filter(Boolean))];
+}
+
+// src/core/redaction.ts
+var PRIVATE_KEY_BLOCK = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
+var BEARER_TOKEN = /\b(Bearer\s+)([A-Za-z0-9._~+/=-]{6,})/gi;
+var SENSITIVE_KEY_VALUE = /(["']?[\w.-]*(?:api[_-]?key|token|secret|password)[\w.-]*["']?\s*[:=]\s*)(["']?)([^\s"',;]+)/gi;
+function redactSensitiveText(value) {
+  if (!value) {
+    return value;
+  }
+  return value.replace(PRIVATE_KEY_BLOCK, "[REDACTED_PRIVATE_KEY]").replace(BEARER_TOKEN, "$1[REDACTED]").replace(SENSITIVE_KEY_VALUE, (_match, prefix, quote) => `${prefix}${quote}[REDACTED]`);
+}
+
+// src/core/context-safety.ts
+async function createContextSafety(root, config) {
+  const ignore = await loadRelayIgnoreMatcher(root, config.excludePatterns);
+  return {
+    ignore,
+    ignoreRulesStatus: ignore.hasRelayIgnore ? "applied: default rules + .relayignore" : "applied: default rules only",
+    redactionRulesStatus: "applied: basic sensitive value redaction",
+    shouldIgnorePath(candidate) {
+      return ignore.shouldIgnorePath(candidate);
+    },
+    redactText(value) {
+      return redactSensitiveText(value);
+    }
+  };
+}
+
+// src/core/openspec.ts
+import fs2 from "fs/promises";
+import path5 from "path";
+async function listOpenSpecChanges(root) {
+  const changesDir = path5.join(root, "openspec", "changes");
+  if (!await pathExists(changesDir)) {
+    return [];
+  }
+  const entries = await fs2.readdir(changesDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+async function resolveOpenSpecChange(root, requested) {
+  if (requested) {
+    const changeDir = path5.join(root, "openspec", "changes", requested);
+    if (!await pathExists(changeDir)) {
+      throw new Error(`OpenSpec change not found: ${requested}`);
+    }
+    return requested;
+  }
+  const changes = await listOpenSpecChanges(root);
+  if (changes.length === 1) {
+    return changes[0];
+  }
+  if (changes.length === 0) {
+    throw new Error("No OpenSpec changes found.");
+  }
+  throw new Error(`Multiple OpenSpec changes found. Specify one with --change: ${changes.join(", ")}`);
+}
+async function readOpenSpecContext(root, change) {
+  const changeDir = path5.join(root, "openspec", "changes", change);
+  return {
+    change,
+    proposal: filterExcludedLines(await readTextIfExists(path5.join(changeDir, "proposal.md"))),
+    design: filterExcludedLines(await readTextIfExists(path5.join(changeDir, "design.md"))),
+    tasks: filterExcludedLines(await readTextIfExists(path5.join(changeDir, "tasks.md")))
+  };
+}
+function formatOpenSpecContext(context) {
+  if (!context) {
+    return "";
+  }
+  return [
+    `# OpenSpec Change: ${context.change}`,
+    "## proposal.md",
+    context.proposal || "(missing)",
+    "## design.md",
+    context.design || "(missing)",
+    "## tasks.md",
+    context.tasks || "(missing)"
+  ].join("\n\n");
+}
+
+// src/core/runs.ts
+import path7 from "path";
+
+// src/core/templates.ts
+import fsSync from "fs";
+import fs3 from "fs/promises";
+import path6 from "path";
+import { fileURLToPath } from "url";
+function getPackageRoot() {
+  const moduleDir = path6.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    moduleDir,
+    path6.resolve(moduleDir, ".."),
+    path6.resolve(moduleDir, "..", "..")
+  ];
+  for (const candidate of candidates) {
+    if (fsSync.existsSync(path6.join(candidate, "templates")) && fsSync.existsSync(path6.join(candidate, "skills"))) {
+      return candidate;
+    }
+  }
+  return path6.resolve(moduleDir, "..", "..");
+}
+function renderTemplate(template, values) {
+  return template.replace(/\{\{([A-Za-z0-9_]+)\}\}/g, (_, rawKey) => {
+    return values[rawKey] ?? "";
+  });
+}
+async function loadTemplate(name) {
+  const templatePath = path6.join(getPackageRoot(), "templates", name);
+  try {
+    return await fs3.readFile(templatePath, "utf8");
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Missing template ${name}: ${detail}`);
+  }
+}
+
+// src/core/runs.ts
+function slugify(value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+  return slug || "task";
+}
+function createRunId(title, date = /* @__PURE__ */ new Date()) {
+  const day = date.toISOString().slice(0, 10);
+  return `${day}-${slugify(title)}`;
+}
+function getRunContext(root, config, runId, lane = DEFAULT_LANE) {
+  const runDir = path7.join(root, config.handoffDir, "runs", runId);
+  return {
+    runId,
+    lane,
+    runDir,
+    laneDir: path7.join(runDir, "lanes", lane)
+  };
+}
+async function createRunStructure(root, config, runId, lane = DEFAULT_LANE, options = {}) {
+  const context = getRunContext(root, config, runId, lane);
+  await ensureDir(context.laneDir);
+  await ensureDir(path7.join(context.runDir, "history"));
+  const runRelative = path7.relative(root, path7.join(context.runDir, "RUN.md"));
+  await safeWriteFile(root, runRelative, `# RUN
+
+- Run: ${runId}
+- Lane: ${lane}
+`, options);
+  const board = renderTemplate(await loadTemplate("TASK_BOARD.template.md"), { runId });
+  const boardRelative = path7.relative(root, path7.join(context.runDir, "TASK_BOARD.md"));
+  await safeWriteFile(root, boardRelative, board, options);
+  return context;
+}
+
+// src/core/state.ts
+import path8 from "path";
+function createDefaultState(mode) {
+  return {
+    currentRun: "",
+    currentLane: DEFAULT_LANE,
+    mode,
+    currentChange: "",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    advisorMode: "review",
+    executorFailures: {
+      currentTask: 0,
+      totalEscalations: 0
+    },
+    directFixLog: []
+  };
+}
+async function loadState(root) {
+  const state = await readJsonIfExists(path8.join(root, STATE_FILE));
+  if (!state) {
+    throw new Error("Missing .relay/state.json. Run relay init first.");
+  }
+  return state;
+}
+async function writeState(root, state) {
+  await writeJsonFile(path8.join(root, STATE_FILE), state);
+}
+async function updateState(root, patch) {
+  const current = await loadState(root);
+  const next = { ...current, ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeState(root, next);
+  return next;
+}
+
+// src/commands/ask.ts
+function registerAskCommand(program2) {
+  program2.command("ask").description("Create a relay escalation request when the executor is stuck.").option("--run <target>", "Explicitly run build or test before generating ASK_ADVISOR.md.").option("--copy", "Copy generated content to clipboard.").option("--force", "Overwrite ASK_ADVISOR.md.").action(async (options) => {
+    const result = await runAsk(process.cwd(), options);
+    console.log(result.summary);
+  });
+}
+async function runAsk(root, options = {}) {
+  if (options.run && options.run !== "build" && options.run !== "test") {
+    throw new Error("--run must be build or test.");
+  }
+  const config = await loadConfig(root);
+  const state = await loadState(root);
+  const run = requireCurrentRun(root, config, state.currentRun, state.currentLane);
+  const contextSafety = await createContextSafety(root, config);
+  const git2 = await collectGitContext(root, {
+    maxDiffLines: config.maxDiffLines,
+    gitExcludePathspecs: contextSafety.ignore.gitExcludePathspecs,
+    shouldIgnorePath: contextSafety.shouldIgnorePath,
+    redactText: contextSafety.redactText
+  });
+  const currentTask = contextSafety.redactText(await readTextIfExists(path9.join(run.laneDir, "EXECUTOR_TASK.md")));
+  const commandResult = await maybeRunCommand(root, config, options.run);
+  const openSpecText = state.mode === "openspec" && state.currentChange ? contextSafety.redactText(formatOpenSpecContext(await readOpenSpecContext(root, state.currentChange))) : "";
+  const errorLog = contextSafety.redactText(commandResult ? [`Command: ${commandResult.command}`, `Exit Code: ${commandResult.exitCode}`, commandResult.output].join("\n") : "No build/test command was run. Pass --run build or --run test to include command output.");
+  const content = renderTemplate(await loadTemplate("ASK_ADVISOR.template.md"), {
+    projectName: config.projectName,
+    runId: state.currentRun,
+    lane: state.currentLane,
+    branch: git2.branch,
+    ignoreRulesStatus: contextSafety.ignoreRulesStatus,
+    redactionRulesStatus: contextSafety.redactionRulesStatus,
+    currentTask: [currentTask || "(missing EXECUTOR_TASK.md)", openSpecText].filter(Boolean).join("\n\n"),
+    errorLog,
+    gitStatus: git2.status || "(clean)",
+    gitDiffStat: git2.diffStat || "(no diff)"
+  });
+  const relative = path9.relative(root, path9.join(run.laneDir, "ASK_ADVISOR.md"));
+  const file = await safeWriteFile(root, relative, content, { force: options.force });
+  const copied = options.copy ? await copyToClipboard(content) : void 0;
+  return {
+    file,
+    summary: [`Created ${path9.relative(root, file)}`, copied === false ? "Clipboard copy failed; file was still generated." : ""].filter(Boolean).join("\n")
+  };
+}
+function requireCurrentRun(root, config, runId, lane) {
+  if (!runId) {
+    throw new Error("No current run. Run relay start first.");
+  }
+  return getRunContext(root, config, runId, lane);
+}
+async function maybeRunCommand(root, config, target) {
+  if (!target) {
+    return void 0;
+  }
+  const command = target === "build" ? config.buildCommand : config.testCommand;
+  if (!command) {
+    throw new Error(`No ${target} command configured or detected.`);
+  }
+  const contextSafety = await createContextSafety(root, config);
+  return runShellCommand(root, command, {
+    maxLogLines: config.maxLogLines,
+    redactText: contextSafety.redactText
+  });
+}
+
+// src/commands/doctor.ts
+import path11 from "path";
+
+// src/core/project.ts
+import fs4 from "fs/promises";
+import path10 from "path";
+async function readPackageScripts(root) {
+  const packageJsonPath = path10.join(root, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return {};
+  }
+  const packageJson = JSON.parse(stripBom(await fs4.readFile(packageJsonPath, "utf8")));
+  return packageJson.scripts ?? {};
+}
+async function detectPackageManager(root) {
+  if (await pathExists(path10.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path10.join(root, "package-lock.json"))) return "npm";
+  if (await pathExists(path10.join(root, "yarn.lock"))) return "yarn";
+  if (await pathExists(path10.join(root, "bun.lockb"))) return "bun";
+  return "unknown";
+}
+async function detectProject(root = process.cwd()) {
+  const resolvedRoot = path10.resolve(root);
+  const packageJsonPath = path10.join(resolvedRoot, "package.json");
+  const packageJson = await pathExists(packageJsonPath) ? JSON.parse(stripBom(await fs4.readFile(packageJsonPath, "utf8"))) : {};
+  return {
+    root: resolvedRoot,
+    name: packageJson.name ?? path10.basename(resolvedRoot),
+    hasGit: await pathExists(path10.join(resolvedRoot, ".git")),
+    hasPackageJson: await pathExists(packageJsonPath),
+    packageManager: await detectPackageManager(resolvedRoot),
+    packageScripts: await readPackageScripts(resolvedRoot),
+    hasOpenSpec: await hasOpenSpecStructure(resolvedRoot)
+  };
+}
+async function hasOpenSpecStructure(root) {
+  return await pathExists(path10.join(root, "openspec")) && (await pathExists(path10.join(root, "openspec", "changes")) || await pathExists(path10.join(root, "openspec", "specs")));
+}
+
+// src/commands/doctor.ts
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Check relay-kit project integration status.").action(async () => {
+    console.log(await runDoctor(process.cwd()));
+  });
+}
+async function runDoctor(root) {
+  const project = await detectProject(root);
+  const checks = [];
+  const configExists = await pathExists(path11.join(root, CONFIG_FILE));
+  const stateExists = await pathExists(path11.join(root, STATE_FILE));
+  checks.push(formatCheck(configExists, CONFIG_FILE, "Run relay init."));
+  checks.push(formatCheck(stateExists, STATE_FILE, "Run relay init."));
+  const agents = await readTextIfExists(path11.join(root, "AGENTS.md"));
+  checks.push(formatCheck(agents.includes(AGENTS_START_MARKER), "AGENTS.md relay-kit block", "Run relay init --force."));
+  if (configExists && stateExists) {
+    const config = await loadConfig(root);
+    const state = await loadState(root);
+    checks.push(formatCheck(await pathExists(path11.join(root, config.handoffDir, "runs")), `${config.handoffDir}/runs`, "Run relay init."));
+    for (const target of [".relay/skills", ".claude/skills", ".agents/skills"]) {
+      for (const skill of DEFAULT_SKILLS) {
+        checks.push(formatCheck(await pathExists(path11.join(root, target, skill, "SKILL.md")), `${target}/${skill}`, "Run relay init --force."));
+      }
+    }
+    if (state.currentRun) {
+      const run = getRunContext(root, config, state.currentRun, state.currentLane);
+      checks.push(formatCheck(await pathExists(run.laneDir), `current lane ${path11.relative(root, run.laneDir)}`, "Run relay start."));
+      checks.push(formatPending(!await pathExists(path11.join(run.laneDir, "ASK_ADVISOR.md")), "ASK_ADVISOR.md", "Advisor response may be needed."));
+      checks.push(formatPending(!await pathExists(path11.join(run.laneDir, "ADVISOR_DECISION.md")), "ADVISOR_DECISION.md", "Run relay resume if ready."));
+    }
+  }
+  checks.push(formatCheck(project.hasPackageJson, "package.json", "CLI works without it, but build/test detection will be limited."));
+  checks.push(formatCheck(project.packageScripts.build !== void 0, "package script: build", "Add a build script to enable relay ask --run build."));
+  checks.push(formatCheck(project.packageScripts.test !== void 0, "package script: test", "Add a test script to enable relay ask --run test."));
+  if (project.hasOpenSpec) {
+    const changes = await listOpenSpecChanges(root);
+    checks.push(`ok   OpenSpec changes: ${changes.length ? changes.join(", ") : "(none)"}`);
+  } else {
+    checks.push("warn OpenSpec: not detected; simple mode is supported.");
+  }
+  return ["relay doctor", ...checks].join("\n");
+}
+function formatCheck(ok, label, fix) {
+  return ok ? `ok   ${label}` : `warn ${label} - ${fix}`;
+}
+function formatPending(clear, fileName, fix) {
+  return clear ? `ok   no pending ${fileName}` : `warn pending ${fileName} - ${fix}`;
+}
+
+// src/commands/init.ts
+import fs5 from "fs/promises";
+import path13 from "path";
+
+// src/core/skills.ts
+import path12 from "path";
+async function installProjectSkills(root, config, options = {}) {
+  const sourceRoot = path12.join(getPackageRoot(), "skills");
+  const targets = [];
+  if (config.skills.install.manager) targets.push(path12.join(root, ".relay", "skills"));
+  if (config.skills.install.claudeProject) targets.push(path12.join(root, ".claude", "skills"));
+  if (config.skills.install.codexProject) targets.push(path12.join(root, ".agents", "skills"));
+  for (const targetRoot of targets) {
+    await ensureDir(targetRoot);
+    for (const skill of DEFAULT_SKILLS) {
+      await copyDirectory(path12.join(sourceRoot, skill), path12.join(targetRoot, skill), options);
+    }
+  }
+  return targets;
+}
+
+// src/commands/init.ts
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize relay-kit in the current project.").option("--mode <mode>", "Initialization mode: simple or openspec.").option("--with-openspec", "Show OpenSpec setup guidance without silently creating openspec/.").option("--yes", "Accept non-destructive defaults.").option("--force", "Overwrite relay-kit managed files.").action(async (options) => {
+    const result = await runInit(process.cwd(), options);
+    console.log(result.summary);
+  });
+}
+async function runInit(root, options = {}) {
+  const project = await detectProject(root);
+  const mode = resolveMode(project.hasOpenSpec, options.mode);
+  if (options.mode === "openspec" && !project.hasOpenSpec) {
+    throw new Error("Cannot use --mode openspec because openspec/ was not detected.");
+  }
+  const config = createDefaultConfig(project, mode);
+  const state = createDefaultState(mode);
+  await ensureDir(path13.join(root, ".relay"));
+  if (!options.force && (await pathExists(path13.join(root, CONFIG_FILE)) || await pathExists(path13.join(root, STATE_FILE)))) {
+    throw new Error("relay-kit is already initialized. Use --force to rewrite managed config/state files.");
+  }
+  await writeConfig(root, config);
+  await writeState(root, state);
+  await ensureDir(path13.join(root, DEFAULT_HANDOFF_DIR, "runs"));
+  const relayIgnoreStatus = await ensureRelayIgnore(root);
+  await injectAgentsRules(root, options.force);
+  const skillTargets = await installProjectSkills(root, config, { force: options.force });
+  const guidance = options.withOpenspec && !project.hasOpenSpec ? "\nOpenSpec was requested, but relay-kit did not create openspec/. Install/init OpenSpec explicitly, then rerun relay init --mode openspec --force." : "";
+  return {
+    summary: [
+      `relay init complete (${mode}).`,
+      `Config: ${CONFIG_FILE}`,
+      `State: ${STATE_FILE}`,
+      `Relay ignore: ${relayIgnoreStatus}`,
+      `Skills: ${skillTargets.map((target) => path13.relative(root, target)).join(", ")}`,
+      guidance
+    ].filter(Boolean).join("\n")
+  };
+}
+async function ensureRelayIgnore(root) {
+  if (await pathExists(path13.join(root, RELAYIGNORE_FILE))) {
+    return `${RELAYIGNORE_FILE} (kept existing)`;
+  }
+  await safeWriteFile(root, RELAYIGNORE_FILE, DEFAULT_RELAYIGNORE_CONTENT);
+  return RELAYIGNORE_FILE;
+}
+function resolveMode(hasOpenSpec, requested) {
+  if (requested && requested !== "simple" && requested !== "openspec") {
+    throw new Error("--mode must be simple or openspec.");
+  }
+  return requested ?? (hasOpenSpec ? "openspec" : "simple");
+}
+async function injectAgentsRules(root, force = false) {
+  const agentsPath = path13.join(root, "AGENTS.md");
+  const existing = await readTextIfExists(agentsPath);
+  const block = (await loadTemplate("AGENTS.relay.md")).trim();
+  if (existing.includes(AGENTS_START_MARKER) && existing.includes(AGENTS_END_MARKER)) {
+    if (!force) {
+      return;
+    }
+    const pattern = new RegExp(`${escapeRegExp(AGENTS_START_MARKER)}[\\s\\S]*?${escapeRegExp(AGENTS_END_MARKER)}`);
+    await fs5.writeFile(agentsPath, `${existing.replace(pattern, block).trim()}
+`, "utf8");
+    return;
+  }
+  const next = existing.trim() ? `${existing.trim()}
+
+${block}
+` : `${block}
+`;
+  await safeWriteFile(root, "AGENTS.md", next, { force: true });
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/resume.ts
+import path14 from "path";
+function registerResumeCommand(program2) {
+  program2.command("resume").description("Create a resume prompt from a relay decision.").option("--from <path>", "Read Advisor decision from a specific file.").option("--copy", "Copy generated content to clipboard.").option("--force", "Overwrite RESUME_PROMPT.md.").action(async (options) => {
+    const result = await runResume(process.cwd(), options);
+    console.log(result.summary);
+  });
+}
+async function runResume(root, options = {}) {
+  const config = await loadConfig(root);
+  const state = await loadState(root);
+  if (!state.currentRun) {
+    throw new Error("No current run. Run relay start first.");
+  }
+  const run = getRunContext(root, config, state.currentRun, state.currentLane);
+  const sourcePath = options.from ? path14.resolve(root, options.from) : path14.join(run.laneDir, "ADVISOR_DECISION.md");
+  const decision = await readTextIfExists(sourcePath);
+  if (!decision.trim()) {
+    throw new Error(`Decision is missing or empty: ${path14.relative(root, sourcePath)}`);
+  }
+  const prompt = extractPromptForExecutor(decision);
+  if (!prompt.trim()) {
+    throw new Error("Decision does not contain a non-empty 'Prompt For Executor' section.");
+  }
+  const content = renderTemplate(await loadTemplate("RESUME_PROMPT.template.md"), {
+    promptForExecutor: prompt
+  });
+  const relative = path14.relative(root, path14.join(run.laneDir, "RESUME_PROMPT.md"));
+  const file = await safeWriteFile(root, relative, content, { force: options.force });
+  const copied = options.copy ? await copyToClipboard(content) : void 0;
+  return {
+    file,
+    summary: [`Created ${path14.relative(root, file)}`, copied === false ? "Clipboard copy failed; file was still generated." : ""].filter(Boolean).join("\n")
+  };
+}
+function extractPromptForExecutor(decision) {
+  const heading = /^## Prompt For Executor\s*$/im.exec(decision);
+  if (!heading) {
+    return "";
+  }
+  const bodyStart = heading.index + heading[0].length;
+  const rest = decision.slice(bodyStart);
+  const nextHeading = /^##\s.+$/im.exec(rest);
+  return rest.slice(0, nextHeading?.index).trim();
+}
+
+// src/commands/review.ts
+import path15 from "path";
+function registerReviewCommand(program2) {
+  program2.command("review").description("Create a relay review request for the current implementation.").option("--copy", "Copy generated content to clipboard.").option("--force", "Overwrite REVIEW_REQUEST.md.").action(async (options) => {
+    const result = await runReview(process.cwd(), options);
+    console.log(result.summary);
+  });
+}
+async function runReview(root, options = {}) {
+  const config = await loadConfig(root);
+  const state = await loadState(root);
+  if (!state.currentRun) {
+    throw new Error("No current run. Run relay start first.");
+  }
+  const run = getRunContext(root, config, state.currentRun, state.currentLane);
+  const contextSafety = await createContextSafety(root, config);
+  const git2 = await collectGitContext(root, {
+    maxDiffLines: config.maxDiffLines,
+    gitExcludePathspecs: contextSafety.ignore.gitExcludePathspecs,
+    shouldIgnorePath: contextSafety.shouldIgnorePath,
+    redactText: contextSafety.redactText
+  });
+  const task = contextSafety.redactText(await readTextIfExists(path15.join(run.laneDir, "EXECUTOR_TASK.md")));
+  const openSpecText = state.mode === "openspec" && state.currentChange ? contextSafety.redactText(formatOpenSpecContext(await readOpenSpecContext(root, state.currentChange))) : "";
+  const content = renderTemplate(await loadTemplate("REVIEW_REQUEST.template.md"), {
+    projectName: config.projectName,
+    runId: state.currentRun,
+    lane: state.currentLane,
+    ignoreRulesStatus: contextSafety.ignoreRulesStatus,
+    redactionRulesStatus: contextSafety.redactionRulesStatus,
+    gitDiffStat: git2.diffStat || "(no diff)",
+    gitDiff: [git2.diff || "(no diff)", task ? `
+
+# Current Executor Task
+${task}` : "", openSpecText].filter(Boolean).join("\n")
+  });
+  const relative = path15.relative(root, path15.join(run.laneDir, "REVIEW_REQUEST.md"));
+  const file = await safeWriteFile(root, relative, content, { force: options.force });
+  const copied = options.copy ? await copyToClipboard(content) : void 0;
+  return {
+    file,
+    summary: [`Created ${path15.relative(root, file)}`, copied === false ? "Clipboard copy failed; file was still generated." : ""].filter(Boolean).join("\n")
+  };
+}
+
+// src/commands/start.ts
+import path16 from "path";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+function registerStartCommand(program2) {
+  program2.command("start").description("Start a relay handoff run and create an executor task.").option("--title <title>", "Simple mode task title.").option("--scope <scope>", "Allowed implementation scope.").option("--blocked-scope <scope>", "Scope that must not be changed.").option("--change <change>", "OpenSpec change name.").option("--copy", "Copy generated handoff content to clipboard.").option("--force", "Overwrite generated run files.").action(async (options) => {
+    const result = await runStart(process.cwd(), options);
+    console.log(result.summary);
+  });
+}
+async function runStart(root, options = {}) {
+  const config = await loadConfig(root);
+  const state = await loadState(root);
+  const mode = state.mode || config.mode;
+  const answers = mode === "simple" ? await collectSimpleInputs(options) : options;
+  const title = answers.title || (mode === "openspec" ? "OpenSpec handoff" : "Untitled task");
+  const runId = createRunId(title);
+  const run = await createRunStructure(root, config, runId, DEFAULT_LANE, { force: options.force });
+  let change = options.change || state.currentChange;
+  let openSpecText = "";
+  if (mode === "openspec") {
+    change = await resolveOpenSpecChange(root, change || void 0);
+    openSpecText = formatOpenSpecContext(await readOpenSpecContext(root, change));
+  }
+  const content = renderTemplate(await loadTemplate("EXECUTOR_TASK.template.md"), {
+    projectName: config.projectName,
+    runId,
+    lane: DEFAULT_LANE,
+    mode,
+    change: change || "",
+    taskTitle: title,
+    allowedScope: [answers.scope || "Follow the current task only.", openSpecText].filter(Boolean).join("\n\n"),
+    blockedScope: answers.blockedScope || "Do not expand scope beyond EXECUTOR_TASK.md."
+  });
+  const relative = path16.relative(root, path16.join(run.laneDir, "EXECUTOR_TASK.md"));
+  const file = await safeWriteFile(root, relative, content, { force: options.force });
+  await updateState(root, { currentRun: runId, currentLane: DEFAULT_LANE, mode, currentChange: change || "" });
+  const copied = options.copy ? await copyToClipboard(content) : void 0;
+  return {
+    file,
+    summary: [`Created ${path16.relative(root, file)}`, copied === false ? "Clipboard copy failed; file was still generated." : ""].filter(Boolean).join("\n")
+  };
+}
+async function collectSimpleInputs(options) {
+  if (options.title && options.scope && options.blockedScope) {
+    return options;
+  }
+  if (!input.isTTY || !output.isTTY) {
+    return options;
+  }
+  const rl = createInterface({ input, output });
+  try {
+    return {
+      ...options,
+      title: options.title || await rl.question("Task title: "),
+      scope: options.scope || await rl.question("Allowed scope: "),
+      blockedScope: options.blockedScope || await rl.question("Blocked scope: ")
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+// src/core/skills-sync.ts
+import crypto from "crypto";
+import fs6 from "fs/promises";
+import os from "os";
+import path17 from "path";
+var SkillSyncConflictError = class extends Error {
+  constructor(report) {
+    super("Skills sync encountered conflicts. Re-run with --force to overwrite conflicted files.");
+    this.report = report;
+  }
+  report;
+};
+var MANIFEST_FILE = path17.join(RELAY_DIR, "skills-sync.json");
+var ACTIONS = ["create", "update", "unchanged", "conflict", "skip"];
+async function syncSkills(root, config, options = {}) {
+  const sourceRoot = path17.join(root, RELAY_DIR, "skills");
+  const scope = options.scope ?? "project";
+  const targets = resolveSkillSyncTargets(root, config, { ...options, scope });
+  const sources = await collectSkillSourceFiles(sourceRoot);
+  const manifest = await readManifest(root);
+  const report = await planSkillSync(sourceRoot, sources, targets, manifest, options.target ?? "configured", scope, options);
+  if (!options.force && report.summary.conflict > 0) {
+    throw new SkillSyncConflictError(report);
+  }
+  if (!options.dryRun) {
+    await applySkillSync(report, sources, manifest);
+    await writeJsonFile(path17.join(root, MANIFEST_FILE), manifest);
+  }
+  return report;
+}
+function resolveSkillSyncTargets(root, config, options = {}) {
+  const scope = options.scope ?? "project";
+  const homeDir = options.homeDir ?? os.homedir();
+  const tools = resolveTools(config, options.target, scope);
+  return tools.map((tool) => ({
+    tool,
+    scope,
+    root: resolveTargetRoot(root, homeDir, tool, scope)
+  }));
+}
+function formatSkillSyncReport(report) {
+  const targetLabels = report.targets.map((target) => pathLabel(target.root)).join(", ") || "(none)";
+  const lines = [
+    "relay sync --skills",
+    `source: ${pathLabel(report.sourceRoot)}`,
+    `scope: ${report.scope}`,
+    `target: ${report.targetOption}`,
+    `dry-run: ${report.dryRun ? "yes" : "no"}`,
+    `force: ${report.force ? "yes" : "no"}`,
+    `targets: ${targetLabels}`,
+    `summary: create ${report.summary.create}, update ${report.summary.update}, unchanged ${report.summary.unchanged}, conflict ${report.summary.conflict}, skip ${report.summary.skip}`
+  ];
+  if (report.entries.length) {
+    lines.push("files:");
+    for (const entry of report.entries) {
+      lines.push(`- ${entry.action} ${entry.tool}/${entry.scope} ${entry.skill}/${entry.relativePath} -> ${pathLabel(entry.targetPath)} (${entry.reason})`);
+    }
+  }
+  if (report.summary.conflict > 0) {
+    lines.push("conflicts:");
+    for (const entry of report.entries.filter((item) => item.action === "conflict")) {
+      lines.push(`- ${pathLabel(entry.targetPath)}`);
+    }
+    lines.push("Use --force to overwrite conflicted files after reviewing them.");
+  }
+  return lines.join("\n");
+}
+function resolveTools(config, target, scope) {
+  if (target) {
+    if (target === "all") {
+      return ["claude", "codex"];
+    }
+    return [target];
+  }
+  if (scope === "project") {
+    return [
+      config.skills.install.claudeProject ? "claude" : void 0,
+      config.skills.install.codexProject ? "codex" : void 0
+    ].filter((tool) => Boolean(tool));
+  }
+  const tools = [
+    config.skills.install.claudeUser ? "claude" : void 0,
+    config.skills.install.codexUser ? "codex" : void 0
+  ].filter((tool) => Boolean(tool));
+  if (tools.length === 0) {
+    throw new Error("No user-level skills targets are enabled. Pass --target claude, --target codex, or --target all with --scope user.");
+  }
+  return tools;
+}
+function resolveTargetRoot(root, homeDir, tool, scope) {
+  if (scope === "user") {
+    return path17.join(homeDir, tool === "claude" ? ".claude" : ".agents", "skills");
+  }
+  return path17.join(root, tool === "claude" ? ".claude" : ".agents", "skills");
+}
+async function collectSkillSourceFiles(sourceRoot) {
+  if (!await pathExists(sourceRoot)) {
+    throw new Error("Missing .relay/skills. Run relay init first.");
+  }
+  const entries = await fs6.readdir(sourceRoot, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("relay-")) {
+      continue;
+    }
+    const skillRoot = path17.join(sourceRoot, entry.name);
+    if (!await pathExists(path17.join(skillRoot, "SKILL.md"))) {
+      continue;
+    }
+    files.push(...await collectFiles(skillRoot, entry.name, ""));
+  }
+  if (files.length === 0) {
+    throw new Error("No relay skills found in .relay/skills.");
+  }
+  return files;
+}
+async function collectFiles(skillRoot, skill, relativeDir) {
+  const dir = path17.join(skillRoot, relativeDir);
+  const entries = await fs6.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const relativePath = path17.join(relativeDir, entry.name);
+    const absolutePath = path17.join(skillRoot, relativePath);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(skillRoot, skill, relativePath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const content = await fs6.readFile(absolutePath);
+    files.push({
+      skill,
+      relativePath,
+      absolutePath,
+      content,
+      hash: hashBuffer(content)
+    });
+  }
+  return files;
+}
+async function planSkillSync(sourceRoot, sources, targets, manifest, targetOption, scope, options) {
+  const entries = [];
+  const summary = createEmptySummary();
+  for (const target of targets) {
+    for (const source of sources) {
+      const targetPath = path17.join(target.root, source.skill, source.relativePath);
+      const recordKey = manifestKey(target, source.skill, source.relativePath);
+      const record = manifest.records[recordKey];
+      const targetExists = await pathExists(targetPath);
+      const targetHash = targetExists ? hashBuffer(await fs6.readFile(targetPath)) : "";
+      const action = resolveAction(source.hash, targetExists, targetHash, record, Boolean(options.force));
+      const reason = actionReason(action, targetExists, record, Boolean(options.force));
+      entries.push({
+        action,
+        tool: target.tool,
+        scope: target.scope,
+        skill: source.skill,
+        relativePath: normalizeRelative(source.relativePath),
+        sourcePath: source.absolutePath,
+        targetPath,
+        reason
+      });
+      summary[action] += 1;
+    }
+  }
+  return {
+    sourceRoot,
+    targetOption,
+    scope,
+    dryRun: Boolean(options.dryRun),
+    force: Boolean(options.force),
+    targets,
+    entries,
+    summary
+  };
+}
+async function applySkillSync(report, sources, manifest) {
+  const sourceByKey = new Map(sources.map((source) => [`${source.skill}/${normalizeRelative(source.relativePath)}`, source]));
+  const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  for (const entry of report.entries) {
+    const source = sourceByKey.get(`${entry.skill}/${entry.relativePath}`);
+    if (!source) {
+      continue;
+    }
+    if (entry.action === "create" || entry.action === "update") {
+      await ensureDir(path17.dirname(entry.targetPath));
+      await fs6.writeFile(entry.targetPath, source.content);
+    }
+    if (entry.action === "create" || entry.action === "update" || entry.action === "unchanged") {
+      manifest.records[manifestKey(entry, entry.skill, entry.relativePath)] = {
+        sourceHash: source.hash,
+        targetHash: source.hash,
+        syncedAt
+      };
+    }
+  }
+}
+function resolveAction(sourceHash, targetExists, targetHash, record, force) {
+  if (!targetExists) {
+    return "create";
+  }
+  if (targetHash === sourceHash) {
+    return "unchanged";
+  }
+  if (record?.targetHash === targetHash || force) {
+    return "update";
+  }
+  return "conflict";
+}
+function actionReason(action, targetExists, record, force) {
+  if (action === "create") return "target file does not exist";
+  if (action === "unchanged") return record ? "target already matches source" : "target matches source; recording sync state";
+  if (action === "update") return force ? "force enabled" : "target unchanged since last sync";
+  if (action === "conflict") return targetExists ? "target differs and is not safe to overwrite" : "not applicable";
+  return "skipped";
+}
+async function readManifest(root) {
+  const manifest = await readJsonIfExists(path17.join(root, MANIFEST_FILE));
+  if (!manifest || manifest.version !== 1 || typeof manifest.records !== "object") {
+    return { version: 1, records: {} };
+  }
+  return manifest;
+}
+function manifestKey(target, skill, relativePath) {
+  return `${target.scope}:${target.tool}:${skill}/${normalizeRelative(relativePath)}`;
+}
+function hashBuffer(value) {
+  return `sha256:${crypto.createHash("sha256").update(value).digest("hex")}`;
+}
+function createEmptySummary() {
+  return Object.fromEntries(ACTIONS.map((action) => [action, 0]));
+}
+function normalizeRelative(value) {
+  return value.replace(/\\/g, "/");
+}
+function pathLabel(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/commands/sync.ts
+function registerSyncCommand(program2) {
+  program2.command("sync").description("Synchronize relay-kit managed resources.").option("--skills", "Synchronize relay Skills from .relay/skills.").option("--target <target>", "Skill target: claude, codex, or all.").option("--scope <scope>", "Skill sync scope: project or user.", "project").option("--dry-run", "Preview the sync plan without writing files.").option("--force", "Overwrite conflicted skill files.").action(async (options) => {
+    const result = await runSync(process.cwd(), options);
+    console.log(result.summary);
+  });
+}
+async function runSync(root, options = {}) {
+  if (!options.skills) {
+    throw new Error("relay sync currently supports only --skills.");
+  }
+  validateTarget(options.target);
+  validateScope(options.scope);
+  const config = await loadConfig(root);
+  try {
+    const report = await syncSkills(root, config, options);
+    return { summary: formatSkillSyncReport(report) };
+  } catch (error) {
+    if (error instanceof SkillSyncConflictError) {
+      throw new Error(`${formatSkillSyncReport(error.report)}
+${error.message}`);
+    }
+    throw error;
+  }
+}
+function validateTarget(target) {
+  if (target === void 0 || target === "claude" || target === "codex" || target === "all") {
+    return;
+  }
+  throw new Error("--target must be claude, codex, or all.");
+}
+function validateScope(scope) {
+  if (scope === void 0 || scope === "project" || scope === "user") {
+    return;
+  }
+  throw new Error("--scope must be project or user.");
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("relay").description("Skills-first, CLI-assisted AI programming relay workflow toolkit.").version("0.2.0");
+registerInitCommand(program);
+registerStartCommand(program);
+registerAskCommand(program);
+registerResumeCommand(program);
+registerReviewCommand(program);
+registerDoctorCommand(program);
+registerSyncCommand(program);
+program.parseAsync(process.argv).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map