mandrel 2.64.0 → 2.65.0

package/.agents/scripts/lib/orchestration/single-story-close/runner.js

@@ -33,6 +33,7 @@ import { runConfirmMergePhase } from './phases/confirm-merge.js';
 import { runGraphqlPreflight } from './phases/graphql-preflight.js';
 import { lockWaitPending } from './phases/lock-wait-pending.js';
 import { parseCloseOptions, resolveWaitForMerge } from './phases/options.js';
+import { runPostLandTail } from './phases/post-land.js';
 import { ensurePullRequestWith } from './phases/pull-request.js';
 import { pushStoryBranch } from './phases/push.js';
 import { handleCriticalReviewBlock } from './phases/review-block.js';
@@ -42,12 +43,54 @@ import { runWrongTreeGuardPhase } from './phases/wrong-tree-guard.js';
 
 const progress = Logger.createProgress('single-story-close', { stderr: true });
 
+/**
+ * Wall-clock seconds per named phase; each transition logs the phase it ends.
+ *
+ * @param {() => number} [nowMs]
+ */
+function createPhaseTimer(nowMs = Date.now) {
+  const durations = {};
+  let current = null;
+  let since = 0;
+  const end = () => {
+    if (current === null) return;
+    const seconds = Math.round((nowMs() - since) / 100) / 10;
+    durations[current] = (durations[current] ?? 0) + seconds;
+    progress('TIMING', `⏱  ${current}: ${seconds}s`);
+    current = null;
+  };
+  return {
+    enter(phase) {
+      end();
+      if (phase === 'init') return;
+      current = phase;
+      since = nowMs();
+    },
+    finish() {
+      end();
+      return Object.keys(durations).length > 0 ? { ...durations } : null;
+    },
+    stamp(terminal) {
+      const phaseDurations = this.finish();
+      if (phaseDurations) terminal.phaseDurations = phaseDurations;
+    },
+  };
+}
+
+const UNTIMED = Object.freeze({ stamp() {} });
+
 /**
  * The single terminal writer: the result summary, the envelope callers parse,
  * and terminal friction — so no ending can forget one. Must be awaited: the
  * CLI `process.exit`s as soon as `main` resolves.
  */
