@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/{chunk-OT2O76OS.js → chunk-UGUP3ZM6.js}

@@ -11,7 +11,7 @@ import {
   generateAssistantFiles,
   parseHeader,
   writeAssistantFiles
-} from "./chunk-IPKHE5D6.js";
+} from "./chunk-BEVTIBRH.js";
 import {
   CONSTITUTION_FILE_LABEL,
   buildContext,
@@ -33,7 +33,7 @@ import {
   sectionMatching,
   toFinding,
   writeFinding
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-S4PMJU6H.js";
 import {
   changeFolder,
   changeFootprint,
@@ -41,10 +41,13 @@ import {
   changeTypeOf,
   loadChangeContext,
   referenceMetarepoIn
-} from "./chunk-XY3P7JW7.js";
+} from "./chunk-IDKCWSM5.js";
 import {
   readSpecKitFeatures
-} from "./chunk-MC3H7736.js";
+} from "./chunk-CQDGOPGH.js";
+import {
+  fsRepo
+} from "./chunk-3NFFJL5D.js";
 import {
   baseClonePath,
   changeWorktreesDir,
@@ -52,14 +55,11 @@ import {
   loadRepos,
   readChangeRepos,
   toRepoRelative
-} from "./chunk-EFHQ3TWP.js";
-import {
-  fsRepo
-} from "./chunk-GQ4N4WKF.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   buildContextPack,
   toRunSummary
-} from "./chunk-CNUKCS2T.js";
+} from "./chunk-P32RUW3B.js";
 import {
   ChecklistPack,
   Finding,
@@ -68,13 +68,16 @@ import {
   changesRelOf,
   normalizePath,
   orgPackDirOf,
-  require_dist,
   taskBranch,
   toCanonicalYaml
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 import {
+  renameRetrying,
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -114,7 +117,8 @@ function readChangeTasks(files) {
       title: rest.replace(/\s*\((?:story|stories)\b[^)]*\)\s*$/i, "").trim(),
       stories,
       line: i + 1,
-      done: m[2].toLowerCase() === "x"
+      done: m[2].toLowerCase() === "x",
+      .../(^|\s)\[P\](\s|$)/.test(rest) ? { parallel: true } : {}
     });
   });
   return out;
@@ -128,10 +132,34 @@ async function markTaskDone(root, changeId, task) {
     return false;
   if (m[2].toLowerCase() === "x")
     return false;
-  lines[task.line - 1] = l.replace(TASK_LINE, (_a, a, _b, c, d, e) => `${a}x${c}${d} ${e}`);
+  lines[task.line - 1] = `${m[1]}x${m[3]}${m[4]} ${m[5]}${l.endsWith("\r") ? "\r" : ""}`;
   await writeFileAtomic(path, lines.join("\n"));
   return true;
 }
