mandrel 1.68.0 → 1.70.0

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/signals.js

@@ -67,10 +67,9 @@ export const PHASE_ORDER = [
 ];
 
 /**
- * Emoji prefix per high-level state. Shared between the per-poll table
- * (`composition.renderProgressTable`) and the rolled-up Epic table
- * (`composition.upsertEpicRunProgress`) so operators see the same icon
- * in both surfaces.
+ * Emoji prefix per high-level state. Consumed by the rolled-up Epic table
+ * (`composition.upsertEpicRunProgress`) so operators see a consistent icon
+ * per state across the progress surface.
  */
 export const STATE_EMOJI = {
   done: '✅',

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/transport.js

@@ -38,10 +38,10 @@ export const EPIC_PROGRESS_EVENT = 'epic-progress';
 
 /**
  * Fire a curated `epic-progress` webhook event. Event-driven only — called
- * at wave boundaries and after blocker raise/clear transitions. Carries
- * the rollup payload `{ pct, done, total, currentWave, totalWaves, phase,
- * openBlockers }`, which Slack consumers and downstream subscribers use to
- * track epic progress without subscribing to per-story chatter.
+ * per recorder beat and after blocker raise/clear transitions. Carries the
+ * rollup payload `{ pct, done, total, phase, openBlockers }`, which Slack
+ * consumers and downstream subscribers use to track epic progress without
+ * subscribing to per-story chatter.
  *
  * The dispatch passes `skipComment: true` — the operator-facing GitHub
  * comment is owned by `ProgressReporter.fire()` and `upsertEpicRunProgress`,
@@ -50,13 +50,17 @@ export const EPIC_PROGRESS_EVENT = 'epic-progress';
  * Failures are swallowed by design: the runner must keep moving even if
  * the webhook URL is misconfigured or the network is flaky.
  *
+ * Story #4155 — the Epic `/deliver` runtime cut over to the continuous
+ * ready-set scheduler, which has **no wave index**. The wave segment was
+ * dropped from the message and the rollup payload entirely (rather than
+ * rendered as `Wave undefined/undefined`); the sole live caller
+ * (`wave-record-notifications.js`) never supplied wave coordinates.
+ *
  * @param {{
  *   notify: Function|null,
  *   epicId: number,
  *   done: number,
  *   total: number,
- *   currentWave: number,
- *   totalWaves: number,
  *   phase?: string,
  *   openBlockers?: Array<{ reason: string, storyId?: number }>,
  *   logger?: { warn?: Function },
@@ -68,8 +72,6 @@ export async function emitEpicProgress({
   epicId,
   done,
   total,
-  currentWave,
-  totalWaves,
   phase,
   openBlockers = [],
   logger,
@@ -85,7 +87,7 @@ export async function emitEpicProgress({
     blockerCount > 0
       ? ` · 🚧 ${blockerCount} blocker${blockerCount === 1 ? '' : 's'}`
       : '';
-  const message = `Epic #${epicIdNum} progress · Wave ${currentWave}/${totalWaves} · ${doneN}/${totalN} stories done (${pct}%)${blockerSuffix}`;
+  const message = `Epic #${epicIdNum} progress · ${doneN}/${totalN} stories done (${pct}%)${blockerSuffix}`;
 
   const payload = {
     severity: blockerCount > 0 ? 'high' : 'medium',
@@ -109,8 +111,6 @@ export async function emitEpicProgress({
       pct,
       done: doneN,
       total: totalN,
-      currentWave,
-      totalWaves,
       phase,
       openBlockers: openBlockers ?? [],
     },
@@ -121,11 +121,14 @@ export async function emitEpicProgress({
  * Fire a curated `epic-started` webhook event at /deliver kickoff.
  * The Slack consumer anchors the rest of the epic narrative to this fire.
  * Failures are swallowed.
+ *
+ * Story #4155 — the ready-set runtime has no wave count, so the wave
+ * segment was dropped from the message (rather than rendered as
+ * `undefined wave(s)`); the sole live caller never supplied one.
  */
 export async function emitEpicStarted({
   notify,
   epicId,
-  totalWaves,
   totalStories,
   title,
   logger,
@@ -133,7 +136,7 @@ export async function emitEpicStarted({
   if (typeof notify !== 'function') return null;
   const epicIdNum = Number(epicId);
   if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) return null;
-  const message = `Epic #${epicIdNum} started · ${totalWaves} wave${totalWaves === 1 ? '' : 's'} · ${totalStories} stor${totalStories === 1 ? 'y' : 'ies'}${title ? ` — ${title}` : ''}`;
+  const message = `Epic #${epicIdNum} started · ${totalStories} stor${totalStories === 1 ? 'y' : 'ies'}${title ? ` — ${title}` : ''}`;
   try {
     await notify(
       epicIdNum,

package/.agents/scripts/lib/orchestration/epic-runner/sub-agent-return.js

@@ -241,26 +241,29 @@ export async function reconcileStoryFromGitHub({ provider, storyId } = {}) {
 
 /**
  * Render a single friction-comment body listing every malformed sub-agent
- * return for a given wave. Pure helper — no provider call. Exposed so tests
- * can pin the body shape.
+ * return for a recorder beat. Pure helper — no provider call. Exposed so
+ * tests can pin the body shape.
+ *
+ * Story #4155 — under the ready-set runtime there is no wave index; the
+ * recorder records the Stories it was handed, so the body is keyed by Epic
+ * only.
  *
  * @param {{
  *   epicId: number,
- *   wave: number,
  *   failures: Array<{ storyId: number, error: string, returnText: string }>,
  * }} args
  * @returns {string}
  */
-export function renderMalformedReturnsFriction({ epicId, wave, failures }) {
+export function renderMalformedReturnsFriction({ epicId, failures }) {
   const lines = [
-    `### 🚧 epic-execute friction — Epic #${epicId}, wave ${wave}`,
+    `### 🚧 epic-execute friction — Epic #${epicId}`,
     '',
     `**Reason:** \`malformed-subagent-return\``,
     '',
     `${failures.length} sub-agent return(s) did not match the /deliver return contract.`,
     'Each Story below was reconciled from GitHub (labels + `story-run-progress`)',
-    'and its wave-row downgraded to `failed` unless the live ticket already carried',
-    '`agent::done`.',
+    'and its recorded status downgraded to `failed` unless the live ticket',
+    'already carried `agent::done`.',
     '',
   ];
   for (const f of failures) {

package/.agents/scripts/lib/orchestration/lifecycle/listeners/automerge-predicate.js

@@ -21,7 +21,7 @@
  *     is a hard block evaluated BEFORE the structured-signal evaluator.
  *
  * Either trigger evaluates the same verdict: if `evaluateAutoMergePredicate`
- * reports `clean: true` (no manual interventions, no incomplete waves,
+ * reports `clean: true` (no manual interventions, every Story done,
  * no story blockers, no critical/high review findings, machine-readable
  * "clean sprint" retro trailer), emit `epic.merge.ready`. Otherwise emit
  * `epic.merge.blocked` with a non-empty reason.
@@ -172,38 +172,51 @@ function evaluateStateSignals(state, reasons) {
         .join('; ')}${interventionCount > 3 ? '; …' : ''}`,
     );
   }
-  const waves = Array.isArray(state?.waves) ? state.waves : [];
-  const waveStatuses = waves.map((w) => w.status ?? 'unknown');
-  const nonCompleteWaves = waveStatuses.filter((s) => s !== 'complete');
-  if (nonCompleteWaves.length > 0) {
+  // Story #4155 — the ready-set runtime records a flat per-Story status map
+  // on the checkpoint (`stories: { [id]: { status, blockerCommentId? } }`)
+  // instead of a per-wave `waves[]` history. The clean-run certification
+  // reads it directly: a run is clean only when every Story reached `done`
+  // and none carries a recorded blocker comment.
+  const stories =
+    state?.stories && typeof state.stories === 'object' ? state.stories : {};
+  const storyStatuses = Object.values(stories).map(
+    (s) => s?.status ?? 'pending',
+  );
+  const nonDoneStatuses = storyStatuses.filter((s) => s !== 'done');
+  if (nonDoneStatuses.length > 0) {
     reasons.push(
-      `${nonCompleteWaves.length} wave(s) not complete (statuses: ${nonCompleteWaves.join(', ')})`,
+      `${nonDoneStatuses.length} story(ies) not done (statuses: ${nonDoneStatuses.join(', ')})`,
     );
   }
-  const storyBlockers = countStoryBlockers(waves);
+  const storyBlockers = countStoryBlockers(stories);
   if (storyBlockers > 0) {
     reasons.push(
       `${storyBlockers} story-level blocker(s) recorded in run-state`,
     );
   }
-  return { interventionCount, waveStatuses, storyBlockers };
+  return { interventionCount, storyStatuses, storyBlockers };
 }
 
-function countStoryBlockers(waves) {
+/**
+ * Count blockers in the flat per-Story `stories` status map: each Story with
+ * a recorded `blockerCommentId` and each Story whose status is not `done`
+ * contributes one blocker (matching the prior per-wave count semantics).
+ *
+ * @param {Record<string, { status?: string, blockerCommentId?: string }>} stories
+ * @returns {number}
+ */
+function countStoryBlockers(stories) {
   let blockers = 0;
-  for (const w of waves) {
-    if (!Array.isArray(w.stories)) continue;
-    for (const s of w.stories) {
-      if (
-        s &&
-        typeof s.blockerCommentId === 'string' &&
-        s.blockerCommentId.length > 0
-      ) {
-        blockers += 1;
-      }
-      if (s?.status && s.status !== 'done') {
-        blockers += 1;
-      }
+  for (const s of Object.values(stories ?? {})) {
+    if (
+      s &&
+      typeof s.blockerCommentId === 'string' &&
+      s.blockerCommentId.length > 0
+    ) {
+      blockers += 1;
+    }
+    if (s?.status && s.status !== 'done') {
+      blockers += 1;
     }
   }
   return blockers;
@@ -271,7 +284,7 @@ function evaluateRetroSignals(retro, reasons) {
  *   reasons: string[],
  *   signals: {
  *     manualInterventions: number,
- *     waveStatuses: string[],
+ *     storyStatuses: string[],
  *     storyBlockers: number,
  *     severity: { critical: number|null, high: number|null, medium: number|null, suggestion: number|null },
  *     retroCompact: boolean,
@@ -292,7 +305,7 @@ export function deriveAutoMergeVerdict({ state, codeReview, retro }) {
     reasons,
     signals: {
       manualInterventions: stateSig.interventionCount,
-      waveStatuses: stateSig.waveStatuses,
+      storyStatuses: stateSig.storyStatuses,
       storyBlockers: stateSig.storyBlockers,
       severity: reviewSig.severity,
       retroCompact: retroSig.retroCompact,

package/.agents/scripts/lib/orchestration/lifecycle/trace-logger.js

@@ -353,7 +353,3 @@ export class TraceLogger {
     });
   }
 }
-
-export function createTraceLogger(opts) {
-  return new TraceLogger(opts);
-}

package/.agents/scripts/lib/orchestration/manifest-builder.js

@@ -139,6 +139,12 @@ function buildStoryOnlyManifest(stories, epicId) {
       type: 'story',
       branchName: getStoryBranch(epicId, story.id),
       earliestWave,
+      // Carry the resolved cross-Story dependency edges on the entry so the
+      // presentation layer can derive grouping depth at render time via
+      // `assignLayers` (Story #4157) instead of trusting the persisted
+      // `earliestWave`. This is the same `explicitStoryDeps` set the wave
+      // computation consumed, already closed over the scheduled Story set.
+      dependsOn: explicitStoryDeps.get(story.id) ?? [],
       tasks: [],
     };
   });

package/.agents/scripts/lib/orchestration/retro/phases/compose-body.js

@@ -415,6 +415,94 @@ function shellEscape(s) {
   return `'${str.replace(/'/g, `'\\''`)}'`;
 }
 
+/**
+ * Render the body lines (everything below a section heading and its trailing
+ * blank) for a "proposed issues" bucket — the consumer and framework sections
+ * share this shape. Empty buckets collapse to a single `_None._`; populated
+ * buckets emit one fenced `gh issue create` stanza per item.
+ *
+ * @param {object[]} items
+ * @returns {string[]}
+ */
+function renderIssueBucket(items) {
+  if (items.length === 0) return ['_None._'];
+  const lines = [];
+  for (const item of items) {
+    lines.push(`- **${item.title ?? item.category}**`);
+    lines.push('');
+    lines.push('```sh');
+    lines.push(String(item.command ?? ''));
+    lines.push('```');
+    lines.push('');
+  }
+  return lines;
+}
+
+/**
+ * Render the body lines for the "proposed memory updates" bucket — a plain
+ * instruction prelude followed by one bullet per insight, or `_None._` when
+ * empty. Deliberately NOT YAML frontmatter (asserted by the routed-sections
+ * contract test).
+ *
+ * @param {object[]} items
+ * @returns {string[]}
+ */
+function renderMemoryBucket(items) {
+  if (items.length === 0) return ['_None._'];
+  return [
+    'update your memory with the following insights:',
+    '',
+    ...items.map((m) => `- ${m.insight}`),
+  ];
+}
+
+/**
+ * Render the body lines for the "one-off / discarded" bucket — one bullet per
+ * discarded class naming its occurrence count and source, or `_None._`.
+ *
+ * @param {object[]} items
+ * @returns {string[]}
+ */
+function renderDiscardedBucket(items) {
+  if (items.length === 0) return ['_None._'];
+  return items.map(
+    (d) =>
+      `- \`${d.category}\` (${d.occurrences ?? 1} occurrence, source: ${d.source ?? 'consumer'})`,
+  );
+}
+
+/**
+ * Descriptor table for the four routed-proposal sections, in deterministic
+ * emit order (consumer → framework → memory → discarded). Each descriptor
+ * pairs a heading, the `routedProposals` field it reads, and a body renderer.
+ * {@link renderRoutedSections} walks the table once, so reordering or adding a
+ * section is a data edit here rather than another copy-pasted emit block.
+ *
+ * @type {Array<{ heading: string, field: string, renderBucket: (items: object[]) => string[] }>}
+ */
+const ROUTED_SECTIONS = [
+  {
+    heading: '### Proposed issues — consumer repo',
+    field: 'consumer',
+    renderBucket: renderIssueBucket,
+  },
+  {
+    heading: '### Proposed issues — framework repo',
+    field: 'framework',
+    renderBucket: renderIssueBucket,
+  },
+  {
+    heading: '### Proposed memory updates',
+    field: 'memory',
+    renderBucket: renderMemoryBucket,
+  },
+  {
+    heading: '### One-off / discarded',
+    field: 'discarded',
+    renderBucket: renderDiscardedBucket,
+  },
+];
+
 /**
  * Pure: render the four routed-proposal sections in deterministic order.
  * Returns `null` when `routedProposals` is absent or fully empty — the
@@ -432,80 +520,23 @@ function renderRoutedSections(routedProposals) {
   ) {
     return null;
   }
-  const framework = Array.isArray(routedProposals.framework)
-    ? routedProposals.framework
-    : [];
-  const consumer = Array.isArray(routedProposals.consumer)
-    ? routedProposals.consumer
-    : [];
-  const memory = Array.isArray(routedProposals.memory)
-    ? routedProposals.memory
-    : [];
-  const discarded = Array.isArray(routedProposals.discarded)
-    ? routedProposals.discarded
-    : [];
-  if (
-    framework.length === 0 &&
-    consumer.length === 0 &&
-    memory.length === 0 &&
-    discarded.length === 0
-  ) {
+  const buckets = ROUTED_SECTIONS.map((section) => {
+    const items = Array.isArray(routedProposals[section.field])
+      ? routedProposals[section.field]
+      : [];
+    return { section, items };
+  });
+  if (buckets.every(({ items }) => items.length === 0)) {
     return null;
   }
 
+  // Each section renders as `[heading, '', ...body]`; a single blank-line
+  // separator sits between consecutive sections (no trailing separator after
+  // the last), reproducing the original hand-unrolled push sequence exactly.
   const out = [];
-  out.push('### Proposed issues — consumer repo');
-  out.push('');
-  if (consumer.length === 0) {
-    out.push('_None._');
-  } else {
-    for (const item of consumer) {
-      out.push(`- **${item.title ?? item.category}**`);
-      out.push('');
-      out.push('```sh');
-      out.push(String(item.command ?? ''));
-      out.push('```');
-      out.push('');
-    }
-  }
-  out.push('');
-  out.push('### Proposed issues — framework repo');
-  out.push('');
-  if (framework.length === 0) {
-    out.push('_None._');
-  } else {
-    for (const item of framework) {
-      out.push(`- **${item.title ?? item.category}**`);
-      out.push('');
-      out.push('```sh');
-      out.push(String(item.command ?? ''));
-      out.push('```');
-      out.push('');
-    }
-  }
-  out.push('');
-  out.push('### Proposed memory updates');
-  out.push('');
-  if (memory.length === 0) {
-    out.push('_None._');
-  } else {
-    out.push('update your memory with the following insights:');
-    out.push('');
-    for (const m of memory) {
-      out.push(`- ${m.insight}`);
-    }
-  }
-  out.push('');
-  out.push('### One-off / discarded');
-  out.push('');
-  if (discarded.length === 0) {
-    out.push('_None._');
-  } else {
-    for (const d of discarded) {
-      out.push(
-        `- \`${d.category}\` (${d.occurrences ?? 1} occurrence, source: ${d.source ?? 'consumer'})`,
-      );
-    }
+  for (const { section, items } of buckets) {
+    if (out.length > 0) out.push('');
+    out.push(section.heading, '', ...section.renderBucket(items));
   }
   return out;
 }

package/.agents/scripts/lib/orchestration/spec-renderer.js

@@ -157,6 +157,45 @@ function sanitizeLabels(labels) {
   return out.length > 0 ? out : undefined;
 }
 
+/**
+ * Descriptor table for the structured-body → markdown projection, in
+ * canonical emit order (`## Goal`, `## Changes`, `## Acceptance`,
+ * `## Verify`). Each descriptor reads one body field and returns the
+ * section's markdown block when the field is present and non-empty, or `null`
+ * to omit it. Adding a section is a one-line data edit rather than a new
+ * branch in {@link renderBody}.
+ *
+ * @type {Array<{ field: string, render: (value: unknown) => string | null }>}
+ */
+const SPEC_BODY_SECTIONS = [
+  {
+    field: 'goal',
+    render: (goal) =>
+      typeof goal === 'string' && goal.length > 0 ? `## Goal\n${goal}` : null,
+  },
+  {
+    field: 'changes',
+    render: (changes) =>
+      Array.isArray(changes) && changes.length > 0
+        ? `## Changes\n${changes.map((c) => `- ${String(c)}`).join('\n')}`
+        : null,
+  },
+  {
+    field: 'acceptance',
+    render: (acceptance) =>
+      Array.isArray(acceptance) && acceptance.length > 0
+        ? `## Acceptance\n${acceptance.map((a) => `- [ ] ${String(a)}`).join('\n')}`
+        : null,
+  },
+  {
+    field: 'verify',
+    render: (verify) =>
+      Array.isArray(verify) && verify.length > 0
+        ? `## Verify\n${verify.map((v) => `- ${String(v)}`).join('\n')}`
+        : null,
+  },
+];
+
 /**
  * Convert a decomposer body value into a spec `body` string. The
  * decomposer schema admits two shapes for a Story body:
@@ -190,20 +229,9 @@ function renderBody(body) {
   if (typeof body !== 'object') return undefined;
 
   const sections = [];
-  if (typeof body.goal === 'string' && body.goal.length > 0) {
-    sections.push(`## Goal\n${body.goal}`);
-  }
-  if (Array.isArray(body.changes) && body.changes.length > 0) {
-    const items = body.changes.map((c) => `- ${String(c)}`).join('\n');
-    sections.push(`## Changes\n${items}`);
-  }
-  if (Array.isArray(body.acceptance) && body.acceptance.length > 0) {
-    const items = body.acceptance.map((a) => `- [ ] ${String(a)}`).join('\n');
-    sections.push(`## Acceptance\n${items}`);
-  }
-  if (Array.isArray(body.verify) && body.verify.length > 0) {
-    const items = body.verify.map((v) => `- ${String(v)}`).join('\n');
-    sections.push(`## Verify\n${items}`);
+  for (const descriptor of SPEC_BODY_SECTIONS) {
+    const block = descriptor.render(body[descriptor.field]);
+    if (block !== null) sections.push(block);
   }
   return sections.length > 0 ? sections.join('\n\n') : undefined;
 }

package/.agents/scripts/lib/orchestration/ticket-lease.js

@@ -56,6 +56,9 @@ import { parseLedger } from './lifecycle/trace-logger.js';
  * coordinated under a shared identity) and no assignee PATCH ever writes a
  * literal `[USERNAME]` (HTTP 422).
  */
+// kept (dead-export allowlist): public config sentinel — the distributed
+// `.agentrc.json` / templates carry this literal; exported so consumers and
+// future call sites resolve it by symbol rather than re-typing the string.
 export const OPERATOR_HANDLE_PLACEHOLDER = '@[USERNAME]';
 const OPERATOR_HANDLE_PLACEHOLDER_BARE = '[USERNAME]';
 

package/.agents/scripts/lib/orchestration/ticket-validator-sizing.js

@@ -18,7 +18,7 @@
  *
  * Sizing model (Story #3760 — profile-matrix collapse; Story #3874 — one
  * uniform relaxed profile):
- *   - Flat knobs: `softFiles` (~8), `hardFiles` (~30), `maxAcceptance` (~14),
+ *   - Flat knobs: `softFiles` (~15), `hardFiles` (~30), `maxAcceptance` (~14),
  *     `softAcceptanceCount` (~10). No per-profile ceiling map, no parallel
  *     `testSurface` axis, no selector and no second profile.
  *   - The four-profile `sizingProfile` enum is replaced by a single optional
@@ -32,7 +32,11 @@
 
 export const DEFAULT_TASK_SIZING = Object.freeze({
   // Typical-Story warning thresholds (soft — emit advisory findings).
-  softFiles: 8,
+  // Story #4162 raised `softFiles` 8 → 15: a capability-sized Story routinely
+  // touches a dozen-plus files for one cohesive reason, so the advisory width
+  // nudge fired far too eagerly and biased the decomposer toward over-slicing.
+  // The hard `hardFiles` rejection (30) is unchanged.
+  softFiles: 15,
   softAcceptanceCount: 10,
   // Hard ceilings (rejection unless lifted).
   hardFiles: 30,