@pellux/goodvibes-sdk 0.37.1 → 0.38.0

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

@@ -0,0 +1,31 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Per-work-item cancellation registry (Wave 4, wo701) — the deferred W0.1
+ * cooperative-cancellation piece.
+ *
+ * One AbortController per in-flight WorkItem. `engine.kill(itemId)` aborts
+ * the controller here AND calls `agentManager.cancel(agentId, 'kill')` — the
+ * same mechanism every agent in the system already uses to stop at its next
+ * turn boundary (orchestrator-runner.ts's `record.status === 'cancelled'`
+ * poll). That covers "no orphaned AGENT" unconditionally.
+ *
+ * The AbortSignal this registry hands out is ALSO registered on AgentManager
+ * (registerCancellationSignal) so opted-in tools (exec, fetch) can abort an
+ * in-flight child process/request immediately instead of waiting for that
+ * turn boundary — see AgentManager.getCancellationSignal /
+ * AgentOrchestrator.setCancellationSource / orchestrator-runner.ts's
+ * `context.getCancellationSignal?.(record.id)` threaded into
+ * `toolRegistry.execute` opts.
+ */
+export interface CancellationRegistry {
+    /** Create (replacing any prior registration) the controller for a work item and return its signal. */
+    start(itemId: string): AbortSignal;
+    /** Abort the item's controller, if one is registered. Returns false when nothing was registered (already terminal, or never started). */
+    abort(itemId: string): boolean;
+    /** Drop the registration once the item's phase run has ended (success, failure, or cancel). Safe to call unconditionally. */
+    release(itemId: string): void;
+    /** True when this item currently has a live (non-aborted) registration. */
+    isActive(itemId: string): boolean;
+}
+export declare function createCancellationRegistry(): CancellationRegistry;
+//# sourceMappingURL=cancellation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cancellation.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/cancellation.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,oBAAoB;IACnC,sGAAsG;IACtG,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC;IACnC,yIAAyI;IACzI,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,6HAA6H;IAC7H,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;CACnC;AAED,wBAAgB,0BAA0B,IAAI,oBAAoB,CA2BjE"}

package/dist/platform/orchestration/cancellation.js

@@ -0,0 +1,25 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export function createCancellationRegistry() {
+    const controllers = new Map();
+    function start(itemId) {
+        controllers.get(itemId)?.abort();
+        const controller = new AbortController();
+        controllers.set(itemId, controller);
+        return controller.signal;
+    }
+    function abort(itemId) {
+        const controller = controllers.get(itemId);
+        if (!controller)
+            return false;
+        controller.abort();
+        return true;
+    }
+    function release(itemId) {
+        controllers.delete(itemId);
+    }
+    function isActive(itemId) {
+        const controller = controllers.get(itemId);
+        return controller !== undefined && !controller.signal.aborted;
+    }
+    return { start, abort, release, isActive };
+}

package/dist/platform/orchestration/controller-compat.d.ts

@@ -0,0 +1,32 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Controller-compat (Wave 4, wo701) — stage 1 of the 3-stage WrfcController
+ * migration (see design doc (g) and the work-order report's design-
+ * divergences section).
+ *
+ * `fromChainSpec()` produces the canned two-phase engineer->review
+ * WORKSTREAM SPEC that a `WrfcController.createChain(ownerRecord)` call
+ * would otherwise start — a NEW opt-in surface for callers that want the
+ * engine-backed pipeline. It returns a `CreateWorkstreamInput` (a spec), not
+ * a live `Workstream`: realizing one (generated ids, initialized item
+ * state) is the engine's own responsibility via
+ * `engine.createWorkstream(fromChainSpec(...))`, mirroring how the type
+ * model already separates PhaseSpec/WorkItemSpec (input) from Phase/WorkItem
+ * (engine-owned state).
+ *
+ * STAGE 1 (this wave, unchanged): WrfcController itself is NOT touched.
+ * spawn-forced-wrfc, /teamwork, and archetypes all keep hitting
+ * WrfcController.createChain via AgentManager.manager.ts:565 exactly as
+ * before. This function is additive only.
+ * STAGE 2 (later, feature-flagged): WrfcController.createChain internally
+ * builds a workstream via this same helper and delegates execution to the
+ * engine — the public seam (createChain's signature and the three entry
+ * points) stays byte-for-byte unchanged.
+ * STAGE 3 (future wave): retire the standalone WrfcController state machine
+ * once parity is proven.
+ */
+import type { AgentRecord } from '../tools/agent/manager.js';
+import type { ConfigManager } from '../config/manager.js';
+import type { CreateWorkstreamInput } from './engine.js';
+export declare function fromChainSpec(ownerRecord: Pick<AgentRecord, 'id' | 'task'>, configManager: Pick<ConfigManager, 'get' | 'getCategory'>): CreateWorkstreamInput;
+//# sourceMappingURL=controller-compat.d.ts.map

