@maycombhq/atticus 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/{chunk-PNQLCRSS.js → chunk-K4OXYSGS.js}

@@ -5,20 +5,22 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   readCatalog
-} from "./chunk-4SLBCEPD.js";
+} from "./chunk-IKAW2KJU.js";
 import {
   scopeWords
-} from "./chunk-64AADMTW.js";
+} from "./chunk-4GAB5ZOZ.js";
 import {
   baseClonePath,
   loadManifest
-} from "./chunk-XOL3GFW2.js";
+} from "./chunk-3EWKO457.js";
 import {
   Sources,
   catalogDirOf,
-  orgPackDirOf,
+  orgPackDirOf
+} from "./chunk-FPBUTZI5.js";
+import {
   require_dist
-} from "./chunk-PAINMSID.js";
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-3J5I7ZOU.js → chunk-K4RNVDR4.js}

@@ -5,20 +5,20 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   excludesOf
-} from "./chunk-Q46QDDMF.js";
+} from "./chunk-73GFVW2L.js";
 import {
   dirSource,
   houseImportsUntaught,
   readRulesOf
-} from "./chunk-JYMIB5XY.js";
+} from "./chunk-CZ2ZS7AT.js";
 import {
   globToRegExp
-} from "./chunk-7AB6OWTV.js";
+} from "./chunk-PQQKZPBU.js";
 import {
   conventionsOf,
   loadOrgPack,
   orgPackDirOf
-} from "./chunk-PAINMSID.js";
+} from "./chunk-FPBUTZI5.js";
 
 // packages/cli/dist/house-imports.js
 async function houseUntaughtOf(root, repo, o) {

package/dist/{chunk-LEBR5NHW.js → chunk-K757G7AD.js}

@@ -5,28 +5,31 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   runPluginTests
-} from "./chunk-4SLBCEPD.js";
-import "./chunk-64AADMTW.js";
-import "./chunk-JYMIB5XY.js";
-import "./chunk-CPK7QSBG.js";
-import "./chunk-YO2PKTXT.js";
-import "./chunk-TWQRPM76.js";
-import "./chunk-XOL3GFW2.js";
-import {
-  SHIPPED_MODEL_PROVIDER_PLUGINS
-} from "./chunk-PRW3HXM3.js";
-import "./chunk-QHJJMZLX.js";
+} from "./chunk-IKAW2KJU.js";
+import "./chunk-CZ2ZS7AT.js";
+import "./chunk-4GAB5ZOZ.js";
+import "./chunk-A4JXVO5O.js";
+import "./chunk-TDSCKP3V.js";
+import "./chunk-G6EFXTUO.js";
 import {
   pluginEntryHash,
   runTranslator
-} from "./chunk-7AB6OWTV.js";
+} from "./chunk-PQQKZPBU.js";
+import "./chunk-3EWKO457.js";
+import {
+  SHIPPED_MODEL_PROVIDER_PLUGINS
+} from "./chunk-27AJAKX7.js";
+import "./chunk-3424TLIJ.js";
+import "./chunk-QA4O2GGC.js";
 import {
   ModelProviderPlugin,
   ScannerPlugin,
-  orgPackDirOf,
+  orgPackDirOf
+} from "./chunk-FPBUTZI5.js";
+import "./chunk-B4AEL3RF.js";
+import {
   require_dist
-} from "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-AHW3RY3X.js → chunk-KDJ2YKAZ.js}

@@ -5,13 +5,14 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   conformanceCommand
-} from "./chunk-G5YJBNDZ.js";
-import "./chunk-DDJPM5YX.js";
-import "./chunk-4KNOJC6J.js";
-import "./chunk-TWQRPM76.js";
-import "./chunk-7AB6OWTV.js";
-import "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-3EX5HCZD.js";
+import "./chunk-VKTXFFOZ.js";
+import "./chunk-FL344WQD.js";
+import "./chunk-G6EFXTUO.js";
+import "./chunk-PQQKZPBU.js";
+import "./chunk-FPBUTZI5.js";
+import "./chunk-B4AEL3RF.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   conformanceCommand

