@parall/claude-agent 1.28.0 → 1.29.0

package/dist/dispatch.d.ts

@@ -17,6 +17,7 @@ export declare function buildSpawnEnv(parentEnv: NodeJS.ProcessEnv, claudeHome:
 export declare class ClaudeCodeAdapter implements DispatchAdapter {
     private readonly opts;
     private readonly processes;
+    private readonly pendingInjections;
     private shuttingDown;
     private _model;
     private _effortLevel;
@@ -27,12 +28,26 @@ export declare class ClaudeCodeAdapter implements DispatchAdapter {
         model?: string | null;
         effort?: string | null;
     }): void;
+    enqueueDuringDispatch(sessionKey: string, body: string): boolean;
+    hasPendingInjections(sessionKey: string): boolean;
     dispatch({ event, bodyForAgent, sessionKey, context }: DispatchOpts): AsyncIterable<RuntimeEvent>;
     getBranchPoint(_sessionKey: string): string | undefined;
     getSessionHistoryPath(sessionKey: string): string | undefined;
     forkSession({ sessionKey }: ForkOpts): import("@parall/agent-core").ForkSessionHandle | null;
     cleanupFork({ fork }: CleanupForkOpts): void;
     shutdown(): Promise<void>;
+    private static readonly STEER_TURN_TIMEOUT_MS;
+    /**
+     * Consume a steer turn whose message was already written to stdin via
+     * enqueueDuringDispatch. Skip the stdin write — only read parser output.
+     * If no output arrives within STEER_TURN_TIMEOUT_MS, the steer was
+     * incorporated into the previous turn and there is nothing to consume.
+     *
+     * On timeout, the losing parser.next() promise is saved to
+     * state.steerReadPending so the next runTurn can drain it instead of
+     * silently losing the first event of the subsequent turn.
+     */
+    private consumeSteerTurn;
     private runTurn;
     private ensureProcess;
     private spawnProcess;

package/dist/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,QAAQ,EAER,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EACL,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAE9B,KAAK,wBAAwB,GAAG,IAAI,CAClC,iBAAiB,EACf,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,oBAAoB,GACpB,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,OAAO,GACP,gBAAgB,GAChB,cAAc,CACjB,GAAG;IACF,cAAc,EAAE,oBAAoB,CAAC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,yBAAyB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3D,iDAAiD;IACjD,wBAAwB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3D,CAAC;AAEF,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,CAAC,UAAU,EAC5B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,EAChC,IAAI,EAAE;IAAE,WAAW,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACnD,MAAM,CAAC,UAAU,CAuBnB;AAgBD,qBAAa,iBAAkB,YAAW,eAAe;IAM3C,OAAO,CAAC,QAAQ,CAAC,IAAI;IALjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAC7D,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,YAAY,CAAqB;gBAEZ,IAAI,EAAE,wBAAwB;IAI3D,IAAI,YAAY,IAAI,MAAM,GAAG,SAAS,CAAwB;IAC9D,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAA8B;IAErE,YAAY,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI;IAYtE,QAAQ,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC;IAuBxG,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvD,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAQ7D,WAAW,CAAC,EAAE,UAAU,EAAE,EAAE,QAAQ;IAIpC,WAAW,CAAC,EAAE,IAAI,EAAE,EAAE,eAAe;IAQ/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAShB,OAAO;IAgFtB,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,YAAY;IA8CpB,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,SAAS;IAyCjB,OAAO,CAAC,uBAAuB;CAkBhC"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,QAAQ,EAER,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EACL,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAE9B,KAAK,wBAAwB,GAAG,IAAI,CAClC,iBAAiB,EACf,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,oBAAoB,GACpB,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,OAAO,GACP,gBAAgB,GAChB,cAAc,CACjB,GAAG;IACF,cAAc,EAAE,oBAAoB,CAAC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,yBAAyB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3D,iDAAiD;IACjD,wBAAwB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3D,CAAC;AAgBF,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,CAAC,UAAU,EAC5B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,EAChC,IAAI,EAAE;IAAE,WAAW,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACnD,MAAM,CAAC,UAAU,CAuBnB;AAiBD,qBAAa,iBAAkB,YAAW,eAAe;IAO3C,OAAO,CAAC,QAAQ,CAAC,IAAI;IANjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAC7D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAC/D,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,YAAY,CAAqB;gBAEZ,IAAI,EAAE,wBAAwB;IAI3D,IAAI,YAAY,IAAI,MAAM,GAAG,SAAS,CAAwB;IAC9D,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAA8B;IAErE,YAAY,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI;IAY7E,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAchE,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAI1C,QAAQ,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC;IAiCxG,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvD,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAQ7D,WAAW,CAAC,EAAE,UAAU,EAAE,EAAE,QAAQ;IAIpC,WAAW,CAAC,EAAE,IAAI,EAAE,EAAE,eAAe;IAQ/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAS/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAU;IAEvD;;;;;;;;;OASG;YACY,gBAAgB;YAsDhB,OAAO;IA2GtB,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,YAAY;IA+CpB,OAAO,CAAC,WAAW;IAkBnB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,SAAS;IAwCjB,OAAO,CAAC,uBAAuB;CAkBhC"}

