@exaudeus/workrail 3.40.0 → 3.42.0

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

@@ -7,6 +7,11 @@ import type { V2StartWorkflowOutputSchema } from '../mcp/output-schemas.js';
 import type { DaemonEventEmitter } from './daemon-events.js';
 export declare const DAEMON_SESSIONS_DIR: string;
 export { DAEMON_SOUL_DEFAULT, DAEMON_SOUL_TEMPLATE } from './soul-template.js';
+export type ReadFileState = {
+    content: string;
+    timestamp: number;
+    isPartialView: boolean;
+};
 export interface WorkflowTrigger {
     readonly workflowId: string;
     readonly goal: string;
@@ -53,6 +58,7 @@ export interface WorkflowDeliveryFailed {
 }
 export type WorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout | WorkflowDeliveryFailed;
 export type ChildWorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout;
+export type SteerRegistry = Map<string, (text: string) => void>;
 export interface OrphanedSession {
     readonly sessionId: string;
     readonly continueToken: string;
@@ -68,8 +74,15 @@ export declare function runStartupRecovery(sessionsDir?: string): Promise<void>;
 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;
 export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+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 makeGlobTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeGrepTool(workspacePath: string, 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;
 export declare function makeSpawnAgentTool(sessionId: string, ctx: V2ToolContext, apiKey: string, thisWorkrailSessionId: string, currentDepth: number, maxDepth: number, runWorkflowFn: typeof runWorkflow, schemas: Record<string, any>, emitter?: DaemonEventEmitter): AgentTool;
 export declare function makeReportIssueTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, issuesDirOverride?: string, onIssueSummary?: (summary: string) => void): AgentTool;
+export declare const DAEMON_SIGNALS_DIR: string;
+export declare function makeSignalCoordinatorTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, signalsDirOverride?: string): AgentTool;
 export declare function buildSessionRecap(notes: readonly string[]): string;
 export declare function buildSystemPrompt(trigger: WorkflowTrigger, sessionState: string, soulContent: string, workspaceContext: string | null): string;
-export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter): Promise<WorkflowRunResult>;
+export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter, steerRegistry?: SteerRegistry): Promise<WorkflowRunResult>;

package/dist/daemon/workflow-runner.js

@@ -36,15 +36,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = exports.DAEMON_SESSIONS_DIR = void 0;
+exports.DAEMON_SIGNALS_DIR = exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = exports.DAEMON_SESSIONS_DIR = void 0;
 exports.readDaemonSessionState = readDaemonSessionState;
 exports.readAllDaemonSessions = readAllDaemonSessions;
 exports.runStartupRecovery = runStartupRecovery;
 exports.makeContinueWorkflowTool = makeContinueWorkflowTool;
 exports.makeCompleteStepTool = makeCompleteStepTool;
 exports.makeBashTool = makeBashTool;
+exports.makeReadTool = makeReadTool;
+exports.makeWriteTool = makeWriteTool;
+exports.makeGlobTool = makeGlobTool;
+exports.makeGrepTool = makeGrepTool;
+exports.makeEditTool = makeEditTool;
 exports.makeSpawnAgentTool = makeSpawnAgentTool;
 exports.makeReportIssueTool = makeReportIssueTool;
+exports.makeSignalCoordinatorTool = makeSignalCoordinatorTool;
 exports.buildSessionRecap = buildSessionRecap;
 exports.buildSystemPrompt = buildSystemPrompt;
 exports.runWorkflow = runWorkflow;
@@ -54,6 +60,7 @@ const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
+const tinyglobby_1 = require("tinyglobby");
 const node_crypto_1 = require("node:crypto");
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const bedrock_sdk_1 = require("@anthropic-ai/bedrock-sdk");
@@ -65,6 +72,7 @@ const index_js_2 = require("../v2/durable-core/ids/index.js");
 const node_outputs_js_1 = require("../v2/projections/node-outputs.js");
 const assert_never_js_1 = require("../runtime/assert-never.js");
 const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const BASH_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_SESSION_RECAP_NOTES = 3;
 const MAX_SESSION_NOTE_CHARS = 800;
