@kynetic-ai/spec 0.8.0 → 0.9.0

package/dist/cli/commands/ralph.d.ts

@@ -5,5 +5,53 @@
  * Uses session event storage for full audit trail and streaming output.
  */
 import type { Command } from "commander";
+import { type LoadedSkill } from "../../parser/index.js";
+type RalphPromptPlatform = "claude-code" | "codex" | "unknown";
+type SkillOrigin = LoadedSkill["origin"];
+/**
+ * Map adapter IDs to prompt rendering platforms.
+ */
+export declare function getPromptPlatformForAdapter(adapterId: string): RalphPromptPlatform;
+/**
+ * Resolve configured skill invocation string for a specific platform.
+ * Supports portable {skill:<id>} syntax and legacy literal strings.
+ */
+export declare function resolveRalphSkillInvocation(invocation: string, platform: RalphPromptPlatform, skillOrigins: Map<string, SkillOrigin>): string;
+type AdapterValidationRunner = (command: string, args: string[], options: {
+    encoding: "utf-8";
+    stdio: "pipe";
+}) => {
+    status: number | null;
+};
+/**
+ * Check whether an adapter package appears to be installed and executable.
+ * Uses multiple non-installing probes because CLIs differ on supported flags.
+ */
+export declare function isAdapterPackageAvailable(adapterPackage: string, runner?: AdapterValidationRunner): boolean;
+interface TerminalRunResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    stdout_path?: string;
+    stderr_path?: string;
+    stdout_bytes: number;
+    stderr_bytes: number;
+    preview_truncated: boolean;
+}
+interface TerminalRunOptions {
+    command: string;
+    cwd: string;
+    timeout: number;
+    toolCallId: string | number;
+    specDir?: string;
+    sessionId?: string;
+    previewMaxBytes?: number;
+}
+/**
+ * Execute terminal/run request with bounded in-memory preview and streamed
+ * session artifacts for full stdout/stderr retention.
+ */
+export declare function runTerminalCommandWithArtifacts(options: TerminalRunOptions): Promise<TerminalRunResult>;
 export declare function registerRalphCommand(program: Command): void;
+export {};
 //# sourceMappingURL=ralph.d.ts.map

package/dist/cli/commands/ralph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ralph.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/ralph.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqyBzC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA42B3D"}
+{"version":3,"file":"ralph.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/ralph.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoBzC,OAAO,EAKL,KAAK,WAAW,EAIjB,MAAM,uBAAuB,CAAC;AAiJ/B,KAAK,mBAAmB,GAAG,aAAa,GAAG,OAAO,GAAG,SAAS,CAAC;AAE/D,KAAK,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AAOzC;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,CAUlF;AA8DD;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,mBAAmB,EAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GACrC,MAAM,CAeR;AAiHD,KAAK,uBAAuB,GAAG,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,KAC1C;IAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE/B;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,EACtB,MAAM,GAAE,uBAAmC,GAC1C,OAAO,CAiBT;AAuBD,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,UAAU,kBAAkB;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAgED;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,iBAAiB,CAAC,CAqG5B;AAqeD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA64B3D"}

package/dist/cli/commands/ralph.js

@@ -5,6 +5,7 @@
  * Uses session event storage for full audit trail and streaming output.
  */
 import { spawn, spawnSync } from "node:child_process";
+import { createWriteStream } from "node:fs";
 import * as fs from "node:fs/promises";
 import { createRequire } from "node:module";
 import * as path from "node:path";
@@ -15,9 +16,10 @@ const require = createRequire(import.meta.url);
 const { version: packageVersion } = require("../../../package.json");
 import { registerAdapter, resolveAdapter, } from "../../agents/index.js";
 import { spawnAndInitialize } from "../../agents/spawner.js";
-import { initContext, loadAllItems, loadAllTasks, ReferenceIndex, } from "../../parser/index.js";
+import { initContext, loadAllItems, loadMetaContext, loadAllTasks, ReferenceIndex, } from "../../parser/index.js";
+import { resolveSkillReferenceTokensForPlatform } from "../../parser/skill-render.js";
 import { buildWrapUpContext, createCliRenderer, createTranslator, DEFAULT_SUBAGENT_PREFIX, DEFAULT_WRAPUP_TIMEOUT, RALPH_PROMPT_TIMEOUT, runSubagent, runWrapUpAgent, WRAPUP_AGENT_PREFIX, } from "../../ralph/index.js";
