panoma 0.10.3 → 0.11.1

package/dist/memory-command-ESZY4HJY.js

@@ -0,0 +1,770 @@
+import {
+  sessionCommand
+} from "./chunk-V5EG3JSQ.js";
+import {
+  unreachable
+} from "./chunk-MBTQ3PDJ.js";
+import {
+  catalogFetch
+} from "./chunk-YL7PZVKO.js";
+import {
+  say
+} from "./chunk-3UQ4TNO4.js";
+import "./chunk-DITTKJ7U.js";
+import {
+  expandTilde
+} from "./chunk-RD7TE2IA.js";
+import "./chunk-MLKGABMK.js";
+
+// src/memory-command.ts
+import { writeFile } from "fs/promises";
+import { resolve } from "path";
+import pc from "picocolors";
+var QUOTA_NEAR = 0.8;
+var FACT_KINDS = ["read", "edit", "command", "test_result", "failure", "commit", "lifecycle", "receipt_seen"];
+var PERMISSION_WIRE = { capture: "memoryCapture", extract: "memoryExtract", twin: "twinAutoLearn" };
+function isPermissionWord(value) {
+  return value in PERMISSION_WIRE;
+}
+var JOB_SEARCH_PAGES = 40;
+var BACKFILL_LIMIT_MAX = 500;
+async function memoryCommand(parsed) {
+  const [, sub, argument, third, fourth] = parsed.positionals;
+  if (sub === "session") {
+    return sessionCommand(resolve(expandTilde(argument ?? ".")), parsed.api);
+  }
+  if (sub === "export" && argument !== void 0 && third === void 0) return exportMemory(parsed, argument);
+  if (sub === "status" && third === void 0) return memoryStatus(parsed, argument);
+  if ((sub === "purge" || sub === "withdraw") && third === void 0) {
+    if (argument === void 0) {
+      process.stderr.write(pc.red(`${say("memory.needsSource", { verb: sub })}
+`));
+      return 1;
+    }
+    return deleteSource(parsed, sub, argument);
+  }
+  if (sub === "allow" || sub === "revoke") return setPermission(parsed, sub, argument, third, fourth);
+  if (sub === "backfill") return backfill(parsed, argument, third);
+  if (sub === "jobs") return jobs(parsed, argument, third, fourth);
+  process.stderr.write(
+    pc.red(`${say("memory.usage")}
+${say("memory.usageMore")}
+`) + pc.dim(`${say("memory.usageHint")}
+`)
+  );
+  return 1;
+}
+async function exportMemory(parsed, slug) {
+  let response;
+  try {
+    response = await catalogFetch(
+      new URL(`/api/memory/export?slug=${encodeURIComponent(slug)}`, parsed.api)
+    );
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!response.ok) return rejected(response);
+  const doc = await response.json();
+  const json = `${JSON.stringify(doc, null, 2)}
+`;
+  if (parsed.out) {
+    await writeFile(parsed.out, json, "utf8");
+    const decisions = (doc.decisions?.length ?? 0) + (doc.generalDecisions?.length ?? 0);
+    process.stderr.write(
+      pc.green(`\u2713 ${say("memory.wrote", { path: parsed.out, notes: doc.notes?.length ?? 0, decisions })}
+`)
+    );
+    return 0;
+  }
+  process.stdout.write(json);
+  return 0;
+}
+async function memoryStatus(parsed, slug) {
+  const url = new URL("/api/memory/status", parsed.api);
+  if (slug !== void 0) url.searchParams.set("slug", slug);
+  let response;
+  try {
+    response = await catalogFetch(url);
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!response.ok) return rejected(response);
+  const reply = await response.json();
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(reply, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(`${memoryStatusLines(reply, parsed.api).join("\n")}
+`);
+  return 0;
+}
+var count = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+var word = (value, fallback = "unknown") => typeof value === "string" && value !== "" ? value : fallback;
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+function mebibytes(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+function quotaLines(quota, projects) {
+  if (typeof quota !== "object" || quota === null) return [];
+  const lines = [];
+  const line = (scope, state) => {
+    const bytes = count(state?.bytes);
+    const limit = count(state?.limit);
+    if (limit <= 0) return;
+    if (state?.exceeded === true || bytes >= limit) {
+      lines.push(`  ${pc.yellow("!")} ${say("memory.quotaOver", { scope, limit: mebibytes(limit), used: mebibytes(bytes) })}`);
+    } else if (bytes >= limit * QUOTA_NEAR) {
+      lines.push(`  ${say("memory.quotaNear", { scope, limit: mebibytes(limit), used: mebibytes(bytes) })}`);
+    }
+  };
+  line(say("memory.quotaCatalog"), quota.catalog);
+  const named = new Map(projects.filter((project) => typeof project.id === "string").map((project) => [project.id, project.slug]));
+  for (const [id, state] of Object.entries(quota.projects ?? {})) {
+    const slug = named.get(id);
+    line(say("memory.quotaProject", { project: typeof slug === "string" && slug !== "" ? slug : id }), state);
+  }
+  if (quota.paused === true) lines.push(`  ${pc.yellow("!")} ${say("memory.quotaPaused")}`);
+  return lines;
+}
+function memoryStatusLines(reply, api) {
+  const lines = ["", `  ${pc.bold(say("memory.status", { api }))}`, ""];
+  if (reply.coverage?.quarantined === true) {
+    lines.push(`  ${pc.yellow("!")} ${say("memory.quarantined")}`, "");
+  }
+  const delivery = reply.delivery ?? {};
+  const queue = reply.queue ?? {};
+  const cursors = record(queue.cursors) ?? queue;
+  lines.push(
+    `  ${say("memory.delivery", {
+      offers: count(delivery.offers),
+      sent: count(delivery.attempts?.sent),
+      failed: count(delivery.attempts?.failed),
+      unknown: count(delivery.attempts?.unknown),
+      unbound: count(delivery.unbound)
+    })}`,
+    `  ${say("memory.receptions", {
+      full: count(delivery.receptions?.full),
+      partial: count(delivery.receptions?.partial),
+      unknown: count(delivery.receptions?.unknown),
+      notObserved: count(delivery.receptions?.notObserved)
+    })}`,
+    `  ${say("memory.queue", {
+      pending: count(cursors["pending"]),
+      active: count(cursors["active"]),
+      blocked: count(cursors["blocked"]),
+      complete: count(cursors["complete"]),
+      revoked: count(cursors["revoked"])
+    })}`
+  );
+  const jobs2 = record(queue.jobs);
+  const capture = record(queue["capture"]);
+  if (capture) {
+    lines.push(`  ${say("memory.capturePass", { streams: count(capture["streams"]), bytes: count(capture["bytesRead"]) })}`);
+    const skipped = record(capture["skipped"]);
+    for (const [reason, total] of Object.entries(skipped ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+      if (count(total) > 0) lines.push(`    ${say("memory.captureSkipped", { reason: word(reason), n: count(total) })}`);
+    }
+  }
+  if (jobs2 !== void 0) {
+    lines.push(
+      `  ${say("memory.jobCounts", {
+        pending: count(jobs2["pending"]),
+        running: count(jobs2["running"]),
+        staged: count(jobs2["staged"]),
+        deferred: count(jobs2["deferred"]),
+        failed: count(jobs2["failed"]),
+        complete: count(jobs2["complete"]),
+        cancelled: count(jobs2["cancelled"]),
+        obsolete: count(jobs2["obsolete"])
+      })}`
+    );
+  }
+  const extraction = queue.extraction;
+  if (typeof extraction === "object" && extraction !== null) {
+    const pendingBytes = count(extraction.pendingBytes);
+    lines.push(
+      `  ${pendingBytes === 0 ? pc.dim(say("memory.extractionIdle")) : say("memory.extraction", { pendingBytes, oldestPendingAt: word(extraction.oldestPendingAt) })}`,
+      `  ${say("memory.extractionIntervals", {
+        arrived: count(extraction.intervals?.arrived),
+        completed: count(extraction.intervals?.completed),
+        deferred: count(extraction.intervals?.deferred),
+        dropped: count(extraction.intervals?.dropped)
+      })}`
+    );
+    if (extraction.capacityLimited === true) lines.push(`  ${pc.yellow("!")} ${say("memory.capacityLimited")}`);
+  }
+  const checks = record(reply.coverage?.checks);
+  if (checks) lines.push(`  ${say("memory.checkCounts", {
+    defined: count(checks["defined"]),
+    observed: count(checks["observed"]),
+    unknown: count(checks["unknown"])
+  })}`);
+  const commitments = record(reply.coverage?.commitments);
+  if (commitments) lines.push(`  ${say("memory.commitmentCounts", {
+    open: count(commitments["open"]),
+    fulfilled: count(commitments["fulfilled"]),
+    cancelled: count(commitments["cancelled"])
+  })}`);
+  const patrol = record(queue["patrol"]);
+  if (patrol) {
+    const pass = record(patrol["lastPass"]);
+    const pending = patrol["pending"];
+    lines.push(`  ${say("memory.patrolPending", { n: Array.isArray(pending) ? pending.length : 0 })}`);
+    if (pass) {
+      const results = record(pass["results"]);
+      lines.push(`    ${say("memory.patrolResults", {
+        pass: count(results?.["pass"]),
+        fail: count(results?.["fail"]),
+        unknown: count(results?.["unknown"])
+      })}`);
+    } else lines.push(`    ${say("memory.patrolUnobserved")}`);
+  }
+  lines.push(...quotaLines(reply.coverage?.quota, reply.projects ?? []));
+  lines.push("");
+  lines.push(`  ${pc.bold(say("memory.capabilities"))}`);
+  const capabilities = reply.capabilities ?? [];
+  if (capabilities.length === 0) lines.push(`    ${pc.dim(say("memory.capabilitiesNone"))}`);
+  for (const capability of capabilities) {
+    lines.push(
+      `    ${say("memory.capability", {
+        harness: word(capability.harness),
+        entry: word(capability.entry),
+        profile: word(capability.profile, "none"),
+        receiptSite: word(capability.receiptSite),
+        invocation: word(capability.invocation)
+      })}`
+    );
+  }
+  lines.push("");
+  lines.push(`  ${pc.bold(say("memory.permissions"))}`);
+  const grants = reply.coverage?.grants ?? [];
+  const enabled = grants.filter((grant) => grant.purpose === "memoryCapture" && grant.enabled === true);
+  if (enabled.length === 0) lines.push(`    ${pc.dim(say("memory.permissionsNone"))}`);
+  for (const grant of enabled) {
+    lines.push(
+      `    ${say("memory.permission", {
+        source: word(grant.source),
+        state: "on",
+        scope: word(grant.scope),
+        generation: count(grant.generation)
+      })}`
+    );
+  }
+  for (const grant of grants.filter((grant2) => grant2.purpose === "memoryExtract" && grant2.enabled === true)) {
+    lines.push(
+      `    ${say("memory.extractPermission", {
+        source: word(grant.source),
+        scope: word(grant.scope),
+        generation: count(grant.generation)
+      })}`
+    );
+  }
+  for (const grant of grants.filter((grant2) => grant2.purpose === "twinAutoLearn" && grant2.enabled === true)) {
+    lines.push(
+      `    ${say("memory.twinPermission", {
+        source: word(grant.source),
+        scope: word(grant.scope),
+        generation: count(grant.generation)
+      })}`
+    );
+  }
+  lines.push("");
+  const facts = record(reply.coverage?.facts);
+  if (facts !== void 0) {
+    lines.push(`  ${pc.bold(say("memory.facts"))}`);
+    const total = FACT_KINDS.reduce((sum, kind) => sum + count(facts[kind]), 0);
+    if (total === 0) lines.push(`    ${pc.dim(say("memory.factsNone"))}`);
+    else {
+      lines.push(
+        `    ${say("memory.factCounts", {
+          read: count(facts["read"]),
+          edit: count(facts["edit"]),
+          command: count(facts["command"]),
+          testResult: count(facts["test_result"]),
+          failure: count(facts["failure"]),
+          commit: count(facts["commit"]),
+          lifecycle: count(facts["lifecycle"]),
+          receiptSeen: count(facts["receipt_seen"])
+        })}`
+      );
+    }
+    lines.push("");
+  }
+  lines.push(`  ${pc.bold(say("memory.sources"))}`);
+  const sources = reply.sources ?? [];
+  if (sources.length === 0) lines.push(`    ${pc.dim(say("memory.sourcesNone"))}`);
+  for (const source of sources) {
+    lines.push(
+      `    ${say("memory.source", {
+        id: pc.cyan(word(source.id)),
+        harness: word(source.harness),
+        entry: word(source.entrypoint),
+        status: word(source.status),
+        generation: count(source.generation)
+      })}`
+    );
+  }
+  lines.push("");
+  lines.push(`  ${pc.bold(say("memory.projects"))}`);
+  const projects = reply.projects ?? [];
+  if (projects.length === 0) lines.push(`    ${pc.dim(say("memory.projectsNone"))}`);
+  for (const project of projects) {
+    lines.push(
+      `    ${say("memory.project", {
+        name: word(project.name, word(project.slug)),
+        slug: word(project.slug),
+        offers: count(project.offers)
+      })}`
+    );
+  }
+  lines.push("", pc.dim(`  ${say("memory.statusHint")}`));
+  return lines;
+}
+async function deleteSource(parsed, operation, sourceId) {
+  const url = new URL(`/api/memory/${operation}`, parsed.api);
+  let preview;
+  try {
+    preview = await catalogFetch(url, post({ target: { kind: "source", id: sourceId }, dryRun: true }));
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!preview.ok) return rejected(preview);
+  const plan = await preview.json();
+  if (!parsed.json) process.stdout.write(`${deletionPlanLines(operation, sourceId, plan).join("\n")}
+`);
+  if (!parsed.yes) {
+    if (parsed.json) process.stdout.write(`${JSON.stringify(plan, null, 2)}
+`);
+    else process.stderr.write(pc.dim(`  ${say("memory.confirmRequired")}
+
+`));
+    return 0;
+  }
+  let confirmation;
+  try {
+    confirmation = await catalogFetch(
+      url,
+      post({ planId: plan.planId, expectedRevision: plan.expectedRevision, confirm: true })
+    );
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!confirmation.ok) return rejected(confirmation);
+  const accepted = await confirmation.json();
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(accepted, null, 2)}
+`);
+    return 0;
+  }
+  const key = operation === "purge" ? "memory.purgeAccepted" : "memory.withdrawAccepted";
+  process.stdout.write(`  ${pc.green("\u2713")} ${say(key, { id: word(accepted.operationId) })}
+
+`);
+  return 0;
+}
+function deletionPlanLines(operation, sourceId, plan) {
+  const affected = plan.affected ?? {};
+  const retained = plan.retained?.length ?? 0;
+  const external = plan.externalCopies?.length ?? 0;
+  const stores = {
+    revisions: count(affected.revisions),
+    offers: count(affected.offers),
+    events: count(affected.events),
+    sources: count(affected.sources),
+    contexts: count(affected.contexts)
+  };
+  const counted = affected.facts !== void 0 || affected.jobs !== void 0;
+  return [
+    "",
+    `  ${pc.bold(say(operation === "purge" ? "memory.purgePreview" : "memory.withdrawPreview"))}`,
+    "",
+    `  ${say("memory.plan", {
+      planId: pc.cyan(plan.planId),
+      id: pc.cyan(sourceId),
+      revision: plan.expectedRevision,
+      expiresAt: word(plan.expiresAt)
+    })}`,
+    `  ${counted ? say("memory.planAffectedAll", { ...stores, facts: count(affected.facts), jobs: count(affected.jobs) }) : say("memory.planAffected", stores)}`,
+    `  ${retained === 0 ? pc.dim(say("memory.planRetainedNone")) : say("memory.planRetained", { n: retained })}`,
+    `  ${external === 0 ? pc.dim(say("memory.planExternalNone")) : say("memory.planExternal", { n: external })}`
+  ];
+}
+function scopeOf(parsed) {
+  if (parsed.all) return { scope: "global" };
+  if (parsed.project !== void 0) return { scope: "project", slug: parsed.project };
+  return void 0;
+}
+function scopeText(scope) {
+  return scope.scope === "global" ? say("memory.scopeGlobal") : say("memory.scopeProject", { slug: scope.slug });
+}
+async function setPermission(parsed, verb, source, purpose, extra) {
+  const scope = scopeOf(parsed);
+  if (source === void 0 || purpose === void 0 || extra !== void 0 || scope === void 0) {
+    process.stderr.write(
+      pc.red(`${say("memory.permissionUsage", { verb })}
+`) + pc.dim(`${say("memory.permissionUsageHint")}
+`)
+    );
+    return 1;
+  }
+  if (!isPermissionWord(purpose)) {
+    process.stderr.write(pc.red(`${say("memory.badPermissionPurpose", { value: purpose })}
+`));
+    return 1;
+  }
+  const notice = parsed.notice ?? 1;
+  const wire = PERMISSION_WIRE[purpose];
+  let response;
+  try {
+    response = await catalogFetch(
+      new URL("/api/twin/sources", parsed.api),
+      post({
+        source,
+        purpose: wire,
+        scope: scope.scope,
+        ...scope.scope === "project" ? { slug: scope.slug } : {},
+        allowed: verb === "allow",
+        noticeVersion: notice
+      })
+    );
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!response.ok) return rejected(response, PERMISSION_REFUSALS);
+  const reply = await response.json();
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(reply, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(
+    `${permissionLines(verb, purpose, source, scopeText(scope), notice, count(reply.permissionRevision)).join("\n")}
+`
+  );
+  return 0;
+}
+function permissionLines(verb, purpose, source, scope, notice, revision) {
+  const WORDS = {
+    capture: { on: "memory.captureOn", off: "memory.captureOff", boundary: "memory.captureBoundary", revoked: "memory.captureRevoked" },
+    extract: { on: "memory.extractOn", off: "memory.extractOff", boundary: "memory.extractBoundary", revoked: "memory.extractRevoked" },
+    twin: { on: "memory.twinOn", off: "memory.twinOff", boundary: "memory.twinBoundary", revoked: "memory.twinRevoked" }
+  };
+  const words = WORDS[purpose];
+  const lines = ["", `  ${pc.green("\u2713")} ${say(verb === "allow" ? words.on : words.off, { source: pc.cyan(source), scope, revision })}`];
+  if (verb === "allow") {
+    lines.push(`  ${say(words.boundary)}`);
+    if (purpose === "capture") lines.push(`  ${notice >= 2 ? say("memory.captureNotice2") : pc.dim(say("memory.captureNotice1"))}`);
+  } else {
+    lines.push(`  ${say(words.revoked)}`);
+  }
+  lines.push("");
+  return lines;
+}
+var INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:?\d{2})$/;
+function instantOf(value) {
+  if (!INSTANT.test(value)) return void 0;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? void 0 : new Date(ms).toISOString();
+}
+async function backfill(parsed, source, extra) {
+  const scope = scopeOf(parsed);
+  if (source === void 0 || extra !== void 0 || scope === void 0 || parsed.from === void 0 || parsed.until === void 0 || parsed.purpose === void 0) {
+    process.stderr.write(
+      pc.red(`${say("memory.backfillUsage")}
+`) + pc.dim(`${say("memory.backfillUsageHint")}
+`)
+    );
+    return 1;
+  }
+  const from = instantOf(parsed.from);
+  if (from === void 0) {
+    process.stderr.write(pc.red(`${say("memory.badInstant", { flag: "--from", value: parsed.from })}
+`));
+    return 1;
+  }
+  const until = instantOf(parsed.until);
+  if (until === void 0) {
+    process.stderr.write(pc.red(`${say("memory.badInstant", { flag: "--until", value: parsed.until })}
+`));
+    return 1;
+  }
+  if (until <= from) {
+    process.stderr.write(pc.red(`${say("memory.emptyRange")}
+`));
+    return 1;
+  }
+  if (parsed.limit !== void 0 && parsed.limit > BACKFILL_LIMIT_MAX) {
+    process.stderr.write(pc.red(`${say("memory.backfillLimit")}
+`));
+    return 1;
+  }
+  const url = new URL("/api/memory/backfill", parsed.api);
+  let preview;
+  try {
+    preview = await catalogFetch(
+      url,
+      post({
+        source,
+        purpose: parsed.purpose,
+        scope: scope.scope,
+        ...scope.scope === "project" ? { slug: scope.slug } : {},
+        from,
+        to: until,
+        dryRun: true,
+        ...parsed.limit !== void 0 ? { limit: parsed.limit } : {}
+      })
+    );
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!preview.ok) return rejected(preview, BACKFILL_REFUSALS);
+  const plan = await preview.json();
+  if (!parsed.json) {
+    process.stdout.write(
+      `${backfillPlanLines({ source, purpose: parsed.purpose, scope: scopeText(scope), from, until }, plan).join("\n")}
+`
+    );
+  }
+  if (!parsed.yes) {
+    if (parsed.json) process.stdout.write(`${JSON.stringify(plan, null, 2)}
+`);
+    else process.stderr.write(pc.dim(`  ${say("memory.confirmRequired")}
+
+`));
+    return 0;
+  }
+  let confirmation;
+  try {
+    confirmation = await catalogFetch(
+      url,
+      post({ planId: plan.planId, expectedRevision: plan.expectedRevision, confirm: true })
+    );
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!confirmation.ok) return rejected(confirmation, BACKFILL_REFUSALS);
+  const accepted = await confirmation.json();
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(accepted, null, 2)}
+`);
+    return 0;
+  }
+  const lines = [`  ${pc.green("\u2713")} ${say("memory.backfillAccepted", { id: word(accepted.operationId) })}`];
+  if (typeof accepted.queued === "number") lines.push(`  ${say("memory.backfillQueued", { n: accepted.queued })}`);
+  process.stdout.write(`${lines.join("\n")}
+
+`);
+  return 0;
+}
+function backfillPlanLines(asked, plan) {
+  const omitted = count(plan.omitted);
+  return [
+    "",
+    `  ${pc.bold(say("memory.backfillPreview"))}`,
+    "",
+    `  ${say("memory.backfillPlan", {
+      planId: pc.cyan(plan.planId),
+      id: pc.cyan(asked.source),
+      purpose: asked.purpose,
+      scope: asked.scope,
+      revision: plan.expectedRevision,
+      expiresAt: word(plan.expiresAt)
+    })}`,
+    `  ${say("memory.backfillRange", { from: asked.from, until: asked.until })}`,
+    `  ${say("memory.backfillReach", {
+      streams: count(plan.streams),
+      bytes: count(plan.bytes),
+      unreadable: count(plan.unreadable),
+      callsEstimate: count(plan.callsEstimate)
+    })}`,
+    ...omitted > 0 ? [`  ${say("memory.backfillOmitted", { n: omitted })}`] : []
+  ];
+}
+async function jobs(parsed, argument, third, fourth) {
+  if (argument === "retry" || argument === "cancel") {
+    if (third === void 0) {
+      process.stderr.write(pc.red(`${say("memory.needsJob", { verb: argument })}
+`));
+      return 1;
+    }
+    if (fourth !== void 0) return jobsUsage();
+    return jobAction(parsed, argument, third);
+  }
+  if (third !== void 0) return jobsUsage();
+  return listJobs(parsed, argument);
+}
+function jobsUsage() {
+  process.stderr.write(pc.red(`${say("memory.jobsUsage")}
+`));
+  return 1;
+}
+async function jobsPage(parsed, slug, cursor) {
+  const url = new URL("/api/memory/jobs", parsed.api);
+  if (slug !== void 0) url.searchParams.set("slug", slug);
+  if (cursor !== void 0) url.searchParams.set("cursor", cursor);
+  let response;
+  try {
+    response = await catalogFetch(url);
+  } catch {
+    return { code: unreachable(parsed.api) };
+  }
+  if (!response.ok) return { code: await rejected(response) };
+  return { page: await response.json() };
+}
+async function listJobs(parsed, slug) {
+  const answer = await jobsPage(parsed, slug, void 0);
+  if ("code" in answer) return answer.code;
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(answer.page, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(`${jobLines(answer.page, slug, parsed.api).join("\n")}
+`);
+  return 0;
+}
+function jobLines(page, slug, api) {
+  const title = slug === void 0 ? say("memory.jobs", { api }) : say("memory.jobsOf", { slug, api });
+  const lines = ["", `  ${pc.bold(title)}`, ""];
+  const rows = page.jobs ?? [];
+  if (rows.length === 0) {
+    lines.push(`    ${pc.dim(say("memory.jobsNone"))}`);
+  } else {
+    const header = [
+      say("memory.jobsColId"),
+      say("memory.jobsColProcessor"),
+      say("memory.jobsColStatus"),
+      say("memory.jobsColPurpose"),
+      say("memory.jobsColOrigin"),
+      say("memory.jobsColAttempts"),
+      say("memory.jobsColPaid"),
+      say("memory.jobsColReason"),
+      say("memory.jobsColRetryAt")
+    ];
+    const cells = rows.map((job) => [
+      word(job.id),
+      word(job.processor),
+      word(job.status),
+      word(job.purpose),
+      word(job.origin),
+      String(count(job.attempts)),
+      String(count(job.paidAttempts)),
+      word(job.reason, "-"),
+      word(job.retryAt, "-")
+    ]);
+    for (const line of table(header, cells)) lines.push(`    ${line}`);
+  }
+  lines.push("");
+  if (typeof page.nextCursor === "string" && page.nextCursor !== "") lines.push(`  ${pc.dim(say("memory.jobsMore"))}`);
+  lines.push(pc.dim(`  ${say("memory.jobsHint")}`));
+  return lines;
+}
+function table(header, rows) {
+  const widths = header.map((label, column) => Math.max(label.length, ...rows.map((row) => (row[column] ?? "").length)));
+  const line = (cells) => cells.map((cell, column) => cell.padEnd(widths[column] ?? 0)).join("  ").trimEnd();
+  return [pc.bold(line(header)), ...rows.map(line)];
+}
+async function jobAction(parsed, action, id) {
+  let cursor;
+  let found;
+  for (let pages = 0; pages < JOB_SEARCH_PAGES && found === void 0; pages++) {
+    const answer = await jobsPage(parsed, void 0, cursor);
+    if ("code" in answer) return answer.code;
+    found = (answer.page.jobs ?? []).find((job) => job.id === id);
+    if (typeof answer.page.nextCursor !== "string" || answer.page.nextCursor === "") break;
+    cursor = answer.page.nextCursor;
+  }
+  if (found === void 0) {
+    process.stderr.write(pc.red(`${say("memory.jobUnknown", { id })}
+`));
+    return 1;
+  }
+  let response;
+  try {
+    response = await catalogFetch(
+      new URL("/api/memory/jobs", parsed.api),
+      post({ id, action, expectedRevision: count(found.rev) })
+    );
+  } catch {
+    return unreachable(parsed.api);
+  }
+  if (!response.ok) return rejected(response, JOB_REFUSALS);
+  const reply = await response.json();
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(reply, null, 2)}
+`);
+    return 0;
+  }
+  const key = response.status === 202 ? action === "retry" ? "memory.jobRetryScheduled" : "memory.jobCancelled" : "memory.jobUnchanged";
+  process.stdout.write(`  ${pc.green("\u2713")} ${say(key, { id: pc.cyan(word(reply.id, id)), status: word(reply.status) })}
+
+`);
+  return 0;
+}
+function post(body) {
+  return {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  };
+}
+var DELETION_REFUSALS = {
+  stale_revision: { key: "memory.staleRevision", hint: "memory.staleRevisionHint" },
+  stale_plan: { key: "memory.stalePlan" }
+};
+var PERMISSION_REFUSALS = {
+  consent_required: { key: "memory.consentRequired" },
+  unsupported_source: { key: "memory.unsupportedSource" },
+  stale_revision: { key: "memory.permissionStale" }
+};
+var BACKFILL_REFUSALS = {
+  ...DELETION_REFUSALS,
+  stale_policy: { key: "memory.stalePolicy" },
+  consent_required: { key: "memory.consentRequired" },
+  unsupported_source: { key: "memory.unsupportedSource" }
+};
+var JOB_REFUSALS = {
+  stale_revision: { key: "memory.jobStale" },
+  not_retryable: { key: "memory.notRetryable" }
+};
+async function rejected(response, named = DELETION_REFUSALS) {
+  const refusal = await refusalOf(response);
+  const own = refusal.code === void 0 ? void 0 : named[refusal.code];
+  if (own !== void 0) {
+    process.stderr.write(
+      pc.red(`${say(own.key)}
+`) + (own.hint === void 0 ? "" : pc.dim(`${say(own.hint)}
+`)) + (refusal.detail === "" ? "" : pc.dim(`${refusal.detail}
+`))
+    );
+    return 1;
+  }
+  process.stderr.write(pc.red(`${say("cli.httpError", { status: response.status, detail: refusal.detail })}
+`));
+  return 1;
+}
+var REFUSAL_DETAIL_MAX = 200;
+async function refusalOf(response) {
+  const text = await response.text().catch(() => "");
+  try {
+    const body = JSON.parse(text);
+    const code = typeof body.code === "string" ? body.code : void 0;
+    const error = typeof body.error === "string" ? body.error : "";
+    const hint = typeof body.hint === "string" ? ` ${body.hint}` : "";
+    if (error) return { code, detail: `${error}${hint}` };
+  } catch {
+  }
+  return { detail: (text.split("\n")[0]?.trim() ?? "").slice(0, REFUSAL_DETAIL_MAX) };
+}
+export {
+  QUOTA_NEAR,
+  backfillPlanLines,
+  deletionPlanLines,
+  instantOf,
+  jobLines,
+  memoryCommand,
+  memoryStatusLines,
+  permissionLines,
+  quotaLines
+};