@exaudeus/workrail 3.75.0 → 3.77.0

package/dist/daemon/runner/finalize-session.js

@@ -0,0 +1,75 @@
+"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.finalizeSession = finalizeSession;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const index_js_1 = require("../core/index.js");
+const index_js_2 = require("../io/index.js");
+const _shared_js_1 = require("../tools/_shared.js");
+const assert_never_js_1 = require("../../runtime/assert-never.js");
+async function finalizeSession(result, ctx) {
+    const outcome = (0, index_js_1.tagToStatsOutcome)(result._tag);
+    const detail = result._tag === 'stuck' ? result.reason
+        : result._tag === 'timeout' ? result.reason
+            : result._tag === 'error' ? result.message.slice(0, 200)
+                : result._tag === 'delivery_failed' ? result.deliveryError.slice(0, 200)
+                    : result.stopReason;
+    ctx.emitter?.emit({
+        kind: 'session_completed',
+        sessionId: ctx.sessionId,
+        workflowId: ctx.workflowId,
+        outcome,
+        detail,
+        ...(0, _shared_js_1.withWorkrailSession)(ctx.workrailSessionId),
+    });
+    if (ctx.workrailSessionId !== null) {
+        ctx.daemonRegistry?.unregister(ctx.workrailSessionId, result._tag === 'success' || result._tag === 'delivery_failed' ? 'completed' : 'failed');
+    }
+    (0, index_js_2.writeExecutionStats)(ctx.statsDir, ctx.sessionId, ctx.workflowId, ctx.startMs, outcome, ctx.stepAdvanceCount);
+    const lifecycle = (0, index_js_1.sidecardLifecycleFor)(result._tag, ctx.branchStrategy);
+    switch (lifecycle.kind) {
+        case 'delete_now':
+            await fs.unlink(path.join(ctx.sessionsDir, `${ctx.sessionId}.json`)).catch(() => { });
+            break;
+        case 'retain_for_delivery':
+            break;
+        default:
+            (0, assert_never_js_1.assertNever)(lifecycle);
+    }
+    if (result._tag === 'success' && ctx.branchStrategy !== 'worktree') {
+        await fs.unlink(ctx.conversationPath).catch(() => { });
+    }
+}

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

@@ -0,0 +1,8 @@
+export { WORKTREES_DIR } from './runner-types.js';
+export type { PreAgentSession, PreAgentSessionResult, AgentReadySession, SessionOutcome, FinalizationContext, } from './runner-types.js';
+export { getSchemas } from './tool-schemas.js';
+export { constructTools } from './construct-tools.js';
+export { finalizeSession } from './finalize-session.js';
+export { buildPreAgentSession } from './pre-agent-session.js';
+export type { TurnEndSubscriberContext } from './agent-loop-runner.js';
+export { buildTurnEndSubscriber, buildAgentCallbacks, buildAgentReadySession, runAgentLoop, } from './agent-loop-runner.js';

package/dist/daemon/runner/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentLoop = exports.buildAgentReadySession = exports.buildAgentCallbacks = exports.buildTurnEndSubscriber = exports.buildPreAgentSession = exports.finalizeSession = exports.constructTools = exports.getSchemas = exports.WORKTREES_DIR = void 0;
+var runner_types_js_1 = require("./runner-types.js");
+Object.defineProperty(exports, "WORKTREES_DIR", { enumerable: true, get: function () { return runner_types_js_1.WORKTREES_DIR; } });
+var tool_schemas_js_1 = require("./tool-schemas.js");
+Object.defineProperty(exports, "getSchemas", { enumerable: true, get: function () { return tool_schemas_js_1.getSchemas; } });
+var construct_tools_js_1 = require("./construct-tools.js");
+Object.defineProperty(exports, "constructTools", { enumerable: true, get: function () { return construct_tools_js_1.constructTools; } });
+var finalize_session_js_1 = require("./finalize-session.js");
+Object.defineProperty(exports, "finalizeSession", { enumerable: true, get: function () { return finalize_session_js_1.finalizeSession; } });
+var pre_agent_session_js_1 = require("./pre-agent-session.js");
+Object.defineProperty(exports, "buildPreAgentSession", { enumerable: true, get: function () { return pre_agent_session_js_1.buildPreAgentSession; } });
+var agent_loop_runner_js_1 = require("./agent-loop-runner.js");
+Object.defineProperty(exports, "buildTurnEndSubscriber", { enumerable: true, get: function () { return agent_loop_runner_js_1.buildTurnEndSubscriber; } });
+Object.defineProperty(exports, "buildAgentCallbacks", { enumerable: true, get: function () { return agent_loop_runner_js_1.buildAgentCallbacks; } });
+Object.defineProperty(exports, "buildAgentReadySession", { enumerable: true, get: function () { return agent_loop_runner_js_1.buildAgentReadySession; } });
+Object.defineProperty(exports, "runAgentLoop", { enumerable: true, get: function () { return agent_loop_runner_js_1.runAgentLoop; } });

