@pellux/goodvibes-sdk 0.37.2 → 1.0.0

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

@@ -0,0 +1,24 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { type OrchestrationEvent, type PhaseResult, type SerializedWorkstream, type Workstream, type WorkstreamSnapshot } from './types.js';
+export declare function serializeWorkstream(workstream: Workstream): SerializedWorkstream;
+export declare function deserializeWorkstream(serialized: SerializedWorkstream): Workstream;
+/** Mirrors WrfcController.serializeChain: JSON.stringify a schema-versioned envelope. Returns null on serialization failure rather than throwing. */
+export declare function serializeWorkstreamSnapshot(workstream: Workstream, completedResults: readonly PhaseResult[]): string | null;
+/**
+ * Mirrors WrfcController.deserializeChain's future-schemaVersion-reject
+ * guard: a snapshot written by a newer runtime is rejected (fail closed)
+ * rather than partially trusted.
+ */
+export declare function deserializeWorkstreamSnapshot(json: string): WorkstreamSnapshot | null;
+/** Read + quarantine-on-corrupt (never throws, never crashes the caller on a bad file). */
+export declare function loadWorkstreamSnapshot(projectRoot: string, workstreamId: string): WorkstreamSnapshot | null;
+/** List the workstream ids with a snapshot on disk (recognized or not — callers decide via loadWorkstreamSnapshot). */
+export declare function listSnapshotWorkstreamIds(projectRoot: string): string[];
+export declare function writeWorkstreamSnapshot(projectRoot: string, workstream: Workstream, completedResults: readonly PhaseResult[]): void;
+/**
+ * Debounced trailing writer (250ms, exactly like wrfc-persistence.ts
+ * DEBOUNCE_MS), subscribing to engine lifecycle events. Returns an
+ * unsubscribe function that also flushes any pending timers.
+ */
+export declare function attachDebouncedWriter(projectRoot: string, getWorkstream: (workstreamId: string) => Workstream | null, getCompletedResults: (workstreamId: string) => readonly PhaseResult[], subscribe: (listener: (event: OrchestrationEvent) => void) => () => void): () => void;
+//# sourceMappingURL=persistence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/persistence.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAerF,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAEhB,KAAK,oBAAoB,EAEzB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACxB,MAAM,YAAY,CAAC;AAepB,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,oBAAoB,CAEhF;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,oBAAoB,GAAG,UAAU,CAElF;AAED,qJAAqJ;AACrJ,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,GAAG,IAAI,CAa3H;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CA6BrF;AAUD,2FAA2F;AAC3F,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAsB3G;AAED,uHAAuH;AACvH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAWvE;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,CAUnI;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,UAAU,GAAG,IAAI,EAC1D,mBAAmB,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,SAAS,WAAW,EAAE,EACrE,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,KAAK,MAAM,IAAI,GACvE,MAAM,IAAI,CA4BZ"}

package/dist/platform/orchestration/persistence.js