package/dist/platform/orchestration/controller-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-compat.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/controller-compat.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,wBAAgB,aAAa,CAC3B,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,MAAM,CAAC,EAC7C,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,aAAa,CAAC,GACxD,qBAAqB,CAUvB"}

package/dist/platform/orchestration/controller-compat.js

@@ -0,0 +1,13 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { getWrfcCommitScope } from '../agents/wrfc-config.js';
+export function fromChainSpec(ownerRecord, configManager) {
+    const commitScope = getWrfcCommitScope(configManager);
+    return {
+        title: ownerRecord.task,
+        items: [{ id: ownerRecord.id, title: ownerRecord.task, task: ownerRecord.task }],
+        phases: [
+            { role: 'engineer', capacity: 1, kind: 'engineer', gate: { scope: commitScope, gates: [] } },
+            { role: 'reviewer', capacity: 1, kind: 'review', gate: { scope: commitScope, gates: [] } },
+        ],
+    };
+}

package/dist/platform/orchestration/dirty-guard.d.ts

@@ -0,0 +1,32 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/** Content hash of a file's current working-tree bytes. Binary-safe (raw bytes, not text). Returns null when the path does not exist on disk (a working-tree deletion). */
+export declare function hashWorkingTreeFile(cwd: string, relativePath: string): string | null;
+/** path -> content hash at launch (null = the dirty path did not exist on disk, e.g. an unstaged deletion). */
+export type DirtyLaunchSnapshot = ReadonlyMap<string, string | null>;
+/**
+ * Snapshot every dirty path (staged + unstaged + untracked) in `cwd`'s
+ * working tree right now, each with a content hash. Call once at engine
+ * launch, before any phase of this run has had a chance to touch anything.
+ * Never throws: a git failure (e.g. `cwd` is not a repo) degrades to an
+ * empty snapshot, which makes the exclusion guard a no-op (today's
+ * behavior) rather than blocking commits.
+ */
+export declare function snapshotDirtyTree(cwd: string): DirtyLaunchSnapshot;
+/** Result of partitioning a scoped commit's candidate paths against the launch snapshot. */
+export interface ScopedCommitExclusion {
+    readonly included: readonly string[];
+    readonly excluded: readonly string[];
+}
+/**
+ * Partition `candidatePaths` into paths safe to include in a scoped commit
+ * vs. paths that must be excluded because they are untouched launch-dirty
+ * residue. A path is excluded only when BOTH:
+ *  - it appears in `launchSnapshot` (it was already dirty before this run), AND
+ *  - its current content hash equals the hash recorded at launch (this run
+ *    never actually changed it).
+ * Everything else is included — a path absent from the snapshot was clean
+ * at launch (this run is what dirtied it), and a path whose hash changed
+ * was genuinely touched by this run even though it started out dirty.
+ */
+export declare function excludeUntouchedLaunchResidue(cwd: string, candidatePaths: readonly string[], launchSnapshot: DirtyLaunchSnapshot): ScopedCommitExclusion;
+//# sourceMappingURL=dirty-guard.d.ts.map

package/dist/platform/orchestration/dirty-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirty-guard.d.ts","sourceRoot":"","sources":["../../../src/platform/orchestration/dirty-guard.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAsCrF,2KAA2K;AAC3K,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYpF;AAED,+GAA+G;AAC/G,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;AAyCrE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAalE;AAED,4FAA4F;AAC5F,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,cAAc,EAAE,mBAAmB,GAClC,qBAAqB,CAiBvB"}

package/dist/platform/orchestration/dirty-guard.js

