@exaudeus/workrail 3.71.1 → 3.72.1

package/dist/daemon/tools/file-tools.js

@@ -0,0 +1,195 @@
+"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.makeReadTool = makeReadTool;
+exports.makeWriteTool = makeWriteTool;
+exports.makeEditTool = makeEditTool;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const _shared_js_1 = require("./_shared.js");
+function makeReadTool(readFileState, schemas, sessionId, emitter, workrailSessionId) {
+    return {
+        name: 'Read',
+        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) => {
+            if (typeof params.filePath !== 'string' || !params.filePath)
+                throw new Error('Read: filePath must be a non-empty string');
+            const filePath = params.filePath;
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Read', summary: filePath.slice(0, 80), ...(0, _shared_js_1.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 > _shared_js_1.READ_SIZE_CAP_BYTES) {
+                throw new Error(`File is too large to read at once (${stat.size} bytes, cap is ${_shared_js_1.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: formatted }],
+                details: { filePath, totalLines: allLines.length, returnedLines: slicedLines.length, offset, isPartialView },
+            };
+        },
+    };
+}
+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. ' +
+            '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) => {
+            if (typeof params.filePath !== 'string' || !params.filePath)
+                throw new Error('Write: filePath must be a non-empty string');
+            if (typeof params.content !== 'string')
+                throw new Error('Write: content must be a string');
+            const filePath = params.filePath;
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Write', summary: filePath.slice(0, 80), ...(0, _shared_js_1.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 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) => {
+            if (typeof params.file_path !== 'string' || !params.file_path)
+                throw new Error('Edit: file_path must be a non-empty string');
+            if (typeof params.old_string !== 'string')
+                throw new Error('Edit: old_string must be a string');
+            if (typeof params.new_string !== 'string')
+                throw new Error('Edit: new_string must be a string');
+            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), ...(0, _shared_js_1.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 = (0, _shared_js_1.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 },
+            };
+        },
+    };
+}

package/dist/daemon/tools/glob-grep.d.ts

@@ -0,0 +1,4 @@
+import type { AgentTool } from '../agent-loop.js';
+import type { DaemonEventEmitter } from '../daemon-events.js';
+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;

package/dist/daemon/tools/glob-grep.js

@@ -0,0 +1,172 @@
+"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.makeGlobTool = makeGlobTool;
+exports.makeGrepTool = makeGrepTool;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const tinyglobby_1 = require("tinyglobby");
+const _shared_js_1 = require("./_shared.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+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) => {
+            if (typeof params.pattern !== 'string' || !params.pattern)
+                throw new Error('Glob: pattern must be a non-empty string');
+            const pattern = params.pattern;
+            const searchRoot = params.path ?? workspacePath;
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Glob', summary: pattern.slice(0, 80), ...(0, _shared_js_1.withWorkrailSession)(workrailSessionId) });
+            const GLOB_LIMIT = 100;
+            let paths;
+            try {
+                paths = await (0, tinyglobby_1.glob)(pattern, {
+                    cwd: searchRoot,
+                    ignore: _shared_js_1.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: 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) => {
+            if (typeof params.pattern !== 'string' || !params.pattern)
+                throw new Error('Grep: pattern must be a non-empty string');
+            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), ...(0, _shared_js_1.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 },
+            };
+        },
+    };
+}

package/dist/daemon/tools/report-issue.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from '../agent-loop.js';
+import type { DaemonEventEmitter } from '../daemon-events.js';
+export declare function makeReportIssueTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, issuesDirOverride?: string, onIssueSummary?: (summary: string) => void): AgentTool;

package/dist/daemon/tools/report-issue.js

@@ -0,0 +1,129 @@
+"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.makeReportIssueTool = makeReportIssueTool;
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const _shared_js_1 = require("./_shared.js");
+function makeReportIssueTool(sessionId, emitter, workrailSessionId, issuesDirOverride, onIssueSummary) {
+    const issuesDir = issuesDirOverride ?? path.join(os.homedir(), '.workrail', 'issues');
+    return {
+        name: 'report_issue',
+        description: "Record a structured issue, error, or unexpected behavior. Call this AND continue_workflow (unless fatal). " +
+            "Does not stop the session -- it creates a record for the auto-fix coordinator.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kind: {
+                    type: 'string',
+                    enum: ['tool_failure', 'blocked', 'unexpected_behavior', 'needs_human', 'self_correction'],
+                    description: 'Category of issue being reported.',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['info', 'warn', 'error', 'fatal'],
+                    description: 'Severity level. Fatal means the session cannot continue productively.',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'One-line summary of the issue. Max 200 chars.',
+                    maxLength: 200,
+                },
+                context: {
+                    type: 'string',
+                    description: 'What you were trying to do when this issue occurred.',
+                },
+                toolName: {
+                    type: 'string',
+                    description: 'Name of the tool that failed or behaved unexpectedly, if applicable.',
+                },
+                command: {
+                    type: 'string',
+                    description: 'The shell command or expression that caused the issue, if applicable.',
+                },
+                suggestedFix: {
+                    type: 'string',
+                    description: 'A suggested fix or recovery action for the auto-fix coordinator.',
+                },
+                continueToken: {
+                    type: 'string',
+                    description: 'The current continueToken, so the coordinator can resume this session.',
+                },
+            },
+            required: ['kind', 'severity', 'summary'],
+            additionalProperties: false,
+        },
+        label: 'report_issue',
+        execute: async (_toolCallId, params) => {
+            if (typeof params.kind !== 'string' || !params.kind)
+                throw new Error('report_issue: kind must be a non-empty string');
+            if (typeof params.severity !== 'string' || !params.severity)
+                throw new Error('report_issue: severity must be a non-empty string');
+            if (typeof params.summary !== 'string' || !params.summary)
+                throw new Error('report_issue: summary must be a non-empty string');
+            const record = {
+                sessionId,
+                kind: params.kind,
+                severity: params.severity,
+                summary: String(params.summary ?? '').slice(0, 200),
+                ...(params.context !== undefined && { context: String(params.context) }),
+                ...(params.toolName !== undefined && { toolName: String(params.toolName) }),
+                ...(params.command !== undefined && { command: String(params.command) }),
+                ...(params.suggestedFix !== undefined && { suggestedFix: String(params.suggestedFix) }),
+                ...(params.continueToken !== undefined && { continueToken: String(params.continueToken) }),
+            };
+            void (0, _shared_js_1.appendIssueAsync)(issuesDir, sessionId, record).catch(() => {
+            });
+            emitter?.emit({
+                kind: 'issue_reported',
+                sessionId,
+                issueKind: record.kind,
+                severity: record.severity,
+                summary: record.summary,
+                ...(record.continueToken !== undefined && { continueToken: record.continueToken }),
+                ...(workrailSessionId != null ? { workrailSessionId } : {}),
+            });
+            onIssueSummary?.(record.summary);
+            const isFatal = record.severity === 'fatal';
+            const message = isFatal
+                ? `FATAL issue recorded. Call continue_workflow with notes explaining the blocker, then the session will end.`
+                : `Issue recorded (severity=${record.severity}). Continue with your work unless this is fatal.`;
+            return {
+                content: [{ type: 'text', text: message }],
+                details: { sessionId, kind: record.kind, severity: record.severity },
+            };
+        },
+    };
+}

package/dist/daemon/tools/signal-coordinator.d.ts

@@ -0,0 +1,4 @@
+import type { AgentTool } from '../agent-loop.js';
+import type { DaemonEventEmitter } from '../daemon-events.js';
+export declare const DAEMON_SIGNALS_DIR: string;
+export declare function makeSignalCoordinatorTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, signalsDirOverride?: string): AgentTool;

package/dist/daemon/tools/signal-coordinator.js

@@ -0,0 +1,105 @@
+"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.DAEMON_SIGNALS_DIR = void 0;
+exports.makeSignalCoordinatorTool = makeSignalCoordinatorTool;
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const _shared_js_1 = require("./_shared.js");
+exports.DAEMON_SIGNALS_DIR = path.join(os.homedir(), '.workrail', 'signals');
+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) => {
+            if (typeof params.signalKind !== 'string' || !params.signalKind)
+                throw new Error('signal_coordinator: signalKind must be a non-empty string');
+            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 (0, _shared_js_1.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,
+            };
+        },
+    };
+}

package/dist/daemon/tools/spawn-agent.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 type { runWorkflow } from '../workflow-runner.js';
+import type { ActiveSessionSet } from '../active-sessions.js';
+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, activeSessionSet?: ActiveSessionSet): AgentTool;