@kynetic-ai/spec 0.7.0 → 0.9.0

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,11 +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,
-                handleRequest: (client, reqId, method, params) => handleRequest(client, reqId, method, params, options.yolo),
+                extraArgs: options.autoApproveArgs,
+                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
@@ -612,6 +814,8 @@ export function registerRalphCommand(program) {
         .option("--no-yolo", "Require normal permission prompts")
         .option("--subagent-timeout <minutes>", "Review subagent timeout in minutes", "20")
         .option("--adapter <id>", "Agent adapter to use", "claude-agent-acp")
+        .option("--worker-adapter <id>", "Adapter for task-work agent (overrides --adapter)")
+        .option("--reviewer-adapter <id>", "Adapter for review subagent (overrides --adapter)")
         .option("--adapter-cmd <cmd>", "Custom adapter command (for testing)")
         .option("--restart-every <n>", "Restart agent every N iterations to prevent OOM (0 = never)", "10")
         .option("--focus <instructions>", "Focus instructions included in every iteration prompt")
@@ -679,28 +883,32 @@ export function registerRalphCommand(program) {
                 registerAdapter("custom", customAdapter);
                 options.adapter = "custom";
             }
-            // Resolve adapter
-            const adapter = resolveAdapter(options.adapter);
-            // Validate adapter package exists before proceeding
-            // Skip validation for:
-            // - Custom adapters (--adapter-cmd)
-            // - Non-npx adapters
-            // - Dry-run mode with default adapter (doesn't spawn agent, default may not be installed in CI)
-            // Note: If user explicitly specifies --adapter, validate even in dry-run to catch typos
-            // Accept both new and deprecated adapter names
-            const isDefaultAdapter = options.adapter === "claude-agent-acp" ||
-                options.adapter === "claude-code-acp";
-            const skipValidation = options.adapterCmd ||
-                adapter.command !== "npx" ||
-                !adapter.args[0] ||
-                (options.dryRun && isDefaultAdapter);
-            if (!skipValidation) {
-                validateAdapter(adapter.args[0]);
-            }
-            // Add yolo flag to adapter args if needed (accept both new and deprecated names)
-            if (options.yolo && isDefaultAdapter) {
-                adapter.args = [...adapter.args, "--dangerously-skip-permissions"];
+            // AC: @ralph-per-role-adapters ac-3, ac-4, ac-5
+            // Resolve per-role adapters with precedence: role flag > --adapter > default
+            const workerAdapterId = options.workerAdapter ?? options.adapter;
+            const reviewerAdapterId = options.reviewerAdapter ?? options.adapter;
+            const workerAdapter = resolveAdapter(workerAdapterId);
+            const reviewerAdapter = resolveAdapter(reviewerAdapterId);
+            // AC: @ralph-per-role-adapters ac-6, ac-9, ac-11
+            // Validate adapter packages — deduplicate when same ID
+            const adapterIdsToValidate = new Set([workerAdapterId, reviewerAdapterId]);
+            for (const id of adapterIdsToValidate) {
+                const resolved = resolveAdapter(id);
+                const isDefault = id === "claude-agent-acp" || id === "claude-code-acp";
+                const skip = resolved.command !== "npx" ||
+                    !resolved.args[0] ||
+                    (options.dryRun && isDefault);
+                if (!skip) {
+                    validateAdapter(resolved.args[0]);
+                }
             }
+            // Build auto-approve extra args per adapter (applied per-spawn to prevent cross-role leakage)
+            const workerAutoApproveArgs = options.yolo
+                ? workerAdapter.autoApproveArgs
+                : undefined;
+            const reviewerAutoApproveArgs = options.yolo
+                ? reviewerAdapter.autoApproveArgs
+                : undefined;
             const restartInfo = restartEvery > 0 ? `, restart every ${restartEvery}` : "";
             const maxTasksInfo = maxTasks === 0 ? "unlimited" : `${maxTasks}`;
             // Initialize kspec context early to validate --tasks
@@ -717,10 +925,19 @@ 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(",")}`
                 : "";
-            info(`Starting ralph loop (adapter=${options.adapter}, max ${maxLoops} iterations, ${maxRetries} retries, ${maxFailures} max failures${restartInfo}, max-tasks=${maxTasksInfo}${taskScopeInfo})`);
+            const adapterInfo = workerAdapterId === reviewerAdapterId
+                ? `adapter=${workerAdapterId}`
+                : `worker=${workerAdapterId}, reviewer=${reviewerAdapterId}`;
+            info(`Starting ralph loop (${adapterInfo}, max ${maxLoops} iterations, ${maxRetries} retries, ${maxFailures} max failures${restartInfo}, max-tasks=${maxTasksInfo}${taskScopeInfo})`);
             if (options.focus) {
                 info(`Focus: ${options.focus}`);
             }
@@ -738,12 +955,20 @@ export function registerRalphCommand(program) {
             // Create session with budget. When maxTasks=0 (unlimited), no budget.json is created.
             await createSessionWithBudget(specDir, {
                 id: sessionId,
-                agent_type: options.adapter,
+                agent_type: workerAdapterId,
                 budget: maxTasks,
             });
-            // Adapter ID for harness-specific env injection/cleanup.
-            // Declared before try/finally so signal handlers and finally block can access it.
-            const adapterId = options.adapter || "claude-agent-acp";
+            // AC: @ralph-per-role-adapters ac-6, ac-7
+            // Adapter IDs for harness-specific env injection/cleanup.
+            // Deduplicate by harness target, not just adapter ID. claude-code-acp is
+            // an alias for claude-agent-acp — both inject to the same Claude Code
+            // settings file. Without normalization, injecting twice would clobber the
+            // previousValue and break cleanup restoration.
+            const normalizeForEnv = (id) => id === "claude-code-acp" ? "claude-agent-acp" : id;
+            const uniqueAdapterIds = [...new Set([
+                    normalizeForEnv(workerAdapterId),
+                    normalizeForEnv(reviewerAdapterId),
+                ])];
             // Everything after session creation is wrapped in try/finally to guarantee
             // budget cleanup even if pre-loop setup (event logging, signal handlers) throws.
             // AC: @ralph-session-budget-integration ac-session-close-all-paths
@@ -753,7 +978,9 @@ export function registerRalphCommand(program) {
             let exitReason = null;
             let lastIterationCtx = null;
             let lastErrorMessage;
-            let previousEnvValue; // For restoring pre-existing KSPEC_SESSION_ID
+            // AC: @ralph-per-role-adapters ac-7
+            // Track previous env values per adapter for cleanup restoration
+            const previousEnvValues = new Map();
             const recentTaskRefs = [];
             const sessionIterationMap = new Map();
             // Signal handler refs — declared here so finally can remove them
@@ -772,7 +999,7 @@ export function registerRalphCommand(program) {
                         await Promise.all([
                             fs.unlink(getSessionBudgetPath(specDir, sessionId)).catch(() => { }),
                             closeSession(specDir, sessionId, "abandoned", `Received ${signal}`),
-                            removeEnvForAdapter(adapterId, previousEnvValue),
+                            ...uniqueAdapterIds.map((id) => removeEnvForAdapter(id, previousEnvValues.get(id))),
                         ]);
                     }
                     catch {
@@ -792,19 +1019,24 @@ export function registerRalphCommand(program) {
                 // AC: @ralph-session-budget-integration ac-session-close-all-paths
                 process.on("SIGINT", sigintHandler);
                 process.on("SIGTERM", sigtermHandler);
-                // Inject KSPEC_SESSION_ID into agent harness config so it reaches child
-                // processes. Inside try/finally so cleanup runs even if injection fails.
+                // AC: @ralph-per-role-adapters ac-6, ac-7
+                // Inject KSPEC_SESSION_ID into agent harness config for each unique adapter.
                 // Process env alone is insufficient — some harnesses (e.g., Claude Code)
                 // sandbox child processes and don't forward arbitrary parent env vars.
                 // AC: @ralph-session-budget-integration ac-env-inject
-                const injectionResult = await injectEnvForAdapter(adapterId, sessionId);
-                previousEnvValue = injectionResult?.previousValue;
-                // Log session start
+                for (const id of uniqueAdapterIds) {
+                    const injectionResult = await injectEnvForAdapter(id, sessionId);
+                    previousEnvValues.set(id, injectionResult?.previousValue);
+                }
+                // AC: @ralph-per-role-adapters ac-12
+                // Log session start with both adapter IDs
                 await appendEvent(specDir, {
                     session_id: sessionId,
                     type: "session.start",
                     data: {
-                        adapter: options.adapter,
+                        adapter: workerAdapterId,
+                        workerAdapter: workerAdapterId,
+                        reviewerAdapter: reviewerAdapterId,
                         maxLoops,
                         maxRetries,
                         maxFailures,
@@ -841,14 +1073,19 @@ export function registerRalphCommand(program) {
                         sessionCtx = filterByExplicitTasks(sessionCtx, explicitTaskScope);
                     }
                     // AC: @ralph-subagent-spawning ac-8 - Process pending_review tasks BEFORE main iteration
+                    // AC: @ralph-per-role-adapters ac-2 - Use reviewer adapter for review subagents
                     // This wraps consecutiveFailures in an object so it can be mutated by the helper
                     const failureTracker = { count: consecutiveFailures };
-                    const continueLoop = await processPendingReviewTasks(ctx, adapter, sessionCtx.pending_review_tasks, {
+                    const continueLoop = await processPendingReviewTasks(ctx, reviewerAdapter, sessionCtx.pending_review_tasks, {
                         yolo: options.yolo,
                         maxRetries,
                         maxFailures,
                         cwd: process.cwd(),
+                        specDir,
+                        sessionId,
                         subagentTimeout: subagentTimeout * 60 * 1000,
+                        autoApproveArgs: reviewerAutoApproveArgs,
+                        prReviewSkillName: reviewerPrReviewSkill,
                     }, failureTracker);
                     consecutiveFailures = failureTracker.count;
                     if (!continueLoop) {
@@ -902,16 +1139,22 @@ 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) {
                         console.log(chalk.yellow("=== DRY RUN - Configuration ===\n"));
+                        console.log(`  worker-adapter: ${workerAdapterId}`);
+                        console.log(`  reviewer-adapter: ${reviewerAdapterId}`);
                         console.log(`  max-loops: ${maxLoops}`);
                         console.log(`  max-tasks: ${maxTasks === 0 ? "unlimited" : maxTasks}`);
                         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(", ")}`);
                         }
