@pellux/goodvibes-sdk 0.37.2 → 1.0.0

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

@@ -0,0 +1,535 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Orchestration engine — the model (W4.1, wo701).
+ *
+ * A phase/work-item pipeline layered OVER (not replacing) WrfcController. The
+ * hard departure from WrfcController is pipeline semantics: an item advances
+ * to its next phase the instant its gate passes, claimed by WHATEVER capacity
+ * slot is free — there is no pairwise binding of one reviewer to one
+ * engineer's history (see wrfc-controller.ts startReview:883/startFix:1042,
+ * which bind chain.reviewerAgentId/chain.fixerAgentId to a single chain).
+ *
+ * Float ordinals on Phase are load-bearing: inserting a phase mid-run assigns
+ * an ordinal strictly between its neighbors, so existing phase ids — and
+ * therefore existing PhaseResult resume-cache keys (itemId,phaseId) — never
+ * shift or invalidate.
+ */
+import type { WrfcAgentRole, QualityGateResult } from '../agents/wrfc-types.js';
+import type { WrfcCommitScope } from '../agents/wrfc-config.js';
+import type { CompletionReport, ConstraintFinding } from '../agents/completion-report.js';
+/** A named agent role, OR an archetype name loaded via ArchetypeLoader. */
+export type PhaseRole = WrfcAgentRole | (string & {});
+export type PhaseKind = 'plan' | 'engineer' | 'review' | 'fix' | 'gate' | 'integrate' | 'custom';
+/** The gate policy a phase enforces before an item may advance past it. */
+export interface PhaseGateSpec {
+    readonly scope: WrfcCommitScope;
+    readonly gates: readonly string[];
+}
+/**
+ * One pipeline stage. `ordinal` is a float specifically so
+ * `engine.insertPhase()` can slot a new phase strictly between two existing
+ * ordinals without renumbering anything — renumbering would invalidate every
+ * PhaseResult cache key already keyed off the old (itemId,phaseId) pairs.
+ */
+export interface Phase {
+    readonly id: string;
+    readonly ordinal: number;
+    readonly role: PhaseRole;
+    readonly capacity: number;
+    readonly gate: PhaseGateSpec;
+    readonly kind: PhaseKind;
+    /** Epoch ms — set only for phases created via insertPhase() mid-run. */
+    readonly insertedAt?: number | undefined;
+}
+/** Caller-supplied shape for engine.insertPhase() / seeding. `id` is generated when omitted. */
+export interface PhaseSpec {
+    readonly id?: string | undefined;
+    readonly role: PhaseRole;
+    readonly capacity: number;
+    readonly gate: PhaseGateSpec;
+    readonly kind: PhaseKind;
+}
+export type WorkItemState = 'pending' | 'awaiting-capacity'
+/**
+ * Live only while a phase's agent is actually running. `importWorkstream`
+ * (engine.ts) reconciles any item persisted in this state back to
+ * 'pending' and clears `agentId` before the workstream is registered — a
+ * snapshot can only ever capture 'in-phase' as a crash artifact (the
+ * process died mid-run), never a resumable one, since no agent from a
+ * prior process is still alive to finish it. Without that reconciliation
+ * an imported 'in-phase' item counts as an OCCUPIED capacity slot forever
+ * (computeClaims, scheduler.ts) while never being in the re-claimable
+ * waiting set, permanently starving its workstream.
+ */
+ | 'in-phase' | 'passed' | 'failed'
+/**
+ * Recoverable, not terminal. computeClaims (scheduler.ts) includes
+ * 'blocked-budget' items in its waiting set, so the item is automatically
+ * reconsidered on the next tick(). Because usage only grows, in practice
+ * that next tick only unblocks the item once the ceiling itself rises (or
+ * is removed) via `engine.updateBudget()` — which calls tick() after
+ * updating `workstream.budget` so the reconsideration happens immediately
+ * rather than waiting on some unrelated sibling to complete. `blockedReason`
+ * carries the human-readable reason for as long as the item stays blocked
+ * (cleared the moment it reclaims a slot).
+ */
+ | 'blocked-budget'
+/**
+ * Recoverable, not terminal — the item cannot be claimed yet because at
+ * least one of its `dependsOn` items has not reached 'passed'. This is a
+ * REFUSE-not-kill gate (BIG-3 item 2): the item sits here, out of the
+ * claimable waiting set (computeClaims excludes it), until the engine's
+ * per-tick dependency pre-pass (applyDependencyGates, engine.ts) finds every
+ * dependency passed and flips it back to 'pending'. `blockedReason` is
+ * recomputed every tick so it stays honest as dependencies change:
+ *   - `waiting on: <titles>` while dependencies are still pending/running,
+ *   - `dependency failed: <titles>` once a dependency has terminally failed.
+ * A FAILED dependency does NOT terminally fail the dependent — it stays here,
+ * recoverable: if that dependency is later retried (engine.retryItem) and
+ * passes, the next tick clears this block and the item proceeds. Only ever
+ * set on an item that has not started yet (no phase has run); once an item's
+ * dependencies are all passed at its first claim they stay passed (passed is
+ * terminal), so a mid-pipeline item is never re-gated.
+ */
+ | 'blocked-dependency';
+/** Token/cost usage rolled up across every agent this work-item has ever spawned. */
+export interface WorkItemUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly reasoningTokens?: number | undefined;
+    readonly llmCallCount: number;
+    readonly turnCount: number;
+    readonly toolCallCount: number;
+    readonly costUsd: number | null;
+    readonly costState: 'priced' | 'unpriced' | 'estimated';
+}
+export declare function emptyWorkItemUsage(): WorkItemUsage;
+/**
+ * Combine two usage rollups into one running total. The SINGLE canonical merge
+ * used everywhere a WorkItemUsage is accumulated — the phase-runner (folding a
+ * completed phase into an item), the engine (same, at the phase boundary), and
+ * the fleet rollup adapters (overlaying live in-flight usage onto committed
+ * totals). Keeping one implementation is what makes the rollup MONOTONE in
+ * presence: every count is summed (counts only grow) and a cost is retained
+ * via `??` whenever either operand carries one, so once a real token or cost
+ * value has appeared the merged result can never regress to absent/`null`
+ * (DEBT-4 item 2 — "updating" is a state, never a data wipe).
+ *
+ * Cost state stays honest rather than optimistic: 'priced' only when BOTH
+ * operands are priced; 'unpriced' only when NEITHER carries a cost; any mix is
+ * 'estimated' — a real partial sum, explicitly flagged as incomplete.
+ */
+export declare function mergeWorkItemUsage(a: WorkItemUsage, b: WorkItemUsage): WorkItemUsage;
+/**
+ * One unit of pipeline work. `visits` bounds re-review cycles the same way
+ * WrfcController.retryTransportFailure/evaluateConstraints cap fix attempts —
+ * keyed by phaseId so a dynamically-inserted 'fix' phase gets its own counter.
+ */
+export interface WorkItem {
+    readonly id: string;
+    title: string;
+    readonly task: string;
+    /**
+     * IDs of the sibling work items this item depends on (BIG-3 item 2). The
+     * item is not claimable until EVERY id here refers to an item that has
+     * reached 'passed'; until then it sits in 'blocked-dependency' with an
+     * honest `blockedReason`. Empty (the common case) ⇒ no dependency gate, the
+     * item is claimable as soon as capacity and budget allow. Populated from a
+     * PlanProposal's resolved `dependsOn` by `fromPlanProposal`
+     * (proposal-workstream.ts); the assembly asserts these reference real items
+     * and form no cycle. JSON-safe (a plain string[]), so it serializes with the
+     * work item unchanged.
+     */
+    dependsOn: string[];
+    /** The phase this item is currently queued for or running in; null once terminal. */
+    currentPhaseId: string | null;
+    state: WorkItemState;
+    branch?: string | undefined;
+    /** The agent currently (or most recently) driving this item's active phase. */
+    agentId?: string | undefined;
+    /** Every agent ever spawned for this item, across all phases/retries — usage rollup roster. */
+    allAgentIds: string[];
+    /** phaseId -> number of times this item has been routed through that phase. */
+    readonly visits: Map<string, number>;
+    /** Deduped touched-path ledger for scoped commits, mirrors WrfcChain.touchedPaths. */
+    touchedPaths: string[];
+    usage: WorkItemUsage;
+    /** Separate from `visits` — a transport blip must never eat into the fix-cycle budget. */
+    transportRetryCount: number;
+    readonly createdAt: number;
+    completedAt?: number | undefined;
+    failureReason?: string | undefined;
+    /** Set only while state === 'blocked-budget'; cleared the instant the item reclaims a slot. See the 'blocked-budget' state doc for recovery semantics. */
+    blockedReason?: string | undefined;
+    /**
+     * Non-fatal bookkeeping notes accrued while the item PASSED its phases — e.g.
+     * a scoped commit that could not complete (DEBT-4 item 1). Warnings NEVER
+     * change the item's terminal status (that derives only from phase outcomes
+     * plus the explicit negating set, see bookkeeping.ts); they make a
+     * passed-with-caveats outcome legible instead of hiding it — or, worse,
+     * misreporting a genuinely-passed item as failed.
+     */
+    warnings?: string[] | undefined;
+    /**
+     * Absolute path to this item's isolated git worktree (worktree mode only).
+     * Set at first claim, cleared once the worktree is removed. Retained on a
+     * KEPT worktree (merge conflict, or a dirty tree after fail/kill) so the
+     * terminal summary and events can name exactly where the unmerged work lives.
+     */
+    worktreePath?: string | undefined;
+    /** The item's branch name inside its worktree (worktree mode only), e.g. `ws/<wsShort>/<itemShort>`. */
+    worktreeBranch?: string | undefined;
+    /**
+     * Integration state of the item branch relative to the base branch (worktree
+     * mode). `'pending'` from the moment the passed item enters the integration
+     * lane until its merge resolves; `'merged'` (with {@link mergeHash} set) on a
+     * clean merge; `'conflict'` when the lane could not merge it — the worktree is
+     * then KEPT and `blockedReason` carries `merge-conflict: <files>`.
+     */
+    mergeState?: ItemMergeState | undefined;
+    /** The merge commit hash recorded on a clean integration (mergeState === 'merged'). */
+    mergeHash?: string | undefined;
+    /**
+     * True when this item's worktree was deliberately KEPT rather than removed —
+     * a merge conflict, or a dirty tree left after fail/kill (data safety, rule
+     * 4). A kept worktree still lives at {@link worktreePath} for inspection.
+     */
+    worktreeKept?: boolean | undefined;
+}
+export interface WorkItemSpec {
+    readonly id?: string | undefined;
+    readonly title: string;
+    readonly task: string;
+    /**
+     * IDs of other items in the SAME workstream this item depends on (BIG-3
+     * item 2). Omitted/empty ⇒ no dependency gate. Every id must match another
+     * item's id in the same CreateWorkstreamInput; `fromPlanProposal` asserts
+     * this (and acyclicity) at assembly, and the engine gates the claim path on
+     * it (see the 'blocked-dependency' state doc).
+     */
+    readonly dependsOn?: readonly string[] | undefined;
+}
+/**
+ * Where a workstream's item phases run their file changes.
+ *
+ * - `shared` (DEFAULT): every item's phases run their agents in the ONE shared
+ *   `projectRoot` working tree and scoped-commit straight onto its branch, as
+ *   the engine has always behaved. Two items editing the same file serialize
+ *   only by luck of scheduling — full behavioral back-compat, every pre-existing
+ *   test passes untouched.
+ * - `worktree`: at first claim each item gets its own git worktree branched
+ *   from the base branch (see IsolatedWorktree, worktree.ts). Its phases commit
+ *   onto the item branch INSIDE that worktree, so concurrent items never touch
+ *   each other's working tree. When an item terminates passed its branch is
+ *   merged back into the base branch through a single sequential integration
+ *   lane (completion order). See the engine's WorktreeIsolationManager.
+ */
+export type WorkstreamIsolation = 'shared' | 'worktree';
+/**
+ * The integration state of an item's isolated worktree branch relative to the
+ * base branch (worktree mode only; absent/`'n-a'` in shared mode). Distinct
+ * from WorkItemState (the pipeline state): an item can be terminally `passed`
+ * while its merge is still `pending` in the integration lane, or `conflict`
+ * after the lane hit an unmergeable branch.
+ */
+export type ItemMergeState = 'n-a' | 'pending' | 'merged' | 'conflict';
+export interface BudgetCeiling {
+    readonly maxTokens?: number | undefined;
+    readonly maxCostUsd?: number | undefined;
+}
+/**
+ * Workstream-level provenance (BIG-3 item 1) — honest, machine-readable record
+ * of where a workstream's items came from when it was assembled from an
+ * approved PlanProposal by `fromPlanProposal` (proposal-workstream.ts). Absent
+ * on workstreams built the compat way (`fromChainSpec`) or authored directly.
+ * Carried through serialization and surfaced in status/fleet so a resumed or
+ * observed workstream reports its origin without guessing.
+ */
+export interface WorkstreamProvenance {
+    /** Whether a read-only planning agent decomposed the goal, or the heuristic single-item path did. Mirrors PlanProposal.decomposedBy. */
+    readonly decomposedBy?: 'agent' | 'heuristic' | undefined;
+    /** The id of the PlanProposal this workstream was assembled from. */
+    readonly proposalId?: string | undefined;
+    /** The proposal's execution strategy label (e.g. 'parallel', 'sequential'), for display. */
+    readonly strategy?: string | undefined;
+    /** Estimated dollar cost of the planning-agent decomposition run, when priced. */
+    readonly agentCostUsd?: number | undefined;
+    /** Wall-clock time the planning agent ran, in ms (when the agent path ran). */
+    readonly elapsedMs?: number | undefined;
+}
+export interface Workstream {
+    readonly id: string;
+    title: string;
+    readonly schemaVersion: number;
+    phases: Phase[];
+    items: WorkItem[];
+    /**
+     * Mutable (not readonly) specifically so `engine.updateBudget()` can raise,
+     * lower, or clear (`undefined`) the ceiling on a live workstream. Every
+     * update calls tick() immediately afterward, so any item already sitting
+     * in 'blocked-budget' gets reconsidered right away rather than waiting on
+     * an unrelated sibling to complete first.
+     */
+    budget?: BudgetCeiling | undefined;
+    /**
+     * Where item phases run their file changes (see {@link WorkstreamIsolation}).
+     * Absent is treated as `'shared'` everywhere — the default that preserves
+     * full behavioral back-compat. Persisted with the workstream and surfaced in
+     * events, so a resumed or observed workstream reports its isolation honestly.
+     */
+    readonly isolation?: WorkstreamIsolation | undefined;
+    /**
+     * Where this workstream's items came from (BIG-3 item 1). Set only when the
+     * workstream was assembled from an approved PlanProposal via
+     * `fromPlanProposal`; absent for compat/`fromChainSpec` or hand-authored
+     * workstreams. Persisted and surfaced for honest origin reporting.
+     */
+    readonly provenance?: WorkstreamProvenance | undefined;
+    readonly createdAt: number;
+}
+/** Outcome of running a phase's configured gates for one item. */
+export interface GateOutcome {
+    readonly passed: boolean;
+    readonly results: readonly QualityGateResult[];
+    readonly constraintFindings?: readonly ConstraintFinding[] | undefined;
+    readonly unsatisfiedConstraintIds?: readonly string[] | undefined;
+}
+/**
+ * Recorded on a PhaseResult when a scoped commit (Wave 6, wo-F item 4)
+ * excluded one or more candidate paths because they were already dirty
+ * before this engine run launched and this phase never actually touched
+ * them (see dirty-guard.ts's excludeUntouchedLaunchResidue). `skipped: true`
+ * means every candidate was excluded and no commit was attempted at all.
+ */
+export interface CommitExclusion {
+    readonly excludedPaths: readonly string[];
+    readonly skipped: boolean;
+}
+/**
+ * Honest record of the scoped-commit bookkeeping step that runs AFTER a
+ * phase's gate has already passed (see phase-runner.ts commitPhaseWork). The
+ * commit is a POST-gate step: its outcome never decides whether the phase
+ * passed — the gate already did that — it only reports what happened to the
+ * working tree afterward, so the fleet and transcript can state "committed
+ * <hash>" or "commit skipped/failed" without ever contradicting the phase
+ * verdict (DEBT-4 item 1). Present on a PhaseResult only when the gate passed
+ * and a commit was therefore attempted or deliberately skipped.
+ */
+export interface PhaseCommitOutcome {
+    readonly status: 'committed' | 'skipped' | 'failed';
+    /** The landed commit hash, present only for status 'committed'. */
+    readonly hash?: string | undefined;
+    /** Human-readable detail for 'skipped'/'failed', plus any gitignored-path note on 'committed'. */
+    readonly reason?: string | undefined;
+    /**
+     * True ONLY for a 'failed' commit whose failure belongs to the NEGATING SET —
+     * a bookkeeping failure (workspace/index corruption) that genuinely
+     * invalidates the phase's passed work. A negating commit failure is the one
+     * post-gate condition that DOES fail the item; every other commit failure is
+     * a non-fatal warning on a passed item. See bookkeeping.ts for the set.
+     */
+    readonly negating?: boolean | undefined;
+}
+/**
+ * The resume-cache unit, keyed (itemId,phaseId). On resume, every
+ * (itemId,phaseId) present in a snapshot's completedResults is hydrated
+ * without re-spawning — this is what makes prefix-replay possible.
+ */
+export interface PhaseResult {
+    readonly itemId: string;
+    readonly phaseId: string;
+    readonly agentId: string;
+    readonly report: CompletionReport;
+    readonly gate: GateOutcome;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly usage: WorkItemUsage;
+    /** Present only when a scoped commit excluded launch-dirty residue (see CommitExclusion). */
+    readonly commitExclusion?: CommitExclusion | undefined;
+    /**
+     * Outcome of the post-gate scoped-commit step (DEBT-4 item 1). Present only
+     * when this phase's gate passed and a commit was attempted or deliberately
+     * skipped; absent for a failed/cancelled phase (no commit is reached).
+     */
+    readonly commit?: PhaseCommitOutcome | undefined;
+}
+/** Snapshot shape written to .goodvibes/orchestration/<workstreamId>.json. */
+export interface WorkstreamSnapshot {
+    readonly schemaVersion: number;
+    readonly writtenAt: number;
+    readonly workstream: SerializedWorkstream;
+    readonly completedResults: readonly PhaseResult[];
+}
+/** JSON-safe mirror of Workstream (WorkItem.visits as an object, not a Map). */
+export interface SerializedWorkstream extends Omit<Workstream, 'items'> {
+    readonly items: readonly SerializedWorkItem[];
+}
+export interface SerializedWorkItem extends Omit<WorkItem, 'visits'> {
+    readonly visits: Record<string, number>;
+}
+export declare const CURRENT_WORKSTREAM_SCHEMA_VERSION = 1;
+/** Discriminated events the engine emits over its own lifecycle (persistence, budget, fleet). */
+export type OrchestrationEvent = {
+    readonly type: 'phase-inserted';
+    readonly workstreamId: string;
+    readonly phase: Phase;
+} | {
+    readonly type: 'item-advanced';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly fromPhaseId: string | null;
+    readonly toPhaseId: string | null;
+} | {
+    readonly type: 'item-blocked-budget';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly phaseId: string;
+    readonly reason: string;
+} | {
+    readonly type: 'item-cancelled';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly reason: string;
+} | {
+    readonly type: 'item-passed';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly warnings?: readonly string[] | undefined;
+} | {
+    readonly type: 'item-failed';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly reason: string;
+}
+/**
+ * Dependency-gating lifecycle (BIG-3 item 2). `item-blocked-dependency`
+ * fires once per NEW block (not every idle tick), naming the unmet
+ * dependencies by id in `deps` and carrying the current human-readable
+ * `reason` ('waiting on: …' or 'dependency failed: …'). `item-dependency-cleared`
+ * fires when a previously-blocked item's dependencies all reach passed and it
+ * is released back to the claimable set. `item-retried` fires when a
+ * terminally-failed item is deliberately reset to re-run via engine.retryItem
+ * — the documented recovery path that lets a failed dependency (and its
+ * stuck dependents) recover.
+ */
+ | {
+    readonly type: 'item-blocked-dependency';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly phaseId: string;
+    readonly reason: string;
+    readonly deps: readonly string[];
+} | {
+    readonly type: 'item-dependency-cleared';
+    readonly workstreamId: string;
+    readonly itemId: string;
+} | {
+    readonly type: 'item-retried';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly reason: string;
+}
+/** Emitted once per item on `importWorkstream` for every item reconciled from a crash-artifact 'in-phase' snapshot back to 'pending' — see the 'in-phase' state doc. */
+ | {
+    readonly type: 'item-requeued';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly reason: string;
+} | {
+    readonly type: 'workstream-persisted';
+    readonly workstreamId: string;
+}
+/**
+ * Worktree-isolation lifecycle events (worktree mode only). Each names the
+ * item and, where relevant, the on-disk worktree path and branch so an
+ * observer (TUI, transcript) can report isolation + merge state honestly and
+ * point at KEPT worktrees for inspection. None of these ever fire in shared
+ * mode.
+ */
+ | {
+    readonly type: 'item-worktree-created';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly path: string;
+    readonly branch: string;
+}
+/** A passed item's branch merged cleanly into the base branch through the integration lane. */
+ | {
+    readonly type: 'item-merged';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly branch: string;
+    readonly hash: string;
+}
+/**
+ * The integration lane could not merge a passed item's branch — the base
+ * merge conflicted. The worktree + branch are KEPT (never auto-resolved,
+ * never silently dropped); the lane continues with the next item.
+ */
+ | {
+    readonly type: 'item-merge-conflict';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly branch: string;
+    readonly path: string;
+    readonly files: readonly string[];
+}
+/** An item's worktree + branch were removed (merged item, or a clean tree after fail/kill). */
+ | {
+    readonly type: 'item-worktree-removed';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly path: string;
+}
+/**
+ * An item's worktree was deliberately KEPT rather than removed — a merge
+ * conflict, or a dirty tree left behind by a failed/killed item (data
+ * safety). `reason` states which; `path` is where the work still lives.
+ */
+ | {
+    readonly type: 'item-worktree-kept';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly path: string;
+    readonly reason: string;
+}
+/**
+ * A KEPT worktree was evicted (removed) to stay under the kept-worktree cap —
+ * oldest-first, and always announced (never a silent sweep). `path` is what
+ * was removed.
+ */
+ | {
+    readonly type: 'item-worktree-evicted';
+    readonly workstreamId: string;
+    readonly itemId: string;
+    readonly path: string;
+}
+/**
+ * Reconciliation of an orphaned `ws/*` worktree found at import (a crash
+ * artifact from a prior process). `disposition` is `'adopted'` when the
+ * engine re-attached it to a re-queued item, or `'reported'` when it belongs
+ * to no known item and was left in place for the operator (NEVER deleted on
+ * sight).
+ */
+ | {
+    readonly type: 'orphan-worktree-reconciled';
+    readonly workstreamId: string;
+    readonly path: string;
+    readonly branch: string;
+    readonly disposition: 'adopted' | 'reported';
+}
+/**
+ * Emitted once per engine instance (Wave 6, wo-F item 4), right after the
+ * launch-time dirty-tree snapshot resolves, ONLY when it is non-empty.
+ * Engine-wide, not workstream-scoped — `workstreamId` is absent (unlike
+ * every other variant above) because it fires before any workstream is
+ * necessarily even created. See dirty-guard.ts.
+ */
+ | {
+    readonly type: 'dirty-tree-at-launch';
+    readonly paths: readonly string[];
+};
+export type OrchestrationEventListener = (event: OrchestrationEvent) => void;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/types.ts"],"names":[],"mappings":"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"}

