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

package/dist/{chunk-3ZA3AK2D.js → chunk-IKRM64KR.js}

@@ -15,16 +15,18 @@ import {
   inAcpSession,
   proposalsSnapshot,
   undoBatch
-} from "./chunk-FSN6JFXB.js";
-import "./chunk-PXW2RZGQ.js";
-import "./chunk-73GFVW2L.js";
-import "./chunk-XOMEQVLK.js";
-import "./chunk-CZ2ZS7AT.js";
-import "./chunk-G6EFXTUO.js";
-import "./chunk-PQQKZPBU.js";
-import "./chunk-3EWKO457.js";
-import "./chunk-FPBUTZI5.js";
-import "./chunk-B4AEL3RF.js";
+} from "./chunk-QFOJ3UPU.js";
+import "./chunk-7F4GZ7U2.js";
+import "./chunk-XP5DF5MC.js";
+import "./chunk-G5P7F6RQ.js";
+import "./chunk-CGVRLQAY.js";
+import "./chunk-2VN4TLGI.js";
+import "./chunk-4U3JLIRC.js";
+import "./chunk-WS7KBKP4.js";
+import "./chunk-GLISHJ4G.js";
+import "./chunk-G3ZFEHCX.js";
+import "./chunk-LZFKJ2BR.js";
+import "./chunk-CTJHEG6A.js";
 import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {

package/dist/{chunk-JMEWJPF2.js → chunk-IMTAHDME.js}

@@ -9,7 +9,7 @@ import {
   matrixMarkdown,
   traceMatrix,
   writeTraceFindings
-} from "./chunk-EMVZIOOD.js";
+} from "./chunk-SEBBJQWK.js";
 import {
   table
 } from "./chunk-VOGCSYOI.js";
@@ -23,7 +23,7 @@ import {
   driftMarkdown,
   pipelineSnippet,
   repoDrift
-} from "./chunk-ZR6J4QFQ.js";
+} from "./chunk-JWLABUXL.js";
 import {
   GlossaryError,
   aliasDecision,
@@ -34,13 +34,13 @@ import {
   resolveTermId,
   scanGlossary,
   writeDecisions
-} from "./chunk-IKAW2KJU.js";
-import {
-  createGit
-} from "./chunk-3EWKO457.js";
+} from "./chunk-YRKAJ42V.js";
 import {
   runtimeForCli
-} from "./chunk-3424TLIJ.js";
+} from "./chunk-QQD25YNF.js";
+import {
+  createGit
+} from "./chunk-WS7KBKP4.js";
 
 // packages/cli/dist/quality-commands.js
 import { appendFile, mkdir, writeFile } from "node:fs/promises";

package/dist/{chunk-DCRYOMTM.js → chunk-IP6TSICI.js}

@@ -11,19 +11,21 @@ import {
   editRepoBuild,
   editRepoDescription,
   repoBranches
-} from "./chunk-BP33TBLI.js";
-import "./chunk-IKAW2KJU.js";
-import "./chunk-CZ2ZS7AT.js";
-import "./chunk-4GAB5ZOZ.js";
-import "./chunk-A4JXVO5O.js";
-import "./chunk-TDSCKP3V.js";
-import "./chunk-G6EFXTUO.js";
-import "./chunk-PQQKZPBU.js";
-import "./chunk-3EWKO457.js";
-import "./chunk-3424TLIJ.js";
+} from "./chunk-CPFAWYVC.js";
+import "./chunk-YRKAJ42V.js";
+import "./chunk-CGVRLQAY.js";
+import "./chunk-RL7PETU6.js";
+import "./chunk-PGKCRK77.js";
+import "./chunk-M6HI36T3.js";
+import "./chunk-2VN4TLGI.js";
+import "./chunk-4U3JLIRC.js";
+import "./chunk-QQD25YNF.js";
 import "./chunk-QA4O2GGC.js";
