fapony 0.6.2 → 0.7.1

package/src/install/zcode.ts

@@ -1,19 +1,12 @@
 // src/install/zcode.ts — ZCode install provider
 //
-// Reads/writes ~/.zcode/cli/config.json (fallback ~/.agents/mcp.json) directly.
-// ZCode has no `zcode mcp add` CLI.
+// Symlinks skills into ~/.agents/skills/. Memory moved to fael.
 
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { agentsSkillsDir, linkSkills, reportSkills } from "./skills.js";
-import {
-  defaultExit,
-  type InstallDeps,
-  MCP_KEY,
-  ZCODE_MCP_CONFIG,
-} from "./types.js";
-import { computeDiff } from "./utils.js";
+import { defaultExit, type InstallDeps } from "./types.js";
 
 /** Resolve the active ZCode config file. Primary: ~/.zcode/cli/config.json.
  *  Fallback: ~/.agents/mcp.json (only when primary is absent). */
@@ -27,94 +20,15 @@ export function findZcodeConfig(
   return null;
 }
 
-function getZcodeServers(
-  cfg: Record<string, unknown>,
-  key: "mcp.servers" | "mcpServers",
-): Record<string, unknown> | undefined {
-  if (key === "mcpServers") {
-    return cfg.mcpServers as Record<string, unknown> | undefined;
-  }
-  const mcp = cfg.mcp as Record<string, unknown> | undefined;
-  return mcp?.servers as Record<string, unknown> | undefined;
-}
-
-function setZcodeServers(
-  cfg: Record<string, unknown>,
-  key: "mcp.servers" | "mcpServers",
-  servers: Record<string, unknown>,
-): Record<string, unknown> {
-  if (key === "mcpServers") {
-    return { ...cfg, mcpServers: servers };
-  }
-  const mcp = (cfg.mcp as Record<string, unknown>) ?? {};
-  return { ...cfg, mcp: { ...mcp, servers } };
-}
-
-function isZcodeConfigured(
-  servers: Record<string, unknown> | undefined,
-): boolean {
-  if (!servers) return false;
-  const entry = servers[MCP_KEY];
-  if (!entry || typeof entry !== "object") return false;
-  const cfg = entry as Record<string, unknown>;
-  if (cfg.type !== "stdio" && cfg.type !== undefined) return false;
-  if (cfg.command !== ZCODE_MCP_CONFIG.command) return false;
-  if (!Array.isArray(cfg.args)) return false;
-  return JSON.stringify(cfg.args) === JSON.stringify(ZCODE_MCP_CONFIG.args);
-}
-
 export function cmdInstallZcode(dryRun: boolean, deps: InstallDeps = {}): void {
-  const exitFn = deps.exit ?? defaultExit;
   const getHome = deps.homedir ?? homedir;
-
-  const found = findZcodeConfig(getHome);
-  if (!found) {
+  if (!findZcodeConfig(getHome)) {
     console.error(
       `ZCode config not found — open ZCode at least once to create ~/.zcode/cli/config.json`,
     );
-    exitFn(1);
+    (deps.exit ?? defaultExit)(1);
     return;
   }
-
-  let before: Record<string, unknown>;
-  try {
-    before = JSON.parse(readFileSync(found.path, "utf-8")) as Record<
-      string,
-      unknown
-    >;
-  } catch (e) {
-    console.error(`failed to parse ${found.path}: ${(e as Error).message}`);
-    exitFn(1);
-    return;
-  }
-
-  const servers = getZcodeServers(before, found.key) ?? {};
-  if (isZcodeConfigured(servers)) {
-    console.error(`✓ mcp.${MCP_KEY} already configured — no change needed`);
-    console.error(`  (${found.path})`);
-    const skillsDir = agentsSkillsDir(getHome);
-    reportSkills(linkSkills(skillsDir, dryRun), skillsDir, dryRun);
-    return;
-  }
-
-  const after = setZcodeServers(before, found.key, {
-    ...servers,
-    [MCP_KEY]: ZCODE_MCP_CONFIG,
-  });
-
-  if (dryRun) {
-    console.error(`── dry-run: would write ${found.key}.${MCP_KEY} ──`);
-    console.error(`  (${found.path})`);
-    console.log(computeDiff(before, after));
-    return;
-  }
-
-  writeFileSync(found.path, `${JSON.stringify(after, null, 2)}\n`);
-  console.error(`✓ added mcp.${MCP_KEY} to ${found.path}`);
-  if (found.key === "mcpServers") {
-    console.error(`  (fallback path: ~/.agents/mcp.json)`);
-  }
-  console.error(`  restart ZCode to load the MCP server`);
   const skillsDir = agentsSkillsDir(getHome);
   reportSkills(linkSkills(skillsDir, dryRun), skillsDir, dryRun);
 }

package/src/install.ts

@@ -1,21 +1,13 @@
-// src/install.ts — `fapony install --platform antigravity|agy|opencode|claude|cursor|zcode|codex` command.
-// opencode: adds mcp.fapony config to ~/.config/opencode/opencode.json or opencode.jsonc.
-// claude: shells out to `claude mcp add` (never parses/writes ~/.claude.json directly).
-// cursor: writes mcpServers.fapony to ~/.cursor/mcp.json directly and merges the
-//         fapony stop hook into the stop array in ~/.cursor/hooks.json.
-// zcode: reads/writes ~/.zcode/cli/config.json (fallback ~/.agents/mcp.json) directly,
-//        and symlinks skills into ~/.agents/skills.
-// codex: reads/writes ~/.codex/config.toml directly.
+// src/install.ts — `fapony install --platform antigravity|agy|opencode|claude|zcode|codex` command.
+// Every platform gets skill/<name>/ symlinked (claude/opencode → ~/.claude/skills,
+// zcode/codex/antigravity → ~/.agents/skills). claude also gets the plan-mv
+// guard. Memory — MCP, Stop, SessionStart — moved to fael (`fael install`).
 // All platforms are idempotent + support --dry-run.
-// Claude/OpenCode also get skill/<name>/ symlinked into ~/.claude/skills so
-// `fapony update` reaches them without a second copy to keep in sync.
-// ZCode gets skill/<name>/ symlinked into ~/.agents/skills.
 
 import { createInterface } from "node:readline";
 import { cmdInstallAntigravity } from "./install/antigravity.js";
 import { cmdInstallClaude } from "./install/claude.js";
 import { cmdInstallCodex } from "./install/codex.js";
-import { cmdInstallCursor } from "./install/cursor.js";
 import { detectClients } from "./install/detect.js";
 import { cmdInstallOpencode } from "./install/opencode.js";
 import { defaultExit, type InstallDeps } from "./install/types.js";
@@ -24,24 +16,14 @@ import { ask } from "./setup.js";
 import { isAffirmative } from "./util.js";
 
 export { cmdInstallAntigravity } from "./install/antigravity.js";
-export {
-  claudeAddArgs,
-  claudeGetArgs,
-  claudeGetPointsToFapony,
-  cmdInstallClaude,
-} from "./install/claude.js";
-export { cmdInstallCodex, findCodexHooksJson } from "./install/codex.js";
-export { cmdInstallCursor } from "./install/cursor.js";
+export { cmdInstallClaude } from "./install/claude.js";
+export { cmdInstallCodex } from "./install/codex.js";
 export { detectClients } from "./install/detect.js";
 export {
   cmdInstallOpencode,
-  commitHintPluginSource,
-  editHintPluginSource,
   gitAutonomyPluginSource,
   type OpencodeInstallOpts,
   opencodePluginFiles,
-  readHintPluginSource,
-  sessionStartPluginSource,
 } from "./install/opencode.js";
 export {
   agentsSkillsDir,
@@ -49,7 +31,6 @@ export {
   linkSkills,
 } from "./install/skills.js";
 export {
-  type ClaudeRunResult,
   INSTALL_ROOT,
   type InstallDeps,
 } from "./install/types.js";
@@ -80,10 +61,6 @@ export async function cmdInstall(
     cmdInstallClaude(dryRun, deps);
     return;
   }
-  if (platform === "cursor") {
-    cmdInstallCursor(dryRun, deps);
-    return;
-  }
   if (platform === "zcode") {
     cmdInstallZcode(dryRun, deps);
     return;
@@ -98,10 +75,10 @@ export async function cmdInstall(
   }
   if (platform !== undefined) {
     console.error(
-      `usage: fapony install --platform antigravity|agy|opencode|claude|cursor|zcode|codex [--dry-run] [--git-autonomy] [--plugins-only]`,
+      `usage: fapony install --platform antigravity|agy|opencode|claude|zcode|codex [--dry-run] [--git-autonomy] [--plugins-only]`,
     );
     console.error(
-      `  supported platforms: antigravity (agy), opencode, claude, cursor, zcode, codex`,
+      `  supported platforms: antigravity (agy), opencode, claude, zcode, codex`,
     );
     (deps.exit ?? defaultExit)(1);
     return;
@@ -125,7 +102,7 @@ export async function cmdInstall(
   if (found.length === 0) {
     console.error();
     console.error(
-      `  no MCP client found (looked for claude on PATH; config files for antigravity, cursor, opencode, zcode, codex).`,
+      `  no agent client found (looked for claude on PATH; config files for antigravity, opencode, zcode, codex).`,
     );
     console.error(
       `  open the app once, then re-run — or force with: fapony install --platform <name>`,
@@ -193,9 +170,6 @@ function installPlatform(
     case "claude":
       cmdInstallClaude(dryRun, deps);
       break;
-    case "cursor":
-      cmdInstallCursor(dryRun, deps);
-      break;
     case "opencode":
       cmdInstallOpencode(dryRun, deps, opts);
       break;

package/src/memory.ts

@@ -1,53 +1,16 @@
-// src/memory.ts — memory domain: config.memory.* shell adapter helpers.
-// The shared mem-log reader now lives in src/core/mem-log.ts (PLAN-lib-layer chunk 2b).
+// src/memory.ts — config.memory.* shell adapter helpers for the frozen ledger
+// (gate.ts). Runs only commands the user configured; reading memory is
+// src/fael.ts.
 
 import { execSync } from "node:child_process";
 import type { Config } from "./core/config.js";
 import { assertSafe } from "./safety.js";
 import { templateArgs } from "./util.js";
 
-// Re-export mem-log reader for existing callers (gate, hook, digest, mcp, seed, mem).
-export {
-  type MemDirResult,
-  type MemRow,
-  readMemLog,
-  readRecentMemDecisions,
-  resolveMemDir,
-  whereMemDir,
-} from "./core/mem-log.js";
-
-// Internal import used by resolveMemoryConfig below.
-import {
-  resolveMemDir as _resolveMemDir,
-  walkUpForMemDir,
-} from "./core/mem-log.js";
-
-/** Default memory commands — built into fapony via `fapony mem <sub>`. */
-export const DEFAULT_MEMORY: Config["memory"] = {
-  claim: ["fapony", "mem", "claim", "{id}"],
-  close: ["fapony", "mem", "close", "{id}", "{msg}"],
-  add: ["fapony", "mem", "add", "{kind}", "{text}"],
-  kickoff: ["fapony", "mem", "kickoff"],
-};
-
-/**
- * Returns the effective memory config:
- * - explicit config.memory wins if set
- * - fallback: a mem log dir exists (any `.fapony/.memory/`) → DEFAULT_MEMORY
- * - otherwise null (no memory)
- */
-export function resolveMemoryConfig(
-  config: Config,
-  worktree: string,
-): Config["memory"] {
-  if (config.memory) return config.memory;
-  // A real log is not required for wiring: `fapony init` scaffolds an empty
-  // `.fapony/.memory/` and the writer creates the first log there.
-  if (_resolveMemDir(worktree) || walkUpForMemDir(worktree, true)) {
-    return DEFAULT_MEMORY;
-  }
-  return null;
-}
+/** config.memory when set — nothing is wired by default any more (memory
+ *  moved to fael, which has its own commands). */
+const resolveMemoryConfig = (config: Config): Config["memory"] =>
+  config.memory ?? null;
 
 export function closeMemory(
   config: Config,
@@ -55,7 +18,7 @@ export function closeMemory(
   memId: string,
   msg: string,
 ): void {
-  const mem = resolveMemoryConfig(config, worktree);
+  const mem = resolveMemoryConfig(config);
   if (!mem) return;
   try {
     const cmd = templateArgs(mem.close, { id: memId, msg });
@@ -70,31 +33,9 @@ export function closeMemory(
   }
 }
 
-export function claimMemory(
-  config: Config,
-  worktree: string,
-  memId: string,
-  timeoutMs = 15_000,
-): boolean {
-  const mem = resolveMemoryConfig(config, worktree);
-  if (!mem) return false;
-  try {
-    const cmd = templateArgs(mem.claim, { id: memId });
-    assertSafe(cmd, config.safety?.deny ?? []);
-    execSync(cmd.join(" "), {
-      cwd: worktree,
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: timeoutMs,
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Runs memory.kickoff (if configured or default-wired) and returns its stdout, or null if unset/failed. */
+/** Runs memory.kickoff (if configured) and returns its stdout, or null if unset/failed. */
 export function kickoffMemory(config: Config, worktree: string): string | null {
-  const mem = resolveMemoryConfig(config, worktree);
+  const mem = resolveMemoryConfig(config);
   if (!mem?.kickoff) return null;
   try {
     assertSafe(mem.kickoff, config.safety?.deny ?? []);

package/src/plan/index.ts

@@ -0,0 +1,34 @@
+// src/plan/index.ts — `fapony plan [<PLAN.md>] | sweep | check`
+
+import { cmdPlanNext } from "./next.js";
+import { initPlanStore } from "./store.js";
+import { cmdPlanCheck, cmdPlanSweep } from "./sweep.js";
+
+const HELP = `usage: fapony plan [<PLAN.md>] | sweep [<PLAN.md>] [--apply] | check [--quiet]
+
+  fapony plan                 every active plan: progress + next unchecked chunk
+  fapony plan <PLAN.md>       one plan: unchecked chunks, last-tick sha check,
+                              open fael rows about it (the chunk handoff notes)
+  fapony plan sweep           shipped plans not yet archived (dry run)
+  fapony plan sweep <PLAN.md> --apply
+                              move a shipped or superseded plan into done/
+                              (git mv; plain rename when .fapony/ is gitignored)
+                              + rewrite the links to it
+  fapony plan check           frontmatter deps, broken links, ticked-chunk shas
+                              (exit 1 on issues)
+
+close a chunk: tick it with its sha, commit, then
+  fael add note "<what chunk N+1 must know>" --files <f1>,<PLAN path>
+example: fapony plan .fapony/plan/PLAN-x.md`;
+
+export function cmdPlan(a: string[]): void {
+  const [sub, ...rest] = a;
+  if (sub === "-h" || sub === "--help" || rest.includes("--help")) {
+    console.log(HELP);
+    return;
+  }
+  initPlanStore();
+  if (sub === "sweep") cmdPlanSweep(rest);
+  else if (sub === "check") cmdPlanCheck(rest);
+  else cmdPlanNext(a);
+}

package/src/plan/next.ts

@@ -0,0 +1,181 @@
+// src/plan/next.ts — `fapony plan [<PLAN.md>]`: where a plan stands.
+//
+// Replaces the plan half of `fapony mem kickoff` (memory moved to fael):
+//   no arg    → every active plan: progress, first unchecked chunk, priority
+//               high first, blocked marked; plus shipped-but-not-archived
+//   <PLAN.md> → its unchecked chunks, whether the last ticked chunk's sha
+//               verifies, and the open fael rows about it (the chunk handoff
+//               notes — `fael add note … --files <PLAN path>`)
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { doneDir, planDir, rel, root } from "./store.js";
+import {
+  checkTickedLine,
+  openRowsFor,
+  parsePlanFrontmatter,
+  planSweepCmd,
+  shippedNotMoved,
+} from "./sweep.js";
+
+const HANDOFF_LIMIT = 5;
+const TEXT_MAX = 200;
+
+/** Checked + unchecked items of the first `##` section (the TL;DR). */
+const readPlanSectionItems = (
+  planPath: string,
+): { checked: string[]; unchecked: string[] } => {
+  try {
+    const body = readFileSync(planPath, "utf8").replace(
+      /^---\r?\n[\s\S]*?\r?\n---/,
+      "",
+    );
+    const start = body.search(/^##\s+/m);
+    if (start < 0) return { checked: [], unchecked: [] };
+    const rest = body.slice(start);
+    const next = rest.slice(3).search(/^##\s+/m);
+    const block = next < 0 ? rest : rest.slice(0, next + 3);
+    const checked: string[] = [];
+    const unchecked: string[] = [];
+    for (const line of block.split("\n")) {
+      let m = /^\s*[-*]\s+\[\s\]\s+(.+)$/.exec(line);
+      if (m) {
+        unchecked.push(m[1].trim());
+        continue;
+      }
+      m = /^\s*[-*]\s+\[[xX]\]\s+(.+)$/.exec(line);
+      if (m) checked.push(m[1].trim());
+    }
+    return { checked, unchecked };
+  } catch {
+    return { checked: [], unchecked: [] };
+  }
+};
+
+// One line saying whether the last ticked chunk actually closed. Verified
+// shas stay silent; only the newest ticked chunk is ever mentioned.
+const closureHint = (checked: string[]): string | null => {
+  const last = checked[checked.length - 1];
+  if (!last) return null;
+  const { missing, diverged, cited } = checkTickedLine(last, root);
+  const label = /chunk\s+([^\s—–-]+)/i.exec(last)?.[1] ?? "latest";
+  if (missing.length)
+    return `⚠ chunk ${label} is ticked but ${missing[0]} is not in git — nothing proves it closed`;
+  if (diverged.length)
+    return `⚠ chunk ${label} is ticked but ${diverged[0]} is not on HEAD (rebased away?)`;
+  if (!cited)
+    return `⚠ chunk ${label} is ticked but cites no commit — nothing to verify it closed`;
+  return null;
+};
+
+const readPlanTitle = (planPath: string): string => {
+  try {
+    return /^#\s+(.+)$/m.exec(readFileSync(planPath, "utf8"))?.[1].trim() ?? "";
+  } catch {
+    return "";
+  }
+};
+
+const isHighPriority = (planPath: string): boolean => {
+  try {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(
+      readFileSync(planPath, "utf8").slice(0, 1024),
+    );
+    return !!m && /^\s*priority\s*:\s*high\s*$/m.test(m[1]);
+  } catch {
+    return false;
+  }
+};
+
+const clip = (s: string): string => {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > TEXT_MAX ? `${flat.slice(0, TEXT_MAX - 1)}…` : flat;
+};
+
+/** A plan arg as typed (bare name, with/without .md, or a path) → the file. */
+const findPlan = (arg: string): string | null => {
+  const name = arg.endsWith(".md") ? basename(arg) : `${basename(arg)}.md`;
+  return (
+    [arg, join(root, arg), join(planDir, name), join(doneDir, name)].find(
+      (p) => p.endsWith(".md") && existsSync(p),
+    ) ?? null
+  );
+};
+
+function showPlan(file: string): void {
+  const { checked, unchecked } = readPlanSectionItems(file);
+  console.log(`# ${readPlanTitle(file) || basename(file)} — ${rel(file)}`);
+  if (unchecked.length) {
+    console.log(`\n## unchecked`);
+    for (const c of unchecked) console.log(`- [ ] ${c}`);
+  } else {
+    console.log(`\n(all chunks checked — ready to ship or archive)`);
+  }
+  const hint = closureHint(checked);
+  if (hint) console.log(hint);
+
+  const rows = openRowsFor(file);
+  if (rows.length) {
+    console.log(`\n## open in fael (${rows.length})`);
+    for (const r of rows.slice(0, HANDOFF_LIMIT))
+      console.log(`- ${r.ts.slice(0, 10)} ${r.kind} [${r.id}] ${clip(r.text)}`);
+    if (rows.length > HANDOFF_LIMIT)
+      console.log(
+        `… +${rows.length - HANDOFF_LIMIT} more — fael find --files ${rel(file)}`,
+      );
+  }
+}
+
+function showAll(): void {
+  const files = existsSync(planDir)
+    ? readdirSync(planDir)
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => join(planDir, f))
+    : [];
+  if (!files.length) {
+    console.log(`no plans in ${rel(planDir)}/`);
+    return;
+  }
+  const shipped = new Set(shippedNotMoved());
+  const active = files
+    .filter((f) => !shipped.has(basename(f)))
+    .sort(
+      (a, b) =>
+        Number(isHighPriority(b)) - Number(isHighPriority(a)) ||
+        a.localeCompare(b),
+    );
+  console.log(`# ${rel(planDir)}/ — ${active.length} active plan(s)`);
+  for (const f of active) {
+    const { checked, unchecked } = readPlanSectionItems(f);
+    const fm = parsePlanFrontmatter(f);
+    const tags = [
+      isHighPriority(f) ? "priority:high" : "",
+      fm.status === "blocked" ? `blocked_by: ${fm.blockedByRaw ?? "?"}` : "",
+    ].filter(Boolean);
+    console.log(
+      `\n- ${basename(f)} — ${checked.length}/${checked.length + unchecked.length} chunks${tags.length ? ` · ${tags.join(" · ")}` : ""}`,
+    );
+    if (unchecked[0]) console.log(`  next: ${clip(unchecked[0])}`);
+  }
+  if (shipped.size) {
+    console.log(`\n## shipped but not archived into done/ (${shipped.size})`);
+    for (const n of shipped) console.log(`- ${n}`);
+    console.log(`(move: ${planSweepCmd} <file.md> --apply)`);
+  }
+}
+
+export function cmdPlanNext(a: string[]): void {
+  const arg = a.find((x) => !x.startsWith("--"));
+  if (!arg) {
+    showAll();
+    return;
+  }
+  const file = findPlan(arg);
+  if (!file) {
+    console.error(
+      `no plan "${arg}" (looked in ${rel(planDir)}/, ${rel(doneDir)}/ and the repo root)`,
+    );
+    process.exit(1);
+  }
+  showPlan(file);
+}

package/src/plan/store.ts

@@ -0,0 +1,41 @@
+// src/plan/store.ts — where plans live, resolved once per `fapony plan` run.
+//
+// plan/ and done/ sit side by side under the repo's `.fapony/` (nearest one
+// walking up from cwd — app-scoped in a monorepo). done/ can be moved with
+// paths.doneDir in fapony.config.json; a legacy plan/done/ is honoured.
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { CONFIG_FILENAME, FAPONY_DIR } from "../core/config.js";
+import { faponyDirFrom, repoRootOf } from "../core/fapony-dir.js";
+
+export let root = "";
+export let planBase = "";
+export let planDir = "";
+export let doneDir = "";
+
+export function initPlanStore(cwd: string = process.cwd()): void {
+  root = repoRootOf(cwd) ?? cwd;
+  planBase = faponyDirFrom(cwd);
+  planDir = join(planBase, "plan");
+
+  const configDir =
+    planBase === join(root, FAPONY_DIR) ? root : dirname(planBase);
+  let doneFromConfig: string | null = null;
+  try {
+    const paths = JSON.parse(
+      readFileSync(join(configDir, CONFIG_FILENAME), "utf8"),
+    )?.paths;
+    if (typeof paths?.doneDir === "string")
+      doneFromConfig = join(configDir, paths.doneDir);
+  } catch {
+    // no config — defaults below
+  }
+  doneDir =
+    doneFromConfig ??
+    (!existsSync(join(planBase, "done")) && existsSync(join(planDir, "done"))
+      ? join(planDir, "done")
+      : join(planBase, "done"));
+}
+
+export const rel = (p: string): string => relative(root, p) || ".";