@exaudeus/workrail 3.76.0 → 3.77.1

package/dist/daemon/io/workspace-context-loader.d.ts

@@ -0,0 +1,17 @@
+export declare const WORKSPACE_CONTEXT_MAX_BYTES: number;
+export declare const MAX_GLOB_FILES_PER_PATTERN = 20;
+type LiteralCandidatePath = {
+    readonly kind: 'literal';
+    readonly relativePath: string;
+};
+type GlobCandidatePath = {
+    readonly kind: 'glob';
+    readonly pattern: string;
+    readonly stripFrontmatter: boolean;
+    readonly sort: 'alpha';
+};
+type WorkspaceContextCandidate = LiteralCandidatePath | GlobCandidatePath;
+export declare const WORKSPACE_CONTEXT_CANDIDATE_PATHS: readonly WorkspaceContextCandidate[];
+export declare function stripFrontmatter(content: string): string;
+export declare function loadWorkspaceContext(workspacePath: string): Promise<string | null>;
+export {};

package/dist/daemon/io/workspace-context-loader.js

@@ -0,0 +1,137 @@
+"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.WORKSPACE_CONTEXT_CANDIDATE_PATHS = exports.MAX_GLOB_FILES_PER_PATTERN = exports.WORKSPACE_CONTEXT_MAX_BYTES = void 0;
+exports.stripFrontmatter = stripFrontmatter;
+exports.loadWorkspaceContext = loadWorkspaceContext;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const tinyglobby_1 = require("tinyglobby");
+exports.WORKSPACE_CONTEXT_MAX_BYTES = 32 * 1024;
+exports.MAX_GLOB_FILES_PER_PATTERN = 20;
+exports.WORKSPACE_CONTEXT_CANDIDATE_PATHS = [
+    { kind: 'literal', relativePath: '.claude/CLAUDE.md' },
+    { kind: 'literal', relativePath: 'CLAUDE.md' },
+    { kind: 'literal', relativePath: 'CLAUDE.local.md' },
+    { kind: 'literal', relativePath: 'AGENTS.md' },
+    { kind: 'literal', relativePath: '.github/AGENTS.md' },
+    { kind: 'glob', pattern: '.cursor/rules/*.mdc', stripFrontmatter: true, sort: 'alpha' },
+    { kind: 'literal', relativePath: '.cursorrules' },
+    { kind: 'glob', pattern: '.windsurf/rules/*.md', stripFrontmatter: true, sort: 'alpha' },
+    { kind: 'glob', pattern: '.firebender/rules/*.mdc', stripFrontmatter: true, sort: 'alpha' },
+    { kind: 'literal', relativePath: '.firebender/AGENTS.md' },
+    { kind: 'literal', relativePath: '.github/copilot-instructions.md' },
+    { kind: 'glob', pattern: '.continue/rules/*.md', stripFrontmatter: false, sort: 'alpha' },
+];
+function stripFrontmatter(content) {
+    if (!content.startsWith('---\n') && !content.startsWith('---\r\n'))
+        return content;
+    const endIdx = content.indexOf('\n---', 4);
+    if (endIdx === -1)
+        return content;
+    return content.slice(endIdx + 4).trimStart();
+}
+async function loadWorkspaceContext(workspacePath) {
+    const parts = [];
+    const injectedPaths = [];
+    let combinedBytes = 0;
+    let truncated = false;
+    function accumulateFile(relativePath, content) {
+        const contentBytes = Buffer.byteLength(content, 'utf8');
+        if (combinedBytes + contentBytes > exports.WORKSPACE_CONTEXT_MAX_BYTES) {
+            const remaining = exports.WORKSPACE_CONTEXT_MAX_BYTES - combinedBytes;
+            const truncatedContent = content.slice(0, remaining);
+            parts.push(`### ${relativePath}\n${truncatedContent}`);
+            injectedPaths.push(relativePath);
+            truncated = true;
+        }
+        else {
+            parts.push(`### ${relativePath}\n${content}`);
+            injectedPaths.push(relativePath);
+            combinedBytes += contentBytes;
+        }
+    }
+    for (const entry of exports.WORKSPACE_CONTEXT_CANDIDATE_PATHS) {
+        if (truncated)
+            break;
+        if (entry.kind === 'literal') {
+            const fullPath = path.join(workspacePath, entry.relativePath);
+            let content;
+            try {
+                content = await fs.readFile(fullPath, 'utf8');
+            }
+            catch (err) {
+                const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+                if (!isEnoent) {
+                    console.warn(`[WorkflowRunner] Skipping ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                continue;
+            }
+            accumulateFile(entry.relativePath, content);
+        }
+        else {
+            const matches = await (0, tinyglobby_1.glob)(entry.pattern, { cwd: workspacePath, absolute: false });
+            const sorted = [...matches].sort();
+            if (sorted.length > exports.MAX_GLOB_FILES_PER_PATTERN) {
+                console.warn(`[WorkflowRunner] ${entry.pattern}: ${sorted.length} files found, capped at ${exports.MAX_GLOB_FILES_PER_PATTERN}`);
+            }
+            for (const relativePath of sorted.slice(0, exports.MAX_GLOB_FILES_PER_PATTERN)) {
+                if (truncated)
+                    break;
+                const fullPath = path.join(workspacePath, relativePath);
+                let content;
+                try {
+                    content = await fs.readFile(fullPath, 'utf8');
+                }
+                catch (err) {
+                    const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+                    if (!isEnoent) {
+                        console.warn(`[WorkflowRunner] Skipping ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    continue;
+                }
+                accumulateFile(relativePath, entry.stripFrontmatter ? stripFrontmatter(content) : content);
+            }
+        }
+    }
+    if (parts.length === 0)
+        return null;
+    let combined = parts.join('\n\n');
+    if (truncated) {
+        combined += '\n\n[Workspace context truncated: combined size exceeded 32 KB limit. Some files may be missing.]';
+    }
+    console.log(`[WorkflowRunner] Injecting workspace context from: ${injectedPaths.join(', ')}`);
+    return combined;
+}

package/dist/daemon/runner/agent-loop-runner.d.ts

@@ -0,0 +1,28 @@
+import type { AgentLoop, AgentEvent, AgentLoopCallbacks } from '../agent-loop.js';
+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 type { SessionState } from '../state/session-state.js';
+import type { StuckConfig } from '../state/stuck-detection.js';
+import { ActiveSessionSet } from '../active-sessions.js';
+import type { WorkflowTrigger } from '../types.js';
+import type { PreAgentSession, AgentReadySession, SessionOutcome } from './runner-types.js';
+import type { runWorkflow } from '../workflow-runner.js';
+import type { EnricherResult } from '../workflow-enricher.js';
+export interface TurnEndSubscriberContext {
+    readonly agent: AgentLoop;
+    readonly state: SessionState;
+    readonly stuckConfig: StuckConfig;
+    readonly sessionId: string;
+    readonly workflowId: string;
+    readonly emitter: DaemonEventEmitter | undefined;
+    readonly conversationPath: string;
+    readonly lastFlushedRef: {
+        count: number;
+    };
+    readonly stuckRepeatThreshold: number;
+}
+export declare function buildTurnEndSubscriber(ctx: TurnEndSubscriberContext): (event: AgentEvent) => Promise<void>;
+export declare function buildAgentCallbacks(sessionId: string, state: SessionState, modelId: string, emitter: DaemonEventEmitter | undefined, stuckRepeatThreshold: number, workflowId?: string): AgentLoopCallbacks;
+export declare function buildAgentReadySession(preAgentSession: PreAgentSession, trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, sessionId: string, emitter: DaemonEventEmitter | undefined, daemonRegistry: DaemonRegistry | undefined, activeSessionSet: ActiveSessionSet | undefined, runWorkflowFn: typeof runWorkflow, enricherResult?: EnricherResult): Promise<AgentReadySession>;
+export declare function runAgentLoop(session: AgentReadySession, trigger: WorkflowTrigger, conversationPath: string): Promise<SessionOutcome>;

package/dist/daemon/runner/agent-loop-runner.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTurnEndSubscriber = buildTurnEndSubscriber;
+exports.buildAgentCallbacks = buildAgentCallbacks;
+exports.buildAgentReadySession = buildAgentReadySession;
+exports.runAgentLoop = runAgentLoop;
+const agent_loop_js_1 = require("../agent-loop.js");
+const index_js_1 = require("../state/index.js");
+const session_context_js_1 = require("../core/session-context.js");
+const assert_never_js_1 = require("../../runtime/assert-never.js");
+const index_js_2 = require("../io/index.js");
+const index_js_3 = require("../io/index.js");
+const context_loader_js_1 = require("../context-loader.js");
+const session_scope_js_1 = require("../session-scope.js");
+const _shared_js_1 = require("../tools/_shared.js");
+const step_injector_js_1 = require("../turn-end/step-injector.js");
+const conversation_flusher_js_1 = require("../turn-end/conversation-flusher.js");
+const tool_schemas_js_1 = require("./tool-schemas.js");
+const construct_tools_js_1 = require("./construct-tools.js");
+function buildTurnEndSubscriber(ctx) {
+    return async (event) => {
+        if (event.type !== 'turn_end')
+            return;
+        for (const toolResult of event.toolResults) {
+            if (toolResult.isError) {
+                const errorText = toolResult.result?.content[0]?.text ?? 'tool error';
+                ctx.emitter?.emit({ kind: 'tool_error', sessionId: ctx.sessionId, toolName: toolResult.toolName, error: errorText.slice(0, 200), ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
+            }
+        }
+        ctx.state.turnCount++;
+        const signal = (0, index_js_1.evaluateStuckSignals)(ctx.state, ctx.stuckConfig);
+        if (signal !== null) {
+            if (signal.kind === 'max_turns_exceeded') {
+                (0, index_js_1.setTerminalSignal)(ctx.state, { kind: 'timeout', reason: 'max_turns' });
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'timeout_imminent', detail: 'Max-turn limit reached', ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
+                ctx.agent.abort();
+                return;
+            }
+            else if (signal.kind === 'repeated_tool_call') {
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'repeated_tool_call', detail: `Same tool+args called ${ctx.stuckRepeatThreshold} times: ${signal.toolName}`, toolName: signal.toolName, argsSummary: signal.argsSummary, ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
+                void (0, index_js_3.writeStuckOutboxEntry)({ workflowId: ctx.workflowId, reason: 'repeated_tool_call', ...(ctx.state.issueSummaries.length > 0 ? { issueSummaries: [...ctx.state.issueSummaries] } : {}) });
+                if (ctx.stuckConfig.stuckAbortPolicy !== 'notify_only') {
+                    if ((0, index_js_1.setTerminalSignal)(ctx.state, { kind: 'stuck', reason: 'repeated_tool_call' })) {
+                        ctx.agent.abort();
+                        return;
+                    }
+                }
+            }
+            else if (signal.kind === 'no_progress') {
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'no_progress', detail: `${signal.turnCount} turns used, 0 step advances (${signal.maxTurns} turn limit)`, ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
+                if (ctx.stuckConfig.noProgressAbortEnabled) {
+                    void (0, index_js_3.writeStuckOutboxEntry)({ workflowId: ctx.workflowId, reason: 'no_progress', ...(ctx.state.issueSummaries.length > 0 ? { issueSummaries: [...ctx.state.issueSummaries] } : {}) });
+                    if (ctx.stuckConfig.stuckAbortPolicy !== 'notify_only') {
+                        if ((0, index_js_1.setTerminalSignal)(ctx.state, { kind: 'stuck', reason: 'no_progress' })) {
+                            ctx.agent.abort();
+                            return;
+                        }
+                    }
+                }
+            }
+            else if (signal.kind === 'timeout_imminent') {
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'timeout_imminent', detail: `${signal.timeoutReason === 'wall_clock' ? 'Wall-clock timeout' : 'Max-turn limit'} reached`, ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
+            }
+            else {
+                (0, assert_never_js_1.assertNever)(signal);
+            }
+        }
+        (0, conversation_flusher_js_1.flushConversation)(ctx.agent.state.messages, ctx.lastFlushedRef, ctx.conversationPath, index_js_3.appendConversationMessages);
+        (0, step_injector_js_1.injectPendingSteps)(ctx.state, ctx.agent);
+    };
+}
+function buildAgentCallbacks(sessionId, state, modelId, emitter, stuckRepeatThreshold, workflowId) {
+    return {
+        onLlmTurnStarted: ({ messageCount }) => {
+            emitter?.emit({ kind: 'llm_turn_started', sessionId, messageCount, modelId, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
+        },
+        onLlmTurnCompleted: ({ stopReason, outputTokens, inputTokens, toolNamesRequested }) => {
+            emitter?.emit({ kind: 'llm_turn_completed', sessionId, stopReason, outputTokens, inputTokens, toolNamesRequested, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
+        },
+        onToolCallStarted: ({ toolName, argsSummary }) => {
+            emitter?.emit({ kind: 'tool_call_started', sessionId, toolName, argsSummary, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
+            (0, index_js_1.recordToolCall)(state, toolName, argsSummary, stuckRepeatThreshold);
+        },
+        onToolCallCompleted: ({ toolName, durationMs, resultSummary }) => {
+            emitter?.emit({ kind: 'tool_call_completed', sessionId, toolName, durationMs, resultSummary, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
+        },
+        onToolCallFailed: ({ toolName, durationMs, errorMessage }) => {
+            emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
+        },
+        onStallDetected: () => {
+            (0, index_js_1.setTerminalSignal)(state, { kind: 'stuck', reason: 'stall' });
+            emitter?.emit({
+                kind: 'agent_stuck',
+                sessionId,
+                reason: 'stall',
+                detail: `No LLM API call started within the stall timeout window. Last tool calls: ${state.lastNToolCalls.map((c) => c.toolName).join(', ') || 'none'}`,
+                ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId),
+            });
+            void (0, index_js_3.writeStuckOutboxEntry)({
+                workflowId: workflowId ?? sessionId,
+                reason: 'stall',
+                ...(state.issueSummaries.length > 0 ? { issueSummaries: [...state.issueSummaries] } : {}),
+            });
+        },
+    };
+}
+function buildUserMessage(text) {
+    return { role: 'user', content: text, timestamp: Date.now() };
+}
+async function buildAgentReadySession(preAgentSession, trigger, ctx, apiKey, sessionId, emitter, daemonRegistry, activeSessionSet, runWorkflowFn, enricherResult) {
+    const { state, firstStepPrompt, sessionWorkspacePath, sessionWorktreePath, agentClient, modelId } = preAgentSession;
+    const startContinueToken = preAgentSession.continueToken;
+    const handle = preAgentSession.handle;
+    const MAX_ISSUE_SUMMARIES = 10;
+    const STUCK_REPEAT_THRESHOLD = 3;
+    const onAdvance = (stepText, continueToken) => {
+        (0, index_js_1.advanceStep)(state, stepText, continueToken);
+        if (state.workrailSessionId !== null)
+            daemonRegistry?.heartbeat(state.workrailSessionId);
+        emitter?.emit({ kind: 'step_advanced', sessionId, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
+    };
+    const onComplete = (notes, artifacts) => {
+        (0, index_js_1.recordCompletion)(state, notes, artifacts);
+    };
+    const schemas = (0, tool_schemas_js_1.getSchemas)();
+    const scope = {
+        fileTracker: new session_scope_js_1.DefaultFileStateTracker(preAgentSession.readFileState),
+        onAdvance,
+        onComplete,
+        onTokenUpdate: (t) => { (0, index_js_1.updateToken)(state, t); },
+        onIssueReported: (summary) => {
+            if (state.issueSummaries.length < MAX_ISSUE_SUMMARIES) {
+                state.issueSummaries.push(summary);
+            }
+        },
+        onSteer: (text) => { state.pendingSteerParts.push(text); },
+        getCurrentToken: () => state.currentContinueToken,
+        sessionWorkspacePath,
+        spawnCurrentDepth: preAgentSession.spawnCurrentDepth,
+        spawnMaxDepth: preAgentSession.spawnMaxDepth,
+        workrailSessionId: state.workrailSessionId,
+        emitter,
+        sessionId,
+        workflowId: trigger.workflowId,
+        activeSessionSet,
+    };
+    const tools = (0, construct_tools_js_1.constructTools)(ctx, apiKey, schemas, scope, runWorkflowFn);
+    const contextLoader = new context_loader_js_1.DefaultContextLoader(index_js_2.loadDaemonSoul, index_js_2.loadWorkspaceContext, index_js_2.loadSessionNotes, ctx);
+    const baseCtx = await contextLoader.loadBase(trigger);
+    const contextBundle = await contextLoader.loadSession(startContinueToken, baseCtx);
+    const effectiveWorkspacePath = sessionWorkspacePath;
+    const sessionCtx = (0, session_context_js_1.buildSessionContext)(trigger, contextBundle, firstStepPrompt || 'No step content available', effectiveWorkspacePath, enricherResult);
+    const agentCallbacks = buildAgentCallbacks(sessionId, state, modelId, emitter, STUCK_REPEAT_THRESHOLD, trigger.workflowId);
+    const agent = new agent_loop_js_1.AgentLoop({
+        systemPrompt: sessionCtx.systemPrompt,
+        modelId,
+        tools,
+        client: agentClient,
+        toolExecution: 'sequential',
+        callbacks: agentCallbacks,
+        ...(trigger.agentConfig?.maxOutputTokens !== undefined
+            ? { maxTokens: trigger.agentConfig.maxOutputTokens }
+            : {}),
+        stallTimeoutMs: sessionCtx.stallTimeoutMs,
+    });
+    handle?.setAgent(agent);
+    return {
+        preAgentSession,
+        contextBundle,
+        scope,
+        tools,
+        sessionCtx,
+        handle,
+        sessionId,
+        workflowId: trigger.workflowId,
+        worktreePath: sessionWorktreePath,
+        agent,
+        stuckRepeatThreshold: STUCK_REPEAT_THRESHOLD,
+    };
+}
+async function runAgentLoop(session, trigger, conversationPath) {
+    const { agent, preAgentSession, sessionCtx, sessionId, handle } = session;
+    const { state } = preAgentSession;
+    const { emitter } = session.scope;
+    const { stuckRepeatThreshold } = session;
+    const { sessionTimeoutMs, maxTurns } = sessionCtx;
+    const stuckConfig = {
+        maxTurns,
+        stuckAbortPolicy: trigger.agentConfig?.stuckAbortPolicy ?? 'abort',
+        noProgressAbortEnabled: trigger.agentConfig?.noProgressAbortEnabled ?? false,
+        stuckRepeatThreshold,
+    };
+    const lastFlushedRef = { count: 0 };
+    const unsubscribe = agent.subscribe(buildTurnEndSubscriber({
+        agent,
+        state,
+        stuckConfig,
+        sessionId,
+        workflowId: trigger.workflowId,
+        emitter,
+        conversationPath,
+        lastFlushedRef,
+        stuckRepeatThreshold,
+    }));
+    let stopReason = 'stop';
+    let errorMessage;
+    let timeoutHandle;
+    try {
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                (0, index_js_1.setTerminalSignal)(state, { kind: 'timeout', reason: 'wall_clock' });
+                reject(new Error('Workflow timed out'));
+            }, sessionTimeoutMs);
+        });
+        console.log(`[WorkflowRunner] Agent loop started: sessionId=${sessionId} workflowId=${trigger.workflowId} modelId=${preAgentSession.modelId}`);
+        await Promise.race([agent.prompt(buildUserMessage(sessionCtx.initialPrompt)), timeoutPromise])
+            .catch((err) => {
+            agent.abort();
+            throw err;
+        });
+        const messages = agent.state.messages;
+        let lastAssistant;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            if ('role' in m && m.role === 'assistant') {
+                lastAssistant = m;
+                break;
+            }
+        }
+        stopReason = lastAssistant?.stopReason ?? 'stop';
+        errorMessage = lastAssistant?.errorMessage;
+    }
+    catch (err) {
+        errorMessage = err instanceof Error ? err.message : String(err);
+        stopReason = 'error';
+    }
+    finally {
+        unsubscribe();
+        const remainingMessages = agent.state.messages.slice(lastFlushedRef.count);
+        void (0, index_js_3.appendConversationMessages)(conversationPath, remainingMessages).catch(() => { });
+        if (timeoutHandle !== undefined)
+            clearTimeout(timeoutHandle);
+        handle?.dispose();
+        console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
+    }
+    if (stopReason === 'error') {
+        return { kind: 'aborted', errorMessage };
+    }
+    return { kind: 'completed', stopReason, errorMessage };
+}

package/dist/daemon/runner/construct-tools.d.ts

@@ -0,0 +1,5 @@
+import type { AgentTool } from '../agent-loop.js';
+import type { V2ToolContext } from '../../mcp/types.js';
+import type { SessionScope } from '../session-scope.js';
+import type { runWorkflow } from '../workflow-runner.js';
+export declare function constructTools(ctx: V2ToolContext, apiKey: string, schemas: Record<string, any>, scope: SessionScope, runWorkflowFn: typeof runWorkflow): readonly AgentTool[];

package/dist/daemon/runner/construct-tools.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructTools = constructTools;
+const index_js_1 = require("../../mcp/handlers/v2-execution/index.js");
+const continue_workflow_js_1 = require("../tools/continue-workflow.js");
+const bash_js_1 = require("../tools/bash.js");
+const file_tools_js_1 = require("../tools/file-tools.js");
+const glob_grep_js_1 = require("../tools/glob-grep.js");
+const spawn_agent_js_1 = require("../tools/spawn-agent.js");
+const report_issue_js_1 = require("../tools/report-issue.js");
+const signal_coordinator_js_1 = require("../tools/signal-coordinator.js");
+function constructTools(ctx, apiKey, schemas, scope, runWorkflowFn) {
+    const { fileTracker, onAdvance, onComplete, onTokenUpdate, onIssueReported, getCurrentToken, sessionWorkspacePath, spawnCurrentDepth, spawnMaxDepth, emitter, activeSessionSet, } = scope;
+    const sid = scope.sessionId;
+    const workrailSid = scope.workrailSessionId;
+    const readFileStateMap = fileTracker.toMap();
+    return [
+        (0, continue_workflow_js_1.makeCompleteStepTool)(sid, ctx, getCurrentToken, onAdvance, onComplete, onTokenUpdate, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSid),
+        (0, continue_workflow_js_1.makeContinueWorkflowTool)(sid, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSid),
+        (0, bash_js_1.makeBashTool)(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
+        (0, file_tools_js_1.makeReadTool)(sessionWorkspacePath, readFileStateMap, schemas, sid, emitter, workrailSid),
+        (0, file_tools_js_1.makeWriteTool)(sessionWorkspacePath, readFileStateMap, schemas, sid, emitter, workrailSid),
+        (0, glob_grep_js_1.makeGlobTool)(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
+        (0, glob_grep_js_1.makeGrepTool)(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
+        (0, file_tools_js_1.makeEditTool)(sessionWorkspacePath, readFileStateMap, schemas, sid, emitter, workrailSid),
+        (0, report_issue_js_1.makeReportIssueTool)(sid, emitter, workrailSid, undefined, onIssueReported),
+        (0, spawn_agent_js_1.makeSpawnAgentTool)(sid, ctx, apiKey, workrailSid ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflowFn, schemas, emitter, activeSessionSet),
+        (0, signal_coordinator_js_1.makeSignalCoordinatorTool)(sid, emitter, workrailSid),
+    ];
+}

package/dist/daemon/runner/finalize-session.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowRunResult } from '../types.js';
+import type { FinalizationContext } from './runner-types.js';
+export declare function finalizeSession(result: WorkflowRunResult, ctx: FinalizationContext): Promise<void>;

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>;