@@ -77,6 +85,7 @@ exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessi
 const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
 const WORKRAIL_DIR = path.join(os.homedir(), '.workrail');
 const WORKSPACE_CONTEXT_MAX_BYTES = 32 * 1024;
+const MAX_ASSEMBLED_CONTEXT_BYTES = 8192;
 const WORKSPACE_CONTEXT_CANDIDATE_PATHS = [
     '.claude/CLAUDE.md',
     'CLAUDE.md',
@@ -365,7 +374,9 @@ function getSchemas() {
         ReadParams: {
             type: 'object',
             properties: {
-                filePath: { type: 'string', description: 'Absolute path to the file to read' },
+                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'],
         },
@@ -377,6 +388,39 @@ function getSchemas() {
             },
             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: {
@@ -648,37 +692,282 @@ function makeBashTool(workspacePath, schemas, sessionId, emitter, workrailSessio
         },
     };
 }
-function makeReadTool(schemas, sessionId, emitter, workrailSessionId) {
+function findActualString(fileContent, oldString) {
+    if (fileContent.includes(oldString))
+        return oldString;
+    const normalized = oldString
+        .replace(/[\u2018\u2019]/g, "'")
+        .replace(/[\u201C\u201D]/g, '"')
+        .replace(/\u2013/g, '-')
+        .replace(/\u2014/g, '--');
+    if (fileContent.includes(normalized))
+        return normalized;
+    return null;
+}
+const READ_SIZE_CAP_BYTES = 256 * 1024;
+const GLOB_ALWAYS_EXCLUDE = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'];
+function makeReadTool(readFileState, schemas, sessionId, emitter, workrailSessionId) {
     return {
         name: 'Read',
-        description: 'Read the contents of a file at the given absolute path.',
+        description: 'Read the contents of a file at the given absolute path. ' +
+            'Content is returned in cat -n format: each line is prefixed with its 1-indexed line number and a tab character (e.g. "1\\tline one\\n2\\tline two"). ' +
+            'Use offset (0-indexed start line) and limit (max lines) to read a slice of a large file.',
         inputSchema: schemas['ReadParams'],
         label: 'Read',
         execute: async (_toolCallId, params) => {
+            const filePath = params.filePath;
             if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Read', summary: String(params.filePath).slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            const content = await fs.readFile(params.filePath, 'utf8');
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Read', summary: filePath.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
+            const devPaths = ['/dev/stdin', '/dev/tty', '/dev/zero', '/dev/random', '/dev/full', '/dev/urandom'];
+            if (devPaths.some(d => filePath === d)) {
+                throw new Error(`Refusing to read device path: ${filePath}`);
+            }
+            const stat = await fs.stat(filePath);
+            const offset = params.offset ?? 0;
+            const limit = params.limit;
+            const isPaginated = params.offset !== undefined || params.limit !== undefined;
+            if (!isPaginated && stat.size > READ_SIZE_CAP_BYTES) {
+                throw new Error(`File is too large to read at once (${stat.size} bytes, cap is ${READ_SIZE_CAP_BYTES} bytes). ` +
+                    `Use offset and limit parameters to read a specific range of lines.`);
+            }
+            const rawContent = await fs.readFile(filePath, 'utf8');
+            const allLines = rawContent.split('\n');
+            const isPartialView = offset !== 0 || limit != null;
+            const slicedLines = limit != null ? allLines.slice(offset, offset + limit) : allLines.slice(offset);
+            const startLine = offset;
+            const formatted = slicedLines.map((l, i) => `${startLine + i + 1}\t${l}`).join('\n');
+            readFileState.set(filePath, { content: rawContent, timestamp: stat.mtimeMs, isPartialView });
             return {
-                content: [{ type: 'text', text: content }],
-                details: { filePath: params.filePath, length: content.length },
+                content: [{ type: 'text', text: formatted }],
+                details: { filePath, totalLines: allLines.length, returnedLines: slicedLines.length, offset, isPartialView },
             };
         },
     };
 }
-function makeWriteTool(schemas, sessionId, emitter, workrailSessionId) {
+function makeWriteTool(readFileState, schemas, sessionId, emitter, workrailSessionId) {
     return {
         name: 'Write',
-        description: 'Write content to a file at the given absolute path. Creates parent directories if needed.',
+        description: 'Write content to a file at the given absolute path. Creates parent directories if needed. ' +
+            'For existing files: the file must have been read in this session and must not have changed on disk since then. ' +
+            'For new files (path does not exist): no prior read is required.',
         inputSchema: schemas['WriteParams'],
         label: 'Write',
         execute: async (_toolCallId, params) => {
+            const filePath = params.filePath;
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Write', summary: filePath.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
+            let existsOnDisk = false;
+            try {
+                await fs.access(filePath);
+                existsOnDisk = true;
+            }
+            catch {
+            }
+            if (existsOnDisk) {
+                const state = readFileState.get(filePath);
+                if (!state) {
+                    throw new Error(`File has not been read in this session. Call Read first before writing to it: ${filePath}`);
+                }
+                const stat = await fs.stat(filePath);
+                if (stat.mtimeMs !== state.timestamp) {
+                    throw new Error(`File has been modified since it was read. Re-read before writing: ${filePath}`);
+                }
+            }
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, params.content, 'utf8');
+            const newStat = await fs.stat(filePath);
+            readFileState.set(filePath, { content: params.content, timestamp: newStat.mtimeMs, isPartialView: false });
+            return {
+                content: [{ type: 'text', text: `Written ${params.content.length} bytes to ${filePath}` }],
+                details: { filePath, length: params.content.length },
+            };
+        },
+    };
+}
+function makeGlobTool(workspacePath, schemas, sessionId, emitter, workrailSessionId) {
+    return {
+        name: 'Glob',
+        description: 'Find files matching a glob pattern. Returns newline-separated relative file paths, sorted by modification time descending. ' +
+            'node_modules, .git, dist, and build directories are always excluded. ' +
+            'Results are capped at 100 files.',
+        inputSchema: schemas['GlobParams'],
+        label: 'Glob',
+        execute: async (_toolCallId, params) => {
+            const pattern = params.pattern;
+            const searchRoot = params.path ?? workspacePath;
             if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Write', summary: String(params.filePath).slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            await fs.mkdir(path.dirname(params.filePath), { recursive: true });
-            await fs.writeFile(params.filePath, params.content, 'utf8');
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Glob', summary: pattern.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
+            const GLOB_LIMIT = 100;
+            let paths;
+            try {
+                paths = await (0, tinyglobby_1.glob)(pattern, {
+                    cwd: searchRoot,
+                    ignore: GLOB_ALWAYS_EXCLUDE,
+                    absolute: false,
+                });
+            }
+            catch {
+                paths = [];
+            }
+            const withMtimes = await Promise.all(paths.map(async (p) => {
+                try {
+                    const stat = await fs.stat(path.join(searchRoot, p));
+                    return { p, mtime: stat.mtimeMs };
+                }
+                catch {
+                    return { p, mtime: 0 };
+                }
+            }));
+            withMtimes.sort((a, b) => b.mtime - a.mtime);
+            const sorted = withMtimes.map(x => x.p);
+            const truncated = sorted.length > GLOB_LIMIT;
+            const result = sorted.slice(0, GLOB_LIMIT);
+            let text = result.join('\n');
+            if (truncated) {
+                text += '\n[Results truncated at 100 files]';
+            }
             return {
-                content: [{ type: 'text', text: `Written ${params.content.length} bytes to ${params.filePath}` }],
-                details: { filePath: params.filePath, length: params.content.length },
+                content: [{ type: 'text', text: text || '(no matches)' }],
+                details: { pattern, searchRoot, matchCount: sorted.length, truncated },
+            };
+        },
+    };
+}
+function makeGrepTool(workspacePath, schemas, sessionId, emitter, workrailSessionId) {
+    return {
+        name: 'Grep',
+        description: 'Search file contents using ripgrep (rg). Fast regex search with optional context lines, file-type filtering, and case-insensitive mode. ' +
+            'output_mode: "files_with_matches" (default) returns only file paths; "content" returns matching lines; "count" returns match counts per file. ' +
+            'node_modules and .git are always excluded.',
+        inputSchema: schemas['GrepParams'],
+        label: 'Grep',
+        execute: async (_toolCallId, params) => {
+            const pattern = params.pattern;
+            const searchPath = params.path ?? workspacePath;
+            const outputMode = params.output_mode ?? 'files_with_matches';
+            const headLimit = params.head_limit ?? 250;
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Grep', summary: pattern.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
+            const args = [
+                '--hidden',
+                '--glob', '!node_modules',
+                '--glob', '!.git',
+                '--max-columns', '500',
+            ];
+            if (params['-i'])
+                args.push('-i');
+            if (params.glob) {
+                args.push('--glob', params.glob);
+            }
+            if (params.type) {
+                args.push('--type', params.type);
+            }
+            switch (outputMode) {
+                case 'files_with_matches':
+                    args.push('--files-with-matches');
+                    break;
+                case 'count':
+                    args.push('--count');
+                    break;
+                case 'content':
+                    args.push('--vimgrep');
+                    if (params.context != null) {
+                        args.push('-C', String(params.context));
+                    }
+                    break;
+            }
+            args.push('--', pattern, searchPath);
+            let stdout;
+            try {
+                const result = await execFileAsync('rg', args, { cwd: workspacePath, maxBuffer: 10 * 1024 * 1024 });
+                stdout = result.stdout;
+            }
+            catch (err) {
+                const nodeErr = err;
+                if (nodeErr.code === 'ENOENT') {
+                    throw new Error('ripgrep (rg) is not installed. Install it with: brew install ripgrep (macOS) or apt install ripgrep (Ubuntu/Debian).');
+                }
+                if (typeof nodeErr.code === 'number' && nodeErr.code === 1) {
+                    return {
+                        content: [{ type: 'text', text: '(no matches)' }],
+                        details: { pattern, searchPath, outputMode },
+                    };
+                }
+                throw new Error(`rg failed: ${nodeErr.message ?? String(err)}`);
+            }
+            const lines = stdout.split('\n').filter(l => l.length > 0);
+            const truncated = lines.length > headLimit;
+            let result = lines.slice(0, headLimit).join('\n');
+            if (truncated) {
+                result += `\n[Results truncated at ${headLimit} lines. Use a more specific pattern or increase head_limit.]`;
+            }
+            return {
+                content: [{ type: 'text', text: result || '(no matches)' }],
+                details: { pattern, searchPath, outputMode, lineCount: lines.length, truncated },
+            };
+        },
+    };
+}
+function makeEditTool(workspacePath, readFileState, schemas, sessionId, emitter, workrailSessionId) {
+    return {
+        name: 'Edit',
+        description: 'Perform an exact string replacement in a file. ' +
+            'The file must have been read in this session via the Read tool. ' +
+            'By default, old_string must appear exactly once; use replace_all=true to replace all occurrences. ' +
+            'Do NOT include line-number prefixes (e.g. "1\\t") from Read output in old_string or new_string.',
+        inputSchema: schemas['EditParams'],
+        label: 'Edit',
+        execute: async (_toolCallId, params) => {
+            const rawFilePath = params.file_path;
+            const absoluteFilePath = path.isAbsolute(rawFilePath)
+                ? rawFilePath
+                : path.join(workspacePath, rawFilePath);
+            if (!absoluteFilePath.startsWith(workspacePath)) {
+                throw new Error(`Edit target is outside the workspace: ${rawFilePath}`);
+            }
+            const filePath = absoluteFilePath;
+            const oldString = params.old_string;
+            const newString = params.new_string;
+            const replaceAll = params.replace_all ?? false;
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Edit', summary: filePath.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
+            if (oldString === newString) {
+                throw new Error('old_string and new_string are identical. No edit needed.');
+            }
+            const state = readFileState.get(filePath);
+            if (!state) {
+                throw new Error(`File has not been read in this session. Call Read first before editing: ${filePath}`);
+            }
+            let stat;
+            try {
+                stat = await fs.stat(filePath);
+            }
+            catch {
+                throw new Error(`File not found: ${filePath}. It may have been deleted after it was read.`);
+            }
+            if (stat.mtimeMs !== state.timestamp) {
+                throw new Error(`File has been modified since it was read. Re-read before editing: ${filePath}`);
+            }
+            const currentContent = await fs.readFile(filePath, 'utf8');
+            const actualString = findActualString(currentContent, oldString);
+            if (actualString === null) {
+                throw new Error(`String to replace not found in file. Make sure old_string exactly matches the file content ` +
+                    `(do not include line-number prefixes from Read output): ${filePath}`);
+            }
+            const occurrences = currentContent.split(actualString).length - 1;
+            if (!replaceAll && occurrences > 1) {
+                throw new Error(`old_string appears ${occurrences} times in the file. ` +
+                    `Provide a more specific string that matches exactly once, or set replace_all=true to replace all occurrences.`);
+            }
+            const updatedContent = replaceAll
+                ? currentContent.split(actualString).join(newString)
+                : currentContent.replace(actualString, newString);
+            await fs.writeFile(filePath, updatedContent, 'utf8');
+            const newStat = await fs.stat(filePath);
+            readFileState.set(filePath, { content: updatedContent, timestamp: newStat.mtimeMs, isPartialView: false });
+            return {
+                content: [{ type: 'text', text: `The file ${filePath} has been updated successfully.` }],
+                details: { filePath, occurrencesReplaced: occurrences },
             };
         },
     };
@@ -691,7 +980,8 @@ function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, curre
             'Use this when a step requires delegating a well-defined sub-task to a separate workflow. ' +
             'IMPORTANT: The parent session\'s time limit (maxSessionMinutes) keeps ticking while the child runs. ' +
             'Configure the parent with enough time to cover both its own work and the child\'s work. ' +
-            'Returns: { childSessionId, outcome: "success"|"error"|"timeout", notes: string }. ' +
+            'Returns: { childSessionId, outcome: "success"|"error"|"timeout", notes: string, artifacts?: readonly unknown[] }. ' +
+            'On success, artifacts contains the child session\'s final step artifacts if any were produced. ' +
             'Check outcome before using notes -- on error/timeout, notes contains the error message.',
         inputSchema: schemas['SpawnAgentParams'],
         label: 'Spawn Agent',
@@ -755,6 +1045,7 @@ function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, curre
                     childSessionId,
                     outcome: 'success',
                     notes: childResult.lastStepNotes ?? '(no notes from child session)',
+                    ...(childResult.lastStepArtifacts !== undefined ? { artifacts: childResult.lastStepArtifacts } : {}),
                 };
             }
             else if (childResult._tag === 'error') {
@@ -873,6 +1164,74 @@ function makeReportIssueTool(sessionId, emitter, workrailSessionId, issuesDirOve
         },
     };
 }
+exports.DAEMON_SIGNALS_DIR = path.join(os.homedir(), '.workrail', 'signals');
+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');
+}
+function makeSignalCoordinatorTool(sessionId, emitter, workrailSessionId, signalsDirOverride) {
+    const signalsDir = signalsDirOverride ?? exports.DAEMON_SIGNALS_DIR;
+    return {
+        name: 'signal_coordinator',
+        description: 'Emit a structured mid-session signal to the coordinator WITHOUT advancing the workflow step. ' +
+            'Use this to surface progress updates, intermediate findings, data requests, ' +
+            'approval requests, or blocking conditions while the session continues. ' +
+            'Always returns immediately -- fire-and-observe, never blocks. ' +
+            'Signal kinds: "progress" (heartbeat, no data needed), "finding" (intermediate result), ' +
+            '"data_needed" (request external data), "approval_needed" (request coordinator approval), ' +
+            '"blocked" (cannot continue without coordinator intervention).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                signalKind: {
+                    type: 'string',
+                    enum: ['progress', 'finding', 'data_needed', 'approval_needed', 'blocked'],
+                    description: 'The kind of signal to emit.',
+                },
+                payload: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Structured data accompanying the signal. Pass {} for progress signals.',
+                },
+            },
+            required: ['signalKind', 'payload'],
+            additionalProperties: false,
+        },
+        label: 'signal_coordinator',
+        execute: async (_toolCallId, params) => {
+            const signalId = 'sig_' + (0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 8);
+            const signalKind = String(params.signalKind ?? 'progress');
+            const payload = (typeof params.payload === 'object' && params.payload !== null && !Array.isArray(params.payload))
+                ? params.payload
+                : {};
+            console.log(`[WorkflowRunner] Tool: signal_coordinator sessionId=${sessionId} signalKind=${signalKind} signalId=${signalId}`);
+            const record = {
+                signalId,
+                sessionId,
+                ...(workrailSessionId != null ? { workrailSessionId } : {}),
+                signalKind,
+                payload,
+            };
+            void appendSignalAsync(signalsDir, sessionId, record).catch(() => {
+            });
+            emitter?.emit({
+                kind: 'signal_emitted',
+                sessionId,
+                signalKind,
+                signalId,
+                payload,
+                ...(workrailSessionId != null ? { workrailSessionId } : {}),
+            });
+            const result = { status: 'recorded', signalId };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result) }],
+                details: result,
+            };
+        },
+    };
+}
 const BASE_SYSTEM_PROMPT = `\
 You are WorkRail Auto, an autonomous agent that executes workflows step by step. You are running unattended -- there is no user watching. Your entire job is to faithfully complete the current workflow.
 
@@ -900,6 +1259,7 @@ Good pattern: "Question: Should I check the middleware? Answer: The workflow ste
 - \`Write\`: Write files.
 - \`report_issue\`: Record a structured issue, error, or unexpected behavior. Call this AND complete_step (unless fatal). Does not stop the session -- it creates a record for the auto-fix coordinator.
 - \`spawn_agent\`: Delegate a sub-task to a child WorkRail session. BLOCKS until the child completes. Returns \`{ childSessionId, outcome: "success"|"error"|"timeout", notes: string }\`. Always check \`outcome\` before using \`notes\`. IMPORTANT: your session's time limit (maxSessionMinutes) keeps running while the child executes -- ensure your parent session has enough time for both your work AND the child's work. Maximum spawn depth is 3 by default (configurable). Use only when a step explicitly asks for delegation or when a clearly separable sub-task would benefit from its own WorkRail audit trail.
+- \`signal_coordinator\`: Emit a structured mid-session signal to the coordinator WITHOUT advancing the workflow step. Use when the step asks you to surface a finding, request data, request approval, or report a blocking condition. Always returns immediately -- fire-and-observe. Signal kinds: "progress", "finding", "data_needed", "approval_needed", "blocked".
 
 ## Execution contract
 1. Read the step carefully. Do ALL the work the step asks for.
@@ -948,6 +1308,16 @@ function buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext)
         lines.push('## Workspace Context (from AGENTS.md / CLAUDE.md)');
         lines.push(workspaceContext);
     }
+    const assembledContextSummary = trigger.context?.['assembledContextSummary'];
+    if (typeof assembledContextSummary === 'string' && assembledContextSummary.trim().length > 0) {
+        let ctxStr = assembledContextSummary;
+        if (Buffer.byteLength(ctxStr, 'utf8') > MAX_ASSEMBLED_CONTEXT_BYTES) {
+            ctxStr = ctxStr.slice(0, MAX_ASSEMBLED_CONTEXT_BYTES) + '\n[Prior context truncated at 8KB]';
+        }
+        lines.push('');
+        lines.push('## Prior Context');
+        lines.push(ctxStr.trim());
+    }
     if (trigger.referenceUrls && trigger.referenceUrls.length > 0) {
         lines.push('');
         lines.push('## Reference documents');
@@ -964,7 +1334,7 @@ function buildUserMessage(text) {
         timestamp: Date.now(),
     };
 }
-async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
+async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerRegistry) {
     const sessionId = (0, node_crypto_1.randomUUID)();
     console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
     emitter?.emit({
@@ -1002,7 +1372,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         }
     }
     let isComplete = false;
-    let pendingSteerText = null;
+    const pendingSteerParts = [];
     let lastStepNotes;
     let lastStepArtifacts;
     let stepAdvanceCount = 0;
@@ -1011,7 +1381,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     const issueSummaries = [];
     const MAX_ISSUE_SUMMARIES = 10;
     const onAdvance = (stepText, continueToken) => {
-        pendingSteerText = stepText;
+        pendingSteerParts.push(stepText);
         stepAdvanceCount++;
         currentContinueToken = continueToken;
         if (workrailSessionId !== null)
@@ -1054,6 +1424,9 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     if (workrailSessionId !== null) {
         daemonRegistry?.register(workrailSessionId, trigger.workflowId);
     }
+    if (workrailSessionId !== null) {
+        steerRegistry?.set(workrailSessionId, (text) => { pendingSteerParts.push(text); });
+    }
     if (startContinueToken) {
         await persistTokens(sessionId, startContinueToken, startCheckpointToken);
     }
@@ -1067,18 +1440,23 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     const schemas = getSchemas();
     const spawnCurrentDepth = trigger.spawnDepth ?? 0;
     const spawnMaxDepth = trigger.agentConfig?.maxSubagentDepth ?? 3;
+    const readFileState = new Map();
     const tools = [
         makeCompleteStepTool(sessionId, ctx, () => currentContinueToken, onAdvance, onComplete, (t) => { currentContinueToken = t; }, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSessionId),
         makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSessionId),
         makeBashTool(trigger.workspacePath, schemas, sessionId, emitter, workrailSessionId),
-        makeReadTool(schemas, sessionId, emitter, workrailSessionId),
-        makeWriteTool(schemas, sessionId, emitter, workrailSessionId),
+        makeReadTool(readFileState, schemas, sessionId, emitter, workrailSessionId),
+        makeWriteTool(readFileState, schemas, sessionId, emitter, workrailSessionId),
+        makeGlobTool(trigger.workspacePath, schemas, sessionId, emitter, workrailSessionId),
+        makeGrepTool(trigger.workspacePath, schemas, sessionId, emitter, workrailSessionId),
+        makeEditTool(trigger.workspacePath, readFileState, schemas, sessionId, emitter, workrailSessionId),
         makeReportIssueTool(sessionId, emitter, workrailSessionId, undefined, (summary) => {
             if (issueSummaries.length < MAX_ISSUE_SUMMARIES) {
                 issueSummaries.push(summary);
             }
         }),
         makeSpawnAgentTool(sessionId, ctx, apiKey, workrailSessionId ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflow, schemas, emitter),
+        makeSignalCoordinatorTool(sessionId, emitter, workrailSessionId),
     ];
     const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
         loadDaemonSoul(trigger.soulFile),
@@ -1193,10 +1571,10 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
                 ...withWorkrailSession(workrailSessionId),
             });
         }
-        if (pendingSteerText !== null && !isComplete) {
-            const text = pendingSteerText;
-            pendingSteerText = null;
-            agent.steer(buildUserMessage(text));
+        if (pendingSteerParts.length > 0 && !isComplete) {
+            const joined = pendingSteerParts.join('\n\n');
+            pendingSteerParts.length = 0;
+            agent.steer(buildUserMessage(joined));
         }
     });
     let stopReason = 'stop';
@@ -1237,6 +1615,9 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         unsubscribe();
         if (timeoutHandle !== undefined)
             clearTimeout(timeoutHandle);
+        if (workrailSessionId !== null) {
+            steerRegistry?.delete(workrailSessionId);
+        }
         console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
     }
     if (timeoutReason !== null) {