mandrel 1.68.0 → 1.70.0

package/.agents/scripts/bootstrap.js

@@ -534,6 +534,13 @@ export function buildQuestions(defaults, flags, env = process.env, lists = {}) {
   const reposList = lists.reposList;
   const projectsList = lists.projectsList;
   const pickerOwner = (answers) => answers?.owner || owner;
+  // `owner` / `repo` are GitHub-side answers. When `--skip-github` suppresses
+  // the entire GitHub bootstrap, they are not required — this lets a
+  // non-interactive `--assume-yes --skip-github` run materialize and configure
+  // a fresh non-git directory (no inferable remote) without hard-failing on
+  // `missing required answers: owner, repo`. With GitHub bootstrap active they
+  // remain required (the target repo must be resolvable).
+  const skipGithub = Boolean(flags?.['skip-github']);
   return [
     {
       key: 'owner',
@@ -541,7 +548,7 @@ export function buildQuestions(defaults, flags, env = process.env, lists = {}) {
       env: 'GH_OWNER',
       message: '\n\nGitHub repo owner',
       default: defaults.owner,
-      required: true,
+      required: !skipGithub,
       validate: (v) =>
         /^[A-Za-z0-9][A-Za-z0-9-]*$/.test(v) ? null : 'Invalid GitHub owner',
     },
@@ -567,7 +574,7 @@ export function buildQuestions(defaults, flags, env = process.env, lists = {}) {
       pickerMessage:
         'GitHub repo name  - Select existing or press ENTER to create',
       default: defaults.repo,
-      required: true,
+      required: !skipGithub,
       picker: {
         list: (answers) => {
           if (Array.isArray(reposList) && reposList.length > 0)
@@ -957,7 +964,10 @@ export async function collectAndConfirm(state) {
     });
     if (missing.length > 0) {
       Logger.error(
-        `[Bootstrap] missing required answers: ${missing.join(', ')}`,
+        `[Bootstrap] missing required answers: ${missing.join(', ')}. ` +
+          'Pass them as flags (e.g. `--owner <name> --repo <name>`), or run ' +
+          'with `--skip-github` to configure the files/local setup only and ' +
+          'wire GitHub later.',
       );
       return { ok: false, exit: 1 };
     }

package/.agents/scripts/epic-deliver-preflight.js

@@ -8,7 +8,7 @@
  * fan-out and surfaces the result to the operator on two channels:
  *
  *   1. A JSON envelope on stdout (always) with the keys
- *      `storyCount`, `installCostSeconds`, `waveCount`,
+ *      `storyCount`, `installCostSeconds`, `dependencyDepth`,
  *      `githubApiRequests`, `claudeQuotaTokens`, plus `breaches`
  *      (the non-empty subset of `delivery.preflight.max*` thresholds the
  *      estimate exceeds).
@@ -30,8 +30,14 @@
  * the comment can reason about the numbers):
  *
  *   - `storyCount`           = number of child `type::story` tickets.
- *   - `waveCount`            = computed wave DAG length (matches the
- *                              dispatch manifest).
+ *   - `dependencyDepth`      = longest dependency chain through the Story
+ *                              DAG (Story #4155). The ready-set runtime has
+ *                              no wave barrier, so wall-clock is bounded
+ *                              below by this depth, not by a wave count: a
+ *                              depth-1 Epic (all Stories independent) can run
+ *                              fully parallel, while a depth-N chain forces N
+ *                              sequential beats regardless of cap. Computed
+ *                              as the dependency-DAG layer count.
  *   - `installCostSeconds`   = `storyCount * perStoryInstallSeconds`
  *                              (default 45s, override via
  *                              `--per-story-install-seconds`). Models a
@@ -115,7 +121,7 @@ const DEFAULTS = Object.freeze({
  *
  * @param {{
  *   storyCount: number,
- *   waveCount: number,
+ *   dependencyDepth: number,
  *   perStoryInstallSeconds?: number,
  *   perStoryApiRequests?: number,
  *   perStoryClaudeTokens?: number,
@@ -124,14 +130,14 @@ const DEFAULTS = Object.freeze({
  * @returns {{
  *   storyCount: number,
  *   installCostSeconds: number,
- *   waveCount: number,
+ *   dependencyDepth: number,
  *   githubApiRequests: number,
  *   claudeQuotaTokens: number,
  * }}
  */
 export function computeEstimate({
   storyCount,
-  waveCount,
+  dependencyDepth,
   perStoryInstallSeconds = DEFAULTS.perStoryInstallSeconds,
   perStoryApiRequests = DEFAULTS.perStoryApiRequests,
   perStoryClaudeTokens = DEFAULTS.perStoryClaudeTokens,
@@ -142,15 +148,15 @@ export function computeEstimate({
       'computeEstimate: storyCount must be a non-negative integer',
     );
   }
-  if (!Number.isInteger(waveCount) || waveCount < 0) {
+  if (!Number.isInteger(dependencyDepth) || dependencyDepth < 0) {
     throw new TypeError(
-      'computeEstimate: waveCount must be a non-negative integer',
+      'computeEstimate: dependencyDepth must be a non-negative integer',
     );
   }
   return {
     storyCount,
     installCostSeconds: storyCount * perStoryInstallSeconds,
-    waveCount,
+    dependencyDepth,
     githubApiRequests: baseApiRequests + storyCount * perStoryApiRequests,
     claudeQuotaTokens: storyCount * perStoryClaudeTokens,
   };
@@ -167,7 +173,14 @@ export function computeEstimate({
 export function detectBreaches(estimate, thresholds) {
   const mapping = [
     { key: 'storyCount', observedKey: 'storyCount', maxKey: 'maxStories' },
-    { key: 'waveCount', observedKey: 'waveCount', maxKey: 'maxWaves' },
+    // Story #4155 — `dependencyDepth` replaces the retired `waveCount`
+    // estimate; it is still gated by the `maxWaves` config threshold (the
+    // published config key is left unchanged for contract stability).
+    {
+      key: 'dependencyDepth',
+      observedKey: 'dependencyDepth',
+      maxKey: 'maxWaves',
+    },
     {
       key: 'installCostSeconds',
       observedKey: 'installCostSeconds',
@@ -213,7 +226,7 @@ export function renderPreflightBody({
   lines.push('| --- | ---: | ---: |');
   const rows = [
     ['storyCount', estimate.storyCount, thresholds.maxStories],
-    ['waveCount', estimate.waveCount, thresholds.maxWaves],
+    ['dependencyDepth', estimate.dependencyDepth, thresholds.maxWaves],
     [
       'installCostSeconds',
       estimate.installCostSeconds,
@@ -292,7 +305,11 @@ export async function runPreflight({
   state = await runBuildWaveDagPhase(ctx, {}, state);
 
   const storyCount = Array.isArray(state.stories) ? state.stories.length : 0;
-  const waveCount = Array.isArray(state.waves) ? state.waves.length : 0;
+  // Dependency depth = the dependency-DAG layer count (the longest chain of
+  // `blocked by` edges). `runBuildWaveDagPhase` already computes this layering
+  // as `state.waves`, so its length is the depth even though the ready-set
+  // runtime no longer dispatches by wave (Story #4155).
+  const dependencyDepth = Array.isArray(state.waves) ? state.waves.length : 0;
 
   // Persist the snapshot/DAG envelope so `epic-deliver-prepare.js` can
   // reuse it instead of re-walking the hierarchy. The cache key is a
@@ -317,7 +334,7 @@ export async function runPreflight({
 
   const estimate = computeEstimate({
     storyCount,
-    waveCount,
+    dependencyDepth,
     perStoryInstallSeconds,
     perStoryApiRequests,
     perStoryClaudeTokens,

package/.agents/scripts/epic-deliver-prepare.js

@@ -5,17 +5,25 @@
  * epic-deliver-prepare.js — Step 0/1 of the operator-driven `/deliver`.
  *
  * Composes the existing engine phases that the in-process epic-runner used to
- * call sequentially, but does NOT dispatch any waves. The CLI is the single
+ * call sequentially, but does NOT dispatch any Stories. The CLI is the single
  * point at which the slash-command captures:
  *
  *   1. The Epic ticket snapshot (`runSnapshotPhase`).
- *   2. The wave DAG (`runBuildWaveDagPhase`) computed from every child Story.
+ *   2. The story DAG (`runBuildWaveDagPhase`) computed from every child Story —
+ *      used here only to enumerate the open Story set and run the
+ *      concurrency-hazard gate; the ready-set runtime re-derives readiness
+ *      from live labels on every `tick`, so the prepare no longer persists a
+ *      wave grouping.
  *   3. The seeded `epic-run-state` checkpoint (`epic-run-state-store.initialize`)
- *      — idempotent, so re-running prepare against a partially-driven Epic
- *      preserves the original `startedAt`.
- *   4. The per-wave dispatch plan (`StoryLauncher.planWave`) — a deterministic
- *      list of `{ storyId, worktree }` entries that the slash command feeds
- *      into N parallel `Agent` tool calls per wave.
+ *      in the per-Story-status shape (Story #4155): a flat
+ *      `stories: { [storyId]: { status: 'pending' } }` map plus the GLOBAL
+ *      in-flight `concurrencyCap`. Idempotent — re-running prepare against a
+ *      partially-driven Epic preserves the original `startedAt` and every
+ *      already-recorded Story status (it never resets recorded progress).
+ *   4. The dispatch hint (`StoryLauncher.planWave`) — a deterministic list of
+ *      `{ storyId, worktree }` entries the slash command uses to resolve
+ *      per-Story worktree paths. The ready-set `tick` selects which of these
+ *      to dispatch on each beat; the prepare only enumerates the set.
  *
  * Stdout is a single JSON envelope so the slash command can parse without
  * re-reading any tickets.
@@ -37,7 +45,6 @@ import {
 } from './lib/orchestration/epic-deliver-lease-guard.js';
 import {
   initialize as initializeEpicRunState,
-  reconcileResumePointer,
   write as writeEpicRunState,
 } from './lib/orchestration/epic-run-state-store.js';
 import {
@@ -133,9 +140,9 @@ function resolveGitUserEmail(cwd) {
  * }} args
  * @returns {Promise<{
  *   epicId: number,
- *   totalWaves: number,
+ *   storyCount: number,
  *   concurrencyCap: number,
- *   plan: Array<{ wave: number, stories: Array<{ storyId: number, title: string, worktree?: string }> }>,
+ *   stories: Array<{ storyId: number, title: string, worktree?: string }>,
  *   checkpointInitializedAt: string,
  * }>}
  */
@@ -334,64 +341,44 @@ export async function runEpicDeliverPrepare({
     ignoreConcurrencyHazards,
   });
 
-  const totalWaves = state.waves.length;
+  // Flatten the wave-DAG into the open Story set. The ready-set runtime
+  // re-derives readiness from live labels on every tick, so the checkpoint
+  // stores only the Story set in scope (seeded at `pending`) and the global
+  // in-flight cap — no wave grouping, no `currentWave`, no `totalWaves`.
+  const openStories = state.waves.flat();
   const checkpointState = await initializeEpicRunState({
     provider,
     epicId,
-    totalWaves,
+    storyIds: openStories,
     concurrencyCap,
   });
 
+  // Resolve per-Story worktree paths via the launcher so the slash command
+  // has a deterministic `{ storyId, worktree, title }` list to seed Agent
+  // dispatch from. This is a dispatch *hint* — the ready-set tick decides
+  // which Stories to dispatch on each beat; the prepare only enumerates them.
   const launcher = new StoryLauncher({ concurrencyCap });
-  const plan = state.waves.map((stories, index) => ({
-    wave: index,
-    stories: launcher.planWave(stories).map((entry, i) => ({
-      ...entry,
-      title: stories[i]?.title ?? '',
-    })),
+  const stories = launcher.planWave(openStories).map((entry, i) => ({
+    ...entry,
+    title: openStories[i]?.title ?? '',
   }));
 
-  // Persist the plan onto the checkpoint so `wave-tick.js` (which reads
-  // state.plan as `Array<Array<{ id|storyId, title?, worktree? }>>`) can
-  // resolve the next wave's stories. Without this write the tick reports
-  // every wave as `wave-complete: empty` and the delivery stalls.
-  const tickPlan = plan.map((wave) => wave.stories);
-
-  // Story #3358 — reconcile the resume pointer against the recomputed
-  // plan. On a resumed Epic, `build-wave-dag.js` drops the already-merged
-  // (closed) Stories, so the recomputed plan is shorter and re-indexed
-  // from 0. The preserved `currentWave`/`waves[]` reference the *old*
-  // index space; left untouched, `wave-tick.js` would index
-  // `plan[currentWave]` into the new plan and dispatch the wrong wave.
-  // Prepare owns the `plan` field, so it owns the pointer that indexes
-  // into it. When the plan changed, reset the pointer to 0 and drop the
-  // stale history; when it is byte-identical (idempotent re-prepare),
-  // preserve in-flight progress verbatim.
-  const { currentWave, waves } = reconcileResumePointer(
-    checkpointState,
-    checkpointState.plan,
-    tickPlan,
-  );
-
-  // Persist the `--ignore-concurrency-hazards` flag on the checkpoint
-  // so retro tooling can flag a run that shipped despite an outstanding
-  // hazard (the warning above is one-shot; the checkpoint is durable).
-  const checkpointPayload = {
-    ...checkpointState,
-    plan: tickPlan,
-    currentWave,
-    waves,
-  };
+  // Persist the `--ignore-concurrency-hazards` flag on the checkpoint so
+  // retro tooling can flag a run that shipped despite an outstanding hazard
+  // (the warning above is one-shot; the checkpoint is durable).
   if (gate.bypassed) {
-    checkpointPayload.ignoreConcurrencyHazards = true;
+    await writeEpicRunState({
+      provider,
+      epicId,
+      state: { ...checkpointState, ignoreConcurrencyHazards: true },
+    });
   }
-  await writeEpicRunState({ provider, epicId, state: checkpointPayload });
 
   return {
     epicId,
-    totalWaves,
+    storyCount: openStories.length,
     concurrencyCap,
-    plan,
+    stories,
     checkpointInitializedAt:
       checkpointState.startedAt ??
       checkpointState.lastUpdatedAt ??