@exaudeus/workrail 3.72.0 → 3.72.1

package/dist/daemon/active-sessions.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveSessionSet = void 0;
+class SessionHandleImpl {
+    constructor(sessionId, onSteer, set) {
+        this._agent = null;
+        this.sessionId = sessionId;
+        this._onSteer = onSteer;
+        this._set = set;
+    }
+    steer(text) {
+        this._onSteer(text);
+    }
+    setAgent(agent) {
+        if (this._agent === null) {
+            this._agent = agent;
+        }
+    }
+    abort() {
+        if (this._agent !== null) {
+            this._agent.abort();
+        }
+    }
+    dispose() {
+        this._set._remove(this.sessionId);
+    }
+}
+class ActiveSessionSet {
+    constructor() {
+        this._handles = new Map();
+    }
+    register(sessionId, onSteer) {
+        const handle = new SessionHandleImpl(sessionId, onSteer, this);
+        this._handles.set(sessionId, handle);
+        return handle;
+    }
+    get(sessionId) {
+        return this._handles.get(sessionId);
+    }
+    sessionIds() {
+        return this._handles.keys();
+    }
+    abortAll() {
+        for (const handle of this._handles.values()) {
+            handle.abort();
+        }
+    }
+    get size() {
+        return this._handles.size;
+    }
+    _remove(sessionId) {
+        this._handles.delete(sessionId);
+    }
+}
+exports.ActiveSessionSet = ActiveSessionSet;

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

@@ -0,0 +1,32 @@
+import type { WorkflowTrigger } from './workflow-runner.js';
+import type { V2ToolContext } from '../mcp/types.js';
+export interface ContextRule {
+    readonly source: string;
+    readonly content: string;
+    readonly truncated: boolean;
+}
+export interface SessionNote {
+    readonly nodeId: string;
+    readonly stepId: string;
+    readonly content: string;
+}
+export interface BaseContext {
+    readonly soulContent: string;
+    readonly workspaceRules: readonly ContextRule[];
+}
+export interface ContextBundle extends BaseContext {
+    readonly sessionHistory: readonly SessionNote[];
+}
+export interface ContextLoader {
+    loadBase(trigger: WorkflowTrigger): Promise<BaseContext>;
+    loadSession(continueToken: string | null, base: BaseContext): Promise<ContextBundle>;
+}
+export declare class DefaultContextLoader implements ContextLoader {
+    private readonly _loadSoul;
+    private readonly _loadWorkspace;
+    private readonly _loadNotes;
+    private readonly _ctx;
+    constructor(_loadSoul: (resolvedPath?: string) => Promise<string>, _loadWorkspace: (workspacePath: string) => Promise<string | null>, _loadNotes: (continueToken: string, ctx: V2ToolContext) => Promise<readonly string[]>, _ctx: V2ToolContext);
+    loadBase(trigger: WorkflowTrigger): Promise<BaseContext>;
+    loadSession(continueToken: string | null, base: BaseContext): Promise<ContextBundle>;
+}

package/dist/daemon/context-loader.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultContextLoader = void 0;
+class DefaultContextLoader {
+    constructor(_loadSoul, _loadWorkspace, _loadNotes, _ctx) {
+        this._loadSoul = _loadSoul;
+        this._loadWorkspace = _loadWorkspace;
+        this._loadNotes = _loadNotes;
+        this._ctx = _ctx;
+    }
+    async loadBase(trigger) {
+        const [soulContent, workspaceContextStr] = await Promise.all([
+            this._loadSoul(trigger.soulFile),
+            this._loadWorkspace(trigger.workspacePath),
+        ]);
+        const workspaceRules = workspaceContextStr !== null
+            ? [{ source: 'workspace-context', content: workspaceContextStr, truncated: false }]
+            : [];
+        return { soulContent, workspaceRules };
+    }
+    async loadSession(continueToken, base) {
+        if (!continueToken) {
+            return { ...base, sessionHistory: [] };
+        }
+        const notes = await this._loadNotes(continueToken, this._ctx);
+        const sessionHistory = notes.map((content) => ({
+            nodeId: '',
+            stepId: '',
+            content,
+        }));
+        return { ...base, sessionHistory };
+    }
+}
+exports.DefaultContextLoader = DefaultContextLoader;

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

