@parall/claude-agent 1.24.0 → 1.26.0

package/dist/session-manager.js

@@ -7,6 +7,7 @@ export class ClaudeSessionManager {
     logger;
     sessionIds = new Map();
     pendingForkParents = new Map();
+    processes = new Map();
     constructor(mainSessionKey, stateFilePath, logger) {
         this.mainSessionKey = mainSessionKey;
         this.stateFilePath = stateFilePath;
@@ -43,6 +44,122 @@ export class ClaudeSessionManager {
     cleanupFork(sessionKey) {
         this.pendingForkParents.delete(sessionKey);
         this.sessionIds.delete(sessionKey);
+        const handle = this.processes.get(sessionKey);
+        if (handle) {
+            this.processes.delete(sessionKey);
+            this.closeHandle(handle, `fork ${sessionKey} cleanup`);
+        }
+    }
+    getProcess(sessionKey) {
+        return this.processes.get(sessionKey);
+    }
+    registerProcess(sessionKey, handle) {
+        const existing = this.processes.get(sessionKey);
+        if (existing && existing !== handle) {
+            this.logger?.warn(`claude-agent: replacing existing process handle for ${sessionKey}; closing previous`);
+            this.closeHandle(existing, `replaced for ${sessionKey}`);
+        }
+        this.processes.set(sessionKey, handle);
+        // Auto-clear on exit so the map does not accumulate dead handles.
+        handle.exitPromise
+            .finally(() => {
+            const current = this.processes.get(sessionKey);
+            if (current === handle) {
+                this.processes.delete(sessionKey);
+            }
+        })
+            .catch(() => {
+            // exitPromise is resolved, never rejected, but guard anyway.
+        });
+    }
+    clearProcess(sessionKey, handle) {
+        const current = this.processes.get(sessionKey);
+        if (!current)
+            return;
+        if (handle && current !== handle)
+            return;
+        this.processes.delete(sessionKey);
+    }
+    /** Grace period (ms) between SIGTERM and SIGKILL during shutdown. */
+    static SHUTDOWN_GRACE_MS = 5_000;
+    async shutdownAll() {
+        const handles = [...this.processes.entries()];
+        this.processes.clear();
+        await Promise.all(handles.map(([sessionKey, handle]) => this.shutdownOne(sessionKey, handle)));
+    }
+    async shutdownOne(sessionKey, handle) {
+        this.closeHandle(handle, `shutdown ${sessionKey}`);
+        // Wait for SIGTERM to take effect, but bound the wait: if the child
+        // ignores SIGTERM (buggy tool, uninterruptible syscall, etc.) we must
+        // not block the whole agent exit forever. Escalate to SIGKILL after the
+        // grace window and then wait once more for the kernel to reap it.
+        const timedOut = await this.raceWithTimeout(handle.exitPromise, ClaudeSessionManager.SHUTDOWN_GRACE_MS);
+        if (!timedOut)
+            return;
+        if (handle.proc.exitCode === null && handle.proc.signalCode === null) {
+            this.logger?.warn(`claude-agent: SIGTERM timed out for ${sessionKey}, escalating to SIGKILL`);
+            try {
+                handle.proc.kill("SIGKILL");
+            }
+            catch (error) {
+                this.logger?.warn(`claude-agent: SIGKILL failed for ${sessionKey}: ${String(error)}`);
+            }
+        }
+        // Bound the post-SIGKILL wait too: on the rare kernel path where even
+        // SIGKILL delivery is delayed (uninterruptible D-state, zombie reaping
+        // stuck on a parent bookkeeping path), gateway disconnect must still
+        // make progress. Warn and move on if the reap is not observed in time.
+        const killTimedOut = await this.raceWithTimeout(handle.exitPromise, ClaudeSessionManager.SHUTDOWN_GRACE_MS);
+        if (killTimedOut) {
+            this.logger?.warn(`claude-agent: subprocess for ${sessionKey} not reaped after SIGKILL within ${ClaudeSessionManager.SHUTDOWN_GRACE_MS}ms; continuing shutdown`);
+        }
+    }
+    /**
+     * Wait up to `ms` for `promise`. Resolves `false` if the promise settled
+     * in time, `true` if the timeout fired first. Never rejects.
+     */
+    raceWithTimeout(promise, ms) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(true);
+            }, ms);
+            // Don't keep the event loop alive purely on the timeout.
+            if (typeof timer.unref === "function")
+                timer.unref();
+            promise
+                .catch(() => {
+                /* exitPromise does not reject; guard anyway */
+            })
+                .finally(() => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(false);
+            });
+        });
+    }
+    closeHandle(handle, reason) {
+        try {
+            if (!handle.proc.stdin.destroyed) {
+                handle.proc.stdin.end();
+            }
+        }
+        catch (error) {
+            this.logger?.warn(`claude-agent: failed to close stdin (${reason}): ${String(error)}`);
+        }
+        if (handle.proc.exitCode === null && handle.proc.signalCode === null) {
+            try {
+                handle.proc.kill("SIGTERM");
+            }
+            catch (error) {
+                this.logger?.warn(`claude-agent: failed to SIGTERM claude subprocess (${reason}): ${String(error)}`);
+            }
+        }
     }
     restore() {
         try {

package/dist/workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../src/workspace.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,EACrC,aAAa,CAAC,EAAE,aAAa,QAiC9B"}
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../src/workspace.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,EACrC,aAAa,CAAC,EAAE,aAAa,QAmB9B"}

package/dist/workspace.js

@@ -1,35 +1,20 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { BRIDGE_WORKSPACE_INSTRUCTIONS, PRLL_BEHAVIOR, PRLL_REFERENCE_GUIDE, buildIdentity, } from "@parall/agent-core";
+import { BRIDGE_WORKSPACE_INSTRUCTIONS, PRLL_BEHAVIOR, PRLL_REFERENCE_GUIDE, buildIdentity, buildSkillReferences, writeSkillFiles, } from "@parall/agent-core";
 import { ensureLocalAttachmentGitExclude } from "@parall/agent-core/internal/attachment-input";
 export function ensureClaudeWorkspace(workspaceDir, log, agentIdentity) {
-    const CLAUDE_MD = [
+    const systemPrompt = [
         buildIdentity(agentIdentity),
         BRIDGE_WORKSPACE_INSTRUCTIONS,
         PRLL_BEHAVIOR,
         PRLL_REFERENCE_GUIDE,
+        buildSkillReferences(workspaceDir),
     ].join("\n\n");
     fs.mkdirSync(workspaceDir, { recursive: true });
     fs.mkdirSync(path.join(workspaceDir, ".claude"), { recursive: true });
-    // CLAUDE.md is bridge-managed: always overwrite so a hosted PVC keeps the
-    // current guardrails (e.g. the `no-reply` instruction). Operators must not
-    // hand-edit this file — workspace customizations should go into AGENTS.md
-    // / SOUL.md / TOOLS.md, which are env-driven and untouched here. Surface a
-    // warning when we replace a file whose content diverges, so an operator
-    // who did edit it locally gets a signal instead of silently losing changes.
-    const claudeMdPath = path.join(workspaceDir, "CLAUDE.md");
-    if (log) {
-        try {
-            const existing = fs.readFileSync(claudeMdPath, "utf8");
-            if (existing !== CLAUDE_MD) {
-                log.warn(`claude-agent: overwriting divergent ${claudeMdPath} with bridge-managed template ` +
-                    `(local edits to CLAUDE.md are not preserved — customize AGENTS.md / SOUL.md / TOOLS.md instead)`);
-            }
-        }
-        catch {
-            // file missing or unreadable — first-boot case, no warning needed
-        }
-    }
-    fs.writeFileSync(claudeMdPath, CLAUDE_MD, "utf8");
+    const parallDir = path.join(workspaceDir, ".parall");
+    fs.mkdirSync(parallDir, { recursive: true });
+    fs.writeFileSync(path.join(parallDir, "system-prompt.md"), systemPrompt, "utf8");
+    writeSkillFiles(path.join(parallDir, "skills"));
     ensureLocalAttachmentGitExclude(workspaceDir);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/claude-agent",
-  "version": "1.24.0",
+  "version": "1.26.0",
   "description": "Claude Code bridge runtime for self-hosted Parall agents",
   "license": "MIT",
   "repository": {
@@ -25,9 +25,9 @@
     "src"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.24.0",
-    "@parall/cli": "1.24.0",
-    "@parall/sdk": "1.24.0"
+    "@parall/agent-core": "1.26.0",
+    "@parall/cli": "1.26.0",
+    "@parall/sdk": "1.26.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/config.ts

@@ -88,6 +88,12 @@ export function sessionStateFilePathForRuntime(stateDir: string, runtimeKey: str
   return path.join(stateDir, "sessions", `${fileName}.json`);
 }
 
+export function contextFilePathForSession(stateDir: string, sessionKey: string): string {
+  const fileName = Buffer.from(sessionKey).toString("base64url");
+  return path.join(stateDir, "dispatch-context", `${fileName}.json`);
+}
+
+/** @deprecated Use contextFilePathForSession. */
 export function stepIdFilePathForSession(stateDir: string, sessionKey: string): string {
   const fileName = Buffer.from(sessionKey).toString("base64url");
   return path.join(stateDir, "step-ids", `${fileName}.txt`);

package/src/dispatch.ts

@@ -1,3 +1,4 @@
+import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import {
@@ -9,11 +10,15 @@ import type {
   DispatchAdapter,
   DispatchOpts,
   ForkOpts,
+  GatewayLogger,
   RuntimeEvent,
 } from "@parall/agent-core";
 import type { ClaudeAgentConfig } from "./config.js";
-import { parseClaudeStreamJson } from "./output-parser.js";
-import { ClaudeSessionManager } from "./session-manager.js";
+import { parseClaudeStreamJson, type ClaudeParsedEvent } from "./output-parser.js";
+import {
+  ClaudeSessionManager,
+  type ClaudeProcessHandle,
+} from "./session-manager.js";
 
 type ClaudeCodeAdapterOptions = Pick<
   ClaudeAgentConfig,
@@ -29,25 +34,26 @@ type ClaudeCodeAdapterOptions = Pick<
   | "workspaceDir"
 > & {
   sessionManager: ClaudeSessionManager;
+  apiUrl: string;
+  apiKey: string;
+  orgId: string;
+  contextFilePathForSession?: (sessionKey: string) => string;
+  /** @deprecated Use contextFilePathForSession. */
+  stepIdFilePathForSession?: (sessionKey: string) => string;
 };
 
 export function buildSpawnEnv(
   parentEnv: NodeJS.ProcessEnv,
   claudeHome: string,
   context: DispatchOpts["context"],
-  opts: { allowApiKey: boolean },
+  opts: { allowApiKey: boolean; effortLevel?: string },
 ): NodeJS.ProcessEnv {
   const env: NodeJS.ProcessEnv = { ...parentEnv };
-  // Default: behave like the hosted Claude container — OAuth via
-  // ~/.claude/.credentials.json only. Inheriting the operator's
-  // ANTHROPIC_API_KEY would silently divert billing to Anthropic API
-  // pay-per-use instead of the connected Claude.ai subscription.
-  // Opt back in with PRLL_CLAUDE_ALLOW_API_KEY=1.
   if (!opts.allowApiKey) {
     delete env.ANTHROPIC_API_KEY;
     delete env.ANTHROPIC_AUTH_TOKEN;
   }
-  return {
+  const result: NodeJS.ProcessEnv = {
     ...env,
     HOME: claudeHome,
     PRLL_API_URL: context.apiUrl,
@@ -57,12 +63,53 @@ export function buildSpawnEnv(
     PRLL_CHAT_ID: context.chatId ?? "",
     PRLL_TRIGGER_MESSAGE_ID: context.triggerMessageId ?? "",
     PRLL_NO_REPLY: context.noReply ? "1" : "",
+    PRLL_CONTEXT_FILE: context.contextFilePath ?? "",
     PRLL_STEP_ID_FILE: context.stepIdFilePath ?? "",
   };
+  if (opts.effortLevel) {
+    result.CLAUDE_CODE_EFFORT_LEVEL = opts.effortLevel;
+  }
+  return result;
 }
 
+/**
+ * Per-sessionKey long-lived process state. The process stays alive across
+ * dispatches; each dispatch writes one NDJSON user message to stdin and
+ * drains stdout until `turn_end`. Between dispatches the process is idle —
+ * gateway's `drainMainBuffer` serializes dispatch calls so no concurrent
+ * access to the same process occurs.
+ */
+type ProcessState = {
+  handle: ClaudeProcessHandle;
+  parser: AsyncGenerator<ClaudeParsedEvent>;
+  done: boolean;
+  needsRestart: boolean;
+};
+
 export class ClaudeCodeAdapter implements DispatchAdapter {
-  constructor(private readonly opts: ClaudeCodeAdapterOptions) {}
+  private readonly processes = new Map<string, ProcessState>();
+  private shuttingDown = false;
+  private _model: string | undefined;
+  private _effortLevel: string | undefined;
+
+  constructor(private readonly opts: ClaudeCodeAdapterOptions) {
+    this._model = opts.model;
+  }
+
+  get currentModel(): string | undefined { return this._model; }
+  get currentEffort(): string | undefined { return this._effortLevel; }
+
+  updateConfig(config: { model?: string | null; effort?: string | null }): void {
+    const modelChanged = config.model !== undefined && config.model !== this._model;
+    const effortChanged = config.effort !== undefined && config.effort !== this._effortLevel;
+    if (modelChanged) this._model = config.model ?? undefined;
+    if (effortChanged) this._effortLevel = config.effort ?? undefined;
+    if (modelChanged || effortChanged) {
+      for (const [, state] of this.processes) {
+        state.needsRestart = true;
+      }
+    }
+  }
 
   async *dispatch({ event, bodyForAgent, sessionKey, context }: DispatchOpts): AsyncIterable<RuntimeEvent> {
     let promptBody = bodyForAgent;
@@ -81,107 +128,211 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     }
 
     try {
-      const args = this.buildArgs(sessionKey, promptBody);
-      const env = buildSpawnEnv(process.env, this.opts.claudeHome, context, {
-        allowApiKey: this.opts.allowApiKey,
-      });
-
-      context.log?.info(`claude-agent[${context.accountId}]: spawn ${this.opts.claudeBin} ${args.slice(0, -1).join(" ")}`);
+      yield* this.runTurn(sessionKey, promptBody, context.log);
+    } finally {
+      releasePreparedAttachments();
+    }
+  }
 
-      const proc = spawn(this.opts.claudeBin, args, {
-        cwd: this.opts.workspaceDir,
-        env,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
+  forkSession({ sessionKey }: ForkOpts) {
+    return this.opts.sessionManager.createForkSession(sessionKey);
+  }
 
-      if (!proc.stdout || !proc.stderr) {
-        throw new Error("Claude subprocess did not provide stdio pipes");
-      }
+  cleanupFork({ fork }: CleanupForkOpts) {
+    const state = this.processes.get(fork.sessionKey);
+    if (state) {
+      this.killProcess(fork.sessionKey, state);
+    }
+    this.opts.sessionManager.cleanupFork(fork.sessionKey);
+  }
 
-      const stderr: string[] = [];
-      proc.stderr.on("data", (chunk) => {
-        stderr.push(chunk.toString());
-      });
+  async shutdown(): Promise<void> {
+    this.shuttingDown = true;
+    for (const [sessionKey, state] of this.processes) {
+      this.killProcess(sessionKey, state);
+    }
+    this.processes.clear();
+    await this.opts.sessionManager.shutdownAll();
+  }
 
-      const exitPromise = new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
-        proc.once("error", reject);
-        proc.once("close", (code, signal) => resolve({ code, signal }));
-      });
+  private async *runTurn(
+    sessionKey: string,
+    promptBody: string,
+    log: GatewayLogger | undefined,
+  ): AsyncGenerator<RuntimeEvent> {
+    let state: ProcessState;
+    try {
+      state = this.ensureProcess(sessionKey, log);
+    } catch (err) {
+      yield { type: "error", message: `Claude spawn failed: ${String(err)}` };
+      return;
+    }
+    const groupKey = randomUUID();
+    let sawError = false;
 
-      const groupKey = randomUUID();
-      let sawError = false;
-      let completed = false;
+    try {
+      this.writeUserMessage(state.handle, promptBody);
+    } catch (err) {
+      yield { type: "error", message: `Claude stdin write failed: ${String(err)}` };
+      this.killProcess(sessionKey, state);
+      return;
+    }
 
-      try {
-        for await (const streamEvent of parseClaudeStreamJson(proc.stdout)) {
-          if (streamEvent.type === "session_id") {
-            this.opts.sessionManager.recordSessionId(sessionKey, streamEvent.sessionId);
-            continue;
-          }
-
-          if (streamEvent.type === "error") {
-            sawError = true;
-            yield streamEvent;
-            continue;
-          }
-
-          if (streamEvent.type === "text") {
-            // Runtime output contract (symmetric with OpenClaw channel): Claude's
-            // plain text is never projected as a chat message. To reply, the agent
-            // must explicitly run `parall messages send` / `dm` via Bash. Text
-            // events are still recorded as suppressed session steps for audit.
-            yield {
-              ...streamEvent,
-              project: false,
-              groupKey,
-            };
-            continue;
-          }
+    while (true) {
+      const next = await state.parser.next();
 
-          yield {
-            ...streamEvent,
-            groupKey,
-          };
-        }
-        completed = true;
-      } finally {
-        if (!completed && proc.exitCode === null && proc.signalCode === null) {
-          proc.kill("SIGTERM");
-        }
-        const { code, signal } = await exitPromise;
-        if ((code ?? 0) !== 0 && !sawError) {
-          const detail = stderr.join("").trim();
+      if (next.done) {
+        state.done = true;
+        this.processes.delete(sessionKey);
+        if (!sawError) {
+          const detail = state.handle.stderrChunks.join("").trim();
+          const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null } as const));
           yield {
             type: "error",
-            message: detail || `Claude exited with code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`,
+            message: detail
+              || `Claude exited with code ${exit.code ?? "unknown"}${exit.signal ? ` (${exit.signal})` : ""}`,
           };
         }
+        return;
       }
-    } finally {
-      releasePreparedAttachments();
+
+      const parsed = next.value;
+
+      if (parsed.type === "session_id") {
+        this.opts.sessionManager.recordSessionId(sessionKey, parsed.sessionId);
+        continue;
+      }
+
+      if (parsed.type === "turn_end") {
+        if (state.needsRestart) {
+          this.killProcess(sessionKey, state);
+        }
+        return;
+      }
+
+      if (parsed.type === "error") {
+        sawError = true;
+        yield parsed;
+        continue;
+      }
+
+      if (parsed.type === "text") {
+        yield { ...parsed, project: false, groupKey };
+        continue;
+      }
+
+      yield { ...parsed, groupKey };
     }
   }
 
-  forkSession({ sessionKey }: ForkOpts) {
-    return this.opts.sessionManager.createForkSession(sessionKey);
+  private ensureProcess(sessionKey: string, log: GatewayLogger | undefined): ProcessState {
+    if (this.shuttingDown) {
+      throw new Error("claude-agent: adapter shutting down, refusing new process");
+    }
+
+    const existing = this.processes.get(sessionKey);
+    if (existing && !existing.done) {
+      const { proc } = existing.handle;
+      if (existing.needsRestart) {
+        this.killProcess(sessionKey, existing);
+      } else if (proc.exitCode === null && proc.signalCode === null && !proc.stdin.destroyed) {
+        return existing;
+      } else {
+        this.processes.delete(sessionKey);
+      }
+    }
+
+    const handle = this.spawnProcess(sessionKey, log);
+    const parser = parseClaudeStreamJson(handle.proc.stdout!);
+    const state: ProcessState = { handle, parser, done: false, needsRestart: false };
+    this.processes.set(sessionKey, state);
+    this.opts.sessionManager.registerProcess(sessionKey, handle);
+    return state;
   }
 
-  cleanupFork({ fork }: CleanupForkOpts) {
-    this.opts.sessionManager.cleanupFork(fork.sessionKey);
+  private spawnProcess(sessionKey: string, log: GatewayLogger | undefined): ClaudeProcessHandle {
+    const args = this.buildArgs(sessionKey);
+    const env = buildSpawnEnv(
+      process.env,
+      this.opts.claudeHome,
+      this.buildPlaceholderContext(sessionKey),
+      { allowApiKey: this.opts.allowApiKey, effortLevel: this._effortLevel },
+    );
+
+    log?.info(
+      `claude-agent: spawn long-lived ${this.opts.claudeBin} (session ${sessionKey}, model=${this._model || "default"}, effort=${this._effortLevel || "default"}, mode=${this.opts.permissionMode})`,
+    );
+
+    const proc = spawn(this.opts.claudeBin, args, {
+      cwd: this.opts.workspaceDir,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    if (!proc.stdout || !proc.stderr || !proc.stdin) {
+      throw new Error("Claude subprocess did not provide stdio pipes");
+    }
+
+    const stderrChunks: string[] = [];
+    proc.stderr.on("data", (chunk: Buffer) => {
+      stderrChunks.push(chunk.toString());
+    });
+    proc.stdin.on("error", () => {
+      // Absorb async EPIPE / ERR_STREAM_WRITE_AFTER_END when the child
+      // exits between our write check and the kernel delivering the data.
+      // The next parser.next() will see the stream end and surface an error
+      // RuntimeEvent through the normal turn-end path.
+    });
+
+    const exitPromise = new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve) => {
+      proc.once("close", (code, signal) => resolve({ code, signal }));
+      proc.once("error", () => resolve({ code: null, signal: null }));
+    });
+
+    return { proc, exitPromise, stderrChunks };
+  }
+
+  private killProcess(sessionKey: string, state: ProcessState) {
+    state.done = true;
+    const current = this.processes.get(sessionKey);
+    if (current === state) {
+      this.processes.delete(sessionKey);
+    }
+    try {
+      state.handle.proc.stdin.end();
+    } catch { /* best-effort */ }
+    if (state.handle.proc.exitCode === null && state.handle.proc.signalCode === null) {
+      try {
+        state.handle.proc.kill("SIGTERM");
+      } catch { /* best-effort */ }
+    }
+  }
+
+  private writeUserMessage(handle: ClaudeProcessHandle, text: string) {
+    const payload = JSON.stringify({
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "text", text }],
+      },
+    });
+    handle.proc.stdin.write(`${payload}\n`);
   }
 
-  private buildArgs(sessionKey: string, prompt: string): string[] {
+  private buildArgs(sessionKey: string): string[] {
     const args = [
-      "--print",
+      "-p",
       "--verbose",
+      "--input-format",
+      "stream-json",
       "--output-format",
       "stream-json",
       "--permission-mode",
       this.opts.permissionMode,
     ];
 
-    if (this.opts.model) {
-      args.push("--model", this.opts.model);
+    if (this._model) {
+      args.push("--model", this._model);
     }
 
     if (this.opts.allowedTools.length > 0) {
@@ -192,6 +343,11 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
       args.push("--disallowedTools", this.opts.disallowedTools.join(","));
     }
 
+    args.push(
+      "--append-system-prompt-file",
+      path.join(this.opts.workspaceDir, ".parall", "system-prompt.md"),
+    );
+
     if (this.opts.appendSystemPrompt) {
       args.push("--append-system-prompt", this.opts.appendSystemPrompt);
     }
@@ -201,7 +357,25 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     }
 
     args.push(...this.opts.sessionManager.getResumeArgs(sessionKey));
-    args.push(prompt);
     return args;
   }
+
+  private buildPlaceholderContext(sessionKey: string): DispatchOpts["context"] {
+    return {
+      accountId: "",
+      apiUrl: this.opts.apiUrl,
+      apiKey: this.opts.apiKey,
+      orgId: this.opts.orgId,
+      agentUserId: "",
+      runtimeType: "",
+      runtimeKey: "",
+      sessionId: "",
+      chatId: "",
+      triggerMessageId: "",
+      noReply: false,
+      contextFilePath: this.opts.contextFilePathForSession?.(sessionKey) ?? "",
+      stepIdFilePath: this.opts.stepIdFilePathForSession?.(sessionKey) ?? "",
+      client: undefined as unknown as DispatchOpts["context"]["client"],
+    };
+  }
 }