@pellux/goodvibes-sdk 0.38.0 → 1.1.0

package/dist/platform/orchestration/phase-runner.js

@@ -8,6 +8,8 @@ import { isTransportFailureMessage } from '../types/errors.js';
 import { logger } from '../utils/logger.js';
 import { summarizeError } from '../utils/error-display.js';
 import { excludeUntouchedLaunchResidue } from './dirty-guard.js';
+import { classifyBookkeepingFailure } from './bookkeeping.js';
+import { mergeWorkItemUsage } from './types.js';
 function templateForPhase(phase) {
     return phase.kind === 'review' || phase.kind === 'gate' ? 'general' : 'engineer';
 }
@@ -74,23 +76,14 @@ function usageFromRecord(record, priceUsage) {
     }
     return { ...base, costUsd, costState };
 }
-/** Combines a new phase's usage into a work item's running total. Single-source cost (never independently re-priced here). */
+/**
+ * Combines a new phase's usage into a work item's running total. Single-source
+ * cost (never independently re-priced here). Thin alias over the canonical
+ * {@link mergeWorkItemUsage} (types.ts) so the phase-runner, the engine, and
+ * the fleet rollup adapters all fold usage through exactly one implementation.
+ */
 export function mergeUsage(a, b) {
-    const sawReasoning = a.reasoningTokens !== undefined || b.reasoningTokens !== undefined;
-    const bothPriced = a.costState === 'priced' && b.costState === 'priced';
-    const neitherPriced = a.costUsd === null && b.costUsd === null;
-    return {
-        inputTokens: a.inputTokens + b.inputTokens,
-        outputTokens: a.outputTokens + b.outputTokens,
-        cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
-        cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,
-        reasoningTokens: sawReasoning ? (a.reasoningTokens ?? 0) + (b.reasoningTokens ?? 0) : undefined,
-        llmCallCount: a.llmCallCount + b.llmCallCount,
-        turnCount: a.turnCount + b.turnCount,
-        toolCallCount: a.toolCallCount + b.toolCallCount,
-        costUsd: a.costUsd !== null && b.costUsd !== null ? a.costUsd + b.costUsd : (a.costUsd ?? b.costUsd),
-        costState: bothPriced ? 'priced' : neitherPriced ? 'unpriced' : 'estimated',
-    };
+    return mergeWorkItemUsage(a, b);
 }
 /** Quality gates (global-config-driven, reused VERBATIM) + phase-required-gate assertion + phantom guard + reviewer constraint findings. */
 async function evaluateGate(workstream, phase, report, deps) {
@@ -100,6 +93,13 @@ async function evaluateGate(workstream, phase, report, deps) {
             runtimeBus: deps.runtimeBus,
             sessionId: deps.sessionId,
             chainId: workstream.id,
+            // Worktree mode (BIG-3 item 5): run the configured quality gates INSIDE the
+            // item's isolated worktree, the same way the phantom-work guard above
+            // verifies claims against that worktree path. BIG-1 fixed only the phantom
+            // check; without this, gates (typecheck/lint/test) would run against the
+            // shared projectRoot and never see the item's isolated changes. Absent
+            // (shared mode) ⇒ runWrfcGateChecks defaults cwd to projectRoot — unchanged.
+            ...(deps.itemWorktree ? { cwd: deps.itemWorktree.path } : {}),
         })];
     const ranNames = new Set(results.map((r) => r.gate));
     const missingRequired = phase.gate.gates.filter((name) => !ranNames.has(name));
@@ -107,7 +107,11 @@ async function evaluateGate(workstream, phase, report, deps) {
         results.push({ gate: name, passed: false, output: 'required gate is not configured/enabled', durationMs: 0 });
     }
     if (report.archetype === 'engineer' && !deps.skipClaimVerification) {
-        const verification = verifyEngineerClaims(report, deps.projectRoot);
+        // Worktree mode: the agent's files landed in the item's OWN worktree, not
+        // the shared projectRoot — verify claims (existence + `git diff`) against
+        // that worktree path, or every real change would be falsely flagged as
+        // phantom work (nothing to find at projectRoot).
+        const verification = verifyEngineerClaims(report, deps.itemWorktree?.path ?? deps.projectRoot);
         if (verification.kind === 'unverified' || verification.kind === 'unverifiable_no_claims') {
             results.push({ gate: 'phantom-work-guard', passed: false, output: verification.summary, durationMs: 0 });
         }
@@ -137,11 +141,48 @@ async function evaluateGate(workstream, phase, report, deps) {
         unsatisfiedConstraintIds,
     };
 }
