fapony 0.7.0 → 0.7.1

package/src/fael.ts

@@ -0,0 +1,139 @@
+// src/fael.ts — read the repo's memory from fael (`fael find --json --all`).
+//
+// Memory moved to fael 2026-09-25; .fapony/.memory is frozen (imported into
+// .fael/). fapony only reads, never writes, and speaks MemRow internally, so
+// the fael row shape is translated here and nowhere else:
+//   by → agent · kind "issue" → "bug" · a close — inline `closed` (compacted
+//   rows) or a kindless row with `ref` (close file) — → a kind:"close" row
+//   with ref = the closed row's id (the old tombstone shape).
+// Close-file rows reach here from fael 0.0.5 on; 0.0.4 printed only inline
+// `closed`, so a native `fael close` read as open.
+
+/** fapony's internal row shape — what every reader downstream consumes. */
+export interface MemRow {
+  ts: string;
+  agent: string;
+  kind: string;
+  text: string;
+  spec?: string;
+  id?: string;
+  /** On a kind:"close" row: the id of the row it closes. */
+  ref?: string;
+  files?: string[];
+  key?: string;
+}
+
+interface FaelRow {
+  id: string;
+  ts: string;
+  by: string;
+  kind: string;
+  text: string;
+  files?: string[];
+  spec?: string;
+  key?: string;
+  ref?: string;
+  closed?: { id: string; ts: string; by: string; text: string };
+}
+
+export interface FaelRead {
+  rows: MemRow[];
+  /** false = fael missing or failed — "no memory", not "no match". */
+  ok: boolean;
+  skipped: number;
+}
+
+/** fael `--json` lines → MemRows (+ close rows), newest first, ts ≥ sinceIso. */
+export function faelLinesToMemRows(
+  stdout: string,
+  sinceIso?: string,
+): { rows: MemRow[]; skipped: number } {
+  const rows: MemRow[] = [];
+  let skipped = 0;
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    let r: FaelRow;
+    try {
+      r = JSON.parse(line) as FaelRow;
+    } catch {
+      skipped++;
+      continue;
+    }
+    // Close row (docs/format.md: no kind, `ref` names the closed row).
+    if (!r.kind && r.ref) {
+      rows.push({
+        ts: r.ts,
+        agent: r.by,
+        kind: "close",
+        text: r.text,
+        id: r.id,
+        ref: r.ref,
+      });
+      continue;
+    }
+    rows.push({
+      ts: r.ts,
+      agent: r.by,
+      kind: r.kind === "issue" ? "bug" : r.kind,
+      text: r.text,
+      id: r.id,
+      ...(r.files ? { files: r.files } : {}),
+      ...(r.spec ? { spec: r.spec } : {}),
+      ...(r.key ? { key: r.key } : {}),
+    });
+    if (r.closed) {
+      rows.push({
+        ts: r.closed.ts,
+        agent: r.closed.by,
+        kind: "close",
+        text: r.closed.text,
+        id: r.closed.id,
+        ref: r.id,
+      });
+    }
+  }
+  const kept = sinceIso ? rows.filter((r) => r.ts >= sinceIso) : rows;
+  kept.sort((a, b) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0));
+  return { rows: kept, skipped };
+}
+
+/** Every row fael sees from `worktree` — or, with `openOnly`, only the rows
+ *  fael itself counts as open (not closed, not superseded). Never throws. */
+export function readFaelLog(
+  worktree: string,
+  sinceIso?: string,
+  openOnly = false,
+): FaelRead {
+  const argv = ["fael", "find", "--json", ...(openOnly ? [] : ["--all"])];
+  try {
+    const p = Bun.spawnSync(argv, {
+      cwd: worktree,
+      env: process.env, // resolve `fael` on the live PATH, not the startup one
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (p.exitCode !== 0) return { rows: [], ok: false, skipped: 0 };
+    return { ...faelLinesToMemRows(p.stdout.toString(), sinceIso), ok: true };
+  } catch {
+    // fael not on PATH
+    return { rows: [], ok: false, skipped: 0 };
+  }
+}
+
+/** Newest decisions, keyword hits first when any match. */
+export function recentDecisions(
+  rows: MemRow[],
+  limit: number,
+  keywords: string[] = [],
+): MemRow[] {
+  const decisions = rows.filter((r) => r.kind === "decision");
+  const kws = keywords.map((k) => k.toLowerCase()).filter(Boolean);
+  if (kws.length > 0) {
+    const hits = decisions.filter((r) => {
+      const hay = `${r.text}\n${r.spec ?? ""}`.toLowerCase();
+      return kws.some((k) => hay.includes(k));
+    });
+    if (hits.length > 0) return hits.slice(0, limit);
+  }
+  return decisions.slice(0, limit);
+}

package/src/hook.ts

@@ -5,84 +5,4 @@
 // src/digest/collect.ts, and the generated OpenCode plugin all import
 // from this path.
 
-export {
-  BUG_MARKERS,
-  bugDedupeKey,
-  bugSignalFromTranscript,
-  COMMIT_HINT_MIN_COMMITS,
-  type CommitHintInput,
-  type ContextLineData,
-  capContext,
-  cmdHookEditHint,
-  cmdHookMvGuard,
-  cmdHookReadHint,
-  cmdHookSessionStart,
-  cmdHookStop,
-  commitHintFor,
-  computeHintImpact,
-  countTicks,
-  cursorTranscriptPath,
-  decideHandoff,
-  decideStop,
-  type EditHintInput,
-  type EditTrackRow,
-  editHintFor,
-  editTrackPath,
-  fileAtRevision,
-  GIT_AUTONOMY_COMMIT_POLICY,
-  GIT_AUTONOMY_PLUGIN_FILE,
-  GIT_AUTONOMY_PLUGIN_NAME,
-  GIT_AUTONOMY_SYSTEM_REWRITES,
-  GIT_AUTONOMY_TOOL_POLICY,
-  GIT_AUTONOMY_TOOL_REWRITES,
-  type GitAutonomyRewrite,
-  type GitAutonomyStatus,
-  type GitAutonomyToolRewrite,
-  gitAutonomyStatus,
-  type HandoffDecision,
-  type HandoffPlanFile,
-  type HintFireRow,
-  type HintImpact,
-  handoffBaseSha,
-  handoffBlockMessage,
-  handoffDedupeKey,
-  hasBugMarker,
-  hasHandoffLiteral,
-  hintLogDir,
-  hintLogPath,
-  hookTsMs,
-  isBugfixCommit,
-  isCodexPayload,
-  isCursorPayload,
-  isPlanPath,
-  memHasHandoffForPlan,
-  mergeStopReasons,
-  mvGuardDecision,
-  type NormalizedStopInput,
-  normalizeStopInput,
-  type RawStopPayload,
-  READ_HINT_MIN_BYTES,
-  READ_HINT_MIN_LIMIT,
-  type ReadHintInput,
-  type ReadTrackRow,
-  type RereadHintInput,
-  readContextData,
-  readContextLines,
-  readHintFor,
-  readTrackPath,
-  recordHintFire,
-  rereadHintFor,
-  rewriteGitAutonomySystem,
-  rewriteGitAutonomyTool,
-  SESSION_START_MAX_CHARS,
-  type StopClient,
-  sessionKey,
-  sessionPlanFiles,
-  sessionStartContext,
-  stopBlockedBefore,
-  stopBlockPath,
-  stopBlockSurface,
-  stopOutput,
-  utcStamp,
-  worktreeKey,
-} from "./adapters/hooks/index.js";
+export * from "./adapters/hooks/index.js";

package/src/init.ts

@@ -1,5 +1,6 @@
 // src/init.ts — scaffold fapony project structure at a target path.
-// Creates .fapony/plan/, .fapony/done/, .fapony/spec/, .fapony/.memory/ (from template).
+// Creates .fapony/plan/, .fapony/done/, .fapony/spec/ + evidence.json. Memory
+// (decisions, bugs, notes) is fael's — `fael install`, not scaffolded here.
 // state.db stays in ~/.config/fapony/ by design (security boundary — see db.ts),
 // never inside the worktree where agents have full write access.
 
@@ -19,18 +20,18 @@ import {
   doneDir,
   evidenceFile,
   FAPONY_DIR,
-  memoryDir,
   planDir,
   specDir,
 } from "./core/config.js";
 import { isAffirmative } from "./util.js";
 
-const FAPONY_README = `# .fapony/ — fapony project dir (plans, specs, memory)
+const FAPONY_README = `# .fapony/ — fapony project dir (plans, specs, conventions)
 # plan/ holds live plans, done/ the shipped ones, spec/ every spec (specs are a
 # reference library — they are not archived). done/ sits beside plan/ rather
 # than inside it so archiving never changes a file's depth, and the relative
 # links inside it keep working.
-# memory lives in .fapony/.memory/, the evidence allowlist in .fapony/evidence.json.
+# memory (decisions, bugs, notes) lives in fael; the evidence allowlist is
+# .fapony/evidence.json.
 #
 # evidence.json SHOULD be committed — it is the shared allowlist that decides
 # which commands 'fapony report' may run, and the team must run the same
@@ -44,7 +45,7 @@ const FAPONY_README = `# .fapony/ — fapony project dir (plans, specs, memory)
 # running in this worktree cannot rewrite run state / audit trail.
 #
 # Ask your agent for the plan picture instead of listing these by hand:
-#   run "fapony mem kickoff" — priority plans, the first unchecked chunk, open bugs
+#   run "fapony plan" — every active plan, its progress and next chunk
 `;
 
 // Static template — deliberately NOT derived from the repo (reading package.json
@@ -59,59 +60,30 @@ const EVIDENCE_JSON = `{
 }
 `;
 
-// Rules snippet for the user's own agent-rules file. Nothing writes
-// log.<person>.jsonl on its own — an agent does, because the rules file it already
-// reads says to. That file is the user's, so init asks before writing it (rule 6c)
-// and never writes it twice (RULES_MARKER). Not in SERVER_INSTRUCTIONS either: that
-// reaches every MCP session of every user, and most of them never ran `fapony init`
-// — it would tell them to run a command that does not exist.
-const RULES_MARKER = "## Memory: .fapony/.memory";
-const RULES_SNIPPET = () => `${RULES_MARKER}/log.<you>.jsonl (append-only)
+// Rules snippet for the user's own agent-rules file: how to run a plan chunk
+// by chunk. The file is the user's, so init asks before writing it (rule 6c)
+// and never writes it twice (RULES_MARKER). Memory rules are fael's own skill.
+const RULES_MARKER = "## Plans: .fapony/plan (fapony)";
+const RULES_SNIPPET = () => `${RULES_MARKER}
 
-The log is this project's shared brain — it lives in git, so anyone who clones the
-repo gets every decision, bug and note with it. The filename comes from
-\`git config user.name\` — one file per person, and \`*.jsonl merge=union\` in
-.gitattributes keeps both sides when two people end up sharing a name anyway.
-
-Log as you work — do not wait to be asked. Nothing writes it for you. With the
-fapony MCP server connected, call mem_add / mem_find / mem_close directly;
-otherwise the CLI:
-
-    fapony mem kickoff <plan.md>      # start a session with this
-    fapony mem add decision "what was locked, and why" --files src/x.ts
-    fapony mem add bug "what is broken" --files src/x.ts
-    fapony mem add note "state the next session needs" --files src/x.ts
-    fapony mem close <id> "fixed in <sha>"
-    fapony mem find "<text>"
-
-What goes in — would someone cloning this repo tomorrow need it, and can they not
-find it anywhere else?
-- bug — something broken, even when found mid-task on something else: add it now,
-  not at the end. Once fixed, close it — only close closes a bug.
-- decision — something agreed or locked that git and the plan do not say, with why.
-- note — state the next session needs (where a chunk stopped, what is half-done).
-Before ending a turn that committed work: at least one row about it.
-
-Write each entry standalone — it is read months later with no chat to refer to.
---files is required: rows that name no file cannot be recalled when that file is
-touched later (add refuses without it).
-
-## Executing a plan chunk-by-chunk
+Plans live in .fapony/plan/ (shipped ones in .fapony/done/). Memory — decisions,
+bugs, notes — lives in fael (\`fael add\` / \`fael find\`), not in .fapony/.
 
 A long plan run in one unbroken session accumulates context with nothing to shrink
 it — token cost and coherence both degrade with session length, not with amount of
 work done. Cut at chunk boundaries instead:
 
 Finish a chunk, before starting the next:
-1. Tick its checkbox + stamp the TL;DR in the plan file
+1. Tick its checkbox + stamp the TL;DR, citing the commit sha
 2. Commit — separate from other chunks
-3. \`fapony mem add note "what the next chunk needs" --files f1,f2 <path/to/PLAN-x.md>\`
-   — use the same plan path every time
+3. \`fael add note "what the next chunk needs" --files f1,f2,<path/to/PLAN-x.md>\`
+   — the plan path in --files is what finds the note again
 4. Stop. Do not continue to the next chunk in the same session unless told to.
 
-Next chunk, new session — open with \`fapony mem kickoff <path/to/PLAN-x.md>\` instead
-of carrying the old transcript forward. kickoff already filters to the rows for that plan,
-and takes just the filename (\`kickoff PLAN-x.md\`) when you do not want to type the path.`;
+Next chunk, new session — open with \`fapony plan PLAN-x.md\` (unchecked chunks +
+the notes left for it) instead of carrying the old transcript forward.
+\`fapony plan\` alone lists every active plan; ship one with
+\`fapony plan sweep PLAN-x.md --apply\` (moves it to done/, fixes the links).`;
 
 export function initProject(targetPath: string, config?: Config): void {
   // Create target root
@@ -127,22 +99,6 @@ export function initProject(targetPath: string, config?: Config): void {
   mkdirSync(faponyDir, { recursive: true });
   writeFileSync(join(faponyDir, "README"), FAPONY_README);
 
-  // --- .gitattributes: union-merge the append-only logs ---
-  //
-  // Every row is one person's append, so both sides of a "conflict" are always
-  // right. Without the line, two people whose git user.name collides (admin /
-  // user / owner — what a fresh OS install offers) resolve a conflict by hand
-  // on every pull. Appended, never rewritten: the file is the repo's, not ours.
-  const attrs = join(targetPath, ".gitattributes");
-  const attrsBody = existsSync(attrs) ? readFileSync(attrs, "utf-8") : "";
-  if (!/^\s*\*\.jsonl\s+merge=union\s*$/m.test(attrsBody)) {
-    appendFileSync(
-      attrs,
-      `${attrsBody && !attrsBody.endsWith("\n") ? "\n" : ""}# append-only memory logs: keep both sides, never hand-resolve\n*.jsonl merge=union\n`,
-    );
-    console.log(`  + ${attrs} — *.jsonl merge=union`);
-  }
-
   // --- evidence.json (verification_report allowlist — see src/mcp/evidence.ts) ---
   const evidencePath = join(targetPath, evidenceFile(config));
   if (existsSync(evidencePath)) {
@@ -151,7 +107,7 @@ export function initProject(targetPath: string, config?: Config): void {
   mkdirSync(dirname(evidencePath), { recursive: true });
   writeFileSync(evidencePath, EVIDENCE_JSON);
 
-  // --- plan/ spec/ .memory/ — all under .fapony/ ---
+  // --- plan/ spec/ — all under .fapony/ ---
   const planDirAbs = join(targetPath, planDir());
   if (existsSync(planDirAbs)) {
     throw new Error(`${planDirAbs} already exists — not overwriting.`);
@@ -172,33 +128,17 @@ export function initProject(targetPath: string, config?: Config): void {
   }
   mkdirSync(specDirAbs, { recursive: true });
 
-  // --- .fapony/.memory/ (empty dir — mem commands are built into fapony now) ---
-  const memoryDirPath = join(targetPath, memoryDir(config));
-  if (existsSync(memoryDirPath)) {
-    console.log(`  ${relative(targetPath, memoryDirPath)}/ — already exists`);
-  } else {
-    mkdirSync(memoryDirPath, { recursive: true });
-    console.log(
-      `  ${relative(targetPath, memoryDirPath)}/ — mem commands are built into fapony (fapony mem ...)`,
-    );
-  }
-
   console.log(`scaffolded ${targetPath}/`);
-  console.log(
-    `  .fapony/         — project dir (plans, specs, memory, evidence)`,
-  );
+  console.log(`  .fapony/         — project dir (plans, specs, evidence)`);
   console.log(`  ${planDir()}/    — live plan files`);
   console.log(`  ${doneDir(config)}/    — shipped plans (archive)`);
   console.log(`  ${specDir()}/    — spec files`);
   console.log(
     `  ${evidenceFile(config)}    — allowlist for 'fapony report' (edit the cmds!)`,
   );
-  console.log(
-    `  ${relative(targetPath, memoryDirPath)}/ — mem commands are built into fapony (fapony mem ...)`,
-  );
   console.log(`\nNext: add "${targetPath}" to fapony.config.json worktrees`);
   console.log(
-    `\nThe memory log only fills up if the rules your agent already reads tell it\nto write — these go into CLAUDE.md / AGENTS.md next:\n`,
+    `\nPlans are only run chunk by chunk if the rules your agent already reads say\nso — these go into CLAUDE.md / AGENTS.md next:\n`,
   );
   console.log(RULES_SNIPPET());
 }
@@ -235,7 +175,7 @@ export function rulesTargets(targetPath: string): {
 }
 
 /**
- * Write the memory rules into the agent-rules files. No file yet = AGENTS.md
+ * Write the plan rules into the agent-rules files. No file yet = AGENTS.md
  * (read by OpenCode/Codex/Cursor) + a CLAUDE.md that imports it, so the rules
  * exist once. Files that already carry the rules are left alone.
  */
@@ -244,7 +184,7 @@ export function writeRules(targetPath: string): void {
   if (create) {
     writeFileSync(join(targetPath, "AGENTS.md"), `${RULES_SNIPPET()}\n`);
     writeFileSync(join(targetPath, "CLAUDE.md"), "@AGENTS.md\n");
-    console.log("  + AGENTS.md (memory rules) · CLAUDE.md → @AGENTS.md");
+    console.log("  + AGENTS.md (plan rules) · CLAUDE.md → @AGENTS.md");
     return;
   }
   for (const f of append) {
@@ -253,7 +193,7 @@ export function writeRules(targetPath: string): void {
       f,
       `${body.endsWith("\n") ? "\n" : "\n\n"}${RULES_SNIPPET()}\n`,
     );
-    console.log(`  appended memory rules to ${relative(targetPath, f)}`);
+    console.log(`  appended plan rules to ${relative(targetPath, f)}`);
   }
 }
 
@@ -264,7 +204,7 @@ export async function cmdInit(args: string[]): Promise<void> {
   if (!targetPath) {
     console.error("usage: fapony init <path> [--rules] [--yes]");
     console.error(
-      "  --rules  only write the memory rules into CLAUDE.md / AGENTS.md (repo already set up)",
+      "  --rules  only write the plan rules into CLAUDE.md / AGENTS.md (repo already set up)",
     );
     console.error("  --yes    write them without asking");
     process.exit(1);
@@ -298,13 +238,13 @@ export async function cmdInit(args: string[]): Promise<void> {
 
   const { create, append } = rulesTargets(targetPath);
   if (!create && append.length === 0) {
-    console.log("  memory rules already in the agent-rules file");
+    console.log("  plan rules already in the agent-rules file");
     return;
   }
   if (!yes) {
     const what = create
-      ? "Create AGENTS.md with the memory-logging rules (+ CLAUDE.md → @AGENTS.md)"
-      : `Append the memory-logging rules to ${append.map((f) => relative(targetPath, f)).join(" and ")}`;
+      ? "Create AGENTS.md with the plan rules (+ CLAUDE.md → @AGENTS.md)"
+      : `Append the plan rules to ${append.map((f) => relative(targetPath, f)).join(" and ")}`;
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout,

package/src/install/antigravity.ts

@@ -1,21 +1,14 @@
 // src/install/antigravity.ts — Google Antigravity install provider
 //
-// Writes mcpServers.fapony to ~/.gemini/config/mcp_config.json (Antigravity's
-// global MCP config) and symlinks skills into ~/.agents/skills/ (Progressive
-// Skills path). No hooks in the first phase — Antigravity's hook surface is
-// still evolving.
+// Symlinks skills into ~/.agents/skills/ (Progressive Skills path). Memory
+// moved to fael.
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultCheckCmd } from "../setup.js";
 import { agentsSkillsDir, linkSkills, reportSkills } from "./skills.js";
-import {
-  CURSOR_MCP_ENTRY,
-  defaultExit,
-  type InstallDeps,
-  MCP_KEY,
-} from "./types.js";
+import { defaultExit, type InstallDeps } from "./types.js";
 
 /** ~/.gemini — created on first Antigravity launch. */
 export function findGeminiDir(getHome: () => string): string | null {
@@ -23,103 +16,19 @@ export function findGeminiDir(getHome: () => string): string | null {
   return existsSync(dir) ? dir : null;
 }
 
-function isFaponyEntry(entry: unknown): boolean {
-  if (!entry || typeof entry !== "object") return false;
-  const cfg = entry as Record<string, unknown>;
-  return (
-    cfg.command === CURSOR_MCP_ENTRY.command &&
-    JSON.stringify(cfg.args) === JSON.stringify(CURSOR_MCP_ENTRY.args)
-  );
-}
-
-function readJsonObject(path: string): Record<string, unknown> | null {
-  try {
-    const raw = readFileSync(path, "utf-8").trim();
-    if (!raw) return {};
-    const parsed: unknown = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return null;
-    }
-    return parsed as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
 export function cmdInstallAntigravity(
   dryRun: boolean,
   deps: InstallDeps = {},
 ): void {
-  const exitFn = deps.exit ?? defaultExit;
   const getHome = deps.homedir ?? homedir;
   const checkCmd = deps.checkCmd ?? defaultCheckCmd;
-  let geminiDir = findGeminiDir(getHome);
-
-  if (!geminiDir) {
-    // Detect signal #2: the `agy` CLI on PATH — installed but never launched,
-    // so ~/.gemini doesn't exist yet; the write path below creates it.
-    if (!checkCmd("agy")) {
-      console.error(
-        `Antigravity not found — open Antigravity at least once to create ~/.gemini (or put the agy CLI on PATH)`,
-      );
-      exitFn(1);
-      return;
-    }
-    geminiDir = join(getHome(), ".gemini");
-  }
-
-  // --- 1. MCP server (mcpServers.fapony in ~/.gemini/config/mcp_config.json) ---
-  const configDir = join(geminiDir, "config");
-  const mcpPath = join(configDir, "mcp_config.json");
-  let mcp: Record<string, unknown> = {};
-  let mcpIsNew = true;
-  if (existsSync(mcpPath)) {
-    const parsed = readJsonObject(mcpPath);
-    if (!parsed) {
-      console.error(`failed to parse ${mcpPath} — fix or remove it first`);
-      exitFn(1);
-      return;
-    }
-    mcp = parsed;
-    mcpIsNew = false;
-  }
-  const servers = (mcp.mcpServers ?? {}) as Record<string, unknown>;
-  const existing = servers[MCP_KEY];
-  if (existing !== undefined && !isFaponyEntry(existing)) {
+  if (!findGeminiDir(getHome) && !checkCmd("agy")) {
     console.error(
-      `an MCP server named "${MCP_KEY}" exists but points elsewhere — not overwriting.`,
+      `Antigravity not found — open Antigravity at least once to create ~/.gemini (or put the agy CLI on PATH)`,
     );
-    console.error(`  inspect ${mcpPath} and remove it first`);
-    exitFn(1);
+    (deps.exit ?? defaultExit)(1);
     return;
   }
-  if (existing !== undefined) {
-    console.error(
-      `✓ mcpServers.${MCP_KEY} already configured — no change needed`,
-    );
-    console.error(`  (${mcpPath})`);
-  } else {
-    const after = {
-      ...mcp,
-      mcpServers: { ...servers, [MCP_KEY]: CURSOR_MCP_ENTRY },
-    };
-    if (dryRun) {
-      console.error(
-        `── dry-run: would ${mcpIsNew ? "create" : "write"} ${mcpPath}${mcpIsNew ? "" : ` (mcpServers.${MCP_KEY})`} ──`,
-      );
-    } else {
-      // Escape hatch (plan §5): ~/.gemini/config may not exist yet — either
-      // the app never got as far as its config dir, or agy-on-PATH created
-      // nothing. Recursive mkdir is idempotent and non-destructive.
-      mkdirSync(configDir, { recursive: true });
-      writeFileSync(mcpPath, `${JSON.stringify(after, null, 2)}\n`, "utf-8");
-      console.error(`✓ added mcpServers.${MCP_KEY} to ${mcpPath}`);
-      console.error(`  restart Antigravity to load the MCP server`);
-    }
-  }
-
-  // --- 2. Skills (~/.agents/skills/) ---
   const skillsDir = agentsSkillsDir(getHome);
-  const results = linkSkills(skillsDir, dryRun);
-  reportSkills(results, skillsDir, dryRun);
+  reportSkills(linkSkills(skillsDir, dryRun), skillsDir, dryRun);
 }