@@ -1,4 +1,5 @@
-import type { ReadFileState, AbortRegistry } from './workflow-runner.js';
+import type { ReadFileState } from './workflow-runner.js';
+import type { ActiveSessionSet } from './active-sessions.js';
 import type { DaemonEventEmitter } from './daemon-events.js';
 export interface FileStateTracker {
     recordRead(filePath: string, content: string, timestamp: number, isPartialView: boolean): void;
@@ -22,6 +23,6 @@ export interface SessionScope {
     readonly emitter: DaemonEventEmitter | undefined;
     readonly sessionId: string;
     readonly workflowId: string;
-    readonly abortRegistry: AbortRegistry | undefined;
+    readonly activeSessionSet: ActiveSessionSet | undefined;
     readonly maxIssueSummaries: number;
 }

package/dist/daemon/tools/_shared.d.ts

@@ -0,0 +1,38 @@
+import type { Result } from '../../runtime/result.js';
+export declare const DAEMON_SESSIONS_DIR: string;
+export declare const BASH_TIMEOUT_MS: number;
+export declare const READ_SIZE_CAP_BYTES: number;
+export declare const GLOB_ALWAYS_EXCLUDE: string[];
+export declare function withWorkrailSession(sid: string | null | undefined): {
+    workrailSessionId?: string;
+};
+export interface PersistTokensError {
+    readonly code: string;
+    readonly message: string;
+}
+export declare function persistTokens(sessionId: string, continueToken: string, checkpointToken: string | null, worktreePath?: string, recoveryContext?: {
+    readonly workflowId: string;
+    readonly goal: string;
+    readonly workspacePath: string;
+}): Promise<Result<void, PersistTokensError>>;
+export declare function findActualString(fileContent: string, oldString: string): string | null;
+export interface IssueRecord {
+    sessionId: string;
+    kind: 'tool_failure' | 'blocked' | 'unexpected_behavior' | 'needs_human' | 'self_correction';
+    severity: 'info' | 'warn' | 'error' | 'fatal';
+    summary: string;
+    context?: string;
+    toolName?: string;
+    command?: string;
+    suggestedFix?: string;
+    continueToken?: string;
+}
+export declare function appendIssueAsync(issuesDir: string, sessionId: string, record: IssueRecord): Promise<void>;
+export interface SignalRecord {
+    readonly signalId: string;
+    readonly sessionId: string;
+    readonly workrailSessionId?: string;
+    readonly signalKind: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+}
+export declare function appendSignalAsync(signalsDir: string, sessionId: string, record: SignalRecord): Promise<void>;

package/dist/daemon/tools/_shared.js

@@ -0,0 +1,101 @@
+"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.GLOB_ALWAYS_EXCLUDE = exports.READ_SIZE_CAP_BYTES = exports.BASH_TIMEOUT_MS = exports.DAEMON_SESSIONS_DIR = void 0;
+exports.withWorkrailSession = withWorkrailSession;
+exports.persistTokens = persistTokens;
+exports.findActualString = findActualString;
+exports.appendIssueAsync = appendIssueAsync;
+exports.appendSignalAsync = appendSignalAsync;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const result_js_1 = require("../../runtime/result.js");
+exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
+exports.BASH_TIMEOUT_MS = 5 * 60 * 1000;
+exports.READ_SIZE_CAP_BYTES = 256 * 1024;
+exports.GLOB_ALWAYS_EXCLUDE = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'];
+function withWorkrailSession(sid) {
+    return sid != null ? { workrailSessionId: sid } : {};
+}
+async function persistTokens(sessionId, continueToken, checkpointToken, worktreePath, recoveryContext) {
+    try {
+        await fs.mkdir(exports.DAEMON_SESSIONS_DIR, { recursive: true });
+        const sessionPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
+        const state = JSON.stringify({
+            continueToken,
+            checkpointToken,
+            ts: Date.now(),
+            ...(worktreePath !== undefined ? { worktreePath } : {}),
+            ...(recoveryContext !== undefined ? {
+                workflowId: recoveryContext.workflowId,
+                goal: recoveryContext.goal,
+                workspacePath: recoveryContext.workspacePath,
+            } : {}),
+        }, null, 2);
+        const tmp = `${sessionPath}.tmp`;
+        await fs.writeFile(tmp, state, 'utf8');
+        await fs.rename(tmp, sessionPath);
+        return (0, result_js_1.ok)(undefined);
+    }
+    catch (e) {
+        const nodeErr = e;
+        return (0, result_js_1.err)({ code: nodeErr.code ?? 'UNKNOWN', message: nodeErr.message ?? String(e) });
+    }
+}
+function findActualString(fileContent, oldString) {
+    if (fileContent.includes(oldString))
+        return oldString;
+    const normalized = oldString
+        .replace(/[‘’]/g, "'")
+        .replace(/[“”]/g, '"')
+        .replace(/–/g, '-')
+        .replace(/—/g, '--');
+    if (fileContent.includes(normalized))
+        return normalized;
+    return null;
+}
+async function appendIssueAsync(issuesDir, sessionId, record) {
+    await fs.mkdir(issuesDir, { recursive: true });
+    const filePath = path.join(issuesDir, `${sessionId}.jsonl`);
+    const line = JSON.stringify({ ...record, ts: Date.now() }) + '\n';
+    await fs.appendFile(filePath, line, 'utf8');
+}
+async function appendSignalAsync(signalsDir, sessionId, record) {
+    await fs.mkdir(signalsDir, { recursive: true });
+    const filePath = path.join(signalsDir, `${sessionId}.jsonl`);
+    const line = JSON.stringify({ ...record, ts: Date.now() }) + '\n';
+    await fs.appendFile(filePath, line, 'utf8');
+}

package/dist/daemon/tools/bash.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from '../agent-loop.js';
+import type { DaemonEventEmitter } from '../daemon-events.js';
+export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;

package/dist/daemon/tools/bash.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBashTool = makeBashTool;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const _shared_js_1 = require("./_shared.js");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+function makeBashTool(workspacePath, schemas, sessionId, emitter, workrailSessionId) {
+    return {
+        name: 'Bash',
+        description: 'Execute a shell command. Throws on failure (non-zero exit with stderr, or exit code 2+). ' +
+            'Exit code 1 with empty stderr is treated as "no match found" (standard grep semantics) and ' +
+            'returns empty output without throwing. ' +
+            `Maximum execution time: ${_shared_js_1.BASH_TIMEOUT_MS / 1000}s.`,
+        inputSchema: schemas['BashParams'],
+        label: 'Bash',
+        execute: async (_toolCallId, params) => {
+            if (typeof params.command !== 'string' || !params.command)
+                throw new Error('Bash: command must be a non-empty string');
+            console.log(`[WorkflowRunner] Tool: bash "${String(params.command).slice(0, 80)}"`);
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Bash', summary: String(params.command).slice(0, 80), ...(0, _shared_js_1.withWorkrailSession)(workrailSessionId) });
+            const cwd = params.cwd ?? workspacePath;
+            try {
+                const { stdout, stderr } = await execAsync(params.command, {
+                    cwd,
+                    timeout: _shared_js_1.BASH_TIMEOUT_MS,
+                    shell: '/bin/bash',
+                });
+                const output = [stdout, stderr].filter(Boolean).join('\n');
+                return {
+                    content: [{ type: 'text', text: output || '(no output)' }],
+                    details: { stdout, stderr },
+                };
+            }
+            catch (err) {
+                const e = err;
+                const stdout = String(e.stdout ?? '');
+                const stderr = String(e.stderr ?? '');
+                const rawCode = e.code;
+                const signal = e.signal;
+                if (rawCode === 1 && !stderr.trim()) {
+                    return {
+                        content: [{ type: 'text', text: stdout || '(no output)' }],
+                        details: { stdout, stderr },
+                    };
+                }
+                const exitInfo = rawCode != null
+                    ? `exit ${String(rawCode)}`
+                    : signal
+                        ? `signal ${String(signal)}`
+                        : 'exit unknown';
+                throw new Error(`Command failed: ${params.command} (${exitInfo})\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`);
+            }
+        },
+    };
+}

package/dist/daemon/tools/continue-workflow.d.ts

@@ -0,0 +1,6 @@
+import type { AgentTool } from '../agent-loop.js';
+import type { V2ToolContext } from '../../mcp/types.js';
+import type { DaemonEventEmitter } from '../daemon-events.js';
+import { executeContinueWorkflow } from '../../mcp/handlers/v2-execution/index.js';
+export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined, artifacts?: readonly unknown[]) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeCompleteStepTool(sessionId: string, ctx: V2ToolContext, getCurrentToken: () => string, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined, artifacts?: readonly unknown[]) => void, onTokenUpdate: (t: string) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;

