mandrel 2.13.0 → 2.14.0

package/.agents/schemas/story-deliver-terminal.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/dsj1984/mandrel/blob/main/.agents/schemas/story-deliver-terminal.schema.json",
   "title": "story-deliver-terminal",
-  "description": "The single terminal envelope every Story close-and-land invocation emits (Story #4543). Before this schema, the delivery tail had two divergent prose return contracts — one in .agents/workflows/helpers/deliver-story.md, a different one in .agents/agents/story-worker.md — and neither was validated by anything, so a caller could not tell a landed Story from a parked one without re-probing GitHub. This is the SSOT both now reference rather than restate. status is exactly one of landed | pending | blocked | failed; phase names where the run ended; tail carries per-step booleans so a partial-tail degradation is visible without failing an otherwise-landed merge; nextCommand names the single command that resumes or remediates the run, drawn from the same vocabulary deliver-recover.js prints.",
+  "description": "The single terminal envelope a Story delivery invocation emits (Story #4543). Before this schema, the delivery tail had two divergent prose return contracts — one in .agents/workflows/helpers/deliver-story.md, a different one in .agents/agents/story-worker.md — and neither was validated by anything, so a caller could not tell a landed Story from a parked one without re-probing GitHub. This is the SSOT both now reference rather than restate. status is exactly one of landed | pending | blocked | failed | escalated; phase names where the run ended; tail carries per-step booleans so a partial-tail degradation is visible without failing an otherwise-landed merge; nextCommand names the single command that resumes or remediates the run, drawn from the same vocabulary deliver-recover.js prints. escalated (Story #4746) is the one status emitted BEFORE a Story exists — /deliver-light's suitability gate refusing an over-scope prompt — which is why storyId is null exactly there and non-null everywhere else.",
   "type": "object",
   "required": [
     "kind",
@@ -14,16 +14,21 @@
   ],
   "properties": {
     "kind": { "type": "string", "const": "story-deliver-terminal" },
-    "storyId": { "type": "integer", "minimum": 1 },
+    "storyId": {
+      "type": ["integer", "null"],
+      "minimum": 1,
+      "description": "The Story this envelope reports on. null ONLY for status escalated, where the run refused before authoring a receipt Story — the allOf below pins that correspondence in both directions, so an escalated envelope cannot name a Story it did not create and a landed one cannot omit the Story it landed."
+    },
     "status": {
       "type": "string",
-      "description": "landed — the PR merged, the Story is agent::done, and the post-land tail was attempted. pending — a bounded wait expired with the PR still in flight; NO label was mutated and no merge.unlanded event was emitted, so the run is resumable via nextCommand. blocked — a classified hard block; the Story carries agent::blocked and blocked.blockClass names the class. failed — a phase crashed; phase names which one.",
-      "enum": ["landed", "pending", "blocked", "failed"]
+      "description": "landed — the PR merged, the Story is agent::done, and the post-land tail was attempted. pending — a bounded wait expired with the PR still in flight; NO label was mutated and no merge.unlanded event was emitted, so the run is resumable via nextCommand. blocked — a classified hard block; the Story carries agent::blocked and blocked.blockClass names the class. failed — a phase crashed; phase names which one. escalated — the /deliver-light suitability gate refused an over-scope prompt under --yes; nothing was created and the session ENDS here, nextCommand naming the /plan invocation that owns the work instead.",
+      "enum": ["landed", "pending", "blocked", "failed", "escalated"]
     },
     "phase": {
       "type": "string",
-      "description": "The pipeline phase the run ended in. Mirrors the close pipeline's phase names so a terminal envelope is attributable to one step.",
+      "description": "The pipeline phase the run ended in. Mirrors the close pipeline's phase names so a terminal envelope is attributable to one step. suitability-gate precedes them all — it is the /deliver-light gate, the only phase that runs before a Story exists.",
       "enum": [
+        "suitability-gate",
         "init",
         "wrong-tree-guard",
         "close-validation",
@@ -130,9 +135,35 @@
       },
       "additionalProperties": false
     },
+    "escalation": {
+      "type": ["object", "null"],
+      "description": "Present iff status === \"escalated\" (Story #4746). The suitability gate's decision was already correct before this block existed — what was missing was an outcome a session could not walk past. reasons carries the gate's own words; created records, per artifact, that the run started nothing.",
+      "required": ["reasons", "created"],
+      "properties": {
+        "reasons": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "type": "string", "minLength": 1 },
+          "description": "The gate's reasons verbatim — the same strings the ask-operator path prints, so attended and unattended over-scope explain themselves identically."
+        },
+        "created": {
+          "type": "object",
+          "description": "Per-artifact proof that an escalated run left nothing half-started for a later run to trip over. Deliberately three const-false booleans rather than one aggregate flag or a bare omission: an omitted field reads as \"not checked\", and an aggregate is exactly the shape that let the post-land tail once report an outcome it never verified. Every value is pinned false by the schema, so an escalated envelope claiming it authored a receipt Story, cut a branch, or materialized a worktree cannot be built at all.",
+          "required": ["receiptStory", "storyBranch", "worktree"],
+          "properties": {
+            "receiptStory": { "const": false },
+            "storyBranch": { "const": false },
+            "worktree": { "const": false }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
     "nextCommand": {
       "type": ["string", "null"],
-      "description": "The single command that advances this Story from where it stopped, or null when status === \"landed\" and nothing remains. Shares its vocabulary with deliver-recover.js so recovery and normal resumption speak one language."
+      "description": "The single command that advances this work from where it stopped, or null when status === \"landed\" and nothing remains. Shares its vocabulary with deliver-recover.js so recovery and normal resumption speak one language. For status escalated it is the /plan invocation the operator runs in a FRESH session — the one case where the command is a slash command rather than a script, because the work needs planning, not resumption.",
+      "minLength": 1
     },
     "elapsedSeconds": { "type": "number", "minimum": 0 },
     "waitBudget": {
@@ -148,5 +179,28 @@
     },
     "timestamp": { "type": "string", "format": "date-time" }
   },
+  "allOf": [
+    {
+      "description": "escalated is the pre-Story terminal, and the correspondence is pinned in BOTH directions. An escalated envelope MUST carry the escalation block, MUST have a null storyId (it created none), and MUST name the next command that owns the work — so a run cannot report escalation while pointing at a Story it started. Every other status MUST carry an integer storyId and MUST NOT carry an escalation block, so the new status cannot leak into the close path.",
+      "if": {
+        "properties": { "status": { "const": "escalated" } },
+        "required": ["status"]
+      },
+      "then": {
+        "required": ["escalation"],
+        "properties": {
+          "storyId": { "type": "null" },
+          "escalation": { "type": "object" },
+          "nextCommand": { "type": "string", "minLength": 1 }
+        }
+      },
+      "else": {
+        "properties": {
+          "storyId": { "type": "integer", "minimum": 1 },
+          "escalation": { "type": "null" }
+        }
+      }
+    }
+  ],
   "additionalProperties": false
 }

package/.agents/scripts/deliver-light.js

@@ -23,12 +23,25 @@
  *   - **gate** (default) — judge a prompt's predicted footprint. On
  *     `proceed-light` it authors the receipt Story (via the plan-persist
  *     `createStoryIssues` surface) and prints the init/close hand-off. On
- *     over-scope it prints `ask-operator` (attended) or `escalate-plan`
- *     (`--yes`), never landing silently.
+ *     over-scope it prints `ask-operator` (attended) or emits an `escalated`
+ *     terminal envelope (`--yes`), never landing silently.
  *   - **backstop** (`--backstop --story <id>`) — re-check the ACTUAL diff of
  *     the Story branch after implementation; exit non-zero when it exceeds the
  *     light ceilings, so an over-scope diff is blocked rather than landed.
  *
+ * ## Escalation is terminal, not advisory (Story #4746)
+ *
+ * Over-scope under `--yes` emits a schema-validated `story-deliver-terminal`
+ * envelope with status `escalated` and **ends the session**. Before that it was
+ * an ordinary gate envelope plus exit 2 — a warning a caller could walk past,
+ * and one mandrel-bench 2.13.0 light-arm run did exactly that: it read the
+ * escalation, invoked `/plan` in the same session, and delivered. In-session
+ * planning under-decomposed (ONE Story against the scenario's 3-5 contract,
+ * where a fresh `/plan` session on the identical seed authored four), so
+ * escalation silently produced the outcome the guard exists to prevent.
+ * {@link module:lib/orchestration/story-deliver-terminal.buildEscalationTerminal}
+ * carries the guarantees the schema then enforces.
+ *
  * Usage:
  *   node .agents/scripts/deliver-light.js --prompt "<text>" \
  *     --creates path,path --acceptance 1 --route lite --reason "<why>"
@@ -36,7 +49,8 @@
  *   node .agents/scripts/deliver-light.js --backstop --story 4741
  *
  * Exit codes: 0 ok (proceed / clean backstop), 1 usage error, 2 the gate did
- * not proceed light (ask-operator / escalate-plan), 3 the diff backstop blocked.
+ * not proceed light (ask-operator, or an `escalated` terminal), 3 the diff
+ * backstop blocked.
  */
 
 import { parseArgs } from 'node:util';
@@ -55,6 +69,11 @@ import {
   assemblePlanStories,
   createStoryIssues,
 } from './lib/orchestration/plan-persist/story-ops.js';
+import {
+  buildEscalationTerminal,
+  emitTerminalEnvelope,
+  exitCodeForTerminal,
+} from './lib/orchestration/story-deliver-terminal.js';
 import { createProvider } from './lib/provider-factory.js';
 
 const HELP = `\
@@ -75,7 +94,8 @@ Gate options:
   --route <r>        Ledgered model verdict route: lite | full.
   --reason <text>    Recorded reason for a lite verdict (required for lite).
   --amends <#id>     Mark this as an amendment of an existing issue.
-  --yes              Unattended: over-scope fails closed to /plan (no prompt).
+  --yes              Unattended: over-scope emits an escalated terminal
+                     envelope and ENDS the session (no prompt, no fallback).
 
 Backstop options:
   --backstop         Re-check the ACTUAL diff after implementation.
@@ -291,10 +311,39 @@ async function runBackstopMode(values) {
 /**
  * Gate mode — judge the prompt and, on proceed, author the receipt Story.
  *
+ * The three outcomes are deliberately asymmetric in what they emit:
+ *
+ *   - **`escalate-plan`** returns a schema-validated `escalated` **terminal
+ *     envelope** and stops (Story #4746). It is placed **first**, above every
+ *     creation call site, so "nothing was started" is a property of the
+ *     control flow rather than a claim the envelope makes about itself.
+ *   - **`ask-operator`** is unchanged: the plain gate envelope and exit 2. It
+ *     is not terminal — the operator has a choice to make, and manufacturing a
+ *     terminal for it would end a session that is supposed to be waiting.
+ *   - **`proceed-light`** authors the receipt Story and prints the hand-off.
+ *
+ * The injectable seams exist so the no-side-effect guarantee is testable
+ * without a network: a test asserts the escalate path never reaches them.
+ *
  * @param {object} values Parsed CLI values.
+ * @param {{
+ *   createProviderFn?: typeof createProvider,
+ *   resolveConfigFn?: typeof resolveConfig,
+ *   createReceiptFn?: typeof createLightReceipt,
+ *   emitFn?: typeof emit,
+ *   emitTerminalFn?: typeof emitTerminalEnvelope,
+ * }} [deps]
  * @returns {Promise<number>}
  */
-async function runGateMode(values) {
+export async function runGateMode(values, deps = {}) {
+  const {
+    createProviderFn = createProvider,
+    resolveConfigFn = resolveConfig,
+    createReceiptFn = createLightReceipt,
+    emitFn = emit,
+    emitTerminalFn = emitTerminalEnvelope,
+  } = deps;
+
   if (!values.prompt || String(values.prompt).trim() === '') {
     process.stderr.write(HELP);
     throw new Error('[deliver-light] --prompt <text> is required for the gate');
@@ -311,8 +360,20 @@ async function runGateMode(values) {
     yes: values.yes === true,
   });
 
+  if (gate.action === 'escalate-plan') {
+    const envelope = buildEscalationTerminal({
+      prompt: String(values.prompt),
+      reasons: gate.outcome.reasons,
+    });
+    emitTerminalFn(envelope);
+    Logger.warn(
+      `[deliver-light] ESCALATED to /plan — this session ENDS here; run ${envelope.nextCommand} in a FRESH session: ${gate.outcome.reasons.join('; ')}`,
+    );
+    return exitCodeForTerminal(envelope);
+  }
+
   if (gate.action !== 'proceed-light') {
-    emit(
+    emitFn(
       { mode: 'gate', action: gate.action, outcome: gate.outcome },
       values.pretty,
     );
@@ -322,8 +383,8 @@ async function runGateMode(values) {
     return EXIT_NOT_PROCEED;
   }
 
-  const provider = createProvider(resolveConfig());
-  const receipt = await createLightReceipt({
+  const provider = createProviderFn(resolveConfigFn());
+  const receipt = await createReceiptFn({
     provider,
     prompt: String(values.prompt),
     changedFiles: [
@@ -332,7 +393,7 @@ async function runGateMode(values) {
     ],
     amends: values.amends ?? null,
   });
-  emit(
+  emitFn(
     {
       mode: 'gate',
       action: 'proceed-light',

package/.agents/scripts/lib/orchestration/story-deliver-terminal.js

@@ -61,6 +61,15 @@ export const TERMINAL_EXIT_CODES = Object.freeze({
   pending: 3,
   blocked: 1,
   failed: 1,
+  /**
+   * `escalated` reuses **2**, the code `/deliver-light` already documents for
+   * "the gate did not proceed light" — the escalation is that outcome made
+   * terminal, not a new one, so giving it a fresh code would fork a vocabulary
+   * callers already branch on. It stays distinct from `landed` (nothing was
+   * delivered) and from `blocked`/`failed` (nothing is wrong — the work simply
+   * belongs to `/plan`).
+   */
+  escalated: 2,
 });
 
 export const TERMINAL_STATUSES = Object.freeze([
@@ -68,13 +77,38 @@ export const TERMINAL_STATUSES = Object.freeze([
   'pending',
   'blocked',
   'failed',
+  'escalated',
 ]);
 
+/** Cap on the prompt echoed into an escalation's `/plan` next command. */
+const PLAN_PROMPT_MAX = 200;
+
+/**
+ * Render an operator prompt safe to sit inside the double quotes of the
+ * `/plan "<prompt>"` next command: collapse newlines (a next command is one
+ * line by contract), escape backslashes and double quotes so the quoting
+ * cannot be broken out of, and cap the length so a long prompt does not turn
+ * the envelope into a transcript. Total — a non-string yields the empty
+ * string, which the escalation builder rejects rather than emitting.
+ *
+ * @param {unknown} prompt
+ * @returns {string}
+ */
+function quoteForPlan(prompt) {
+  const text =
+    typeof prompt === 'string' ? prompt.replace(/\s+/g, ' ').trim() : '';
+  const capped =
+    text.length > PLAN_PROMPT_MAX
+      ? `${text.slice(0, PLAN_PROMPT_MAX - 1).trimEnd()}…`
+      : text;
+  return capped.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
 /**
  * The shared next-command vocabulary. Every producer of a "what now?"
- * answer — the `pending` terminal envelope and `deliver-recover.js` —
- * builds its command from here, so the two surfaces never drift into
- * naming different commands for the same observed state.
+ * answer — the `pending` terminal envelope, an `escalated` one, and
+ * `deliver-recover.js` — builds its command from here, so the surfaces never
+ * drift into naming different commands for the same observed state.
  */
 export const NEXT_COMMANDS = Object.freeze({
   /**
@@ -104,6 +138,18 @@ export const NEXT_COMMANDS = Object.freeze({
   /** Probe a stranded Story and print its single next command. */
   recover: (storyId) =>
     `node .agents/scripts/deliver-recover.js --story ${storyId}`,
+  /**
+   * Hand over-scope work to `/plan` — the next command of an `escalated`
+   * terminal (Story #4746).
+   *
+   * The only entry here that is a slash command rather than a script, and
+   * deliberately so: the other entries resume a Story that exists, while this
+   * one names work that has no Story yet and needs planning before it can have
+   * one. It is quoted for a shell but addressed to a **fresh session** — see
+   * the workflow's escalation section for why running it in the escalating
+   * session is forbidden.
+   */
+  escalateToPlan: (prompt) => `/plan "${quoteForPlan(prompt)}"`,
 });
 
 /** @type {Function|null} */
@@ -165,8 +211,9 @@ function compact(obj) {
  * this replaces.
  *
  * @param {object} args
- * @param {number} args.storyId
- * @param {'landed'|'pending'|'blocked'|'failed'} args.status
+ * @param {number|null} args.storyId `null` only for an `escalated` terminal,
+ *   which by construction never authored a Story.
+ * @param {'landed'|'pending'|'blocked'|'failed'|'escalated'} args.status
  * @param {string} args.phase
  * @param {string} [args.storyBranch]
  * @param {string} [args.baseBranch]
@@ -175,6 +222,7 @@ function compact(obj) {
  * @param {object|null} [args.tail]
  * @param {object|null} [args.blocked]
  * @param {object|null} [args.failure]
+ * @param {object|null} [args.escalation]
  * @param {string|null} [args.nextCommand]
  * @param {number} args.elapsedSeconds
  * @param {object|null} [args.waitBudget]
@@ -192,6 +240,7 @@ export function buildTerminalEnvelope({
   tail,
   blocked,
   failure,
+  escalation,
   nextCommand,
   elapsedSeconds = 0,
   waitBudget,
@@ -199,7 +248,10 @@ export function buildTerminalEnvelope({
 }) {
   const envelope = compact({
     kind: TERMINAL_ENVELOPE_KIND,
-    storyId: Number(storyId),
+    // `Number(null)` is 0, which would quietly satisfy nothing and confuse
+    // everything — a nullish storyId stays null and lets the schema decide
+    // whether this status is allowed to omit one.
+    storyId: storyId === null || storyId === undefined ? null : Number(storyId),
     status,
     phase,
     storyBranch: storyBranch ?? null,
@@ -209,6 +261,7 @@ export function buildTerminalEnvelope({
     tail: tail ?? null,
     blocked: blocked ?? null,
     failure: failure ?? null,
+    escalation: escalation ?? null,
     nextCommand: nextCommand ?? null,
     elapsedSeconds: Math.max(0, Number(elapsedSeconds) || 0),
     waitBudget: waitBudget ?? null,
@@ -225,6 +278,69 @@ export function buildTerminalEnvelope({
   return envelope;
 }
 
+/**
+ * Build the `escalated` terminal — the one envelope emitted before a Story
+ * exists (Story #4746).
+ *
+ * `/deliver-light`'s suitability gate already decided correctly when it
+ * overrode a `lite` self-verdict on shape; what it lacked was an outcome a
+ * session could not walk past. A mandrel-bench 2.13.0 light-arm run did
+ * exactly that — it read the gate's `escalate-plan`, then invoked `/plan`
+ * in the same session and delivered. The continuation was not harmless:
+ * planning inside a session already framed as small work authored ONE Story
+ * against the scenario's 3-5 contract, where a fresh `/plan` session on the
+ * identical seed authored four. Escalation silently produced the very
+ * under-decomposition the guard exists to prevent.
+ *
+ * So the outcome is a validated envelope with its own exit code, naming the
+ * `/plan` command that owns the work, and asserting per artifact that nothing
+ * was started. Every guarantee here is enforced by the schema rather than by
+ * prose: `storyId` must be null, `escalation.created.*` are pinned `false`.
+ *
+ * @param {{
+ *   prompt: string,
+ *   reasons?: string[],
+ *   elapsedSeconds?: number,
+ *   timestamp?: string,
+ * }} args
+ * @returns {object} The validated `escalated` envelope.
+ */
+export function buildEscalationTerminal({
+  prompt,
+  reasons,
+  elapsedSeconds = 0,
+  timestamp,
+}) {
+  const quoted = quoteForPlan(prompt);
+  if (quoted === '') {
+    // An escalation whose next command is `/plan ""` hands the operator
+    // nothing — the same walk-past-able non-outcome in envelope clothing.
+    throw new TypeError(
+      'buildEscalationTerminal: a non-empty prompt is required — the escalated terminal exists to name the /plan invocation that owns the work',
+    );
+  }
+  const recorded = (Array.isArray(reasons) ? reasons : []).filter(
+    (r) => typeof r === 'string' && r.trim() !== '',
+  );
+  return buildTerminalEnvelope({
+    storyId: null,
+    status: 'escalated',
+    phase: 'suitability-gate',
+    escalation: {
+      reasons:
+        recorded.length > 0
+          ? recorded
+          : ['predicted scope exceeds the light ceilings — escalate to /plan'],
+      // Not computed from anything: the escalation path returns before the
+      // receipt/init call sites, so these are the assertion that it did.
+      created: { receiptStory: false, storyBranch: false, worktree: false },
+    },
+    nextCommand: NEXT_COMMANDS.escalateToPlan(prompt),
+    elapsedSeconds,
+    ...(timestamp === undefined ? {} : { timestamp }),
+  });
+}
+
 /**
  * Resolve the process exit code for a terminal envelope.
  *

package/.agents/workflows/deliver-light.md

@@ -30,7 +30,8 @@ unchanged close path. It never relaxes a close gate, never bypasses the PR to
    ledgered model verdict with a recorded reason. Both must agree on `lite`.
 2. **Over-scope stops — it never hard-fails.** An over-ceiling prompt STOPS and
    asks the operator to escalate to `/plan` or proceed light. Under `--yes` it
-   fails closed to recommending `/plan`.
+   fails closed to an **`escalated` terminal envelope** that ends the session
+   (§ Escalation is terminal).
 3. **Diff-derived backstop.** After implementation the ACTUAL change set is
    re-checked — the diff is the real scope signal — and an over-ceiling diff is
    blocked rather than landed.
@@ -55,9 +56,10 @@ unchanged close path. It never relaxes a close gate, never bypasses the PR to
      `nextCommands`. Continue to step 2.
    - **`ask-operator`** — predicted scope exceeds the light ceilings. STOP and
      ask the operator to escalate to `/plan` or proceed light. Do not proceed
-     on your own.
-   - **`escalate-plan`** — over-scope under `--yes`: recommend `/plan` and stop.
-     `/deliver-light` never lands over-scope work.
+     on your own. This is a **question, not a terminal** — wait for the answer.
+   - **over-scope under `--yes`** — no `action` to branch on: the gate emits an
+     **`escalated` terminal envelope** instead (exit 2). § Escalation is
+     terminal governs; you are finished.
 
    `--amends '#<id>'` is the canonical light case — shape-checked identically; a
    heavy amendment escalates to `/plan` like any other over-scope prompt.
@@ -98,10 +100,39 @@ unchanged close path. It never relaxes a close gate, never bypasses the PR to
    [`helpers/deliver-digest.md`](helpers/deliver-digest.md) § 5 — every close
    gate runs byte-identical to the full path.
 
+## Escalation is terminal {#escalation-is-terminal}
+
+Over-scope under `--yes` emits a schema-validated `story-deliver-terminal`
+envelope with **`status: "escalated"`**, `storyId: null`, and a `nextCommand`
+naming the `/plan` invocation that owns the work.
+
+**That envelope IS this session's terminal output.** Relay it and stop. There is
+no remaining step, no degraded fallback, and no smaller version of the work to
+attempt.
+
+**Invoking `/plan` in this same session is forbidden.** Hand the operator the
+`nextCommand`; `/plan` runs in a **fresh** session.
+
+This is not style — it is the empirical finding that motivated the envelope.
+A mandrel-bench 2.13.0 light-arm run read the escalation and continued anyway:
+it invoked `/plan` in-session and delivered. The in-session plan authored **one**
+Story against the scenario's 3–5 contract, where a fresh `/plan` session on the
+identical seed authored **four**. Planning inside a session already framed as
+small work under-decomposes, so walking past the escalation silently produced
+the very outcome the guard exists to prevent. The gate's decision was right both
+times; only the outcome's finality was missing.
+
+Nothing is left half-started: an escalated run creates **no receipt Story, no
+`story-<id>` branch, and no worktree** — the escalation path returns before
+every creation call site, and `escalation.created` records all three as `false`
+in a shape the schema pins, so a later run finds nothing to trip over.
+
 ## Constraints
 
-- **Land or block — never a silent local build.** The close push is the only
-  sanctioned landing.
+- **Land, block, or escalate — never a silent local build.** The close push is
+  the only sanctioned landing; an `escalated` terminal is the only sanctioned
+  ending that delivers nothing, and it ends the session
+  (§ Escalation is terminal).
 - **No parallel engine.** `/deliver-light` invokes `single-story-init.js` and
   `single-story-close.js`; it never reimplements worktree, branch, PR, or merge
   mechanics.

package/docs/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.14.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.13.0...mandrel-v2.14.0) (2026-07-24)
+
+
+### Added
+
+* **deliver-light:** make escalate-plan a terminal outcome (refs [#4746](https://github.com/dsj1984/mandrel/issues/4746)) ([#4747](https://github.com/dsj1984/mandrel/issues/4747)) ([53f3151](https://github.com/dsj1984/mandrel/commit/53f3151cff5a22e8ce938ec286cc2898985eb892))
+
 ## [2.13.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.12.0...mandrel-v2.13.0) (2026-07-24)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandrel",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "Claude Code-first opinionated workflow framework: instructions, skills, rules, and SDLC workflows that govern AI coding assistants.",
   "files": [
     ".agents/",