-async function emitTerminal({ terminal, result, config }) {
+async function emitTerminal({
+  terminal,
+  result,
+  config,
+  phaseTimer = UNTIMED,
+}) {
+  phaseTimer.stamp(terminal);
   if (result) {
     emitTerseResult({
       label: 'STORY CLOSE RESULT',
@@ -516,8 +559,10 @@ export async function runSingleStoryClose({
   // builds the `failed` envelope from those tags.
   let phase = 'init';
   let observedGates = null;
+  const phaseTimer = createPhaseTimer();
   const setPhase = (next) => {
     phase = next;
+    phaseTimer.enter(next);
   };
   const setObservedGates = (gates) => {
     observedGates = gates;
@@ -527,6 +572,7 @@ export async function runSingleStoryClose({
       options,
       setPhase,
       setObservedGates,
+      phaseTimer,
       injectedProvider,
       injectedConfig,
       injectedNotify,
@@ -539,6 +585,7 @@ export async function runSingleStoryClose({
     });
   } catch (err) {
     if (err && typeof err === 'object') {
+      err.closePhaseDurations = phaseTimer.finish();
       if (!err.closePhase) err.closePhase = phase;
       if (!err.closeGates && observedGates) err.closeGates = observedGates;
     }
@@ -617,6 +664,10 @@ async function finishWithMergeWait(prCtx, deps) {
     progress,
     injectedGh: deps.injectedGh,
     injectedNotify: deps.injectedNotify,
+    runPostLandTailFn: (args) => {
+      deps.setPhase('post-land');
+      return runPostLandTail(args);
+    },
   });
   const terminal = terminalFromWaitOutcome({
     waitOutcome,
@@ -650,7 +701,12 @@ async function finishWithMergeWait(prCtx, deps) {
     }),
     landCompleted: waitOutcome.confirmed === true,
   });
-  await emitTerminal({ terminal, result, config: prCtx.config });
+  await emitTerminal({
+    terminal,
+    result,
+    config: prCtx.config,
+    phaseTimer: prCtx.phaseTimer,
+  });
   reportWaitTerminal(terminal, { storyId: prCtx.storyId, prUrl: prCtx.prUrl });
   return { success: terminal.status === 'landed', result, terminal };
 }
@@ -698,7 +754,12 @@ async function finishWithoutMergeWait(prCtx, waitForMergeReason) {
     nextCommand: NEXT_COMMANDS.confirmMerge(prCtx.storyId),
     elapsedSeconds: elapsedSecondsSince(prCtx.startedAtMs),
   });
-  await emitTerminal({ terminal, result, config: prCtx.config });
+  await emitTerminal({
+    terminal,
+    result,
+    config: prCtx.config,
+    phaseTimer: prCtx.phaseTimer,
+  });
   progress(
     'DONE',
     `✅ Story #${prCtx.storyId}: PR ready → ${prCtx.prUrl} (${waitForMergeReason})`,
@@ -714,13 +775,16 @@ async function finishWithoutMergeWait(prCtx, waitForMergeReason) {
  *   config: object, startedAtMs: number }} ctx
  * @returns {Promise<{ success: false, result: object, terminal: object }>}
  */
-async function finishDeferred(lockWait, { config, startedAtMs, ...ids }) {
+async function finishDeferred(
+  lockWait,
+  { config, startedAtMs, phaseTimer, ...ids },
+) {
   const { result, terminal, note } = lockWaitPending({
     ...ids,
     lockWait,
     elapsedSeconds: elapsedSecondsSince(startedAtMs),
   });
-  await emitTerminal({ terminal, result, config });
+  await emitTerminal({ terminal, result, config, phaseTimer });
   progress('PENDING', note);
   return { success: false, result, terminal };
 }
@@ -759,6 +823,7 @@ async function runClosePipeline({
   options,
   setPhase,
   setObservedGates,
+  phaseTimer,
   injectedProvider,
   injectedConfig,
   injectedNotify,
@@ -848,6 +913,7 @@ async function runClosePipeline({
       baseBranch,
       config,
       startedAtMs,
+      phaseTimer,
     });
   }
 
@@ -943,6 +1009,7 @@ async function runClosePipeline({
     directMerged,
     config,
     startedAtMs,
+    phaseTimer,
     lockWait: prePush.lockWait,
     gates: closeEnvelopeGates(options, prePush.validationGates, reviewOverride),
   };

package/.agents/scripts/lib/orchestration/story-close/phases/review-core.js

@@ -3,23 +3,20 @@
  * maker-blind `runCodeReview` invocation out of any phase file.
  */
 
-import { countChangedLines } from '../../../audit-suite/index.js';
 import { gitSpawn } from '../../../git-utils.js';
-import { appendFindingsYield } from '../../../observability/metrics-ledger.js';
 import { computeChangeSet } from '../../change-set.js';
 import { runCodeReview } from '../../code-review.js';
-import { runLocalLensReview } from './local-lens-review.js';
 
 /**
- * Run the local-lens pass and `runCodeReview` over one change set and return
- * the review result. Throws propagate; the caller picks the advisory posture.
- * Review depth is derived by `runCodeReview` from the changed files and is
- * input-only — it never alters the output envelope.
+ * Run `runCodeReview` over one change set and return the review result.
+ * Throws propagate; the caller picks the advisory posture. Review depth is
+ * derived by `runCodeReview` from the changed files and is input-only — it
+ * never alters the output envelope.
  *
- * The diff is enumerated exactly once here and injected into both consumers,
- * so lens roster and review depth agree on what changed even if a commit
- * lands in between. An unenumerable diff injects `null` ("already tried"),
- * which both consumers honour without re-spawning git.
+ * The diff is enumerated exactly once here and injected into the review, so
+ * review depth scores the same file set the change set names even if a
+ * commit lands in between. An unenumerable diff injects `null` ("already
+ * tried"), which the review honours without re-spawning git.
  *
  * @param {{
  *   storyId: number|string,
@@ -32,12 +29,9 @@ import { runLocalLensReview } from './local-lens-review.js';
  *   gitSpawnFn?: import('../../change-set.js').GitSpawnFn,
  *   computeChangeSetFn?: typeof computeChangeSet,
  *   runCodeReviewFn?: typeof runCodeReview,
- *   runLocalLensReviewFn?: typeof runLocalLensReview,
- *   countChangedLinesFn?: typeof countChangedLines,
- *   appendFindingsYieldFn?: typeof appendFindingsYield,
  * }} args
- * @returns {Promise<object>} The `runCodeReview` result plus
- *   `localLensReview` and the computed `changeSet`.
+ * @returns {Promise<object>} The `runCodeReview` result plus the computed
+ *   `changeSet`.
  */
 export async function runStoryReviewCore({
   storyId,
@@ -50,24 +44,12 @@ export async function runStoryReviewCore({
   gitSpawnFn = gitSpawn,
   computeChangeSetFn = computeChangeSet,
   runCodeReviewFn = runCodeReview,
-  runLocalLensReviewFn = runLocalLensReview,
-  countChangedLinesFn = countChangedLines,
-  appendFindingsYieldFn = appendFindingsYield,
 }) {
-  const storyIdNum = Number(storyId);
-
   const changeSet = computeChangeSetFn({ baseRef, headRef, gitSpawnFn });
 
-  // Line count for the lens diff-floor, probed only for a non-empty file set;
-  // `null` = unknown, and the floor fails open.
-  const changedLineCount =
-    Array.isArray(changeSet.files) && changeSet.files.length > 0
-      ? countChangedLinesFn({ baseRef, headRef, gitSpawnFn })
-      : null;
-
   const opts = {
     scope: 'story',
-    ticketId: storyIdNum,
+    ticketId: Number(storyId),
     baseRef,
     headRef,
     provider,
@@ -82,63 +64,6 @@ export async function runStoryReviewCore({
     opts.commentTargetId = commentTargetId;
   }
 
-  const localLensReview = await runLocalLensReviewFn({
-    baseRef,
-    headRef,
-    changedFiles: changeSet.files,
-    changedLineCount,
-    storyId: storyIdNum,
-    progress,
-    progressTag,
-    gitSpawnFn,
-  });
-
   const result = await runCodeReviewFn(opts);
-
-  // Best-effort findings-yield ledger, for tuning the roster on measurement.
-  try {
-    const yieldEntries = buildLensYieldEntries(localLensReview);
-    if (yieldEntries !== null) {
-      await appendFindingsYieldFn({
-        storyId: storyIdNum,
-        cli: 'story-close-review',
-        lenses: yieldEntries,
-        diffFloor: localLensReview?.floorSkip ?? null,
-      });
-    }
-  } catch (err) {
-    progress(
-      progressTag,
-      `⚠️ findings-yield ledger append failed (continuing): ${err?.message ?? err}`,
-    );
-  }
-
-  return { ...result, localLensReview, changeSet };
-}
-
-/**
- * One findings-yield entry per matched lens; `null` for an empty roster.
- *
- * @param {object|null|undefined} localLensReview
- * @returns {Array<{ lens: string, findings: number, skippedByFloor: boolean }>|null}
- */
-function buildLensYieldEntries(localLensReview) {
-  const lenses = Array.isArray(localLensReview?.lenses)
-    ? localLensReview.lenses.filter((l) => typeof l === 'string' && l.length)
-    : [];
-  if (lenses.length === 0) return null;
-  const skippedByFloor = localLensReview?.floorSkip?.skip === true;
-  const findingsByLens = new Map();
-  for (const finding of localLensReview?.materialized?.findings ?? []) {
-    if (typeof finding?.audit !== 'string') continue;
-    findingsByLens.set(
-      finding.audit,
-      (findingsByLens.get(finding.audit) ?? 0) + 1,
-    );
-  }
-  return lenses.map((lens) => ({
-    lens,
-    findings: skippedByFloor ? 0 : (findingsByLens.get(lens) ?? 0),
-    skippedByFloor,
-  }));
+  return { ...result, changeSet };
 }

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

@@ -116,6 +116,7 @@ function compact(obj) {
  * @param {object|null} [args.waitBudget]
  * @param {{ waitedSeconds: number, expired: boolean }|null} [args.lockWait]
  *   Full-suite lock wait; `waitBudget` is merge-wait only.
+ * @param {Record<string, number>|null} [args.phaseDurations] Seconds per phase.
  * @param {string} [args.timestamp]
  * @param {{ schema: object|null, error: string|null }} [args.schemaSource]
  *   Test seam.
@@ -137,6 +138,7 @@ export function buildTerminalEnvelope({
   elapsedSeconds = 0,
   waitBudget,
   lockWait,
+  phaseDurations,
   timestamp = new Date().toISOString(),
   schemaSource,
 }) {
@@ -158,6 +160,7 @@ export function buildTerminalEnvelope({
     elapsedSeconds: Math.max(0, Number(elapsedSeconds) || 0),
     waitBudget: waitBudget ?? null,
     lockWait: lockWait ?? null,
+    phaseDurations,
     timestamp,
   });
 

package/.agents/scripts/lib/templates/decomposer-prompts.js

@@ -31,13 +31,11 @@ export function renderStoryAuthorCore() {
     (lint) =>
       `- **${lint.id}** — ${lint.summary} Example: \`${lint.goodExample}\``,
   ).join('\n');
-  return `You are an expert Senior Project Manager and Orchestrator.
-Your job is to turn a plan seed / Tech Spec into a Story ticket array for an AI Agent to execute.
+  return `Turn a plan seed / Tech Spec into Story tickets for an AI agent to execute. The emitted stories template (see STORY BODY SCHEMA) is the ticket shape.
 
 ### HIERARCHY RULES (v2 default-single):
 1. **Emit exactly one Story by default.** Split into N>1 only when pieces have near-zero overlap or sit across an architectural seam. Coupled work stays one Story — put intra-session checkpoints in \`## Slicing\` and fold the Tech Spec into \`## Spec\`.
 2. **Stories**: Specific user-facing or architectural capabilities (e.g., "Implement JWT Token Exchange").
-   - There is NO Epic parent ticket, NO Feature tier, and NO Task layer.
    - **Story-Level Execution**: Each Story is executed end-to-end on a single branch by a single agent. Acceptance criteria and verification commands live as top-level \`acceptance[]\` / \`verify[]\` arrays on the Story ticket (see STORY BODY SCHEMA below).
    - Thematic grouping is prose in the Story's folded \`## Spec\` / \`## Slicing\`, never sibling tickets for coupled work.
 
@@ -46,27 +44,10 @@ Your job is to turn a plan seed / Tech Spec into a Story ticket array for an AI
 - \`labels[]\` is **optional**. Emit it only to request an *additional* label; persist sanitizes the list before applying it.
 - Do **not** emit \`agent::*\` labels — lifecycle state is runtime-owned, and persist applies \`agent::ready\` itself once every checkpoint is on the ticket.
 
-### OUTPUT FORMAT:
-You MUST respond ONLY with a valid JSON array of objects. No prose, no markdown blocks.
-
-### JSON SCHEMA:
-[
-  {
-    "slug": "hyphen-case-id",
-    "type": "story",
-    "title": "Short descriptive title",
-    "body": <string — see STORY BODY SCHEMA below>,
-    "acceptance": ["<outcome a PR reviewer can confirm>", ...],
-    "verify": ["<exact command or test path>", ...],
-    "labels": ["<extra-label>"] (optional — type::story is applied automatically; omit this field unless you need an additional label),
-    "depends_on": ["slug-of-blocking-dependency"] (optional array of Story slugs that block execution)
-  }
-]
-
 **Slug format**: \`^[a-z0-9][a-z0-9-]*$\` — hyphen-case only. Underscores are rejected by the validator.
 
 ### STORY BODY SCHEMA (REQUIRED FOR EVERY STORY):
-\`body\` is either the serialized markdown **string** (the section format below) or a **structured object** carrying the same fields (\`goal\`, optional \`slicing\` / \`spec\`, \`changes\`, optional \`non_goals\`) — persist parses either shape and serializes the canonical markdown itself, so you never need to read \`story-body.js\` or hand-assemble the markdown (the \`stories.template.json\` file emitted next to the plan-context envelope is a ready-to-fill structured-object skeleton). Stories are consumed by non-interactive sub-agents that must self-verify from the Story ticket alone — so the ticket must carry everything an agent needs to execute and self-verify.
+\`body\` is either the serialized markdown **string** (the section format below) or a **structured object** carrying the same fields (\`goal\`, optional \`slicing\` / \`spec\`, \`changes\`, optional \`non_goals\`) — persist parses either shape and serializes the canonical markdown itself, so you never need to read \`story-body.js\` or hand-assemble the markdown (the \`stories.template.json\` file emitted next to the plan-context envelope is a ready-to-fill structured-object skeleton). The executing sub-agent is non-interactive and self-verifies from the ticket alone, so the ticket carries everything it needs.
 
 The \`acceptance[]\` and \`verify[]\` arrays live at the **top level** of the Story ticket object — that is the machine contract the validator reads. Author each list **once, at top level**, and **omit** the \`## Acceptance\` / \`## Verify\` sections from the authored \`body\` string: persist syncs the top-level arrays into those sections so the GitHub issue stays a complete executable document. The validator resolves both fields from the top level, so an omitted section is the expected shape, not a violation.
 
@@ -153,9 +134,9 @@ ${envelopeFloor}
 - A Story touching UI (\`*.tsx\`, \`*.astro\`, \`*.svelte\`, \`*.vue\`, a components folder) states the \`data-testid\` contract in \`acceptance[]\` per the testid contract in \`.agents/skills/stack/qa/playwright/SKILL.md\`.
 - A Story touching user-visible copy, brand assets or visual style cites the relevant section of \`docs/style-guide.md\` in \`acceptance[]\` when that file exists.
 
-CRITICAL: Dependencies should follow execution blockers. There is no parent ticket — never emit a 'parent_slug' field.
-IMPORTANT DEPENDENCY RULE: Story-to-Story dependencies are expressed via \`depends_on\` (one Story depends_on another Story's slug). Use this to express execution ordering across the plan.
-**Never stop mid-array.** Always emit complete JSON — partial arrays are rejected by the validator.`;
+#### ORDERING:
+
+Express execution ordering between Stories with \`depends_on\` — the slugs of the Stories that must land first. Never emit a parent field.`;
 }
 
 /**

package/.agents/scripts/providers/github/issues.js

@@ -138,38 +138,29 @@ export class IssuesGateway {
 
   /**
    * Resolve an issue's container parent in one request via `Issue.parent`.
-   * Never throws: no parent, an odd shape, or sub-issues being unavailable all
-   * return `null`, leaving the caller's checklist fallback to run.
+   * `null` means "no parent"; a degraded lookup throws after retries.
    *
    * @param {number} number Issue number whose parent to resolve.
    * @returns {Promise<object|null>} Mapped parent ticket, or null.
+   * @throws {Error} When the lookup degrades.
    * @field-manifest GraphQL Issue.parent: number, id, title, body, state,
    *                 labels.nodes.name, assignees.nodes.login
    */
   async getParentIssue(number) {
     const issueNumber = Number(number);
     if (!Number.isInteger(issueNumber) || issueNumber <= 0) return null;
-    let data;
-    try {
-      data = await withTransientRetry(
-        () =>
-          this.ghGraphql(
-            PARENT_ISSUE_QUERY,
-            { owner: this.owner, repo: this.repo, number: issueNumber },
-            { headers: { 'GraphQL-Features': 'sub_issues' } },
-          ),
-        {
-          label: `getParentIssue #${issueNumber}`,
-          onRetry: defaultRetryWarn,
-        },
-      );
-    } catch (err) {
-      Logger.warn(
-        `[GitHubProvider] parent lookup for #${issueNumber} degraded to none ` +
-          `(${err?.message ?? err}).`,
-      );
-      return null;
-    }
+    const data = await withTransientRetry(
+      () =>
+        this.ghGraphql(
+          PARENT_ISSUE_QUERY,
+          { owner: this.owner, repo: this.repo, number: issueNumber },
+          { headers: { 'GraphQL-Features': 'sub_issues' } },
+        ),
+      {
+        label: `getParentIssue #${issueNumber}`,
+        onRetry: defaultRetryWarn,
+      },
+    );
     return subIssueNodeToTicket(data?.repository?.issue?.parent ?? null);
   }
 

package/.agents/scripts/sync-claude-agents.js

@@ -4,7 +4,7 @@
  * Project `.agents/agents/` and `.agents/local/agents/` into a flat
  * `.claude/agents/` tree — the sibling of `sync-claude-commands.js`, with the
  * same payload-wins shadowing and orphan-reap. A role agent runs on its own
- * system prompt (no `CLAUDE.md` closure), which is the point of routing to it.
+ * system prompt (no entry-doc `@`-import closure), which is the point of routing to it.
  */
 
 // cli-opt-out: top-level-await script with no main() function — runAsCli wraps an async main, which doesn't apply here.

package/.agents/workflows/audit-quality.md

@@ -12,7 +12,8 @@ the Story under audit. The shared lens machinery lives in
 `{{auditOutputDir}}/audit-quality-results.md`. Each finding carries a
 **Category:** (`Flakiness | Coverage | Performance | Mocking | Test Plans`); the
 report adds a **Test Strategy Assessment** table (Unit / Integration / E2E /
-Test Plans: Healthy / Needs Work / Missing).
+Test Plans / Property-Based Testing: Healthy / Needs Work / Missing, or `N/A`
+for Property-Based Testing when no module is a candidate).
 
 ## Scope
 
@@ -130,6 +131,36 @@ Evaluate the gathered context against the following test quality dimensions:
    finding here. Route the *architectural* framing of the same defect to
    [`audit-architecture`](audit-architecture.md)'s Shipped-But-Never-Wired
    dimension; this lens owns the **missing-test** framing.
+8. **Property-Based Coverage — Invariants Tested Only by Examples.** Flag a
+   module whose correctness rests on an invariant but whose tests are all
+   hand-picked examples, which structurally cannot reach the inputs nobody
+   thought to pick. A module is a candidate **only** on code evidence: a
+   documented invariant or "never"/"always" claim in a header comment; an
+   explicit state machine or status/label transition table; an
+   encode/decode, parse/serialize or normalise pair (round-trip); a
+   merge/dedup/sort/scheduler function; bounded-concurrency or retry
+   coordination over async I/O; or an idempotency claim. A module with no
+   stated or implied invariant is **never** a finding. Rank candidates by
+   Step 0's churn × coverage gap and cite their `baselines/` coverage/CRAP row
+   where one exists.
+
+   - **Toolchain by ecosystem, never one library.** Detect an existing
+     property-testing library from the consumer's manifests (e.g.
+     `fast-check` for JS/TS, `hypothesis` for Python, `proptest`/`quickcheck`
+     for Rust, `jqwik` for the JVM, `rapid`/`gopter` for Go); recommend the
+     ecosystem-idiomatic one only when none is present.
+   - Severity: an async/concurrency coordinator, or a guard whose
+     invariant protects an irreversible write, tested only by examples →
+     **High**; any other invariant-bearing module with example-only tests →
+     **Medium**; toolchain absent with no High/Medium candidate → **one Low**
+     roll-up finding, not one per module.
+   - Category: file under `Coverage`. A property test whose seed is
+     neither pinned nor printed on failure goes under `Flakiness`: a red that
+     cannot be reproduced breaks the reproducibility the rubric demands.
+   - **Name the property.** Each finding states the invariant as a testable
+     property (e.g. `decode(encode(x)) === x`; "no transition leaves a
+     terminal state") plus its generator shape (the input domain to draw
+     from) — never a bare "add property tests".
 
 ## Constraint (lens-specific carve-out)
 
@@ -150,10 +181,14 @@ table:
 
 ## Test Strategy Assessment
 
-| Layer               | Status                           | Notes          |
-| ------------------- | -------------------------------- | -------------- |
-| Unit Testing        | [Healthy / Needs Work / Missing] | [Brief reason] |
-| Integration Testing | [Healthy / Needs Work / Missing] | [Brief reason] |
-| E2E Testing         | [Healthy / Needs Work / Missing] | [Brief reason] |
-| Test Plans          | [Healthy / Needs Work / Missing] | [Brief reason] |
+| Layer                  | Status                                 | Notes          |
+| ---------------------- | -------------------------------------- | -------------- |
+| Unit Testing           | [Healthy / Needs Work / Missing]       | [Brief reason] |
+| Integration Testing    | [Healthy / Needs Work / Missing]       | [Brief reason] |
+| E2E Testing            | [Healthy / Needs Work / Missing]       | [Brief reason] |
+| Test Plans             | [Healthy / Needs Work / Missing]       | [Brief reason] |
+| Property-Based Testing | [Healthy / Needs Work / Missing / N/A] | [Brief reason] |
 ```
+
+`Property-Based Testing` reads `N/A` when the repo has no candidate module
+(dimension 8), so a repo with no invariant-bearing code is not nagged.

package/.agents/workflows/helpers/acceptance-self-eval.md

@@ -69,7 +69,7 @@ per-criterion, mid-delivery, and evaluates the actual work product.
    > `delivery.routing.roleScopedAgents` is enabled (the **default**), use
    > `subagent_type: acceptance-critic`: it boots on the role-scoped
    > [`acceptance-critic`](../../agents/acceptance-critic.md) context (its own
-   > system prompt, no `CLAUDE.md` @-closure) carrying the maker-blind
+   > system prompt, no entry-doc @-closure) carrying the maker-blind
    > invariant and the verdict schema standalone. With the kill-switch off
    > (`roleScopedAgents: false`), fall back to
    > `subagent_type: general-purpose`. This loop already runs inside a Story

package/.agents/workflows/helpers/code-review.md

@@ -74,8 +74,8 @@ How each tier changes the review protocol:
   adversarial pass over the diff hunting for integration regressions and
   security-relevant edges before findings are finalized.
 
-The LLM-backed review providers (codex, security-review, ultrareview) render
-the resolved `depth` into the prompt/instructions they emit so the underlying
+The LLM-backed review providers (code-review, codex, security-review,
+ultrareview) render the resolved `depth` into the prompt/instructions they emit so the underlying
 model actually changes thoroughness. The native provider deliberately ignores
 `depth` — its mechanical lint + maintainability sweep already scales with diff
 size, and there is no "review harder" knob a deterministic scorer can turn (its
@@ -110,44 +110,21 @@ The pipeline will:
 - Run a focused lint check on the change set.
 - Post a structured summary report to the `[TICKET_ID]` issue.
 
-### Step 1a — Story-scope local-lens pass (`scope: story` only)
-
-When `scope === 'story'`, the shared review spine
-[`runStoryReviewCore`](../../scripts/lib/orchestration/story-close/phases/review-core.js)
-runs a **shift-left local-lens pass** in the same close subprocess, *before*
-returning the review envelope. It:
-
-1. Enumerates the actual Story diff (`baseRef...headRef` via
-   `git diff --name-only`).
-2. Selects the **local-tier** lenses that own a concern decidable from a single
-   Story's diff — `resolveLensTier(lens) === 'local'` **plus** the pure
-   `matchesAnyFilePattern` matcher against the diff (the audit-suite SDK's
-   [`selectLocalLenses`](../../scripts/lib/audit-suite/selector.js)). This is
-   deliberately **not** `selectAudits`: `selectAudits` unions in keyword and
-   gate matches and has no per-tier gate, so it would widen the roster past the
-   footprint-matched local set this tier owns.
-3. Materializes the matched roster at **`light`** depth
-   (`STORY_SCOPE_LENS_DEPTH`) via `runAuditSuite`, surfacing the outcome on the
-   review envelope's `localLensReview` field.
-
-A diff that matches no local lens adds **no** lens work (the roster is empty and
-`runAuditSuite` is never invoked). The pass is advisory and best-effort: a git
-or materialization failure degrades to a skipped envelope and never blocks the
-close.
-
-The live close entry point —
-[`runStoryScopeReview`](../../scripts/lib/orchestration/single-story-close/phases/code-review.js)
-— reaches this pass through the shared `runStoryReviewCore` spine. Because
-the pass lives inside the close subprocess (invoked after the delivering
-child exits), it honors the maker-blind invariant above: a maker never runs
-its own local-lens review.
+### Story scope runs no lens pass
+
+Close runs **no** audit-lens pass of its own (Story #5416 retired it: it
+materialized prompt files no workflow read, then armed auto-merge without
+waiting). The Story-scope review is this pipeline plus CI. Local-tier lens
+concerns are covered shift-left by the write-time authoring checklists
+threaded into the Story prompt; the on-demand `/audit-*` workflows remain the
+way to run a full lens over a change.
 
 ## Step 2 — Review Pillars
 
 For each changed file, execute a strict review against four pillars. The
 second pillar (**Integration Review**) deliberately defers the security /
 performance / quality / coverage sweeps to the change-set-scoped lenses —
-those ran shift-left in the Story-scope local-lens pass (Step 1a).
+those are covered shift-left by the write-time lens checklists.
 Re-walking those sweeps a second time in this pillar is duplication, not
 defense-in-depth.
 
@@ -173,9 +150,9 @@ Does the implementation match the Story's acceptance criteria and folded Spec?
 
 The diff under review is `baseRef..headRef`
 (`main..story-<storyId>`, or the configured base branch to the Story
-branch). The Story-scope local-lens pass (Step 1a) has already covered the
-local-tier concerns. Lens findings and pillar findings share the single
-`verification-results` comment this pass posts. The
+branch). The write-time lens checklists have already covered the local-tier
+concerns. Pillar findings land in the single `verification-results` comment
+this pass posts. The
 integration view here focuses on cross-cutting ripple within the Story and
 contract drift against the base branch. Look for:
 
@@ -260,7 +237,7 @@ prior baseline before merging.
 
 Findings are **persisted as a `verification-results` structured comment on
 the `[TICKET_ID]` issue** by `runCodeReview` (the unified findings contract —
-this single comment carries the Story-scope lens findings). The target
+this single comment carries the Story-scope review findings). The target
 ticket is the Story. The comment
 is idempotent — re-runs replace the prior one — and its body includes
 severity-tier counts plus the full findings list so downstream workflows

package/.agents/workflows/helpers/deliver-reference.md

@@ -175,7 +175,7 @@ into batches of `cap` and dispatch each batch in its own turn.
 exposes agent dispatch, spawn each ready Story as its own
 `subagent_type: story-worker` sub-agent — it boots on the role-scoped
 [`story-worker`](../../agents/story-worker.md) context (its own system prompt, no
-`CLAUDE.md` @-closure) carrying the load-bearing delivery MUSTs standalone. The
+entry-doc @-closure) carrying the load-bearing delivery MUSTs standalone. The
 sub-agent executes [`deliver-story.md`](deliver-story.md) Steps 0–2.5
 (init → implement → acceptance self-eval → **push**) and stops there; **you**
 own Step 3, serialized — see `/mandrel-deliver` § Closing what the workers hand back.
@@ -291,7 +291,9 @@ confirm instead (`captureStoryFollowUps`).
   reopen the issue.
 - The parent lookup resolves the native parent edge in **one** call
   (`getParentIssue`), falling back to a `type::epic` scan for a child linked by
-  checklist alone. Children are the body checklist **union** the native
+  checklist alone. An authoritative "no parent" narrows that scan to Epics
+  whose body checklist names the Story (no per-Epic native read); only a
+  degraded lookup reads every scanned Epic's native children. Children are the body checklist **union** the native
   sub-issue edges — the same reader `/mandrel-deliver`'s expansion uses.
 - A checklist row citing an id that resolves to nothing is **dropped with a
   warning** when the native read succeeded; an unresolvable *native* edge

package/.agents/workflows/helpers/deliver-story.md

@@ -72,6 +72,9 @@ One branch, one PR to `main`, commits against the inline `acceptance[]` /
 1. Read the Story body; its acceptance criteria are the contract. Docs are
    digest-first; read a caller-provided `checklistPath` first, and walk any
    `## Slicing` rows as **intra-session checkpoints** (reference § Step 1).
+   After a context summary, re-derive progress from `git log` on
+   `story-<id>` against the `## Slicing` rows (each checkpoint is a commit
+   boundary) before continuing.
 2. Implement and commit on the Story branch, iterating with quick advisory
    gates (`typecheck`, `lint`, scoped tests) — the full chain runs in Step 3,
    and the **one** full-suite run at Step 2.5.