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

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

@@ -7,23 +7,27 @@ import {
   onboardingQueue,
   queueWhy,
   reasonOf
-} from "./chunk-YY7VP7KW.js";
+} from "./chunk-HE3HRDNZ.js";
+import {
+  onboardingView
+} from "./chunk-PNQLCRSS.js";
 import {
   houseUntaughtOf,
   houseUntaughtWords
-} from "./chunk-7TOAS7KI.js";
+} from "./chunk-3J5I7ZOU.js";
 import {
   repoIdKey
-} from "./chunk-MKFYQQ5Q.js";
-import {
-  onboardingView
-} from "./chunk-R5MNPIMD.js";
+} from "./chunk-OMPENNWY.js";
 import {
   catalogSources
-} from "./chunk-2QMZOCWN.js";
+} from "./chunk-4FOAYLI4.js";
+import {
+  readTaskRun
+} from "./chunk-Y6K3CJBU.js";
+import {
+  rulesLackingAll
+} from "./chunk-GIFMBCTW.js";
 import {
-  checkoutOf,
-  conventionsAt,
   loadReadPlan,
   partOfWords,
   readCostOf,
@@ -31,53 +35,60 @@ import {
   readPlanProgress,
   readPlanRelOf,
   tokensWords
-} from "./chunk-AB5E5HCN.js";
+} from "./chunk-MD7KUEJ3.js";
+import {
+  checkoutOf,
+  conventionsAt
+} from "./chunk-Q46QDDMF.js";
+import {
+  readChangeTasks
+} from "./chunk-YWAKDNMH.js";
 import {
   isMetarepo,
   notMetarepo
 } from "./chunk-3G4YI4ZU.js";
-import {
-  readChangeTasks
-} from "./chunk-2ZICHO3V.js";
 import {
   ASSISTANT_FORMATS,
   probedAssistant,
   readProbes,
-  rulesLacking,
   whatRunsWhere
-} from "./chunk-BAXM3JFQ.js";
+} from "./chunk-3AQ2R5NL.js";
 import {
-  metarepoOpenSpec,
-  openspecProgress,
   readNeeds,
   seedCollisions
-} from "./chunk-XO5RQKNM.js";
+} from "./chunk-BEPCKDCP.js";
 import {
   readChangeFiles
-} from "./chunk-VEJYZEPC.js";
+} from "./chunk-K332XW7K.js";
 import {
+  assess,
   changeStore,
+  isManualPrUrl,
+  liveHandoff,
+  loadChangeContext,
   loadChangePolicy,
+  releasePrReasons,
   stageCompletion
-} from "./chunk-IOW6BF3U.js";
+} from "./chunk-HSZMPH5T.js";
 import {
   readCatalog
-} from "./chunk-EZBAS5BL.js";
+} from "./chunk-4SLBCEPD.js";
 import {
   readKnowledge,
   snapshotDates,
   workingDays
-} from "./chunk-KCQS52TH.js";
+} from "./chunk-64AADMTW.js";
 import {
   baseClonePath
-} from "./chunk-ZQC7MNQB.js";
+} from "./chunk-XOL3GFW2.js";
 import {
   stepClassOfNextStep
-} from "./chunk-QNMLLYTN.js";
+} from "./chunk-QHJJMZLX.js";
 import {
   ScanVerifyProposal,
   catalogDirOf,
   changesDirOf,
+  changesRelOf,
   factsDirOf,
   factsFileOf,
   factsRelOf,
@@ -94,7 +105,7 @@ import {
   readSpecFindings,
   require_dist,
   stepModelsOf
-} from "./chunk-YK6CSODO.js";
+} from "./chunk-PAINMSID.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -107,10 +118,6 @@ import { join } from "node:path";
 var METAREPO = "metarepo";
 var DRAFTING = ["feature", "architecture", "stories"];
 var draftingAt = (s) => DRAFTING.indexOf(s);