+/**
+ * Runs the POST-gate scoped-commit + merge for a passed phase and reports its
+ * outcome HONESTLY rather than swallowing failures. The gate has already
+ * decided the phase passed; this step only records the changes, so its result
+ * is bookkeeping: a failure surfaces to the engine as a warning on a passed
+ * item (or, for the narrow negating set — workspace corruption, see
+ * bookkeeping.ts — as an item failure), never as a silent no-op that lets the
+ * fleet imply a commit happened when it did not (DEBT-4 item 1).
+ */
 async function commitPhaseWork(item, phase, agentId, worktree, deps) {
-    if (phase.gate.scope === 'off')
-        return undefined;
+    if (phase.gate.scope === 'off') {
+        return { commit: { status: 'skipped', reason: 'commit disabled for this phase (gate scope: off)' } };
+    }
     let paths = phase.gate.scope === 'scoped' ? item.touchedPaths : undefined;
     let exclusion;
+    // Worktree mode: the item commits onto its own branch INSIDE its dedicated
+    // worktree, which the engine created fresh (and therefore clean) at claim.
+    // The launch-dirty snapshot is taken against the SHARED projectRoot, so it
+    // has nothing to say about a just-created worktree — a fresh worktree starts
+    // clean, so its launch-dirty residue is trivially empty. Skip the residue
+    // exclusion entirely and commit straight onto the item branch; NO merge to
+    // base (the sequential integration lane owns that at item termination).
+    if (deps.itemWorktree) {
+        try {
+            const result = await deps.itemWorktree.commit(`orchestration: ${item.title} — ${phase.kind} phase`, paths);
+            const ignoredNote = result.skippedIgnored.length > 0
+                ? `${result.skippedIgnored.length} ignored path${result.skippedIgnored.length === 1 ? '' : 's'} skipped`
+                : undefined;
+            if (result.hash === null) {
+                return { commit: { status: 'skipped', reason: ignoredNote ? `nothing to stage (${ignoredNote})` : 'nothing to stage' } };
+            }
+            return { commit: { status: 'committed', hash: result.hash, ...(ignoredNote ? { reason: ignoredNote } : {}) } };
+        }
+        catch (error) {
+            const reason = summarizeError(error);
+            const negating = classifyBookkeepingFailure(error) === 'negating';
+            logger.warn('orchestration phase-runner: worktree scoped commit did not complete', {
+                itemId: item.id, phaseId: phase.id, worktreePath: deps.itemWorktree.path, error: reason, negating,
+            });
+            return { commit: { status: 'failed', reason, negating } };
+        }
+    }
     if (paths && paths.length > 0 && deps.launchDirtySnapshot) {
         const launchSnapshot = deps.launchDirtySnapshot;
         if (launchSnapshot.size > 0) {
@@ -157,7 +198,7 @@ async function commitPhaseWork(item, phase, agentId, worktree, deps) {
                         phaseId: phase.id,
                         excludedPaths: excluded,
                     });
-                    return exclusion;
+                    return { exclusion, commit: { status: 'skipped', reason: 'every candidate path was untouched launch-dirty residue' } };
                 }
                 logger.info('orchestration phase-runner: excluded untouched launch-dirty residue from scoped commit', {
                     itemId: item.id,
@@ -169,13 +210,31 @@ async function commitPhaseWork(item, phase, agentId, worktree, deps) {
         }
     }
     try {
-        await worktree.commitWorkingTree(`orchestration: ${item.title} — ${phase.kind} phase`, paths);
+        const result = await worktree.commitWorkingTree(`orchestration: ${item.title} — ${phase.kind} phase`, paths);
         await worktree.merge(agentId);
+        const ignoredNote = result.skippedIgnored.length > 0
+            ? `${result.skippedIgnored.length} ignored path${result.skippedIgnored.length === 1 ? '' : 's'} skipped`
+            : undefined;
+        if (result.hash === null) {
+            // A null hash is "nothing was staged" — an honest skip, not a landed commit.
+            return { exclusion, commit: { status: 'skipped', reason: ignoredNote ? `nothing to stage (${ignoredNote})` : 'nothing to stage' } };
+        }
+        return {
+            exclusion,
+            commit: { status: 'committed', hash: result.hash, ...(ignoredNote ? { reason: ignoredNote } : {}) },
+        };
     }
     catch (error) {
-        logger.warn('orchestration phase-runner: commit/merge failed', { itemId: item.id, phaseId: phase.id, error: summarizeError(error) });
+        const reason = summarizeError(error);
+        const negating = classifyBookkeepingFailure(error) === 'negating';
+        // Non-fatal by default: the gate already passed, so the engine treats this
+        // as a warning on a passed item. Only a NEGATING failure (workspace
+        // corruption — bookkeeping.ts) flips the item to failed.
+        logger.warn('orchestration phase-runner: scoped commit/merge did not complete', {
+            itemId: item.id, phaseId: phase.id, error: reason, negating,
+        });
+        return { exclusion, commit: { status: 'failed', reason, negating } };
     }
-    return exclusion;
 }
 /** Runs one WorkItem through one Phase to completion (or cancellation/failure). Recurses (bounded by transportRetryLimit) on a transport-classified spawn failure. */
 export async function runPhase(workstream, item, phase, priorReports, deps) {
@@ -187,6 +246,11 @@ export async function runPhase(workstream, item, phase, priorReports, deps) {
         task: buildPhaseTask(item, phase, priorReports),
         template: templateForPhase(phase),
         dangerously_disable_wrfc: true,
+        // Worktree mode: run the agent's tools with their working directory set to
+        // the item's isolated worktree, so its file edits land there instead of the
+        // shared projectRoot. Omitted (undefined) in shared mode ⇒ agent uses the
+        // orchestrator's default working directory exactly as before.
+        ...(deps.itemWorktree ? { workingDirectory: deps.itemWorktree.path } : {}),
     });
     record.workItemId = item.id;
     item.agentId = record.id;
@@ -253,10 +317,18 @@ export async function runPhase(workstream, item, phase, priorReports, deps) {
     }
     const gate = await evaluateGate(workstream, phase, report, deps);
     let commitExclusion;
+    let commit;
     if (gate.passed) {
-        commitExclusion = await commitPhaseWork(item, phase, record.id, worktree, deps);
+        const committed = await commitPhaseWork(item, phase, record.id, worktree, deps);
+        commitExclusion = committed.exclusion;
+        commit = committed.commit;
+    }
+    // In worktree mode the item worktree persists across phases (the engine's
+    // integration lane owns its teardown), so only the shared-mode transient
+    // worktree gets cleaned up here.
+    if (!deps.itemWorktree) {
+        await worktree.cleanup(record.id).catch(() => undefined);
     }
-    await worktree.cleanup(record.id).catch(() => undefined);
     return {
         agentStatus: 'completed',
         result: {
@@ -269,6 +341,7 @@ export async function runPhase(workstream, item, phase, priorReports, deps) {
             completedAt: Date.now(),
             usage,
             ...(commitExclusion ? { commitExclusion } : {}),
+            ...(commit ? { commit } : {}),
         },
     };
 }

package/dist/platform/orchestration/proposal-workstream.d.ts

@@ -0,0 +1,56 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Proposal → workstream assembly (BIG-3 item 1) — the final stage of the
+ * WRFC→orchestration migration. `fromPlanProposal()` maps an APPROVED
+ * PlanProposal (platform/core/plan-proposal.ts, produced by the BIG-2 planner
+ * decomposition pipeline) into a `CreateWorkstreamInput` the engine can run
+ * directly, so `/workstream launch` executes the REAL multi-item plan instead
+ * of flattening it through the `fromChainSpec` compat path.
+ *
+ * The mapping, one honest step at a time:
+ *  - ONE work item per proposal work item. The proposal item's `title` becomes
+ *    the work item's title and its `brief` becomes the work item's `task` — the
+ *    prompt/context the phase agents actually run against (the phase-runner
+ *    prepends "Work item: <title>" to review/fix prompts, so both survive into
+ *    the agent's context). The proposal item's id is preserved so provenance,
+ *    dependencies, and fleet nodes all line up 1:1.
+ *  - Every item runs the SAME standard role-phase pipeline — engineer→review,
+ *    the exact `engineerReviewPhases` template `fromChainSpec` uses
+ *    (controller-compat.ts). The only per-assembly parameter is phase
+ *    `capacity`: it defaults to the item count so independent items run
+ *    concurrently (bounded only by their dependencies), where a single compat
+ *    chain stays at capacity 1. Callers may cap concurrency via `opts.capacity`.
+ *  - Inter-item dependencies carry over verbatim: `workItem.dependsOn` (already
+ *    resolved to item ids by assemblePlanProposal) becomes the engine work
+ *    item's `dependsOn`, which the scheduler gates the claim path on (an item
+ *    is not claimable until every dependency reaches 'passed'; see the
+ *    'blocked-dependency' state and applyDependencyGates).
+ *  - Workstream-level provenance records where the plan came from
+ *    (decomposedBy, proposalId, strategy, agent cost/elapsed).
+ *
+ * ASSERT-AT-ASSEMBLY (BIG-3 item 2): even though `assemblePlanProposal` already
+ * rejects dangling dependencies and cycles, this function re-checks both and
+ * THROWS on violation rather than quietly building a broken workstream — a
+ * dangling dependency would gate an item on nothing, and a cycle would deadlock
+ * every item in it forever in 'blocked-dependency'. Belt-and-braces, because a
+ * caller could hand us a hand-built or mutated proposal that never went through
+ * the assembler.
+ */
+import type { ConfigManager } from '../config/manager.js';
+import type { PlanProposal } from '../core/plan-proposal.js';
+import type { CreateWorkstreamInput } from './engine.js';
+export interface FromPlanProposalOptions {
+    /**
+     * Per-phase capacity for the engineer/review phases. Defaults to the number
+     * of work items, so all independent items can run concurrently (dependencies
+     * still gate the rest). Set a lower value to cap concurrency; clamped to at
+     * least 1.
+     */
+    readonly capacity?: number | undefined;
+}
+/**
+ * Assemble a `CreateWorkstreamInput` from an approved multi-item PlanProposal.
+ * See the module doc for the full mapping and the assembly-time assertions.
+ */
+export declare function fromPlanProposal(proposal: PlanProposal, configManager: Pick<ConfigManager, 'get' | 'getCategory'>, opts?: FromPlanProposalOptions): CreateWorkstreamInput;
+//# sourceMappingURL=proposal-workstream.d.ts.map

package/dist/platform/orchestration/proposal-workstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposal-workstream.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/proposal-workstream.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AA8CD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,YAAY,EACtB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,aAAa,CAAC,EACzD,IAAI,GAAE,uBAA4B,GACjC,qBAAqB,CA8BvB"}

package/dist/platform/orchestration/proposal-workstream.js

@@ -0,0 +1,76 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { getWrfcCommitScope } from '../agents/wrfc-config.js';
+import { engineerReviewPhases } from './controller-compat.js';
+/** Throws if any item's `dependsOn` references an unknown item, or if the dependency graph contains a cycle. */
+function assertAcyclicAndResolved(proposal) {
+    const ids = new Set(proposal.workItems.map((wi) => wi.id));
+    const byId = new Map(proposal.workItems.map((wi) => [wi.id, wi]));
+    for (const wi of proposal.workItems) {
+        for (const dep of wi.dependsOn) {
+            if (!ids.has(dep)) {
+                throw new Error(`fromPlanProposal: work item "${wi.title}" (${wi.id}) depends on unknown item id "${dep}" — the proposal is not internally consistent`);
+            }
+        }
+    }
+    // Iterative DFS cycle detection over ids (white/grey/black).
+    const state = new Map();
+    const onCycle = (id) => {
+        const title = byId.get(id)?.title ?? id;
+        throw new Error(`fromPlanProposal: dependency cycle detected involving work item "${title}" (${id}) — cannot assemble a workstream that would deadlock`);
+    };
+    const visit = (start) => {
+        const stack = [{ id: start, deps: byId.get(start)?.dependsOn ?? [], i: 0 }];
+        state.set(start, 'visiting');
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            if (frame.i >= frame.deps.length) {
+                state.set(frame.id, 'done');
+                stack.pop();
+                continue;
+            }
+            const next = frame.deps[frame.i++];
+            const seen = state.get(next);
+            if (seen === 'visiting')
+                onCycle(next);
+            if (seen === 'done')
+                continue;
+            state.set(next, 'visiting');
+            stack.push({ id: next, deps: byId.get(next)?.dependsOn ?? [], i: 0 });
+        }
+    };
+    for (const wi of proposal.workItems) {
+        if (!state.has(wi.id))
+            visit(wi.id);
+    }
+}
+/**
+ * Assemble a `CreateWorkstreamInput` from an approved multi-item PlanProposal.
+ * See the module doc for the full mapping and the assembly-time assertions.
+ */
+export function fromPlanProposal(proposal, configManager, opts = {}) {
+    assertAcyclicAndResolved(proposal);
+    const commitScope = getWrfcCommitScope(configManager);
+    const capacity = Math.max(1, opts.capacity ?? proposal.workItems.length);
+    const items = proposal.workItems.map((wi) => ({
+        id: wi.id,
+        title: wi.title,
+        // The brief IS the actionable prompt context; the engineer phase runs it
+        // verbatim as the item's task, and review/fix phases see it alongside the
+        // title (buildPhaseTask, phase-runner.ts).
+        task: wi.brief,
+        ...(wi.dependsOn.length > 0 ? { dependsOn: [...wi.dependsOn] } : {}),
+    }));
+    const provenance = {
+        ...(proposal.decomposedBy ? { decomposedBy: proposal.decomposedBy } : {}),
+        proposalId: proposal.id,
+        strategy: proposal.strategy,
+        ...(proposal.agentCostUsd !== undefined ? { agentCostUsd: proposal.agentCostUsd } : {}),
+        ...(proposal.elapsedMs !== undefined ? { elapsedMs: proposal.elapsedMs } : {}),
+    };
+    return {
+        title: proposal.task,
+        phases: engineerReviewPhases(commitScope, capacity),
+        items,
+        provenance,
+    };
+}