package/dist/platform/orchestration/types.js

@@ -0,0 +1,47 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export function emptyWorkItemUsage() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        llmCallCount: 0,
+        turnCount: 0,
+        toolCallCount: 0,
+        costUsd: null,
+        costState: 'unpriced',
+    };
+}
+/**
+ * Combine two usage rollups into one running total. The SINGLE canonical merge
+ * used everywhere a WorkItemUsage is accumulated — the phase-runner (folding a
+ * completed phase into an item), the engine (same, at the phase boundary), and
+ * the fleet rollup adapters (overlaying live in-flight usage onto committed
+ * totals). Keeping one implementation is what makes the rollup MONOTONE in
+ * presence: every count is summed (counts only grow) and a cost is retained
+ * via `??` whenever either operand carries one, so once a real token or cost
+ * value has appeared the merged result can never regress to absent/`null`
+ * (DEBT-4 item 2 — "updating" is a state, never a data wipe).
+ *
+ * Cost state stays honest rather than optimistic: 'priced' only when BOTH
+ * operands are priced; 'unpriced' only when NEITHER carries a cost; any mix is
+ * 'estimated' — a real partial sum, explicitly flagged as incomplete.
+ */
+export function mergeWorkItemUsage(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',
+    };
+}
+export const CURRENT_WORKSTREAM_SCHEMA_VERSION = 1;