-var canMoveOn = (state) => {
-  const at = draftingAt(stageOf(state));
-  return at >= 0 && at < DRAFTING.length - 1;
-};
 var STALE_DAYS = 14;
 var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
 async function verifyState(root, repo) {
@@ -165,7 +172,7 @@ async function readNextState(root) {
     const planFile = await loadReadPlan(root, r.id);
     const mapped = !!spec.header?.template.startsWith("facts@") || (fromFacts.get(r.id)?.facts ?? 0) > 0;
     const stale = mapped && hasFacts ? await staleOf(root, r.id) : void 0;
-    const rules = hasFacts && r.cloned && !await staleOf(root, r.id) ? rulesLacking(planFile?.rules) : [];
+    const rules = hasFacts && r.cloned && !await staleOf(root, r.id) ? await rulesLackingAll(root, r.id, planFile?.rules) : [];
     repos.push({
       id: r.id,
       cloned: r.cloned,
@@ -215,6 +222,7 @@ async function readNextState(root) {
   problems.push(...open.problems);
   const changeIds = new Set(await changeStore(root).list().then((cs) => cs.map((c) => c.id), () => []));
   const changeQuestions = {};
+  const openIds = new Set(open.questions.map((q) => q.id));
   for (const q of open.questions)
     if (changeIds.has(q.repo))
       (changeQuestions[q.repo] ??= []).push(q.id);
@@ -254,8 +262,9 @@ async function readNextState(root) {
   let active;
   const types = orgPack instanceof Error ? [] : orgPack.changeTypes.types;
   const { policy } = await loadChangePolicy(orgPackDirOf(root));
-  const os = metarepoOpenSpec(root);
   const clashes = await seedCollisions(root).catch(() => []);
+  let ctxP;
+  const changeContext = () => ctxP ??= loadChangeContext(root);
   try {
     for (const c of await changeStore(root).list()) {
       const clash = clashes.filter((x) => x.change === c.id).map(({ seed, repo, capability, flow }) => ({ seed, repo, capability, flow }));
@@ -272,17 +281,40 @@ async function readNextState(root) {
         // The lead time as the knowledge scan read it (ADR 0117); a need with none sorts last.
         days: n.leadTimeDays ? workingDays(n.leadTimeDays) : 0
       })).sort((a, b) => b.days - a.days)[0];
-      const progress = os && canMoveOn(c.state) ? await openspecProgress(os, c.id).catch(() => void 0) : void 0;
+      const own = stageOf(c.state);
+      const loop = draftingAt(own) >= 0 ? await loopState(root, c.id, own) : void 0;
+      const live = c.state === "returned" ? void 0 : liveHandoff(c);
       const busy = await stageInProgress(root, c.id);
+      const asked = await stageQuestions(root, c.id, openIds);
+      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;
       if (busy && stageOf(c.state) !== "done" && (!active || busy > active.at))
         active = { id: c.id, at: busy };
       changes.push({
         id: c.id,
         state: c.state,
-        tasks: files ? readChangeTasks(files).map((t) => ({ id: t.id, repo: t.repo, done: t.done })) : [],
+        tasks: files ? await Promise.all(readChangeTasks(files).map(async (t) => {
+          const run = t.done ? void 0 : (await readTaskRun(root, c.id, t.id).catch(() => void 0))?.state;
+          return { id: t.id, repo: t.repo, done: t.done, ...run ? { run } : {} };
+        })) : [],
         feature: existsSync(join(changesDirOf(root), c.id, "feature.yaml")),
+        ...missing.draft ? { undrafted: true } : {},
+        ...blocking ? { blocking } : {},
+        ...stageOf(c.state) === "release" ? await releasePrsOf(root, c.id) : {},
+        ...missing.brief ? { brief: `${changesRelOf(root)}/${c.id}/brief.md` } : {},
+        ...questions.length ? { questions } : {},
+        ...knowledge.items.length ? { knowledge: true } : {},
         ...stagesDone.length ? { stagesDone } : {},
-        ...progress?.next ? { openspecStage: progress.next } : {},
+        ...loop ? { loop } : {},
+        ...live ? {
+          handoff: {
+            phase: live.phase,
+            number: live.pr.number,
+            url: live.pr.url,
+            state: live.state
+          }
+        } : {},
         ...clash.length ? { seedCollisions: clash } : {},
         ...await isFast(root, c, types) ? {
           fast: true,
@@ -331,6 +363,35 @@ async function stageInProgress(root, change) {
   }
   return newest;
 }
+async function loopState(root, change, stage) {
+  const t = await readFile(join(changesDirOf(root), change, "stage", `${stage}.yaml`), "utf8").catch(() => void 0);
+  if (t === void 0)
+    return void 0;
+  try {
+    const s = (0, import_yaml.parse)(t)?.state;
+    return typeof s === "string" ? s : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function stageQuestions(root, change, open) {
+  const out = [];
+  for (const s of DRAFTING) {
+    const t = await readFile(join(changesDirOf(root), change, "stage", `${s}.yaml`), "utf8").catch(() => "");
+    let y;
+    try {
+      y = (0, import_yaml.parse)(t);
+    } catch {
+      continue;
+    }
+    if (Array.isArray(y?.questions)) {
+      for (const q of y.questions)
+        if (typeof q === "string" && open.has(q))
+          out.push(q);
+    }
+  }
+  return out;
+}
 async function isFast(root, c, types) {
   const type = types.find((t) => t.id === c.type);
   if (!type || type.size !== "small" && !type.smallWhenBriefSays)
@@ -338,6 +399,25 @@ async function isFast(root, c, types) {
   const brief = await readFile(join(changesDirOf(root), c.id, "brief.md"), "utf8").catch(() => "");
   return fastPathOf(type, brief).fast;
 }
+async function draftMissing(ctx, c) {
+  const a = await assess(await ctx(), c);
+  return {
+    draft: a.blockers.some((b) => b.code === "missing-artifact" && (b.artifact === "proposal" || b.artifact === "specs")),
+    brief: a.blockers.some((b) => (b.code === "missing-artifact" || b.code === "unfilled-artifact") && b.artifact === "brief")
+  };
+}
+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 releasePrsOf(root, id) {
+  const reasons = await releasePrReasons(root, id).catch(() => []);
+  if (reasons.some((r) => r.code === "release-pr-missing"))
+    return { releasePrs: "raise" };
+  if (reasons.some((r) => r.code === "release-pr-not-merged"))
+    return { releasePrs: "merge" };
+  return {};
+}
 function stageOf(state) {
   switch (state) {
     case "draft":
@@ -362,7 +442,7 @@ function changeSteps(c) {
   const stage = stageSteps(c);
   const id = c.id;
   const done = stageOf(c.state) === "done";
-  const find = c.feature && !c.needs && !done ? [
+  const find = c.feature && c.knowledge && !c.needs && !done ? [
     {
       step: "needs",
       command: `atticus change needs ${id}`,
@@ -394,13 +474,89 @@ function changeSteps(c) {
       repo
     };
   });
-  return [...find, ...seeds, ...stage, ...raise];
+  const gate = done ? [] : handoffWait(c);
+  if (gate.length)
+    return [...gate, ...find, ...raise];
+  const asked = done ? [] : questionStep(c);
+  const ownDone = (c.stagesDone ?? []).includes(stageOf(c.state));
+  return ownDone ? [...seeds, ...stage, ...asked, ...find, ...raise] : [...asked, ...seeds, ...stage, ...find, ...raise];
+}
+function handoffWait(c) {
+  const h = c.handoff;
+  if (!h)
+    return [];
+  const id = c.id;
+  if (h.state === "changes-requested")
+    return [
+      {
+        step: "handoff",
+        command: `atticus change handoff ${id} --approve`,
+        where: METAREPO,
+        why: `Changes were requested on PR #${h.number} (${id}'s ${h.phase} hand-off): update the work, then a person hands it off again.`,
+        change: id,
+        person: true,
+        ...isManualPrUrl(h.url) ? {} : { pr: h.url }
+      }
+    ];
+  if (isManualPrUrl(h.url))
+    return [
+      {
+        step: "merge",
+        command: `atticus todo --change ${id}`,
+        where: METAREPO,
+        why: `${id}'s ${h.phase} hand-off PR isn't open yet: your Git host is manual, so opening it is a step waiting on you (atticus todo, or Home \u203A Manual steps in the app). Open it on the Git host as its step says, record its link, then sync; merging it approves the ${h.phase} gate.`,
+        change: id,
+        person: true,
+        pr: h.url
+      }
+    ];
+  return [
+    {
+      step: "merge",
+      command: `atticus change sync ${id}`,
+      where: METAREPO,
+      why: `${id}'s ${h.phase} hand-off PR #${h.number} is raised (${h.url}): a person approves and merges it on the Git host, then syncing moves the change on (ADR 0073).`,
+      change: id,
+      person: true,
+      pr: h.url
+    }
+  ];
+}
+function questionStep(c) {
+  const ids = c.questions ?? [];
+  if (!ids.length)
+    return [];
+  const stage = stageOf(c.state);
+  const again = draftingAt(stage) >= 0 ? `Answer ${plural(ids.length, "question")} on Questions (or atticus questions answer <id>), then run the ${c.fast ? "fast path's one step" : `${stage} stage`} again.` : `Its stage goes on once ${ids.length === 1 ? "it is" : "they are"} answered.`;
+  return [
+    {
+      step: "answer",
+      command: "atticus questions list --state open",
+      slash: "/atticus-answer",
+      where: METAREPO,
+      why: `${plural(ids.length, "question")} of ${c.id} ${ids.length === 1 ? "is" : "are"} waiting for a person: ${ids.join(", ")}. ${again}`,
+      person: true,
+      change: c.id
+    }
+  ];
+}
+function againWhy(c, stage) {
+  return c.loop === "questions" && !c.questions?.length ? `The questions the ${stage} stage of ${c.id} asked are answered: run the stage again so it reads the answers (ADR 0087).` : void 0;
 }
 function stageSteps(c) {
   const id = c.id;
-  const byState = stageOf(c.state);
-  const at = draftingAt;
-  const stage = c.openspecStage && at(byState) >= 0 && at(c.openspecStage) > at(byState) ? c.openspecStage : byState;
+  const stage = stageOf(c.state);
+  if (c.brief && stage === "feature" && !c.stagesDone?.includes("feature"))
+    return [
+      {
+        step: "brief",
+        command: c.brief,
+        where: METAREPO,
+        why: `Write the brief of ${id} (${c.brief}): it still holds only the template. The feature stage places the change on the estate from it.`,
+        change: id,
+        person: true
+      }
+    ];
   if (c.fast && (stage === "feature" || stage === "architecture" || stage === "stories"))
     return c.fastDone ? [
       {
@@ -424,6 +580,17 @@ function stageSteps(c) {
   if ((stage === "feature" || stage === "architecture" || stage === "stories") && c.stagesDone?.includes(stage)) {
     const later = c.stagesDone.slice(c.stagesDone.indexOf(stage) + 1);
     const gate = c.state === "returned" ? "define" : c.state;
+    if (stage === "feature" && c.undrafted)
+      return [
+        {
+          step: "draft",
+          command: `atticus change draft ${id}`,
+          slash: `/atticus-draft ${id}`,
+          where: METAREPO,
+          why: `${id} is placed on the estate, but its proposal or specs aren't written yet: your assistant drafts them, and Atticus checks the draft. Then a person raises the define hand-off.`,
+          change: id
+        }
+      ];
     return [
       {
         step: "handoff",
@@ -443,18 +610,29 @@ function stageSteps(c) {
           command: `atticus change feature ${id}`,
           slash: `/atticus-feature ${id}`,
           where: METAREPO,
-          why: `${id} is at the feature stage: your assistant places it on the estate's flows and features, and Atticus checks and criticises every draft until nothing blocks (ADR 0087).`,
+          why: againWhy(c, "feature") ?? `${id} is at the feature stage: your assistant places it on the estate's flows and features, and Atticus checks and criticises every draft until nothing blocks (ADR 0087).`,
           change: id
         }
       ];
     case "architecture":
       return [
+        // Fifth UX walk: the architecture stage reads the placed feature; without one it refuses.
+        ...c.feature === false ? [
+          {
+            step: "feature",
+            command: `atticus change feature ${id}`,
+            slash: `/atticus-feature ${id}`,
+            where: METAREPO,
+            why: `${id} isn't placed on the estate yet: your assistant places it on the flows and features first, then writes its target flows.`,
+            change: id
+          }
+        ] : [],
         {
           step: "architecture",
           command: `atticus change architecture ${id}`,
           slash: `/atticus-architecture ${id}`,
           where: METAREPO,
-          why: `${id} is at the architecture stage: your assistant writes its target flows, and Atticus checks and criticises every draft until nothing blocks (ADR 0087).`,
+          why: againWhy(c, "architecture") ?? `${id} is at the architecture stage: your assistant writes its target flows, and Atticus checks and criticises every draft until nothing blocks (ADR 0087).`,
           change: id
         }
       ];
@@ -465,35 +643,83 @@ function stageSteps(c) {
           command: `atticus plan stories ${id}`,
           slash: `/atticus-stories ${id}`,
           where: METAREPO,
-          why: `${id} has an approved design: write its stories and tasks.`,
+          why: againWhy(c, "stories") ?? `${id} has an approved design: write its stories and tasks.`,
           change: id
         }
       ];
     case "tasks": {
-      const t = c.tasks.find((x) => !x.done);
-      if (!t)
+      const underWay = (x) => x.run === "built" || x.run === "unverified" || x.run === "pr-open" || x.run === "waiting";
+      const open = c.tasks.filter((x) => !x.done);
+      const t = open.find((x) => !underWay(x));
+      const drafted = open.filter(underWay).map((x) => x.id);
+      const draftedNote = drafted.length ? ` ${drafted.length === 1 ? "Task" : "Tasks"} ${drafted.join(", ")} ${drafted.length === 1 ? "is" : "are"} under way: raise or merge ${drafted.length === 1 ? "its" : "their"} PR on the Task board.` : "";
+      if (!t && drafted.length)
         return [
           {
             step: "tasks",
             command: `atticus change status ${id}`,
             where: METAREPO,
-            why: `Every task of ${id} is ticked; the status says what is left before release.`,
+            why: `Every task of ${id} not ticked is under way.${draftedNote}`,
             change: id
           }
         ];
+      const handoffStep = {
+        step: "handoff",
+        command: `atticus change handoff ${id} --approve`,
+        where: METAREPO,
+        why: `Every task of ${id} is ticked: a person raises its ${c.state} hand-off PR, and merging it approves the ${c.state} gate and moves it on (ADR 0073).`,
+        change: id,
+        person: true
+      };
+      if (!t && c.blocking)
+        return [
+          {
+            step: "findings",
+            command: `atticus change status ${id}`,
+            where: METAREPO,
+            why: `Every task of ${id} is ticked, but ${plural(c.blocking, "blocking finding")} hold${c.blocking === 1 ? "s" : ""} its ${c.state} hand-off: a person resolves each (Apply fix, Not relevant or Waive, on the change's page), then raises the hand-off PR.`,
+            change: id,
+            person: true
+          },
+          handoffStep
+        ];
+      if (!t)
+        return [handoffStep];
       return [
         {
           step: "task",
           command: `atticus task run ${id} ${t.id}`,
           slash: `/atticus-task ${id} ${t.id}`,
           where: METAREPO,
-          why: `Task ${t.id} of ${id} in ${t.repo} is the first one not done. /atticus-task gives your assistant its context (atticus task context ${id} ${t.id}): the story, the criteria, the step with today's code and the files to change (ADR 0113).`,
+          why: `Task ${t.id} of ${id} in ${t.repo} is the first one not done. /atticus-task gives your assistant its context (atticus task context ${id} ${t.id}): the story, the criteria, the step with today's code and the files to change (ADR 0113).${draftedNote}`,
           repo: t.repo,
           change: id
         }
       ];
     }
     case "release":
+      if (c.releasePrs === "raise")
+        return [
+          {
+            step: "release-prs",
+            command: `atticus change release-prs ${id} --approve`,
+            where: METAREPO,
+            why: `${id}'s code reaches each repo's default branch through its release PRs: raise them (Release \u203A Raise the release PRs), then a person merges each on the Git host.`,
+            person: true,
+            change: id
+          }
+        ];
+      if (c.releasePrs === "merge")
+        return [
+          {
+            step: "release-prs-merge",
+            command: `atticus change sync ${id}`,
+            where: METAREPO,
+            why: `${id}'s release PRs wait on a person on the Git host: merge each, then Sync records it (Release).`,
+            person: true,
+            change: id
+          }
+        ];
       return [
         {
           step: "release",
@@ -508,7 +734,9 @@ function stageSteps(c) {
       return [];
   }
 }
-function changeAnswer(id, ids) {
+function changeAnswer(c, filed) {
+  const id = c.id;
+  const ids = filed.filter((q) => !c.questions?.includes(q));
   if (!ids.length)
     return [];
   return [
@@ -537,8 +765,11 @@ function nextSteps(s) {
   const byChange = s.changeQuestions ?? {};
   const inHand = s.active ? s.changes.find((c) => c.id === s.active) : void 0;
   if (inHand && stageOf(inHand.state) !== "done")
-    out.push(...changeAnswer(inHand.id, byChange[inHand.id] ?? []), ...changeSteps(inHand));
-  const ofChanges = new Set(Object.values(byChange).flat());
+    out.push(...changeAnswer(inHand, byChange[inHand.id] ?? []), ...changeSteps(inHand));
+  const ofChanges = /* @__PURE__ */ new Set([
+    ...Object.values(byChange).flat(),
+    ...s.changes.filter((c) => stageOf(c.state) !== "done").flatMap((c) => c.questions ?? [])
+  ]);
   const repoQuestions = s.openQuestions.filter((id) => !ofChanges.has(id));
   if (s.repos.length === 0 && !inHand) {
     out.push({
@@ -727,7 +958,7 @@ function nextSteps(s) {
   const inFlight = s.changes.filter((c) => stageOf(c.state) !== "done");
   for (const c of inFlight)
     if (c !== inHand)
-      out.push(...changeAnswer(c.id, byChange[c.id] ?? []), ...changeSteps(c));
+      out.push(...changeAnswer(c, byChange[c.id] ?? []), ...changeSteps(c));
   if (!inFlight.length)
     out.push({
       step: "new-change",
@@ -829,7 +1060,6 @@ function queueOut(s, o, io) {
 }
 
 export {
-  canMoveOn,
   readNextState,
   changeSteps,
   nextSteps,

package/dist/{chunk-RMEEHH24.js → chunk-5CMPVC3N.js}

@@ -7,29 +7,29 @@ import {
   ConformError,
   conformChange,
   conformanceOf
-} from "./chunk-GTW54D3D.js";
-import "./chunk-2ZICHO3V.js";
-import "./chunk-BAXM3JFQ.js";
-import "./chunk-YC2K3FJG.js";
-import "./chunk-TAKAEJRD.js";
-import "./chunk-XO5RQKNM.js";
-import "./chunk-L3T33FA7.js";
-import "./chunk-VEJYZEPC.js";
-import "./chunk-IOW6BF3U.js";
-import "./chunk-43E6XX67.js";
-import "./chunk-V3UEPUHT.js";
-import "./chunk-EZBAS5BL.js";
-import "./chunk-KCQS52TH.js";
-import "./chunk-IPSFMTK2.js";
-import "./chunk-TNCROWPQ.js";
-import "./chunk-7IM4BVVH.js";
-import "./chunk-RBXDHCN7.js";
-import "./chunk-YXUIUOQZ.js";
-import "./chunk-ZQC7MNQB.js";
-import "./chunk-TLDL2ZZI.js";
-import "./chunk-QNMLLYTN.js";
-import "./chunk-YK6CSODO.js";
-import "./chunk-MMB2OHUY.js";
+} from "./chunk-Y6K3CJBU.js";
+import "./chunk-EZIN5E5B.js";
+import "./chunk-3LZ6P5EP.js";
+import "./chunk-YWAKDNMH.js";
+import "./chunk-3AQ2R5NL.js";
+import "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./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 "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/change-conform.js
@@ -94,7 +94,7 @@ async function changeConformCommand(root, change, o, io) {
       return 1;
     print(run.results, io);
     io.out(bad ? `The findings are on the conform gate${run.round ? ` (round ${run.round})` : ""}: atticus findings ${change} lists them; dismiss one with atticus finding ${change} <id> not-relevant --reason "...".` : "The code has everything its target flows add, and nothing they don't name.");
-    return bad ? 1 : 0;
+    return bad && !o.findingsAnswer ? 1 : 0;
   } catch (e) {
     if (e instanceof ConformError) {
       io.err(e.message);

package/dist/chunk-5G7ILBUG.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));
+import {
+  assistantFiles,
+  describeRun,
+  driftCommand,
+  runDone,
+  specHandDown,
+  specHandUp,
+  taskHandoff,
+  taskRun,
+  taskRunNotWaiting
+} from "./chunk-AOCWFA7T.js";
+import {
+  isTaskRun
+} from "./chunk-Y6K3CJBU.js";
+import "./chunk-IFHDV6KQ.js";
+import "./chunk-LQH4P45K.js";
+import "./chunk-P2VBXX7N.js";
+import "./chunk-ZX7235KR.js";
+import "./chunk-EZIN5E5B.js";
+import "./chunk-3LZ6P5EP.js";
+import "./chunk-YWAKDNMH.js";
+import "./chunk-3AQ2R5NL.js";
+import "./chunk-PTQ3ZALZ.js";
+import "./chunk-A2G72UI4.js";
+import "./chunk-I2A3Z5AK.js";
+import "./chunk-F6H2RJ3N.js";
+import "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./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 {
+  runtimeForCli
+} from "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+export {
+  assistantFiles,
+  describeRun,
+  driftCommand,
+  isTaskRun,
+  runDone,
+  runtimeForCli,
+  specHandDown,
+  specHandUp,
+  taskHandoff,
+  taskRun,
+  taskRunNotWaiting
+};

package/dist/{chunk-Z75XDWQR.js → chunk-5PV7S2ZP.js}

@@ -28,9 +28,9 @@ import {
   stampEvidence,
   tooLargeMessage,
   withParseCache
-} from "./chunk-TLDL2ZZI.js";
-import "./chunk-YK6CSODO.js";
-import "./chunk-MMB2OHUY.js";
+} from "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 export {
   DEFAULT_IGNORES,