@productbrain/mcp 0.0.1-beta.11434 → 0.0.1-beta.11441

package/dist/{chunk-KU3IBGI4.js → chunk-CY37RSBU.js}

@@ -34,7 +34,7 @@ import {
   runWithToolContext,
   setSessionOriented,
   startAgentSession
-} from "./chunk-QUM6WNMF.js";
+} from "./chunk-LELPZ5YE.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -190,6 +190,81 @@ function orientationRefusalResult(err, lines) {
 }
 var ORIENT_REQUIRED_NOTE = "workflow checkpoints and organisation-structure writes (membership, ownership, parent) still require an oriented session.";
 
+// src/lib/spineRungs.ts
+var SPINE_RUNG_SEQUENCE = [
+  { relationType: "validates", targetKey: "key_result", gapIfMissing: "key_result_missing" },
+  { relationType: "part_of", targetKey: "objective", gapIfMissing: "objective_missing" },
+  { relationType: "part_of", targetKey: "strategy", gapIfMissing: "strategy_missing" },
+  { relationType: "part_of", targetKey: "vision", gapIfMissing: "vision_missing" },
+  { relationType: "part_of", targetKey: "purpose", gapIfMissing: "purpose_missing" }
+];
+
+// src/lib/checklist.ts
+var FIRST_SPINE_SUBJECT = "work_package";
+var kindWord = (kind) => kind.replace(/_/g, " ");
+var withArticle = (word) => `${/^[aeiou]/.test(word) ? "an" : "a"} ${word}`;
+var spineSubject = (kind) => {
+  const words = withArticle(kindWord(kind));
+  return words[0].toUpperCase() + words.slice(1);
+};
+function rungLine(rung) {
+  const index = SPINE_RUNG_SEQUENCE.findIndex((spec) => spec.targetKey === rung);
+  if (index < 0) return null;
+  const { relationType: relationType2, targetKey } = SPINE_RUNG_SEQUENCE[index];
+  const parent = `an accepted ${kindWord(targetKey)}`;
+  const subject = spineSubject(index === 0 ? FIRST_SPINE_SUBJECT : SPINE_RUNG_SEQUENCE[index - 1].targetKey);
+  return relationType2 === "part_of" ? `${subject} hangs on ${parent} with ${relationType2}.` : `${subject} ${relationType2} ${parent}.`;
+}
+var SPINE_RUNG_LINES = SPINE_RUNG_SEQUENCE.map((spec) => rungLine(spec.targetKey));
+var SPINE_LINKS_LINES = [
+  `Spine links run child to parent, each ${SPINE_RUNG_SEQUENCE[SPINE_RUNG_SEQUENCE.length - 1].relationType} the level above.`,
+  `${spineSubject(FIRST_SPINE_SUBJECT)} ${SPINE_RUNG_SEQUENCE[0].relationType} ${withArticle(kindWord(SPINE_RUNG_SEQUENCE[0].targetKey))}; informs joins no levels.`,
+  "Before accepting a spine entry, preflight it: it names what blocks."
+];
+var CHECKLIST_LINES = {
+  purpose: {
+    stranger_test: "Explain it so a stranger knows why this company exists",
+    specificity: "Say what would be missing from the world without this company",
+    not_a_platitude: "Say something a reasonable company would not also claim",
+    beneficiary_named: "Name who it is for: people, a community or part of the world, specific enough to say who it is not for",
+    durable_not_dated: "Leave out dates and planning cycles; those belong on goals"
+  },
+  vision: {
+    specificity: "Say what will be different, in words only this product could use",
+    beneficiary: "Name who it is for: people, a community or part of the world, specific enough to say who it is not for",
+    falsifiability: "Choose a direction a reasonable rival would reject",
+    stranger_test: "Explain it so a stranger knows what will be different, and for whom"
+  },
+  strategy: {
+    coherent_narrative: "Connect the diagnosis, the policy and the first actions",
+    decisiveness: "Say what you will not do",
+    time_bounded: "Name a horizon: a date, a duration or a milestone"
+  },
+  objective: {
+    outcome_not_activity: "State what will be true once it is met, not the work to do",
+    serves_strategy: "Say what must be true for the strategy to succeed",
+    observable: "Make it something a reader could see has happened"
+  },
+  key_result: {
+    measurable: "Name a measure and the target value or state",
+    bounded: "Say by when, or how often, the measure is read",
+    moves_the_objective: "Pick a result that shows the objective is happening, not that work was done"
+  },
+  /** One line per spine rung, keyed by the rung it reaches: rungLine, in SPINE_RUNG_SEQUENCE order (TASK-1026). */
+  strategy_link: Object.fromEntries(SPINE_RUNG_SEQUENCE.map((spec) => [spec.targetKey, rungLine(spec.targetKey)]))
+};
+var MARK = { met: "[x]", not_yet: "[ ]", judging: "[~]" };
+function renderChecklist(canonicalKey, criteria, judging) {
+  const lines = CHECKLIST_LINES[canonicalKey];
+  if (!lines) return null;
+  return criteria.filter((c) => lines[c.id] !== void 0).map((c) => {
+    const state = !c.passed ? "not_yet" : judging ? "judging" : "met";
+    const still = state === "judging" ? " (still judging)" : "";
+    const missing = state === "not_yet" && c.missing ? ` \u2014 missing: ${c.missing}` : "";
+    return `${MARK[state]} ${lines[c.id]}${still}${missing}`;
+  });
+}
+
 // src/lib/createEntryPreviewResult.ts
 async function resolvePreviewPreflight(result2, links) {
   if (!links?.length) return result2.preflight;
@@ -729,57 +804,6 @@ function buildCaptureForRealNextAction(payload) {
   }];
 }
 