@@ -0,0 +1,179 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Persistence (Wave 4, wo701) — mirrors the WrfcController chain seams
+ * exactly: serializeChain:323 / deserializeChain:345 (including the
+ * future-schemaVersion-reject guard at :364) / importChain:402. Writes to
+ * `.goodvibes/orchestration/<workstreamId>.json` — SEPARATE from the TUI's
+ * `.goodvibes/tui/wrfc-chains.json` (src/runtime/wrfc-persistence.ts), no
+ * path collision. Debounce (250ms) and corrupt-snapshot quarantine
+ * (`<path>.unrecognized`) mirror that same TUI module's conventions.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+import { CURRENT_WORKSTREAM_SCHEMA_VERSION, } from './types.js';
+const DEBOUNCE_MS = 250;
+function serializeWorkItem(item) {
+    return { ...item, visits: Object.fromEntries(item.visits) };
+}
+function deserializeWorkItem(raw) {
+    // `dependsOn` (BIG-3 item 2) defaults to [] for snapshots written before the
+    // field existed, so an older snapshot deserializes as an un-gated item rather
+    // than crashing the dependency pre-pass on an undefined array.
+    return { ...raw, dependsOn: raw.dependsOn ?? [], visits: new Map(Object.entries(raw.visits)) };
+}
+export function serializeWorkstream(workstream) {
+    return { ...workstream, items: workstream.items.map(serializeWorkItem) };
+}
+export function deserializeWorkstream(serialized) {
+    return { ...serialized, items: serialized.items.map(deserializeWorkItem) };
+}
+/** Mirrors WrfcController.serializeChain: JSON.stringify a schema-versioned envelope. Returns null on serialization failure rather than throwing. */
+export function serializeWorkstreamSnapshot(workstream, completedResults) {
+    const snapshot = {
+        schemaVersion: CURRENT_WORKSTREAM_SCHEMA_VERSION,
+        writtenAt: Date.now(),
+        workstream: serializeWorkstream(workstream),
+        completedResults,
+    };
+    try {
+        return JSON.stringify(snapshot);
+    }
+    catch (error) {
+        logger.error('orchestration persistence: JSON serialization failed', { workstreamId: workstream.id, error: summarizeError(error) });
+        return null;
+    }
+}
+/**
+ * Mirrors WrfcController.deserializeChain's future-schemaVersion-reject
+ * guard: a snapshot written by a newer runtime is rejected (fail closed)
+ * rather than partially trusted.
+ */
+export function deserializeWorkstreamSnapshot(json) {
+    let raw;
+    try {
+        raw = JSON.parse(json);
+    }
+    catch (error) {
+        logger.error('orchestration persistence: JSON parse failed', { error: summarizeError(error) });
+        return null;
+    }
+    if (raw === null || typeof raw !== 'object') {
+        logger.warn('orchestration persistence: invalid snapshot JSON — not an object');
+        return null;
+    }
+    const candidate = raw;
+    if (typeof candidate.schemaVersion !== 'number') {
+        logger.warn('orchestration persistence: invalid snapshot JSON — missing schemaVersion');
+        return null;
+    }
+    if (candidate.schemaVersion > CURRENT_WORKSTREAM_SCHEMA_VERSION) {
+        logger.error('orchestration persistence: future schemaVersion rejected — upgrade runtime to read this snapshot', {
+            schemaVersion: candidate.schemaVersion,
+            supportedVersion: CURRENT_WORKSTREAM_SCHEMA_VERSION,
+        });
+        return null;
+    }
+    if (!candidate.workstream || typeof candidate.workstream !== 'object' || !Array.isArray(candidate.completedResults)) {
+        logger.warn('orchestration persistence: invalid snapshot JSON — missing workstream/completedResults');
+        return null;
+    }
+    return candidate;
+}
+function orchestrationDir(projectRoot) {
+    return join(projectRoot, '.goodvibes', 'orchestration');
+}
+function snapshotPath(projectRoot, workstreamId) {
+    return join(orchestrationDir(projectRoot), `${workstreamId}.json`);
+}
+/** Read + quarantine-on-corrupt (never throws, never crashes the caller on a bad file). */
+export function loadWorkstreamSnapshot(projectRoot, workstreamId) {
+    const path = snapshotPath(projectRoot, workstreamId);
+    if (!existsSync(path))
+        return null;
+    let text;
+    try {
+        text = readFileSync(path, 'utf-8');
+    }
+    catch (error) {
+        logger.warn('orchestration persistence: snapshot read failed', { path, error: summarizeError(error) });
+        return null;
+    }
+    const snapshot = deserializeWorkstreamSnapshot(text);
+    if (snapshot === null) {
+        const quarantinePath = `${path}.unrecognized`;
+        try {
+            renameSync(path, quarantinePath);
+            logger.warn('orchestration persistence: quarantined unrecognized snapshot', { path, quarantinePath });
+        }
+        catch (error) {
+            logger.error('orchestration persistence: failed to quarantine unrecognized snapshot', { path, error: summarizeError(error) });
+        }
+        return null;
+    }
+    return snapshot;
+}
+/** List the workstream ids with a snapshot on disk (recognized or not — callers decide via loadWorkstreamSnapshot). */
+export function listSnapshotWorkstreamIds(projectRoot) {
+    const dir = orchestrationDir(projectRoot);
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter((entry) => entry.endsWith('.json'))
+            .map((entry) => entry.slice(0, -'.json'.length));
+    }
+    catch (error) {
+        logger.warn('orchestration persistence: failed to list snapshot directory', { dir, error: summarizeError(error) });
+        return [];
+    }
+}
+export function writeWorkstreamSnapshot(projectRoot, workstream, completedResults) {
+    const json = serializeWorkstreamSnapshot(workstream, completedResults);
+    if (json === null)
+        return;
+    const path = snapshotPath(projectRoot, workstream.id);
+    try {
+        mkdirSync(orchestrationDir(projectRoot), { recursive: true });
+        writeFileSync(path, json, 'utf-8');
+    }
+    catch (error) {
+        logger.error('orchestration persistence: snapshot write failed', { path, error: summarizeError(error) });
+    }
+}
+/**
+ * Debounced trailing writer (250ms, exactly like wrfc-persistence.ts
+ * DEBOUNCE_MS), subscribing to engine lifecycle events. Returns an
+ * unsubscribe function that also flushes any pending timers.
+ */
+export function attachDebouncedWriter(projectRoot, getWorkstream, getCompletedResults, subscribe) {
+    const timers = new Map();
+    function scheduleWrite(workstreamId) {
+        const existing = timers.get(workstreamId);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            timers.delete(workstreamId);
+            const workstream = getWorkstream(workstreamId);
+            if (!workstream)
+                return;
+            writeWorkstreamSnapshot(projectRoot, workstream, getCompletedResults(workstreamId));
+        }, DEBOUNCE_MS);
+        timer.unref?.();
+        timers.set(workstreamId, timer);
+    }
+    const unsubscribe = subscribe((event) => {
+        // 'dirty-tree-at-launch' (Wave 6, wo-F item 4) is engine-wide, not
+        // workstream-scoped — it has no workstreamId to schedule a write for.
+        if (event.type === 'dirty-tree-at-launch')
+            return;
+        scheduleWrite(event.workstreamId);
+    });
+    return () => {
+        unsubscribe();
+        for (const timer of timers.values())
+            clearTimeout(timer);
+        timers.clear();
+    };
+}