package/dist/daemon/runner/pre-agent-session.d.ts

@@ -0,0 +1,7 @@
+import type { V2ToolContext } from '../../mcp/types.js';
+import type { DaemonRegistry } from '../../v2/infra/in-memory/daemon-registry/index.js';
+import type { DaemonEventEmitter } from '../daemon-events.js';
+import { ActiveSessionSet } from '../active-sessions.js';
+import type { WorkflowTrigger, SessionSource } from '../types.js';
+import type { PreAgentSessionResult } from './runner-types.js';
+export declare function buildPreAgentSession(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, sessionId: string, startMs: number, statsDir: string, sessionsDir: string, emitter: DaemonEventEmitter | undefined, daemonRegistry: DaemonRegistry | undefined, activeSessionSet: ActiveSessionSet | undefined, source?: SessionSource): Promise<PreAgentSessionResult>;

package/dist/daemon/runner/pre-agent-session.js

@@ -0,0 +1,227 @@
+"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.buildPreAgentSession = buildPreAgentSession;
+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 start_js_1 = require("../../mcp/handlers/v2-execution/start.js");
+const v2_token_ops_js_1 = require("../../mcp/handlers/v2-token-ops.js");
+const index_js_1 = require("../state/index.js");
+const index_js_2 = require("../core/index.js");
+const _shared_js_1 = require("../tools/_shared.js");
+const runner_types_js_1 = require("./runner-types.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, statsDir, sessionsDir, emitter, daemonRegistry, activeSessionSet, source) {
+    let agentClient;
+    let modelId;
+    try {
+        ({ agentClient, modelId } = (0, index_js_2.buildAgentClient)(trigger, apiKey, process.env));
+        if (trigger.agentConfig?.model) {
+            console.log(`[WorkflowRunner] Model: ${modelId} (override from agentConfig.model)`);
+        }
+        else {
+            const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
+            if (usesBedrock) {
+                console.log(`[WorkflowRunner] Model: ${modelId} (amazon-bedrock, detected from AWS env)`);
+            }
+            else {
+                console.log(`[WorkflowRunner] Model: ${modelId} (anthropic direct). Set agentConfig.model or AWS env vars to use Bedrock.`);
+            }
+        }
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { kind: 'complete', result: { _tag: 'error', workflowId: trigger.workflowId, message, stopReason: 'error' }, workrailSessionId: null, handle: undefined };
+    }
+    const state = (0, index_js_1.createSessionState)('');
+    let continueToken;
+    let checkpointToken;
+    let firstStepPrompt;
+    let isComplete;
+    const effectiveSource = source ?? { kind: 'allocate', trigger };
+    if (effectiveSource.kind === 'pre_allocated') {
+        const s = effectiveSource.session;
+        continueToken = s.continueToken;
+        checkpointToken = s.checkpointToken ?? null;
+        firstStepPrompt = s.firstStepPrompt;
+        isComplete = s.isComplete;
+    }
+    else {
+        const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId: trigger.workflowId, workspacePath: trigger.workspacePath, goal: trigger.goal }, ctx, { is_autonomous: 'true', workspacePath: trigger.workspacePath, triggerSource: 'daemon' });
+        if (startResult.isErr()) {
+            return {
+                kind: 'complete',
+                result: {
+                    _tag: 'error',
+                    workflowId: trigger.workflowId,
+                    message: `start_workflow failed: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
+                    stopReason: 'error',
+                },
+                workrailSessionId: null,
+                handle: undefined,
+            };
+        }
+        const r = startResult.value.response;
+        continueToken = r.continueToken ?? '';
+        checkpointToken = r.checkpointToken ?? null;
+        firstStepPrompt = r.pending?.prompt ?? '';
+        isComplete = r.isComplete;
+    }
+    (0, index_js_1.updateToken)(state, continueToken);
+    if (continueToken) {
+        const decoded = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(continueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
+        if (decoded.isOk()) {
+            (0, index_js_1.setSessionId)(state, decoded.value.sessionId);
+        }
+        else {
+            console.error(`[WorkflowRunner] Error: could not decode WorkRail session ID from continueToken -- isLive and liveActivity will not work. Reason: ${decoded.error.message}`);
+        }
+    }
+    if (continueToken) {
+        const persistResult = await (0, _shared_js_1.persistTokens)(sessionId, continueToken, checkpointToken, undefined, {
+            workflowId: trigger.workflowId,
+            goal: trigger.goal,
+            workspacePath: trigger.workspacePath,
+        });
+        if (persistResult.kind === 'err') {
+            return {
+                kind: 'complete',
+                result: {
+                    _tag: 'error',
+                    workflowId: trigger.workflowId,
+                    message: `Initial token persist failed: ${persistResult.error.code} -- ${persistResult.error.message}`,
+                    stopReason: 'error',
+                },
+                workrailSessionId: state.workrailSessionId,
+                handle: undefined,
+            };
+        }
+    }
+    let sessionWorkspacePath = trigger.workspacePath;
+    let sessionWorktreePath;
+    if (effectiveSource.kind === 'pre_allocated' && effectiveSource.session.sessionWorkspacePath !== undefined) {
+        sessionWorkspacePath = effectiveSource.session.sessionWorkspacePath;
+        sessionWorktreePath = effectiveSource.session.sessionWorkspacePath;
+    }
+    if (trigger.branchStrategy === 'worktree') {
+        const branchPrefix = trigger.branchPrefix ?? 'worktrain/';
+        const baseBranch = trigger.baseBranch ?? 'main';
+        sessionWorkspacePath = path.join(runner_types_js_1.WORKTREES_DIR, sessionId);
+        sessionWorktreePath = sessionWorkspacePath;
+        try {
+            await fs.mkdir(runner_types_js_1.WORKTREES_DIR, { recursive: true });
+            await execFileAsync('git', ['-C', trigger.workspacePath, 'fetch', 'origin', baseBranch]);
+            await execFileAsync('git', [
+                '-C', trigger.workspacePath,
+                'worktree', 'add',
+                sessionWorkspacePath,
+                '-b', `${branchPrefix}${sessionId}`,
+                `origin/${baseBranch}`,
+            ]);
+            const worktreePersistResult = await (0, _shared_js_1.persistTokens)(sessionId, continueToken ?? state.currentContinueToken, checkpointToken, sessionWorktreePath, { workflowId: trigger.workflowId, goal: trigger.goal, workspacePath: trigger.workspacePath });
+            if (worktreePersistResult.kind === 'err') {
+                console.error(`[WorkflowRunner] Worktree sidecar persist failed: ${worktreePersistResult.error.code} -- ${worktreePersistResult.error.message}`);
+                try {
+                    await execFileAsync('git', ['-C', trigger.workspacePath, 'worktree', 'remove', '--force', sessionWorkspacePath]);
+                }
+                catch { }
+                return {
+                    kind: 'complete',
+                    result: {
+                        _tag: 'error',
+                        workflowId: trigger.workflowId,
+                        message: `Worktree sidecar persist failed: ${worktreePersistResult.error.code} -- ${worktreePersistResult.error.message}`,
+                        stopReason: 'error',
+                    },
+                    workrailSessionId: state.workrailSessionId,
+                    handle: undefined,
+                };
+            }
+            console.log(`[WorkflowRunner] Worktree created: sessionId=${sessionId} branch=${branchPrefix}${sessionId} path=${sessionWorkspacePath}`);
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            console.error(`[WorkflowRunner] Worktree creation failed: sessionId=${sessionId} error=${errMsg}`);
+            return {
+                kind: 'complete',
+                result: { _tag: 'error', workflowId: trigger.workflowId, message: `Worktree creation failed: ${errMsg}`, stopReason: 'error' },
+                workrailSessionId: state.workrailSessionId,
+                handle: undefined,
+            };
+        }
+    }
+    let handle;
+    if (state.workrailSessionId !== null) {
+        daemonRegistry?.register(state.workrailSessionId, trigger.workflowId);
+        handle = activeSessionSet?.register(state.workrailSessionId, (text) => { state.pendingSteerParts.push(text); });
+    }
+    if (isComplete) {
+        return {
+            kind: 'complete',
+            result: {
+                _tag: 'success',
+                workflowId: trigger.workflowId,
+                stopReason: 'stop',
+                ...(sessionWorktreePath !== undefined ? { sessionWorkspacePath: sessionWorktreePath } : {}),
+                ...(sessionWorktreePath !== undefined ? { sessionId } : {}),
+                ...(trigger.botIdentity !== undefined ? { botIdentity: trigger.botIdentity } : {}),
+            },
+            workrailSessionId: state.workrailSessionId,
+            handle,
+        };
+    }
+    return {
+        kind: 'ready',
+        session: {
+            sessionId,
+            workrailSessionId: state.workrailSessionId,
+            continueToken,
+            checkpointToken,
+            sessionWorkspacePath,
+            sessionWorktreePath,
+            firstStepPrompt,
+            state,
+            spawnCurrentDepth: trigger.spawnDepth ?? 0,
+            spawnMaxDepth: trigger.agentConfig?.maxSubagentDepth ?? 3,
+            readFileState: new Map(),
+            agentClient,
+            modelId,
+            startMs,
+            ...(handle !== undefined ? { handle } : {}),
+        },
+    };
+}

package/dist/daemon/runner/runner-types.d.ts

@@ -0,0 +1,73 @@
+import type { AgentLoop, AgentTool } from '../agent-loop.js';
+import type { SessionState } from '../state/session-state.js';
+import type { SessionContext } from '../core/session-context.js';
+import type { ContextBundle } from '../context-loader.js';
+import type { SessionScope } from '../session-scope.js';
+import type { SessionHandle } from '../active-sessions.js';
+import type { DaemonEventEmitter } from '../daemon-events.js';
+import type { DaemonRegistry } from '../../v2/infra/in-memory/daemon-registry/index.js';
+import type { WorkflowRunResult } from '../types.js';
+import type { ReadFileState } from '../types.js';
+import Anthropic from '@anthropic-ai/sdk';
+import { AnthropicBedrock } from '@anthropic-ai/bedrock-sdk';
+export declare const WORKTREES_DIR: string;
+export interface PreAgentSession {
+    readonly sessionId: string;
+    readonly workrailSessionId: string | null;
+    readonly continueToken: string;
+    readonly checkpointToken: string | null;
+    readonly sessionWorkspacePath: string;
+    readonly sessionWorktreePath: string | undefined;
+    readonly firstStepPrompt: string;
+    readonly state: SessionState;
+    readonly spawnCurrentDepth: number;
+    readonly spawnMaxDepth: number;
+    readonly readFileState: Map<string, ReadFileState>;
+    readonly agentClient: Anthropic | AnthropicBedrock;
+    readonly modelId: string;
+    readonly startMs: number;
+    readonly handle?: SessionHandle;
+}
+export type PreAgentSessionResult = {
+    readonly kind: 'ready';
+    readonly session: PreAgentSession;
+} | {
+    readonly kind: 'complete';
+    readonly result: WorkflowRunResult;
+    readonly workrailSessionId: string | null;
+    readonly handle: SessionHandle | undefined;
+};
+export interface AgentReadySession {
+    readonly preAgentSession: PreAgentSession;
+    readonly contextBundle: ContextBundle;
+    readonly scope: SessionScope;
+    readonly tools: readonly AgentTool[];
+    readonly sessionCtx: SessionContext;
+    readonly handle: SessionHandle | undefined;
+    readonly sessionId: string;
+    readonly workflowId: string;
+    readonly worktreePath: string | undefined;
+    readonly agent: AgentLoop;
+    readonly stuckRepeatThreshold: number;
+}
+export type SessionOutcome = {
+    readonly kind: 'completed';
+    readonly stopReason: string;
+    readonly errorMessage?: string;
+} | {
+    readonly kind: 'aborted';
+    readonly errorMessage?: string;
+};
+export interface FinalizationContext {
+    readonly sessionId: string;
+    readonly workrailSessionId: string | null;
+    readonly startMs: number;
+    readonly stepAdvanceCount: number;
+    readonly branchStrategy: 'worktree' | 'none' | undefined;
+    readonly statsDir: string;
+    readonly sessionsDir: string;
+    readonly conversationPath: string;
+    readonly emitter: DaemonEventEmitter | undefined;
+    readonly daemonRegistry: DaemonRegistry | undefined;
+    readonly workflowId: string;
+}

package/dist/daemon/runner/runner-types.js

@@ -0,0 +1,39 @@
+"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.WORKTREES_DIR = void 0;
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+exports.WORKTREES_DIR = path.join(os.homedir(), '.workrail', 'worktrees');

package/dist/daemon/runner/tool-schemas.d.ts

@@ -0,0 +1 @@
+export declare function getSchemas(): Record<string, any>;

package/dist/daemon/runner/tool-schemas.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemas = getSchemas;
+let _schemas = null;
+function getSchemas() {
+    if (_schemas)
+        return _schemas;
+    _schemas = {
+        ContinueWorkflowParams: {
+            type: 'object',
+            properties: {
+                continueToken: {
+                    type: 'string',
+                    description: 'The continueToken from the previous start_workflow or continue_workflow call. Round-trip exactly as received.',
+                },
+                intent: {
+                    type: 'string',
+                    enum: ['advance', 'rehydrate'],
+                    description: 'advance: I completed this step. rehydrate: remind me what the current step is.',
+                },
+                notesMarkdown: {
+                    type: 'string',
+                    description: 'Notes on what you did in this step (10-30 lines, markdown).',
+                },
+                artifacts: {
+                    type: 'array',
+                    items: {},
+                    description: 'Optional structured artifacts to attach to this step. ' +
+                        'Include wr.assessment objects here when the step requires an assessment gate. ' +
+                        'Example: [{ "kind": "wr.assessment", "assessmentId": "<id>", "dimensions": { "<dimensionId>": "high" } }]',
+                },
+                context: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Updated context variables (only changed values). Exception: metrics_commit_shas must always contain the FULL accumulated list of all commit SHAs from this session -- never send only new SHAs.',
+                },
+            },
+            required: ['continueToken'],
+        },
+        CompleteStepParams: {
+            type: 'object',
+            properties: {
+                notes: {
+                    type: 'string',
+                    minLength: 50,
+                    description: 'What you did in this step (required, at least 50 characters). Write for a human reader. ' +
+                        'Include: what you did and key decisions, what you produced (files, tests, numbers), ' +
+                        'anything notable (risks, open questions, things you chose NOT to do and why). ' +
+                        'Use markdown: headings, bullets, bold. 10-30 lines is ideal.',
+                },
+                artifacts: {
+                    type: 'array',
+                    items: {},
+                    description: 'Optional structured artifacts to attach to this step. ' +
+                        'Include wr.assessment objects here when the step requires an assessment gate. ' +
+                        'Example: [{ "kind": "wr.assessment", "assessmentId": "<id>", "dimensions": { "<dimensionId>": "high" } }]',
+                },
+                context: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Updated context variables (only changed values). Omit entirely if no facts changed. Exception: metrics_commit_shas must always contain the FULL accumulated list of all commit SHAs from this session -- never send only new SHAs.',
+                },
+            },
+            required: ['notes'],
+            additionalProperties: false,
+        },
+        BashParams: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Shell command to execute' },
+                cwd: { type: 'string', description: 'Working directory for the command' },
+            },
+            required: ['command'],
+        },
+        ReadParams: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the file to read. Content is returned in cat -n format: each line prefixed with its 1-indexed line number and a tab character.' },
+                offset: { type: 'number', description: '0-indexed line number to start reading from (inclusive). Omit to read from the beginning.' },
+                limit: { type: 'number', description: 'Maximum number of lines to return. Omit to read to end of file.' },
+            },
+            required: ['filePath'],
+        },
+        WriteParams: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the file to write' },
+                content: { type: 'string', description: 'Content to write to the file' },
+            },
+            required: ['filePath', 'content'],
+        },
+        GlobParams: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Glob pattern to match (e.g. "**/*.ts"). Supports standard glob syntax.' },
+                path: { type: 'string', description: 'Absolute path to search root. Defaults to the workspace root.' },
+            },
+            required: ['pattern'],
+        },
+        GrepParams: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Regular expression pattern to search for in file contents.' },
+                path: { type: 'string', description: 'Absolute path to search in. Defaults to the workspace root.' },
+                glob: { type: 'string', description: 'Glob pattern to restrict which files are searched (e.g. "*.ts").' },
+                type: { type: 'string', description: 'File type filter for ripgrep (e.g. "ts", "js", "py").' },
+                output_mode: { type: 'string', enum: ['content', 'files_with_matches', 'count'], description: 'Output mode. "files_with_matches": only file paths (default). "content": matching lines with context. "count": match counts per file.' },
+                head_limit: { type: 'number', description: 'Maximum number of output lines to return. Default: 250.' },
+                context: { type: 'number', description: 'Number of lines of context to show before and after each match (output_mode=content only).' },
+                '-i': { type: 'boolean', description: 'Case-insensitive search.' },
+            },
+            required: ['pattern'],
+        },
+        EditParams: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Absolute path to the file to edit. The file must have been read in this session via the Read tool.' },
+                old_string: { type: 'string', description: 'Exact string to find and replace. Must appear exactly once in the file (or use replace_all=true for multiple occurrences). Do NOT include line-number prefixes from Read output.' },
+                new_string: { type: 'string', description: 'Replacement string. Must differ from old_string.' },
+                replace_all: { type: 'boolean', description: 'Replace all occurrences of old_string. Default: false (fails if more than one match).' },
+            },
+            required: ['file_path', 'old_string', 'new_string'],
+            additionalProperties: false,
+        },
+        SpawnAgentParams: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'ID of the workflow to run in the child session (e.g. "wr.discovery").',
+                },
+                goal: {
+                    type: 'string',
+                    description: 'One-sentence description of what the child session should accomplish.',
+                },
+                workspacePath: {
+                    type: 'string',
+                    description: 'Absolute path to the workspace directory for the child session.',
+                },
+                context: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Optional initial context variables to pass to the child workflow.',
+                },
+            },
+            required: ['workflowId', 'goal', 'workspacePath'],
+            additionalProperties: false,
+        },
+    };
+    return _schemas;
+}

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

@@ -1,4 +1,4 @@
-import type { ReadFileState } from './workflow-runner.js';
+import type { ReadFileState } from './types.js';
 import type { ActiveSessionSet } from './active-sessions.js';
 import type { DaemonEventEmitter } from './daemon-events.js';
 export interface FileStateTracker {

package/dist/daemon/startup-recovery.d.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import type { V2ToolContext } from '../mcp/types.js';
+import { executeContinueWorkflow } from '../mcp/handlers/v2-execution/index.js';
+import type { ContinueTokenResolved } from '../mcp/handlers/v2-token-ops.js';
+import type { SessionEventLogReadonlyStorePortV2 } from '../v2/ports/session-event-log-store.port.js';
+import type { ToolFailure } from '../mcp/handlers/v2-execution-helpers.js';
+import type { ResultAsync } from 'neverthrow';
+import type { OrphanedSession } from './types.js';
+import { runWorkflow } from './workflow-runner.js';
+export declare function readDaemonSessionState(sessionId: string): Promise<{
+    continueToken: string;
+    checkpointToken: string | null;
+} | null>;
+export declare function readAllDaemonSessions(sessionsDir?: string): Promise<OrphanedSession[]>;
+export declare function runStartupRecovery(sessionsDir?: string, execFn?: (file: string, args: string[]) => Promise<{
+    stdout: string;
+    stderr: string;
+}>, ctx?: V2ToolContext, _countStepAdvancesFn?: typeof countOrphanStepAdvances, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, _runWorkflowFn?: typeof runWorkflow, apiKey?: string): Promise<void>;
+export declare function countOrphanStepAdvances(continueToken: string, ctx: V2ToolContext, _parseFn?: ((raw: string) => ResultAsync<ContinueTokenResolved, ToolFailure>) | undefined, _loadFn?: SessionEventLogReadonlyStorePortV2['loadValidatedPrefix'] | undefined): Promise<number>;
+export declare function clearQueueIssueSidecars(sessionsDir: string): Promise<void>;