package/dist/{chunk-4WXRPQDE.js → chunk-KT6Q44CA.js}

@@ -3,30 +3,27 @@ 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 {
+  onboardingView
+} from "./chunk-K4OXYSGS.js";
 import {
   onboardingQueue,
   queueWhy,
   reasonOf
-} from "./chunk-HE3HRDNZ.js";
-import {
-  onboardingView
-} from "./chunk-PNQLCRSS.js";
+} from "./chunk-XF6TSZW2.js";
 import {
   houseUntaughtOf,
   houseUntaughtWords
-} from "./chunk-3J5I7ZOU.js";
-import {
-  repoIdKey
-} from "./chunk-OMPENNWY.js";
+} from "./chunk-K4RNVDR4.js";
 import {
   catalogSources
-} from "./chunk-4FOAYLI4.js";
+} from "./chunk-7K5OH45X.js";
 import {
   readTaskRun
-} from "./chunk-Y6K3CJBU.js";
+} from "./chunk-PNSSE7JM.js";
 import {
   rulesLackingAll
-} from "./chunk-GIFMBCTW.js";
+} from "./chunk-ZLQEQR3D.js";
 import {
   loadReadPlan,
   partOfWords,
@@ -35,31 +32,31 @@ import {
   readPlanProgress,
   readPlanRelOf,
   tokensWords
-} from "./chunk-MD7KUEJ3.js";
+} from "./chunk-OPWGPQ2N.js";
 import {
   checkoutOf,
   conventionsAt
-} from "./chunk-Q46QDDMF.js";
-import {
-  readChangeTasks
-} from "./chunk-YWAKDNMH.js";
+} from "./chunk-73GFVW2L.js";
 import {
   isMetarepo,
   notMetarepo
 } from "./chunk-3G4YI4ZU.js";
+import {
+  readChangeTasks
+} from "./chunk-S5GSQPIN.js";
 import {
   ASSISTANT_FORMATS,
   probedAssistant,
   readProbes,
   whatRunsWhere
-} from "./chunk-3AQ2R5NL.js";
+} from "./chunk-J4CPHJUL.js";
 import {
   readNeeds,
   seedCollisions
-} from "./chunk-BEPCKDCP.js";
+} from "./chunk-MLGWSBF4.js";
 import {
   readChangeFiles
-} from "./chunk-K332XW7K.js";
+} from "./chunk-D6BVLTDV.js";
 import {
   assess,
   changeStore,
@@ -69,21 +66,25 @@ import {
   loadChangePolicy,
   releasePrReasons,
   stageCompletion
-} from "./chunk-HSZMPH5T.js";
+} from "./chunk-WZYM5M4U.js";
+import {
+  fileStepStore
+} from "./chunk-FL344WQD.js";
 import {
   readCatalog
-} from "./chunk-4SLBCEPD.js";
+} from "./chunk-IKAW2KJU.js";
 import {
   readKnowledge,
   snapshotDates,
   workingDays
-} from "./chunk-64AADMTW.js";
+} from "./chunk-4GAB5ZOZ.js";
 import {
-  baseClonePath
-} from "./chunk-XOL3GFW2.js";
+  baseClonePath,
+  repoIdKey
+} from "./chunk-3EWKO457.js";
 import {
   stepClassOfNextStep
-} from "./chunk-QHJJMZLX.js";
+} from "./chunk-3424TLIJ.js";
 import {
   ScanVerifyProposal,
   catalogDirOf,
@@ -103,9 +104,11 @@ import {
   questionWeights,
   readRepoSpec,
   readSpecFindings,
-  require_dist,
   stepModelsOf
-} from "./chunk-PAINMSID.js";
+} from "./chunk-FPBUTZI5.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -289,6 +292,7 @@ async function readNextState(root) {
       const questions = [.../* @__PURE__ */ new Set([...changeQuestions[c.id] ?? [], ...asked])];
       const missing = c.state === "define" || c.state === "returned" ? await draftMissing(changeContext, c).catch(() => ({ draft: false, brief: false })) : { draft: false, brief: false };
       const blocking = stageOf(c.state) === "tasks" ? await blockingOf(changeContext, c).catch(() => 0) : 0;