package/dist/platform/orchestration/worktree-isolation.d.ts

@@ -0,0 +1,33 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { type CommitWorkingTreeResult } from '../agents/worktree.js';
+import type { OrchestrationEvent, WorkItem, Workstream } from './types.js';
+export interface WorktreeIsolationManagerDeps {
+    readonly projectRoot: string;
+    readonly emit: (event: OrchestrationEvent) => void;
+    readonly now?: (() => number) | undefined;
+    /** Bounds how many KEPT (conflict/dirty) worktrees are retained before oldest-first eviction. Default 20. */
+    readonly keptWorktreeCap?: number | undefined;
+}
+export interface ItemWorktreeHandle {
+    readonly path: string;
+    commit(message: string, paths?: string[]): Promise<CommitWorkingTreeResult>;
+}
+export interface WorktreeIsolationManager {
+    /** Ensure this item has a dedicated worktree (idempotent — created once, at first claim). Only meaningful when workstream.isolation === 'worktree'. */
+    ensureWorktree(workstream: Workstream, item: WorkItem): Promise<ItemWorktreeHandle>;
+    /**
+     * Enqueue a just-passed item's branch onto the sequential integration lane.
+     * Resolves once THIS item's attempt (merged/conflict/empty) and any
+     * resulting cleanup has settled. Callers that don't need to wait may let
+     * the returned promise run fire-and-forget (errors are caught internally —
+     * this never rejects).
+     */
+    enqueueIntegration(workstream: Workstream, item: WorkItem): Promise<void>;
+    /** Fail/kill cleanup rule: remove the item's worktree if clean, else KEEP it (data safety). No-op if the item never got a worktree. Never throws. */
+    cleanupTerminated(workstream: Workstream, item: WorkItem): Promise<void>;
+    /** Synchronous orphan scan — see the module doc. Call once, right after registering an imported workstream, before start()/tick(). */
+    reconcileOrphans(workstream: Workstream): void;
+}
+export declare function itemWorktreeBranch(workstreamId: string, itemId: string): string;
+export declare function createWorktreeIsolationManager(deps: WorktreeIsolationManagerDeps): WorktreeIsolationManager;
+//# sourceMappingURL=worktree-isolation.d.ts.map

package/dist/platform/orchestration/worktree-isolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-isolation.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/worktree-isolation.ts"],"names":[],"mappings":"AAAA,qFAAqF;AA+CrF,OAAO,EAAoB,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAGvF,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE3E,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACnD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,6GAA6G;IAC7G,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC7E;AAED,MAAM,WAAW,wBAAwB;IACvC,uJAAuJ;IACvJ,cAAc,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACpF;;;;;;OAMG;IACH,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,qJAAqJ;IACrJ,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzE,sIAAsI;IACtI,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;CAChD;AAUD,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE/E;AAaD,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,4BAA4B,GAAG,wBAAwB,CA4L3G"}