@exaudeus/workrail 3.41.0 → 3.43.0

package/dist/context-assembly/infra.js

@@ -0,0 +1,154 @@
+"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.createListRecentSessions = createListRecentSessions;
+const fs = __importStar(require("node:fs/promises"));
+const nodePath = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const neverthrow_1 = require("neverthrow");
+const result_js_1 = require("../runtime/result.js");
+const index_js_1 = require("../v2/infra/local/session-summary-provider/index.js");
+const index_js_2 = require("../v2/infra/local/data-dir/index.js");
+const index_js_3 = require("../v2/infra/local/directory-listing/index.js");
+const index_js_4 = require("../v2/infra/local/session-store/index.js");
+const index_js_5 = require("../v2/infra/local/sha256/index.js");
+const WRITE_NOT_SUPPORTED = 'context-assembly: write ops not supported in read-only session store';
+function makeReadOnlyFsPort() {
+    return {
+        readFileUtf8(filePath) {
+            return (0, neverthrow_1.fromPromise)(fs.readFile(filePath, 'utf-8'), (e) => {
+                const nodeErr = e;
+                if (nodeErr.code === 'ENOENT')
+                    return { code: 'FS_NOT_FOUND', message: nodeErr.message ?? 'not found' };
+                return { code: 'FS_IO_ERROR', message: nodeErr.message ?? String(e) };
+            });
+        },
+        readFileBytes(filePath) {
+            return (0, neverthrow_1.fromPromise)(fs.readFile(filePath).then((buf) => new Uint8Array(buf)), (e) => {
+                const nodeErr = e;
+                if (nodeErr.code === 'ENOENT')
+                    return { code: 'FS_NOT_FOUND', message: nodeErr.message ?? 'not found' };
+                return { code: 'FS_IO_ERROR', message: nodeErr.message ?? String(e) };
+            });
+        },
+        stat(_filePath) {
+            throw new Error(WRITE_NOT_SUPPORTED);
+        },
+        mkdirp(_dirPath) { throw new Error(WRITE_NOT_SUPPORTED); },
+        fsyncDir(_dirPath) { throw new Error(WRITE_NOT_SUPPORTED); },
+        openWriteTruncate(_filePath) { throw new Error(WRITE_NOT_SUPPORTED); },
+        openAppend(_filePath) { throw new Error(WRITE_NOT_SUPPORTED); },
+        openExclusive(_filePath, _bytes) { throw new Error(WRITE_NOT_SUPPORTED); },
+        writeAll(_fd, _bytes) { throw new Error(WRITE_NOT_SUPPORTED); },
+        fsyncFile(_fd) { throw new Error(WRITE_NOT_SUPPORTED); },
+        closeFile(_fd) { throw new Error(WRITE_NOT_SUPPORTED); },
+        rename(_from, _to) { throw new Error(WRITE_NOT_SUPPORTED); },
+        unlink(_filePath) { throw new Error(WRITE_NOT_SUPPORTED); },
+        writeFileBytes(_filePath, _bytes) { throw new Error(WRITE_NOT_SUPPORTED); },
+        readdir(_dirPath) { throw new Error(WRITE_NOT_SUPPORTED); },
+        readdirWithMtime(_dirPath) { throw new Error(WRITE_NOT_SUPPORTED); },
+    };
+}
+function makeDirectoryListingOpsPort() {
+    return {
+        readdir(dirPath) {
+            return (0, neverthrow_1.fromPromise)(fs.readdir(dirPath), (e) => {
+                const nodeErr = e;
+                if (nodeErr.code === 'ENOENT')
+                    return { code: 'FS_NOT_FOUND', message: nodeErr.message ?? 'not found' };
+                return { code: 'FS_IO_ERROR', message: nodeErr.message ?? String(e) };
+            });
+        },
+        readdirWithMtime(dirPath) {
+            return (0, neverthrow_1.fromPromise)((async () => {
+                const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                const withMtimes = await Promise.all(entries.map(async (entry) => {
+                    try {
+                        const stat = await fs.stat(nodePath.join(dirPath, entry.name));
+                        return { name: entry.name, mtimeMs: stat.mtimeMs };
+                    }
+                    catch {
+                        return null;
+                    }
+                }));
+                return withMtimes.filter((e) => e !== null);
+            })(), (e) => {
+                const nodeErr = e;
+                if (nodeErr.code === 'ENOENT')
+                    return { code: 'FS_NOT_FOUND', message: nodeErr.message ?? 'not found' };
+                return { code: 'FS_IO_ERROR', message: nodeErr.message ?? String(e) };
+            });
+        },
+    };
+}
+function createListRecentSessions() {
+    return async (workspacePath, limit) => {
+        try {
+            const dataDir = new index_js_2.LocalDataDirV2(process.env);
+            const directoryListingOps = makeDirectoryListingOpsPort();
+            const directoryListing = new index_js_3.LocalDirectoryListingV2(directoryListingOps);
+            const fsPort = makeReadOnlyFsPort();
+            const sha256 = new index_js_5.NodeSha256V2();
+            const sessionStore = new index_js_4.LocalSessionEventLogStoreV2(dataDir, fsPort, sha256);
+            const provider = new index_js_1.LocalSessionSummaryProviderV2({
+                directoryListing,
+                dataDir,
+                sessionStore,
+            });
+            const result = await provider.loadHealthySummaries();
+            if (result.isErr()) {
+                return (0, result_js_1.err)(`listRecentSessions: ${result.error.message}`);
+            }
+            const workspaceHash = `sha256:${(0, node_crypto_1.createHash)('sha256').update(workspacePath).digest('hex')}`;
+            const notes = result.value
+                .filter((s) => s.observations.repoRootHash === null ||
+                s.observations.repoRootHash === workspaceHash)
+                .slice()
+                .sort((a, b) => (b.lastModifiedMs ?? Date.now()) - (a.lastModifiedMs ?? Date.now()))
+                .slice(0, limit)
+                .map((s) => ({
+                sessionId: String(s.sessionId),
+                recapSnippet: s.recapSnippet != null ? String(s.recapSnippet) : null,
+                sessionTitle: s.sessionTitle,
+                gitBranch: s.observations.gitBranch,
+                lastModifiedMs: s.lastModifiedMs ?? Date.now(),
+            }));
+            return (0, result_js_1.ok)(notes);
+        }
+        catch (e) {
+            return (0, result_js_1.err)(`listRecentSessions error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    };
+}

package/dist/context-assembly/types.d.ts

@@ -0,0 +1,30 @@
+import type { Result } from '../runtime/result.js';
+export type AssemblyTask = {
+    readonly kind: 'pr_review';
+    readonly prNumber: number;
+    readonly workspacePath: string;
+    readonly payloadBody?: string;
+} | {
+    readonly kind: 'coding_task';
+    readonly issueNumber?: number;
+    readonly workspacePath: string;
+    readonly payloadBody?: string;
+};
+export interface SessionNote {
+    readonly sessionId: string;
+    readonly recapSnippet: string | null;
+    readonly sessionTitle: string | null;
+    readonly gitBranch: string | null;
+    readonly lastModifiedMs: number;
+}
+export interface ContextBundle {
+    readonly task: AssemblyTask;
+    readonly gitDiff: Result<string, string>;
+    readonly priorSessionNotes: Result<readonly SessionNote[], string>;
+    readonly assembledAt: string;
+}
+export interface RenderOpts {
+}
+export interface ContextAssembler {
+    assemble(task: AssemblyTask): Promise<ContextBundle>;
+}

package/dist/context-assembly/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/coordinators/pr-review.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from '../runtime/result.js';
 import type { AwaitResult } from '../cli/commands/worktrain-await.js';
+import type { ContextAssembler } from '../context-assembly/types.js';
 export type ReviewSeverity = 'clean' | 'minor' | 'blocking' | 'unknown';
 export interface ReviewFindings {
     readonly severity: ReviewSeverity;
@@ -36,7 +37,8 @@ export interface PrReviewOpts {
     readonly port?: number;
 }
 export interface CoordinatorDeps {
-    readonly spawnSession: (workflowId: string, goal: string, workspace: string) => Promise<Result<string, string>>;
+    readonly spawnSession: (workflowId: string, goal: string, workspace: string, context?: Readonly<Record<string, unknown>>) => Promise<Result<string, string>>;
+    readonly contextAssembler?: ContextAssembler;
     readonly awaitSessions: (handles: readonly string[], timeoutMs: number) => Promise<AwaitResult>;
     readonly getAgentResult: (sessionHandle: string) => Promise<{
         recapMarkdown: string | null;

package/dist/coordinators/pr-review.js

@@ -9,6 +9,7 @@ exports.drainMessageQueue = drainMessageQueue;
 exports.runPrReviewCoordinator = runPrReviewCoordinator;
 const result_js_1 = require("../runtime/result.js");
 const review_verdict_js_1 = require("../v2/durable-core/schemas/artifacts/review-verdict.js");
+const index_js_1 = require("../context-assembly/index.js");
 const MAX_FIX_PASSES = 3;
 const CHILD_SESSION_TIMEOUT_MS = 15 * 60 * 1000;
 const COORDINATOR_MAX_MS = 90 * 60 * 1000;
@@ -377,13 +378,33 @@ async function runPrReviewCoordinator(deps, opts) {
     }
     const reviewHandles = new Map();
     const spawnErrors = new Map();
+    const spawnContexts = new Map();
     for (const pr of prs) {
         const goal = `Review PR #${pr.number} "${pr.title}" before merge`;
         if (opts.dryRun) {
             log(`      PR #${pr.number} [dry-run] would spawn mr-review-workflow-agentic`);
             continue;
         }
-        const spawnResult = await deps.spawnSession('mr-review-workflow-agentic', goal, opts.workspace);
+        let spawnContext;
+        if (deps.contextAssembler) {
+            const bundle = await deps.contextAssembler.assemble({
+                kind: 'pr_review',
+                prNumber: pr.number,
+                workspacePath: opts.workspace,
+            });
+            const rendered = (0, index_js_1.renderContextBundle)(bundle);
+            if (rendered.trim().length > 0) {
+                spawnContext = { assembledContextSummary: rendered };
+                spawnContexts.set(pr.number, spawnContext);
+            }
+            if (bundle.gitDiff.kind === 'err') {
+                deps.stderr(`[WARN coord:context prNumber=${pr.number}] gitDiff failed: ${bundle.gitDiff.error}`);
+            }
+            if (bundle.priorSessionNotes.kind === 'err') {
+                deps.stderr(`[WARN coord:context prNumber=${pr.number}] priorSessionNotes failed: ${bundle.priorSessionNotes.error}`);
+            }
+        }
+        const spawnResult = await deps.spawnSession('mr-review-workflow-agentic', goal, opts.workspace, spawnContext);
         if (spawnResult.kind === 'err') {
             spawnErrors.set(pr.number, spawnResult.error);
             log(`      PR #${pr.number} spawn failed: ${spawnResult.error}`);
@@ -462,7 +483,7 @@ async function runPrReviewCoordinator(deps, opts) {
                 sessionHandles: [handle],
             };
             if (severity === 'minor' && findings && sessionResult.outcome === 'success') {
-                const processedOutcome = await runFixAgentLoop(deps, opts, pr, findings, outcome, coordinatorStartMs, log);
+                const processedOutcome = await runFixAgentLoop(deps, opts, pr, findings, outcome, coordinatorStartMs, log, spawnContexts.get(prNum));
                 outcomes.set(prNum, processedOutcome);
             }
             else {
@@ -537,7 +558,7 @@ async function runPrReviewCoordinator(deps, opts) {
     await writeReport(deps, reportPath, reportLines, result);
     return result;
 }
-async function runFixAgentLoop(deps, opts, pr, initialFindings, initialOutcome, coordinatorStartMs, log) {
+async function runFixAgentLoop(deps, opts, pr, initialFindings, initialOutcome, coordinatorStartMs, log, reviewSpawnContext) {
     let passCount = 0;
     let currentFindings = initialFindings;
     let sessionHandles = [...initialOutcome.sessionHandles];
@@ -614,7 +635,7 @@ async function runFixAgentLoop(deps, opts, pr, initialFindings, initialOutcome,
             };
         }
         const reReviewGoal = `Re-review PR #${pr.number} after fixes (pass ${passCount})`;
-        const reReviewSpawnResult = await deps.spawnSession('mr-review-workflow-agentic', reReviewGoal, opts.workspace);
+        const reReviewSpawnResult = await deps.spawnSession('mr-review-workflow-agentic', reReviewGoal, opts.workspace, reviewSpawnContext);
         if (reReviewSpawnResult.kind === 'err') {
             log(`      PR #${pr.number}  ->  re-review spawn failed: ${reReviewSpawnResult.error}`);
             return {

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

@@ -6,6 +6,7 @@ import type { DaemonRegistry } from '../v2/infra/in-memory/daemon-registry/index
 import type { V2StartWorkflowOutputSchema } from '../mcp/output-schemas.js';
 import type { DaemonEventEmitter } from './daemon-events.js';
 export declare const DAEMON_SESSIONS_DIR: string;
+export declare const WORKTREES_DIR: string;
 export { DAEMON_SOUL_DEFAULT, DAEMON_SOUL_TEMPLATE } from './soul-template.js';
 export type ReadFileState = {
     content: string;
@@ -28,6 +29,9 @@ export interface WorkflowTrigger {
     readonly parentSessionId?: string;
     readonly spawnDepth?: number;
     readonly soulFile?: string;
+    readonly branchStrategy?: 'worktree' | 'none';
+    readonly baseBranch?: string;
+    readonly branchPrefix?: string;
 }
 export interface WorkflowRunSuccess {
     readonly _tag: 'success';
@@ -35,6 +39,8 @@ export interface WorkflowRunSuccess {
     readonly stopReason: string;
     readonly lastStepNotes?: string;
     readonly lastStepArtifacts?: readonly unknown[];
+    readonly sessionWorkspacePath?: string;
+    readonly sessionId?: string;
 }
 export interface WorkflowRunError {
     readonly _tag: 'error';
@@ -64,13 +70,17 @@ export interface OrphanedSession {
     readonly continueToken: string;
     readonly checkpointToken: string | null;
     readonly ts: number;
+    readonly worktreePath?: string;
 }
 export declare function readDaemonSessionState(sessionId: string): Promise<{
     continueToken: string;
     checkpointToken: string | null;
 } | null>;
 export declare function readAllDaemonSessions(sessionsDir?: string): Promise<OrphanedSession[]>;
-export declare function runStartupRecovery(sessionsDir?: string): Promise<void>;
+export declare function runStartupRecovery(sessionsDir?: string, execFn?: (file: string, args: string[]) => Promise<{
+    stdout: string;
+    stderr: 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;

package/dist/daemon/workflow-runner.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAEMON_SIGNALS_DIR = 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.WORKTREES_DIR = exports.DAEMON_SESSIONS_DIR = void 0;
 exports.readDaemonSessionState = readDaemonSessionState;
 exports.readAllDaemonSessions = readAllDaemonSessions;
 exports.runStartupRecovery = runStartupRecovery;
@@ -83,8 +83,11 @@ function withWorkrailSession(sid) {
 }
 exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
 const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
+const MAX_WORKTREE_ORPHAN_AGE_MS = 24 * 60 * 60 * 1000;
 const WORKRAIL_DIR = path.join(os.homedir(), '.workrail');
+exports.WORKTREES_DIR = path.join(os.homedir(), '.workrail', 'worktrees');
 const WORKSPACE_CONTEXT_MAX_BYTES = 32 * 1024;
+const MAX_ASSEMBLED_CONTEXT_BYTES = 8192;
 const WORKSPACE_CONTEXT_CANDIDATE_PATHS = [
     '.claude/CLAUDE.md',
     'CLAUDE.md',
@@ -95,10 +98,10 @@ const soul_template_js_1 = require("./soul-template.js");
 var soul_template_js_2 = require("./soul-template.js");
 Object.defineProperty(exports, "DAEMON_SOUL_DEFAULT", { enumerable: true, get: function () { return soul_template_js_2.DAEMON_SOUL_DEFAULT; } });
 Object.defineProperty(exports, "DAEMON_SOUL_TEMPLATE", { enumerable: true, get: function () { return soul_template_js_2.DAEMON_SOUL_TEMPLATE; } });
-async function persistTokens(sessionId, continueToken, checkpointToken) {
+async function persistTokens(sessionId, continueToken, checkpointToken, worktreePath) {
     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() }, null, 2);
+    const state = JSON.stringify({ continueToken, checkpointToken, ts: Date.now(), ...(worktreePath !== undefined ? { worktreePath } : {}) }, null, 2);
     const tmp = `${sessionPath}.tmp`;
     await fs.writeFile(tmp, state, 'utf8');
     await fs.rename(tmp, sessionPath);
@@ -144,6 +147,7 @@ async function readAllDaemonSessions(sessionsDir = exports.DAEMON_SESSIONS_DIR)
                 continueToken: parsed.continueToken,
                 checkpointToken: typeof parsed.checkpointToken === 'string' ? parsed.checkpointToken : null,
                 ts: parsed.ts,
+                ...(typeof parsed.worktreePath === 'string' ? { worktreePath: parsed.worktreePath } : {}),
             });
         }
         catch (err) {
@@ -152,7 +156,7 @@ async function readAllDaemonSessions(sessionsDir = exports.DAEMON_SESSIONS_DIR)
     }
     return sessions;
 }
-async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR) {
+async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR, execFn = execFileAsync) {
     const sessions = await readAllDaemonSessions(sessionsDir);
     if (sessions.length === 0) {
         await clearStrayTmpFiles(sessionsDir);
@@ -167,6 +171,22 @@ async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR) {
         const ageSec = Math.round(ageMs / 1000);
         const label = isStale ? 'stale orphaned session' : 'orphaned session';
         console.log(`[WorkflowRunner] Clearing ${label}: sessionId=${session.sessionId} age=${ageSec}s`);
+        if (session.worktreePath && ageMs > MAX_WORKTREE_ORPHAN_AGE_MS) {
+            console.log(`[WorkflowRunner] Removing orphan worktree: sessionId=${session.sessionId} worktreePath=${session.worktreePath}`);
+            try {
+                await execFn('git', ['worktree', 'remove', '--force', session.worktreePath]);
+                console.log(`[WorkflowRunner] Removed orphan worktree: ${session.worktreePath}`);
+            }
+            catch (err) {
+                console.warn(`[WorkflowRunner] Could not remove orphan worktree ${session.worktreePath}: ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else if (session.worktreePath && ageMs <= MAX_WORKTREE_ORPHAN_AGE_MS) {
+            const ageHours = (ageMs / (60 * 60 * 1000)).toFixed(1);
+            console.log(`[WorkflowRunner] Keeping recent orphan worktree: sessionId=${session.sessionId} ` +
+                `age=${ageHours}h (threshold=24h) worktreePath=${session.worktreePath}`);
+        }
         try {
             await fs.unlink(path.join(sessionsDir, `${session.sessionId}.json`));
             cleared++;
@@ -1307,6 +1327,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');
@@ -1419,12 +1449,53 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     if (startContinueToken) {
         await persistTokens(sessionId, startContinueToken, startCheckpointToken);
     }
+    let sessionWorkspacePath = trigger.workspacePath;
+    let sessionWorktreePath;
+    if (trigger.branchStrategy === 'worktree') {
+        const branchPrefix = trigger.branchPrefix ?? 'worktrain/';
+        const baseBranch = trigger.baseBranch ?? 'main';
+        sessionWorkspacePath = path.join(exports.WORKTREES_DIR, sessionId);
+        sessionWorktreePath = sessionWorkspacePath;
+        try {
+            await fs.mkdir(exports.WORKTREES_DIR, { recursive: true });
+            await execFileAsync('git', ['-C', trigger.workspacePath, 'fetch', 'origin', baseBranch]);
+            await execFileAsync('git', [
+                '-C', trigger.workspacePath,
+                'worktree', 'add',
+                sessionWorkspacePath,
+                '-b', `${branchPrefix}${sessionId}`,
+                `origin/${baseBranch}`,
+            ]);
+            await persistTokens(sessionId, startContinueToken ?? currentContinueToken, startCheckpointToken, sessionWorktreePath);
+            console.log(`[WorkflowRunner] Worktree created: sessionId=${sessionId} ` +
+                `branch=${branchPrefix}${sessionId} path=${sessionWorkspacePath}`);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            console.error(`[WorkflowRunner] Worktree creation failed: sessionId=${sessionId} error=${errMsg}`);
+            emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'error', detail: errMsg.slice(0, 200), ...withWorkrailSession(workrailSessionId) });
+            if (workrailSessionId !== null)
+                daemonRegistry?.unregister(workrailSessionId, 'failed');
+            return {
+                _tag: 'error',
+                workflowId: trigger.workflowId,
+                message: `Worktree creation failed: ${errMsg}`,
+                stopReason: 'error',
+            };
+        }
+    }
     if (firstStep.isComplete) {
         await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
         emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop', ...withWorkrailSession(workrailSessionId) });
         if (workrailSessionId !== null)
             daemonRegistry?.unregister(workrailSessionId, 'completed');
-        return { _tag: 'success', workflowId: trigger.workflowId, stopReason: 'stop' };
+        return {
+            _tag: 'success',
+            workflowId: trigger.workflowId,
+            stopReason: 'stop',
+            ...(sessionWorktreePath !== undefined ? { sessionWorkspacePath: sessionWorktreePath } : {}),
+            ...(sessionWorktreePath !== undefined ? { sessionId } : {}),
+        };
     }
     const schemas = getSchemas();
     const spawnCurrentDepth = trigger.spawnDepth ?? 0;
@@ -1433,12 +1504,12 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     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),
+        makeBashTool(sessionWorkspacePath, 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),
+        makeGlobTool(sessionWorkspacePath, schemas, sessionId, emitter, workrailSessionId),
+        makeGrepTool(sessionWorkspacePath, schemas, sessionId, emitter, workrailSessionId),
+        makeEditTool(sessionWorkspacePath, readFileState, schemas, sessionId, emitter, workrailSessionId),
         makeReportIssueTool(sessionId, emitter, workrailSessionId, undefined, (summary) => {
             if (issueSummaries.length < MAX_ISSUE_SUMMARIES) {
                 issueSummaries.push(summary);
@@ -1659,5 +1730,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         stopReason,
         ...(lastStepNotes !== undefined ? { lastStepNotes } : {}),
         ...(lastStepArtifacts !== undefined ? { lastStepArtifacts } : {}),
+        ...(sessionWorktreePath !== undefined ? { sessionWorkspacePath: sessionWorktreePath } : {}),
+        ...(sessionWorktreePath !== undefined ? { sessionId } : {}),
     };
 }

package/dist/domain/execution/state.d.ts

@@ -20,12 +20,12 @@ export declare const LoopFrameSchema: z.ZodObject<{
     iteration: z.ZodNumber;
     bodyIndex: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    loopId: string;
     iteration: number;
+    loopId: string;
     bodyIndex: number;
 }, {
-    loopId: string;
     iteration: number;
+    loopId: string;
     bodyIndex: number;
 }>;
 export declare const StepInstanceIdSchema: z.ZodObject<{
@@ -34,23 +34,23 @@ export declare const StepInstanceIdSchema: z.ZodObject<{
         loopId: z.ZodString;
         iteration: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        loopId: string;
         iteration: number;
-    }, {
         loopId: string;
+    }, {
         iteration: number;
+        loopId: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     stepId: string;
     loopPath: {
-        loopId: string;
         iteration: number;
+        loopId: string;
     }[];
 }, {
     stepId: string;
     loopPath: {
-        loopId: string;
         iteration: number;
+        loopId: string;
     }[];
 }>;
 export declare const ExecutionStateSchema: z.ZodType<ExecutionState>;