+async function setTaskDone(root, changeId, taskId, done) {
+  const path = join(changeFolder(root, changeId), "tasks.md");
+  const text = await readFile(path, "utf8").catch(() => void 0);
+  if (text === void 0)
+    return false;
+  const lines = text.split("\n");
+  let repo = false;
+  for (const [i, l] of lines.entries()) {
+    if (/^##\s+\S/.test(l)) {
+      repo = true;
+      continue;
+    }
+    const m = repo ? TASK_LINE.exec(l.replace(/\r$/, "")) : null;
+    if (!m || m[4].toLowerCase() !== taskId.toLowerCase())
+      continue;
+    if (m[2].toLowerCase() === "x" === done)
+      return false;
+    const at = m[1].length;
+    lines[i] = `${l.slice(0, at)}${done ? "x" : " "}${l.slice(at + m[2].length)}`;
+    await writeFileAtomic(path, lines.join("\n"));
+    return true;
+  }
+  return false;
+}
 function readStory(files, id) {
   const doc = files.docs.get(`stories/${id}.md`);
   if (!doc)
@@ -226,7 +254,7 @@ function mappingSections(doc) {
 }
 
 // packages/speckit/dist/handdown.js
-import { mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile as readFile2, rm, writeFile } from "node:fs/promises";
 import { dirname, join as join3 } from "node:path";
 
 // packages/speckit/dist/constitution.js
@@ -399,6 +427,24 @@ function repoData(t) {
 function contractFile(t) {
   return `contracts/${t.component}.yaml`;
 }
+function designSummary(t) {
+  const design = docOf(t.files, "design.md");
+  const body = (s, from = s.line) => design.rawLines.slice(from, s.end).join("\n").trim();
+  const approach = sectionMatching(design, /^approach$/i);
+  if (design && approach)
+    return body(approach);
+  const flows = sectionMatching(design, /^target flows$/i);
+  if (design && flows) {
+    const repo = `(${t.repo.id}, `;
+    const mine = design.sections.filter((s) => s.level === flows.level + 1 && s.line > flows.line && s.line <= flows.end && s.heading.endsWith(")") && s.heading.includes(repo));
+    if (mine.length)
+      return mine.map((s) => body(s, s.line - 1)).join("\n\n");
+  }
+  const decisions = sectionMatching(design, /^decisions$/i);
+  if (design && decisions)
+    return body(decisions);
+  return `[${NC}: the change's design.md has no Approach, Decisions or target flow for ${t.repo.id}]`;
+}
 function renderPlan(t) {
   const { calls, serves } = repoHops(t);
   const data = repoData(t);
@@ -411,9 +457,7 @@ function renderPlan(t) {
   const platforms = [
     ...new Set(t.ctx.records.filter((r) => r.kind === "Deployment" && r.component === t.component).map((r) => r.platform))
   ].sort();
-  const design = docOf(t.files, "design.md");
-  const approach = sectionMatching(design, /^approach$/i);
-  const summary = design && approach ? design.rawLines.slice(approach.line, approach.end).join("\n").trim() : `[${NC}: the change's design.md has no Approach section]`;
+  const summary = designSummary(t);
   const status = (s) => /^planned-(new|modify|retire)$/.test(s) ? s : "planned-new";
   const mapping = mappingSections(docOf(t.files, "mappings.md")).filter((m) => [...calls, ...serves].some((h) => h.method === m.method && h.path === m.path));
   const feature = `specs/${t.task.id}`;
@@ -629,8 +673,13 @@ async function putIfFree(dir, rel, text, force, r) {
     return;
   }
   await mkdir(dirname(full), { recursive: true });
-  await writeFile(`${full}.atticus-tmp`, text, "utf8");
-  await rename(`${full}.atticus-tmp`, full);
+  try {
+    await writeFile(`${full}.atticus-tmp`, text, "utf8");
+    await renameRetrying(`${full}.atticus-tmp`, full);
+  } catch (e) {
+    await rm(`${full}.atticus-tmp`, { force: true });
+    throw e;
+  }
   r.written.push(rel);
 }
 function handDownFiles(t, engine) {
@@ -680,8 +729,12 @@ async function handDown(root, changeId, taskId, o = {}) {
     assistantFiles: { results: [], upToDate: true },
     problems: []
   };
+  const commit = o.commit !== false;
+  const git = o.git ?? createGit();
+  const dirty = commit ? await dirtyPaths(git, dir) : /* @__PURE__ */ new Set();
   for (const [rel, text] of handDownFiles(t, engine))
     await putIfFree(dir, rel, text, !!o.force, r);
+  const whole = new Set(r.written);
   const ref = await referenceMetarepoIn(root, dir, o.git ? { git: o.git } : {});
   if (ref.action === "added")
     r.written.push(ref.file);
@@ -726,25 +779,52 @@ async function handDown(root, changeId, taskId, o = {}) {
   });
   r.assistantFiles = { results: af.results, upToDate: af.upToDate };
   r.problems.push(...af.problems);
-  if (o.commit !== false && (r.written.length || af.results.some((x) => x.written))) {
-    const git = o.git ?? createGit();
-    await git(["add", "-A", "--", "."], dir);
-    const staged = (await git(["diff", "--cached", "--name-only"], dir)).stdout.trim();
-    if (staged) {
-      await git([
-        "commit",
-        "-q",
-        "-m",
-        `Hand down task ${t.task.id} of ${t.change.id}: ${t.task.title}`,
-        "-m",
-        `Atticus-Change: ${t.change.id}
-Atticus-Task: ${t.task.id}`
-      ], dir);
-      r.commit = (await git(["rev-parse", "HEAD"], dir)).stdout.trim();
+  if (commit) {
+    const ours = [];
+    for (const p of [...r.written, ...af.results.filter((x) => x.written).map((x) => x.path)]) {
+      if (ours.includes(p))
+        continue;
+      if (dirty.has(p) && !whole.has(p)) {
+        r.problems.push(`${p} had your uncommitted edits, so the hand-down didn't commit it: Atticus's part is in the file with yours. Commit it yourself when it's ready.`);
+        continue;
+      }
+      ours.push(p);
+    }
+    if (ours.length) {
+      await git(["add", "-A", "--", ...ours.map(literal)], dir);
+      const staged = (await git(["diff", "--cached", "--name-only", "--", ...ours.map(literal)], dir)).stdout.trim();
+      if (staged) {
+        await git([
+          "commit",
+          "-q",
+          "--only",
+          "-m",
+          `Hand down task ${t.task.id} of ${t.change.id}: ${t.task.title}`,
+          "-m",
+          `Atticus-Change: ${t.change.id}
+Atticus-Task: ${t.task.id}`,
+          "--",
+          ...ours.map(literal)
+        ], dir);
+        r.commit = (await git(["rev-parse", "HEAD"], dir)).stdout.trim();
+      }
     }
   }
   return r;
 }
+var literal = (p) => `:(literal)${p}`;
+async function dirtyPaths(git, dir) {
+  const out = (await git(["-c", "core.quotePath=false", "status", "--porcelain", "-z", "--untracked-files=all"], dir)).stdout;
+  const parts = out.split("\0").filter(Boolean);
+  const paths = /* @__PURE__ */ new Set();
+  for (let k = 0; k < parts.length; k++) {
+    const e = parts[k];
+    paths.add(e.slice(3));
+    if (/^[RC]/.test(e) && parts[k + 1])
+      paths.add(parts[++k]);
+  }
+  return paths;
+}
 
 // packages/speckit/dist/drift.js
 import { existsSync as existsSync2 } from "node:fs";
@@ -825,19 +905,111 @@ function taskWorktreePath(root, change, task, repo) {
       throw new SpecKitError("invalid", `${what} "${v}" must be a lowercase slug`);
   return join5(changeWorktreesDir(root, change), ".tasks", task, repo);
 }
-async function openTaskWorktree(root, change, task, repo, git = createGit()) {
+async function catchUpChangeBranch(root, change, task, repo, changeDir, git = createGit(), o = {}) {
+  const base = baseClonePath(root, repo);
+  if (!existsSync(base))
+    return void 0;
+  const from = changeBranch(change);
+  const rev = (ref) => git(["rev-parse", "--verify", "--quiet", ref], base).then((r) => r.stdout.trim() || void 0, () => void 0);
+  if (!o.settled && await rev(`refs/heads/${taskBranch(change, task)}`))
+    return void 0;
+  const local = await rev(`refs/heads/${from}`);
+  if (!local)
+    return void 0;
+  const onHost = await git(["ls-remote", "--heads", "origin", `refs/heads/${from}`], base).then((r) => r.stdout.trim(), () => "");
+  if (!onHost)
+    return void 0;
+  const fetched = await git(["fetch", "-q", "origin", `+refs/heads/${from}:refs/remotes/origin/${from}`], base).then(() => true, () => false);
+  const remote = fetched ? await rev(`refs/remotes/origin/${from}`) : void 0;
+  if (!remote || remote === local)
+    return void 0;
+  const ancestor = (a, b) => git(["merge-base", "--is-ancestor", a, b], base).then(() => true, () => false);
+  if (await ancestor(remote, local))
+    return void 0;
+  const onlyHandDowns = async (onHostTip, localTip) => {
+    try {
+      const log = await git(["log", "--format=%P%x00%B%x1e", `${onHostTip}..${localTip}`], base);
+      const commits = log.stdout.split("").map((c) => c.replace(/^\n+/, "")).filter(Boolean);
+      if (commits.length === 0)
+        return false;
+      for (const c of commits) {
+        const [parents = "", body = ""] = c.split("\0");
+        if (parents.trim().split(/\s+/).length !== 1)
+          return false;
+        if (!body.startsWith("Hand down task "))
+          return false;
+        if (!body.split("\n").includes(`Atticus-Change: ${change}`))
+          return false;
+      }
+      const diff = await git(["diff", "--name-only", "-z", `${onHostTip}...${localTip}`], base);
+      const files = [...new Set(diff.stdout.split("\0").filter(Boolean))];
+      if (files.length > 0)
+        await git(["--literal-pathspecs", "diff", "--quiet", onHostTip, localTip, "--", ...files], base);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const rel = changeDir.slice(root.length + 1).replace(/\\/g, "/");
+  const note = (handedDown2) => `Brought ${from} in ${repo} up to the Git host's first (the tasks merged into it there).${handedDown2 ? " Its local hand-down commits were already there, in the tasks' merged PRs." : ""}`;
+  const behind = await ancestor(local, remote);
+  const handedDown = !behind && await onlyHandDowns(remote, local);
+  if (!behind && !handedDown)
+    throw new SpecKitError("refused", `${from} in ${repo} has commits the Git host's hasn't, and the host's has commits it hasn't (tasks merged there): Atticus doesn't rewrite it. Merge origin/${from} into it in ${rel} (or push it), then run task ${task} again.`);
+  const there = await git(["symbolic-ref", "-q", "HEAD"], changeDir).then((r) => r.stdout.trim(), () => "");
+  if (there !== `refs/heads/${from}`) {
+    const list = await git(["worktree", "list", "--porcelain"], base);
+    const out = list.stdout.split("\n").includes(`branch refs/heads/${from}`);
+    if (out) {
+      const has = there ? there.replace(/^refs\/heads\//, "") : "a detached HEAD";
+      const own = there ? ` (commit your work on ${has} first)` : "";
+      throw new SpecKitError("refused", `${from} in ${repo} is behind the Git host's (tasks merged there), but the change worktree ${rel} has ${has} checked out, not ${from}, and ${from} is checked out in another worktree: Atticus doesn't move a branch you're working on. Switch ${rel} back to ${from}${own}, then run task ${task} again.`);
+    }
+    await git(["update-ref", `refs/heads/${from}`, remote, local], base);
+    return note(handedDown);
+  }
+  try {
+    await git(handedDown ? ["reset", "-q", "--keep", remote] : ["merge", "-q", "--ff-only", remote], changeDir);
+  } catch (e) {
+    throw new SpecKitError("refused", `${from} in ${repo} is behind the Git host's (tasks merged there), and it can't fast-forward in ${rel}: ${(e instanceof Error ? e.message : String(e)).trim()}. Commit or put aside the edits there, then run task ${task} again.`);
+  }
+  return note(handedDown);
+}
+async function taskBranchOwnCommits(root, change, task, repo, git = createGit()) {
+  const base = baseClonePath(root, repo);
+  if (!existsSync(base))
+    return 0;
+  const branch = taskBranch(change, task);
+  const from = changeBranch(change);
+  const has = (ref) => git(["rev-parse", "--verify", "--quiet", ref], base).then((r2) => !!r2.stdout.trim(), () => false);
+  if (!await has(`refs/heads/${branch}`))
+    return 0;
+  await git(["fetch", "-q", "origin", `+refs/heads/${from}:refs/remotes/origin/${from}`], base).catch(() => void 0);
+  const not = [];
+  for (const ref of [`refs/heads/${from}`, `refs/remotes/origin/${from}`])
+    if (await has(ref))
+      not.push(ref);
+  const r = await git(["rev-list", "--count", `refs/heads/${branch}`, "--not", ...not], base);
+  return Number(r.stdout.trim()) || 0;
+}
+async function openTaskWorktree(root, change, task, repo, git = createGit(), o = {}) {
   const path = taskWorktreePath(root, change, task, repo);
   const branch = taskBranch(change, task);
-  if (existsSync(path))
+  if (existsSync(path)) {
+    if (o.fresh)
+      await fastForwardTask(root, change, task, repo, path, git);
     return { path, branch, created: false };
+  }
   const base = baseClonePath(root, repo);
   if (!existsSync(base))
     throw new SpecKitError("refused", `There is no base clone of ${repo}; run atticus workspace sync first.`);
   const ok = async (ref) => git(["rev-parse", "--verify", "--quiet", ref], base).then(() => true, () => false);
   await mkdir2(dirname2(path), { recursive: true });
-  if (await ok(`refs/heads/${branch}`))
+  if (await ok(`refs/heads/${branch}`)) {
+    if (o.fresh)
+      await fastForwardTask(root, change, task, repo, void 0, git);
     await git(["worktree", "add", "--", path, branch], base);
-  else {
+  } else {
     const from = changeBranch(change);
     if (!await ok(`refs/heads/${from}`))
       throw new SpecKitError("refused", `${repo} has no ${from} branch yet. Open the change first: atticus workspace open ${change} --repos ${repo}`);
@@ -845,6 +1017,32 @@ async function openTaskWorktree(root, change, task, repo, git = createGit()) {
   }
   return { path, branch, created: true };
 }
+async function fastForwardTask(root, change, task, repo, path, git) {
+  const base = baseClonePath(root, repo);
+  const branch = taskBranch(change, task);
+  const from = changeBranch(change);
+  const rev = (ref) => git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], base).then((r) => r.stdout.trim() || void 0, () => void 0);
+  const tip = await rev(`refs/heads/${branch}`);
+  const to = await rev(`refs/heads/${from}`);
+  if (!tip || !to || tip === to)
+    return;
+  const behind = await git(["merge-base", "--is-ancestor", tip, to], base).then(() => true, () => false);
+  if (!behind)
+    return;
+  const there = path ? await git(["symbolic-ref", "-q", "HEAD"], path).then((r) => r.stdout.trim(), () => "") : "";
+  try {
+    if (path && there === `refs/heads/${branch}`) {
+      await git(["merge", "-q", "--ff-only", to], path);
+      return;
+    }
+    const list = await git(["worktree", "list", "--porcelain"], base);
+    if (list.stdout.split("\n").includes(`branch refs/heads/${branch}`))
+      throw new Error(`${branch} is checked out in another worktree`);
+    await git(["update-ref", `refs/heads/${branch}`, to, tip], base);
+  } catch (e) {
+    throw new SpecKitError("refused", `${branch} in ${repo} couldn't move on to ${from} for a fresh start: ${(e instanceof Error ? e.message : String(e)).trim()}. Commit or put aside the edits in its worktree, then run task ${task} again.`);
+  }
+}
 
 // packages/speckit/dist/drift.js
 var DRIFT_GATE = "drift";
@@ -1483,10 +1681,13 @@ async function driftAfterScan(root, o = {}) {
 
 export {
   readChangeTasks,
+  setTaskDone,
   readStory,
   loadTask,
   changeWorktree,
   handDown,
+  catchUpChangeBranch,
+  taskBranchOwnCommits,
   openTaskWorktree,
   driftCheck,
   handUpLensTask,

package/dist/chunk-UNAGJYET.js

@@ -0,0 +1,45 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  effectiveRules,
+  exampleOf,
+  kindGlob,
+  orgRulesLacking,
+  readingRulesText,
+  ruleFromPairing,
+  ruleId,
+  ruleIds,
+  ruleMatches,
+  rulesDirOf,
+  rulesLackingAll
+} from "./chunk-WXFLMQSR.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+export {
+  effectiveRules,
+  exampleOf,
+  kindGlob,
+  orgRulesLacking,
+  readingRulesText,
+  ruleFromPairing,
+  ruleId,
+  ruleIds,
+  ruleMatches,
+  rulesDirOf,
+  rulesLackingAll
+};

package/dist/{chunk-5WG5YP4T.js → chunk-UOR2DTHH.js}

@@ -9,21 +9,23 @@ import {
   questionsCommand,
   sourcesAdd,
   sourcesSync
-} from "./chunk-PCVDV3UZ.js";
-import "./chunk-ABWHYWNI.js";
-import "./chunk-BWZ77RQT.js";
+} from "./chunk-KQGURXFU.js";
+import "./chunk-D73UEXYW.js";
+import "./chunk-PAQ2AS5E.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   coverageCommand,

package/dist/{chunk-S3QNRWYR.js → chunk-UPOY4YSQ.js}

@@ -6,18 +6,20 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   aliasCommand,
   reconcileCommand
-} from "./chunk-R6XF6UR3.js";
-import "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-KDNTAPLX.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   aliasCommand,

package/dist/{chunk-EPTBZ3GP.js → chunk-UPS2DGFC.js}

@@ -5,7 +5,7 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   parseFactLine
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 
 // packages/cli/dist/memory-room.js
 import { createReadStream } from "node:fs";

package/dist/{chunk-4AK7IBVP.js → chunk-UUU4CLJG.js}

@@ -4,9 +4,11 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
-  external_exports,
+  external_exports
+} from "./chunk-Q2TECDIT.js";
+import {
   require_dist
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-W3BQAZ3Q.js → chunk-UWMJKX5U.js}

@@ -10,19 +10,21 @@ import {
   intakeList,
   triageDecide,
   triageList
-} from "./chunk-ZNCEKR4J.js";
+} from "./chunk-SFUP7TTO.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   addToInbox,