-import "./chunk-FPBUTZI5.js";
-import "./chunk-B4AEL3RF.js";
+import "./chunk-WS7KBKP4.js";
+import "./chunk-GLISHJ4G.js";
+import "./chunk-G3ZFEHCX.js";
+import "./chunk-LZFKJ2BR.js";
+import "./chunk-CTJHEG6A.js";
 import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {

package/dist/{chunk-PT4USJNN.js → chunk-IW3QMW3X.js}

@@ -10,17 +10,19 @@ import {
   scoreRepo,
   scoreSpecs,
   scoreVerifier
-} from "./chunk-6SNTHK43.js";
+} from "./chunk-UI7ID4HG.js";
 import {
   readCatalog
-} from "./chunk-IKAW2KJU.js";
+} from "./chunk-YRKAJ42V.js";
 import {
   ScanVerifyProposal,
-  external_exports,
   parseFacts,
   readEstateJoins,
   readRepoSpec
-} from "./chunk-FPBUTZI5.js";
+} from "./chunk-GLISHJ4G.js";
+import {
+  external_exports
+} from "./chunk-LZFKJ2BR.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";
@@ -115,7 +117,7 @@ var pct = (x) => `${Math.round(x * 100)}%`;
 async function benchRun(o, io) {
   try {
     const { dir, cache, repos } = await load(o);
-    const { main } = await import("./chunk-QAVRDONY.js");
+    const { main } = await import("./chunk-XZQBFF65.js");
     const quiet = { out: () => {
     }, err: () => {
     } };
@@ -435,7 +437,7 @@ function printSpecScores(scores, none, passes, cache, io) {
 async function benchSurvey(o, io) {
   try {
     const { cache, repos } = await load(o);
-    const { main } = await import("./chunk-QAVRDONY.js");
+    const { main } = await import("./chunk-XZQBFF65.js");
     const quiet = { out: () => {
     }, err: () => {
     } };
@@ -483,7 +485,7 @@ $1- ${mode}`), "utf8");
 async function benchVerify(o, io, deps = {}) {
   try {
     const { cache, repos } = await load(o);
-    const { main } = await import("./chunk-QAVRDONY.js");
+    const { main } = await import("./chunk-XZQBFF65.js");
     const quiet = { out: () => {
     }, err: () => {
     } };
@@ -510,7 +512,7 @@ async function benchVerify(o, io, deps = {}) {
       const capture = { out: (l) => lines.push(l), err: (l) => lines.push(l) };
       let code;
       if (deps.runtime) {
-        const { scanVerify } = await import("./chunk-POSDBRKV.js");
+        const { scanVerify } = await import("./chunk-NB664KWQ.js");
         code = await scanVerify(path, path, {}, { runtime: deps.runtime, ...deps.now ? { now: deps.now } : {} }, capture);
       } else
         code = await main(["scan", "verify", path, "--root", path, ...o.mode ? ["--mode", o.mode] : []], capture);

package/dist/{chunk-MLGWSBF4.js → chunk-IWQEZFVV.js}

@@ -17,7 +17,7 @@ import {
   parseNewFile,
   rerunOf,
   usesOf
-} from "./chunk-CA3DKO4D.js";
+} from "./chunk-EM7F6XEU.js";
 import {
   CriticError,
   MERGED_FLOWS,
@@ -49,18 +49,7 @@ import {
   triggerReason,
   waitingLenses,
   writeQuarantineItems
-} from "./chunk-D6BVLTDV.js";
-import {
-  GAP_STEP,
-  candidateRef,
-  contextToolBox,
-  defaultCodeDir,
-  gapNameOf,
-  gapQuestion,
-  namesInCode,
-  nodesById,
-  openIndex
-} from "./chunk-RCG5IAAT.js";
+} from "./chunk-GDGE7ZHC.js";
 import {
   changeFolder,
   changeFootprint,
@@ -78,21 +67,32 @@ import {
   stageCommand,
   testPlanFor,
   wroteThis
-} from "./chunk-WZYM5M4U.js";
+} from "./chunk-JQGWP3SC.js";
 import {
   ARTIFACT_STAGE,
   archiveRefuses,
   artifactsOfStage,
   createOpenSpec
-} from "./chunk-NC755EKE.js";
+} from "./chunk-UTZMF5CV.js";
 import {
   AdapterError,
   createAdapters,
   fileStepStore
-} from "./chunk-FL344WQD.js";
+} from "./chunk-U7YZ3IRI.js";
+import {
+  GAP_STEP,
+  candidateRef,
+  contextToolBox,
+  defaultCodeDir,
+  gapNameOf,
+  gapQuestion,
+  namesInCode,
+  nodesById,
+  openIndex
+} from "./chunk-DLNQ3HUM.js";
 import {
   readCatalog
-} from "./chunk-IKAW2KJU.js";
+} from "./chunk-YRKAJ42V.js";
 import {
   CONFLICT_STEP,
   checkQuote,
@@ -111,17 +111,17 @@ import {
   snapshotPages,
   syncSources,
   workingDays
-} from "./chunk-4GAB5ZOZ.js";
+} from "./chunk-RL7PETU6.js";
 import {
   changeInputSources,
   citedParts,
   heldOutInputs,
   readServiceRequestExports,
   readWorkItemExports
-} from "./chunk-A4JXVO5O.js";
+} from "./chunk-PGKCRK77.js";
 import {
   readDocument
-} from "./chunk-TDSCKP3V.js";
+} from "./chunk-M6HI36T3.js";
 import {
   APPLIES_SPEC,
   ASKS_CHECK_SPEC,
@@ -144,43 +144,24 @@ import {
   toRunSummary,
   verdictOf,
   wrapData
-} from "./chunk-3424TLIJ.js";
+} from "./chunk-QQD25YNF.js";
 import {
-  AgentDefinition,
   JOINED_BY_AI,
   JOIN_GUESS_FLAGS,
-  KNOWLEDGE_KINDS,
-  Procedure,
-  QUESTION_SCHEMA_VERSION,
-  Question,
-  QuestionDraft,
-  RecordId,
-  RuntimeKind,
-  ServiceRequestTemplate,
-  answerByWords,
   answerText,
   answerWords,
-  authorityRank,
   catalogDirOf,
   changesDirOf,
   changesRelOf,
-  componentTypeRulesText,
-  effectiveComponentTypes,
   estimateTokens,
-  external_exports,
   factsDirOf,
   fileJudgments,
-  gateRoundLimit,
   identifierWords,
   inputsDirOf,
-  isAiBy,
   isSecretPath,
   judgmentKey,
-  knowledgeKindOf,
   listQuestions,
-  loadOrgPack,
   makeJudgment,
-  normalizePath,
   openspecDirOf,
   orgPackDirOf,
   orgPackRelOf,
@@ -197,22 +178,43 @@ import {
   readRepoSpec,
   redactSecrets,
   retireQuestion,
-  retrievalOf,
   runsDirOf,
   runsRelOf,
   serializeRecord,
-  specTemplateFor,
   specsDirOf,
   stateDirOf,
   taskBranch,
   toCanonicalYaml,
   writeQuestion
-} from "./chunk-FPBUTZI5.js";
+} from "./chunk-GLISHJ4G.js";
 import {
   QUICK_WRITE_LOCK,
   withSharedFileLock,
   writeFileAtomic
-} from "./chunk-B4AEL3RF.js";
+} from "./chunk-G3ZFEHCX.js";
+import {
+  AgentDefinition,
+  KNOWLEDGE_KINDS,
+  Procedure,
+  QUESTION_SCHEMA_VERSION,
+  Question,
+  QuestionDraft,
+  RecordId,
+  RuntimeKind,
+  ServiceRequestTemplate,
+  answerByWords,
+  authorityRank,
+  componentTypeRulesText,
+  effectiveComponentTypes,
+  external_exports,
+  gateRoundLimit,
+  isAiBy,
+  knowledgeKindOf,
+  loadOrgPack,
+  normalizePath,
+  retrievalOf,
+  specTemplateFor
+} from "./chunk-LZFKJ2BR.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";
@@ -4238,7 +4240,7 @@ async function gapsOf(root, change, unknown) {
   return out;
 }
 async function codeReaders() {
-  const x = await import("./chunk-J25YOUIZ.js");
+  const x = await import("./chunk-SXF66YNZ.js");
   return {
     outline: (path, text4) => x.declarationOutline(path, text4),
     outlines: (path) => x.syntaxLanguageOf(path) !== void 0
@@ -17736,6 +17738,14 @@ import { join as join28 } from "node:path";
 var import_yaml24 = __toESM(require_dist(), 1);
 var Id4 = external_exports.string().regex(/^[a-z0-9][a-z0-9._-]*$/, "an id is lower case: letters, digits, . _ -");
 var text3 = () => external_exports.string().trim().min(1).max(500);
+var RunsOn = external_exports.object({
+  system: Id4.optional(),
+  platform: external_exports.string().trim().min(1).optional(),
+  cloud: external_exports.string().trim().min(1).optional(),
+  framework: external_exports.string().trim().min(1).optional(),
+  /** What the new box is (ADR 0180): one of the organisation's component types. */
+  type: Id4.optional()
+});
 var From = external_exports.object({
   component: Id4,
   /** The flow the step goes on; left out when the component has one flow, or a new one is named. */
@@ -17749,15 +17759,7 @@ var From = external_exports.object({
       what: text3(),
       entry: external_exports.string().trim().min(1).optional()
     }),
-    /** A component the catalog doesn't have yet: where it runs (ADR 0132), drawn as a new box. */
-    runsOn: external_exports.object({
-      system: Id4.optional(),
-      platform: external_exports.string().trim().min(1).optional(),
-      cloud: external_exports.string().trim().min(1).optional(),
-      framework: external_exports.string().trim().min(1).optional(),
-      /** What the new box is (ADR 0180): one of the organisation's component types. */
-      type: Id4.optional()
-    }).optional()
+    runsOn: RunsOn.optional()
   }).optional()
 });
 var Stroke = external_exports.discriminatedUnion("kind", [
@@ -17809,7 +17811,27 @@ var Stroke = external_exports.discriminatedUnion("kind", [
    * ADR 0189: a component taken away by the change: every flow of it today is removed (one
    * remove delta per flow, each carrying the stroke's mark, so Undo takes them all back).
    */
-  external_exports.object({ kind: external_exports.literal("retire"), component: Id4, why: text3() })
+  external_exports.object({ kind: external_exports.literal("retire"), component: Id4, why: text3() }),
+  /**
+   * ADR 0193: a component absorbed into another (new or existing): each flow of it today moves
+   * to the other with the same trigger, entry and steps, its own flows are removed, and every
+   * step of today's map that calls it calls the other at the same entry, so callers' contracts
+   * don't change. One stroke: every part carries its mark, so one Undo takes it all back.
+   */
+  external_exports.object({
+    kind: external_exports.literal("absorb"),
+    component: Id4,
+    into: external_exports.object({
+      component: Id4,
+      runsOn: RunsOn.optional(),
+      /**
+       * A path the moved flows' entries go under on the target ("/legacy-cards"), so components
+       * that serve the same paths can merge; callers are sent to the prefixed path.
+       */
+      prefix: external_exports.string().regex(/^\/[A-Za-z0-9._~{}/-]*[A-Za-z0-9._~}-]$/, "a path prefix: starts with /, no trailing /").optional()
+    }),
+    why: text3()
+  })
 ]);
 var slug5 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 var DRAWN = "drawn on the canvas";
@@ -18046,13 +18068,15 @@ function applyStroke(deltas, stroke, estate, by, strokeId = newStrokeId()) {
       ];
       return { deltas: all2, changed: flows.map((f) => f.flow.id) };
     }
+    case "absorb":
+      return absorbStroke(before, stroke, estate, by, why);
     case "undo": {
-      const retired2 = before.find((x) => x.flow === stroke.flow && x.change === "remove");
-      const rid = retired2 ? strokeIdOf(retired2) : void 0;
+      const marked = before.find((x) => x.flow === stroke.flow && strokeIdOf(x) !== void 0);
+      const rid = marked ? strokeIdOf(marked) : before.find((x) => x.flow === stroke.flow)?.steps.map((s2) => strokeIdOf(s2)).find((id2) => id2 !== void 0 && before.some((x) => strokeIdOf(x) === id2));
       if (rid)
         return {
-          deltas: before.filter((x) => !(x.change === "remove" && strokeIdOf(x) === rid)),
-          changed: before.filter((x) => x.change === "remove" && strokeIdOf(x) === rid).map((x) => x.flow)
+          deltas: before.filter((x) => strokeIdOf(x) !== rid).map((x) => ({ ...x, steps: x.steps.filter((y) => strokeIdOf(y) !== rid) })).filter((x) => !(x.steps.length === 0 && isDrawnDelta(x))),
+          changed: before.filter((x) => strokeIdOf(x) === rid || x.steps.some((y) => strokeIdOf(y) === rid)).map((x) => x.flow)
         };
       const d = before.find((x) => x.flow === stroke.flow);
       const s = d?.steps[stroke.index];
@@ -18069,25 +18093,200 @@ function applyStroke(deltas, stroke, estate, by, strokeId = newStrokeId()) {
     }
   }
 }
+var markedWhy = (why, reason) => {
+  const room = 500 - why("").length;
+  return why(reason.length > room ? `${reason.slice(0, Math.max(0, room - 1))}\u2026` : reason);
+};
+function entryOf(flow, estate) {
+  const ref2 = flow.trigger.ref;
+  if (!ref2)
+    return void 0;
+  const r = estate.byId?.get(ref2);
+  if (r?.kind === "Endpoint" && typeof r.pathOrTopic === "string")
+    return typeof r.method === "string" && r.method ? `${r.method} ${r.pathOrTopic}` : r.pathOrTopic;
+  return ref2;
+}
+function absorbStroke(before, stroke, estate, by, why) {
+  const a = stroke.component;
+  const b = stroke.into.component;
+  const fail = (problem) => ({ deltas: before, changed: [], problem });
+  if (a === b)
+    return fail(`${a} can't be absorbed into itself.`);
+  const flows = estate.flows.filter((f) => f.flow.component === a);
+  const callers = estate.flows.flatMap((f) => f.flow.component === a ? [] : f.flow.steps.flatMap((s, i) => s.to?.component === a ? [{ f, step: i + 1, s }] : []));
+  if (!flows.length && !callers.length)
+    return fail(estate.ids.has(a) ? `${a} has no flow and no caller on today's map, so there is nothing of it to absorb yet.` : `${a} isn't a component of today's map.`);
+  const ABSORBED = /^Absorbs (\S+) into (\S+?)[: ]/;
+  const earlier = before.filter((d) => d.change === "remove" && ABSORBED.exec(d.why)?.[1] === a);
+  const earlierInto = earlier.map((d) => ABSORBED.exec(d.why)[2]).find((x) => x !== void 0);
+  if (earlierInto && earlierInto !== b)
+    return fail(`${a} is absorbed into ${earlierInto} already in this change: absorb it there, or take that back first.`);
+  const movedBefore = new Set(earlier.map((d) => d.flow));
+  const retargetedBefore = (flow, step) => before.some((d) => d.flow === flow && d.steps.some((x) => x.op === "remove" && x.step === step && (x.why ?? "").startsWith(`${a} is absorbed into ${b}`)));
+  if (earlierInto) {
+    const pendingFlows = flows.filter((f) => !movedBefore.has(f.flow.id));
+    const pendingCallers = callers.filter((c) => !retargetedBefore(c.f.flow.id, c.step));
+    if (!pendingFlows.length && !pendingCallers.length)
+      return fail(`${a} is absorbed into ${b} already, and the map shows nothing new of it since.`);
+    flows.splice(0, flows.length, ...pendingFlows);
+    callers.splice(0, callers.length, ...pendingCallers);
+  }
+  const removed = flows.filter((f) => before.some((d) => d.flow === f.flow.id && d.change === "remove"));
+  if (removed.length)
+    return fail(`${removed.map((f) => f.flow.id).join(", ")} ${removed.length === 1 ? "is" : "are"} changed in this change already: take that back first, then absorb ${a}.`);
+  const prefix = stroke.into.prefix;
+  const endpointOf2 = (e) => {
+    const r = estate.byId?.get(e);
+    return r?.kind === "Endpoint" && typeof r.pathOrTopic === "string" ? typeof r.method === "string" && r.method ? `${r.method} ${r.pathOrTopic}` : r.pathOrTopic : e;
+  };
+  const landed = (e) => {
+    if (!prefix)
+      return e;
+    const m = /^([A-Z]+)\s+(\/.*)$/.exec(endpointOf2(e));
+    return m ? `${m[1]} ${prefix}${m[2]}` : e;
+  };
+  const key3 = (e) => e.replace(/\s+/g, " ").trim().toLowerCase();
+  const served = /* @__PURE__ */ new Set();
+  for (const f of estate.flows)
+    if (f.flow.component === b) {
+      const e = entryOf(f.flow, estate);
+      if (e)
+        served.add(key3(e));
+    }
+  for (const d of before)
+    if (d.change === "new" && d.trigger?.entry && (d.runsOn?.component === b || d.flow.startsWith(`${b}.`)))
+      served.add(key3(d.trigger.entry));
+  for (const f of flows) {
+    const raw = entryOf(f.flow, estate);
+    const e = raw ? landed(raw) : void 0;
+    if (e && served.has(key3(e)))
+      return fail(`${b} has a flow at ${e} already: a second flow can't take the same entry. Give the absorb a prefix (into.prefix: /something), take that one back, or absorb ${a} into another component.`);
+    if (e)
+      served.add(key3(e));
+  }
+  const busy = flows.filter((f) => before.some((d) => d.flow === f.flow.id));
+  if (busy.length)
+    return fail(`${busy.map((f) => f.flow.id).join(", ")} ${busy.length === 1 ? "is" : "are"} changed in this change already: take that back first, then absorb ${a}.`);
+  const known = estate.ids.has(b) || estate.flows.some((f) => f.flow.component === b);
+  const repo = repoOf(estate, b) ?? b;
+  const taken = /* @__PURE__ */ new Set([
+    ...estate.ids,
+    ...estate.flows.map((f) => f.flow.id),
+    ...before.map((d) => d.flow)
+  ]);
+  const idFor = (flow) => {
+    const local = flow.startsWith(`${a}.`) ? flow.slice(a.length + 1) : slug5(flow);
+    let id = `${b}.${local}`;
+    for (let n = 2; taken.has(id); n++)
+      id = `${b}.${local}-${n}`;
+    taken.add(id);
+    return id;
+  };
+  let all2 = [...before];
+  const changed = [];
+  for (const f of flows) {
+    const raw = entryOf(f.flow, estate);
+    const entry = raw ? landed(raw) : void 0;
+    const id = idFor(f.flow.id);
+    all2.push({
+      schemaVersion: FLOW_DELTA_SCHEMA_VERSION,
+      flow: id,
+      repo,
+      change: "new",
+      name: f.flow.name,
+      trigger: {
+        kind: f.flow.trigger.kind,
+        what: f.flow.trigger.what,
+        ...entry ? { entry } : {}
+      },
+      why: markedWhy(why, `Absorbs ${a} into ${b} (flow ${f.flow.id}): ${stroke.why}`),
+      ...!known || stroke.into.runsOn ? { runsOn: { component: b, ...stroke.into.runsOn ?? {} } } : {},
+      steps: f.flow.steps.map((s) => ({
+        op: "add",
+        kind: s.kind,
+        what: s.what,
+        ...s.to ? {
+          to: {
+            component: s.to.component === a ? b : s.to.component,
+            entry: s.to.component === a ? landed(s.to.entry) : s.to.entry,
+            new: false
+          }
+        } : {},
+        ...s.store ? { store: { table: s.store.table, columns: [...s.store.columns], new: false } } : {},
+        ...s.data ? { fields: s.data } : {},
+        ...s.repeats ? { repeats: s.repeats } : {},
+        why: why()
+      }))
+    });
+    all2.push({
+      schemaVersion: FLOW_DELTA_SCHEMA_VERSION,
+      flow: f.flow.id,
+      repo: f.repo,
+      change: "remove",
+      why: markedWhy(why, `Absorbs ${a} into ${b}: ${stroke.why}`),
+      steps: []
+    });
+    changed.push(id, f.flow.id);
+  }
+  for (const c of callers) {
+    let d = all2.find((x) => x.flow === c.f.flow.id);
+    if (d?.change === "remove")
+      continue;
+    if (d?.steps.some((s) => s.op !== "add" && s.step === c.step))
+      return fail(`Step ${c.step} of ${c.f.flow.id} is changed already in this change: take that back first, then absorb ${a}.`);
+    if (!d) {
+      d = {
+        schemaVersion: FLOW_DELTA_SCHEMA_VERSION,
+        flow: c.f.flow.id,
+        repo: c.f.repo,
+        change: "modify",
+        why: deltaWhy(by),
+        steps: []
+      };
+      all2 = [...all2, d];
+    }
+    const flow = d.flow;
+    const reason = `${a} is absorbed into ${b}`;
+    all2 = all2.map((x) => x.flow === flow ? {
+      ...x,
+      steps: [
+        ...x.steps,
+        { op: "remove", step: c.step, why: why(reason) },
+        {
+          op: "add",
+          after: c.step,
+          kind: c.s.kind,
+          what: c.s.what,
+          to: { component: b, entry: landed(c.s.to.entry), new: false },
+          why: why(reason)
+        }
+      ]
+    } : x);
+    changed.push(flow);
+  }
+  return { deltas: all2, changed: [...new Set(changed)] };
+}
 function drawnStrokes(deltas) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
+  const whole = new Set(deltas.map((d) => strokeIdOf(d)).filter((id) => id !== void 0));
   for (const d of deltas) {
-    const rid = d.change === "remove" ? strokeIdOf(d) : void 0;
+    const rid = strokeIdOf(d);
     if (rid && !seen.has(rid)) {
       seen.add(rid);
       const by = drawnBy(d);
+      const absorbed = /^Absorbs (\S+) into (\S+?)[: ]/.exec(d.why);
       const component = /^Retires (\S+?):/.exec(d.why)?.[1];
       out.push({
         flow: d.flow,
         index: 0,
-        what: `retired ${component ?? d.flow}`,
+        what: absorbed ? `absorbed ${absorbed[1]} into ${absorbed[2]}` : `retired ${component ?? d.flow}`,
         ...by ? { by } : {}
       });
     }
     d.steps.forEach((s, index) => {
       const id = strokeIdOf(s);
-      if (!id || seen.has(id))
+      if (!id || seen.has(id) || whole.has(id))
         return;
       seen.add(id);
       const pair = d.steps.find((y, j) => j !== index && strokeIdOf(y) === id);

package/dist/{chunk-C6ORPLCN.js → chunk-J65TN6QU.js}

@@ -8,24 +8,26 @@ import {
 } from "./chunk-VOGCSYOI.js";
 import {
   readCatalog
-} from "./chunk-IKAW2KJU.js";
+} from "./chunk-YRKAJ42V.js";
 import {
   TriageError,
   buildTriage,
   classify,
   scanInputs
-} from "./chunk-A4JXVO5O.js";
+} from "./chunk-PGKCRK77.js";
 import {
   readDrawio,
   reconcile
-} from "./chunk-TDSCKP3V.js";
+} from "./chunk-M6HI36T3.js";
 import {
   inputsDirOf,
-  loadOrgPack,
   orgPackDirOf,
   recordPath,
   serializeRecord
-} from "./chunk-FPBUTZI5.js";
+} from "./chunk-GLISHJ4G.js";
+import {
+  loadOrgPack
+} from "./chunk-LZFKJ2BR.js";
 
 // packages/cli/dist/intake-commands.js
 import { createHash } from "node:crypto";