@@ -0,0 +1,147 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Dirty-residue guard (Wave 6, wo-F item 4) — prevents an orchestration
+ * engine run's scoped commit from sweeping in uncommitted changes that were
+ * ALREADY sitting in the working tree before this engine launched (typically
+ * residue left behind by a previously killed run sharing the same
+ * `projectRoot`, since phase-runner.ts's WorkItem.touchedPaths accumulates
+ * across phases/retries and never resets — see phase-runner.ts runPhase).
+ *
+ * Mechanism: snapshot every dirty path + a binary-safe content hash at
+ * engine-launch time (`snapshotDirtyTree`). At scoped-commit time, a
+ * candidate path is excluded only when it was ALREADY dirty at launch AND
+ * its content hash is unchanged since launch — i.e. this run never touched
+ * it. A path that was clean at launch, or whose hash changed, is included:
+ * this run is the one that dirtied (or re-dirtied) it.
+ *
+ * `snapshotDirtyTree` is deliberately SYNCHRONOUS (Bun.spawnSync, mirroring
+ * GitService's own sync helpers — initRepo/isGitRepo/getRepoRoot,
+ * platform/git/service.ts) rather than shelling out through simple-git's
+ * async API: the engine factory (engine.ts) is a synchronous function that
+ * must have a settled snapshot before its first phase can possibly reach a
+ * commit, and a promise backed by real child-process I/O cannot be relied
+ * on to resolve within a caller's microtask-only wait (subprocess exit is
+ * delivered via the event loop's macrotask phases, not microtasks) — a real
+ * regression seen against tests that only drain microtasks. One blocking
+ * `git status` call at launch (paid once, exactly like GitService.initRepo)
+ * avoids that whole class of timing hazard entirely.
+ */
+import { createHash } from 'node:crypto';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+/** Dirty paths under this prefix are GoodVibes' own internal state, never a candidate for a scoped commit — excluded from the snapshot so they never pollute the 'dirty-tree-at-launch' event. */
+const INTERNAL_STATE_PREFIX = '.goodvibes/';
+/** Content hash of a file's current working-tree bytes. Binary-safe (raw bytes, not text). Returns null when the path does not exist on disk (a working-tree deletion). */
+export function hashWorkingTreeFile(cwd, relativePath) {
+    const absolutePath = join(cwd, relativePath);
+    if (!existsSync(absolutePath))
+        return null;
+    try {
+        return createHash('sha256').update(readFileSync(absolutePath)).digest('hex');
+    }
+    catch (error) {
+        logger.warn('orchestration dirty-guard: failed to hash working-tree file', {
+            path: relativePath,
+            error: summarizeError(error),
+        });
+        return null;
+    }
+}
+/**
+ * Parse `git status --porcelain -z --untracked-files=all` output into a set of
+ * paths. The `-z` (NUL-terminated) format is used deliberately because it emits
+ * paths VERBATIM: git's default porcelain C-quotes any path containing
+ * non-ASCII or special bytes (core.quotePath defaults to true), rendering
+ * `café.txt` as `"caf\303\251.txt"`. Keying the launch snapshot on that quoted
+ * string while excludeUntouchedLaunchResidue / hashWorkingTreeFile receive the
+ * RAW path would silently bypass exclusion (residue leaks into scoped commits)
+ * and make the content hash read the wrong (nonexistent, quoted) filename. With
+ * `-z` there is no quoting, so snapshot keys match the raw paths used
+ * everywhere else.
+ *
+ * Record shape: each NUL-terminated record is `XY<space><path>`. A rename or
+ * copy (X or Y is 'R'/'C') is split across TWO NUL-terminated fields — the
+ * destination first, then the origin. We keep the destination (the actual
+ * scoped-commit candidate, already in this record) and consume the following
+ * origin field so it is never mis-parsed as its own dirty path.
+ */
+function parsePorcelainPaths(output) {
+    const paths = new Set();
+    const records = output.split('\0');
+    for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        // Skips the trailing empty field left by the final NUL, plus any record too
+        // short to hold a 2-char status pair + separator + a 1-char path.
+        if (record.length < 4)
+            continue;
+        const x = record[0];
+        const y = record[1];
+        // A rename/copy record is followed by a second NUL-separated field (the
+        // origin path). Consume it so the next iteration does not treat it as a
+        // standalone status record — done before any early-continue below.
+        if (x === 'R' || y === 'R' || x === 'C' || y === 'C')
+            i++;
+        const path = record.slice(3);
+        if (path.startsWith(INTERNAL_STATE_PREFIX))
+            continue;
+        paths.add(path);
+    }
+    return paths;
+}
+/**
+ * Snapshot every dirty path (staged + unstaged + untracked) in `cwd`'s
+ * working tree right now, each with a content hash. Call once at engine
+ * launch, before any phase of this run has had a chance to touch anything.
+ * Never throws: a git failure (e.g. `cwd` is not a repo) degrades to an
+ * empty snapshot, which makes the exclusion guard a no-op (today's
+ * behavior) rather than blocking commits.
+ */
+export function snapshotDirtyTree(cwd) {
+    try {
+        const result = Bun.spawnSync(['git', '-C', cwd, 'status', '--porcelain', '-z', '--untracked-files=all']);
+        if (result.exitCode !== 0)
+            return new Map();
+        const output = new TextDecoder().decode(result.stdout);
+        const paths = parsePorcelainPaths(output);
+        const snapshot = new Map();
+        for (const path of paths)
+            snapshot.set(path, hashWorkingTreeFile(cwd, path));
+        return snapshot;
+    }
+    catch (error) {
+        logger.warn('orchestration dirty-guard: failed to snapshot dirty tree at launch', { error: summarizeError(error) });
+        return new Map();
+    }
+}
+/**
+ * Partition `candidatePaths` into paths safe to include in a scoped commit
+ * vs. paths that must be excluded because they are untouched launch-dirty
+ * residue. A path is excluded only when BOTH:
+ *  - it appears in `launchSnapshot` (it was already dirty before this run), AND
+ *  - its current content hash equals the hash recorded at launch (this run
+ *    never actually changed it).
+ * Everything else is included — a path absent from the snapshot was clean
+ * at launch (this run is what dirtied it), and a path whose hash changed
+ * was genuinely touched by this run even though it started out dirty.
+ */
+export function excludeUntouchedLaunchResidue(cwd, candidatePaths, launchSnapshot) {
+    const included = [];
+    const excluded = [];
+    for (const path of candidatePaths) {
+        if (!launchSnapshot.has(path)) {
+            included.push(path);
+            continue;
+        }
+        const hashAtLaunch = launchSnapshot.get(path) ?? null;
+        const hashNow = hashWorkingTreeFile(cwd, path);
+        if (hashAtLaunch === hashNow) {
+            excluded.push(path);
+        }
+        else {
+            included.push(path);
+        }
+    }
+    return { included, excluded };
+}

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