package/dist/daemon/tools/continue-workflow.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeContinueWorkflowTool = makeContinueWorkflowTool;
+exports.makeCompleteStepTool = makeCompleteStepTool;
+const index_js_1 = require("../../mcp/handlers/v2-execution/index.js");
+const _shared_js_1 = require("./_shared.js");
+function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, emitter, workrailSessionId) {
+    return {
+        name: 'continue_workflow',
+        description: '[DEPRECATED in daemon sessions -- use complete_step instead] ' +
+            'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
+            'required by the current step. Include your notes in notesMarkdown. ' +
+            'When the step requires an assessment gate, include wr.assessment objects in artifacts.',
+        inputSchema: schemas['ContinueWorkflowParams'],
+        label: 'Continue Workflow',
+        execute: async (_toolCallId, params) => {
+            console.log(`[WorkflowRunner] Tool: continue_workflow sessionId=${sessionId}`);
+            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'continue_workflow', summary: params.intent ?? 'advance', ...(0, _shared_js_1.withWorkrailSession)(workrailSessionId) });
+            const result = await _executeContinueWorkflowFn({
+                continueToken: params.continueToken,
+                intent: (params.intent ?? 'advance'),
+                output: (params.notesMarkdown || params.artifacts?.length)
+                    ? {
+                        ...(params.notesMarkdown ? { notesMarkdown: params.notesMarkdown } : {}),
+                        ...(params.artifacts ? { artifacts: params.artifacts } : {}),
+                    }
+                    : undefined,
+                context: params.context,
+            }, ctx);
+            if (result.isErr()) {
+                throw new Error(`continue_workflow failed: ${result.error.kind} -- ${JSON.stringify(result.error)}`);
+            }
+            const out = result.value.response;
+            const continueToken = out.continueToken ?? '';
+            const checkpointToken = out.checkpointToken ?? null;
+            const persistToken = (out.kind === 'blocked' ? out.nextCall?.params.continueToken : undefined) ?? continueToken;
+            if (persistToken) {
+                const persistResult = await (0, _shared_js_1.persistTokens)(sessionId, persistToken, checkpointToken);
+                if (persistResult.kind === 'err') {
+                    console.warn(`[WorkflowRunner] persistTokens failed (continue_workflow): ${persistResult.error.code} -- ${persistResult.error.message}`);
+                }
+            }
+            if (out.kind === 'blocked') {
+                const retryToken = out.nextCall?.params.continueToken ?? continueToken;
+                const lines = ['## Step blocked -- action required\n'];
+                for (const blocker of out.blockers.blockers) {
+                    lines.push(blocker.message);
+                    if (blocker.suggestedFix) {
+                        lines.push(`\nWhat to do: ${blocker.suggestedFix}`);
+                    }
+                    lines.push('');
+                }
+                if (out.validation) {
+                    if (out.validation.issues.length > 0) {
+                        lines.push('**Issues:**');
+                        for (const issue of out.validation.issues)
+                            lines.push(`- ${issue}`);
+                        lines.push('');
+                    }
+                    if (out.validation.suggestions.length > 0) {
+                        lines.push('**Suggestions:**');
+                        for (const s of out.validation.suggestions)
+                            lines.push(`- ${s}`);
+                        lines.push('');
+                    }
+                }
+                if (out.assessmentFollowup) {
+                    lines.push(`**Follow-up required:** ${out.assessmentFollowup.title}`);
+                    lines.push(out.assessmentFollowup.guidance);
+                    lines.push('');
+                }
+                if (out.retryable) {
+                    lines.push(`Retry the same step with corrected output.\n\ncontinueToken: ${retryToken}`);
+                }
+                else {
+                    lines.push(`You cannot proceed without resolving this. Inform the user and wait for their response, then call continue_workflow.\n\ncontinueToken: ${retryToken}`);
+                }
+                const feedback = lines.join('\n');
+                return {
+                    content: [{ type: 'text', text: feedback }],
+                    details: out,
+                };
+            }
+            if (out.isComplete) {
+                onComplete(params.notesMarkdown, Array.isArray(params.artifacts) ? params.artifacts : undefined);
+                return {
+                    content: [{ type: 'text', text: 'Workflow complete. All steps have been executed.' }],
+                    details: out,
+                };
+            }
+            const pending = out.pending;
+            const stepText = pending
+                ? `## Next step: ${pending.title}\n\n${pending.prompt}\n\ncontinueToken: ${continueToken}`
+                : `Step advanced. continueToken: ${continueToken}`;
+            onAdvance(stepText, continueToken);
+            return {
+                content: [{ type: 'text', text: stepText }],
+                details: out,
+            };
+        },
+    };
+}
+function makeCompleteStepTool(sessionId, ctx, getCurrentToken, onAdvance, onComplete, onTokenUpdate, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, emitter, workrailSessionId) {
+    return {
+        name: 'complete_step',
+        description: 'Mark the current WorkRail workflow step as complete and advance to the next one. ' +
+            'Call this after completing all work required by the current step. ' +
+            'Include your substantive notes (min 50 characters) describing what you did. ' +
+            'The daemon manages the session token internally -- you do not need a continueToken. ' +
+            'When the step requires an assessment gate, include wr.assessment objects in artifacts.',
+        inputSchema: schemas['CompleteStepParams'],
+        label: 'Complete Step',
+        execute: async (_toolCallId, params) => {
+            console.log(`[WorkflowRunner] Tool: complete_step sessionId=${sessionId}`);
+            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'complete_step', summary: 'advance', ...(0, _shared_js_1.withWorkrailSession)(workrailSessionId) });
+            const notes = params.notes;
+            if (!notes || notes.length < 50) {
+                throw new Error(`complete_step: notes is required and must be at least 50 characters. ` +
+                    `Provide substantive notes describing what you did, what you produced, and any notable decisions. ` +
+                    `Current length: ${notes?.length ?? 0} characters.`);
+            }
+            const continueToken = getCurrentToken();
+            const result = await _executeContinueWorkflowFn({
+                continueToken,
+                intent: 'advance',
+                output: (notes || params.artifacts?.length)
+                    ? {
+                        notesMarkdown: notes,
+                        ...(params.artifacts?.length ? { artifacts: params.artifacts } : {}),
+                    }
+                    : undefined,
+                context: params.context,
+            }, ctx);
+            if (result.isErr()) {
+                throw new Error(`complete_step failed: ${result.error.kind} -- ${JSON.stringify(result.error)}`);
+            }
+            const out = result.value.response;
+            const newContinueToken = out.continueToken ?? '';
+            const checkpointToken = out.checkpointToken ?? null;
+            const persistToken = (out.kind === 'blocked' ? out.nextCall?.params.continueToken : undefined) ?? newContinueToken;
+            if (persistToken) {
+                const persistResult = await (0, _shared_js_1.persistTokens)(sessionId, persistToken, checkpointToken);
+                if (persistResult.kind === 'err') {
+                    console.warn(`[WorkflowRunner] persistTokens failed (complete_step): ${persistResult.error.code} -- ${persistResult.error.message}`);
+                }
+            }
+            if (out.kind === 'blocked') {
+                const retryToken = out.nextCall?.params.continueToken ?? newContinueToken;
+                onTokenUpdate(retryToken);
+                const lines = ['## Step blocked -- action required\n'];
+                for (const blocker of out.blockers.blockers) {
+                    lines.push(blocker.message);
+                    if (blocker.suggestedFix) {
+                        lines.push(`\nWhat to do: ${blocker.suggestedFix}`);
+                    }
+                    lines.push('');
+                }
+                if (out.validation) {
+                    if (out.validation.issues.length > 0) {
+                        lines.push('**Issues:**');
+                        for (const issue of out.validation.issues)
+                            lines.push(`- ${issue}`);
+                        lines.push('');
+                    }
+                    if (out.validation.suggestions.length > 0) {
+                        lines.push('**Suggestions:**');
+                        for (const s of out.validation.suggestions)
+                            lines.push(`- ${s}`);
+                        lines.push('');
+                    }
+                }
+                if (out.assessmentFollowup) {
+                    lines.push(`**Follow-up required:** ${out.assessmentFollowup.title}`);
+                    lines.push(out.assessmentFollowup.guidance);
+                    lines.push('');
+                }
+                if (out.retryable) {
+                    lines.push(`Retry the same step: call complete_step again with corrected notes.`);
+                }
+                else {
+                    lines.push(`You cannot proceed without resolving this. Inform the user and wait for their response, then call complete_step.`);
+                }
+                const feedback = lines.join('\n');
+                return {
+                    content: [{ type: 'text', text: feedback }],
+                    details: out,
+                };
+            }
+            if (out.isComplete) {
+                onComplete(notes, Array.isArray(params.artifacts) ? params.artifacts : undefined);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ status: 'complete' }) }],
+                    details: out,
+                };
+            }
+            const pending = out.pending;
+            const nextStepTitle = pending?.title ?? 'Next step';
+            const stepText = pending
+                ? `${JSON.stringify({ status: 'advanced', nextStep: pending.title })}\n\n## ${pending.title}\n\n${pending.prompt}`
+                : JSON.stringify({ status: 'advanced', nextStep: nextStepTitle });
+            onAdvance(stepText, newContinueToken);
+            return {
+                content: [{ type: 'text', text: stepText }],
+                details: out,
+            };
+        },
+    };
+}

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

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