@iowarp/clio-coder 0.3.4 → 0.3.7

package/dist/library-NJAHIGG4.js

@@ -0,0 +1,217 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  classifyLibraryRequirements,
+  confirmLibraryRemote,
+  discoverLibrary,
+  installLibraryPlan,
+  libraryEntryRef,
+  libraryInstallPath,
+  planLibraryInstall,
+  syncLibrary
+} from "./chunk-THKY7CD7.js";
+import "./chunk-UVDSQ6LW.js";
+import "./chunk-DR52UMZW.js";
+import "./chunk-C4JBQ5SR.js";
+import "./chunk-2SFS6XQE.js";
+import "./chunk-ZWLZP4ZT.js";
+import "./chunk-KCMKRQX4.js";
+import "./chunk-DJNLUABN.js";
+import "./chunk-AOCYTWAV.js";
+import "./chunk-MV3K5QF2.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-CGKSTWHD.js";
+import "./chunk-465YSENW.js";
+import {
+  printError,
+  printOk
+} from "./chunk-PPAMZ32Z.js";
+import "./chunk-5TSRNF4G.js";
+import "./chunk-JRIO5UD2.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-UHXRNZ2J.js";
+import "./chunk-4DGYLA73.js";
+import "./chunk-LL4KHSZI.js";
+import "./chunk-SST6Z5JA.js";
+import "./chunk-D4MDIG46.js";
+import "./chunk-FQ4SKYE4.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-YXLYO42X.js";
+import "./chunk-BNAZZHFG.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/library.ts
+init_esm_shims();
+var KINDS = /* @__PURE__ */ new Set(["skill", "agent", "prompt", "fleet"]);
+var HELP = `clio-coder library <command>
+
+Commands:
+  clio-coder library list [--kind <kind>] [--json]
+  clio-coder library search <query> [--kind <kind>] [--json]
+  clio-coder library add <ref> [--from <catalog|path>] [--with-requirements] [--yes] [--json]
+  clio-coder library use <kind> <name>
+  clio-coder library sync
+  clio-coder library push
+  clio-coder library remote confirm <url>
+`;
+function parse(argv) {
+  const out = { positional: [], json: false, yes: false, withRequirements: false, help: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg) continue;
+    if (!out.command && !arg.startsWith("-")) {
+      out.command = arg;
+      continue;
+    }
+    if (arg === "--json") out.json = true;
+    else if (arg === "--yes") out.yes = true;
+    else if (arg === "--with-requirements") out.withRequirements = true;
+    else if (arg === "--help" || arg === "-h") out.help = true;
+    else if (arg === "--kind") {
+      const value = argv[++i];
+      if (!value || !KINDS.has(value))
+        throw new Error("--kind requires skill, agent, prompt, or fleet");
+      out.kind = value;
+    } else if (arg === "--from") {
+      const value = argv[++i];
+      if (!value) throw new Error("--from requires a value");
+      out.from = value;
+    } else if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    else out.positional.push(arg);
+  }
+  return out;
+}
+function selectEntry(entries, ref) {
+  const matches = ref.includes(":") ? entries.filter((entry) => libraryEntryRef(entry) === ref) : entries.filter((entry) => entry.name === ref);
+  if (matches.length === 0) throw new Error(`library entry not found: ${ref}`);
+  if (matches.length > 1)
+    throw new Error(`library entry is ambiguous; use a typed reference: ${matches.map(libraryEntryRef).join(", ")}`);
+  return matches[0];
+}
+function filtered(entries, kind) {
+  return entries.filter((entry) => kind === void 0 || entry.kind === kind);
+}
+async function runLibraryCommand(argv) {
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (!parsed.command || parsed.help) {
+    process.stdout.write(HELP);
+    return parsed.help ? 0 : 2;
+  }
+  try {
+    if (parsed.command === "list" || parsed.command === "search") {
+      const discovery = discoverLibrary();
+      const query = parsed.command === "search" ? parsed.positional.join(" ").trim().toLowerCase() : "";
+      if (parsed.command === "search" && !query) throw new Error("library search requires a query");
+      const entries = filtered(discovery.entries, parsed.kind).filter(
+        (entry) => !query || entry.name.toLowerCase().includes(query) || entry.description.toLowerCase().includes(query)
+      );
+      if (parsed.json)
+        process.stdout.write(`${JSON.stringify({ entries, diagnostics: discovery.diagnostics }, null, 2)}
+`);
+      else
+        for (const entry of entries) process.stdout.write(`${libraryEntryRef(entry).padEnd(28)} ${entry.description}
+`);
+      return 0;
+    }
+    if (parsed.command === "add") {
+      const ref = parsed.positional[0];
+      if (!ref || parsed.positional.length !== 1) throw new Error("library add requires one reference");
+      const catalog = parsed.from && parsed.from !== "catalog" ? parsed.from : void 0;
+      const discovery = discoverLibrary(catalog ? { catalog } : {});
+      let entry;
+      try {
+        entry = selectEntry(discovery.entries, ref);
+      } catch (error) {
+        const refusal = ref.includes(":") ? discovery.refusals[ref] : Object.entries(discovery.refusals).find(([key]) => key.endsWith(`:${ref}`))?.[1];
+        if (refusal) throw new Error(refusal);
+        throw error;
+      }
+      const requirements = classifyLibraryRequirements(entry, discovery.entries);
+      if (requirements.unsatisfied.length > 0 && !parsed.withRequirements) {
+        const refs = requirements.unsatisfied.map(libraryEntryRef);
+        if (parsed.json)
+          process.stdout.write(
+            `${JSON.stringify({ ok: false, entry: libraryEntryRef(entry), satisfiedRequirements: requirements.satisfied.map(libraryEntryRef), unresolvedRequirements: refs }, null, 2)}
+`
+          );
+        else
+          process.stderr.write(
+            `satisfied requirements: ${requirements.satisfied.length > 0 ? requirements.satisfied.map(libraryEntryRef).join(", ") : "none"}
+unresolved requirements: ${refs.join(", ")}
+pass --with-requirements to install them in dependency order
+`
+          );
+        return 1;
+      }
+      const plans = [...parsed.withRequirements ? requirements.unsatisfied : [], entry].map(planLibraryInstall);
+      if (parsed.json)
+        process.stdout.write(
+          `${JSON.stringify({ ok: true, confirmed: parsed.yes, satisfiedRequirements: requirements.satisfied.map(libraryEntryRef), writes: plans.map((plan) => ({ ref: libraryEntryRef(plan.entry), path: plan.path, sha256: plan.sha256 })) }, null, 2)}
+`
+        );
+      else {
+        process.stdout.write("library add plan:\n");
+        process.stdout.write(
+          `  satisfied requirements: ${requirements.satisfied.length > 0 ? requirements.satisfied.map(libraryEntryRef).join(", ") : "none"}
+`
+        );
+        for (const plan of plans)
+          process.stdout.write(`  ${libraryEntryRef(plan.entry)} -> ${plan.path} sha256 ${plan.sha256}
+`);
+      }
+      if (!parsed.yes) return 0;
+      for (const plan of plans) installLibraryPlan(plan);
+      if (!parsed.json) printOk(`installed ${plans.length} library entry or entries`);
+      return 0;
+    }
+    if (parsed.command === "use") {
+      const kind = parsed.positional[0];
+      const name = parsed.positional[1];
+      if (!kind || !KINDS.has(kind) || !name || parsed.positional.length !== 2)
+        throw new Error("library use requires a kind and name");
+      const output = kind === "fleet" ? `clio-coder fleet run ${name}` : kind === "agent" ? `/run ${name}` : kind === "skill" ? `${libraryInstallPath({ kind, name })}
+load it from /skill in the TUI, or ask the model to call context(scope="skills")` : name;
+      process.stdout.write(`${output}
+`);
+      return 0;
+    }
+    if (parsed.command === "remote") {
+      if (parsed.positional[0] !== "confirm" || !parsed.positional[1] || parsed.positional.length !== 2)
+        throw new Error("library remote confirm requires a URL");
+      confirmLibraryRemote(parsed.positional[1]);
+      printOk("confirmed library remote");
+      return 0;
+    }
+    if (parsed.command === "sync" || parsed.command === "push") {
+      await syncLibrary(parsed.command);
+      printOk(`library ${parsed.command} complete`);
+      return 0;
+    }
+    throw new Error(`unknown library command: ${parsed.command}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(message);
+    if (parsed.json) process.stdout.write(`${JSON.stringify({ ok: false, error: message }, null, 2)}
+`);
+    return 1;
+  }
+}
+export {
+  runLibraryCommand
+};
+//# sourceMappingURL=library-NJAHIGG4.js.map

package/dist/memory-OG6HOYKM.js

@@ -0,0 +1,472 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  approveMemoryRecord,
+  canonicalMemoryRepositoryIdentity,
+  loadMemoryRecords,
+  memoryAgentIdentity,
+  memoryRuntimeIdentity,
+  memoryStatus,
+  parseTaskMemoryHandoffSnapshot,
+  proposeMemoryFromEvidence,
+  proposeMemoryPromotion,
+  pruneStaleMemory,
+  rejectMemoryRecord
+} from "./chunk-6M7VS3J3.js";
+import "./chunk-UUANF5CR.js";
+import "./chunk-6TUKSZVF.js";
+import "./chunk-KZ2H5X4G.js";
+import "./chunk-M4AKACEO.js";
+import "./chunk-RVG5JXAL.js";
+import "./chunk-ZGH7FGS5.js";
+import "./chunk-TSHXZTOQ.js";
+import "./chunk-TXOTCRLG.js";
+import "./chunk-HVDIIIQW.js";
+import "./chunk-W6GROXXM.js";
+import "./chunk-KCMKRQX4.js";
+import "./chunk-WHGPSPT5.js";
+import "./chunk-CEYBNUGC.js";
+import "./chunk-5FR74PWO.js";
+import "./chunk-OBMAI2DP.js";
+import "./chunk-5C77SEEY.js";
+import "./chunk-UND3GU2L.js";
+import "./chunk-CMZWFGD2.js";
+import "./chunk-I4HZDVNP.js";
+import "./chunk-GH5622CP.js";
+import "./chunk-OQE5J4C6.js";
+import "./chunk-GOXNB3AO.js";
+import "./chunk-HWUFFB6L.js";
+import "./chunk-DJNLUABN.js";
+import "./chunk-AOCYTWAV.js";
+import "./chunk-MV3K5QF2.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-ODFEOB4F.js";
+import "./chunk-OZNBF4L3.js";
+import "./chunk-4BJ5BYCE.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-6XLNIQDB.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-CGKSTWHD.js";
+import "./chunk-XAKHZX5N.js";
+import "./chunk-33YXPOE3.js";
+import "./chunk-465YSENW.js";
+import {
+  printError,
+  printOk
+} from "./chunk-PPAMZ32Z.js";
+import "./chunk-5TSRNF4G.js";
+import "./chunk-VQNODYQ4.js";
+import "./chunk-CFGTUFWB.js";
+import "./chunk-JRIO5UD2.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-GEYXPTRF.js";
+import "./chunk-UHXRNZ2J.js";
+import "./chunk-4DGYLA73.js";
+import "./chunk-LL4KHSZI.js";
+import "./chunk-SST6Z5JA.js";
+import "./chunk-FO5ZOVUY.js";
+import "./chunk-R346GLFC.js";
+import "./chunk-D4MDIG46.js";
+import "./chunk-FQ4SKYE4.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-YXLYO42X.js";
+import {
+  clioDataDir
+} from "./chunk-BNAZZHFG.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-ZGVHUX3M.js";
+import "./chunk-OB5HIGJY.js";
+import "./chunk-7CR24IG7.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/memory.ts
+init_esm_shims();
+import { readFile, stat } from "node:fs/promises";
+var HELP = `clio-coder memory list
+clio-coder memory propose --from-evidence <evidenceId> [scope options]
+clio-coder memory promote --from-handoff <path> [--entry <id>...] --scope <scope> [scope options]
+clio-coder memory approve <memoryId>
+clio-coder memory reject <memoryId>
+clio-coder memory prune --stale
+
+Manage scoped, approved, evidence-linked local memory records.
+
+Scope options:
+  --scope repo --repository <canonical-absolute-path>
+  --scope global --acknowledge-global
+  --scope runtime --runtime <source-runtime-id>
+  --scope agent --agent <source-agent-id>
+
+Omit scope options from propose to preserve evidence-inferred scope. Promotion
+always requires an explicit scope and creates unapproved records for review.
+`;
+function parseMemoryArgs(args) {
+  const parsed = { entryIds: [], acknowledgeGlobal: false, stale: false, help: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (parsed.command === void 0) {
+      if (arg === "list" || arg === "propose" || arg === "promote" || arg === "approve" || arg === "reject" || arg === "prune") {
+        parsed.command = arg;
+        continue;
+      }
+      throw new Error(`unknown memory command: ${arg}`);
+    }
+    if (parsed.command === "propose" || parsed.command === "promote") {
+      if (arg === "--from-evidence") {
+        if (parsed.command !== "propose") throw new Error("--from-evidence is valid only for memory propose");
+        const value = args[index + 1];
+        if (value === void 0 || value.startsWith("-")) throw new Error("--from-evidence requires an evidence id");
+        parsed.evidenceId = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--from-handoff") {
+        if (parsed.command !== "promote") throw new Error("--from-handoff is valid only for memory promote");
+        const value = requireOptionValue(args, index, "--from-handoff", "a path");
+        parsed.handoffPath = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--entry") {
+        if (parsed.command !== "promote") throw new Error("--entry is valid only for memory promote");
+        parsed.entryIds.push(requireOptionValue(args, index, "--entry", "an entry id"));
+        index += 1;
+        continue;
+      }
+      if (arg === "--scope") {
+        const value = requireOptionValue(args, index, "--scope", "repo, global, runtime, or agent");
+        if (value !== "repo" && value !== "global" && value !== "runtime" && value !== "agent") {
+          throw new Error("--scope requires repo, global, runtime, or agent");
+        }
+        parsed.scope = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--repository") {
+        parsed.repositoryPath = requireOptionValue(args, index, "--repository", "a canonical absolute path");
+        index += 1;
+        continue;
+      }
+      if (arg === "--acknowledge-global") {
+        parsed.acknowledgeGlobal = true;
+        continue;
+      }
+      if (arg === "--runtime") {
+        parsed.runtimeId = requireOptionValue(args, index, "--runtime", "a runtime id");
+        index += 1;
+        continue;
+      }
+      if (arg === "--agent") {
+        parsed.agentId = requireOptionValue(args, index, "--agent", "an agent id");
+        index += 1;
+        continue;
+      }
+      throw new Error(`unknown memory ${parsed.command} argument: ${arg}`);
+    }
+    if (parsed.command === "approve" || parsed.command === "reject") {
+      if (parsed.memoryId === void 0 && !arg.startsWith("-")) {
+        parsed.memoryId = arg;
+        continue;
+      }
+      throw new Error(`unexpected memory ${parsed.command} argument: ${arg}`);
+    }
+    if (parsed.command === "prune") {
+      if (arg === "--stale") {
+        parsed.stale = true;
+        continue;
+      }
+      throw new Error(`unknown memory prune argument: ${arg}`);
+    }
+    throw new Error(`unexpected memory argument: ${arg}`);
+  }
+  if (parsed.help) return parsed;
+  if (parsed.command === void 0) throw new Error("memory requires list, propose, promote, approve, reject, or prune");
+  if (parsed.command === "propose" && parsed.evidenceId === void 0) {
+    throw new Error("propose requires --from-evidence <evidenceId>");
+  }
+  if (parsed.command === "promote" && parsed.handoffPath === void 0) {
+    throw new Error("promote requires --from-handoff <path>");
+  }
+  if ((parsed.command === "approve" || parsed.command === "reject") && parsed.memoryId === void 0) {
+    throw new Error(`${parsed.command} requires a memory id`);
+  }
+  if (parsed.command === "prune" && !parsed.stale) throw new Error("prune requires --stale");
+  if (parsed.command === "promote" && parsed.scope === void 0) {
+    throw new Error("promote requires --scope <repo|global|runtime|agent>");
+  }
+  validateScopeArguments(parsed);
+  if (parsed.command === "list" && (parsed.evidenceId !== void 0 || parsed.handoffPath !== void 0 || parsed.entryIds.length > 0 || parsed.memoryId !== void 0 || parsed.stale || parsed.scope !== void 0)) {
+    throw new Error("list does not accept extra arguments");
+  }
+  return parsed;
+}
+function requireOptionValue(args, index, option, expected) {
+  const value = args[index + 1];
+  if (value === void 0 || value.startsWith("-")) throw new Error(`${option} requires ${expected}`);
+  return value;
+}
+function validateScopeArguments(parsed) {
+  const hasIdentityOption = parsed.repositoryPath !== void 0 || parsed.acknowledgeGlobal || parsed.runtimeId !== void 0 || parsed.agentId !== void 0;
+  if (parsed.scope === void 0) {
+    if (hasIdentityOption) throw new Error("scope identity options require --scope");
+    return;
+  }
+  if (parsed.scope === "repo") {
+    if (parsed.repositoryPath === void 0)
+      throw new Error("repo scope requires --repository <canonical-absolute-path>");
+    if (parsed.acknowledgeGlobal || parsed.runtimeId !== void 0 || parsed.agentId !== void 0) {
+      throw new Error("repo scope accepts only --repository");
+    }
+    return;
+  }
+  if (parsed.scope === "global") {
+    if (!parsed.acknowledgeGlobal) throw new Error("global scope requires --acknowledge-global");
+    if (parsed.repositoryPath !== void 0 || parsed.runtimeId !== void 0 || parsed.agentId !== void 0) {
+      throw new Error("global scope accepts only --acknowledge-global");
+    }
+    return;
+  }
+  if (parsed.scope === "runtime") {
+    if (parsed.runtimeId === void 0) throw new Error("runtime scope requires --runtime <source-runtime-id>");
+    if (parsed.repositoryPath !== void 0 || parsed.acknowledgeGlobal || parsed.agentId !== void 0) {
+      throw new Error("runtime scope accepts only --runtime");
+    }
+    return;
+  }
+  if (parsed.agentId === void 0) throw new Error("agent scope requires --agent <source-agent-id>");
+  if (parsed.repositoryPath !== void 0 || parsed.acknowledgeGlobal || parsed.runtimeId !== void 0) {
+    throw new Error("agent scope accepts only --agent");
+  }
+}
+async function runMemoryCommand(args) {
+  let parsed;
+  try {
+    parsed = parseMemoryArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const dataDir = clioDataDir();
+  try {
+    if (parsed.command === "list") {
+      renderMemoryList(await loadMemoryRecords(dataDir));
+      return 0;
+    }
+    if (parsed.command === "propose") {
+      const evidenceId = parsed.evidenceId;
+      if (evidenceId === void 0) {
+        printError("propose requires --from-evidence <evidenceId>");
+        return 2;
+      }
+      const result = await proposeMemoryFromEvidence(dataDir, evidenceId, scopeSelection(parsed));
+      renderProposal(result.record, result.created);
+      return 0;
+    }
+    if (parsed.command === "promote") {
+      const handoffPath = parsed.handoffPath;
+      const selection = scopeSelection(parsed);
+      if (handoffPath === void 0 || selection === void 0) {
+        printError("promote requires a handoff and explicit scope");
+        return 2;
+      }
+      const snapshot = await readReviewedHandoff(handoffPath);
+      const entries = selectHandoffEntries(snapshot, parsed.entryIds);
+      for (const entry of entries) {
+        const result = await proposeMemoryPromotion(
+          dataDir,
+          {
+            kind: "handoff-snapshot",
+            sessionId: snapshot.source.sessionId,
+            evidenceRefs: snapshot.source.evidenceRefs,
+            runtimeIds: snapshot.source.runtimeIds,
+            agentIds: snapshot.source.agentIds,
+            entry: handoffTaskEntry(entry),
+            redaction: {
+              replacementCount: snapshot.redaction.replacementCount,
+              sourceFields: snapshot.redaction.sourceFields
+            }
+          },
+          selection
+        );
+        renderProposal(result.record, result.created);
+      }
+      return 0;
+    }
+    if (parsed.command === "approve") {
+      const memoryId = parsed.memoryId;
+      if (memoryId === void 0) {
+        printError("approve requires a memory id");
+        return 2;
+      }
+      const record = await approveMemoryRecord(dataDir, memoryId);
+      printOk(`approved ${record.id}`);
+      return 0;
+    }
+    if (parsed.command === "reject") {
+      const memoryId = parsed.memoryId;
+      if (memoryId === void 0) {
+        printError("reject requires a memory id");
+        return 2;
+      }
+      const record = await rejectMemoryRecord(dataDir, memoryId);
+      printOk(`rejected ${record.id}`);
+      return 0;
+    }
+    if (parsed.command === "prune") {
+      const pruned = await pruneStaleMemory(dataDir);
+      printOk(`pruned ${pruned.length} stale memory record${pruned.length === 1 ? "" : "s"}`);
+      return 0;
+    }
+    printError("memory requires list, propose, promote, approve, reject, or prune");
+    return 2;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+function scopeSelection(parsed) {
+  if (parsed.scope === void 0) return void 0;
+  if (parsed.scope === "repo") {
+    const repositoryPath = parsed.repositoryPath;
+    if (repositoryPath === void 0) throw new Error("repo scope requires --repository");
+    const repository = canonicalMemoryRepositoryIdentity(repositoryPath);
+    if (repository === null || repository.key !== repositoryPath) {
+      throw new Error("--repository must be an existing canonical absolute repository path");
+    }
+    return { scope: "repo", repository };
+  }
+  if (parsed.scope === "global") {
+    if (!parsed.acknowledgeGlobal) throw new Error("global scope requires --acknowledge-global");
+    return { scope: "global", acknowledgeGlobal: true };
+  }
+  if (parsed.scope === "runtime") {
+    if (parsed.runtimeId === void 0) throw new Error("runtime scope requires --runtime");
+    return { scope: "runtime", runtime: memoryRuntimeIdentity(parsed.runtimeId) };
+  }
+  if (parsed.agentId === void 0) throw new Error("agent scope requires --agent");
+  return { scope: "agent", agent: memoryAgentIdentity(parsed.agentId) };
+}
+async function readReviewedHandoff(path) {
+  const info = await stat(path);
+  if (!info.isFile()) throw new Error(`task-memory handoff is not a file: ${path}`);
+  if (info.size > 1e6) throw new Error(`task-memory handoff exceeds 1000000 bytes: ${path}`);
+  const snapshot = parseTaskMemoryHandoffSnapshot(await readFile(path, "utf8"));
+  if (snapshot === null) throw new Error(`task-memory handoff is invalid: ${path}`);
+  if (snapshot.version !== 2) {
+    throw new Error("task-memory handoff lacks source session and evidence provenance; create a new redacted handoff");
+  }
+  return snapshot;
+}
+function selectHandoffEntries(snapshot, entryIds) {
+  const entries = [
+    ...snapshot.knowledge.map((entry) => ({ kind: "knowledge", entry })),
+    ...snapshot.procedural.map((entry) => ({ kind: "procedural", entry }))
+  ];
+  if (entries.length === 0) throw new Error("task-memory handoff contains no promotable entries");
+  if (entryIds.length === 0) return entries;
+  const requested = new Set(entryIds);
+  const selected = entries.filter(({ entry }) => requested.has(entry.id));
+  const missing = [...requested].filter((id) => !selected.some(({ entry }) => entry.id === id));
+  if (missing.length > 0) throw new Error(`task-memory handoff entry not found: ${missing.join(", ")}`);
+  return selected;
+}
+function handoffTaskEntry(selected) {
+  const createdAt = selected.entry.createdAt;
+  const lastTouchedAt = selected.entry.lastTouchedAt;
+  if (createdAt === void 0 || lastTouchedAt === void 0) {
+    throw new Error(`task-memory handoff entry lacks timestamps: ${selected.entry.id}`);
+  }
+  return {
+    id: selected.entry.id,
+    kind: selected.kind,
+    content: selected.entry.content,
+    createdAt,
+    lastTouchedAt,
+    injectionCount: selected.entry.injectionCount
+  };
+}
+function renderProposal(record, created) {
+  process.stdout.write(`memory: ${record.id}
+`);
+  process.stdout.write(`status: ${created ? "proposed" : memoryStatus(record)}
+`);
+  process.stdout.write(`scope: ${record.scope}
+`);
+  if (record.repository !== void 0) process.stdout.write(`repository: ${record.repository.key}
+`);
+  if (record.runtime !== void 0) process.stdout.write(`runtime: ${record.runtime.key}
+`);
+  if (record.agent !== void 0) process.stdout.write(`agent: ${record.agent.key}
+`);
+  process.stdout.write(`key: ${record.key}
+`);
+  process.stdout.write(`evidence: ${record.evidenceRefs.join(", ")}
+`);
+  process.stdout.write(`confidence: ${record.confidence.toFixed(2)}
+`);
+  process.stdout.write(`lesson: ${record.lesson}
+`);
+  if (record.provenance !== void 0) {
+    process.stdout.write(`source: ${record.provenance.sourceKind}
+`);
+    if (record.provenance.sourceSessionId !== void 0) {
+      process.stdout.write(`source-session: ${record.provenance.sourceSessionId}
+`);
+    }
+    if (record.provenance.sourceEntryId !== void 0) {
+      process.stdout.write(`source-entry: ${record.provenance.sourceEntryId}
+`);
+    }
+    if (record.provenance.redaction !== void 0) {
+      process.stdout.write(
+        `redaction: ${record.provenance.redaction.replacementCount} replacement${record.provenance.redaction.replacementCount === 1 ? "" : "s"}; fields=${record.provenance.redaction.sourceFields.join(",") || "none"}
+`
+      );
+    }
+  }
+  process.stdout.write(`review: clio-coder memory approve ${record.id}
+`);
+}
+function renderMemoryList(records) {
+  process.stdout.write(`${records.length} memory record${records.length === 1 ? "" : "s"}
+`);
+  if (records.length === 0) return;
+  process.stdout.write("\n");
+  for (const record of records) {
+    process.stdout.write(
+      [
+        record.id.padEnd(21),
+        memoryStatus(record).padEnd(10),
+        record.scope.padEnd(13),
+        `confidence=${record.confidence.toFixed(2)}`.padEnd(16),
+        `evidence=${record.evidenceRefs.join(",")}`
+      ].join("")
+    );
+    process.stdout.write("\n");
+    process.stdout.write(`  key: ${record.key}
+`);
+    process.stdout.write(`  lesson: ${record.lesson}
+`);
+  }
+}
+export {
+  runMemoryCommand
+};
+//# sourceMappingURL=memory-OG6HOYKM.js.map