@makerx/yoke 0.7.0 → 0.8.0

package/dist/cli.js

@@ -7,7 +7,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@makerx/yoke",
-  version: "0.7.0",
+  version: "0.8.0",
   description: "Lean, user-invoked Claude Code skills for MakerX AI-assisted delivery, plus the CLI they call.",
   license: "MIT",
   author: "MakerX",
@@ -136,14 +136,14 @@ function wrap(text2, width) {
   return line ? [...lines, line] : lines;
 }
 function listSettings(settings, columns = Infinity) {
-  const rows = settingKeys.map((key) => ({
+  const rows2 = settingKeys.map((key) => ({
     key,
     value: displayValue(key, settings[key]),
     description: settingDescription(key)
   }));
-  const keyWidth = Math.max(...rows.map(({ key }) => key.length));
+  const keyWidth = Math.max(...rows2.map(({ key }) => key.length));
   const indent = " ".repeat(keyWidth + gap.length);
-  const blocks = rows.map(
+  const blocks = rows2.map(
     ({ key, value, description }) => [`${key.padEnd(keyWidth)}${gap}${value}`, ...wrap(description, columns - indent.length).map((line) => indent + line)].join("\n")
   );
   return blocks.join("\n\n");
@@ -823,6 +823,37 @@ import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync, readFi
 import { homedir as homedir2, tmpdir } from "os";
 import { join as join8 } from "path";
 
+// src/features/review/comments.ts
+var markerPrefix = "<!-- yoke-review:";
+function slug(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function findingMarker({ file, title }) {
+  return `${markerPrefix} ${file ?? "n/a"}#${slug(title)} -->`;
+}
+function hasMarker(prior, marker) {
+  return prior.some((comment) => comment.body.includes(marker));
+}
+function withoutMarkers(body) {
+  return body.split("\n").filter((line) => !line.trimStart().startsWith(markerPrefix)).join("\n").trim();
+}
+function heading({ path, line }) {
+  if (!path) return "### PR review";
+  return line === null ? `### ${path}` : `### ${path}:${line}`;
+}
+function formatPriorComments(prior) {
+  if (!prior.length) return "";
+  const blocks = prior.map((comment) => `${heading(comment)}
+
+**${comment.author}**: ${withoutMarkers(comment.body)}`);
+  return `## Prior review comments
+
+The PR already has the review comments below, including resolved and outdated threads. Do not re-raise a finding a prior comment substantively covers.
+
+${blocks.join("\n\n")}
+`;
+}
+
 // src/features/review/findings.ts
 var severities = ["blocker", "major", "minor", "nit"];
 var sources = ["confirmed", "disputed", "reviewer1-only", "reviewer2-only", "already-raised"];
@@ -881,184 +912,6 @@ function formatSynthesis({ summary, findings }) {
   return lines.join("\n").trimEnd();
 }
 
-// src/features/review/harness.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-
-// src/features/review/progress.ts
-var maxSummary = 80;
-function isJson(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function truncate(value) {
-  const collapsed = value.replace(/\s+/g, " ").trim();
-  return collapsed.length <= maxSummary ? collapsed : `${collapsed.slice(0, maxSummary - 1)}\u2026`;
-}
-function text(input, key) {
-  const value = input[key];
-  return typeof value === "string" ? value : void 0;
-}
-function toolSummary(input) {
-  if (!isJson(input)) return "";
-  const pattern = text(input, "pattern");
-  if (pattern) {
-    const scope = text(input, "path");
-    return scope ? `${pattern} in ${scope}` : pattern;
-  }
-  const found = text(input, "file_path") ?? text(input, "path") ?? text(input, "url");
-  if (found) return found;
-  const described = text(input, "command") ?? text(input, "query") ?? text(input, "description");
-  return described ? truncate(described) : "";
-}
-function describeTool(tool, summary) {
-  return summary ? `${tool} ${summary}` : tool;
-}
-function claudeEvent(event) {
-  if (event.type === "result" && typeof event.result === "string") return { kind: "final", text: event.result };
-  if (event.type === "system" && event.subtype === "init" && typeof event.model === "string") return { kind: "model", model: event.model };
-  const content = isJson(event.message) ? event.message.content : void 0;
-  if (event.type !== "assistant" || !Array.isArray(content)) return { kind: "ignore" };
-  const uses = content.filter((block) => isJson(block) && block.type === "tool_use");
-  if (!uses.length) return { kind: "ignore" };
-  return { kind: "activity", text: uses.map((use) => describeTool(text(use, "name") ?? "tool", toolSummary(use.input))).join(", ") };
-}
-function unwrapShell(command) {
-  const wrapped = command.match(/^\/bin\/(?:ba|z)?sh\s+-lc\s+["'](.*)["']\s*$/s);
-  return truncate(wrapped?.[1]?.replace(/\\"/g, '"') ?? command);
-}
-function codexError(event) {
-  if (event.type === "error") return text(event, "message");
-  if (event.type === "turn.failed" && isJson(event.error)) return text(event.error, "message");
-  return void 0;
-}
-function codexEvent(event) {
-  const message = codexError(event);
-  if (message) return { kind: "error", message };
-  const item = event.item;
-  if (event.type !== "item.started" || !isJson(item)) return { kind: "ignore" };
-  const command = text(item, "command");
-  if (item.type === "command_execution" && command) return { kind: "activity", text: describeTool("shell", unwrapShell(command)) };
-  return { kind: "ignore" };
-}
-function parseHarnessEvent(harness, line) {
-  let event;
-  try {
-    event = JSON.parse(line);
-  } catch {
-    return { kind: "ignore" };
-  }
-  if (!isJson(event)) return { kind: "ignore" };
-  return harness === "claude" ? claudeEvent(event) : codexEvent(event);
-}
-
-// src/features/review/harness.ts
-var tailLines = 20;
-function harnessArgs({ harness, reviewDir, outputPath, override }) {
-  const extra = override?.args ?? [];
-  if (harness === "codex") return ["exec", "--sandbox", "read-only", "--json", "--output-last-message", outputPath, ...extra, "-"];
-  return [
-    "-p",
-    "--add-dir",
-    reviewDir,
-    "--disallowedTools",
-    "Edit,Write,NotebookEdit",
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    ...extra
-  ];
-}
-function windowsQuote(arg) {
-  return /[\s"]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
-}
-function tail(text2) {
-  return text2.trim().split("\n").slice(-tailLines).join("\n");
-}
-function spawnError(harness, error) {
-  if (error.code === "ENOENT") return `${harness} CLI not found on PATH; install it or sign in, then retry`;
-  return `${harness} failed to start: ${error.message}`;
-}
-function exitError(harness, code, output) {
-  const detail = tail(output);
-  return [`${harness} exited with code ${code ?? "unknown"}`, ...detail ? [detail] : []].join("\n");
-}
-function hasReview(path) {
-  return existsSync3(path) && readFileSync3(path, "utf8").trim().length > 0;
-}
-var runHarness = (run2) => new Promise((resolve) => {
-  const shell = process.platform === "win32";
-  const args = harnessArgs(run2);
-  const child = spawn(run2.harness, shell ? args.map(windowsQuote) : args, {
-    cwd: run2.cwd,
-    env: { ...process.env, ...run2.override?.env },
-    stdio: ["pipe", "pipe", "pipe"],
-    shell
-  });
-  let pending = "";
-  let finalText = "";
-  let model;
-  let lastError = "";
-  let stderr = "";
-  const onLine = (line) => {
-    const event = parseHarnessEvent(run2.harness, line);
-    if (event.kind === "activity") run2.onProgress?.(event.text);
-    if (event.kind === "final") finalText = event.text;
-    if (event.kind === "model") model = event.model;
-    if (event.kind === "error") lastError = event.message;
-  };
-  child.stdout.setEncoding("utf8");
-  child.stderr.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    const lines = (pending + chunk).split("\n");
-    pending = lines.pop() ?? "";
-    lines.forEach(onLine);
-  });
-  child.stderr.on("data", (chunk) => stderr += chunk);
-  child.stdin.on("error", () => {
-  });
-  child.stdin.end(run2.prompt);
-  child.on("error", (error) => resolve({ ok: false, error: spawnError(run2.harness, error) }));
-  child.on("close", (code) => {
-    onLine(pending);
-    if (code !== 0)
-      return resolve({ ok: false, error: exitError(run2.harness, code, [stderr || finalText, lastError].filter(Boolean).join("\n")) });
-    if (run2.harness === "claude") writeFileSync3(run2.outputPath, finalText);
-    if (!hasReview(run2.outputPath)) return resolve({ ok: false, error: `${run2.harness} returned an empty review` });
-    resolve(model ? { ok: true, model } : { ok: true });
-  });
-});
-
-// src/features/review/comments.ts
-var markerPrefix = "<!-- yoke-review:";
-function slug(text2) {
-  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-function findingMarker({ file, title }) {
-  return `${markerPrefix} ${file ?? "n/a"}#${slug(title)} -->`;
-}
-function hasMarker(prior, marker) {
-  return prior.some((comment) => comment.body.includes(marker));
-}
-function withoutMarkers(body) {
-  return body.split("\n").filter((line) => !line.trimStart().startsWith(markerPrefix)).join("\n").trim();
-}
-function heading({ path, line }) {
-  if (!path) return "### PR review";
-  return line === null ? `### ${path}` : `### ${path}:${line}`;
-}
-function formatPriorComments(prior) {
-  if (!prior.length) return "";
-  const blocks = prior.map((comment) => `${heading(comment)}
-
-**${comment.author}**: ${withoutMarkers(comment.body)}`);
-  return `## Prior review comments
-
-The PR already has the review comments below, including resolved and outdated threads. Do not re-raise a finding a prior comment substantively covers.
-
-${blocks.join("\n\n")}
-`;
-}
-
 // src/features/review/request.ts
 var fileHeader = /^\+\+\+ (.+)$/;
 var hunkHeader = /^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
@@ -1168,14 +1021,19 @@ function outsideEntry(finding) {
   const entry = [`- **${finding.severity ?? "finding"}** ${location} \u2014 ${finding.title}`, ...details(finding).map((d) => `  ${d}`)];
   return [...entry, `  ${findingMarker(finding)}`].join("\n");
 }
-function reviewBody(summary, outside, footer = "") {
-  const sections = ["## Adversarial review", ...summary ? [summary] : []];
+var noFindingsNote = "No new findings were raised.";
+var rerunNote = "To re-run this review, mark the PR as draft and then ready for review again.";
+function reviewBody(summary, outside, footer = "", note = "") {
+  const sections = ["## Adversarial review", ...summary ? [summary] : [], ...note ? [note] : []];
   if (outside.length) sections.push(`### Findings outside the diff
 
 ${outside.map(outsideEntry).join("\n")}`);
   if (footer) sections.push(footer);
   return sections.join("\n\n");
 }
+function postFooter(footer, ci) {
+  return [...footer ? [footer] : [], ...ci ? [`_${rerunNote}_`] : []].join("\n\n");
+}
 async function addComments(review, comments, { api, log }) {
   const rejected = [];
   for (const { finding, ...comment } of comments) {
@@ -1189,155 +1047,396 @@ async function addComments(review, comments, { api, log }) {
   }
   return rejected;
 }
+function failedReviewBody(reason, runUrl, footer = "") {
+  const sections = ["## Code review failed", `The review did not complete: ${reason}. No findings were posted.`];
+  if (runUrl) sections.push(`See the [workflow run](${runUrl}) for details.`);
+  if (footer) sections.push(footer);
+  return sections.join("\n\n");
+}
+async function postFailure(pr2, reason, runUrl, deps) {
+  const review = await deps.api.open(pr2);
+  try {
+    const url = await deps.api.submit(pr2, review, failedReviewBody(reason, runUrl, postFooter(deps.footer, true)));
+    deps.log(`posted the failed review: ${url}`);
+  } catch (error) {
+    await discard(pr2, review, deps);
+    throw error;
+  }
+}
+async function discard(pr2, review, { api, log }) {
+  try {
+    await api.discard(pr2, review);
+  } catch (discardError) {
+    log(`could not discard the pending review: ${discardError instanceof Error ? discardError.message : String(discardError)}`);
+  }
+}
 async function postFindings(pr2, synthesis, diff, prior, deps) {
-  const { api, log } = deps;
+  const { api, log, ci = false } = deps;
   const { comments, outside, skipped } = planPost(synthesis, diff, prior);
   if (skipped.length) log(`skipped ${skipped.length} finding(s) already raised on the PR`);
-  if (!comments.length && !outside.length) return log("nothing new to post");
+  const nothingNew = !comments.length && !outside.length;
+  if (nothingNew && !ci) return log("nothing new to post");
+  const footer = postFooter(deps.footer, ci);
   const review = await api.open(pr2);
   try {
+    if (nothingNew) {
+      const url2 = await api.submit(pr2, review, reviewBody(synthesis.summary, [], footer, noFindingsNote));
+      return log(`nothing new to post, so posted a review without findings: ${url2}`);
+    }
     const rejected = await addComments(review, comments, deps);
-    const url = await api.submit(pr2, review, reviewBody(synthesis.summary, [...outside, ...rejected], deps.footer));
+    const url = await api.submit(pr2, review, reviewBody(synthesis.summary, [...outside, ...rejected], footer));
     log(`posted ${comments.length - rejected.length} inline comment(s) and ${outside.length + rejected.length} in the review body: ${url}`);
   } catch (error) {
-    try {
-      await api.discard(pr2, review);
-    } catch (discardError) {
-      log(`could not discard the pending review: ${discardError instanceof Error ? discardError.message : String(discardError)}`);
-    }
+    await discard(pr2, review, deps);
     throw error;
   }
 }
 
-// src/features/review/preflight.ts
-import { execFile as execFile2 } from "child_process";
-var commandTimeout = 3e4;
-var probeTimeout = 6e4;
-var maxBodyChars2 = 300;
-function exec(harness, args) {
-  return new Promise((resolve) => {
-    const options = { encoding: "utf8", timeout: commandTimeout, shell: process.platform === "win32" };
-    execFile2(harness, args, options, (error, stdout) => resolve({ ok: !error, stdout }));
-  });
+// src/features/review/status.ts
+import { styleText } from "util";
+import { createLogUpdate } from "log-update";
+async function timed(ui, label, work) {
+  const started = Date.now();
+  const status = ui.track(label);
+  const elapsed = () => `${Math.round((Date.now() - started) / 1e3)}s`;
+  try {
+    const result = await work();
+    status.succeed(`${label} (${elapsed()})`);
+    return result;
+  } catch (error) {
+    status.fail(`${label} failed after ${elapsed()}`);
+    throw error;
+  }
 }
-async function claudeSignedIn() {
-  const { ok, stdout } = await exec("claude", ["auth", "status", "--json"]);
-  if (!ok) return false;
+function lineUi(log, { activity }) {
+  return {
+    log,
+    track: (label) => {
+      log(`${label}\u2026`);
+      const update = (text2) => activity ? log(`${label}: ${text2}`) : void 0;
+      return { update, succeed: log, fail: log };
+    },
+    stop: () => {
+    }
+  };
+}
+var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var tickMs = 80;
+function spinnerUi(stream) {
+  const update = createLogUpdate(stream);
+  const running = [];
+  let frame = 0;
+  let timer;
+  const paint = (colour, text2) => styleText(colour, text2, { stream });
+  const render = () => update(running.map((entry) => `${paint("cyan", frames[frame] ?? "")} ${entry.text}`).join("\n"));
+  const persist = (line) => {
+    update.clear();
+    update.persist(line);
+    render();
+  };
+  const settle = (entry, line) => {
+    running.splice(running.indexOf(entry), 1);
+    persist(line);
+    if (running.length || !timer) return;
+    clearInterval(timer);
+    timer = void 0;
+  };
+  return {
+    log: persist,
+    track: (label) => {
+      const entry = { label, text: label };
+      running.push(entry);
+      timer ??= setInterval(() => {
+        frame = (frame + 1) % frames.length;
+        render();
+      }, tickMs);
+      render();
+      return {
+        update: (activity) => entry.text = `${label} \u2014 ${activity}`,
+        succeed: (text2) => settle(entry, `${paint("green", "\u2713")} ${text2}`),
+        fail: (text2) => settle(entry, `${paint("red", "\u2717")} ${text2}`)
+      };
+    },
+    stop: () => {
+      if (timer) clearInterval(timer);
+      update.done();
+    }
+  };
+}
+
+// src/features/review/ciRun.ts
+function isCi(env = process.env) {
+  return env.GITHUB_ACTIONS === "true";
+}
+function ciRunUrl(env = process.env) {
+  const { GITHUB_SERVER_URL, GITHUB_REPOSITORY, GITHUB_RUN_ID } = env;
+  if (!GITHUB_SERVER_URL || !GITHUB_REPOSITORY || !GITHUB_RUN_ID) return void 0;
+  return `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`;
+}
+async function reportFailure(pr2, reason, ui, deps) {
   try {
-    const parsed = JSON.parse(stdout);
-    return typeof parsed === "object" && parsed !== null && "loggedIn" in parsed && parsed.loggedIn === true;
-  } catch {
-    return false;
+    await timed(ui, `posting the failed review to #${pr2.number}`, () => postFailure(pr2, reason, ciRunUrl(), deps));
+  } catch (error) {
+    ui.log(`could not post the failed review: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-async function reach({ url, headers, body }) {
+
+// src/features/review/harness.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+
+// src/features/review/usage.ts
+import { appendFileSync } from "fs";
+var fields2 = ["input", "output", "cacheRead", "cacheWrite"];
+var rows = [
+  ["reviewer1", "Reviewer 1"],
+  ["reviewer2", "Reviewer 2"],
+  ["synthesis", "Synthesis"]
+];
+var dash = "\u2014";
+function count(source, key) {
+  const value = key ? source[key] : void 0;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseUsage(raw, keys) {
+  if (!isRecord(raw)) return void 0;
+  const usage = {};
+  for (const field2 of fields2) {
+    const value = count(raw, keys[field2]);
+    if (value !== void 0) usage[field2] = value;
+  }
+  return Object.keys(usage).length ? usage : void 0;
+}
+function sum(values) {
+  const reported = values.filter((value) => value !== void 0);
+  return reported.length ? reported.reduce((a, b) => a + b, 0) : void 0;
+}
+function sumUsage(usages) {
+  const total = {};
+  for (const field2 of fields2) {
+    const value = sum(usages.map((usage) => usage?.[field2]));
+    if (value !== void 0) total[field2] = value;
+  }
+  return total;
+}
+function addUsage(a, b) {
+  return sumUsage([a, b]);
+}
+function cell(value) {
+  return value === void 0 ? dash : value.toLocaleString("en-US");
+}
+function row(label, usage) {
+  return `| ${label} | ${fields2.map((field2) => cell(usage?.[field2])).join(" | ")} |`;
+}
+function usageTable(usage) {
+  const total = sumUsage(rows.map(([step]) => usage[step]));
+  return [
+    "## Token usage",
+    "",
+    "| Slot | Input | Output | Cache read | Cache write |",
+    "| --- | ---: | ---: | ---: | ---: |",
+    ...rows.map(([step, label]) => row(label, usage[step])),
+    row("**Total**", total)
+  ].join("\n");
+}
+function jobSummary(summary, usage) {
+  return ["## Adversarial review", summary || "No summary was given.", usageTable(usage)].join("\n\n");
+}
+function writeJobSummary(summary, usage, log, env = process.env) {
+  const path = env.GITHUB_STEP_SUMMARY;
+  if (!path) return;
   try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...headers },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(probeTimeout)
-    });
-    if (response.ok) return void 0;
-    const text2 = (await response.text()).trim().slice(0, maxBodyChars2);
-    return `HTTP ${response.status}${text2 ? `: ${text2}` : ""}`;
+    appendFileSync(path, `${jobSummary(summary, usage)}
+`);
+    log("wrote the review summary and token usage to the job summary");
   } catch (error) {
-    if (!(error instanceof Error)) return String(error);
-    const cause = error.cause instanceof Error ? error.cause.message : "";
-    return cause ? `${error.message} (${cause})` : error.message;
+    log(`could not write the job summary: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-var checks = {
-  onPath: async (harness) => (await exec(harness, ["--version"])).ok,
-  signedIn: async (harness) => harness === "claude" ? claudeSignedIn() : (await exec("codex", ["login", "status"])).ok,
-  reach
-};
-var loginCommand = { claude: "claude auth login", codex: "codex login" };
-function signedOut({ slot: { harness }, keys }) {
-  const settings = keys.map((key) => `${key}.provider and ${key}.model`).join(", and ");
-  return `${harness} is not signed in (${keys.join(", ")}); run \`${loginCommand[harness]}\`, or run it through LiteLLM or Foundry by setting ${settings} (see \`yoke models\`)`;
+
+// src/features/review/progress.ts
+var maxSummary = 80;
+function isJson(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function slotProblem(use, check) {
-  const { harness, model, probe } = use.slot;
-  if (!await check.onPath(harness)) return `${harness} CLI not found on PATH; install it`;
-  if (!probe) return await check.signedIn(harness) ? void 0 : signedOut(use);
-  const error = await check.reach(probe);
-  return error && `${harness} model "${model}" at ${probe.url}: ${error}`;
+function truncate(value) {
+  const collapsed = value.replace(/\s+/g, " ").trim();
+  return collapsed.length <= maxSummary ? collapsed : `${collapsed.slice(0, maxSummary - 1)}\u2026`;
 }
-function slotsToRun(slots2) {
-  const uses = [
-    ["review.reviewer1", slots2.reviewer1],
-    ["review.reviewer2", slots2.reviewer2],
-    ["review.synthesis", slots2.synthesis ?? { harness: slots2.reviewer1.harness }]
-  ];
-  const distinct = /* @__PURE__ */ new Map();
-  for (const [key, slot] of uses) {
-    const id = `${slot.harness}:${slot.provider ?? "own"}:${slot.model ?? ""}`;
-    const use = distinct.get(id);
-    if (use) use.keys.push(key);
-    else distinct.set(id, { slot, keys: [key] });
+function text(input, key) {
+  const value = input[key];
+  return typeof value === "string" ? value : void 0;
+}
+function toolSummary(input) {
+  if (!isJson(input)) return "";
+  const pattern = text(input, "pattern");
+  if (pattern) {
+    const scope = text(input, "path");
+    return scope ? `${pattern} in ${scope}` : pattern;
   }
-  return [...distinct.values()];
+  const found = text(input, "file_path") ?? text(input, "path") ?? text(input, "url");
+  if (found) return found;
+  const described = text(input, "command") ?? text(input, "query") ?? text(input, "description");
+  return described ? truncate(described) : "";
+}
+function describeTool(tool, summary) {
+  return summary ? `${tool} ${summary}` : tool;
+}
+function claudeUsage(raw) {
+  return parseUsage(raw, {
+    input: "input_tokens",
+    output: "output_tokens",
+    cacheRead: "cache_read_input_tokens",
+    cacheWrite: "cache_creation_input_tokens"
+  });
+}
+function codexUsage(raw) {
+  const usage = parseUsage(raw, { input: "input_tokens", output: "output_tokens", cacheRead: "cached_input_tokens" });
+  if (usage?.input !== void 0 && usage.cacheRead !== void 0) usage.input = Math.max(0, usage.input - usage.cacheRead);
+  return usage;
+}
+function claudeResult(event) {
+  const usage = claudeUsage(event.usage);
+  if (typeof event.result === "string") return usage ? { kind: "final", text: event.result, usage } : { kind: "final", text: event.result };
+  return usage ? { kind: "usage", usage } : { kind: "ignore" };
+}
+function claudeEvent(event) {
+  if (event.type === "result") return claudeResult(event);
+  if (event.type === "system" && event.subtype === "init" && typeof event.model === "string") return { kind: "model", model: event.model };
+  const content = isJson(event.message) ? event.message.content : void 0;
+  if (event.type !== "assistant" || !Array.isArray(content)) return { kind: "ignore" };
+  const uses = content.filter((block) => isJson(block) && block.type === "tool_use");
+  if (!uses.length) return { kind: "ignore" };
+  return { kind: "activity", text: uses.map((use) => describeTool(text(use, "name") ?? "tool", toolSummary(use.input))).join(", ") };
+}
+function unwrapShell(command) {
+  const wrapped = command.match(/^\/bin\/(?:ba|z)?sh\s+-lc\s+["'](.*)["']\s*$/s);
+  return truncate(wrapped?.[1]?.replace(/\\"/g, '"') ?? command);
+}
+function codexError(event) {
+  if (event.type === "error") return text(event, "message");
+  if (event.type === "turn.failed" && isJson(event.error)) return text(event.error, "message");
+  return void 0;
+}
+function codexEvent(event) {
+  const message = codexError(event);
+  if (message) return { kind: "error", message };
+  const usage = event.type === "turn.completed" ? codexUsage(event.usage) : void 0;
+  if (usage) return { kind: "usage", usage };
+  const item = event.item;
+  if (event.type !== "item.started" || !isJson(item)) return { kind: "ignore" };
+  const command = text(item, "command");
+  if (item.type === "command_execution" && command) return { kind: "activity", text: describeTool("shell", unwrapShell(command)) };
+  return { kind: "ignore" };
+}
+function parseHarnessEvent(harness, line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return { kind: "ignore" };
+  }
+  if (!isJson(event)) return { kind: "ignore" };
+  return harness === "claude" ? claudeEvent(event) : codexEvent(event);
+}
+
+// src/features/review/harness.ts
+var tailLines = 20;
+function harnessArgs({ harness, reviewDir, outputPath, override }) {
+  const extra = override?.args ?? [];
+  if (harness === "codex") return ["exec", "--sandbox", "read-only", "--json", "--output-last-message", outputPath, ...extra, "-"];
+  return [
+    "-p",
+    "--add-dir",
+    reviewDir,
+    "--disallowedTools",
+    "Edit,Write,NotebookEdit",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    ...extra
+  ];
+}
+function windowsQuote(arg) {
+  return /[\s"]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
+}
+function tail(text2) {
+  return text2.trim().split("\n").slice(-tailLines).join("\n");
+}
+function spawnError(harness, error) {
+  if (error.code === "ENOENT") return `${harness} CLI not found on PATH; install it or sign in, then retry`;
+  return `${harness} failed to start: ${error.message}`;
 }
-async function assertViable(slots2, check = checks) {
-  const problems = await Promise.all(slotsToRun(slots2).map((use) => slotProblem(use, check)));
-  const errors = problems.filter((problem) => problem !== void 0);
-  if (errors.length) throw new ReviewError(["Cannot review:", ...errors.map((error) => `- ${error}`)].join("\n"));
+function exitError(harness, code, output) {
+  const detail = tail(output);
+  return [`${harness} exited with code ${code ?? "unknown"}`, ...detail ? [detail] : []].join("\n");
 }
-
-// src/features/review/reviewLog.ts
-import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
-import { join as join4 } from "path";
-function reviewLog(command = process.argv.slice(2), now = () => /* @__PURE__ */ new Date()) {
-  let path;
-  let buffered = [];
-  return {
-    append: (line) => {
-      if (path) appendFileSync(path, `${line}
-`);
-      else buffered.push(line);
-    },
-    attach: (reviewDir) => {
-      mkdirSync3(reviewDir, { recursive: true });
-      path = join4(reviewDir, "review.log");
-      appendFileSync(path, `${["", `=== ${now().toISOString()} ===`, `$ yoke ${command.join(" ")}`, ...buffered].join("\n")}
-`);
-      buffered = [];
-    }
-  };
+function hasReview(path) {
+  return existsSync3(path) && readFileSync3(path, "utf8").trim().length > 0;
 }
-function logged(ui, append) {
-  const both = (show) => (line) => {
-    append(line);
-    show(line);
-  };
-  return {
-    log: both(ui.log),
-    track: (label) => {
-      append(`${label}\u2026`);
-      const status = ui.track(label);
-      return {
-        update: (activity) => {
-          append(`${label}: ${activity}`);
-          status.update(activity);
-        },
-        succeed: both(status.succeed),
-        fail: both(status.fail)
-      };
-    },
-    stop: ui.stop
+var runHarness = (run2) => new Promise((resolve) => {
+  const shell = process.platform === "win32";
+  const args = harnessArgs(run2);
+  const child = spawn(run2.harness, shell ? args.map(windowsQuote) : args, {
+    cwd: run2.cwd,
+    env: { ...process.env, ...run2.override?.env },
+    stdio: ["pipe", "pipe", "pipe"],
+    shell
+  });
+  let pending = "";
+  let finalText = "";
+  let model;
+  let usage;
+  let lastError = "";
+  let stderr = "";
+  const onLine = (line) => {
+    const event = parseHarnessEvent(run2.harness, line);
+    if (event.kind === "activity") run2.onProgress?.(event.text);
+    if (event.kind === "final") {
+      finalText = event.text;
+      if (event.usage) usage = event.usage;
+    }
+    if (event.kind === "usage") usage = addUsage(usage, event.usage);
+    if (event.kind === "model") model = event.model;
+    if (event.kind === "error") lastError = event.message;
   };
-}
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    const lines = (pending + chunk).split("\n");
+    pending = lines.pop() ?? "";
+    lines.forEach(onLine);
+  });
+  child.stderr.on("data", (chunk) => stderr += chunk);
+  child.stdin.on("error", () => {
+  });
+  child.stdin.end(run2.prompt);
+  child.on("error", (error) => resolve({ ok: false, error: spawnError(run2.harness, error) }));
+  child.on("close", (code) => {
+    onLine(pending);
+    if (code !== 0)
+      return resolve({ ok: false, error: exitError(run2.harness, code, [stderr || finalText, lastError].filter(Boolean).join("\n")) });
+    if (run2.harness === "claude") writeFileSync3(run2.outputPath, finalText);
+    if (!hasReview(run2.outputPath)) return resolve({ ok: false, error: `${run2.harness} returned an empty review` });
+    resolve({ ok: true, ...model ? { model } : {}, ...usage ? { usage } : {} });
+  });
+});
+
+// src/features/review/preflight.ts
+import { execFile as execFile2 } from "child_process";
 
 // src/features/review/run.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 
 // src/features/review/cachedSlots.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 function slotsPath(reviewDir) {
-  return join5(reviewDir, "slots.json");
+  return join4(reviewDir, "slots.json");
 }
 function isCachedSlots(value) {
   return typeof value === "object" && value !== null && Object.values(value).every((slot) => typeof slot === "string");
@@ -1500,10 +1599,10 @@ ${files.join("\n")}
 
 // src/features/review/usedModels.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 var repoUrl = "https://github.com/MakerXStudio/yoke";
 function modelsPath(reviewDir) {
-  return join6(reviewDir, "models.json");
+  return join5(reviewDir, "models.json");
 }
 function isUsedModels(value) {
   return typeof value === "object" && value !== null && Object.values(value).every((model) => typeof model === "string");
@@ -1538,6 +1637,17 @@ _Adversarial review by [yoke](${repoUrl})${used.length ? `: ${used.join("; ")}`
 }
 
 // src/features/review/run.ts
+var ReviewFailure = class extends ReviewError {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "ReviewFailure";
+  }
+  reason;
+};
+function stepNames(steps) {
+  return steps.map((step) => step.replace(/(\d)$/, " $1")).join(" and ");
+}
 var reviewers = ["reviewer1", "reviewer2"];
 function seconds(since) {
   return `${Math.round((Date.now() - since) / 1e3)}s`;
@@ -1561,6 +1671,7 @@ async function runStep({ name, label, slot, ...step }, context) {
     status.succeed(`${label} done in ${seconds(started)}`);
     recordUsedModel(context.reviewDir, name, harness, slot.model ?? result.model);
     recordSlot(context.reviewDir, name, describeSlot(slot));
+    if (result.usage) context.usage[name] = result.usage;
     return true;
   }
   status.fail(`${label} failed after ${seconds(started)}: ${result.error}`);
@@ -1578,7 +1689,7 @@ async function runOrReuse(step, context) {
   return { ok: true, ran: false };
 }
 function reviewPath(context, reviewer) {
-  return join7(context.reviewDir, `${reviewer}.md`);
+  return join6(context.reviewDir, `${reviewer}.md`);
 }
 function reviewerLabel(reviewer, context) {
   return `${reviewer} (${describeSlot(context.slots[reviewer])})`;
@@ -1587,7 +1698,7 @@ function withReviewers(result, context) {
   const line = reviewers.map((reviewer) => reviewerLabel(reviewer, context)).join(", ");
   return { ...result, report: `Reviewers: ${line}
 
-${result.report}` };
+${result.report}`, usage: context.usage };
 }
 function synthesisResult(markdown) {
   const synthesis = parseSynthesis(markdown);
@@ -1606,7 +1717,7 @@ function synthesisSlot(succeeded, context) {
 }
 async function synthesise(requestPath, succeeded, reviewersRan, context) {
   const slot = synthesisSlot(succeeded, context);
-  const outputPath = join7(context.reviewDir, "synthesis.md");
+  const outputPath = join6(context.reviewDir, "synthesis.md");
   if (reviewersRan) rmSync(outputPath, { force: true });
   const files = reviewers.map((reviewer) => ({
     reviewer: reviewerLabel(reviewer, context),
@@ -1615,11 +1726,13 @@ async function synthesise(requestPath, succeeded, reviewersRan, context) {
   const prompt = buildSynthesisPrompt(requestPath, files);
   if ((await runOrReuse({ name: "synthesis", label: `synthesis (${describeSlot(slot)})`, slot, prompt, outputPath }, context)).ok)
     return synthesisResult(readFileSync6(outputPath, "utf8"));
+  if (context.strict) throw new ReviewFailure("synthesis failed", "The synthesis failed; nothing to post.");
   context.log("showing the raw reviews instead");
   return rawReviews(succeeded, context);
 }
-async function runReview(request, context) {
-  const requestPath = join7(context.reviewDir, "request.md");
+async function runReview(request, reviewContext) {
+  const context = { ...reviewContext, usage: {} };
+  const requestPath = join6(context.reviewDir, "request.md");
   writeFileSync6(requestPath, request);
   const prompt = buildReviewerPrompt(requestPath);
   const results = await Promise.all(
@@ -1630,7 +1743,10 @@ async function runReview(request, context) {
     })
   );
   const succeeded = reviewers.filter((_, i) => results[i]?.ok);
-  if (!succeeded.length) throw new ReviewError("Every reviewer failed; nothing to report.");
+  const failed = reviewers.filter((reviewer) => !succeeded.includes(reviewer));
+  if (!succeeded.length) throw new ReviewFailure(`${stepNames(failed)} failed`, "Every reviewer failed; nothing to report.");
+  if (context.strict && failed.length)
+    throw new ReviewFailure(`${stepNames(failed)} failed`, `${stepNames(failed)} failed; not synthesising a partial review.`);
   const synthesised = await synthesise(
     requestPath,
     succeeded,
@@ -1640,75 +1756,123 @@ async function runReview(request, context) {
   return withReviewers(synthesised, context);
 }
 
-// src/features/review/status.ts
-import { styleText } from "util";
-import { createLogUpdate } from "log-update";
-async function timed(ui, label, work) {
-  const started = Date.now();
-  const status = ui.track(label);
-  const elapsed = () => `${Math.round((Date.now() - started) / 1e3)}s`;
+// src/features/review/preflight.ts
+var commandTimeout = 3e4;
+var probeTimeout = 6e4;
+var maxBodyChars2 = 300;
+function exec(harness, args) {
+  return new Promise((resolve) => {
+    const options = { encoding: "utf8", timeout: commandTimeout, shell: process.platform === "win32" };
+    execFile2(harness, args, options, (error, stdout) => resolve({ ok: !error, stdout }));
+  });
+}
+async function claudeSignedIn() {
+  const { ok, stdout } = await exec("claude", ["auth", "status", "--json"]);
+  if (!ok) return false;
   try {
-    const result = await work();
-    status.succeed(`${label} (${elapsed()})`);
-    return result;
+    const parsed = JSON.parse(stdout);
+    return typeof parsed === "object" && parsed !== null && "loggedIn" in parsed && parsed.loggedIn === true;
+  } catch {
+    return false;
+  }
+}
+async function reach({ url, headers, body }) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(probeTimeout)
+    });
+    if (response.ok) return void 0;
+    const text2 = (await response.text()).trim().slice(0, maxBodyChars2);
+    return `HTTP ${response.status}${text2 ? `: ${text2}` : ""}`;
   } catch (error) {
-    status.fail(`${label} failed after ${elapsed()}`);
-    throw error;
+    if (!(error instanceof Error)) return String(error);
+    const cause = error.cause instanceof Error ? error.cause.message : "";
+    return cause ? `${error.message} (${cause})` : error.message;
   }
 }
-function lineUi(log, { activity }) {
+var checks = {
+  onPath: async (harness) => (await exec(harness, ["--version"])).ok,
+  signedIn: async (harness) => harness === "claude" ? claudeSignedIn() : (await exec("codex", ["login", "status"])).ok,
+  reach
+};
+var loginCommand = { claude: "claude auth login", codex: "codex login" };
+function signedOut({ slot: { harness }, keys }) {
+  const settings = keys.map((key) => `${key}.provider and ${key}.model`).join(", and ");
+  return `${harness} is not signed in (${keys.join(", ")}); run \`${loginCommand[harness]}\`, or run it through LiteLLM or Foundry by setting ${settings} (see \`yoke models\`)`;
+}
+async function slotProblem(use, check) {
+  const { harness, model, probe } = use.slot;
+  if (!await check.onPath(harness)) return `${harness} CLI not found on PATH; install it`;
+  if (!probe) return await check.signedIn(harness) ? void 0 : signedOut(use);
+  const error = await check.reach(probe);
+  return error && `${harness} model "${model}" at ${probe.url}: ${error}`;
+}
+function slotsToRun(slots2) {
+  const uses = [
+    ["review.reviewer1", slots2.reviewer1],
+    ["review.reviewer2", slots2.reviewer2],
+    ["review.synthesis", slots2.synthesis ?? { harness: slots2.reviewer1.harness }]
+  ];
+  const distinct = /* @__PURE__ */ new Map();
+  for (const [key, slot] of uses) {
+    const id = `${slot.harness}:${slot.provider ?? "own"}:${slot.model ?? ""}`;
+    const use = distinct.get(id);
+    if (use) use.keys.push(key);
+    else distinct.set(id, { slot, keys: [key] });
+  }
+  return [...distinct.values()];
+}
+async function assertViable(slots2, check = checks) {
+  const problems = await Promise.all(slotsToRun(slots2).map((use) => slotProblem(use, check)));
+  const errors = problems.filter((problem) => problem !== void 0);
+  if (errors.length)
+    throw new ReviewFailure("a reviewer could not run", ["Cannot review:", ...errors.map((error) => `- ${error}`)].join("\n"));
+}
+
+// src/features/review/reviewLog.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } from "path";
+function reviewLog(command = process.argv.slice(2), now = () => /* @__PURE__ */ new Date()) {
+  let path;
+  let buffered = [];
   return {
-    log,
-    track: (label) => {
-      log(`${label}\u2026`);
-      const update = (text2) => activity ? log(`${label}: ${text2}`) : void 0;
-      return { update, succeed: log, fail: log };
+    append: (line) => {
+      if (path) appendFileSync2(path, `${line}
+`);
+      else buffered.push(line);
     },
-    stop: () => {
+    attach: (reviewDir) => {
+      mkdirSync3(reviewDir, { recursive: true });
+      path = join7(reviewDir, "review.log");
+      appendFileSync2(path, `${["", `=== ${now().toISOString()} ===`, `$ yoke ${command.join(" ")}`, ...buffered].join("\n")}
+`);
+      buffered = [];
     }
   };
 }
-var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var tickMs = 80;
-function spinnerUi(stream) {
-  const update = createLogUpdate(stream);
-  const running = [];
-  let frame = 0;
-  let timer;
-  const paint = (colour, text2) => styleText(colour, text2, { stream });
-  const render = () => update(running.map((entry) => `${paint("cyan", frames[frame] ?? "")} ${entry.text}`).join("\n"));
-  const persist = (line) => {
-    update.clear();
-    update.persist(line);
-    render();
-  };
-  const settle = (entry, line) => {
-    running.splice(running.indexOf(entry), 1);
-    persist(line);
-    if (running.length || !timer) return;
-    clearInterval(timer);
-    timer = void 0;
+function logged(ui, append) {
+  const both = (show) => (line) => {
+    append(line);
+    show(line);
   };
   return {
-    log: persist,
+    log: both(ui.log),
     track: (label) => {
-      const entry = { label, text: label };
-      running.push(entry);
-      timer ??= setInterval(() => {
-        frame = (frame + 1) % frames.length;
-        render();
-      }, tickMs);
-      render();
+      append(`${label}\u2026`);
+      const status = ui.track(label);
       return {
-        update: (activity) => entry.text = `${label} \u2014 ${activity}`,
-        succeed: (text2) => settle(entry, `${paint("green", "\u2713")} ${text2}`),
-        fail: (text2) => settle(entry, `${paint("red", "\u2717")} ${text2}`)
+        update: (activity) => {
+          append(`${label}: ${activity}`);
+          status.update(activity);
+        },
+        succeed: both(status.succeed),
+        fail: both(status.fail)
       };
     },
-    stop: () => {
-      if (timer) clearInterval(timer);
-      update.done();
-    }
+    stop: ui.stop
   };
 }
 
@@ -1723,12 +1887,12 @@ function prepareRunDir(reviewDir, force) {
   mkdirSync4(reviewDir, { recursive: true });
   if (force) for (const name of cachedOutputs) rmSync2(join8(reviewDir, name), { force: true });
 }
-async function reviewAtHead(pr2, reviewDir, request, slots2, ui) {
+async function reviewAtHead(pr2, reviewDir, request, slots2, ui, strict) {
   const checkoutDir = mkdtempSync(join8(tmpdir(), "yoke-review-"));
   try {
     const checkout = await timed(ui, `checking out ${pr2.headRefOid.slice(0, 7)}`, () => checkoutHead(pr2, checkoutDir));
     try {
-      return await runReview(request, { cwd: checkout.cwd, reviewDir, slots: slots2, runHarness, log: ui.log, track: ui.track });
+      return await runReview(request, { cwd: checkout.cwd, reviewDir, slots: slots2, runHarness, log: ui.log, track: ui.track, strict });
     } finally {
       await checkout.remove();
     }
@@ -1763,24 +1927,40 @@ async function reviewPr(number, settings, { post, force }, io) {
   const reviewDir = reviewRunDir(pr2);
   prepareRunDir(reviewDir, force);
   file.attach(reviewDir);
-  const path = join8(reviewDir, "review.md");
-  let synthesis = savedReview(path, post);
-  if (synthesis) {
-    log(`posting the saved review of #${pr2.number} at ${pr2.headRefOid.slice(0, 7)}`);
-    out(formatSynthesis(synthesis));
-  } else {
+  const ci = post && isCi();
+  const review = async () => {
+    const path = join8(reviewDir, "review.md");
+    const saved = savedReview(path, post);
+    if (saved) {
+      log(`posting the saved review of #${pr2.number} at ${pr2.headRefOid.slice(0, 7)}`);
+      out(formatSynthesis(saved));
+      return { synthesis: saved, usage: {} };
+    }
     await timed(ui, "checking each reviewer can run", () => assertViable(slots2));
     log(`review folder: ${reviewDir}`);
-    const result = await reviewAtHead(pr2, reviewDir, buildRequest(pr2, diff, prior), slots2, ui);
+    const result = await reviewAtHead(pr2, reviewDir, buildRequest(pr2, diff, prior), slots2, ui, ci);
     out(result.report);
-    synthesis = result.synthesis;
     saveReview(path, result.markdown);
+    if (post && !result.synthesis)
+      throw new ReviewFailure(
+        "the synthesis could not be parsed",
+        "Not posting: the synthesis did not produce findings in the expected format."
+      );
+    return result;
+  };
+  const footer = () => modelsFooter(readUsedModels(reviewDir));
+  let findings;
+  try {
+    const { synthesis: synthesis2, usage } = await review();
+    findings = synthesis2;
+    if (ci && synthesis2) writeJobSummary(synthesis2.summary, usage, log);
+  } catch (error) {
+    if (ci && error instanceof ReviewFailure) await reportFailure(pr2, error.reason, ui, { api: github, log, footer: footer() });
+    throw error;
   }
-  if (!post) return;
-  if (!synthesis) throw new ReviewError("Not posting: the synthesis did not produce findings in the expected format.");
-  const findings = synthesis;
-  const footer = modelsFooter(readUsedModels(reviewDir));
-  await timed(ui, `posting to #${pr2.number}`, () => postFindings(pr2, findings, diff, prior, { api: github, log, footer }));
+  if (!post || !findings) return;
+  const synthesis = findings;
+  await timed(ui, `posting to #${pr2.number}`, () => postFindings(pr2, synthesis, diff, prior, { api: github, log, footer: footer(), ci }));
 }
 
 // src/features/sync/sync.ts
@@ -1822,6 +2002,7 @@ var reviewCiSkill = {
   name: "review-ci",
   description: "Add yoke's adversarial PR review workflow to this repo and set the secrets it needs.",
   disableModelInvocation: true,
+  userLevel: true,
   body: `
 Run \`yoke review-ci $ARGUMENTS\`. If it reports that a model is required, run \`yoke models\` to list what the provider serves, ask the user which model each reviewer should run, and rerun with \`--reviewer-1-model\` and \`--reviewer-2-model\`. If it reports the workflow already exists and differs, show the user the difference and ask before rerunning with \`--force\`.
 
@@ -1857,10 +2038,10 @@ function skillsRoot(user, cwd = process.cwd(), home = homedir3()) {
 function isOwnedByUser(skillFile) {
   return existsSync8(skillFile) && !readFileSync8(skillFile, "utf8").includes(ownerMarker);
 }
-function syncSkills(destination, skills = bundledSkills) {
+function syncSkills(destination, userDestination, skills = bundledSkills) {
   const result = { written: [], skipped: [] };
   for (const skill of skills) {
-    const target = join9(destination, skill.name);
+    const target = join9(skill.userLevel ? userDestination : destination, skill.name);
     const skillFile = join9(target, "SKILL.md");
     if (isOwnedByUser(skillFile)) {
       result.skipped.push(target);
@@ -1878,8 +2059,9 @@ var { version } = package_default;
 var program = new Command("yoke").description("Lean Claude Code skills and the CLI they call.").version(version);
 program.command("sync").description("Write yoke's skills into this repo's .claude/skills, or ~/.claude/skills with --user").option("--user", "write to ~/.claude/skills instead, for every repo").action((options) => {
   const user = options.user ?? false;
-  const display = (path) => user ? path : relative(process.cwd(), path);
-  const { written, skipped } = syncSkills(skillsRoot(user));
+  const cwd = process.cwd();
+  const display = (path) => path.startsWith(cwd) ? relative(cwd, path) : path;
+  const { written, skipped } = syncSkills(skillsRoot(user), skillsRoot(true));
   for (const file of written) console.log(`wrote ${display(file)}`);
   for (const dir of skipped) console.log(`skipped ${display(dir)} (your own skill; delete it to take yoke's)`);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makerx/yoke",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Lean, user-invoked Claude Code skills for MakerX AI-assisted delivery, plus the CLI they call.",
   "license": "MIT",
   "author": "MakerX",