@@ -0,0 +1,57 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { PhaseRunnerAgentManagerLike, WrfcWorktreeOps } from './phase-runner.js';
+import { type BudgetCeiling, type OrchestrationEventListener, type Phase, type PhaseResult, type PhaseSpec, type WorkItemSpec, type WorkItemUsage, type Workstream } from './types.js';
+import type { ConfigManager } from '../config/manager.js';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+export interface OrchestrationEngineDeps {
+    readonly agentManager: PhaseRunnerAgentManagerLike;
+    readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
+    readonly runtimeBus: RuntimeEventBus;
+    readonly projectRoot: string;
+    readonly sessionId?: string | undefined;
+    readonly createWorktree?: (() => WrfcWorktreeOps) | undefined;
+    readonly priceUsage?: ((model: string | undefined, usage: WorkItemUsage) => number | null) | undefined;
+    readonly skipClaimVerification?: boolean | undefined;
+    /** Bounds re-review cycles through a dynamically-inserted fix phase. Default 5 (mirrors WrfcController's default maxFixAttempts). */
+    readonly maxPhaseVisits?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    /** Set false to skip wiring the debounced disk writer (tests that don't want filesystem side effects). Default true. */
+    readonly persist?: boolean | undefined;
+}
+export interface CreateWorkstreamInput {
+    readonly id?: string | undefined;
+    readonly title: string;
+    readonly phases: readonly PhaseSpec[];
+    readonly items: readonly WorkItemSpec[];
+    readonly budget?: BudgetCeiling | undefined;
+}
+export interface OrchestrationEngine {
+    createWorkstream(input: CreateWorkstreamInput): Workstream;
+    getWorkstream(id: string): Workstream | null;
+    listWorkstreams(): Workstream[];
+    insertPhase(workstreamId: string, afterOrdinal: number, spec: PhaseSpec): Phase | null;
+    /** Begin (or resume ticking) a workstream's pipeline. Idempotent — safe to call on an already-running workstream. */
+    start(workstreamId: string): void;
+    /** Abort a work item's in-flight agent (if any) and mark it terminally failed. Never affects sibling items. */
+    kill(itemId: string): boolean;
+    /**
+     * Replace (or clear, via `undefined`) a workstream's budget ceiling and
+     * immediately re-tick it, so any item already sitting in 'blocked-budget'
+     * gets reconsidered right away — the only recovery path for that state
+     * (see WorkItemState's 'blocked-budget' doc, types.ts). Returns false if
+     * the workstream doesn't exist.
+     */
+    updateBudget(workstreamId: string, ceiling: BudgetCeiling | undefined): boolean;
+    getPhaseResults(workstreamId: string): readonly PhaseResult[];
+    serializeWorkstream(workstreamId: string): string | null;
+    /** Import a serialized snapshot (a full WorkstreamSnapshot JSON string, see persistence.ts). Refuses to overwrite a non-terminal in-memory workstream unless force=true. */
+    importWorkstream(snapshotJson: string, force?: boolean): boolean;
+    /** Import + start from the on-disk snapshot for one workstream id. */
+    resumeWorkstream(workstreamId: string): boolean;
+    /** Import + start every snapshot under .goodvibes/orchestration/. Returns the count resumed. */
+    resumeAllFromDisk(): number;
+    on(listener: OrchestrationEventListener): () => void;
+    dispose(): void;
+}
+export declare function createOrchestrationEngine(deps: OrchestrationEngineDeps): OrchestrationEngine;
+//# sourceMappingURL=engine.d.ts.map

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

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