-// src/lib/checklist.ts
-var CHECKLIST_LINES = {
-  purpose: {
-    stranger_test: "Explain it so a stranger knows why this company exists",
-    specificity: "Say what would be missing from the world without this company",
-    not_a_platitude: "Say something a reasonable company would not also claim",
-    beneficiary_named: "Name who it is for: people, a community or part of the world, specific enough to say who it is not for",
-    durable_not_dated: "Leave out dates and planning cycles; those belong on goals"
-  },
-  vision: {
-    specificity: "Say what will be different, in words only this product could use",
-    beneficiary: "Name who it is for: people, a community or part of the world, specific enough to say who it is not for",
-    falsifiability: "Choose a direction a reasonable rival would reject",
-    stranger_test: "Explain it so a stranger knows what will be different, and for whom"
-  },
-  strategy: {
-    coherent_narrative: "Connect the diagnosis, the policy and the first actions",
-    decisiveness: "Say what you will not do",
-    time_bounded: "Name a horizon: a date, a duration or a milestone"
-  },
-  objective: {
-    outcome_not_activity: "State what will be true once it is met, not the work to do",
-    serves_strategy: "Say what must be true for the strategy to succeed",
-    observable: "Make it something a reader could see has happened"
-  },
-  key_result: {
-    measurable: "Name a measure and the target value or state",
-    bounded: "Say by when, or how often, the measure is read",
-    moves_the_objective: "Pick a result that shows the objective is happening, not that work was done"
-  },
-  /** One line per spine rung, keyed by the rung it reaches (kernel/strategy/spineTrace.ts order). */
-  strategy_link: {
-    key_result: "Link this work to an accepted key result it validates",
-    objective: "Put the key result under an accepted objective",
-    strategy: "Put the objective under an accepted strategy",
-    vision: "Put the strategy under an accepted vision",
-    purpose: "Put the vision under an accepted purpose"
-  }
-};
-var MARK = { met: "[x]", not_yet: "[ ]", judging: "[~]" };
-function renderChecklist(canonicalKey, criteria, judging) {
-  const lines = CHECKLIST_LINES[canonicalKey];
-  if (!lines) return null;
-  return criteria.filter((c) => lines[c.id] !== void 0).map((c) => {
-    const state = !c.passed ? "not_yet" : judging ? "judging" : "met";
-    const still = state === "judging" ? " (still judging)" : "";
-    const missing = state === "not_yet" && c.missing ? ` \u2014 missing: ${c.missing}` : "";
-    return `${MARK[state]} ${lines[c.id]}${still}${missing}`;
-  });
-}
-
 // src/lib/rubricFormatting.ts
 function verdictQualityPhrase(result2) {
   const v = result2?.verdict;
@@ -911,8 +935,8 @@ var RELATION_BATCH_MAX = 25;
 
 // src/tools/smart-capture.ts
 var CAPTURE_LINK_OUTCOMES = ["written", "refused"];
-var SPINE_FLOOR_SENTENCE = "kept as a draft; it can be accepted once its spine above is accepted \u2014 the promote door checks the whole spine and names the first missing rung.";
 var SPINE_FLOOR_EXEMPT_SENTENCE = "kept as a draft, though this workspace is not yet enforcing the spine above it \u2014 it can be accepted as-is.";
+var LINK_TYPE_DESCRIPTION = `Relation type. The spine links: ${SPINE_RUNG_LINES.join(" ")}`;
 var captureSchema = z5.object({
   collection: z5.string().optional().describe("Collection slug, e.g. 'tensions', 'rules', 'glossary', 'decisions'. Optional \u2014 the kernel classifies when omitted."),
   name: z5.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
@@ -924,7 +948,7 @@ var captureSchema = z5.object({
   // TASK-380: mirrors whyPolicy.ts
   links: z5.array(z5.object({
     to: z5.string().describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
-    type: z5.string().describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
+    type: z5.string().describe(LINK_TYPE_DESCRIPTION)
   })).optional().describe("Links written with the entry in one transaction; each returns written or refused with a reason; a refused link fails nothing."),
   sourceRef: z5.string().optional().describe("URI or path of the source document backing this entry (e.g. 'meeting-2026-03-28.md', 'import://batch-5'). Stored as top-level entry field, not in data."),
   sourceExcerpt: z5.string().optional().describe("Verbatim excerpt from the source that backs this entry's claims. Stored as top-level entry field, not in data."),
@@ -981,7 +1005,7 @@ var captureSuccessOutputSchema = z5.object({
     required: z5.boolean().optional()
   })).optional(),
   // TASK-160: the server's birth-floor verdict must survive the strict output contract.
-  spineFloor: z5.object({ relationType: z5.string(), parentKind: z5.string(), exempt: z5.boolean() }).optional(),
+  spineFloor: z5.object({ relationType: z5.string(), parentKind: z5.string(), exempt: z5.boolean(), linkWritten: z5.boolean().optional() }).optional(),
   // WP-751 M3a-1b (TASK-189, DEC-1700): `coherencyRefusal` and `contradictionAdvisory` are deleted with the
   // client-side auto-commit attempt that alone populated them (its gate refusal, the commit's advisory).
   replayed: z5.literal(true).optional(),
@@ -1008,7 +1032,7 @@ var captureCompoundSchema = z5.object({
   why: z5.string().max(ENTRY_BODY_MAX_CHARS).optional().describe("Why this entry exists."),
   links: z5.array(z5.object({
     to: z5.string().max(200).describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
-    type: z5.string().max(200).describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
+    type: z5.string().max(200).describe(LINK_TYPE_DESCRIPTION)
   })).max(RELATION_BATCH_MAX).optional().describe("Links written with the entry in one transaction; each returns written or refused with a reason; a refused link fails nothing."),
   sourceRef: z5.string().max(2e3).optional().describe("URI or path of the source document backing this entry."),
   sourceExcerpt: z5.string().max(SOURCE_EXCERPT_MAX_CHARS).optional().describe("Verbatim excerpt from the source backing this entry's claims."),
@@ -1260,10 +1284,9 @@ Use \`context action=get\` to inspect the existing entry, or \`entries action=up
     lines.push(`## Accepted: ${finalEntryId}`);
     lines.push(`**${name}** added to your knowledge base.`);
   } else if (spineFloor) {
-    lines.push("");
-    lines.push("## Saved as draft");
-    lines.push(`**${name}** ${spineFloor.exempt ? SPINE_FLOOR_EXEMPT_SENTENCE : SPINE_FLOOR_SENTENCE}`);
-    lines.push(`Next: \`entries action=commit entryId="${finalEntryId}"\`.`);
+    const { relationType: relationType2, parentKind, exempt, linkWritten } = spineFloor, id = finalEntryId, to = `<${parentKind.toUpperCase().replace(/_/g, "-")}-ID>`;
+    lines.push("", "## Saved as draft", `**${name}** ${exempt ? SPINE_FLOOR_EXEMPT_SENTENCE : `kept as a draft. ${rungLine(parentKind)}`}`);
+    lines.push(exempt || linkWritten ? `Next: \`entries action=commit entryId="${id}"\`.` : `Next: \`relations action=create from="${id}" type="${relationType2}" to="${to}"\`.`);
   }
   if (groundingCaveat) lines.push("", groundingCaveat);
   const named = groundingReport.duplicates.slice(0, 3).map((d) => `${d.entryId} "${d.name}"`).join(", ");
@@ -1310,7 +1333,7 @@ Use \`context action=get\` to inspect the existing entry, or \`entries action=up
     next.push({ tool: "context", description: "See its connections", parameters: { action: "find", entryId: finalEntryId } });
   } else {
     next.push({ tool: "context", description: "Review the draft alternative", parameters: { action: "get", entryId: finalEntryId } });
-    next.push({ tool: "entries", description: "Accept onto Chain", parameters: { action: "commit", entryId: finalEntryId } });
+    next.push(spineFloor && !spineFloor.exempt && !spineFloor.linkWritten ? { tool: "relations", description: "Write the spine link it owes", parameters: { action: "create", from: finalEntryId, type: spineFloor.relationType } } : { tool: "entries", description: "Accept onto Chain", parameters: { action: "commit", entryId: finalEntryId } });
   }
   const qualityPhrase = verdictQualityPhrase(verdictResult);
   const summary = finalStatus === "committed" ? `Captured and accepted ${finalEntryId} (${name}) onto ${landedCollection}. ${qualityPhrase}` : `Captured ${finalEntryId} (${name}) as draft in ${landedCollection}. ${qualityPhrase}`;
@@ -3019,11 +3042,91 @@ ${footer}` }],
 
 // src/tools/relations.ts
 import { z as z13 } from "zod/v3";
+
+// src/lib/relationTypes.ts
+var ALLOWED_RELATION_TYPES_LIST = [
+  // Core semantic types
+  "informs",
+  "governs",
+  "surfaces_tension_in",
+  "defines_term_for",
+  "belongs_to",
+  "references",
+  "related_to",
+  "fills_slot",
+  "commits_to",
+  "informed_by",
+  "depends_on",
+  "conflicts_with",
+  "confused_with",
+  // WP-449: Glossary Foundation — negative assertion for agents (spec §4.5)
+  "do_not_confuse_with",
+  "replaces",
+  "part_of",
+  "constrains",
+  // Epistemic types — evidence linking
+  "validates",
+  "invalidates",
+  // Extended types
+  "governed_by",
+  "alternative_to",
+  "has_proposal",
+  "requests_promotion_of",
+  "resolves",
+  // WP-228 Slice 0: Playing Field relation types
+  "experiences",
+  "addresses",
+  // Tier 1 Hierarchy: DEC-401 (experiments prereqs), DEC-402 (risk views)
+  "threatens",
+  "tests",
+  "produces",
+  // WP-274: Capability tier relation types
+  "realizes",
+  "requires",
+  "invests_in",
+  "enables",
+  // PARKED (park note, 2026-08-23) — these 5 verbs are untouched by a separate
+  // governance-verb-ownership review: no delete, no lock, no whitelist, no picker change,
+  // and no relation of this note to that review. Live source-canonicalKey row counts, from
+  // a read-only pass over an uncapped, exhaustive census of a real workspace (measured
+  // 2026-08-23): follows = 11 rows (decision 2, milestone 5, work_package 4);
+  // extracted_from = 4 rows (decision 1, insight 1, tension 1, work_package 1);
+  // part_of_workstream = 0 rows; stated_by = 0 rows; discussed_in = 0 rows. Whether any of
+  // these should be retired, merged, or promoted is a founder call, deliberately deferred —
+  // not decided here, and not decided by silence either. Re-verify the counts before acting
+  // on them; they will drift.
+  // WP-344 S0a: Evolve-First Ingestion relation types
+  "follows",
+  // sequential/derived — new entry follows/continues from another
+  "extracted_from",
+  // provenance — this entry was extracted from a source document
+  // WP-353 S0: scope-propagated commit relation types (DEC-A captured as exploring per RULE-187)
+  "part_of_workstream",
+  // entry belongs to a workstream anchor confirmed at scope step
+  "stated_by",
+  // entry was stated by a speaker in the source document
+  "discussed_in",
+  // entry was discussed within a particular meeting/doc context
+  // Specification types — WP-363 E2: precision alternatives to governs for decision→governance relations
+  "specializes",
+  // DEC narrows or refines a broader STD/PRI — more specific application of the parent
+  "implements",
+  // DEC/WP realizes a BR/STD in concrete operational form
+  // WP-641 S2a (WP-647): belongs_to vocabulary split — the strategy-scope successor.
+  // The other two successors (authority_domain, domain_routed_to) and `blocks` are no longer
+  // legal to write: a new workspace carries none of them (DEC-1845, TASK-331, TASK-425).
+  "anchored_to"
+  // strategy-scope anchor: a raw strategy entry belongs_to a product (DEC-1523)
+];
+var ALLOWED_RELATION_TYPES = new Set(ALLOWED_RELATION_TYPES_LIST);
+
+// src/tools/relations.ts
 var RELATIONS_ACTIONS = ["create", "batch-create", "delete"];
+var relationType = z13.enum(ALLOWED_RELATION_TYPES_LIST);
 var relationItemSchema = z13.object({
   from: z13.string().max(200),
   to: z13.string().max(200),
-  type: z13.string().max(200)
+  type: relationType
 });
 var relationsSchema = z13.object({
   action: z13.enum(RELATIONS_ACTIONS).describe(
@@ -3031,16 +3134,17 @@ var relationsSchema = z13.object({
   ),
   from: z13.string().max(200).optional().describe("For 'create'/'delete': source entry ID."),
   to: z13.string().max(200).optional().describe("For 'create'/'delete': target entry ID."),
-  type: z13.string().max(200).optional().describe("For 'create'/'delete': relation type."),
+  // TASK-1026: the batch item's type is served as a $ref to this one, so the description holds for both; a second enum instance costs 590 bytes of the 64 KB budget (DEC-1981).
+  type: relationType.optional().describe("Relation type, for create, delete and each batch-create item."),
   relations: z13.array(relationItemSchema).min(1).max(RELATION_BATCH_MAX).optional().describe("For 'batch-create': array of {from, to, type}."),
   // WP-316 S3: Preview gate — dry-run mode for action=create.
-  preview: z13.boolean().optional().describe("For 'create': if true, validates the relation without writing. Returns what would happen. Default false.")
+  preview: z13.boolean().optional().describe("For 'create': if true, checks the relation and writes nothing.")
 });
 var relationsCreateVariant = z13.object({
   action: z13.literal("create"),
   from: z13.string().max(200),
   to: z13.string().max(200),
-  type: z13.string().max(200),
+  type: relationType,
   preview: z13.boolean().optional()
 });
 var relationsBatchCreateVariant = z13.object({
@@ -3051,7 +3155,7 @@ var relationsDeleteVariant = z13.object({
   action: z13.literal("delete"),
   from: z13.string().max(200),
   to: z13.string().max(200),
-  type: z13.string().max(200)
+  type: relationType
 });
 var relationsActionUnion = z13.discriminatedUnion("action", [
   relationsCreateVariant,
@@ -3073,7 +3177,9 @@ function registerRelationsTools(server) {
     "relations",
     {
       title: "Relations",
-      description: "Create and delete relations between entries. A relation is written only when you ask for it, with exactly the verb you send. Read an entry's relations with the read-only `context action=find`.\n\n- **create**: Link two entries with a typed relation.\n- **batch-create**: Create multiple relations in one call (validates every item before writing any).\n- **delete**: Remove a relation by from, to, and type.",
+      description: `Create and delete relations between entries, each written only on request with exactly the verb you send. Read relations with the read-only \`context action=find\`.
+
+The spine links, child to parent: ${SPINE_RUNG_LINES.join(" ")}`,
       inputSchema: relationsSchema,
       // DEC-1894 / DEC-74: find lives on the read-only `context` tool; every action left here writes.
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
@@ -4909,27 +5015,27 @@ async function handleBuild(server, entryId, maxHops) {
     )
   };
 }
-async function handleCrossCut(relationType) {
+async function handleCrossCut(relationType2) {
   const result2 = await kernelQuery("chain.structuralAggregation", {
-    relationType
+    relationType: relationType2
   });
   const groupKeys = Object.keys(result2.groups);
   if (result2.totalCount === 0) {
     return {
       content: [{
         type: "text",
-        text: `# Cross-Cut: ${relationType}
+        text: `# Cross-Cut: ${relationType2}
 
-No relations of type '${relationType}' found in this workspace.`
+No relations of type '${relationType2}' found in this workspace.`
       }],
       structuredContent: success(
-        `No '${relationType}' relations found.`,
+        `No '${relationType2}' relations found.`,
         { groups: {}, totalCount: 0, truncated: false }
       )
     };
   }
   const lines = [
-    `# Cross-Cut: ${relationType}`,
+    `# Cross-Cut: ${relationType2}`,
     `_${result2.totalCount} relations across ${groupKeys.length} source collection${groupKeys.length === 1 ? "" : "s"}${result2.truncated ? " (TRUNCATED \u2014 more relations exist)" : ""}_`,
     ""
   ];
@@ -4948,18 +5054,18 @@ No relations of type '${relationType}' found in this workspace.`
   return {
     content: [{ type: "text", text: lines.join("\n") }],
     structuredContent: success(
-      `${result2.totalCount} '${relationType}' relations across ${groupKeys.length} collections.${result2.truncated ? " Truncated." : ""}`,
+      `${result2.totalCount} '${relationType2}' relations across ${groupKeys.length} collections.${result2.truncated ? " Truncated." : ""}`,
       result2
     )
   };
 }
-async function handleChainWalk(entryId, direction, maxHops, relationType) {
+async function handleChainWalk(entryId, direction, maxHops, relationType2) {
   const clampedHops = Math.max(1, Math.min(4, maxHops));
   const result2 = await kernelQuery("chain.deepChainWalk", {
     entryId,
     direction,
     maxHops: clampedHops,
-    ...relationType ? { relationType } : {}
+    ...relationType2 ? { relationType: relationType2 } : {}
   });
   if (result2.error) {
     return notFoundResult(entryId, result2.error);
@@ -4970,7 +5076,7 @@ async function handleChainWalk(entryId, direction, maxHops, relationType) {
         type: "text",
         text: `# Chain Walk: ${entryId}
 
-_No ${direction} relations found${relationType ? ` of type '${relationType}'` : ""}._
+_No ${direction} relations found${relationType2 ? ` of type '${relationType2}'` : ""}._
 
 Try \`context action=chain entryId="${entryId}" direction="${direction === "outgoing" ? "incoming" : "outgoing"}"\` or remove the relationType filter.`
       }],
@@ -4982,7 +5088,7 @@ Try \`context action=chain entryId="${entryId}" direction="${direction === "outg
   }
   const lines = [
     `# Chain Walk: ${entryId}`,
-    `**Direction:** ${direction}  |  **Depth:** ${clampedHops}${relationType ? `  |  **Type filter:** ${relationType}` : ""}`,
+    `**Direction:** ${direction}  |  **Depth:** ${clampedHops}${relationType2 ? `  |  **Type filter:** ${relationType2}` : ""}`,
     `**Nodes:** ${result2.totalNodes}${result2.truncated ? " (TRUNCATED at 100)" : ""}  |  **Edges:** ${result2.edges.length}  |  **Cycles:** ${result2.cycles.length}`,
     ""
   ];
@@ -10218,6 +10324,7 @@ function formatNoticeLines(notices) {
 }
 
 // src/tools/session.ts
+var START_PREFLIGHT_NEXT = 'Next: context action=preflight collection=<kind> links=[{"type":"part_of","entryId":"<PARENT-ID>"}]';
 var SESSION_ACTIONS = [
   "start",
   "close",
@@ -10352,6 +10459,7 @@ async function handleStart2(data) {
     surface: "mcp",
     sessionStart: true
   }));
+  lines.push("", ...SPINE_LINKS_LINES, ...result2.briefing?.firstReply ? [] : [START_PREFLIGHT_NEXT]);
   const summary = `Session ${result2.sessionId} active. Workspace ${result2.workspaceName}. Pass sessionId="${result2.sessionId}" on every write. Orient with a task first; workflow checkpoints and organisation-structure writes still require it.`;
   return {
     content: [{ type: "text", text: lines.join("\n") }],
@@ -12030,6 +12138,8 @@ var INSTRUCTIONS = [
   "Pass the `sessionId` that `session action=start` returned on every write: the connection does not remember it.",
   "Use `capture` to create an entry and read its reply: it lands as a draft, except a question, which is born open and needs no `entries action=commit`.",
   "Link entries with `relations action=create` \u2014 a relation is written only when you ask, with exactly the verb you send.",
+  ...SPINE_LINKS_LINES,
+  // TASK-1022 (WP-862): the spine grammar session start prints, a backup for the clients that load instructions
   "Finish with `session action=wrapup-review`, then `session action=close`.",
   "If the work falls outside the active work packages, name the gap and ask the user before designing it."
 ].join("\n");
@@ -12102,4 +12212,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-KU3IBGI4.js.map
+//# sourceMappingURL=chunk-CY37RSBU.js.map