package/dist/dispatch.js

@@ -1,9 +1,24 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import { appendPreparedLocalAttachmentRefs, pinLocalAttachmentPaths, } from "@parall/agent-core/internal/attachment-input";
 import { parseClaudeStreamJson } from "./output-parser.js";
+const IS_WIN32 = process.platform === "win32";
+function quoteWin32Arg(arg) {
+    if (!/[\s"&|^<>()]/.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '""')}"`;
+}
+function killWin32Tree(pid) {
+    try {
+        execSync(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function buildSpawnEnv(parentEnv, claudeHome, context, opts) {
     const env = { ...parentEnv };
     if (!opts.allowApiKey) {
@@ -31,6 +46,7 @@ export function buildSpawnEnv(parentEnv, claudeHome, context, opts) {
 export class ClaudeCodeAdapter {
     opts;
     processes = new Map();
+    pendingInjections = new Map();
     shuttingDown = false;
     _model;
     _effortLevel;
@@ -53,7 +69,35 @@ export class ClaudeCodeAdapter {
             }
         }
     }
+    enqueueDuringDispatch(sessionKey, body) {
+        const state = this.processes.get(sessionKey);
+        if (!state || state.done)
+            return false;
+        const { proc } = state.handle;
+        if (proc.exitCode !== null || proc.signalCode !== null || proc.stdin.destroyed)
+            return false;
+        try {
+            this.writeUserMessage(state.handle, body);
+            this.pendingInjections.set(sessionKey, (this.pendingInjections.get(sessionKey) ?? 0) + 1);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    hasPendingInjections(sessionKey) {
+        return (this.pendingInjections.get(sessionKey) ?? 0) > 0;
+    }
     async *dispatch({ event, bodyForAgent, sessionKey, context }) {
+        const pending = this.pendingInjections.get(sessionKey) ?? 0;
+        if (pending > 0) {
+            this.pendingInjections.delete(sessionKey);
+            context.log?.info?.(`claude-agent[${context.accountId}]: consuming ${pending} steer turn(s)`);
+            for (let i = 0; i < pending; i++) {
+                yield* this.consumeSteerTurn(sessionKey, context.log);
+            }
+            return;
+        }
         let promptBody = bodyForAgent;
         let releasePreparedAttachments = () => { };
         try {
@@ -103,6 +147,66 @@ export class ClaudeCodeAdapter {
         this.processes.clear();
         await this.opts.sessionManager.shutdownAll();
     }
+    static STEER_TURN_TIMEOUT_MS = 10_000;
+    /**
+     * Consume a steer turn whose message was already written to stdin via
+     * enqueueDuringDispatch. Skip the stdin write — only read parser output.
+     * If no output arrives within STEER_TURN_TIMEOUT_MS, the steer was
+     * incorporated into the previous turn and there is nothing to consume.
+     *
+     * On timeout, the losing parser.next() promise is saved to
+     * state.steerReadPending so the next runTurn can drain it instead of
+     * silently losing the first event of the subsequent turn.
+     */
+    async *consumeSteerTurn(sessionKey, log) {
+        const state = this.processes.get(sessionKey);
+        if (!state || state.done) {
+            throw new Error("claude-agent: process dead during steer consumption");
+        }
+        const groupKey = randomUUID();
+        const parserNext = state.parser.next();
+        const firstRead = await Promise.race([
+            parserNext.then((r) => ({ kind: "value", result: r })),
+            new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), ClaudeCodeAdapter.STEER_TURN_TIMEOUT_MS)),
+        ]);
+        if (firstRead.kind === "timeout") {
+            state.steerReadPending = parserNext;
+            log?.info?.(`claude-agent: steer turn timeout — steer was incorporated into previous turn`);
+            return;
+        }
+        let next = firstRead.result;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (next.done) {
+                state.done = true;
+                this.processes.delete(sessionKey);
+                throw new Error("claude-agent: process exited while consuming steer turn");
+            }
+            const parsed = next.value;
+            if (parsed.type === "session_id") {
+                this.opts.sessionManager.recordSessionId(sessionKey, parsed.sessionId);
+                yield { type: "runtime_session", runtimeSessionId: parsed.sessionId, runtimeLaneKey: sessionKey };
+            }
+            else if (parsed.type === "turn_end") {
+                if (state.needsRestart)
+                    this.killProcess(sessionKey, state);
+                return;
+            }
+            else if (parsed.type === "error") {
+                yield parsed;
+            }
+            else if (parsed.type === "text") {
+                yield { ...parsed, project: false, groupKey };
+            }
+            else if (parsed.type === "runtime_session") {
+                yield parsed;
+            }
+            else {
+                yield { ...parsed, groupKey };
+            }
+            next = await state.parser.next();
+        }
+    }
     async *runTurn(sessionKey, promptBody, log) {
         let state;
         try {
@@ -122,14 +226,46 @@ export class ClaudeCodeAdapter {
             this.killProcess(sessionKey, state);
             return;
         }
+        if (state.steerReadPending) {
+            const orphaned = await state.steerReadPending;
+            state.steerReadPending = undefined;
+            if (!orphaned.done) {
+                const parsed = orphaned.value;
+                if (parsed.type === "session_id") {
+                    this.opts.sessionManager.recordSessionId(sessionKey, parsed.sessionId);
+                    yield { type: "runtime_session", runtimeSessionId: parsed.sessionId, runtimeLaneKey: sessionKey };
+                }
+                else if (parsed.type === "turn_end") {
+                    if (state.needsRestart)
+                        this.killProcess(sessionKey, state);
+                    return;
+                }
+                else if (parsed.type === "error") {
+                    sawError = true;
+                    yield parsed;
+                }
+                else if (parsed.type === "text") {
+                    yield { ...parsed, project: false, groupKey };
+                }
+                else if (parsed.type === "runtime_session") {
+                    yield parsed;
+                }
+                else {
+                    yield { ...parsed, groupKey };
+                }
+            }
+        }
         while (true) {
             const next = await state.parser.next();
             if (next.done) {
                 state.done = true;
                 this.processes.delete(sessionKey);
+                const detail = state.handle.stderrChunks.join("").trim();
+                const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null }));
+                if (detail) {
+                    log?.warn?.(`claude-agent: subprocess stderr: ${detail}`);
+                }
                 if (!sawError) {
-                    const detail = state.handle.stderrChunks.join("").trim();
-                    const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null }));
                     yield {
                         type: "error",
                         message: detail
@@ -198,10 +334,11 @@ export class ClaudeCodeAdapter {
         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, {
+        const proc = spawn(IS_WIN32 ? quoteWin32Arg(this.opts.claudeBin) : this.opts.claudeBin, IS_WIN32 ? args.map(quoteWin32Arg) : args, {
             cwd: this.opts.workspaceDir,
             env,
             stdio: ["pipe", "pipe", "pipe"],
+            shell: IS_WIN32,
         });
         if (!proc.stdout || !proc.stderr || !proc.stdin) {
             throw new Error("Claude subprocess did not provide stdio pipes");
@@ -211,13 +348,11 @@ export class ClaudeCodeAdapter {
             stderrChunks.push(chunk.toString());
         });
         proc.stdin.on("error", () => {
-            // stdin pipe broken: kill the process so parser.next() sees EOF
-            // instead of hanging forever on a process that's alive but can't
-            // accept input. If the process was already exiting (the common
-            // EPIPE-on-close race), kill is a harmless no-op.
             proc.stdin.destroy();
             if (proc.exitCode === null && proc.signalCode === null) {
-                proc.kill("SIGTERM");
+                if (!IS_WIN32 || !proc.pid || !killWin32Tree(proc.pid)) {
+                    proc.kill("SIGTERM");
+                }
             }
         });
         const exitPromise = new Promise((resolve) => {
@@ -238,7 +373,9 @@ export class ClaudeCodeAdapter {
         catch { /* best-effort */ }
         if (state.handle.proc.exitCode === null && state.handle.proc.signalCode === null) {
             try {
-                state.handle.proc.kill("SIGTERM");
+                if (!IS_WIN32 || !state.handle.proc.pid || !killWin32Tree(state.handle.proc.pid)) {
+                    state.handle.proc.kill("SIGTERM");
+                }
             }
             catch { /* best-effort */ }
         }
@@ -255,7 +392,6 @@ export class ClaudeCodeAdapter {
     }
     buildArgs(sessionKey) {
         const args = [
-            "-p",
             "--verbose",
             "--input-format",
             "stream-json",

package/dist/index.js

@@ -1,18 +1,12 @@
 #!/usr/bin/env node
 import * as os from "node:os";
-import { ParallAgentGateway, createPlatformConfigManager, isPlatformManagedProfile, parseShutdownDeadlineMs } from "@parall/agent-core";
+import { ParallAgentGateway, createPlatformConfigManager, createLogger, isPlatformManagedProfile, parseShutdownDeadlineMs } from "@parall/agent-core";
 import { ApiError, ParallClient, ParallWs } from "@parall/sdk";
 import { buildClaudeRuntimeKey, contextFilePathForSession, resolveClaudeAgentConfig, resolveWsUrl, sessionStateFilePathForRuntime, stepIdFilePathForSession, } from "./config.js";
 import { ClaudeCodeAdapter } from "./dispatch.js";
 import { ClaudeSessionManager } from "./session-manager.js";
 import { ensureClaudeWorkspace } from "./workspace.js";
-function createLogger(prefix) {
-    return {
-        info: (msg) => console.log(`[${prefix}] ${msg}`),
-        warn: (msg) => console.warn(`[${prefix}] ${msg}`),
-        error: (msg) => console.error(`[${prefix}] ${msg}`),
-    };
-}
+const log = createLogger("claude-agent");
 async function getAgentMeWithLegacyFallback(client, orgId) {
     try {
         return await client.getAgentMe(orgId);
@@ -27,7 +21,6 @@ async function getAgentMeWithLegacyFallback(client, orgId) {
 }
 async function main() {
     const config = resolveClaudeAgentConfig(process.env);
-    const log = createLogger("claude-agent");
     if (config.allowApiKey &&
         (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN)) {
         // Surface the billing path: default is OAuth (Claude.ai subscription); this
@@ -154,6 +147,6 @@ async function main() {
     }
 }
 main().catch((err) => {
-    console.error(`[claude-agent] fatal: ${String(err)}`);
+    log.error(`fatal: ${String(err)}`);
     process.exitCode = 1;
 });

package/package.json

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

package/src/dispatch.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import {
   appendPreparedLocalAttachmentRefs,
   pinLocalAttachmentPaths,
@@ -43,6 +43,20 @@ type ClaudeCodeAdapterOptions = Pick<
   stepIdFilePathForSession?: (sessionKey: string) => string;
 };
 
+const IS_WIN32 = process.platform === "win32";
+
+function quoteWin32Arg(arg: string): string {
+  if (!/[\s"&|^<>()]/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+
+function killWin32Tree(pid: number): boolean {
+  try {
+    execSync(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: "ignore" });
+    return true;
+  } catch { return false; }
+}
+
 export function buildSpawnEnv(
   parentEnv: NodeJS.ProcessEnv,
   claudeHome: string,
@@ -85,10 +99,12 @@ type ProcessState = {
   parser: AsyncGenerator<ClaudeParsedEvent>;
   done: boolean;
   needsRestart: boolean;
+  steerReadPending?: Promise<IteratorResult<ClaudeParsedEvent>>;
 };
 
 export class ClaudeCodeAdapter implements DispatchAdapter {
   private readonly processes = new Map<string, ProcessState>();
+  private readonly pendingInjections = new Map<string, number>();
   private shuttingDown = false;
   private _model: string | undefined;
   private _effortLevel: string | undefined;
@@ -112,7 +128,35 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     }
   }
 
+  enqueueDuringDispatch(sessionKey: string, body: string): boolean {
+    const state = this.processes.get(sessionKey);
+    if (!state || state.done) return false;
+    const { proc } = state.handle;
+    if (proc.exitCode !== null || proc.signalCode !== null || proc.stdin.destroyed) return false;
+    try {
+      this.writeUserMessage(state.handle, body);
+      this.pendingInjections.set(sessionKey, (this.pendingInjections.get(sessionKey) ?? 0) + 1);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  hasPendingInjections(sessionKey: string): boolean {
+    return (this.pendingInjections.get(sessionKey) ?? 0) > 0;
+  }
+
   async *dispatch({ event, bodyForAgent, sessionKey, context }: DispatchOpts): AsyncIterable<RuntimeEvent> {
+    const pending = this.pendingInjections.get(sessionKey) ?? 0;
+    if (pending > 0) {
+      this.pendingInjections.delete(sessionKey);
+      context.log?.info?.(`claude-agent[${context.accountId}]: consuming ${pending} steer turn(s)`);
+      for (let i = 0; i < pending; i++) {
+        yield* this.consumeSteerTurn(sessionKey, context.log);
+      }
+      return;
+    }
+
     let promptBody = bodyForAgent;
     let releasePreparedAttachments = () => {};
     try {
@@ -168,6 +212,72 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     await this.opts.sessionManager.shutdownAll();
   }
 
+  private static readonly STEER_TURN_TIMEOUT_MS = 10_000;
+
+  /**
+   * Consume a steer turn whose message was already written to stdin via
+   * enqueueDuringDispatch. Skip the stdin write — only read parser output.
+   * If no output arrives within STEER_TURN_TIMEOUT_MS, the steer was
+   * incorporated into the previous turn and there is nothing to consume.
+   *
+   * On timeout, the losing parser.next() promise is saved to
+   * state.steerReadPending so the next runTurn can drain it instead of
+   * silently losing the first event of the subsequent turn.
+   */
+  private async *consumeSteerTurn(
+    sessionKey: string,
+    log: GatewayLogger | undefined,
+  ): AsyncGenerator<RuntimeEvent> {
+    const state = this.processes.get(sessionKey);
+    if (!state || state.done) {
+      throw new Error("claude-agent: process dead during steer consumption");
+    }
+
+    const groupKey = randomUUID();
+
+    const parserNext = state.parser.next();
+    const firstRead = await Promise.race([
+      parserNext.then((r) => ({ kind: "value" as const, result: r })),
+      new Promise<{ kind: "timeout" }>((resolve) =>
+        setTimeout(() => resolve({ kind: "timeout" }), ClaudeCodeAdapter.STEER_TURN_TIMEOUT_MS),
+      ),
+    ]);
+
+    if (firstRead.kind === "timeout") {
+      state.steerReadPending = parserNext;
+      log?.info?.(`claude-agent: steer turn timeout — steer was incorporated into previous turn`);
+      return;
+    }
+
+    let next = firstRead.result;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (next.done) {
+        state.done = true;
+        this.processes.delete(sessionKey);
+        throw new Error("claude-agent: process exited while consuming steer turn");
+      }
+      const parsed = next.value;
+
+      if (parsed.type === "session_id") {
+        this.opts.sessionManager.recordSessionId(sessionKey, parsed.sessionId);
+        yield { type: "runtime_session", runtimeSessionId: parsed.sessionId, runtimeLaneKey: sessionKey };
+      } else if (parsed.type === "turn_end") {
+        if (state.needsRestart) this.killProcess(sessionKey, state);
+        return;
+      } else if (parsed.type === "error") {
+        yield parsed;
+      } else if (parsed.type === "text") {
+        yield { ...parsed, project: false, groupKey };
+      } else if (parsed.type === "runtime_session") {
+        yield parsed;
+      } else {
+        yield { ...parsed, groupKey };
+      }
+      next = await state.parser.next();
+    }
+  }
+
   private async *runTurn(
     sessionKey: string,
     promptBody: string,
@@ -191,15 +301,42 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
       return;
     }
 
+    if (state.steerReadPending) {
+      const orphaned = await state.steerReadPending;
+      state.steerReadPending = undefined;
+      if (!orphaned.done) {
+        const parsed = orphaned.value;
+        if (parsed.type === "session_id") {
+          this.opts.sessionManager.recordSessionId(sessionKey, parsed.sessionId);
+          yield { type: "runtime_session", runtimeSessionId: parsed.sessionId, runtimeLaneKey: sessionKey };
+        } else if (parsed.type === "turn_end") {
+          if (state.needsRestart) this.killProcess(sessionKey, state);
+          return;
+        } else if (parsed.type === "error") {
+          sawError = true;
+          yield parsed;
+        } else if (parsed.type === "text") {
+          yield { ...parsed, project: false, groupKey };
+        } else if (parsed.type === "runtime_session") {
+          yield parsed;
+        } else {
+          yield { ...parsed, groupKey };
+        }
+      }
+    }
+
     while (true) {
       const next = await state.parser.next();
 
       if (next.done) {
         state.done = true;
         this.processes.delete(sessionKey);
+        const detail = state.handle.stderrChunks.join("").trim();
+        const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null } as const));
+        if (detail) {
+          log?.warn?.(`claude-agent: subprocess stderr: ${detail}`);
+        }
         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
@@ -286,10 +423,13 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
       `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, {
+    const proc = spawn(
+      IS_WIN32 ? quoteWin32Arg(this.opts.claudeBin) : this.opts.claudeBin,
+      IS_WIN32 ? args.map(quoteWin32Arg) : args, {
       cwd: this.opts.workspaceDir,
       env,
       stdio: ["pipe", "pipe", "pipe"],
+      shell: IS_WIN32,
     });
 
     if (!proc.stdout || !proc.stderr || !proc.stdin) {
@@ -301,13 +441,11 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
       stderrChunks.push(chunk.toString());
     });
     proc.stdin.on("error", () => {
-      // stdin pipe broken: kill the process so parser.next() sees EOF
-      // instead of hanging forever on a process that's alive but can't
-      // accept input. If the process was already exiting (the common
-      // EPIPE-on-close race), kill is a harmless no-op.
       proc.stdin.destroy();
       if (proc.exitCode === null && proc.signalCode === null) {
-        proc.kill("SIGTERM");
+        if (!IS_WIN32 || !proc.pid || !killWin32Tree(proc.pid)) {
+          proc.kill("SIGTERM");
+        }
       }
     });
 
@@ -330,7 +468,9 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     } catch { /* best-effort */ }
     if (state.handle.proc.exitCode === null && state.handle.proc.signalCode === null) {
       try {
-        state.handle.proc.kill("SIGTERM");
+        if (!IS_WIN32 || !state.handle.proc.pid || !killWin32Tree(state.handle.proc.pid)) {
+          state.handle.proc.kill("SIGTERM");
+        }
       } catch { /* best-effort */ }
     }
   }
@@ -348,7 +488,6 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
 
   private buildArgs(sessionKey: string): string[] {
     const args = [
-      "-p",
       "--verbose",
       "--input-format",
       "stream-json",

package/src/index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import * as os from "node:os";
-import { ParallAgentGateway, createPlatformConfigManager, isPlatformManagedProfile, parseShutdownDeadlineMs } from "@parall/agent-core";
+import { ParallAgentGateway, createPlatformConfigManager, createLogger, isPlatformManagedProfile, parseShutdownDeadlineMs } from "@parall/agent-core";
 import { ApiError, ParallClient, ParallWs } from "@parall/sdk";
 import {
   buildClaudeRuntimeKey,
@@ -15,13 +15,7 @@ import { ClaudeCodeAdapter } from "./dispatch.js";
 import { ClaudeSessionManager } from "./session-manager.js";
 import { ensureClaudeWorkspace } from "./workspace.js";
 
-function createLogger(prefix: string) {
-  return {
-    info: (msg: string) => console.log(`[${prefix}] ${msg}`),
-    warn: (msg: string) => console.warn(`[${prefix}] ${msg}`),
-    error: (msg: string) => console.error(`[${prefix}] ${msg}`),
-  };
-}
+const log = createLogger("claude-agent");
 
 async function getAgentMeWithLegacyFallback(client: ParallClient, orgId: string) {
   try {
@@ -37,7 +31,6 @@ async function getAgentMeWithLegacyFallback(client: ParallClient, orgId: string)
 
 async function main() {
   const config = resolveClaudeAgentConfig(process.env);
-  const log = createLogger("claude-agent");
 
   if (
     config.allowApiKey &&
@@ -179,6 +172,6 @@ async function main() {
 }
 
 main().catch((err) => {
-  console.error(`[claude-agent] fatal: ${String(err)}`);
+  log.error(`fatal: ${String(err)}`);
   process.exitCode = 1;
 });