panoma 0.1.8 → 0.9.0

package/dist/chunk-AW6KPPIR.js

@@ -0,0 +1,378 @@
+import {
+  catalogFetch,
+  unreachable
+} from "./chunk-YQOQAFTY.js";
+import {
+  plural,
+  say
+} from "./chunk-P7ZGHSMO.js";
+
+// src/lang.ts
+import pc from "picocolors";
+var HELP = `
+${pc.bold(pc.cyan("panoma"))} ${pc.dim("\u2014 the local catalog of your projects")}
+
+${pc.bold("YOUR DAY")}
+  panoma                       the day's report: what moved since you last looked
+  panoma today                 the same thing, when you'd rather type it out
+  panoma next                  what to do in each project, and the fact that picked it
+                               (panoma next <project> <assignment> opens your agent on it)
+  panoma north                 what \u201Cfinished\u201D means in each project, and how many don\u2019t say
+  panoma north <project> "\u2026"   write it, or replace the one there after showing it to you
+  panoma open <project>        open it in your editor (--folder \xB7 --terminal \xB7 --all)
+  panoma scan [path]           analyze one project, or every project under the path
+
+${pc.bold("RITUALS")}
+  panoma up                    start the catalog (--on-boot, so it starts itself)
+  panoma up <folder>           start it and fill it from that folder, in one go
+  panoma up --network          and open it to your local network, with a key
+  panoma down                  stop it
+${say("apps.help")}
+${say("apps.videoHelp")}
+${say("apps.doctorHelp")}
+  panoma enrich                fetch latest versions and vulnerabilities for the catalog
+  panoma run <project> <package>  propose a dependency upgrade: installs it, runs the
+                               tests, and leaves a branch with the patch for you to review
+  panoma check <project>       does it still build? \u2014 installs and builds in isolation,
+                               in a separate worktree, and the page remembers the verdict
+  panoma agent-key <name>      create an agent key (--install writes it to .mcp.json)
+  panoma hooks --install       record what agents do here without them having to report it
+  panoma md check              what your CLAUDE.md claims that is no longer true
+  panoma md fix                repair what repairs itself: the lies that left a trail
+  panoma md init               adds a self-maintaining context block to AGENTS.md
+                               (needs the catalog up, like md sync)
+  panoma md sync               regenerate that block (needs the catalog up)
+  panoma memory export <project>  the project's memory as one JSON file: its notes in every
+                               state, its decisions and the extraction receipts (--out <file>)
+
+${pc.bold("DIAGNOSTICS")} ${pc.dim("(first-day questions)")}
+  panoma disk                  how much disk the catalog takes and how much regenerates itself
+  panoma search <text>         search the code of every project at once
+  panoma secrets               credentials committed to your repositories
+  panoma review [path]         what is wrong and provable without opening it: images that
+                               do not say what they show, broken links, stray colours and
+                               corners. No model, nothing spent
+  panoma describe <project>    ask the model to explain what a project is about; an
+                               unchanged project answers from what was saved (--force
+                               asks again anyway)
+  panoma md review             the model's opinion on your CLAUDE.md (paid; --force asks
+                               again even if the file did not change)
+  panoma ai                    which model Panoma uses and how to connect one
+  panoma ai use <provider>     pick a provider (--model <name> to pin which one)
+  panoma ai key <provider>     store an API key (read from stdin, never from an argument)
+  panoma ai ask <question>     check that the connection works (--provider <which>)
+  panoma spend                 what the models cost today and this month, and who holds
+                               each organ back (--json for the whole receipt)
+
+${pc.bold("YOUR TWIN")} ${pc.dim("(what your agents already know about you)")}
+  panoma twin sources          which agent histories are on this disk, how big they are
+                               and which ones are permitted to be read
+  panoma twin allow <source>   permit reading one: without it, not a file gets opened
+  panoma twin revoke <source>  take it back
+  panoma twin forget <source>  delete what was already stored from that source
+  panoma twin mine             what reading the permitted ones yields: funnel and samples
+                               (--source just one \xB7 --save stores them in the catalog)
+  panoma twin verdicts         what got stored, by project: when, and what you said
+  panoma twin distill          read those verdicts and pull out observations about your taste
+                               (--dry-run shows what it would cost, without spending it)
+  panoma twin synthesize       turn those observations into your portrait, without asking
+  panoma twin taste            the portrait that came out, and how much budget is left
+  panoma twin score            how often you correct it: the only mark Twin gives itself
+  panoma twin design           what yours looks like: the palette, typefaces and corners
+                               that repeat across your projects, with no model involved
+  panoma twin look <project>   show it a screen and it names the rule of yours it breaks,
+                               with the assignment already written (with no file, it takes
+                               the latest from the .panoma/shots inbox your agents fill)
+
+${pc.bold("OPTIONS")}
+  --json                       print the raw analysis as JSON
+  --out <file>                 with scan and memory export, write the JSON to a file
+  --verbose, -v                show dependencies and the health breakdown
+  --duplicates, -d             only the families of copies of the same project
+  --save                       send the result to the catalog (needs the web app running)
+  --api <url>                  catalog address (default http://localhost:4173)
+  --folder                     with open, reveal the folder in the file browser
+  --terminal                   with open, open a terminal already in the project
+  --all                        with open, open everything the project's plan lists: links,
+                               terminal, editor, agent; with twin distill, chain passes
+  --install                    with agent-key, write this folder's .mcp.json;
+                               with hooks, set up the passive capture
+  --remove                     with hooks, undo what --install left behind
+  --on-boot                    with up, start it at login
+  --force                      with enrich, skip the 24 h cache; with run, retry a
+                               proposal that already failed; with north, replace blind the
+                               north this terminal cannot read
+  --security                   with run, upgrade to the version that fixes the most
+                               severe vulnerability instead of the latest release
+  --isolation <level>          local \xB7 hardened \xB7 container. Defaults to the strongest
+                               one on this machine: a container when Docker or Podman is
+                               available; otherwise hardened, which on macOS seals off
+                               your home folder with sandbox-exec but leaves the network open
+  --limit <n>                  with twin mine, how many are shown (--save stores them
+                               all); with twin verdicts and twin distill, how many are read
+  --project <path>             with twin mine, only the sessions under that path
+  --source <source>            with twin mine, a single history instead of every permitted
+                               one: claude-code, codex\u2026; with twin verdicts, only the
+                               verdicts that came out of it
+  --dry-run                    with twin distill, stop at the estimate instead of spending
+  --depth <n>                  how deep to look for projects (default 3)
+  --no-git                     skip reading git (faster)
+  --help, -h                   this help
+
+${pc.bold("EXAMPLES")}
+  panoma                       the first thing in the morning
+  panoma next                  and the second: what to do, with the fact behind it
+  panoma open kestrel          open kestrel in your editor
+  panoma open kestrel --all    open its links, terminal and editor in one go
+  panoma up --on-boot          keep the catalog alive without thinking about it
+  panoma scan                  analyze the current directory
+  panoma scan ~/Desktop        find and analyze every project underneath
+  panoma scan . -v             full report with dependencies
+  panoma scan ~/Desktop -d     find copies of the same project and tell which one is alive
+  panoma scan ~/Desktop --save fill the catalog the web app reads
+  panoma scan ~/dev --json --out portfolio.json
+  panoma enrich                refresh versions and security advisories
+  panoma enrich --force        also re-check what was checked less than 24 h ago
+  panoma agent-key "Claude Code" --install   connect an agent to the catalog
+  panoma run panoma typescript propose upgrading typescript in the panoma project
+`;
+function helpText() {
+  return HELP;
+}
+
+// src/today.ts
+import pc2 from "picocolors";
+var VISIBLE_COMMITS = 6;
+async function todayCommand(api) {
+  const reply = await requestReport(api);
+  if (reply.state === "caido") return unreachable(api);
+  if (reply.state === "error") {
+    process.stderr.write(pc2.red(`${reply.error}
+`));
+    return 1;
+  }
+  process.stdout.write(render(reply.report, api));
+  return 0;
+}
+async function entryCommand(api) {
+  const reply = await requestReport(api);
+  if (reply.state === "caido") {
+    process.stdout.write(
+      `
+  ${pc2.yellow(say("today.notUp"))} ${pc2.dim(say("today.nobodyAt", { api }))}
+  ${pc2.dim(say("today.startIt"))} ${pc2.cyan("panoma up")} ${pc2.dim(say("today.andType"))} ${pc2.cyan("panoma")}${pc2.dim(".")}
+${helpText()}
+`
+    );
+    return 0;
+  }
+  if (reply.state === "error") {
+    process.stderr.write(pc2.red(`${reply.error}
+`));
+    return 1;
+  }
+  process.stdout.write(render(reply.report, api));
+  return 0;
+}
+function reportUrl(api, interactive) {
+  const url = new URL("/api/today", api);
+  if (!interactive) url.searchParams.set("fijo", "1");
+  return url;
+}
+async function requestReport(api) {
+  let reply;
+  try {
+    reply = await catalogFetch(reportUrl(api, process.stdout.isTTY === true));
+  } catch {
+    return { state: "caido" };
+  }
+  if (!reply.ok) {
+    if (reply.status === 404) {
+      return { state: "error", error: say("today.tooOld") };
+    }
+    const detail = await reply.text().catch(() => "");
+    return {
+      state: "error",
+      error: say("today.httpError", { status: reply.status, detail }).trim()
+    };
+  }
+  const raw = await reply.json().catch(() => void 0);
+  if (!raw) return { state: "error", error: say("today.badReport") };
+  const projects = (raw.projects ?? []).map((project) => ({
+    ...project,
+    commits: project.commits ?? [],
+    agents: project.agents ?? []
+  }));
+  return {
+    state: "ok",
+    report: {
+      since: raw.since ?? null,
+      // Without the field —a server older than this CLI— it is left at -1, which is not zero: the
+      // empty catalog message only appears when the server has said there is zero.
+      catalog: raw.catalog ?? -1,
+      now: raw.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+      projects,
+      proposals: raw.proposals ?? [],
+      born: raw.born ?? [],
+      critic: {
+        looks: raw.critic?.looks ?? 0,
+        lookFindings: raw.critic?.lookFindings ?? 0,
+        reviews: raw.critic?.reviews ?? 0,
+        reviewFindings: raw.critic?.reviewFindings ?? 0
+      },
+      summary: {
+        touchedProjects: raw.summary?.touchedProjects ?? projects.length,
+        commits: raw.summary?.commits ?? projects.reduce((sum, p) => sum + p.commits.length, 0),
+        byAgents: raw.summary?.byAgents ?? projects.reduce((sum, p) => sum + p.commits.filter((c) => c.agent).length, 0),
+        proposals: raw.summary?.proposals ?? raw.proposals?.length ?? 0,
+        born: raw.summary?.born ?? raw.born?.length ?? 0
+      }
+    }
+  };
+}
+function render(report, api) {
+  const since = period(report.since, report.now);
+  const { summary } = report;
+  const criticFindings = report.critic.lookFindings + report.critic.reviewFindings;
+  const nothingToTell = report.projects.length === 0 && report.proposals.length === 0 && report.born.length === 0 && criticFindings === 0 && summary.commits === 0;
+  if (report.catalog === 0) {
+    return `
+  ${pc2.yellow(say("today.emptyTitle"))}
+  ${pc2.dim(say("today.emptyBody"))}
+
+  ${pc2.cyan("panoma scan ~/Desktop --save")}
+
+`;
+  }
+  if (nothingToTell) {
+    return `
+  ${pc2.dim(say("today.nothing", { since }))}
+
+`;
+  }
+  const lines = [""];
+  lines.push(`  ${pc2.bold(say("today.title"))}  ${pc2.dim(`\xB7 ${since}`)}`);
+  lines.push("");
+  const reports = [
+    summary.touchedProjects > 0 ? say("today.projectsTouched", {
+      n: summary.touchedProjects,
+      s: plural(summary.touchedProjects)
+    }) : void 0,
+    summary.commits > 0 ? say("today.commits", { n: summary.commits, s: plural(summary.commits) }) : void 0,
+    // How many were written by a machine is the information that has nowhere else to be checked, so
+    // it goes in color and not in the grey list.
+    summary.byAgents > 0 ? pc2.magenta(say("today.fromAgents", { n: summary.byAgents })) : void 0,
+    summary.proposals > 0 ? pc2.yellow(say("today.proposals", { n: summary.proposals, s: plural(summary.proposals) })) : void 0,
+    summary.born > 0 ? pc2.cyan(say("today.newProjects", { n: summary.born, s: plural(summary.born) })) : void 0
+  ].filter(Boolean);
+  if (reports.length > 0) {
+    lines.push(`  ${reports.join(pc2.dim(" \xB7 "))}`);
+    lines.push("");
+  }
+  for (const project of report.projects) {
+    lines.push(`  ${pc2.cyan(pc2.bold(project.name || project.slug))}`);
+    for (const commit of project.commits.slice(0, VISIBLE_COMMITS)) {
+      const subject = trimTo(commit.subject ?? "", 62);
+      const signature = commit.agent ? `${subject.padEnd(62)}  ${pc2.magenta(commit.agent)}` : subject;
+      lines.push(`      ${pc2.dim((commit.sha ?? "").slice(0, 7).padEnd(7))}  ${signature}`);
+    }
+    const rest = project.commits.length - VISIBLE_COMMITS;
+    if (rest > 0)
+      lines.push(pc2.dim(`      ${say("today.andMoreCommits", { n: rest, s: plural(rest) })}`));
+    if (project.agents.length > 0) {
+      lines.push(
+        `      ${project.agents.map((agent) => `${pc2.magenta(agent.name)} ${pc2.dim(`${agent.activities}`)}`).join(pc2.dim(" \xB7 "))}`
+      );
+    }
+    lines.push("");
+  }
+  if (report.proposals.length > 0) {
+    lines.push(`  ${pc2.bold(pc2.yellow(say("today.waiting")))}`);
+    for (const proposal of report.proposals) {
+      const stamp = proposal.verified ? pc2.green(say("today.verified")) : pc2.yellow(say("today.unverified"));
+      lines.push(
+        // Without a destination the arrow is not written: «picocolors → null» is worse than
+        // «picocolors».
+        `      ${(proposal.project || proposal.slug).padEnd(18)}${(proposal.a ? `${proposal.pkgName} \u2192 ${proposal.a}` : proposal.pkgName).padEnd(38)}${stamp}`
+      );
+    }
+    const target = report.proposals.length === 1 && report.proposals[0]?.id ? `${api}/runs/${report.proposals[0].id}` : `${api}/runs`;
+    lines.push(pc2.dim(`      ${say("today.decideAt", { url: target })}`));
+    lines.push("");
+  }
+  if (criticFindings > 0) {
+    lines.push(`  ${pc2.bold(say("today.critic"))}`);
+    if (report.critic.lookFindings > 0) {
+      lines.push(
+        `      ${say("today.criticLooks", {
+          n: report.critic.lookFindings,
+          shots: report.critic.looks
+        })}`
+      );
+    }
+    if (report.critic.reviewFindings > 0) {
+      lines.push(
+        `      ${say("today.criticReviews", {
+          n: report.critic.reviewFindings,
+          projects: report.critic.reviews
+        })}`
+      );
+    }
+    lines.push(`      ${pc2.dim(say("today.criticWhere"))}`, "");
+  }
+  if (report.born.length > 0) {
+    lines.push(`  ${pc2.bold(say("today.born"))}`);
+    for (const fresh of report.born) {
+      const name = fresh.name || fresh.slug;
+      const when = sinceMs(fresh.when, report.now);
+      lines.push(`      ${pc2.cyan(when ? name.padEnd(24) : name)}${pc2.dim(when)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
+function trimTo(text, width) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > width ? `${clean.slice(0, width - 1)}\u2026` : clean;
+}
+function period(since, now) {
+  if (!since) return say("today.firstLook");
+  const start = new Date(since);
+  const fin = new Date(now);
+  if (Number.isNaN(start.getTime()) || Number.isNaN(fin.getTime())) {
+    return say("today.sinceLastVisit");
+  }
+  const locale = "en-US";
+  const time = start.toLocaleTimeString(locale, { hour: "2-digit", minute: "2-digit" });
+  const days = Math.round((midnight(fin) - midnight(start)) / 864e5);
+  if (days <= 0) return say("today.sinceToday", { time });
+  if (days === 1) return say("today.sinceYesterday", { time });
+  if (days < 7) {
+    return say("today.sinceWeekday", {
+      weekday: start.toLocaleDateString(locale, { weekday: "long" }),
+      time
+    });
+  }
+  return say("today.sinceDate", {
+    date: start.toLocaleDateString(locale, { day: "numeric", month: "long" })
+  });
+}
+function midnight(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function sinceMs(when, now) {
+  const minutes = Math.floor((Date.parse(now) - Date.parse(when)) / 6e4);
+  if (!Number.isFinite(minutes) || minutes < 0) return "";
+  if (minutes < 60) return say("today.minutesAgo", { n: Math.max(minutes, 1) });
+  if (minutes < 60 * 24) return say("today.hoursAgo", { n: Math.floor(minutes / 60) });
+  const days = Math.floor(minutes / (60 * 24));
+  return say("today.daysAgo", { n: days, s: plural(days) });
+}
+
+export {
+  helpText,
+  todayCommand,
+  entryCommand,
+  reportUrl,
+  sinceMs
+};

package/dist/chunk-BCHIG2AU.js

@@ -0,0 +1,166 @@
+import {
+  catalogFetch,
+  unreachable
+} from "./chunk-YQOQAFTY.js";
+import {
+  appFaultText,
+  say
+} from "./chunk-P7ZGHSMO.js";
+
+// src/apps.ts
+import { createInterface } from "readline/promises";
+async function appsFetch(api, path, body, signal) {
+  const response = await catalogFetch(new URL(path, api), body === void 0 ? { signal } : {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal
+  });
+  const value = await response.json();
+  if (!response.ok && !(response.status === 409 && typeof value.id === "string")) {
+    throw new Error(typeof value.error === "string" ? value.error : String(response.status));
+  }
+  return value;
+}
+async function confirmApps(message) {
+  process.stderr.write(`${message}
+`);
+  if (!process.stdin.isTTY) return false;
+  const reader = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return (await reader.question(say("apps.confirm"))).trim().toLowerCase() === "yes";
+  } finally {
+    reader.close();
+  }
+}
+async function followAppJob(api, id, json, quiet = false) {
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  let last = "";
+  process.stderr.write(`${say("apps.job", { id })}
+`);
+  try {
+    for (; ; ) {
+      const job = await appsFetch(api, `/api/apps/jobs/${encodeURIComponent(id)}?wait=1`, void 0, controller.signal);
+      const message = `${job.status}:${job.progress?.message ?? ""}`;
+      if (message !== last) {
+        process.stderr.write(`${say("apps.jobProgress", { status: job.status, message: job.progress?.message ?? "" })}
+`);
+        last = message;
+      }
+      if (job.status === "done") {
+        if (!quiet) process.stdout.write(json ? `${JSON.stringify(job, null, 2)}
+` : `${say("apps.jobDone", { id })}
+`);
+        return 0;
+      }
+      if (job.status === "cancelled") {
+        process.stderr.write(`${say("apps.cancelled")}
+`);
+        return 3;
+      }
+      if (job.status === "failed") {
+        process.stderr.write(`${appFaultText(job.error ?? job.status, "apps.jobFailed")}
+`);
+        if (json) process.stdout.write(`${JSON.stringify(job, null, 2)}
+`);
+        return 1;
+      }
+    }
+  } catch (reason) {
+    if (controller.signal.aborted) {
+      process.stderr.write(`${say("apps.jobDetached", { id })}
+`);
+      return 0;
+    }
+    throw reason;
+  } finally {
+    process.removeListener("SIGINT", stop);
+  }
+}
+async function appsCommand(flags) {
+  const verb = flags.positionals[1];
+  const id = flags.positionals[2];
+  if (verb && (!id || !["install", "update", "rollback", "remove", "clean", "doctor", "enable", "disable", "check"].includes(verb))) {
+    process.stderr.write(`${say("apps.usage")}
+`);
+    return 1;
+  }
+  try {
+    if (!verb) {
+      const result = await appsFetch(flags.api, "/api/apps");
+      process.stdout.write(flags.json ? `${JSON.stringify(result, null, 2)}
+` : result.apps.map((app) => say("apps.line", {
+        id: app.id,
+        status: app.ready ? "ready" : app.status,
+        version: app.version ?? "\u2014"
+      })).join("\n") + "\n");
+      return 0;
+    }
+    const path = `/api/apps/${encodeURIComponent(id)}`;
+    if (verb === "doctor") {
+      let app = await appsFetch(flags.api, path);
+      if (app.version) {
+        const job = await appsFetch(flags.api, `${path}/doctor`, {});
+        const checked = await followAppJob(flags.api, job.id, false, true);
+        if (checked !== 0) return checked;
+        app = await appsFetch(flags.api, path);
+      }
+      if (flags.json) process.stdout.write(`${JSON.stringify(app, null, 2)}
+`);
+      else {
+        const requirements = Array.isArray(app.requirements) ? app.requirements : Object.entries(app.requirements ?? {}).filter(([, value]) => value && typeof value === "object").map(([name, value]) => ({ id: name, ...value }));
+        for (const item of requirements) process.stdout.write(`${say("apps.requirement", {
+          name: item.id,
+          status: say(item.present === true ? "apps.present" : item.present === false ? "apps.missing" : "apps.unchecked")
+        })}
+`);
+      }
+      return app.version ? app.ready ? 0 : 1 : 2;
+    }
+    if (verb === "clean") {
+      const app = await appsFetch(flags.api, `${path}?space=1`);
+      if (!await confirmApps(say("apps.cleanConfirm", { bytes: app.space?.dataBytes ?? 0 }))) {
+        process.stderr.write(`${say("apps.cancelled")}
+`);
+        return 3;
+      }
+    }
+    const operation = verb === "remove" ? "uninstall" : verb;
+    const queued = await appsFetch(flags.api, `${path}/${operation}`, verb === "clean" ? { confirm: true } : {});
+    const chainingBrowser = verb === "install" && flags.browser;
+    const exit = queued.id ? await followAppJob(flags.api, queued.id, flags.json, chainingBrowser) : 0;
+    if (exit !== 0 || verb !== "install" || !flags.browser) return exit;
+    const installed = await appsFetch(flags.api, path);
+    const browserRequirement = installed.manifest?.requirements?.find((item) => item.kind === "playwright-browser");
+    if (!browserRequirement) {
+      process.stderr.write(`${say("apps.browserUndeclared")}
+`);
+      return 0;
+    }
+    if (!await confirmApps(say("apps.browserConsent", {
+      browser: browserRequirement.browser ?? browserRequirement.id,
+      terms: browserRequirement.termsUrl ?? "",
+      n: browserRequirement.approxMB ?? 0
+    }))) {
+      process.stderr.write(`${say(process.stdin.isTTY ? "apps.cancelled" : "apps.browserRequired")}
+`);
+      return 3;
+    }
+    const browser = await appsFetch(flags.api, `${path}/browser`, {});
+    return followAppJob(flags.api, browser.id, flags.json);
+  } catch (reason) {
+    if (reason instanceof TypeError) return unreachable(flags.api);
+    process.stderr.write(`${appFaultText(reason.message, "apps.rejected")}
+`);
+    return 1;
+  }
+}
+
+export {
+  appsFetch,
+  confirmApps,
+  followAppJob,
+  appsCommand
+};

package/dist/chunk-DITTKJ7U.js

@@ -0,0 +1,147 @@
+// ../../packages/apps/dist/chunk-4G5NKAON.js
+var MANAGER_FAULTS = [
+  // Reachable: an ordinary person meets these.
+  "offline",
+  "npm-not-found",
+  "node-too-old",
+  "npm-too-old",
+  "engine-unsupported",
+  "does-not-start",
+  "cancelled",
+  "timeout",
+  "stalled",
+  "process-failed",
+  "no-previous-version",
+  "not-installed",
+  "app-operation-in-progress",
+  "playwright-not-installed",
+  "browser-not-declared",
+  "malformed-requirements",
+  "incompatible-protocol",
+  "staged-update-invalid",
+  "disk-unreadable",
+  "unknown-app",
+  // Reachable through the operating system rather than through a check of ours.
+  "no-space-left",
+  "permission-denied",
+  "read-only-disk",
+  "too-many-open-files",
+  "disk-error",
+  "command-did-not-start",
+  // A damaged download. Reachable, but only one sentence is worth saying about all of them.
+  "broken-installation",
+  "broken-package-manifest",
+  "package-outside-installation",
+  "package-version-mismatch",
+  "manifest-id-mismatch",
+  "manifest-file-missing-or-outside",
+  "invalid-version",
+  // Guards: corrupt state or a programming mistake, unreachable while both are sound.
+  "path-outside-home",
+  "managed-path-is-symlink",
+  "use-clean-data",
+  "invalid-brain-budget",
+  "provider-key-not-allowed",
+  "fixtures-are-test-only",
+  "fixture-registry-must-be-loopback"
+];
+var HOST_FAULTS = [
+  "local-catalog-required",
+  "unknown-app-operation",
+  "app-not-enabled",
+  "provider-not-enabled",
+  "app-budget-exhausted",
+  "provider-key-missing",
+  "voice-key-missing",
+  "requirement-missing",
+  "interrupted",
+  "app-failed",
+  "invalid-identity",
+  "music-outside-project",
+  "provider-confirmation-required",
+  "unknown-setting",
+  "invalid-brain",
+  "invalid-voice",
+  "malformed-guide",
+  "protocol-mismatch",
+  "invalid-job-id",
+  "invalid-body",
+  "body-too-large",
+  "invalid-app-input",
+  "unknown-app-input",
+  "unknown-app-tool",
+  "invalid-brief_id",
+  "invalid-render_id",
+  "invalid-hook",
+  "invalid-job",
+  "invalid-document",
+  "local-url-required",
+  "job-not-found",
+  "app-job-not-found",
+  "project-not-found",
+  "ambiguous-project",
+  "app-request-failed",
+  "artifact-not-found",
+  "invalid-range",
+  "review-failed",
+  "stage-failed",
+  "no-supported-production",
+  "app-error",
+  "unexpected-operation-input",
+  "invalid-app-job-transition",
+  "invalid-app-spend-receipt"
+];
+var APP_FAULTS = [...MANAGER_FAULTS, ...HOST_FAULTS];
+var KNOWN = new Set(APP_FAULTS);
+function isAppFaultCode(value) {
+  return KNOWN.has(value);
+}
+var AppFault = class extends Error {
+  constructor(code, detail, options) {
+    super(detail ? `${code}: ${detail}` : code, options);
+    this.code = code;
+    this.detail = detail;
+    this.name = "AppFault";
+  }
+  code;
+  detail;
+};
+function faultOf(value) {
+  const message = value instanceof Error ? value.message : typeof value === "string" ? value : "";
+  const cut = message.indexOf(": ");
+  const head = cut === -1 ? message : message.slice(0, cut);
+  if (!isAppFaultCode(head)) return { code: null, ...message ? { detail: message } : {} };
+  return cut === -1 ? { code: head } : { code: head, detail: message.slice(cut + 2) };
+}
+var FAULT_PART = " | ";
+var ERRNO = {
+  ENOSPC: "no-space-left",
+  EDQUOT: "no-space-left",
+  EACCES: "permission-denied",
+  EPERM: "permission-denied",
+  EROFS: "read-only-disk",
+  EMFILE: "too-many-open-files",
+  ENFILE: "too-many-open-files",
+  ELOOP: "disk-error",
+  EIO: "disk-error"
+};
+function asAppFault(value, fallback = "disk-error") {
+  if (value instanceof AppFault) return value;
+  const errno = value?.code;
+  if (typeof errno === "string" && ERRNO[errno]) return new AppFault(ERRNO[errno], errno);
+  const said = value instanceof Error ? value.message : String(value ?? "");
+  const known = faultOf(said);
+  if (known.code) return new AppFault(known.code, known.detail);
+  return new AppFault(fallback, said.slice(0, 300) || void 0);
+}
+
+export {
+  MANAGER_FAULTS,
+  HOST_FAULTS,
+  APP_FAULTS,
+  isAppFaultCode,
+  AppFault,
+  faultOf,
+  FAULT_PART,
+  asAppFault
+};