@exaudeus/workrail 3.75.0 → 3.77.0

package/dist/daemon/startup-recovery.js

@@ -0,0 +1,323 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDaemonSessionState = readDaemonSessionState;
+exports.readAllDaemonSessions = readAllDaemonSessions;
+exports.runStartupRecovery = runStartupRecovery;
+exports.countOrphanStepAdvances = countOrphanStepAdvances;
+exports.clearQueueIssueSidecars = clearQueueIssueSidecars;
+require("reflect-metadata");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const index_js_1 = require("../mcp/handlers/v2-execution/index.js");
+const v2_token_ops_js_1 = require("../mcp/handlers/v2-token-ops.js");
+const index_js_2 = require("../v2/durable-core/ids/index.js");
+const assert_never_js_1 = require("../runtime/assert-never.js");
+const session_recovery_policy_js_1 = require("./session-recovery-policy.js");
+const _shared_js_1 = require("./tools/_shared.js");
+const workflow_runner_js_1 = require("./workflow-runner.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
+const MAX_WORKTREE_ORPHAN_AGE_MS = 24 * 60 * 60 * 1000;
+async function readDaemonSessionState(sessionId) {
+    const sessionPath = path.join(_shared_js_1.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
+    try {
+        const raw = await fs.readFile(sessionPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return { continueToken: parsed.continueToken, checkpointToken: parsed.checkpointToken };
+    }
+    catch {
+        return null;
+    }
+}
+async function readAllDaemonSessions(sessionsDir = _shared_js_1.DAEMON_SESSIONS_DIR) {
+    let entries;
+    try {
+        entries = await fs.readdir(sessionsDir);
+    }
+    catch (err) {
+        const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+        if (!isEnoent) {
+            console.warn(`[WorkflowRunner] Could not read sessions directory ${sessionsDir}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return [];
+    }
+    const sessions = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json') || entry.startsWith('queue-issue-'))
+            continue;
+        const sessionId = entry.slice(0, -5);
+        const filePath = path.join(sessionsDir, entry);
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.continueToken !== 'string' || typeof parsed.ts !== 'number') {
+                console.warn(`[WorkflowRunner] Skipping malformed session file: ${filePath}`);
+                continue;
+            }
+            sessions.push({
+                sessionId,
+                continueToken: parsed.continueToken,
+                checkpointToken: typeof parsed.checkpointToken === 'string' ? parsed.checkpointToken : null,
+                ts: parsed.ts,
+                ...(typeof parsed.worktreePath === 'string' ? { worktreePath: parsed.worktreePath } : {}),
+                ...(typeof parsed.workflowId === 'string' ? { workflowId: parsed.workflowId } : {}),
+                ...(typeof parsed.goal === 'string' ? { goal: parsed.goal } : {}),
+                ...(typeof parsed.workspacePath === 'string' ? { workspacePath: parsed.workspacePath } : {}),
+            });
+        }
+        catch (err) {
+            console.warn(`[WorkflowRunner] Skipping unreadable session file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return sessions;
+}
+async function runStartupRecovery(sessionsDir = _shared_js_1.DAEMON_SESSIONS_DIR, execFn = execFileAsync, ctx, _countStepAdvancesFn = countOrphanStepAdvances, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, _runWorkflowFn = workflow_runner_js_1.runWorkflow, apiKey = '') {
+    await clearQueueIssueSidecars(sessionsDir);
+    const sessions = await readAllDaemonSessions(sessionsDir);
+    if (sessions.length === 0) {
+        await clearStrayTmpFiles(sessionsDir);
+        return;
+    }
+    console.log(`[WorkflowRunner] Startup recovery: found ${sessions.length} orphaned session(s).`);
+    const now = Date.now();
+    let cleared = 0;
+    let preserved = 0;
+    for (const session of sessions) {
+        const ageMs = now - session.ts;
+        const isStale = ageMs > MAX_ORPHAN_AGE_MS;
+        const ageSec = Math.round(ageMs / 1000);
+        if (session.worktreePath && ageMs > MAX_WORKTREE_ORPHAN_AGE_MS) {
+            console.log(`[WorkflowRunner] Removing orphan worktree: sessionId=${session.sessionId} worktreePath=${session.worktreePath}`);
+            try {
+                await execFn('git', ['worktree', 'remove', '--force', session.worktreePath]);
+                console.log(`[WorkflowRunner] Removed orphan worktree: ${session.worktreePath}`);
+            }
+            catch (err) {
+                console.warn(`[WorkflowRunner] Could not remove orphan worktree ${session.worktreePath}: ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else if (session.worktreePath && ageMs <= MAX_WORKTREE_ORPHAN_AGE_MS) {
+            const ageHours = (ageMs / (60 * 60 * 1000)).toFixed(1);
+            console.log(`[WorkflowRunner] Keeping recent orphan worktree: sessionId=${session.sessionId} ` +
+                `age=${ageHours}h (threshold=24h) worktreePath=${session.worktreePath}`);
+        }
+        if (ctx !== undefined) {
+            let stepAdvances = 0;
+            try {
+                stepAdvances = await _countStepAdvancesFn(session.continueToken, ctx);
+            }
+            catch (err) {
+                console.warn(`[WorkflowRunner] Could not count step advances for orphaned session ${session.sessionId}: ` +
+                    `${err instanceof Error ? err.message : String(err)} -- falling back to discard`);
+            }
+            const action = (0, session_recovery_policy_js_1.evaluateRecovery)({ stepAdvances, ageMs });
+            switch (action) {
+                case 'resume': {
+                    const hasContext = typeof session.workflowId === 'string' &&
+                        typeof session.workspacePath === 'string';
+                    if (!hasContext) {
+                        console.log(`[WorkflowRunner] Startup recovery: cannot resume session ${session.sessionId} -- ` +
+                            `missing workflowId/workspacePath in sidecar (old format). Discarding.`);
+                        break;
+                    }
+                    if (isStale) {
+                        console.log(`[WorkflowRunner] Startup recovery: discarding stale resumable session ${session.sessionId} ` +
+                            `(age=${ageSec}s > ${MAX_ORPHAN_AGE_MS / 1000}s threshold).`);
+                        break;
+                    }
+                    if (session.worktreePath !== undefined) {
+                        let worktreeExists = true;
+                        try {
+                            await fs.access(session.worktreePath);
+                        }
+                        catch {
+                            worktreeExists = false;
+                        }
+                        if (!worktreeExists) {
+                            console.log(`[WorkflowRunner] Startup recovery: discarding session ${session.sessionId} -- ` +
+                                `worktree no longer exists at ${session.worktreePath}.`);
+                            break;
+                        }
+                    }
+                    let rehydrateResult;
+                    try {
+                        rehydrateResult = await _executeContinueWorkflowFn({ continueToken: session.continueToken, intent: 'rehydrate' }, ctx);
+                    }
+                    catch (err) {
+                        console.warn(`[WorkflowRunner] Startup recovery: rehydrate failed for session ${session.sessionId}: ` +
+                            `${err instanceof Error ? err.message : String(err)}. Discarding.`);
+                        break;
+                    }
+                    if (rehydrateResult.isErr()) {
+                        console.warn(`[WorkflowRunner] Startup recovery: rehydrate error for session ${session.sessionId}: ` +
+                            `${rehydrateResult.error.kind}. Discarding.`);
+                        break;
+                    }
+                    const rehydrated = rehydrateResult.value.response;
+                    if (rehydrated.isComplete || !rehydrated.pending) {
+                        console.log(`[WorkflowRunner] Startup recovery: session ${session.sessionId} is already complete ` +
+                            `or has no pending step. Discarding.`);
+                        break;
+                    }
+                    const recoveryAllocatedSession = {
+                        continueToken: rehydrated.continueToken ?? '',
+                        checkpointToken: rehydrated.checkpointToken,
+                        firstStepPrompt: rehydrated.pending.prompt ?? '',
+                        isComplete: rehydrated.isComplete,
+                        triggerSource: 'daemon',
+                        ...(session.worktreePath !== undefined
+                            ? { sessionWorkspacePath: session.worktreePath }
+                            : {}),
+                    };
+                    const branchStrategy = 'none';
+                    const recoveredTrigger = {
+                        workflowId: session.workflowId,
+                        goal: session.goal ?? 'Resumed session (crash recovery)',
+                        workspacePath: session.workspacePath,
+                        branchStrategy,
+                    };
+                    const recoverySource = {
+                        kind: 'pre_allocated',
+                        trigger: recoveredTrigger,
+                        session: recoveryAllocatedSession,
+                    };
+                    console.log(`[WorkflowRunner] Startup recovery: resuming session ${session.sessionId} ` +
+                        `workflowId=${session.workflowId} stepAdvances=${stepAdvances}`);
+                    void _runWorkflowFn(recoveredTrigger, ctx, apiKey, undefined, undefined, undefined, undefined, undefined, recoverySource).then((result) => {
+                        console.log(`[WorkflowRunner] Startup recovery: resumed session ${session.sessionId} completed: ${result._tag}`);
+                    }).catch((err) => {
+                        console.warn(`[WorkflowRunner] Startup recovery: resumed session ${session.sessionId} failed: ` +
+                            `${err instanceof Error ? err.message : String(err)}`);
+                    });
+                    preserved++;
+                    continue;
+                }
+                case 'discard': {
+                    const label = isStale ? 'stale orphaned session' : 'orphaned session';
+                    console.log(`[WorkflowRunner] Discarding ${label}: sessionId=${session.sessionId} ` +
+                        `stepAdvances=${stepAdvances} age=${ageSec}s`);
+                    break;
+                }
+                default:
+                    (0, assert_never_js_1.assertNever)(action);
+            }
+        }
+        else {
+            const label = isStale ? 'stale orphaned session' : 'orphaned session';
+            console.log(`[WorkflowRunner] Clearing ${label}: sessionId=${session.sessionId} age=${ageSec}s`);
+        }
+        try {
+            await fs.unlink(path.join(sessionsDir, `${session.sessionId}.json`));
+            cleared++;
+        }
+        catch (err) {
+            const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+            if (!isEnoent) {
+                console.warn(`[WorkflowRunner] Could not clear session file ${session.sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    await clearStrayTmpFiles(sessionsDir);
+    if (ctx !== undefined) {
+        console.log(`[WorkflowRunner] Startup recovery complete: preserved=${preserved} discarded=${cleared}/${sessions.length} orphaned session(s).`);
+    }
+    else {
+        console.log(`[WorkflowRunner] Startup recovery complete: cleared ${cleared}/${sessions.length} orphaned session(s).`);
+    }
+}
+async function countOrphanStepAdvances(continueToken, ctx, _parseFn = undefined, _loadFn = undefined) {
+    const parseFn = _parseFn ?? ((raw) => (0, v2_token_ops_js_1.parseContinueTokenOrFail)(raw, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore));
+    const loadFn = _loadFn ?? ctx.v2.sessionStore.loadValidatedPrefix.bind(ctx.v2.sessionStore);
+    const resolvedResult = await parseFn(continueToken);
+    if (resolvedResult.isErr()) {
+        console.warn(`[WorkflowRunner] Could not decode continueToken for orphaned session: ${resolvedResult.error.message}`);
+        return 0;
+    }
+    const sessionId = (0, index_js_2.asSessionId)(resolvedResult.value.sessionId);
+    const loadResult = await loadFn(sessionId);
+    if (loadResult.isErr()) {
+        console.warn(`[WorkflowRunner] Could not load session event log for orphaned session: ${loadResult.error.code} -- ${loadResult.error.message}`);
+        return 0;
+    }
+    const events = loadResult.value.truth.events;
+    return events.filter((e) => e.kind === 'advance_recorded').length;
+}
+async function clearQueueIssueSidecars(sessionsDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(sessionsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.startsWith('queue-issue-') || !entry.endsWith('.json'))
+            continue;
+        try {
+            await fs.unlink(path.join(sessionsDir, entry));
+            const issueNum = entry.slice('queue-issue-'.length, -'.json'.length);
+            console.log(`[WorkflowRunner] Cleared queue-issue sidecar: issue=${issueNum}`);
+        }
+        catch (err) {
+            const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+            if (!isEnoent) {
+                console.warn(`[WorkflowRunner] Could not clear queue-issue sidecar ${entry}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}
+async function clearStrayTmpFiles(sessionsDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(sessionsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith('.tmp'))
+            continue;
+        try {
+            await fs.unlink(path.join(sessionsDir, entry));
+            console.log(`[WorkflowRunner] Cleared stray temp file: ${entry}`);
+        }
+        catch {
+        }
+    }
+}

package/dist/daemon/state/index.d.ts

@@ -0,0 +1,6 @@
+export type { SessionState } from './session-state.js';
+export { createSessionState, advanceStep, recordCompletion, updateToken, setSessionId, recordToolCall, } from './session-state.js';
+export type { TerminalSignal } from './terminal-signal.js';
+export { setTerminalSignal } from './terminal-signal.js';
+export type { StuckConfig, StuckSignal } from './stuck-detection.js';
+export { evaluateStuckSignals } from './stuck-detection.js';

package/dist/daemon/state/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateStuckSignals = exports.setTerminalSignal = exports.recordToolCall = exports.setSessionId = exports.updateToken = exports.recordCompletion = exports.advanceStep = exports.createSessionState = void 0;
+var session_state_js_1 = require("./session-state.js");
+Object.defineProperty(exports, "createSessionState", { enumerable: true, get: function () { return session_state_js_1.createSessionState; } });
+Object.defineProperty(exports, "advanceStep", { enumerable: true, get: function () { return session_state_js_1.advanceStep; } });
+Object.defineProperty(exports, "recordCompletion", { enumerable: true, get: function () { return session_state_js_1.recordCompletion; } });
+Object.defineProperty(exports, "updateToken", { enumerable: true, get: function () { return session_state_js_1.updateToken; } });
+Object.defineProperty(exports, "setSessionId", { enumerable: true, get: function () { return session_state_js_1.setSessionId; } });
+Object.defineProperty(exports, "recordToolCall", { enumerable: true, get: function () { return session_state_js_1.recordToolCall; } });
+var terminal_signal_js_1 = require("./terminal-signal.js");
+Object.defineProperty(exports, "setTerminalSignal", { enumerable: true, get: function () { return terminal_signal_js_1.setTerminalSignal; } });
+var stuck_detection_js_1 = require("./stuck-detection.js");
+Object.defineProperty(exports, "evaluateStuckSignals", { enumerable: true, get: function () { return stuck_detection_js_1.evaluateStuckSignals; } });

package/dist/daemon/state/session-state.d.ts

@@ -0,0 +1,23 @@
+import type { TerminalSignal } from './terminal-signal.js';
+export interface SessionState {
+    isComplete: boolean;
+    lastStepNotes: string | undefined;
+    lastStepArtifacts: readonly unknown[] | undefined;
+    currentContinueToken: string;
+    workrailSessionId: string | null;
+    stepAdvanceCount: number;
+    lastNToolCalls: Array<{
+        toolName: string;
+        argsSummary: string;
+    }>;
+    issueSummaries: string[];
+    pendingSteerParts: string[];
+    terminalSignal: TerminalSignal | null;
+    turnCount: number;
+}
+export declare function createSessionState(initialToken: string): SessionState;
+export declare function advanceStep(state: SessionState, stepText: string, continueToken: string): void;
+export declare function recordCompletion(state: SessionState, notes: string | undefined, artifacts?: readonly unknown[]): void;
+export declare function updateToken(state: SessionState, token: string): void;
+export declare function setSessionId(state: SessionState, id: string): void;
+export declare function recordToolCall(state: SessionState, toolName: string, argsSummary: string, threshold: number): void;

package/dist/daemon/state/session-state.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionState = createSessionState;
+exports.advanceStep = advanceStep;
+exports.recordCompletion = recordCompletion;
+exports.updateToken = updateToken;
+exports.setSessionId = setSessionId;
+exports.recordToolCall = recordToolCall;
+function createSessionState(initialToken) {
+    return {
+        isComplete: false,
+        lastStepNotes: undefined,
+        lastStepArtifacts: undefined,
+        currentContinueToken: initialToken,
+        workrailSessionId: null,
+        stepAdvanceCount: 0,
+        lastNToolCalls: [],
+        issueSummaries: [],
+        pendingSteerParts: [],
+        terminalSignal: null,
+        turnCount: 0,
+    };
+}
+function advanceStep(state, stepText, continueToken) {
+    state.pendingSteerParts.push(stepText);
+    state.stepAdvanceCount++;
+    state.currentContinueToken = continueToken;
+}
+function recordCompletion(state, notes, artifacts) {
+    state.isComplete = true;
+    state.lastStepNotes = notes;
+    state.lastStepArtifacts = artifacts;
+}
+function updateToken(state, token) {
+    state.currentContinueToken = token;
+}
+function setSessionId(state, id) {
+    state.workrailSessionId = id;
+}
+function recordToolCall(state, toolName, argsSummary, threshold) {
+    state.lastNToolCalls.push({ toolName, argsSummary });
+    if (state.lastNToolCalls.length > threshold)
+        state.lastNToolCalls.shift();
+}

package/dist/daemon/state/stuck-detection.d.ts

@@ -0,0 +1,22 @@
+import type { SessionState } from './session-state.js';
+export interface StuckConfig {
+    maxTurns: number;
+    stuckAbortPolicy: 'abort' | 'notify_only';
+    noProgressAbortEnabled: boolean;
+    stuckRepeatThreshold: number;
+}
+export type StuckSignal = {
+    kind: 'repeated_tool_call';
+    toolName: string;
+    argsSummary: string;
+} | {
+    kind: 'no_progress';
+    turnCount: number;
+    maxTurns: number;
+} | {
+    kind: 'max_turns_exceeded';
+} | {
+    kind: 'timeout_imminent';
+    timeoutReason: 'wall_clock' | 'max_turns';
+};
+export declare function evaluateStuckSignals(state: Readonly<SessionState>, config: StuckConfig): StuckSignal | null;

package/dist/daemon/state/stuck-detection.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateStuckSignals = evaluateStuckSignals;
+function evaluateStuckSignals(state, config) {
+    if (config.maxTurns > 0 && state.turnCount >= config.maxTurns && state.terminalSignal === null) {
+        return { kind: 'max_turns_exceeded' };
+    }
+    if (state.lastNToolCalls.length === config.stuckRepeatThreshold &&
+        state.lastNToolCalls.every((c) => c.toolName === state.lastNToolCalls[0]?.toolName && c.argsSummary === state.lastNToolCalls[0]?.argsSummary)) {
+        return {
+            kind: 'repeated_tool_call',
+            toolName: state.lastNToolCalls[0]?.toolName ?? 'unknown',
+            argsSummary: state.lastNToolCalls[0]?.argsSummary ?? '',
+        };
+    }
+    if (config.maxTurns > 0 &&
+        state.turnCount >= Math.floor(config.maxTurns * 0.8) &&
+        state.stepAdvanceCount === 0) {
+        return { kind: 'no_progress', turnCount: state.turnCount, maxTurns: config.maxTurns };
+    }
+    if (state.terminalSignal?.kind === 'timeout') {
+        return { kind: 'timeout_imminent', timeoutReason: state.terminalSignal.reason };
+    }
+    return null;
+}

package/dist/daemon/state/terminal-signal.d.ts

@@ -0,0 +1,9 @@
+import type { SessionState } from './session-state.js';
+export type TerminalSignal = {
+    readonly kind: 'stuck';
+    readonly reason: 'repeated_tool_call' | 'no_progress' | 'stall';
+} | {
+    readonly kind: 'timeout';
+    readonly reason: 'wall_clock' | 'max_turns';
+};
+export declare function setTerminalSignal(state: SessionState, signal: TerminalSignal): boolean;

package/dist/daemon/state/terminal-signal.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTerminalSignal = setTerminalSignal;
+function setTerminalSignal(state, signal) {
+    if (state.terminalSignal === null) {
+        state.terminalSignal = signal;
+        return true;
+    }
+    return false;
+}

package/dist/daemon/tools/file-tools.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool } from '../agent-loop.js';
 import type { DaemonEventEmitter } from '../daemon-events.js';
-import type { ReadFileState } from '../workflow-runner.js';
+import type { ReadFileState } from '../types.js';
 export declare function makeReadTool(workspacePath: string, readFileState: Map<string, ReadFileState>, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
 export declare function makeWriteTool(workspacePath: string, readFileState: Map<string, ReadFileState>, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
 export declare function makeEditTool(workspacePath: string, readFileState: Map<string, ReadFileState>, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;

package/dist/daemon/turn-end/detect-stuck.d.ts

@@ -1,2 +1,2 @@
-export type { StuckSignal, StuckConfig } from '../workflow-runner.js';
-export { evaluateStuckSignals as detectStuck } from '../workflow-runner.js';
+export type { StuckSignal, StuckConfig } from '../state/stuck-detection.js';
+export { evaluateStuckSignals as detectStuck } from '../state/stuck-detection.js';

package/dist/daemon/turn-end/detect-stuck.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectStuck = void 0;
-var workflow_runner_js_1 = require("../workflow-runner.js");
-Object.defineProperty(exports, "detectStuck", { enumerable: true, get: function () { return workflow_runner_js_1.evaluateStuckSignals; } });
+var stuck_detection_js_1 = require("../state/stuck-detection.js");
+Object.defineProperty(exports, "detectStuck", { enumerable: true, get: function () { return stuck_detection_js_1.evaluateStuckSignals; } });

package/dist/daemon/turn-end/step-injector.d.ts

@@ -1,4 +1,4 @@
-import type { SessionState } from '../workflow-runner.js';
+import type { SessionState } from '../state/session-state.js';
 export declare function injectPendingSteps(state: SessionState, agent: {
     steer(msg: {
         role: 'user';

package/dist/daemon/types.d.ts

@@ -0,0 +1,105 @@
+export type ReadFileState = {
+    content: string;
+    timestamp: number;
+    isPartialView: boolean;
+};
+export interface WorkflowTrigger {
+    readonly workflowId: string;
+    readonly goal: string;
+    readonly workspacePath: string;
+    readonly context?: Readonly<Record<string, unknown>>;
+    readonly referenceUrls?: readonly string[];
+    readonly agentConfig?: {
+        readonly model?: string;
+        readonly maxSessionMinutes?: number;
+        readonly maxTurns?: number;
+        readonly maxOutputTokens?: number;
+        readonly maxSubagentDepth?: number;
+        readonly stuckAbortPolicy?: 'abort' | 'notify_only';
+        readonly noProgressAbortEnabled?: boolean;
+        readonly stallTimeoutSeconds?: number;
+    };
+    readonly parentSessionId?: string;
+    readonly spawnDepth?: number;
+    readonly soulFile?: string;
+    readonly botIdentity?: {
+        readonly name: string;
+        readonly email: string;
+    };
+    readonly branchStrategy?: 'worktree' | 'none';
+    readonly baseBranch?: string;
+    readonly branchPrefix?: string;
+}
+export interface AllocatedSession {
+    readonly continueToken: string;
+    readonly checkpointToken?: string | null;
+    readonly firstStepPrompt: string;
+    readonly isComplete: boolean;
+    readonly triggerSource: 'daemon' | 'mcp';
+    readonly sessionWorkspacePath?: string;
+}
+export type SessionSource = {
+    readonly kind: 'allocate';
+    readonly trigger: WorkflowTrigger;
+} | {
+    readonly kind: 'pre_allocated';
+    readonly trigger: WorkflowTrigger;
+    readonly session: AllocatedSession;
+};
+export interface WorkflowRunSuccess {
+    readonly _tag: 'success';
+    readonly workflowId: string;
+    readonly stopReason: string;
+    readonly lastStepNotes?: string;
+    readonly lastStepArtifacts?: readonly unknown[];
+    readonly sessionWorkspacePath?: string;
+    readonly sessionId?: string;
+    readonly botIdentity?: {
+        readonly name: string;
+        readonly email: string;
+    };
+}
+export interface WorkflowRunError {
+    readonly _tag: 'error';
+    readonly workflowId: string;
+    readonly message: string;
+    readonly stopReason: string;
+    readonly lastStepNotes?: string;
+}
+export interface WorkflowRunTimeout {
+    readonly _tag: 'timeout';
+    readonly workflowId: string;
+    readonly reason: 'wall_clock' | 'max_turns';
+    readonly message: string;
+    readonly stopReason: string;
+}
+export interface WorkflowRunStuck {
+    readonly _tag: 'stuck';
+    readonly workflowId: string;
+    readonly reason: 'repeated_tool_call' | 'no_progress' | 'stall';
+    readonly message: string;
+    readonly stopReason: string;
+    readonly issueSummaries?: readonly string[];
+}
+export interface WorkflowDeliveryFailed {
+    readonly _tag: 'delivery_failed';
+    readonly workflowId: string;
+    readonly stopReason: string;
+    readonly deliveryError: string;
+}
+export type WorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout | WorkflowRunStuck | WorkflowDeliveryFailed;
+export type ChildWorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout | WorkflowRunStuck;
+export interface OrphanedSession {
+    readonly sessionId: string;
+    readonly continueToken: string;
+    readonly checkpointToken: string | null;
+    readonly ts: number;
+    readonly worktreePath?: string;
+    readonly workflowId?: string;
+    readonly goal?: string;
+    readonly workspacePath?: string;
+}
+export interface WorkflowContextSlots {
+    readonly assembledContextSummary?: string;
+}
+export declare function extractContextSlots(context: Readonly<Record<string, unknown>> | undefined): WorkflowContextSlots;

package/dist/daemon/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractContextSlots = extractContextSlots;
+function extractContextSlots(context) {
+    if (!context)
+        return {};
+    const assembledContextSummary = typeof context['assembledContextSummary'] === 'string'
+        ? context['assembledContextSummary']
+        : undefined;
+    return { assembledContextSummary };
+}

package/dist/daemon/workflow-enricher.d.ts

@@ -0,0 +1,16 @@
+import type { Result } from '../runtime/result.js';
+import type { SessionNote } from '../context-assembly/types.js';
+import type { WorkflowTrigger } from './types.js';
+export interface EnricherResult {
+    readonly priorSessionNotes: readonly SessionNote[];
+    readonly gitDiffStat: string | null;
+}
+export declare const EMPTY_RESULT: EnricherResult;
+export type PriorNotesPolicy = 'inject' | 'skip_coordinator_provided';
+export interface WorkflowEnricherDeps {
+    readonly execGit: (args: readonly string[], cwd: string) => Promise<Result<string, string>>;
+    readonly listRecentSessions: (workspacePath: string, limit: number) => Promise<Result<readonly SessionNote[], string>>;
+}
+export declare function createWorkflowEnricherDeps(): WorkflowEnricherDeps;
+export declare function enrichTriggerContext(trigger: WorkflowTrigger, deps: WorkflowEnricherDeps, policy: PriorNotesPolicy): Promise<EnricherResult>;
+export declare function shouldEnrich(trigger: WorkflowTrigger): boolean;