@wairon/cli 5.1.1-dev.88 → 5.1.1-dev.89

package/dist/index.js

@@ -3503,6 +3503,7 @@ __export(src_exports, {
   SystemPublicInterfaceSchema: () => SystemPublicInterfaceSchema,
   SystemSpecSchema: () => SystemSpecSchema,
   TargetConfigSchema: () => TargetConfigSchema,
+  TechnologySchema: () => TechnologySchema,
   TemplateNotFoundError: () => TemplateNotFoundError,
   TemplateSchema: () => TemplateSchema,
   TopologyConfigSchema: () => TopologyConfigSchema,
@@ -3530,6 +3531,7 @@ __export(src_exports, {
   assertProjectInitialized: () => assertProjectInitialized,
   backendCommand: () => backendCommand,
   backfillChainedSubprojectConfigs: () => backfillChainedSubprojectConfigs,
+  backupBeside: () => backupBeside,
   buildCanvasDataModel: () => buildCanvasDataModel,
   buildProjectGraph: () => buildProjectGraph,
   buildRuleContext: () => buildRuleContext,
@@ -3629,6 +3631,7 @@ __export(src_exports, {
   internalizeMember: () => internalizeMember,
   isDraftSubsystem: () => isDraftSubsystem,
   isLogic: () => isLogic,
+  isOutsideRoot: () => isOutsideRoot,
   isOwnComponentEntry: () => isOwnComponentEntry,
   isPattern: () => isPattern,
   isProjectInitialized: () => isProjectInitialized,
@@ -3758,6 +3761,8 @@ __export(src_exports, {
   stepFieldsFor: () => stepFieldsFor,
   stepGraph: () => stepGraph,
   syncContextFiles: () => syncContextFiles,
+  technologyName: () => technologyName,
+  technologyTokens: () => technologyTokens,
   toMarkdown: () => toMarkdown,
   typeBindingOf: () => typeBindingOf,
   typeGenericParameters: () => typeGenericParameters,
@@ -3814,6 +3819,15 @@ function readFileOrNull(filePath) {
 function pathExists(targetPath) {
   return fs.existsSync(targetPath);
 }
+function isOutsideRoot(root, target) {
+  const rel2 = path.relative(path.resolve(root), path.resolve(target));
+  return rel2 === ".." || rel2.startsWith(`..${path.sep}`) || path.isAbsolute(rel2);
+}
+function backupBeside(file, at = /* @__PURE__ */ new Date()) {
+  const backup = `${file}.wairon-backup-${at.toISOString().replace(/[:.]/g, "-")}`;
+  fs.copyFileSync(file, backup);
+  return backup;
+}
 function listFiles(dirPath, ext) {
   if (!fs.existsSync(dirPath)) return [];
   return fs.readdirSync(dirPath).filter((f) => f.endsWith(ext)).map((f) => path.join(dirPath, f));
@@ -7028,6 +7042,19 @@ function parseDeclaredCall(ref) {
   if (at <= 0 || at === ref.length - 1) return null;
   return { compId: ref.slice(0, at), methodName: ref.slice(at + 1) };
 }
+var TechnologySchema = import_zod8.z.union([
+  import_zod8.z.string().min(1),
+  import_zod8.z.object({
+    name: import_zod8.z.string().min(1),
+    matches: import_zod8.z.array(import_zod8.z.string().min(1)).min(1)
+  }).strict()
+]);
+function technologyName(tech) {
+  return typeof tech === "string" ? tech : tech.name;
+}
+function technologyTokens(tech) {
+  return typeof tech === "string" ? [tech] : [...tech.matches];
+}
 var ImplementationSpecSchema = import_zod8.z.object({
   id: SpecIdSchema,
   name: import_zod8.z.string(),
@@ -7052,9 +7079,10 @@ var ImplementationSpecSchema = import_zod8.z.object({
    * component's ownership tree the technology's home: references anywhere
    * outside it are flagged (TECH_LEAKAGE), contract identifiers must stay
    * intent-language (VENDOR_NAME_IN_CONTRACT), and only data-layer
-   * stereotypes should bind tech directly (TECH_ON_LOGIC_COMPONENT).
+   * stereotypes should bind tech directly (TECH_ON_LOGIC_COMPONENT). An entry
+   * is a bare name or `{ name, matches }` (see TechnologySchema).
    */
-  technologies: import_zod8.z.array(import_zod8.z.string()).optional(),
+  technologies: import_zod8.z.array(TechnologySchema).optional(),
   /**
    * The parameter names THIS realization takes BEFORE the ones its contract
    * declares — a config object, a data root, the transport handles a portal is
@@ -14282,7 +14310,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.88";
+var WAIRON_VERSION = "5.1.1-dev.89";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -21413,7 +21441,7 @@ var technologyBindingRule = {
       ctx.addIssue(
         "warning",
         "TECH_ON_LOGIC_COMPONENT",
-        `Implementation "${impl.id}" binds technology (${impl.technologies.join(", ")}) on component "${comp.id}" (${comp.componentType}). Technology belongs behind a data-layer seam \u2014 extract an Adapter (or Store/Registry/Index) behind an intent interface and let this component depend on that.`,
+        `Implementation "${impl.id}" binds technology (${impl.technologies.map(technologyName).join(", ")}) on component "${comp.id}" (${comp.componentType}). Technology belongs behind a data-layer seam \u2014 extract an Adapter (or Store/Registry/Index) behind an intent interface and let this component depend on that.`,
         impl.id,
         ctx.isImplementationDraft(impl)
       );
@@ -21438,6 +21466,16 @@ function makeMatcher(tech) {
     return false;
   };
 }
+function newHome(label7) {
+  const home = {
+    label: label7,
+    matchers: [],
+    match: (text3) => home.matchers.some((m) => m(text3)),
+    ownerComponents: /* @__PURE__ */ new Set(),
+    scope: /* @__PURE__ */ new Set()
+  };
+  return home;
+}
 function contractIdentifiers(m) {
   const parts = [m.name, m.signature, m.returns];
   for (const p of m.params ?? []) parts.push(p.name, p.type);
@@ -21447,7 +21485,7 @@ function contractIdentifiers(m) {
 var technologyRule = {
   name: "technology-boundaries",
   judges: "design",
-  description: "Technology stays behind its owning boundary: an L4 that declares `technologies` (e.g. [mysql]) makes its component's ownership tree the technology's home. References outside that tree are leakage, and L3 contract identifiers must stay intent-language \u2014 the contract is the swap seam, so the vendor name is wrong even on the owning component's own interface.",
+  description: "Technology stays behind its owning boundary: an L4 that declares `technologies` (e.g. [mysql]) makes its component's ownership tree the technology's home. References outside that tree are leakage, and L3 contract identifiers must stay intent-language \u2014 the contract is the swap seam, so the vendor name is wrong even on the owning component's own interface. A technology is matched by its name, or \u2014 when it declares `matches` because its name is also an ordinary word of the tree (a package named after the file format it reads) \u2014 by those tokens alone.",
   codes: [
     { code: "TECH_LEAKAGE", defaultSeverity: "warning", summary: "Technology referenced outside its owning boundary" },
     { code: "VENDOR_NAME_IN_CONTRACT", defaultSeverity: "warning", summary: "Technology name in L3 contract identifiers" }
@@ -21484,7 +21522,9 @@ var technologyRule = {
       const intf = ctx.interfaceMap.get(impl.contract);
       const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
       if (!comp) continue;
-      for (const tech of impl.technologies) declarations.push({ comp, tech });
+      for (const tech of impl.technologies) {
+        declarations.push({ comp, name: technologyName(tech), tokens: technologyTokens(tech) });
+      }
     }
     const scopes = /* @__PURE__ */ new Map();
     const scopeOf2 = (comp) => {
@@ -21508,11 +21548,12 @@ var technologyRule = {
       return scope;
     };
     const homes = /* @__PURE__ */ new Map();
-    for (const { comp, tech } of declarations) {
-      const match2 = makeMatcher(tech);
-      if (!match2) continue;
-      const key = tech.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).join("");
-      const home = homes.get(key) ?? { label: tech, match: match2, ownerComponents: /* @__PURE__ */ new Set(), scope: /* @__PURE__ */ new Set() };
+    for (const { comp, name, tokens } of declarations) {
+      const matchers = tokens.map(makeMatcher).filter((m) => m !== null);
+      if (!matchers.length) continue;
+      const key = name.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).join("");
+      const home = homes.get(key) ?? newHome(name);
+      home.matchers.push(...matchers);
       home.ownerComponents.add(comp.id);
       for (const id of scopeOf2(comp)) home.scope.add(id);
       homes.set(key, home);
@@ -24936,8 +24977,8 @@ function generateSequenceDiagram(componentId, methodName, options) {
     const steps = [...methodImpl.narrative].sort((a, b) => a.stepNumber - b.stepNumber);
     for (const step of steps) {
       for (const par of parallelArms) {
-        const sep12 = par.sepByStep.get(step.stepNumber);
-        if (sep12 !== void 0) lines.push(`  and ${escapeLabel(sep12)}`);
+        const sep13 = par.sepByStep.get(step.stepNumber);
+        if (sep13 !== void 0) lines.push(`  and ${escapeLabel(sep13)}`);
       }
       switch (step.type) {
         case "local":
@@ -25987,7 +26028,7 @@ function mapSpecReferences(kind, spec, map) {
       const s = spec;
       return {
         ...s,
-        publicInterfaces: s.publicInterfaces.map((p) => ({
+        publicInterfaces: (s.publicInterfaces ?? []).map((p) => ({
           ...p,
           ...p.component !== void 0 ? { component: map("publicInterfaces", p.component) } : {},
           ...p.interface !== void 0 ? { interface: map("publicInterfaces", p.interface) } : {},
@@ -26003,8 +26044,8 @@ function mapSpecReferences(kind, spec, map) {
       return {
         ...c,
         subsystem: map("subsystem", c.subsystem),
-        owns: c.owns.map((o) => map("owns", o)),
-        dependsOn: c.dependsOn.map((d) => map("dependsOn", d)),
+        owns: (c.owns ?? []).map((o) => map("owns", o)),
+        dependsOn: (c.dependsOn ?? []).map((d) => map("dependsOn", d)),
         ...c.dispatch ? { dispatch: c.dispatch.map((b) => ({ ...b, component: map("dispatch", b.component) })) } : {},
         ...c.mounts ? { mounts: c.mounts.map((m) => ({ ...m, portal: map("mounts", m.portal) })) } : {}
       };
@@ -26018,9 +26059,9 @@ function mapSpecReferences(kind, spec, map) {
       return {
         ...impl,
         contract: map("contract", impl.contract),
-        methods: impl.methods.map((m) => ({
+        methods: (impl.methods ?? []).map((m) => ({
           ...m,
-          narrative: m.narrative.map((step) => step.targetComponent !== void 0 ? { ...step, targetComponent: map("narrative", step.targetComponent) } : step)
+          narrative: (m.narrative ?? []).map((step) => step.targetComponent !== void 0 ? { ...step, targetComponent: map("narrative", step.targetComponent) } : step)
         }))
       };
     }
@@ -27868,10 +27909,10 @@ var SpecWorkspace = class {
     return this.relativizeSpec("interface", spec);
   }
   prepareImplementationForWrite(spec, carry = true) {
-    const relative18 = this.relativizeSpec("implementation", spec, carry);
+    const relative19 = this.relativizeSpec("implementation", spec, carry);
     const member = this.getSubprojectPrefix(spec.id);
     const memberRoot = member ? this.resolveSubprojectForNamespace(member) : null;
-    return memberRoot ? childRelativeFilePaths(relative18, this.rootDir, memberRoot) : relative18;
+    return memberRoot ? childRelativeFilePaths(relative19, this.rootDir, memberRoot) : relative19;
   }
   prepareTypeForWrite(spec) {
     return this.relativizeSpec("type", spec);
@@ -28710,7 +28751,10 @@ var SpecWorkspace = class {
    *     second delete written as 7 addresses what used to be step 8. That is why
    *     a delete may restate the step's `label` or `description` as a guard, and
    *     why labels are the reliable way to name a jump target. Inserts and
-   *     deletes relocate every jump field in the same narrative around them; a
+   *     deletes relocate every STORED jump field in the same narrative around
+   *     them; a jump the delta itself writes is already in the numbering the
+   *     whole delta leaves behind, so none of its later steps moves it. A new
+   *     implementation method with no narrative is intent-level ([]); a
    *     step whose `type` changes is REBUILT for its new type, keeping its
    *     description and label.
    *  5. UNSET the fields the delta names, at the level each `unset` sits in.
@@ -28768,16 +28812,19 @@ var SpecWorkspace = class {
     }
     const JUMP_FIELDS = ["onTrueStep", "onFalseStep", "defaultStep", "endStep", "finallyStep", "toStep"];
     const JUMP_LIST_FIELDS = ["cases", "catches", "branches"];
+    const isPinned = (step, field) => step?.[DELTA_JUMP_PINS] instanceof Set && step[DELTA_JUMP_PINS].has(field);
+    const isPinnedEntry = (entry) => entry?.[DELTA_JUMP_PINS] === true;
     const relocateJumps = (step, shiftFrom, deltaN, captureInsertTarget = false) => {
       const hit = (v, isRegionTail = false) => deltaN > 0 ? captureInsertTarget && !isRegionTail ? v > shiftFrom : v >= shiftFrom : v > shiftFrom;
       const out = { ...step };
       for (const f of JUMP_FIELDS) {
+        if (isPinned(step, f)) continue;
         if (typeof out[f] === "number" && hit(out[f], f === "endStep")) out[f] = out[f] + deltaN;
       }
       for (const lf of JUMP_LIST_FIELDS) {
         if (Array.isArray(out[lf])) {
           out[lf] = out[lf].map(
-            (c) => typeof c?.step === "number" && hit(c.step) ? { ...c, step: c.step + deltaN } : c
+            (c) => !isPinnedEntry(c) && typeof c?.step === "number" && hit(c.step) ? { ...c, step: c.step + deltaN } : c
           );
         }
       }
@@ -28785,14 +28832,39 @@ var SpecWorkspace = class {
     };
     const jumpRefsTo = (step, target) => {
       const refs = [];
-      for (const f of JUMP_FIELDS) if (step[f] === target) refs.push(f);
+      for (const f of JUMP_FIELDS) if (step[f] === target && !isPinned(step, f)) refs.push(f);
       for (const lf of JUMP_LIST_FIELDS) {
         (Array.isArray(step[lf]) ? step[lf] : []).forEach((c, i) => {
-          if (c?.step === target) refs.push(`${lf}[${i}].step`);
+          if (c?.step === target && !isPinnedEntry(c)) refs.push(`${lf}[${i}].step`);
         });
       }
       return refs;
     };
+    const pinDeltaJumps = (deltaStep, carried) => {
+      const pins = new Set(carried ?? []);
+      for (const f of JUMP_FIELDS) if (typeof deltaStep[f] === "number") pins.add(f);
+      const out = { ...deltaStep };
+      for (const lf of JUMP_LIST_FIELDS) {
+        if (!Array.isArray(out[lf])) continue;
+        out[lf] = out[lf].map((c) => c && typeof c === "object" && typeof c.step === "number" ? { ...c, [DELTA_JUMP_PINS]: true } : c);
+      }
+      out[DELTA_JUMP_PINS] = pins;
+      return out;
+    };
+    const unpinned = (step) => {
+      const out = { ...step };
+      delete out[DELTA_JUMP_PINS];
+      for (const lf of JUMP_LIST_FIELDS) {
+        if (!Array.isArray(out[lf])) continue;
+        out[lf] = out[lf].map((c) => {
+          if (!c || typeof c !== "object" || !(DELTA_JUMP_PINS in c)) return c;
+          const entry = { ...c };
+          delete entry[DELTA_JUMP_PINS];
+          return entry;
+        });
+      }
+      return out;
+    };
     const normalizeIdentity = (k) => String(k ?? "").toLowerCase().replace(/[_\-\s]/g, "");
     const unsetFieldsOf = (item) => Array.isArray(item?.unset) ? item.unset.filter((f) => typeof f === "string") : [];
     const withUnset = (merged, deltaItem) => {
@@ -28972,21 +29044,24 @@ var SpecWorkspace = class {
             capture
           ));
           const { action, remove: remove2, captureJumps, ...cleanStep } = deltaStep;
-          steps.push(withUnset(cleanStep, deltaStep));
+          steps.push(withUnset(pinDeltaJumps(cleanStep), deltaStep));
         } else {
           const idx = steps.findIndex((s) => s.stepNumber === stepNum);
           if (idx !== -1) {
-            const { action, remove: remove2, ...cleanStep } = deltaStep;
+            const { action, remove: remove2, ...rawStep } = deltaStep;
             const stored = steps[idx];
+            const cleanStep = pinDeltaJumps(rawStep, stored[DELTA_JUMP_PINS]);
             const merged = withUnset(retargetByLabel(mergeElement(stored, cleanStep), cleanStep), deltaStep);
-            steps[idx] = rebuildOnRetype(stored, cleanStep, merged, methodName);
+            const rebuilt = rebuildOnRetype(stored, rawStep, merged, methodName);
+            rebuilt[DELTA_JUMP_PINS] = cleanStep[DELTA_JUMP_PINS];
+            steps[idx] = rebuilt;
           } else {
             const { action, remove: remove2, ...cleanStep } = deltaStep;
-            steps.push(withUnset(cleanStep, deltaStep));
+            steps.push(withUnset(pinDeltaJumps(cleanStep), deltaStep));
           }
         }
       }
-      return steps.sort((a, b) => a.stepNumber - b.stepNumber);
+      return steps.map(unpinned).sort((a, b) => a.stepNumber - b.stepNumber);
     };
     const isPlainObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
     const mergeExt = (existing, delta2) => {
@@ -29009,6 +29084,11 @@ var SpecWorkspace = class {
           } else {
             const existingMethod = merged[idx];
             let narrative = existingMethod.narrative ? [...existingMethod.narrative] : [];
+            if (deltaMethod.narrative !== void 0 && deltaMethod.narrative !== null && !Array.isArray(deltaMethod.narrative)) {
+              throw new Error(
+                `Refusing to update implementation method "${String(deltaMethod.name)}": its "narrative" must be a list of step deltas, got ${JSON.stringify(deltaMethod.narrative)}.`
+              );
+            }
             if (Array.isArray(deltaMethod.narrative)) {
               narrative = deltaMethod.narrative.length === 0 ? [] : mergeNarrative(String(deltaMethod.name), narrative, deltaMethod.narrative);
             }
@@ -29021,11 +29101,21 @@ var SpecWorkspace = class {
           }
         } else {
           assertUnmatchedIsAnAddition(deltaMethod, deltaMethod.name, merged.map((m) => m.name), "method");
-          merged.push(withUnset(deltaMethod, deltaMethod));
+          merged.push(withUnset(newMethodOf(deltaMethod), deltaMethod));
         }
       }
       return merged;
     };
+    const newMethodOf = (deltaMethod) => {
+      if (kind !== "implementation") return deltaMethod;
+      if (deltaMethod.narrative === void 0 || deltaMethod.narrative === null) return { ...deltaMethod, narrative: [] };
+      if (!Array.isArray(deltaMethod.narrative)) {
+        throw new Error(
+          `Refusing to add implementation method "${String(deltaMethod.name)}": its "narrative" must be a list of steps, got ${JSON.stringify(deltaMethod.narrative)}. Leave it out (or pass []) for an intent-level method.`
+        );
+      }
+      return deltaMethod;
+    };
     const mergeNamedArray = (existing, delta2) => {
       const merged = [...existing];
       for (const deltaItem of delta2) {
@@ -29203,6 +29293,12 @@ var SpecWorkspace = class {
     const qualifiedDelta = qualifyDeltaRefs(mergeableDelta);
     const mergedResult = mergeDelta(result, qualifiedDelta);
     for (const field of unsetFields) delete mergedResult[field];
+    const withDefaults = deltaSchema.safeParse(mergedResult);
+    if (withDefaults.success) {
+      for (const [key, value] of Object.entries(withDefaults.data)) {
+        if (!(key in mergedResult)) mergedResult[key] = value;
+      }
+    }
     if (kind === "implementation" && Array.isArray(mergedResult.methods)) {
       const labelErrors = [];
       for (const m of mergedResult.methods) {
@@ -29723,6 +29819,7 @@ var PROSE_FIELDS = /* @__PURE__ */ new Set([
   "note",
   "caller"
 ]);
+var DELTA_JUMP_PINS = /* @__PURE__ */ Symbol("jumps written by this delta");
 function cloneSpec(spec) {
   return JSON.parse(JSON.stringify(spec));
 }
@@ -32271,17 +32368,17 @@ function memberHop(agentId) {
   const alias = agentId.slice(0, at);
   const member = graph().nodes.find((n) => n.parent === "" && n.mountAlias === alias);
   if (!member) return null;
-  const relative18 = path26.relative(getProjectRoot(), member.directory).split(path26.sep).join("/");
-  return { alias, rest: agentId.slice(at + 2), directory: member.directory, relative: relative18 };
+  const relative19 = path26.relative(getProjectRoot(), member.directory).split(path26.sep).join("/");
+  return { alias, rest: agentId.slice(at + 2), directory: member.directory, relative: relative19 };
 }
-function throughMount(brief, alias, relative18) {
-  const under = (p) => path26.posix.join(relative18, p);
+function throughMount(brief, alias, relative19) {
+  const under = (p) => path26.posix.join(relative19, p);
   return {
     ...brief,
     agentId: `${alias}::${brief.agentId}`,
     ownedPaths: brief.ownedPaths.map(under),
     ...brief.readPaths ? { readPaths: brief.readPaths.map(under) } : {},
-    root: brief.root ? under(brief.root) : relative18
+    root: brief.root ? under(brief.root) : relative19
   };
 }
 function loadRegistry() {
@@ -32560,19 +32657,19 @@ function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
   const backupDir = path31.join(root, BACKUP_DIR, timestampSlug());
   let backedUp = false;
   for (const rootRel of roots) {
-    const relative18 = rootRel === "." ? "" : rootRel;
-    const stagedSpecDir = path31.join(stagingDir, relative18, ".wai");
+    const relative19 = rootRel === "." ? "" : rootRel;
+    const stagedSpecDir = path31.join(stagingDir, relative19, ".wai");
     if (!fs17.existsSync(stagedSpecDir)) continue;
-    const liveSpecDir = liveSpecDirFor(path31.join(root, relative18));
+    const liveSpecDir = liveSpecDirFor(path31.join(root, relative19));
     if (backupExisting && liveSpecDir && fs17.existsSync(liveSpecDir)) {
-      const backupTarget = path31.join(backupDir, relative18, path31.basename(liveSpecDir));
+      const backupTarget = path31.join(backupDir, relative19, path31.basename(liveSpecDir));
       fs17.mkdirSync(path31.dirname(backupTarget), { recursive: true });
       fs17.renameSync(liveSpecDir, backupTarget);
       backedUp = true;
     } else if (liveSpecDir && fs17.existsSync(liveSpecDir)) {
       fs17.rmSync(liveSpecDir, { recursive: true, force: true });
     }
-    const target = path31.join(root, relative18, ".wai");
+    const target = path31.join(root, relative19, ".wai");
     fs17.mkdirSync(path31.dirname(target), { recursive: true });
     if (fs17.existsSync(target)) fs17.rmSync(target, { recursive: true, force: true });
     fs17.renameSync(stagedSpecDir, target);
@@ -33155,7 +33252,7 @@ var CONTEXT_PATHS = {
   waironGuideMd: () => contextDir("wairon-guide.md")
 };
 function hasContext() {
-  return pathExists(CONTEXT_PATHS.projectMd());
+  return pathExists(CONTEXT_PATHS.dir());
 }
 function readProjectContext() {
   return readFileOrNull(CONTEXT_PATHS.projectMd());
@@ -38626,7 +38723,7 @@ ${renderChangeReport(report2)}`,
     contract: import_zod11.z.string().describe("The L3 Interface contract ID this implements"),
     sourcePath: import_zod11.z.string().optional().describe("Optional: target source code file path relative to project root \u2014 for a chained subproject's implementation (qualified id), relative to that subproject's root; a path given relative to this root that lands inside the subproject is re-expressed for you"),
     simPath: import_zod11.z.string().optional().describe("Optional: the committed integration-sim harness file (project-relative; N:1 sharing allowed). The validator proves it exists and its import graph wires the REAL modules (this component + each direct dependency; technology adapters may stay faked) \u2014 running it is CI's job. Declaring the first simPath in a subsystem activates MISSING_INTEGRATION_SIM for its other complete non-leaf implementations"),
-    technologies: import_zod11.z.array(import_zod11.z.string()).optional().describe(`External technologies this implementation binds to (e.g. ["mysql"]) \u2014 declares this component's ownership tree as the technology's home; references outside it are flagged (TECH_LEAKAGE) and contract identifiers must stay intent-language. Only for Adapter/Store/Registry/Index components.`),
+    technologies: import_zod11.z.array(import_zod11.z.union([import_zod11.z.string(), import_zod11.z.object({ name: import_zod11.z.string(), matches: import_zod11.z.array(import_zod11.z.string()).min(1).describe("The tokens the leakage and contract checks match INSTEAD of the name \u2014 for a technology whose name is also an ordinary word of the tree (the yaml package, the YAML format)") }).strict()])).optional().describe(`External technologies this implementation binds to (e.g. ["mysql"], or [{ "name": "yaml", "matches": ["yaml package", "parseDocument"] }] when the bare name would match a common word) \u2014 declares this component's ownership tree as the technology's home; references outside it are flagged (TECH_LEAKAGE) and contract identifiers must stay intent-language. Only for Adapter/Store/Registry/Index components.`),
     injectedParams: import_zod11.z.array(import_zod11.z.string()).optional().describe("The parameter names this realization takes BEFORE the ones its contract declares \u2014 a config object, a data root, the transport handles a portal is handed. Supplied by whatever wires the component up, never by the caller the contract describes, which is why they belong here and not to the contract: another realization may hold them as fields instead. Declared rather than guessed, because a leading parameter the contract does not name cannot be told from one it named under a different name (`seed(config)` realized as `bootstrapInstance(cfg)`); a leading parameter this list does not name is reported (UNDECLARED_PARAM). Only a LEADING run is dropped \u2014 one of these names appearing after the contract's own parameters is an argument in the middle of the caller's list, not wiring"),
     detail: detailEnum.optional().describe("Spec-level narrative detail default for all methods"),
     conformance: conformanceEnum.optional().describe("Spec-level conformance tier default: declared | anchored | off (omitted = stereotype default: Portal \u2192 anchored, else declared)"),
@@ -38905,7 +39002,7 @@ ${testsBlock}` : ""}`, deletion);
       inputSchema: {
         kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project export table, each entry a re-export {from, component, interface, typeDef, as, name, type, details, audience: project|department|instance|partner|external} \u2014 from alone re-exports everything a subsystem exports, and a legacy {id, subsystem} reads as {as, from})"),
         id: import_zod11.z.string().describe("The ID of the spec to update (namespaced if needed)"),
-        delta: import_zod11.z.record(import_zod11.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", a listener's mounts by "portal", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", a subsystem's publicInterfaces by component+interface (or type+details for an entry not yet bound to a component, and by from+item+interface+as for a re-export or a type export), invariants and patterns by "id", lint.allow by "code" AND "at" (an allow covers one occurrence, so several may share a code on one spec), an interface method's findings by "code", boundaries by "name", globalRequirements by "description", switch cases by "value", try catches by "error". Identity merging applies at EVERY depth, including an array INSIDE an element (a method's params, a step's catches). Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Step entries apply in ASCENDING stepNumber order, each against the numbering the earlier entries of the SAME delta left behind \u2014 delete step 3 and step 7 becomes step 6 \u2014 so prefer labels, and restate the step's "label" or "description" on a delete to have it checked against the step actually addressed. Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative. A delete is REJECTED when the narrative has no such step, when a jump still targets it (retarget the referrers first), when a restated label/description does not match, or when it is a loop/try/parallel header whose body would be left standing (retype the header first to dissolve the region, then delete it). Changing a step's "type" REBUILDS it for the new type: its description and label are kept and every field the new type cannot carry is dropped (returned as a NOTICE); a delta that retypes AND sets such a field is refused. A step delta is also refused when it carries a marker the merge does not recognise: a non-boolean "remove", an "action" that is neither "insert" nor "delete", a "captureJumps" outside an insert, or no "stepNumber" to address. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Every jump field has a "*Label" twin (toLabel, onFalseLabel, endLabel, \u2026, and "label" on a cases/catches entry) resolved against step labels AFTER the merge, so a delta may anchor on a label only pre-existing steps carry; a label the delta supplies REPLACES the stored number it twins, while setting the number and its label together in one delta is refused as a contradiction. Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, at, covers, reason }] }" to silence a WARNING or NOTICE code on this spec only (errors always surface; stale allows are flagged). An allow covers EXACTLY the occurrence it names: "at" is the site the finding names (a contract method, an import edge "from -> to", a declared edge "component -> target") and is REQUIRED for a code whose findings report one, while a finding that reports no site is covered only by an allow that names none; "covers" lists the units an aggregating finding reports, and the allow silences it only when every one is listed. This delta is deliberately OPEN below its top level \u2014 the shapes nest further than a schema here should restate \u2014 so a key that is not a field at its depth is not refused, it is NAMED BACK under NO EFFECT in the answer, together with any value the spec already held and any "unset" that removed nothing. Read that list: it is where a nested typo shows up.`),
+        delta: import_zod11.z.record(import_zod11.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", a listener's mounts by "portal", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", a subsystem's publicInterfaces by component+interface (or type+details for an entry not yet bound to a component, and by from+item+interface+as for a re-export or a type export), invariants and patterns by "id", lint.allow by "code" AND "at" (an allow covers one occurrence, so several may share a code on one spec), an interface method's findings by "code", boundaries by "name", globalRequirements by "description", switch cases by "value", try catches by "error". Identity merging applies at EVERY depth, including an array INSIDE an element (a method's params, a step's catches). Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Step entries apply in ASCENDING stepNumber order, each against the numbering the earlier entries of the SAME delta left behind \u2014 delete step 3 and step 7 becomes step 6 \u2014 so prefer labels, and restate the step's "label" or "description" on a delete to have it checked against the step actually addressed. Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative. Only STORED jumps relocate: a jump the delta itself writes (on an inserted, appended or edited step) names its target in the numbering the WHOLE delta leaves behind, after all of its inserts and deletes, and no later step of the same delta moves it. A method the delta ADDS without a narrative is an intent-level method with none ([]). A delete is REJECTED when the narrative has no such step, when a jump still targets it (retarget the referrers first), when a restated label/description does not match, or when it is a loop/try/parallel header whose body would be left standing (retype the header first to dissolve the region, then delete it). Changing a step's "type" REBUILDS it for the new type: its description and label are kept and every field the new type cannot carry is dropped (returned as a NOTICE); a delta that retypes AND sets such a field is refused. A step delta is also refused when it carries a marker the merge does not recognise: a non-boolean "remove", an "action" that is neither "insert" nor "delete", a "captureJumps" outside an insert, or no "stepNumber" to address. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Every jump field has a "*Label" twin (toLabel, onFalseLabel, endLabel, \u2026, and "label" on a cases/catches entry) resolved against step labels AFTER the merge, so a delta may anchor on a label only pre-existing steps carry; a label the delta supplies REPLACES the stored number it twins, while setting the number and its label together in one delta is refused as a contradiction. Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, at, covers, reason }] }" to silence a WARNING or NOTICE code on this spec only (errors always surface; stale allows are flagged). An allow covers EXACTLY the occurrence it names: "at" is the site the finding names (a contract method, an import edge "from -> to", a declared edge "component -> target") and is REQUIRED for a code whose findings report one, while a finding that reports no site is covered only by an allow that names none; "covers" lists the units an aggregating finding reports, and the allow silences it only when every one is listed. This delta is deliberately OPEN below its top level \u2014 the shapes nest further than a schema here should restate \u2014 so a key that is not a field at its depth is not refused, it is NAMED BACK under NO EFFECT in the answer, together with any value the spec already held and any "unset" that removed nothing. Read that list: it is where a nested typo shows up.`),
         dryRun: import_zod11.z.boolean().optional().describe("Ask what this delta WOULD do instead of doing it. The whole write runs, the candidate gate included, and the answer is the change report it would have produced \u2014 marked DRY RUN, with nothing stamped and not one byte of the stored file moved. Use it before a delta that renumbers a long narrative.")
       },
       outputSchema: specChangeReportOutput
@@ -39244,6 +39341,7 @@ function loadProjectConfig3() {
   SystemPublicInterfaceSchema,
   SystemSpecSchema,
   TargetConfigSchema,
+  TechnologySchema,
   TemplateNotFoundError,
   TemplateSchema,
   TopologyConfigSchema,
@@ -39271,6 +39369,7 @@ function loadProjectConfig3() {
   assertProjectInitialized,
   backendCommand,
   backfillChainedSubprojectConfigs,
+  backupBeside,
   buildCanvasDataModel,
   buildProjectGraph,
   buildRuleContext,
@@ -39370,6 +39469,7 @@ function loadProjectConfig3() {
   internalizeMember,
   isDraftSubsystem,
   isLogic,
+  isOutsideRoot,
   isOwnComponentEntry,
   isPattern,
   isProjectInitialized,
@@ -39499,6 +39599,8 @@ function loadProjectConfig3() {
   stepFieldsFor,
   stepGraph,
   syncContextFiles,
+  technologyName,
+  technologyTokens,
   toMarkdown,
   typeBindingOf,
   typeGenericParameters,