package/dist/platform/orchestration/scheduler.d.ts

@@ -1,6 +1,6 @@
 /** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
 /**
- * Scheduler (Wave 4, wo701) — pure capacity-matching helpers, no side
+ * Scheduler (see CHANGELOG 0.38.0) — pure capacity-matching helpers, no side
  * effects. The hard departure from WrfcController's pairwise
  * engineer<->reviewer binding (startReview:883/startFix:1042): each tick,
  * for every phase in ordinal order, free capacity slots (capacity minus
@@ -27,6 +27,25 @@ export interface PhaseClaim {
     readonly item: WorkItem;
     readonly phase: Phase;
 }
+/**
+ * Whether an item's inter-item dependencies (BIG-3 item 2) are all satisfied,
+ * and — when not — WHY, split into dependencies still in flight vs. ones that
+ * have terminally failed. Pure (no side effects): the engine's per-tick
+ * dependency pre-pass (applyDependencyGates, engine.ts) calls this and applies
+ * the state/blockedReason transition. Missing dependency ids (no item in the
+ * workstream matches) are ignored here — assembly (fromPlanProposal) already
+ * asserts referential integrity, so a dangling id at runtime is treated as
+ * "not blocking" rather than an eternal block.
+ */
+export interface DependencyStatus {
+    /** True when every dependency has reached 'passed' (or there are none). */
+    readonly ready: boolean;
+    /** Titles of dependencies still pending/in flight (neither passed nor failed). */
+    readonly waiting: string[];
+    /** Titles of dependencies that have terminally FAILED — a recoverable block, not a terminal one for the dependent. */
+    readonly failed: string[];
+}
+export declare function dependencyStatus(workstream: Workstream, item: WorkItem): DependencyStatus;
 /**
  * Which (item, phase) pairs have free capacity to claim RIGHT NOW. Pure —
  * no side effects, no budget check (the caller applies budget.checkBudget

package/dist/platform/orchestration/scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/scheduler.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,KAAK,EAAE,CAE5D;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,KAAK,GAAG,SAAS,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAEzF;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAEpF;AAED,gMAAgM;AAChM,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAEzF;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,CAiBlE"}
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/scheduler.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,KAAK,EAAE,CAE5D;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,KAAK,GAAG,SAAS,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAEzF;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAEpF;AAED,gMAAgM;AAChM,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAEzF;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,sHAAsH;IACtH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,gBAAgB,CAWzF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,CAiBlE"}

package/dist/platform/orchestration/scheduler.js

@@ -23,6 +23,22 @@ export function phaseById(workstream, phaseId) {
 export function reviewPhaseBefore(workstream, phase) {
     return sortedPhases(workstream).filter((p) => p.ordinal < phase.ordinal && p.kind === 'review').pop();
 }
+export function dependencyStatus(workstream, item) {
+    const waiting = [];
+    const failed = [];
+    for (const depId of item.dependsOn) {
+        const dep = workstream.items.find((i) => i.id === depId);
+        if (!dep)
+            continue; // dangling id — assembly guarantees this can't happen; ignore rather than block forever
+        if (dep.state === 'passed')
+            continue;
+        if (dep.state === 'failed')
+            failed.push(dep.title);
+        else
+            waiting.push(dep.title);
+    }
+    return { ready: waiting.length === 0 && failed.length === 0, waiting, failed };
+}
 /**
  * Which (item, phase) pairs have free capacity to claim RIGHT NOW. Pure —
  * no side effects, no budget check (the caller applies budget.checkBudget