+      const gate = draftingAt(own) >= 0 && !live && (stagesDone.includes(own) || c.state === "returned") ? await gateFindingsOf(changeContext, c).catch(() => []) : [];
       if (busy && stageOf(c.state) !== "done" && (!active || busy > active.at))
         active = { id: c.id, at: busy };
       changes.push({
@@ -301,6 +305,8 @@ async function readNextState(root) {
         feature: existsSync(join(changesDirOf(root), c.id, "feature.yaml")),
         ...missing.draft ? { undrafted: true } : {},
         ...blocking ? { blocking } : {},
+        ...gate.length ? { gate } : {},
+        ...c.state === "released" ? await releasedOf(root, c.id) : {},
         ...stageOf(c.state) === "release" ? await releasePrsOf(root, c.id) : {},
         ...missing.brief ? { brief: `${changesRelOf(root)}/${c.id}/brief.md` } : {},
         ...questions.length ? { questions } : {},
@@ -312,7 +318,8 @@ async function readNextState(root) {
             phase: live.phase,
             number: live.pr.number,
             url: live.pr.url,
-            state: live.state
+            state: live.state,
+            ...isManualPrUrl(live.pr.url) ? await manualPrRecorded(root, c.id, live.branch, orgPack) : {}
           }
         } : {},
         ...clash.length ? { seedCollisions: clash } : {},
@@ -410,9 +417,124 @@ async function blockingOf(ctx, c) {
   const a = await assess(await ctx(), c);
   return a.blockers.filter((b) => b.code === "blocking-finding" || b.code === "open-gap").length;
 }
+async function gateFindingsOf(ctx, c) {
+  const a = await assess(await ctx(), c);
+  return a.blockers.flatMap((b) => b.code === "blocking-finding" || b.code === "open-gap" ? [{ code: b.code, ...b.finding ? { finding: b.finding } : {}, message: b.message }] : []);
+}
+function gateBlockedStep(c, stage, gate) {
+  const first = c.gate?.[0];
+  if (!first)
+    return void 0;
+  const id = c.id;
+  const more = c.gate.length - 1;
+  const head = `${id}'s ${stage} stage is done, but the ${gate} gate is blocked, so its hand-off would be refused: ${first.message.replace(/\.?$/, ".")}`;
+  const tail = more ? `; ${more} more after it.` : ".";
+  const asked = /\(owner question (q-[0-9a-f]+)[,)]/.exec(first.message)?.[1];
+  if (asked)
+    return {
+      step: "answer",
+      command: `atticus questions answer ${asked}`,
+      where: METAREPO,
+      why: `${head} Its owner answers ${asked} (Questions, Owner questions), and the answer closes the gap${tail}`,
+      person: true,
+      change: id
+    };
+  const f = first.finding ?? "<id>";
+  if (first.code === "open-gap")
+    return {
+      step: "finding",
+      command: `atticus finding ${id} ${f} ask`,
+      where: METAREPO,
+      why: `${head} Ask its owner (atticus finding ${id} ${f} ask --asked-of <who>), or fill it in (atticus finding ${id} ${f} edit-and-apply)${tail}`,
+      person: true,
+      change: id
+    };
+  return {
+    step: "finding",
+    command: `atticus finding ${id} ${f} edit-and-apply`,
+    where: METAREPO,
+    why: `${head} Fix it (atticus finding ${id} ${f} edit-and-apply), or record why it doesn't apply (not-relevant --reason, or waive)${tail}`,
+    person: true,
+    change: id
+  };
+}
+async function releasedOf(root, id) {
+  try {
+    const { archiveGate } = await import("./chunk-P22EPEBR.js");
+    const g = await archiveGate(root, id);
+    return {
+      released: { blockers: g.blockers.map((b) => ({ code: b.code, message: b.message })) }
+    };
+  } catch {
+    return { released: { blockers: [] } };
+  }
+}
+function releasedSteps(c) {
+  const id = c.id;
+  const blockers = c.released?.blockers ?? [];
+  const repoOf = (m) => /^([A-Za-z0-9][\w.-]*): /.exec(m)?.[1];
+  const reads = [];
+  for (const b of blockers) {
+    const repo = repoOf(b.message);
+    if (!repo)
+      continue;
+    if (b.code === "needs-reading")
+      reads.push({
+        step: "reread",
+        command: `atticus map ${repo}`,
+        slash: `/atticus-map ${repo}`,
+        where: METAREPO,
+        why: `${id} is released, and the archive gate needs what shipped read: ${b.message}`,
+        repo,
+        change: id
+      });
+    else if (b.code === "catalog-stale")
+      reads.push({
+        step: "verify",
+        command: `atticus verify ${repo} --write`,
+        where: METAREPO,
+        why: `${id} is released, and the archive gate needs the catalog written from what shipped: ${b.message}`,
+        repo,
+        change: id
+      });
+    else if (b.code === "not-synced")
+      reads.push({
+        step: "sync",
+        command: `atticus workspace sync --repos ${repo}`,
+        where: METAREPO,
+        why: `${id} is released, and the archive gate needs ${repo}'s clone at what merged: ${b.message}`,
+        repo,
+        change: id
+      });
+  }
+  const others = blockers.filter((b) => !repoOf(b.message) || !["needs-reading", "catalog-stale", "not-synced"].includes(b.code));
+  if (others.length)
+    return [
+      ...reads,
+      {
+        step: "archive-gate",
+        command: `atticus ci archive-gate ${id}`,
+        where: METAREPO,
+        why: `${id} is released, but the archive gate doesn't pass yet: ${others.map((b) => b.message).join(" ")}`,
+        change: id,
+        person: true
+      }
+    ];
+  return [
+    ...reads,
+    {
+      step: "archive",
+      command: `atticus change archive ${id}`,
+      where: METAREPO,
+      why: reads.length ? `Then a person archives ${id} (its spec deltas merge into openspec/specs/ and the estate is scanned again).` : `${id} is released and the archive gate passes: a person archives it (its spec deltas merge into openspec/specs/ and the estate is scanned again, so the catalog says what shipped).`,
+      change: id,
+      person: true
+    }
+  ];
+}
 async function releasePrsOf(root, id) {
-  const reasons = await releasePrReasons(root, id).catch(() => []);
-  if (reasons.some((r) => r.code === "release-pr-missing"))
+  const reasons = await releasePrReasons(root, id, { offline: true }).catch(() => []);
+  if (reasons.some((r) => r.code === "release-pr-missing" || r.code === "release-pr-stale"))
     return { releasePrs: "raise" };
   if (reasons.some((r) => r.code === "release-pr-not-merged"))
     return { releasePrs: "merge" };
@@ -439,6 +561,8 @@ function stageOf(state) {
   }
 }
 function changeSteps(c) {
+  if (c.state === "released")
+    return releasedSteps(c);
   const stage = stageSteps(c);
   const id = c.id;
   const done = stageOf(c.state) === "done";
@@ -481,6 +605,15 @@ function changeSteps(c) {
   const ownDone = (c.stagesDone ?? []).includes(stageOf(c.state));
   return ownDone ? [...seeds, ...stage, ...asked, ...find, ...raise] : [...asked, ...seeds, ...stage, ...find, ...raise];
 }
+async function manualPrRecorded(root, change, branch, orgPack) {
+  const steps = await fileStepStore(root).list({ change, system: "git-host" }).catch(() => []);
+  const open = steps.find((x) => x.action === "open-pull-request" && x.inputs.head === branch && x.state !== "open");
+  if (!open)
+    return {};
+  const named = orgPack instanceof Error ? void 0 : orgPack.runtime.adapters.gitHost?.settings.metarepo;
+  const repo = typeof open.inputs.repo === "string" ? open.inputs.repo : void 0;
+  return { recorded: typeof named === "string" || !repo ? {} : { repo } };
+}
 function handoffWait(c) {
   const h = c.handoff;
   if (!h)
@@ -498,6 +631,17 @@ function handoffWait(c) {
         ...isManualPrUrl(h.url) ? {} : { pr: h.url }
       }
     ];
+  if (isManualPrUrl(h.url) && h.recorded)
+    return [
+      {
+        step: "merge",
+        command: `atticus change sync ${id}${h.recorded.repo ? ` --repo ${h.recorded.repo}` : ""}`,
+        where: METAREPO,
+        why: `${id}'s ${h.phase} hand-off PR is recorded on its manual steps: syncing reads what was recorded and moves the change on; once its merge is recorded, that approves the ${h.phase} gate.`,
+        change: id,
+        person: true
+      }
+    ];
   if (isManualPrUrl(h.url))
     return [
       {
@@ -591,6 +735,9 @@ function stageSteps(c) {
           change: id
         }
       ];
+    const blocked = gateBlockedStep(c, stage, gate);
+    if (blocked)
+      return [blocked];
     return [
       {
         step: "handoff",
@@ -955,7 +1102,7 @@ function nextSteps(s) {
       why: `${plural(s.unverifiedNeeds, "open need")} of changes ${s.unverifiedNeeds === 1 ? "comes" : "come"} from knowledge items no person has verified: check each against its page (atticus knowledge verify, correct or reject).`,
       person: true
     });
-  const inFlight = s.changes.filter((c) => stageOf(c.state) !== "done");
+  const inFlight = s.changes.filter((c) => stageOf(c.state) !== "done" || c.state === "released");
   for (const c of inFlight)
     if (c !== inHand)
       out.push(...changeAnswer(c, byChange[c.id] ?? []), ...changeSteps(c));

package/dist/{chunk-EFCQSMXB.js → chunk-KTNOBTV5.js}

@@ -6,6 +6,8 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   DECIDE_AGENTS,
   PROPOSE_CHANGE,
+  cancelMatchRuns,
+  cancelOpenDecideRuns,
   decideRunDone,
   decidedAnswerLines,
   findDecideRun,
@@ -16,14 +18,18 @@ import {
   proposedSince,
   sha256,
   startDecideRun
-} from "./chunk-3SSTNB4E.js";
-import "./chunk-QHJJMZLX.js";
-import "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-7NQAGYK4.js";
+import "./chunk-3424TLIJ.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-FPBUTZI5.js";
+import "./chunk-B4AEL3RF.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   DECIDE_AGENTS,
   PROPOSE_CHANGE,
+  cancelMatchRuns,
+  cancelOpenDecideRuns,
   decideRunDone,
   decidedAnswerLines,
   findDecideRun,

package/dist/chunk-KVVNAUIG.js

@@ -0,0 +1,66 @@
+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));
+
+// packages/cli/dist/user-state.js
+import { createHash, randomBytes } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+function userStateDir(env = process.env, platform = process.platform) {
+  const xdg = env.XDG_STATE_HOME?.trim();
+  if (xdg)
+    return join(xdg, "atticus");
+  if (platform === "win32")
+    return join(env.LOCALAPPDATA?.trim() || join(homedir(), "AppData", "Local"), "atticus", "state");
+  return join(homedir(), ".local", "state", "atticus");
+}
+function metarepoStateDir(root, env = process.env) {
+  let real = resolve(root);
+  try {
+    real = realpathSync.native(real);
+  } catch {
+  }
+  if (process.platform === "win32")
+    real = real.toLowerCase();
+  const id = createHash("sha256").update(real).digest("hex").slice(0, 24);
+  return join(userStateDir(env), "metarepos", id);
+}
+async function readUserState(root, name, env = process.env) {
+  const text = await readFile(join(metarepoStateDir(root, env), name), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+async function writeUserState(root, name, value, env = process.env) {
+  const file = join(metarepoStateDir(root, env), name);
+  const dir = join(file, "..");
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const tmp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+  await writeFile(tmp, JSON.stringify({ ...value, root: resolve(root) }) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  try {
+    await rename(tmp, file);
+  } catch (e) {
+    await rm(tmp, { force: true });
+    throw e;
+  }
+}
+async function forgetUserState(root, name, env = process.env) {
+  await rm(join(metarepoStateDir(root, env), name), { force: true });
+}
+
+export {
+  readUserState,
+  writeUserState,
+  forgetUserState
+};