@wairon/cli 5.1.1-dev.37 → 5.1.1-dev.38

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.37";
+    WAIRON_VERSION = "5.1.1-dev.38";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -1536,7 +1536,13 @@ var init_specs = __esm({
     GuaranteeSchema = import_zod7.z.string().min(1);
     MethodParamSchema = import_zod7.z.object({
       name: import_zod7.z.string(),
-      /** A primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice"). */
+      /**
+       * A primitive/builtin or a defined type id (qualified across subsystems, e.g.
+       * "billing.Invoice"), on its own or inside a generic, an array or a UNION:
+       * `Invoice | null`, `Promise<Invoice | null>`, `Invoice[] | null`. Every
+       * identifier the string names has to resolve — see the grammar on
+       * src/models/type-references.ts.
+       */
       type: import_zod7.z.string(),
       description: import_zod7.z.string().optional(),
       optional: import_zod7.z.boolean().optional()
@@ -1554,8 +1560,9 @@ var init_specs = __esm({
       description: import_zod7.z.string(),
       signature: import_zod7.z.string(),
       // e.g. "save(key: string, data: Buffer): Promise<void>"
+      // e.g. "Promise<void>", or a union: "Invoice | null" — the commonest shape in
+      // any real tree. See the grammar on src/models/type-references.ts.
       returns: import_zod7.z.string(),
-      // e.g. "Promise<void>"
       /** Structured parameters (authoritative for type checking when present). */
       params: import_zod7.z.array(MethodParamSchema).optional(),
       /** Concrete wire binding for this method when its component is a Portal (set via sdd_set_endpoints). */
@@ -1824,8 +1831,10 @@ var init_specs = __esm({
     TypeKindSchema = import_zod7.z.enum(["entity", "value-object"]);
     TypeFieldSchema = import_zod7.z.object({
       name: import_zod7.z.string(),
+      // A primitive, or another type id (qualified across subsystems, e.g.
+      // "billing.Invoice") — on its own or inside a generic, an array or a union
+      // ("Invoice[] | null"). See the grammar on src/models/type-references.ts.
       type: import_zod7.z.string(),
-      // a primitive, or another type id (qualified across subsystems, e.g. "billing.Invoice")
       description: import_zod7.z.string().optional(),
       optional: import_zod7.z.boolean().default(false),
       /**
@@ -26827,6 +26836,7 @@ __export(server_exports, {
   captureBuildStamp: () => captureBuildStamp,
   createMcpServer: () => createMcpServer,
   isBuildStale: () => isBuildStale,
+  markStale: () => markStale,
   startMcpServer: () => startMcpServer,
   statusFamilyContext: () => statusFamilyContext
 });
@@ -26907,6 +26917,12 @@ function json(value) {
 function errText(message) {
   return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
 }
+function structured(content, data) {
+  return { content: [{ type: "text", text: content }], structuredContent: data };
+}
+function jsonStructured(value) {
+  return structured(JSON.stringify(value, null, 2), value);
+}
 function renderChangeReport(report2) {
   const lines = [report2.dryRun ? `DRY RUN \u2014 nothing was written. ${report2.summary}` : report2.summary];
   for (const change of report2.changes) {
@@ -26920,6 +26936,13 @@ function renderChangeReport(report2) {
   if (report2.notices.length) lines.push("", "NOTICE:", ...report2.notices.map((n) => `- ${n}`));
   return lines.join("\n");
 }
+function writeReceipt(sentence, receipt) {
+  const noticeBlock = receipt.notices.length ? `
+
+NOTICE:
+- ${receipt.notices.join("\n- ")}` : "";
+  return structured(`${sentence}${noticeBlock}`, receipt);
+}
 function captureBuildStamp(entryPath) {
   try {
     const s = fs20.statSync(entryPath);
@@ -26937,16 +26960,19 @@ function isBuildStale(stamp) {
     return false;
   }
 }
-function withStaleWarning(result) {
-  if (!isBuildStale(SERVER_BUILD_STAMP)) return result;
-  const first = result.content?.[0];
+function markStale(result) {
+  const marked = result.structuredContent ? { ...result, structuredContent: { ...result.structuredContent, staleServer: true } } : result;
+  const first = marked.content?.[0];
   if (first && first.type === "text") {
     return {
-      ...result,
-      content: [{ ...first, text: `${first.text}${STALE_SERVER_WARNING}` }, ...result.content.slice(1)]
+      ...marked,
+      content: [{ ...first, text: `${first.text}${STALE_SERVER_WARNING}` }, ...marked.content.slice(1)]
     };
   }
-  return result;
+  return marked;
+}
+function withStaleWarning(result) {
+  return isBuildStale(SERVER_BUILD_STAMP) ? markStale(result) : result;
 }
 function reg(server, name, config, cb) {
   const guarded = (args) => {
@@ -26958,8 +26984,9 @@ function reg(server, name, config, cb) {
   server.registerTool(name, strictConfig, guarded);
 }
 function statusForCreate(label, stated, existing) {
-  if (stated === void 0) return { status: "draft" };
-  const held = existing?.status ?? void 0;
+  const stored = existing?.status;
+  const held = stored !== void 0 && STATUS_ORDER.includes(stored) ? stored : void 0;
+  if (stated === void 0) return { status: held ?? "draft" };
   if (held === void 0) return { status: stated };
   const rank = (s) => STATUS_ORDER.indexOf(s);
   if (rank(stated) < rank(held)) {
@@ -27275,8 +27302,9 @@ function createMcpServer(options = {}) {
     server,
     "sdd_initialize_system",
     {
-      description: "Initialize the L0 System Specification (system.yaml). Re-running it on an existing system RE-AUTHORS it: the fields above are replaced, and everything this tool cannot express (databases, the project gateway publicInterfaces, diagram defaults) is carried forward.",
-      inputSchema: systemInput
+      description: "Initialize the L0 System Specification (system.yaml). Re-running it on an existing system RE-AUTHORS it: the fields above are replaced, and everything this tool cannot express (databases, the project gateway publicInterfaces, diagram defaults) is carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 what was written, and whether a system spec already existed \u2014 so a caller never has to read English to find out.",
+      inputSchema: systemInput,
+      outputSchema: specWriteReceiptOutput
     },
     ({ name, vision, boundaries, globalRequirements, targetLanguage }) => {
       try {
@@ -27298,11 +27326,10 @@ function createMcpServer(options = {}) {
         next.updatedAt = now;
         saveSystemSpec2(next);
         const notices = existing ? rewriteNotices({ label: `System spec "${existing.name}"`, carried, cleared, removed: [] }) : [];
-        const noticeBlock = notices.length ? `
-
-NOTICE:
-- ${notices.join("\n- ")}` : "";
-        return text(`Successfully ${existing ? "re-authored" : "initialized"} L0 System Spec for "${name}".${noticeBlock}`);
+        return writeReceipt(
+          `Successfully ${existing ? "re-authored" : "initialized"} L0 System Spec for "${name}".`,
+          { kind: "system", id: "system", name, replacedExisting: Boolean(existing), notices }
+        );
       } catch (e) {
         return errText(String(e));
       }
@@ -27339,8 +27366,9 @@ NOTICE:
     server,
     "sdd_add_subsystem",
     {
-      description: "Add an L1 Subsystem / Service under the system boundary. publicInterfaces should bind each entry to the component that realizes it (the subsystem's published surface); if components do not exist yet, add them later with sdd_set_public_interfaces. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced, lint/ext are carried forward, and the stored status is kept unless this input states a higher one.",
-      inputSchema: subsystemInput
+      description: "Add an L1 Subsystem / Service under the system boundary. publicInterfaces should bind each entry to the component that realizes it (the subsystem's published surface); if components do not exist yet, add them later with sdd_set_public_interfaces. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced, lint/ext are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the child project directory a chained subsystem scaffolded.",
+      inputSchema: subsystemInput,
+      outputSchema: specWriteReceiptOutput
     },
     ({ id, name, description, publicInterfaces, projectPath, targetLanguage, profile, designDepth, trustedLinks, lifecycle, status: status2 }) => {
       try {
@@ -27371,17 +27399,24 @@ NOTICE:
         const cleared = clearedByOmission(existing, spec, subsystemInputFields);
         if (existing) spec.createdAt = existing.createdAt;
         const notices = existing ? rewriteNotices({ label: `Subsystem "${id}"`, carried: ["createdAt", ...carried], cleared, removed: [] }) : [];
-        const noticeBlock = notices.length ? `
-
-NOTICE:
-- ${notices.join("\n- ")}` : "";
+        const receipt = {
+          kind: "subsystem",
+          id,
+          name,
+          replacedExisting: Boolean(existing),
+          status: resolved.status,
+          notices
+        };
         if (projectPath && projectPath.trim() !== "") {
           const { createChainedSubsystem: createChainedSubsystem3 } = requireProvision();
           createChainedSubsystem3(spec, name);
-          return text(`Successfully added external subsystem "${name}" (${id}) and scaffolded its child project at ${projectPath}.${noticeBlock}`);
+          return writeReceipt(
+            `Successfully added external subsystem "${name}" (${id}) and scaffolded its child project at ${projectPath}.`,
+            { ...receipt, scaffoldedProjectPath: projectPath }
+          );
         }
         saveSubsystemSpec2(spec);
-        return text(`Successfully added L1 Subsystem Spec "${name}" (${id}).${noticeBlock}`);
+        return writeReceipt(`Successfully added L1 Subsystem Spec "${name}" (${id}).`, receipt);
       } catch (e) {
         return errText(String(e));
       }
@@ -27577,8 +27612,9 @@ NOTICE:
     server,
     "sdd_add_component",
     {
-      description: `Add an L2 Component under a subsystem. componentType is a building block (Portal, Orchestrator, Supervisor, Actor, Store, Index, Query, Registry, Adapter, Observer) or the pattern Repository. Specialist and Gateway are retired (STEREOTYPE_RETIRED) and cannot be authored: logic is an Orchestrator with a dependencyClass (pure | read; unset = a workflow), and a gateway is a Portal with the gateway variant (set variant with sdd_update_spec). Patterns set "owns" (their private member blocks); all components set "dependsOn" (collaborators \u2014 facades or standalone blocks). Held/persisted state (configs, permissions, sessions, caches): model the Repository recipe \u2014 a Store + Registry (write) + Index (read), plus a Query for computed reads over the Store, owned by a Repository facade consumers depend on; a deliberately standalone Store is the sanctioned lightweight form (workflow-layer consumers + lint.allow on UNOWNED_STORE). Never hold state as fields inside an Orchestrator because a Store link was refused. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced (an omitted array is CLEARED), while lint.allow, a Portal's auth, variant, patterns and externalLinks are carried forward \u2014 edit those with sdd_update_spec. The stored status is kept unless this input states a higher one.`,
-      inputSchema: componentInput
+      description: `Add an L2 Component under a subsystem. componentType is a building block (Portal, Orchestrator, Supervisor, Actor, Store, Index, Query, Registry, Adapter, Observer) or the pattern Repository. Specialist and Gateway are retired (STEREOTYPE_RETIRED) and cannot be authored: logic is an Orchestrator with a dependencyClass (pure | read; unset = a workflow), and a gateway is a Portal with the gateway variant (set variant with sdd_update_spec). Patterns set "owns" (their private member blocks); all components set "dependsOn" (collaborators \u2014 facades or standalone blocks). Held/persisted state (configs, permissions, sessions, caches): model the Repository recipe \u2014 a Store + Registry (write) + Index (read), plus a Query for computed reads over the Store, owned by a Repository facade consumers depend on; a deliberately standalone Store is the sanctioned lightweight form (workflow-layer consumers + lint.allow on UNOWNED_STORE). Never hold state as fields inside an Orchestrator because a Store link was refused. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced (an omitted array is CLEARED), while lint.allow, a Portal's auth, variant, patterns and externalLinks are carried forward \u2014 edit those with sdd_update_spec. The stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and every gate notice the write raised, each as its own entry.`,
+      inputSchema: componentInput,
+      outputSchema: specWriteReceiptOutput
     },
     ({ id, name, description, subsystem, componentType, owns, dependsOn, portalType, basePath, dispatch, durability, dependencyClass, emits, subscribesTo, ext, status: status2 }) => {
       try {
@@ -27621,11 +27657,10 @@ NOTICE:
             removed: []
           }));
         }
-        const noticeBlock = notices.length ? `
-
-NOTICE:
-- ${notices.join("\n- ")}` : "";
-        return text(`Successfully ${existing ? "re-authored" : "added"} L2 Component Spec "${name}" (${id}, ${componentType}).${noticeBlock}`);
+        return writeReceipt(
+          `Successfully ${existing ? "re-authored" : "added"} L2 Component Spec "${name}" (${id}, ${componentType}).`,
+          { kind: "component", id, name, replacedExisting: Boolean(existing), status: resolved.status, notices }
+        );
       } catch (e) {
         return errText(String(e));
       }
@@ -27635,12 +27670,14 @@ NOTICE:
     name: import_zod11.z.string(),
     description: import_zod11.z.string(),
     signature: import_zod11.z.string(),
-    returns: import_zod11.z.string(),
+    returns: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
     params: import_zod11.z.array(import_zod11.z.object({
       name: import_zod11.z.string(),
-      type: import_zod11.z.string().describe('A primitive/builtin or a defined type id (e.g. "billing.Invoice")'),
+      type: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The parameter's type")),
       description: import_zod11.z.string().optional(),
-      optional: import_zod11.z.boolean().optional()
+      optional: import_zod11.z.boolean().optional().describe(
+        'Whether the parameter may be OMITTED by a caller. It is not nullability: a parameter that must be passed but may be passed as nothing is a required parameter whose type is a union \u2014 "ProjectConfig | null". Say whichever is true; they are different contracts.'
+      )
     }).strict()).optional().describe("Structured parameters \u2014 authoritative for type checking (the prose signature becomes display-only). Strongly preferred."),
     guarantees: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Semantic guarantees the method promises (combinable); any guarantee a narrative step asserts must be declared here. Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
     effect: import_zod11.z.enum(["read", "write"]).optional().describe("State-effect direction on the component's held state \u2014 required on a durable Store's contract methods so the durability round-trip rule can pair writes with hydration read-backs"),
@@ -27669,8 +27706,9 @@ NOTICE:
     server,
     "sdd_define_interface",
     {
-      description: "Define an L3 Contract / Interface with method signatures for a component. Prefer supplying structured `params` per method \u2014 they are the authoritative source for type checking (the free-form signature string then becomes display-only and is never heuristically parsed). A method declares the finding codes it reports in `findings` ({code, severity, summary}); each code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). Re-defining an existing id REPLACES the method list: a method left out of the input is REMOVED (and reported); spec-level lint/ext and each method's endpoint binding are carried forward, and the stored status is kept unless this input states a higher one.",
-      inputSchema: interfaceInput
+      description: "Define an L3 Contract / Interface with method signatures for a component. Prefer supplying structured `params` per method \u2014 they are the authoritative source for type checking (the free-form signature string then becomes display-only and is never heuristically parsed). A method declares the finding codes it reports in `findings` ({code, severity, summary}); each code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). Re-defining an existing id REPLACES the method list: a method left out of the input is REMOVED (and reported); spec-level lint/ext and each method's endpoint binding are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the notices a restatement raised, each as its own entry.",
+      inputSchema: interfaceInput,
+      outputSchema: specWriteReceiptOutput
     },
     ({ id, name, description, component, methods, status: status2 }) => {
       try {
@@ -27713,11 +27751,10 @@ NOTICE:
             removedSuffix: " (endpoint bindings included)"
           }));
         }
-        const noticeBlock = notices.length ? `
-
-NOTICE:
-- ${notices.join("\n- ")}` : "";
-        return text(`Successfully ${existing ? "re-authored" : "defined"} L3 Interface Contract "${name}" (${id}).${noticeBlock}`);
+        return writeReceipt(
+          `Successfully ${existing ? "re-authored" : "defined"} L3 Interface Contract "${name}" (${id}).`,
+          { kind: "interface", id, name, replacedExisting: Boolean(existing), status: resolved.status, notices }
+        );
       } catch (e) {
         return errText(String(e));
       }
@@ -27862,8 +27899,9 @@ NOTICE:
     server,
     "sdd_write_narrative",
     {
-      description: "Write L4 Concrete Implementation spec containing L5 method narratives. Narratives are a FLAT ordered step list; flow steps (branch/switch/loop/try/parallel/jump/return/throw) jump by step number \u2014 blocks are just skipped regions. Steps may declare a `label` anchor, and every jump field has a *Label twin (toLabel, onTrueLabel, endLabel, \u2026) resolved to step numbers at write time \u2014 prefer labels over hand-counted numbers; an unresolvable label rejects the write. Detail dial per method: full (narrative required) | calls-only (call choreography suffices) | intent (prose instead of steps); omitted = stereotype default (Portal/Observer/Adapter: calls-only, Store/Index/Registry: intent, else full). Conformance dial per method or spec: declared | anchored | off \u2014 how strictly structural conformance requires contract methods to be realized in their source file (omitted = Portal: anchored, else declared). A method whose body lives in its own file names it in the method's sourcePath; the implementation's sourcePath is the default for every method that names none. Re-authoring an existing id REPLACES the method list: a method left out of the input is REMOVED together with its narrative (and reported); spec-level lint/ext are carried forward, and the stored status is kept unless this input states a higher one.",
-      inputSchema: implInput
+      description: "Write L4 Concrete Implementation spec containing L5 method narratives. Narratives are a FLAT ordered step list; flow steps (branch/switch/loop/try/parallel/jump/return/throw) jump by step number \u2014 blocks are just skipped regions. Steps may declare a `label` anchor, and every jump field has a *Label twin (toLabel, onTrueLabel, endLabel, \u2026) resolved to step numbers at write time \u2014 prefer labels over hand-counted numbers; an unresolvable label rejects the write. Detail dial per method: full (narrative required) | calls-only (call choreography suffices) | intent (prose instead of steps); omitted = stereotype default (Portal/Observer/Adapter: calls-only, Store/Index/Registry: intent, else full). Conformance dial per method or spec: declared | anchored | off \u2014 how strictly structural conformance requires contract methods to be realized in their source file (omitted = Portal: anchored, else declared). A method whose body lives in its own file names it in the method's sourcePath; the implementation's sourcePath is the default for every method that names none. Re-authoring an existing id REPLACES the method list: a method left out of the input is REMOVED together with its narrative (and reported); spec-level lint/ext are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the notices a restatement raised, each as its own entry.",
+      inputSchema: implInput,
+      outputSchema: specWriteReceiptOutput
     },
     ({ id, name, description, contract, sourcePath, simPath, technologies, detail, conformance, methods, status: status2 }) => {
       try {
@@ -27919,11 +27957,10 @@ NOTICE:
             removedSuffix: " (L5 narratives included)"
           }));
         }
-        const noticeBlock = notices.length ? `
-
-NOTICE:
-- ${notices.join("\n- ")}` : "";
-        return text(`Successfully saved L4 Implementation Spec "${name}" (${id}) with method narratives.${noticeBlock}`);
+        return writeReceipt(
+          `Successfully saved L4 Implementation Spec "${name}" (${id}) with method narratives.`,
+          { kind: "implementation", id, name, replacedExisting: Boolean(existing), status: resolved.status, notices }
+        );
       } catch (e) {
         return errText(String(e));
       }
@@ -27938,13 +27975,18 @@ NOTICE:
     group: import_zod11.z.string().optional().describe("Optional logical group ID to organize this type in subfolders"),
     fields: import_zod11.z.array(import_zod11.z.object({
       name: import_zod11.z.string(),
-      type: import_zod11.z.string(),
+      type: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The field's type")),
       description: import_zod11.z.string().optional(),
       optional: import_zod11.z.boolean().optional(),
       key: import_zod11.z.enum(["primary", "unique", "foreign"]).optional().describe("Identity marker (PK/unique/FK) for ERD and database schema derivation"),
       references: import_zod11.z.string().optional().describe('For foreign keys, the referenced type/table id and optional field, e.g. "invoice.id"')
     }).strict()).optional().describe('Data fields (type is a primitive or a qualified type id, e.g. "billing.Invoice")'),
-    methods: import_zod11.z.array(import_zod11.z.object({ name: import_zod11.z.string(), signature: import_zod11.z.string(), returns: import_zod11.z.string(), description: import_zod11.z.string().optional() }).strict()).optional().describe("Pure intrinsic methods only"),
+    methods: import_zod11.z.array(import_zod11.z.object({
+      name: import_zod11.z.string(),
+      signature: import_zod11.z.string(),
+      returns: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
+      description: import_zod11.z.string().optional()
+    }).strict()).optional().describe("Pure intrinsic methods only"),
     componentClass: import_zod11.z.string().optional().describe("Optional component id that implements or owns this logical entity"),
     invariants: import_zod11.z.array(import_zod11.z.object({
       id: import_zod11.z.string().describe("Stable invariant id, unique within the entity"),
@@ -27959,8 +28001,9 @@ NOTICE:
     server,
     "sdd_add_type",
     {
-      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. Re-defining an existing id REPLACES fields/methods/invariants (an omitted list is CLEARED, and a dropped member is reported); lint/ext are carried forward.",
-      inputSchema: typeInput
+      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. Re-defining an existing id REPLACES fields/methods/invariants (an omitted list is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
+      inputSchema: typeInput,
+      outputSchema: specWriteReceiptOutput
     },
     ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity }) => {
       try {
@@ -28007,11 +28050,10 @@ NOTICE:
             removedNoun: "member"
           }));
         }
-        const noticeBlock = notices.length ? `
-
-NOTICE:
-- ${notices.join("\n- ")}` : "";
-        return text(`Successfully ${existing ? "re-authored" : "defined"} ${kind} type "${name}" (${id}).${noticeBlock}`);
+        return writeReceipt(
+          `Successfully ${existing ? "re-authored" : "defined"} ${kind} type "${name}" (${id}).`,
+          { kind: "type", id, name, replacedExisting: Boolean(existing), notices }
+        );
       } catch (e) {
         return errText(String(e));
       }
@@ -28021,11 +28063,12 @@ NOTICE:
     server,
     "sdd_validate_tree",
     {
-      description: "Validate the SDD spec tree, checking parent references, contract compatibility, narratives, and component type boundaries. Supports scoping and recursion controls.",
+      description: "Validate the SDD spec tree, checking parent references, contract compatibility, narratives, and component type boundaries. Supports scoping and recursion controls. Findings come back as structured content too, under the schema this tool declares \u2014 errors and warnings already split, each with its code, severity, message and the spec it concerns \u2014 so a caller filters them as objects instead of parsing the JSON text block and hoping its shape holds.",
       inputSchema: {
         subsystem: import_zod11.z.string().optional().describe("Only validate the specified subsystem (granular)"),
         recursive: import_zod11.z.boolean().optional().describe("Whether to recursively validate subprojects (default: true)")
-      }
+      },
+      outputSchema: validateTreeOutput
     },
     ({ subsystem, recursive }) => {
       try {
@@ -28038,7 +28081,7 @@ NOTICE:
           scopeSubsystem: subsystem,
           recursive: recursive ?? true
         });
-        return json({
+        return jsonStructured({
           valid: result.valid,
           errors: result.issues.filter((i) => i.severity === "error"),
           warnings: result.issues.filter((i) => i.severity === "warning"),
@@ -28053,17 +28096,19 @@ NOTICE:
     server,
     "sdd_get_spec",
     {
-      description: `Get/read the parsed JSON contents of a specific spec from the spec tree. Returns structural contents without file system path searching. Pass "methods" to read only the named methods of a contract, an implementation or a type \u2014 a 45-method spec fetched whole to look at one of them is the read side of the same waste a restatement is on the write side; the answer then carries a "partialResult" marker naming what was left out, and must never be re-authored from. For a variant-tagged COMPONENT the result also carries a derived, read-only "variantGuidance" (the variant's base, its implementation guidance, and the same-variant sibling components to implement alike) \u2014 it is resolved from the variant registry, not part of the spec, so never write it back.`,
+      description: `Get/read the parsed JSON contents of a specific spec from the spec tree. Returns structural contents without file system path searching. Pass "methods" to read only the named methods of a contract, an implementation or a type \u2014 a 45-method spec fetched whole to look at one of them is the read side of the same waste a restatement is on the write side; the answer then carries a "partialResult" marker naming what was left out, and must never be re-authored from. For a variant-tagged COMPONENT the result also carries a derived, read-only "variantGuidance" (the variant's base, its implementation guidance, and the same-variant sibling components to implement alike) \u2014 it is resolved from the variant registry, not part of the spec, so never write it back. The structured content carries the same answer with the two derived markers KEPT SEPARATE from the stored spec ({kind, id, spec, partialResult?, variantGuidance?}), so nothing derived can be mistaken for something stored; the text block folds them in as it always has.`,
       inputSchema: {
         kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The kind of specification"),
         id: import_zod11.z.string().describe('The identifier of the spec to fetch (the L0 system spec is a singleton \u2014 pass the system name or "system")'),
         methods: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Return only these methods by name; every other field of the spec comes back unchanged. Only an interface, an implementation or a type declares methods \u2014 asking for one elsewhere is refused, as is a name the spec does not declare (the answer names the ones it does). Omit it for the whole spec.")
-      }
+      },
+      outputSchema: getSpecOutput
     },
     ({ kind, id, methods }) => {
       try {
         const specs = requireSpecs();
         let result = null;
+        let partial = null;
         switch (kind) {
           case "system":
             result = specs.loadSystemSpec();
@@ -28100,21 +28145,26 @@ NOTICE:
             );
           }
           const kept = declared.filter((m) => methods.includes(String(m?.name)));
-          result = {
-            ...result,
-            methods: kept,
-            partialResult: {
-              shown: kept.map((m) => String(m?.name)),
-              omitted: names.length - kept.length,
-              warning: `PARTIAL: ${names.length - kept.length} of this spec's ${names.length} methods are not in this answer. Never re-author from it \u2014 sdd_define_interface and sdd_write_narrative REPLACE the method list, so every method missing here would be removed from the spec.`
-            }
+          partial = {
+            shown: kept.map((m) => String(m?.name)),
+            omitted: names.length - kept.length,
+            warning: `PARTIAL: ${names.length - kept.length} of this spec's ${names.length} methods are not in this answer. Never re-author from it \u2014 sdd_define_interface and sdd_write_narrative REPLACE the method list, so every method missing here would be removed from the spec.`
           };
+          result = { ...result, methods: kept };
         }
-        if (kind === "component") {
-          const guidance = resolveComponentVariantGuidance(result);
-          if (guidance) return json({ ...result, variantGuidance: guidance });
-        }
-        return json(result);
+        const guidance = kind === "component" ? resolveComponentVariantGuidance(result) : null;
+        const folded = {
+          ...result,
+          ...partial ? { partialResult: partial } : {},
+          ...guidance ? { variantGuidance: guidance } : {}
+        };
+        return structured(JSON.stringify(folded, null, 2), {
+          kind,
+          id,
+          spec: result,
+          ...partial ? { partialResult: partial } : {},
+          ...guidance ? { variantGuidance: guidance } : {}
+        });
       } catch (e) {
         return errText(String(e));
       }
@@ -28168,11 +28218,13 @@ NOTICE:
         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", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", invariants and patterns by "id", lint.allow by "code", 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, reason }] }" to silence a WARNING code on this spec only (errors always surface; stale allows are flagged). 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
     },
     ({ kind, id, delta, dryRun }) => {
       try {
-        return text(renderChangeReport(updateSpecGated(kind, id, delta, dryRun)));
+        const report2 = updateSpecGated(kind, id, delta, dryRun);
+        return structured(renderChangeReport(report2), report2);
       } catch (e) {
         return errText(String(e));
       }
@@ -28376,7 +28428,7 @@ async function startMcpServer() {
   } catch {
   }
 }
-var import_mcp, import_stdio, import_zod11, import_types3, fs20, path27, import_url, SERVER_BUILD_STAMP, STALE_SERVER_WARNING, SPEC_WRITE_TOOLS, listChangedEmitters, STORE_MANAGED_FIELDS, STATUS_ORDER, statusInput, ALWAYS_CARRIED_FIELDS, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
+var import_mcp, import_stdio, import_zod11, import_types3, fs20, path27, import_url, TYPE_REF_GRAMMAR, staleServerOutput, SPEC_KINDS, STATUS_ORDER, specWriteReceiptOutput, specChangeOutput, specChangeReportOutput, validationIssueOutput, validateTreeOutput, getSpecOutput, SERVER_BUILD_STAMP, STALE_SERVER_WARNING, SPEC_WRITE_TOOLS, listChangedEmitters, STORE_MANAGED_FIELDS, statusInput, ALWAYS_CARRIED_FIELDS, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
@@ -28407,6 +28459,105 @@ var init_server = __esm({
     init_agent_resolver();
     init_budget_policy();
     init_surfaces();
+    TYPE_REF_GRAMMAR = (what) => `${what}: a primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice" or "billing::Invoice"). Generics, arrays and UNIONS are all read, at any depth: "Invoice | null" (the commonest shape there is), "Invoice | undefined", "Invoice | Receipt", "Promise<Invoice | null>", "Map<string, Invoice | null>", "Invoice[] | null", "(Invoice | null)[]". Every identifier the string names must resolve \u2014 a union of two defined types means BOTH must exist. A union of string literals ("read" | "write") names no type and resolves to nothing.`;
+    staleServerOutput = {
+      staleServer: import_zod11.z.boolean().optional().describe(
+        "True when the wairon build on disk changed after this server started \u2014 the structured twin of the text answer's STALE SERVER banner. Writes through a stale process can silently drop fields a newer schema introduced: restart the MCP session before editing further."
+      )
+    };
+    SPEC_KINDS = ["system", "subsystem", "component", "interface", "implementation", "type"];
+    STATUS_ORDER = ["draft", "design", "complete"];
+    specWriteReceiptOutput = {
+      kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
+      id: import_zod11.z.string().describe('The id the spec is stored under; "system" for the L0 singleton.'),
+      name: import_zod11.z.string().describe("The spec's display name as written."),
+      replacedExisting: import_zod11.z.boolean().describe(
+        "True when a spec already held this id and the call re-authored it in place rather than adding one. The notices then say what was carried forward, removed or cleared by the restatement."
+      ),
+      status: import_zod11.z.enum(STATUS_ORDER).optional().describe(
+        "The lifecycle status written. Absent for a type, which carries none."
+      ),
+      notices: import_zod11.z.array(import_zod11.z.string()).describe(
+        "The notice lines the text answer lists, one per entry: what was carried forward, what a restatement removed, what an omission cleared, and every gate warning the write raised. Empty for a clean create."
+      ),
+      scaffoldedProjectPath: import_zod11.z.string().optional().describe(
+        "The child project directory a chained subsystem's create scaffolded; absent for every other write."
+      ),
+      ...staleServerOutput
+    };
+    specChangeOutput = {
+      path: import_zod11.z.string().describe("The dotted path the change addresses, with names and indexes."),
+      change: import_zod11.z.enum(["set", "added", "removed", "cleared"]).describe("What happened at that path."),
+      before: import_zod11.z.string().optional().describe("The previous value, summarized; absent when there was none."),
+      after: import_zod11.z.string().optional().describe("The new value, summarized; absent when there is none.")
+    };
+    specChangeReportOutput = {
+      kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
+      id: import_zod11.z.string().describe("The stored spec's id."),
+      written: import_zod11.z.boolean().describe("False when the merged spec equals what is stored: nothing reached disk."),
+      dryRun: import_zod11.z.boolean().describe(
+        "True when the caller asked what the delta WOULD do. `written` is false for a dry run exactly as it is for a delta that changed nothing, and only this field tells the two apart."
+      ),
+      changes: import_zod11.z.array(import_zod11.z.object(specChangeOutput)).describe(
+        "Every change the write made; empty exactly when `written` is false."
+      ),
+      ineffective: import_zod11.z.array(import_zod11.z.string()).describe(
+        "Every path the delta named that the write did not act on, each with why. Read it: a nested typo the permissive delta cannot refuse shows up here and nowhere else."
+      ),
+      notices: import_zod11.z.array(import_zod11.z.string()).describe("Store placement notices, gate warnings and delta notices."),
+      summary: import_zod11.z.string().describe("One line for people."),
+      ...staleServerOutput
+    };
+    validationIssueOutput = {
+      severity: import_zod11.z.enum(["error", "warning"]).describe("The finding's severity after project overrides."),
+      code: import_zod11.z.string().describe("The rule code, UPPER_SNAKE \u2014 the stable handle to filter and suppress by."),
+      message: import_zod11.z.string().describe("What is wrong, named."),
+      agentId: import_zod11.z.string().optional().describe("The agent the finding concerns, when it concerns one."),
+      specId: import_zod11.z.string().optional().describe("The spec the finding concerns, when it concerns one."),
+      draftContext: import_zod11.z.boolean().optional().describe(
+        "True when the finding was raised against a draft/design spec \u2014 what the --ci gate waives."
+      ),
+      surfaceResolved: import_zod11.z.boolean().optional().describe(
+        "True when the finding was verified against a vendored surface snapshot, so it is a contract verdict rather than a resolution failure."
+      )
+    };
+    validateTreeOutput = {
+      valid: import_zod11.z.boolean().describe("False when the tree holds at least one error."),
+      errors: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe("Every finding of severity error."),
+      warnings: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe("Every finding of severity warning."),
+      resolvedThrough: import_zod11.z.object({
+        root: import_zod11.z.string().describe("The top root that was validated."),
+        scope: import_zod11.z.string().describe("The mount chain the verdict was scoped to.")
+      }).optional().describe(
+        "Present when a chained subproject's verdict was resolved through its parent; absent when the tree was validated on its own."
+      ),
+      ...staleServerOutput
+    };
+    getSpecOutput = {
+      kind: import_zod11.z.enum(SPEC_KINDS).describe("The kind of spec read."),
+      id: import_zod11.z.string().describe("The id it was read by."),
+      spec: import_zod11.z.record(import_zod11.z.unknown()).describe(
+        "The stored spec, exactly as the text block renders it \u2014 minus the two derived markers below, which the text folds in and this answer keeps separate so nothing derived can be mistaken for stored."
+      ),
+      partialResult: import_zod11.z.object({
+        shown: import_zod11.z.array(import_zod11.z.string()).describe("The method names this answer carries."),
+        omitted: import_zod11.z.number().describe("How many of the spec's methods are NOT in it."),
+        warning: import_zod11.z.string().describe("Why it must never be re-authored from.")
+      }).optional().describe(
+        "Present only when `methods` filtered the read. A filtered spec is a partial one: sdd_define_interface and sdd_write_narrative REPLACE the method list, so re-authoring from it would delete every method left out."
+      ),
+      variantGuidance: import_zod11.z.object({
+        variant: import_zod11.z.string().describe("The variant id the component declares."),
+        base: import_zod11.z.string().describe("The core stereotype it specializes."),
+        guidance: import_zod11.z.string().describe("How to implement a component of this variant."),
+        siblings: import_zod11.z.array(import_zod11.z.string()).describe("Other components of the same variant, to implement alike."),
+        target: import_zod11.z.string().optional().describe("The target language the variant scopes itself to, if any."),
+        profile: import_zod11.z.string().optional().describe("The architectural profile it scopes itself to, if any.")
+      }).optional().describe(
+        "Derived, read-only guidance for a variant-tagged component \u2014 resolved from the variant registry, not part of the spec. Never write it back."
+      ),
+      ...staleServerOutput
+    };
     SERVER_BUILD_STAMP = captureBuildStamp(__filename);
     STALE_SERVER_WARNING = "\n\n\u26A0 STALE SERVER: the wairon build on disk changed after this MCP server started. Restart the MCP session (e.g. /mcp reconnect) before further spec edits \u2014 writes through a stale server can silently drop fields introduced by newer schemas.";
     SPEC_WRITE_TOOLS = /* @__PURE__ */ new Set([
@@ -28429,7 +28580,6 @@ var init_server = __esm({
     ]);
     listChangedEmitters = /* @__PURE__ */ new WeakMap();
     STORE_MANAGED_FIELDS = /* @__PURE__ */ new Set(["status", "updatedAt"]);
-    STATUS_ORDER = ["draft", "design", "complete"];
     statusInput = import_zod11.z.enum(STATUS_ORDER).optional().describe(
       "The spec's lifecycle status. Omitted means draft for a NEW spec and the status already stored for a re-authoring, so a restatement never reopens a frozen spec. State it to author straight at design or complete instead of promoting afterwards. A status that would LOWER the stored one is refused \u2014 reopening a spec for revision is sdd_update_spec's job, which sets the demotion deliberately."
     );