@hecer/yoke 1.16.0 → 1.18.0

package/dist/estimation/schedule.js

@@ -1,55 +1,118 @@
 import { estimateDurations } from './durations.js';
 import { criticalPathRanks, writeScopesOverlap } from '../loop/scheduler.js';
-/** Simulate the same dependency/area constraints as the loop scheduler. */
-export function estimateSchedule(stories, maxConcurrency, history) {
+/** Simulate dependency-aware implementation slots and a separate serialized integration lane. */
+export function estimateSchedule(stories, maxConcurrency, history, stages = {}) {
     if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1)
         return { available: false, reason: 'Invalid concurrency' };
     if (new Set(stories.map(story => story.id)).size !== stories.length)
         return { available: false, reason: 'Duplicate story IDs' };
-    const estimate = estimateDurations(history.map(item => item.ms));
-    if (!estimate)
+    const totalEstimate = estimateDurations(history.map(item => item.ms));
+    if (!totalEstimate)
         return { available: false, reason: 'No measured duration history' };
+    const integrationEstimate = estimateDurations((stages.integrationMs ?? []).filter(validSample));
+    const queueEstimate = estimateDurations((stages.integrationQueueWaitMs ?? []).filter(validSample));
+    const integrations = integrationEstimate ?? { typicalMs: 0, lowerMs: 0, upperMs: 0, sampleCount: 0, confidence: 'low' };
+    const queueWait = queueEstimate ?? { typicalMs: 0, lowerMs: 0, upperMs: 0, sampleCount: 0, confidence: 'low' };
+    const globalLimit = Number.isInteger(stages.globalLimit) && stages.globalLimit >= 1 ? stages.globalLimit : maxConcurrency;
+    const workerUnitsPerStory = Number.isInteger(stages.workerUnitsPerStory) && stages.workerUnitsPerStory >= 1 ? stages.workerUnitsPerStory : 1;
+    if (workerUnitsPerStory > globalLimit)
+        return { available: false, reason: 'Worker weight exceeds the shared resource limit' };
     const ranks = criticalPathRanks(stories);
-    const durations = new Map(stories.filter(story => !story.passes).map(story => [story.id,
-        estimateDurations(history.filter(item => item.storyId === story.id).map(item => item.ms)) ?? estimate,
-    ]));
-    const simulate = (field) => {
-        const pending = stories.filter(story => !story.passes).sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0) || (ranks.get(b.id) ?? 0) - (ranks.get(a.id) ?? 0) || a.id.localeCompare(b.id));
+    const pending = stories.filter(story => !story.passes).sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0) || (ranks.get(b.id) ?? 0) - (ranks.get(a.id) ?? 0) || a.id.localeCompare(b.id));
+    const simulate = (implementationScale, integrationScale) => {
+        const pendingWork = [...pending];
+        const work = new Map(pending.map(story => {
+            const estimate = estimateDurations(history.filter(item => item.storyId === story.id).map(item => item.ms)) ?? totalEstimate;
+            const subtract = integrationEstimate ? integrations[integrationScale] + queueWait[integrationScale] : 0;
+            return [story.id, Math.max(0, estimate[implementationScale] - subtract)];
+        }));
+        const integrationDuration = integrations[integrationScale];
         const complete = new Set(stories.filter(story => story.passes).map(story => story.id));
         const active = [];
-        const tasks = [];
-        let time = 0;
-        while (pending.length || active.length) {
-            for (let index = 0; index < pending.length && active.length < maxConcurrency;) {
-                const story = pending[index];
-                if ((story.needs ?? []).every(id => complete.has(id)) && (!story.area || !active.some(item => item.story.area === story.area)) && !active.some(item => writeScopesOverlap(story.writes, item.story.writes))) {
-                    const end = time + durations.get(story.id)[field];
-                    active.push({ story, end });
-                    tasks.push({ storyId: story.id, startMs: time, endMs: end });
-                    pending.splice(index, 1);
+        const queued = [];
+        let integrating;
+        const taskTimes = new Map();
+        let time = 0, implementationWorkMs = 0, integrationQueueWaitMs = 0, integrationLaneMs = 0;
+        let completedEvents = 0;
+        while (pendingWork.length || active.length || queued.length || integrating) {
+            for (let index = 0; index < pendingWork.length && active.length < maxConcurrency && (active.length * workerUnitsPerStory) + (integrating ? 1 : 0) + workerUnitsPerStory <= globalLimit;) {
+                const story = pendingWork[index];
+                const occupied = [...active.map(item => item.story), ...queued.map(item => item.story), ...(integrating ? [integrating.story] : [])];
+                const dependenciesReady = (story.needs ?? []).every(id => complete.has(id));
+                const scopesFree = (!story.area || !occupied.some(item => item.area === story.area))
+                    && !occupied.some(item => writeScopesOverlap(story.writes, item.writes));
+                if (dependenciesReady && scopesFree) {
+                    const duration = work.get(story.id) ?? 0;
+                    active.push({ story, ends: time + duration });
+                    taskTimes.set(story.id, { storyId: story.id, startMs: time, endMs: 0 });
+                    implementationWorkMs += duration;
+                    pendingWork.splice(index, 1);
                 }
                 else
                     index++;
             }
-            if (!active.length)
+            if (!integrating && queued.length && active.length * workerUnitsPerStory + 1 <= globalLimit) {
+                const next = queued.shift();
+                integrationQueueWaitMs += Math.max(0, time - next.readyAt);
+                integrationLaneMs += integrationDuration;
+                integrating = { story: next.story, ends: time + integrationDuration };
+            }
+            const nextEnd = Math.min(...active.map(item => item.ends), ...(integrating ? [integrating.ends] : []));
+            if (!Number.isFinite(nextEnd))
                 return undefined;
-            time = Math.min(...active.map(item => item.end));
+            time = nextEnd;
+            const finishedIntegration = integrating && integrating.ends === time ? integrating : undefined;
+            if (finishedIntegration) {
+                complete.add(finishedIntegration.story.id);
+                const task = taskTimes.get(finishedIntegration.story.id);
+                if (task)
+                    task.endMs = time;
+                integrating = undefined;
+                completedEvents++;
+            }
+            const finishedWorkers = active.filter(item => item.ends === time).sort((a, b) => a.story.id.localeCompare(b.story.id));
+            for (const item of finishedWorkers)
+                queued.push({ story: item.story, readyAt: time });
             for (let index = active.length - 1; index >= 0; index--)
-                if (active[index].end === time) {
-                    complete.add(active[index].story.id);
+                if (active[index].ends === time)
                     active.splice(index, 1);
-                }
+            if (finishedWorkers.length || finishedIntegration)
+                continue;
+            if (!active.length && !queued.length && !integrating && pendingWork.length)
+                return undefined;
+            if (completedEvents > stories.length)
+                return undefined;
         }
-        return { time, tasks };
+        return {
+            time,
+            implementationWorkMs,
+            integrationQueueWaitMs,
+            integrationLaneMs,
+            tasks: [...taskTimes.values()],
+        };
     };
-    const typical = simulate('typicalMs'), lower = simulate('lowerMs'), upper = simulate('upperMs');
+    const typical = simulate('typicalMs', 'typicalMs');
+    const lower = simulate('lowerMs', 'lowerMs');
+    const upper = simulate('upperMs', 'upperMs');
     if (!typical || !lower || !upper)
         return { available: false, reason: 'Cyclic or missing dependencies' };
-    // Different durations can change a greedy schedule's ordering. Keep the
-    // empirical scenario envelope ordered; this is not a calibrated interval.
-    return { available: true, etaMs: typical.time,
-        lowerMs: Math.min(lower.time, typical.time, upper.time), upperMs: Math.max(lower.time, typical.time, upper.time),
-        sampleCount: estimate.sampleCount,
-        confidence: [...durations.values()].some(duration => duration.confidence === 'low') ? 'low' : estimate.confidence,
-        tasks: typical.tasks };
+    return {
+        available: true,
+        etaMs: typical.time,
+        lowerMs: Math.min(lower.time, typical.time, upper.time),
+        upperMs: Math.max(lower.time, typical.time, upper.time),
+        sampleCount: totalEstimate.sampleCount,
+        confidence: !integrationEstimate || integrationEstimate.confidence === 'low' ? 'low' : totalEstimate.confidence,
+        implementationWorkMs: typical.implementationWorkMs,
+        integrationQueueWaitMs: typical.integrationQueueWaitMs,
+        integrationLaneMs: typical.integrationLaneMs,
+        integrationSampleCount: integrationEstimate?.sampleCount ?? 0,
+        maxConcurrency,
+        globalLimit,
+        workerUnitsPerStory,
+        tasks: typical.tasks,
+    };
+}
+function validSample(value) {
+    return Number.isFinite(value) && value > 0;
 }

package/dist/loop/claim-lease.js

@@ -113,8 +113,8 @@ export function withClaimOperations(file, context, readRecords, claimFiles, task
     if (!token)
         return null;
     const acquired = [];
-    const orderedFiles = [...new Set(claimFiles(readRecords()).filter(candidate => candidate !== file))].sort((left, right) => left.localeCompare(right));
     try {
+        const orderedFiles = [...new Set(claimFiles(readRecords()).filter(candidate => candidate !== file))].sort((left, right) => left.localeCompare(right));
         for (const nextFile of orderedFiles) {
             const nextToken = acquireClaimOperation(nextFile, context);
             if (!nextToken)

package/dist/loop/dispatcher.js

@@ -55,6 +55,7 @@ export function createDispatcher(options) {
     const queue = new MergeQueue();
     const active = new Map();
     const queued = new Map();
+    const integrationControllers = new Map();
     const areas = new Set();
     const reservedWrites = new Map();
     const integrated = [];
@@ -66,23 +67,34 @@ export function createDispatcher(options) {
     let providerIndex = 0;
     let paused = false;
     let cancellationReason;
-    const reportProgress = () => options.onProgress?.({
-        dispatcherId,
-        maxConcurrency: options.maxConcurrency,
-        activeWorkers: active.size,
-        queuedCandidates: queued.size,
-        integrated: integrated.length,
-        reopened: reopened.length,
-        iteration: iterations,
-        progress: progress(options.stories),
-        workers: [...active.values()].map(worker => ({
-            story: worker.input.story.id,
-            storyTitle: worker.input.story.title,
-            provider: worker.input.provider.provider,
-            ...(worker.input.provider.model ? { model: worker.input.provider.model } : {}),
-            phase: 'implementing',
-        })),
-    });
+    const reportProgress = () => {
+        let globalPool;
+        try {
+            globalPool = options.resourceStatus?.();
+        }
+        catch { /* Resource status is observational; admission remains fail-closed. */ }
+        options.onProgress?.({
+            dispatcherId,
+            maxConcurrency: options.maxConcurrency,
+            workerUnitsPerStory: options.candidateCount && options.candidateCount > 1 && options.candidateCoordinator ? options.candidateCount : 1,
+            activeWorkers: active.size,
+            waitingWorkers: [...active.values()].filter(worker => worker.phase === 'waiting-resource').length,
+            queuedCandidates: queued.size,
+            queuedIntegrations: queued.size,
+            ...(globalPool ? { globalPool } : {}),
+            integrated: integrated.length,
+            reopened: reopened.length,
+            iteration: iterations,
+            progress: progress(options.stories),
+            workers: [...active.values()].map(worker => ({
+                story: worker.input.story.id,
+                storyTitle: worker.input.story.title,
+                provider: worker.input.provider.provider,
+                ...(worker.input.provider.model ? { model: worker.input.provider.model } : {}),
+                phase: worker.phase,
+            })),
+        });
+    };
     const providerFor = (story) => {
         if (story.agent) {
             const configured = options.affinityProviders?.find(provider => provider.provider === story.agent)
@@ -123,9 +135,22 @@ export function createDispatcher(options) {
     };
     const enqueue = (input, result) => {
         let reason = 'integrated verification failed';
+        const integrationQueuedAt = Date.now();
+        let integrationStartedAt;
+        const integrationController = new AbortController();
+        integrationControllers.set(input.story.id, integrationController);
+        let integrationLease;
         const task = queue.enqueue({
             storyId: input.story.id,
             rebase: async () => {
+                if (cancellationReason)
+                    throw new Error(cancellationReason);
+                options.onIntegrationMetrics?.(input, Date.now() - integrationQueuedAt, undefined);
+                if (options.acquireResource) {
+                    options.gates.integrationPhase?.(input, 'waiting-resource');
+                    integrationLease = await options.acquireResource({ story: input.story, provider: input.provider, role: 'integration', units: 1, signal: integrationController.signal });
+                }
+                integrationStartedAt = Date.now();
                 if (cancellationReason)
                     throw new Error(cancellationReason);
                 if (!options.git.isClean(options.targetDir))
@@ -182,11 +207,19 @@ export function createDispatcher(options) {
                     throw new Error(`unexpected merge result: ${String(unexpected)}`);
                 }
             }
-        }).finally(() => {
+        }).finally(async () => {
             queued.delete(input.story.id);
+            integrationControllers.delete(input.story.id);
             options.gates.integrationPhase?.(input, undefined);
-            cleanup(input);
-            reportProgress();
+            try {
+                if (integrationLease)
+                    await integrationLease.release();
+                options.onIntegrationMetrics?.(input, Date.now() - integrationQueuedAt, integrationStartedAt === undefined ? undefined : Date.now() - integrationStartedAt);
+            }
+            finally {
+                cleanup(input);
+                reportProgress();
+            }
         });
         queued.set(input.story.id, task);
         reportProgress();
@@ -207,9 +240,23 @@ export function createDispatcher(options) {
         if (story.area)
             areas.add(story.area);
         const candidateDispatch = candidateRace;
-        const task = (candidateDispatch && options.candidateCoordinator
-            ? Promise.resolve(options.candidateCoordinator(input)).then(coordinateCandidates).then(result => ({ source: 'candidates', result }))
-            : options.worker(input).then(result => ({ source: 'worker', result }))).then(async (outcome) => {
+        const activeWorker = { input, controller, task: Promise.resolve(), phase: options.acquireResource ? 'waiting-resource' : 'implementing' };
+        const task = Promise.resolve().then(async () => {
+            const workerLease = options.acquireResource
+                ? await options.acquireResource({ story, provider, role: 'implementation', units: candidateRace ? options.candidateCount : 1, signal: controller.signal })
+                : undefined;
+            activeWorker.phase = 'implementing';
+            reportProgress();
+            try {
+                return await (candidateDispatch && options.candidateCoordinator
+                    ? Promise.resolve(options.candidateCoordinator(input)).then(coordinateCandidates).then(result => ({ source: 'candidates', result }))
+                    : options.worker(input).then(result => ({ source: 'worker', result })));
+            }
+            finally {
+                if (workerLease)
+                    await workerLease.release();
+            }
+        }).then(async (outcome) => {
             active.delete(story.id);
             claims.heartbeat(input);
             if (outcome.source === 'candidates') {
@@ -285,7 +332,8 @@ export function createDispatcher(options) {
             if (!(error instanceof Error))
                 throw error;
         });
-        active.set(story.id, { input, controller, task });
+        Object.assign(activeWorker, { task });
+        active.set(story.id, activeWorker);
         reportProgress();
     };
     const cancel = (reason) => {
@@ -296,6 +344,8 @@ export function createDispatcher(options) {
             claims.cancel?.(worker.input, reason);
             worker.controller.abort(reason);
         }
+        for (const controller of integrationControllers.values())
+            controller.abort(reason);
     };
     const run = async () => {
         for (;;) {
@@ -303,8 +353,8 @@ export function createDispatcher(options) {
                 paused = true;
             if (!paused && !cancellationReason && integrationBlocks.length === 0 && iterations < options.maxIterations) {
                 const busy = new Set([...active.keys(), ...queued.keys(), ...failed]);
-                // Integration/review retains its execution slot until the candidate lands.
-                const slots = Math.max(0, options.maxConcurrency - active.size - queued.size);
+                // Implementation slots are reusable while candidates wait for the separate integration lane.
+                const slots = Math.max(0, options.maxConcurrency - active.size);
                 const ready = readyStories(options.stories, { activeAreas: areas, activeWrites: [...reservedWrites.values()] }).filter(story => !busy.has(story.id));
                 let launched = 0;
                 for (const story of ready) {

package/dist/loop/git.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { sanitizeCommitMessage } from './identity.js';
-export const RUNTIME_PATHS = [".yoke/supervision", ".yoke/provider-processes", '.yoke/artifacts', '.yoke/events', '.yoke/history', '.yoke/routing', '.yoke/checks', '.yoke/goal.json', '.yoke/goal.pause', '.yoke/loop-status.json', '.yoke/loop.lock', '.yoke/loop.lock.takeover', '.yoke/loop.lock.takeover.recovery', '.yoke/runner.pid', '.yoke/story-durations.json'];
+export const RUNTIME_PATHS = [".yoke/supervision", ".yoke/provider-processes", '.yoke/artifacts', '.yoke/events', '.yoke/history', '.yoke/routing', '.yoke/checks', '.yoke/goal.json', '.yoke/goal.pause', '.yoke/loop.pause', '.yoke/loop-status.json', '.yoke/loop.lock', '.yoke/loop.lock.takeover', '.yoke/loop.lock.takeover.recovery', '.yoke/runner.pid', '.yoke/story-durations.json'];
 // Directory pathspecs include descendants and also exclude the directory entry.
 export const RUNTIME_EXCLUDES = RUNTIME_PATHS.map(path => `:(exclude)${path}`);
 export function stageImplementation(dir) {

package/dist/loop/loop.js

@@ -1,5 +1,5 @@
 import { knownInfrastructureFailure } from "../routing/capability.js";
-import { existsSync, unlinkSync, readFileSync } from 'node:fs';
+import { existsSync, unlinkSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { acceptanceProtectionProblem } from '../check/command.js';
 import { join, relative } from 'node:path';
 import { isAcceptanceCriterion, loadPrd, savePrd, selectNextStory, allPass, progress, storyPathSegment } from './prd.js';
@@ -102,6 +102,18 @@ function runQualityReview(opts, executionDir, story, reporter) {
 export function pauseFilePath(targetDir) {
     return join(targetDir, '.yoke', 'loop.pause');
 }
+/** Request a pause at the next safe story or exploration boundary. */
+export function requestLoopPause(targetDir) {
+    const file = pauseFilePath(targetDir);
+    mkdirSync(join(targetDir, '.yoke'), { recursive: true });
+    try {
+        writeFileSync(file, `${new Date().toISOString()}\n`, { flag: 'wx' });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+}
 function consumePause(targetDir) {
     const file = pauseFilePath(targetDir);
     if (!existsSync(file))

package/dist/loop/parallel-command.js

@@ -11,6 +11,7 @@ import { makeParallelAdapters } from './parallel-adapters.js';
 import { loadPrd, progress } from './prd.js';
 import { makeAsyncRunner } from './runner.js';
 import { runStoryWorker } from './worker.js';
+import { acquireSharedWorker, sharedPoolStatus } from './resource-pool.js';
 export async function runParallelLoopCommand(input) {
     const originalVerify = input.verify;
     input = { ...input, verify: path => {
@@ -39,6 +40,26 @@ export async function runParallelLoopCommand(input) {
         stories: loadPrd(input.prdPath),
         maxConcurrency: input.maxConcurrency,
         maxIterations: input.maxIterations,
+        acquireResource: async (request) => {
+            const started = Date.now();
+            const lease = await acquireSharedWorker({
+                targetDir: input.targetDir,
+                storyId: request.story.id,
+                provider: request.provider.provider,
+                role: request.role,
+                units: request.units,
+                signal: request.signal,
+            });
+            input.reporter.resourceWait?.({ id: request.story.id, title: request.story.title }, request.role, request.units, Date.now() - started, request.provider.provider);
+            return lease;
+        },
+        resourceStatus: () => sharedPoolStatus(),
+        onIntegrationMetrics: (worker, queueWaitMs, integrationMs) => {
+            if (integrationMs === undefined)
+                input.reporter.integrationQueueWait?.({ id: worker.story.id, title: worker.story.title }, queueWaitMs, worker.provider.provider);
+            else
+                input.reporter.integrationDuration?.({ id: worker.story.id, title: worker.story.title }, integrationMs, worker.provider.provider);
+        },
         providers: input.providers,
         affinityProviders: input.affinityProviders,
         worktrees: adapters.worktrees,

package/dist/loop/prd.js

@@ -11,6 +11,15 @@ export const AcceptanceCriterionSchema = z.object({
     text: z.string().min(1),
     verify: z.array(z.string().min(1)).min(1),
 });
+export const ExplorationOriginSchema = z.object({
+    version: z.literal(1),
+    rationale: z.string().min(1).max(2_000),
+    expectedBenefit: z.string().min(1).max(2_000),
+    confidence: z.number().min(0.8).max(1),
+    risk: z.enum(['low', 'medium']),
+    evidence: z.array(z.object({ path: z.string().min(1).max(500), observation: z.string().min(1).max(1_000) }).strict()).min(1).max(6),
+    discoveredAt: z.string().datetime(),
+}).strict();
 export function criterionCommandProblem(criterion) {
     const normalizedId = criterion.id.toLowerCase().replace(/[^a-z0-9]/g, '');
     for (const raw of criterion.verify) {
@@ -46,6 +55,8 @@ export const StorySchema = z.object({
     agent: AgentSchema.optional(),
     /** Inbox request that created this story. Used for idempotent append-only intake. */
     sourceChange: z.string().min(1).optional(),
+    /** Evidence retained for stories created by opt-in continuous exploration. */
+    exploration: ExplorationOriginSchema.optional(),
     quality: StoryQualityDeclarationSchema.optional(),
     assessment: AssessmentSchema.optional(),
     /** Binding to the task, upstream contracts and approved planning brief. */

package/dist/loop/reporter.js

@@ -220,10 +220,12 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             persist({ ...base, state: 'running', phase: undefined, story: story.id, storyTitle: story.title,
                 progress, ...(eta ? { eta } : {}), updatedAt: now().toISOString() }, 'story-done', `✓ ${story.id} done${took} — ${progress.passed}/${progress.total} (${percentOf(progress)}%)${hint}`);
         },
-        phase(phase) {
-            if (!current)
-                return;
-            persist({ ...current, phase, updatedAt: now().toISOString() }, phase, `  · ${phase}…`);
+        phase(phase, reason, progress) {
+            const status = current ?? emptyStatus(now().toISOString());
+            const base = phase === 'exploring' || phase === 'waiting-exploration' || phase === 'waiting-recovery'
+                ? (({ story: _story, storyTitle: _storyTitle, ...withoutStory }) => withoutStory)(status)
+                : status;
+            persist({ ...base, state: 'running', phase, ...(progress ? { progress } : {}), ...(reason ? { reason } : { reason: undefined }), updatedAt: now().toISOString() }, phase, `  · ${phase}…`);
         },
         blocked(reason) {
             const base = current ?? emptyStatus(now().toISOString());
@@ -237,9 +239,9 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             persist({ ...withoutParallel(current ?? emptyStatus(now().toISOString())), state: 'cap-reached', phase: undefined,
                 progress, updatedAt: now().toISOString() }, 'cap-reached', `◾ iteration cap reached — ${progress.passed}/${progress.total}`);
         },
-        paused(progress) {
+        paused(progress, reason) {
             persist({ ...withoutParallel(current ?? emptyStatus(now().toISOString())), state: 'paused', phase: undefined,
-                progress, updatedAt: now().toISOString() }, 'paused', `⏸ loop paused — ${progress.passed}/${progress.total}`);
+                progress, ...(reason ? { reason } : {}), updatedAt: now().toISOString() }, 'paused', `⏸ loop paused — ${progress.passed}/${progress.total}`);
         },
         quality(status) {
             const base = current ?? emptyStatus(now().toISOString());
@@ -260,7 +262,7 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
                         selectedVariant: previous.selectedVariant,
                         ...(previous.model ? { model: previous.model } : {}),
                         provider: previous.provider,
-                        ...(previous.phase ? { phase: previous.phase } : {}),
+                        phase: worker.phase === 'implementing' && previous.phase && previous.phase !== 'waiting-resource' ? previous.phase : worker.phase,
                         ...(previous.quality ? { quality: previous.quality } : {}),
                     }
                     : { ...worker, startedAt: now().toISOString() };
@@ -283,6 +285,24 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
                 updatedAt: now().toISOString(),
             }, 'parallel', `  · parallel ${status.activeWorkers}/${status.maxConcurrency}`);
         },
+        resourceWait(story, role, units, waitMs, provider) {
+            appendEvent(dir, {
+                runId,
+                timestamp: now().toISOString(),
+                type: 'phase-ended',
+                storyId: story.id,
+                phase: `resource-wait-${role}`,
+                provider,
+                durationMs: Math.max(0, waitMs),
+                data: { units },
+            });
+        },
+        integrationQueueWait(story, waitMs, provider) {
+            appendEvent(dir, { runId, timestamp: now().toISOString(), type: 'phase-ended', storyId: story.id, phase: 'integration-queue', provider, durationMs: Math.max(0, waitMs) });
+        },
+        integrationDuration(story, durationMs, provider) {
+            appendEvent(dir, { runId, timestamp: now().toISOString(), type: 'phase-ended', storyId: story.id, phase: 'integration', provider, durationMs: Math.max(0, durationMs) });
+        },
         parallelWorker(status) {
             const base = current;
             const parallel = base?.parallel;