package/dist/platform/orchestration/phase-runner.d.ts

@@ -0,0 +1,114 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Phase-runner (Wave 4, wo701) — runs one WorkItem through one Phase: spawn
+ * agent, await completion, verify claims, run gates, commit, cleanup.
+ *
+ * REUSES the hardened WRFC primitives verbatim (same functions WrfcController
+ * itself calls, so behavior can't fork): verifyEngineerClaims
+ * (wrfc-reporting.ts) for the phantom-work guard, runWrfcGateChecks
+ * (wrfc-gate-runtime.ts) for quality gates, AgentWorktree.commitWorkingTree
+ * for scoped commits, and the transport-retry / WrfcChainFailureKind pattern
+ * (isTransportFailureMessage + getWrfcTransportRetryLimit/DelayMs) for
+ * bounded respawn-on-transport-blip.
+ *
+ * REALITY-WINS DIVERGENCE from the brief's design (c): WrfcController itself
+ * (wrfc-controller.ts, verified) never calls AgentWorktree.create() for its
+ * role agents — engineer/reviewer/fixer/integrator all run in the SAME
+ * shared `projectRoot` working directory; AgentWorktree is used ONLY for its
+ * commitWorkingTree/merge/cleanup surface (merge/cleanup are safe no-ops
+ * when no isolated worktree dir exists, which is always, today). There is no
+ * per-agent `workingDirectory` override anywhere in AgentInput /
+ * AgentOrchestratorRunContext.createRunContext() (verified: the latter is
+ * fixed per AgentOrchestrator instance, not per-spawn), so a spawned agent
+ * cannot actually be pointed at an isolated worktree directory without new
+ * cross-cutting plumbing through AgentManager/AgentOrchestrator construction
+ * — well beyond this module's boundary, and not something WrfcController
+ * itself has either. This module therefore mirrors WrfcController's ACTUAL
+ * (shared-directory) behavior rather than the brief's aspirational
+ * per-item-isolated-worktree fan-out; true fan-out isolation is a valuable,
+ * separately-scoped follow-up (see the work-order report).
+ *
+ * SECOND REALITY-WINS DIVERGENCE: AgentManager.spawn()'s root-spawn
+ * normalization (tools/agent/wrfc-batch-policy.ts isRootReviewRoleTask) force
+ * -rewrites any PARENTLESS spawn whose template is literally
+ * reviewer/tester/verifier/qa/review/test, OR whose task text matches
+ * ROLE_ACTION_RE/ROLE_PREFIX_RE (e.g. "review the diff"), into an
+ * 'engineer'-templated WRFC-owner chain with `dangerously_disable_wrfc`
+ * forced back to `false` — REGARDLESS of what this module passes in.
+ * Phase-runner spawns are always parentless (a workstream has no owning
+ * AgentRecord), so it must dodge that heuristic by construction: never
+ * literally template review/test-flavored phases as one of those role
+ * strings (use 'general' instead — see templateForPhase), and phrase
+ * review-phase prompts with "assess/evaluate" rather than "review/test/
+ * verify" (see buildPhaseTask). This is load-bearing: changing this wording
+ * without checking wrfc-batch-policy.ts's regexes again risks silently
+ * re-activating the WRFC hijack for review-kind phases.
+ */
+import type { AgentManager } from '../tools/agent/manager.js';
+import type { ConfigManager } from '../config/manager.js';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import { type CommitWorkingTreeResult } from '../agents/worktree.js';
+import type { CancellationRegistry } from './cancellation.js';
+import { type DirtyLaunchSnapshot } from './dirty-guard.js';
+import type { Phase, PhaseResult, WorkItem, WorkItemUsage, Workstream } from './types.js';
+/** Narrow structural pick — testable with stubs, mirrors AgentManagerLike (wrfc-config.ts). */
+export type PhaseRunnerAgentManagerLike = Pick<AgentManager, 'spawn' | 'getStatus' | 'cancel' | 'registerCancellationSignal' | 'releaseCancellationSignal'>;
+/** Structural pick of AgentWorktree's surface — matches WrfcController's WrfcWorktreeOps injection seam exactly, so the same test doubles work for both. */
+export interface WrfcWorktreeOps {
+    merge(agentId: string): Promise<boolean>;
+    cleanup(agentId: string): Promise<void>;
+    commitWorkingTree(message: string, paths?: string[]): Promise<CommitWorkingTreeResult>;
+    currentHead(): Promise<string | null>;
+}
+/**
+ * The minimal surface of an item's IsolatedWorktree (worktree.ts) that the
+ * phase-runner needs in `worktree` isolation mode: the on-disk `path` (used as
+ * the spawned agent's working directory) and a scoped `commit` onto the item
+ * branch. Notably NOT merge/cleanup — in worktree mode the item worktree
+ * persists across the item's phases and the engine's sequential integration
+ * lane owns the merge-back and cleanup, so a phase NEVER merges to base or
+ * removes the worktree.
+ */
+export interface PhaseItemWorktree {
+    readonly path: string;
+    commit(message: string, paths?: string[]): Promise<CommitWorkingTreeResult>;
+}
+export interface PhaseRunnerDeps {
+    readonly agentManager: PhaseRunnerAgentManagerLike;
+    readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
+    readonly runtimeBus: RuntimeEventBus;
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly createWorktree?: (() => WrfcWorktreeOps) | undefined;
+    readonly cancellation: CancellationRegistry;
+    readonly priceUsage?: ((model: string | undefined, usage: WorkItemUsage) => number | null) | undefined;
+    readonly skipClaimVerification?: boolean | undefined;
+    /**
+     * The dirty-tree snapshot taken synchronously at engine launch (Wave 6,
+     * wo-F item 4 — see dirty-guard.ts). Absent (undefined) degrades to
+     * today's behavior: no exclusion, every candidate path is committed.
+     */
+    readonly launchDirtySnapshot?: DirtyLaunchSnapshot | undefined;
+    /**
+     * Present ONLY in `worktree` isolation mode: this item's dedicated worktree
+     * (created by the engine at first claim). When set, the phase's scoped commit
+     * lands on the item branch INSIDE this worktree (not the shared projectRoot),
+     * and the spawned agent runs with its working directory set to the worktree
+     * path. Absent ⇒ shared mode, every existing behavior unchanged.
+     */
+    readonly itemWorktree?: PhaseItemWorktree | undefined;
+}
+export interface PhaseRunOutcome {
+    readonly result: PhaseResult;
+    readonly agentStatus: 'completed' | 'failed' | 'cancelled';
+}
+/**
+ * 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 declare function mergeUsage(a: WorkItemUsage, b: WorkItemUsage): WorkItemUsage;
+/** Runs one WorkItem through one Phase to completion (or cancellation/failure). Recurses (bounded by transportRetryLimit) on a transport-classified spawn failure. */
+export declare function runPhase(workstream: Workstream, item: WorkItem, phase: Phase, priorReports: readonly PhaseResult[], deps: PhaseRunnerDeps): Promise<PhaseRunOutcome>;
+//# sourceMappingURL=phase-runner.d.ts.map

package/dist/platform/orchestration/phase-runner.d.ts.map

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