-import { appendEvent, closeSession, createSessionWithBudget, getSessionBudgetPath, injectEnvForAdapter, isEndLoopRequested, removeEnvForAdapter, requestEndLoop, resetBudget, saveSessionContext, } from "../../sessions/index.js";
+import { appendEvent, closeSession, createSessionWithBudget, getSessionBudgetPath, getSessionDir, injectEnvForAdapter, isEndLoopRequested, removeEnvForAdapter, requestEndLoop, resetBudget, saveSessionContext, } from "../../sessions/index.js";
 import { errors } from "../../strings/index.js";
 import { getCurrentBranch } from "../../utils/git.js";
 import { EXIT_CODES } from "../exit-codes.js";
@@ -91,7 +93,79 @@ async function allExplicitTasksDone(ctx, scope) {
     });
     return { done, statuses };
 }
-// ─── Prompt Template ─────────────────────────────────────────────────────────
+const FALLBACK_CORE_SKILLS = new Set(["task-work", "reflect", "review"]);
+const ADAPTER_VALIDATION_PROBES = [["--help"], ["--version"]];
+const TERMINAL_PREVIEW_MAX_BYTES = 64 * 1024;
+const TOOL_OUTPUT_DIR = "tool-output";
+/**
+ * Map adapter IDs to prompt rendering platforms.
+ */
+export function getPromptPlatformForAdapter(adapterId) {
+    switch (adapterId) {
+        case "claude-agent-acp":
+        case "claude-code-acp":
+            return "claude-code";
+        case "codex-acp":
+            return "codex";
+        default:
+            return "unknown";
+    }
+}
+/**
+ * Build skill origin map from meta skills.
+ */
+async function loadSkillOriginsForRalph(ctx) {
+    const meta = await loadMetaContext(ctx);
+    const origins = new Map();
+    for (const skill of meta.skills) {
+        origins.set(skill.id, skill.origin);
+    }
+    // Fallback for core skills frequently used by ralph, even if core skills
+    // were not loaded into project meta for any reason.
+    for (const coreSkill of FALLBACK_CORE_SKILLS) {
+        if (!origins.has(coreSkill)) {
+            origins.set(coreSkill, "core");
+        }
+    }
+    return origins;
+}
+/**
+ * Normalize legacy literal invocation syntax for a target platform.
+ * Keeps backward compatibility for existing slash-style config values.
+ */
+function normalizeLegacyInvocation(invocation, platform) {
+    if (platform === "codex") {
+        if (/^\/kspec:([a-z0-9][a-z0-9-]*)$/.test(invocation)) {
+            return invocation.replace(/^\/kspec:([a-z0-9][a-z0-9-]*)$/, (_m, skillId) => `$kspec-${skillId}`);
+        }
+        if (/^\/([a-z0-9][a-z0-9-]*)$/.test(invocation)) {
+            return invocation.replace(/^\/([a-z0-9][a-z0-9-]*)$/, (_m, skillId) => `$${skillId}`);
+        }
+    }
+    if (platform === "claude-code") {
+        if (/^\$kspec-([a-z0-9][a-z0-9-]*)$/.test(invocation)) {
+            return invocation.replace(/^\$kspec-([a-z0-9][a-z0-9-]*)$/, (_m, skillId) => `/kspec:${skillId}`);
+        }
+        if (/^\$([a-z0-9][a-z0-9-]*)$/.test(invocation)) {
+            return invocation.replace(/^\$([a-z0-9][a-z0-9-]*)$/, (_m, skillId) => `/${skillId}`);
+        }
+    }
+    return invocation;
+}
+/**
+ * Resolve configured skill invocation string for a specific platform.
+ * Supports portable {skill:<id>} syntax and legacy literal strings.
+ */
+export function resolveRalphSkillInvocation(invocation, platform, skillOrigins) {
+    if (platform === "unknown") {
+        return invocation;
+    }
+    const tokenResolved = resolveSkillReferenceTokensForPlatform(invocation, platform, skillOrigins);
+    if (tokenResolved !== invocation) {
+        return tokenResolved;
+    }
+    return normalizeLegacyInvocation(invocation, platform);
+}
 // AC: @ralph-skill-delegation ac-1, ac-2, ac-3
 function buildTaskWorkPrompt(sessionCtx, iteration, maxLoops, sessionId, skillTaskWork, focus, explicitTaskScope) {
     const focusSection = focus
@@ -174,46 +248,182 @@ ${isFinal
 Exit when reflection is complete.
 `;
 }
-// ─── Streaming Output ────────────────────────────────────────────────────────
-// Translator and renderer are created per-session in the action handler.
-// This allows the architecture to be reused by future TUI renderers.
-// ─── Adapter Validation ──────────────────────────────────────────────────────
-// AC: @ralph-adapter-validation valid-adapter-proceeds, invalid-adapter-error, validation-before-spawn
+/**
+ * Check whether an adapter package appears to be installed and executable.
+ * Uses multiple non-installing probes because CLIs differ on supported flags.
+ */
+export function isAdapterPackageAvailable(adapterPackage, runner = spawnSync) {
+    for (const probeArgs of ADAPTER_VALIDATION_PROBES) {
+        const result = runner("npx", ["--no-install", adapterPackage, ...probeArgs], {
+            encoding: "utf-8",
+            stdio: "pipe",
+        });
+        if (result.status === 0) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Validate that the specified ACP adapter package exists.
- * Uses npx --no-install to check both global and local node_modules.
+ * Uses npx --no-install probes to check both global and local node_modules.
  *
  * @throws {Error} Never throws - exits process with code 3 if validation fails
  */
 function validateAdapter(adapterPackage) {
-    // Use npx --no-install with --version to check if package exists
-    // This checks both global and local node_modules, handles scoped packages
-    const result = spawnSync("npx", ["--no-install", adapterPackage, "--version"], {
-        encoding: "utf-8",
-        stdio: "pipe",
-    });
-    if (result.status !== 0) {
+    if (!isAdapterPackageAvailable(adapterPackage)) {
         error(`Adapter package not found: ${adapterPackage}. Install with: npm install -g ${adapterPackage}`);
         process.exit(EXIT_CODES.NOT_FOUND);
     }
 }
+function sanitizeToolCallId(toolCallId) {
+    const raw = String(toolCallId).trim();
+    if (!raw) {
+        return "tool-call";
+    }
+    return raw.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function updateStreamPreview(state, chunk, maxPreviewBytes) {
+    state.bytes += chunk.length;
+    const remaining = maxPreviewBytes - state.previewBytes;
+    if (remaining <= 0) {
+        state.truncated = true;
+        return;
+    }
+    if (chunk.length > remaining) {
+        state.previewParts.push(chunk.subarray(0, remaining).toString("utf-8"));
+        state.previewBytes += remaining;
+        state.truncated = true;
+        return;
+    }
+    state.previewParts.push(chunk.toString("utf-8"));
+    state.previewBytes += chunk.length;
+}
+function closeStream(stream) {
+    if (!stream) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            stream.off("finish", onFinish);
+            reject(err);
+        };
+        const onFinish = () => {
+            stream.off("error", onError);
+            resolve();
+        };
+        stream.once("error", onError);
+        stream.once("finish", onFinish);
+        stream.end();
+    });
+}
+/**
+ * Execute terminal/run request with bounded in-memory preview and streamed
+ * session artifacts for full stdout/stderr retention.
+ */
+export async function runTerminalCommandWithArtifacts(options) {
+    const previewMaxBytes = options.previewMaxBytes ?? TERMINAL_PREVIEW_MAX_BYTES;
+    const shouldWriteArtifacts = Boolean(options.specDir && options.sessionId);
+    let stdoutPath;
+    let stderrPath;
+    if (shouldWriteArtifacts) {
+        const outputDir = path.join(getSessionDir(options.specDir, options.sessionId), TOOL_OUTPUT_DIR);
+        await fs.mkdir(outputDir, { recursive: true });
+        const safeToolCallId = sanitizeToolCallId(options.toolCallId);
+        stdoutPath = path.join(outputDir, `${safeToolCallId}.stdout.log`);
+        stderrPath = path.join(outputDir, `${safeToolCallId}.stderr.log`);
+    }
+    const stdoutState = {
+        bytes: 0,
+        previewBytes: 0,
+        previewParts: [],
+        truncated: false,
+        stream: stdoutPath ? createWriteStream(stdoutPath) : undefined,
+    };
+    const stderrState = {
+        bytes: 0,
+        previewBytes: 0,
+        previewParts: [],
+        truncated: false,
+        stream: stderrPath ? createWriteStream(stderrPath) : undefined,
+    };
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const child = spawn(options.command, [], {
+            cwd: options.cwd,
+            shell: true,
+            timeout: options.timeout,
+        });
+        const finalize = async (exitCode, errorMessage) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (errorMessage) {
+                const errChunk = Buffer.from(errorMessage, "utf-8");
+                stderrState.stream?.write(errChunk);
+                updateStreamPreview(stderrState, errChunk, previewMaxBytes);
+            }
+            try {
+                await Promise.all([
+                    closeStream(stdoutState.stream),
+                    closeStream(stderrState.stream),
+                ]);
+            }
+            catch (streamErr) {
+                reject(streamErr);
+                return;
+            }
+            resolve({
+                stdout: stdoutState.previewParts.join(""),
+                stderr: stderrState.previewParts.join(""),
+                exitCode,
+                stdout_path: stdoutPath,
+                stderr_path: stderrPath,
+                stdout_bytes: stdoutState.bytes,
+                stderr_bytes: stderrState.bytes,
+                preview_truncated: stdoutState.truncated || stderrState.truncated,
+            });
+        };
+        child.stdout?.on("data", (data) => {
+            const chunk = Buffer.isBuffer(data)
+                ? data
+                : Buffer.from(String(data), "utf-8");
+            stdoutState.stream?.write(chunk);
+            updateStreamPreview(stdoutState, chunk, previewMaxBytes);
+        });
+        child.stderr?.on("data", (data) => {
+            const chunk = Buffer.isBuffer(data)
+                ? data
+                : Buffer.from(String(data), "utf-8");
+            stderrState.stream?.write(chunk);
+            updateStreamPreview(stderrState, chunk, previewMaxBytes);
+        });
+        child.on("close", (code) => {
+            void finalize(code ?? 1);
+        });
+        child.on("error", (err) => {
+            void finalize(1, err.message);
+        });
+    });
+}
 // ─── Tool Request Handler ────────────────────────────────────────────────────
 /**
  * Handle tool requests from ACP agent.
  * Implements file operations, terminal commands, and permission handling.
  */
-async function handleRequest(client, id, method, params, yolo) {
+async function handleRequest(client, id, method, params, options) {
     try {
         switch (method) {
             case "session/request_permission": {
                 const p = params;
                 // In yolo mode, auto-approve all permissions
                 // In normal mode, would need to implement permission UI
-                const options = p.options || [];
-                if (yolo) {
+                const permissionOptions = p.options || [];
+                if (options.yolo) {
                     // Find an "allow" option (prefer allow_always, then allow_once)
-                    const allowOption = options.find((o) => o.kind === "allow_always") ||
-                        options.find((o) => o.kind === "allow_once");
+                    const allowOption = permissionOptions.find((o) => o.kind === "allow_always") ||
+                        permissionOptions.find((o) => o.kind === "allow_once");
                     if (allowOption) {
                         client.respondPermission(id, {
                             outcome: { outcome: "selected", optionId: allowOption.optionId },
@@ -250,26 +460,13 @@ async function handleRequest(client, id, method, params, yolo) {
                 const command = p.command;
                 const cwd = p.cwd || process.cwd();
                 const timeout = p.timeout || 60000;
-                const result = await new Promise((resolve) => {
-                    const child = spawn(command, [], {
-                        cwd,
-                        shell: true,
-                        timeout,
-                    });
-                    let stdout = "";
-                    let stderr = "";
-                    child.stdout?.on("data", (data) => {
-                        stdout += data.toString();
-                    });
-                    child.stderr?.on("data", (data) => {
-                        stderr += data.toString();
-                    });
-                    child.on("close", (code) => {
-                        resolve({ stdout, stderr, exitCode: code ?? 1 });
-                    });
-                    child.on("error", (err) => {
-                        resolve({ stdout, stderr: err.message, exitCode: 1 });
-                    });
+                const result = await runTerminalCommandWithArtifacts({
+                    command,
+                    cwd,
+                    timeout,
+                    toolCallId: id,
+                    specDir: options.specDir,
+                    sessionId: options.sessionId,
                 });
                 // Using generic respond() since this is a custom method
                 client.respond(id, result);
@@ -488,12 +685,16 @@ async function processPendingReviewTasks(ctx, adapter, pendingReviewTasks, optio
             const result = await runSubagent(adapter, subagentCtx, {
                 timeout: options.subagentTimeout,
                 outputPrefix: DEFAULT_SUBAGENT_PREFIX,
-                skillName: ctx.config.ralph.skills.pr_review,
+                skillName: options.prReviewSkillName,
             }, {
                 yolo: options.yolo,
                 cwd: options.cwd,
                 extraArgs: options.autoApproveArgs,
-                handleRequest: (client, reqId, method, params) => handleRequest(client, reqId, method, params, options.yolo),
+                handleRequest: (client, reqId, method, params) => handleRequest(client, reqId, method, params, {
+                    yolo: options.yolo,
+                    specDir: options.specDir,
+                    sessionId: options.sessionId,
+                }),
             });
             if (result.timedOut) {
                 // AC: @ralph-subagent-spawning ac-9
@@ -724,6 +925,12 @@ export function registerRalphCommand(program) {
                     process.exit(EXIT_CODES.VALIDATION_FAILED);
                 }
             }
+            const skillOrigins = await loadSkillOriginsForRalph(ctx);
+            const workerPromptPlatform = getPromptPlatformForAdapter(workerAdapterId);
+            const reviewerPromptPlatform = getPromptPlatformForAdapter(reviewerAdapterId);
+            const workerTaskWorkSkill = resolveRalphSkillInvocation(ctx.config.ralph.skills.task_work, workerPromptPlatform, skillOrigins);
+            const workerReflectSkill = resolveRalphSkillInvocation(ctx.config.ralph.skills.reflect, workerPromptPlatform, skillOrigins);
+            const reviewerPrReviewSkill = resolveRalphSkillInvocation(ctx.config.ralph.skills.pr_review, reviewerPromptPlatform, skillOrigins);
             const taskScopeInfo = explicitTaskScope
                 ? `, tasks=${explicitTaskScope.refs.join(",")}`
                 : "";
@@ -874,8 +1081,11 @@ export function registerRalphCommand(program) {
                         maxRetries,
                         maxFailures,
                         cwd: process.cwd(),
+                        specDir,
+                        sessionId,
                         subagentTimeout: subagentTimeout * 60 * 1000,
                         autoApproveArgs: reviewerAutoApproveArgs,
+                        prReviewSkillName: reviewerPrReviewSkill,
                     }, failureTracker);
                     consecutiveFailures = failureTracker.count;
                     if (!continueLoop) {
@@ -929,8 +1139,8 @@ export function registerRalphCommand(program) {
                     const iterationStartTime = new Date();
                     // Build prompts - task-work first, then reflect
                     // AC: @cli-ralph ac-21 - Include explicit task scope in prompt
-                    const taskWorkPrompt = buildTaskWorkPrompt(currentCtx, iteration, maxLoops, sessionId, ctx.config.ralph.skills.task_work, options.focus, explicitTaskScope);
-                    const reflectPrompt = buildReflectPrompt(iteration, maxLoops, sessionId, ctx.config.ralph.skills.reflect);
+                    const taskWorkPrompt = buildTaskWorkPrompt(currentCtx, iteration, maxLoops, sessionId, workerTaskWorkSkill, options.focus, explicitTaskScope);
+                    const reflectPrompt = buildReflectPrompt(iteration, maxLoops, sessionId, workerReflectSkill);
                     // AC: @cli-ralph ac-21
                     // AC: @ralph-per-role-adapters ac-10
                     if (options.dryRun) {
@@ -942,6 +1152,9 @@ export function registerRalphCommand(program) {
                         console.log(`  max-retries: ${maxRetries}`);
                         console.log(`  max-failures: ${maxFailures}`);
                         console.log(`  restart-every: ${restartEvery === 0 ? "never" : restartEvery}`);
+                        console.log(`  worker-task-work-skill: ${workerTaskWorkSkill}`);
+                        console.log(`  worker-reflect-skill: ${workerReflectSkill}`);
+                        console.log(`  reviewer-pr-review-skill: ${reviewerPrReviewSkill}`);
                         if (explicitTaskScope) {
                             console.log(`  explicit-tasks: ${explicitTaskScope.refs.join(", ")}`);
                         }
@@ -1017,7 +1230,11 @@ export function registerRalphCommand(program) {
                                 // Set up tool request handler
                                 agent.client.on("request", (reqId, method, params) => {
                                     // biome-ignore lint/style/noNonNullAssertion: agent is guaranteed to exist when callback is registered
-                                    handleRequest(agent.client, reqId, method, params, options.yolo).catch((err) => {
+                                    handleRequest(agent.client, reqId, method, params, {
+                                        yolo: options.yolo,
+                                        specDir,
+                                        sessionId,
+                                    }).catch((err) => {
                                         // biome-ignore lint/style/noNonNullAssertion: agent is guaranteed to exist when callback is registered
                                         agent.client.respondError(reqId, -32000, err.message);
                                     });
@@ -1187,7 +1404,11 @@ export function registerRalphCommand(program) {
                         yolo: options.yolo,
                         cwd: process.cwd(),
                         extraArgs: workerAutoApproveArgs,
-                        handleRequest: (client, reqId, method, params) => handleRequest(client, reqId, method, params, options.yolo),
+                        handleRequest: (client, reqId, method, params) => handleRequest(client, reqId, method, params, {
+                            yolo: options.yolo,
+                            specDir,
+                            sessionId,
+                        }),
                     }, DEFAULT_WRAPUP_TIMEOUT);
                     // Log wrap-up result
                     await appendEvent(specDir, {