@@ -945,12 +1188,15 @@ export function registerRalphCommand(program) {
                         }
                         try {
                             // Spawn agent if not already running
+                            // AC: @ralph-per-role-adapters ac-1 - Use worker adapter for task-work
                             if (!agent) {
                                 info("Spawning ACP agent...");
                                 // AC: @ralph-session-budget-integration ac-env-inject
-                                agent = await spawnAndInitialize(adapter, {
+                                // AC: @ralph-adapter-auto-approve ac-1, ac-2, ac-3
+                                agent = await spawnAndInitialize(workerAdapter, {
                                     cwd: process.cwd(),
                                     env: { KSPEC_SESSION_ID: sessionId },
+                                    extraArgs: workerAutoApproveArgs,
                                     clientOptions: {
                                         clientInfo: {
                                             name: "kspec-ralph",
@@ -984,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);
                                     });
@@ -1127,9 +1377,11 @@ export function registerRalphCommand(program) {
                     agent = null;
                 }
                 // AC: @ralph-session-budget-integration ac-session-close-all-paths
-                // Clean up budget file and harness env injection when session ends
+                // AC: @ralph-per-role-adapters ac-7 - Clean up env for all unique adapters
                 await fs.unlink(getSessionBudgetPath(specDir, sessionId)).catch(() => { });
-                await removeEnvForAdapter(adapterId, previousEnvValue);
+                for (const id of uniqueAdapterIds) {
+                    await removeEnvForAdapter(id, previousEnvValues.get(id));
+                }
                 // Clean up session env vars
                 delete process.env.KSPEC_RALPH_SESSION;
                 delete process.env.KSPEC_SESSION_ID;
@@ -1147,10 +1399,16 @@ export function registerRalphCommand(program) {
                     maxLoops, inProgressTasks, pendingReviewTasks, recentTaskRefs, process.cwd(), lastErrorMessage);
                     info(`Exit reason: ${exitReason}`);
                     info(`Working tree: ${wrapUpCtx.workingTree.clean ? "clean" : "has uncommitted changes"}`);
-                    const wrapUpResult = await runWrapUpAgent(adapter, wrapUpCtx, {
+                    // AC: @ralph-per-role-adapters ac-8 - Wrap-up uses worker adapter
+                    const wrapUpResult = await runWrapUpAgent(workerAdapter, wrapUpCtx, {
                         yolo: options.yolo,
                         cwd: process.cwd(),
-                        handleRequest: (client, reqId, method, params) => handleRequest(client, reqId, method, params, options.yolo),
+                        extraArgs: workerAutoApproveArgs,
+                        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, {