@posthog/agent 2.3.727 → 2.3.736

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.727",
+  "version": "2.3.736",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -111,9 +111,9 @@
     "@posthog/enricher": "1.0.0"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.19.0",
-    "@anthropic-ai/claude-agent-sdk": "0.2.112",
-    "@anthropic-ai/sdk": "0.89.0",
+    "@agentclientprotocol/sdk": "0.22.1",
+    "@anthropic-ai/claude-agent-sdk": "0.3.154",
+    "@anthropic-ai/sdk": "0.100.0",
     "@hono/node-server": "^1.19.9",
     "@opentelemetry/api-logs": "^0.208.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.208.0",

package/src/adapters/claude/UPSTREAM.md

@@ -5,8 +5,8 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 ## Fork Point
 
 - **Forked**: v0.10.9, commit `5411e0f4`, Dec 2 2025
-- **Last sync**: v0.30.0, commit `e9dd452`, April 20 2026
-- **SDK**: `@anthropic-ai/claude-agent-sdk` 0.2.112 (0.2.114 breaks session init, see agentclientprotocol/claude-agent-acp#575), `@agentclientprotocol/sdk` 0.19.0
+- **Last sync**: v0.38.0 + #716, commit `61ebda2`, May 28 2026
+- **SDK**: `@anthropic-ai/claude-agent-sdk` 0.3.154, `@agentclientprotocol/sdk` 0.22.1, `@anthropic-ai/sdk` 0.100.0
 
 ## File Mapping
 
@@ -53,6 +53,7 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 | Auth methods | `claude-ai-login` + `console-login` | Returns empty `authMethods` | Auth handled externally |
 | Session fingerprinting | Implicit teardown on cwd/mcp change | Explicit `refreshSession()` | Caller-initiated is more predictable |
 | Shutdown on ACP close | Process exits | No standalone process | Agent is embedded in server |
+| Unsupported slash commands | Loops silently on early idle | Emits "Unsupported slash command" chunk, gated on `initializationResult().commands` so plugin/skill commands (e.g. `/skills-store`) whose echoes use a fresh uuid are not false-flagged | The SDK consumes some slash commands without producing output (e.g. `/plugin` in non-interactive mode); without this we hang. The known-commands gate avoids racing plugin/skill loads where idle can arrive before the transformed user-message echo. |
 
 ## Changes Ported in v0.30.0 Sync
 
@@ -66,6 +67,83 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 - **Effort level sync** (v0.25.x): `xhigh` level added, `applyFlagSettings` on effort change
 - **Auto permission mode** (v0.25.0): Added to `CODE_EXECUTION_MODES`, available modes, ExitPlanMode options
 
+## Changes Ported in v0.38.0 Sync
+
+- **SDK bumps**: claude-agent-sdk 0.3.144 -> 0.3.154, anthropic SDK 0.96.0 -> 0.100.0 (ACP SDK
+  unchanged at 0.22.1).
+- **Compaction state-flag fix** (#716, a172885): SDK 0.3.154 emits the terminal `status` carrying
+  `compact_result` twice for failed compactions. Added a per-turn `compactionInProgress` flag in
+  `prompt()` so the user sees a single `Compacting completed.` / `Compacting failed: <reason>`
+  chunk. Manual `/compact` outcomes now surface here rather than via `compact_boundary` (which only
+  fires when there's content to compact).
+- **System-role guard on user/assistant handler** (#716, a172885): Added an early return in
+  `handleUserAssistantMessage` for `message.message.role === "system"`, covering both upstream's
+  `<local-command-stdout>` strip branch guard and the broader assistant-handler guard. Avoids
+  rendering SDK-injected system reminders as user-visible chunks.
+- **New no-op content block types** (#716, a172885): Added `advisor_tool_result` and
+  `mid_conv_system` cases to `processContentChunk` so unknown content blocks don't trip the
+  `unreachable` default.
+- **Opus 4.8 model entries** (#718, 98b54a0): Added `claude-opus-4-8` to gateway model maps with
+  1M context, effort and xhigh-effort support. MCP injection auto-included (Haiku exclusion only).
+
+## Skipped in v0.38.0 Sync
+
+- **Remove hide Claude auth flag** (#707, 7ed1daf): Our fork already returns `authMethods: []`
+  unconditionally; no flag to remove.
+- **`thinking_tokens` status case** (#716, a172885): Our `handleSystemMessage` switch on
+  `status === "compacting"` is non-exhaustive (no default `unreachable`), so unknown status values
+  already no-op harmlessly.
+- **Empty CI-retry commit** (#718, 98b54a0): No code change in the commit itself; the model entries
+  it carried are ported above.
+- **`MessageDisplay` hook + `SessionStart` reloadSkills/sessionTitle** (SDK 0.3.152): Available in
+  the bumped SDK but not wired into our fork; upstream doesn't consume them in #716 either. Defer
+  to a focused PR if we want the capability.
+
+## Changes Ported in v0.37.0 Sync
+
+- **SDK bumps**: claude-agent-sdk 0.2.114 -> 0.3.144, ACP SDK 0.19.0 -> 0.22.1, anthropic SDK 0.89.0 -> 0.96.0
+- **TodoWrite -> Task tools migration** (SDK 0.3.142): Replaced TodoWrite snapshot tool with incremental
+  TaskCreate/TaskUpdate/TaskGet/TaskList. Added `conversion/task-state.ts` and `createTaskHook` to mirror the
+  SDK `TaskCreated`/`TaskCompleted` hook events into a per-session task map; plan entries are derived from
+  Map insertion order (preserves upstream ordering semantics).
+- **MCP_CONNECTION_NONBLOCKING=0** (SDK 0.3.142): SDK changed MCP servers to background-connect by default;
+  set env to restore blocking-connect behavior so MCP tools are available on first prompt.
+- **ACP SDK 0.22 breaking changes**: Renamed `unstable_resumeSession` -> `resumeSession`; new
+  `McpSdkServerConfig` variant (`type: "sdk"`) in the `McpServerConfig` union. Our
+  `parseMcpServers` only accepts `http`/`sse`/stdio entries, so `sdk` falls through and is
+  implicitly dropped (no explicit filter needed).
+- **Skills option** (SDK 0.2.133): `'Skill'` in `allowedTools` deprecated; replaced with `skills` option.
+- **Memory recall tool calls** (#703, a0bfb98): Emit a `tool_call` for SDK `memory_recall` events so the
+  UI shows what memories were surfaced; addresses phantom MEMORY.md read attempts.
+- **Write diff fix** (#618, 8d7e220): `toolUpdateFromEditToolResponse` now also processes `Write` tool
+  responses so overwrites show real diffs instead of optimistic "creation" diffs.
+- **Local-command-stdout render** (#649, 3b9b7d5): Strip marker tags from `<local-command-stdout>` content
+  and render remaining prose so custom slash commands and skill expansions reach the UI.
+- **Cancelled vs end_turn** (#694, 2414a6f): `session_state_changed: idle` handler now reports
+  `stopReason: "cancelled"` when the session was interrupted.
+- **Recover prompt stream** (#706, 2711f50): After a failed turn, drain the trailing
+  `session_state_changed: idle` so the next prompt's first `query.next()` doesn't short-circuit.
+- **additionalDirectories field** (#684, f37e9a0): Accept the official ACP field on session lifecycle
+  requests; advertise via `sessionCapabilities.additionalDirectories`. Legacy `_meta.additionalRoots` still
+  honored as fallback.
+- **availableModels allowlist** (#637, 867a3a0): `ClaudeCodeSettings.availableModels` array merged-and-deduped
+  across settings sources, then applied to gateway model options via `applyAvailableModelsAllowlist`.
+- **Model alias version match** (#702, e1e1c69): Refuse cross-version alias matches in `resolveModelPreference`
+  so `claude-opus-4-6` doesn't get copied onto the `opus` alias when it resolves to 4.7.
+- **Hide /clear** (#705, cfce130): `/clear` removed from advertised commands; clients should use
+  `session/new` for the same effect.
+- **No-op ping events** (#698, 694221a): `streamEventToAcpNotifications` no-ops `ping` keep-alive events
+  instead of falling through to `unreachable` and spamming stderr.
+
+## Skipped in v0.37.0 Sync
+
+- **Avoid redundant initial model sync** (#704, b275f6f): Our flow already guards `setModel` behind
+  `!isResume && resolvedSdkModel !== DEFAULT_MODEL`, so the upstream optimization is redundant.
+- **Default effort option** (#701, 9e259d1): Our effort options are model-class-based rather than
+  SDK-supplied; the implicit no-override path already covers the "let SDK decide" case.
+- **Gate auto mode on model support** (#604, ec47d34): Our `auto` mode is gated behind `ALLOW_BYPASS`,
+  not per-model `supportsAutoMode`. Per-model gating would be a larger refactor.
+
 ## Skipped in v0.30.0 Sync
 
 - **Separate auth methods** (v0.25.0): PostHog returns empty authMethods
@@ -74,7 +152,7 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 
 ## Next Sync
 
-1. Check upstream changelog since v0.30.0
+1. Check upstream changelog since v0.37.0
 2. Diff upstream source against PostHog Code using the file mapping above
 3. Port in phases: bug fixes first, then features
 4. After each phase: `pnpm --filter agent typecheck && pnpm --filter agent build && pnpm lint`

package/src/adapters/claude/claude-agent.slash-command.test.ts

@@ -34,7 +34,11 @@ function makeAgent(): { agent: Agent; client: ClientMocks } {
   return { agent, client };
 }
 
-function installFakeSession(agent: Agent, sessionId: string): MockQuery {
+function installFakeSession(
+  agent: Agent,
+  sessionId: string,
+  knownSlashCommands?: Set<string>,
+): MockQuery {
   const query = createMockQuery();
   const input = new Pushable();
   const abortController = new AbortController();
@@ -63,6 +67,7 @@ function installFakeSession(agent: Agent, sessionId: string): MockQuery {
     taskRunId: "run-1",
     lastContextWindowSize: 200_000,
     modelId: "claude-sonnet-4-6",
+    knownSlashCommands,
   };
 
   (agent as unknown as { session: typeof session }).session = session;
@@ -99,6 +104,7 @@ describe("ClaudeAcpAgent.prompt — early idle handling", () => {
       label: "unsupported slash command surfaces error and ends turn",
       sessionId: "s-slash",
       prompt: "/plugin install slack",
+      knownCommands: undefined,
       expectsUnsupportedChunk: true,
       commandInMessage: "/plugin",
     },
@@ -106,6 +112,16 @@ describe("ClaudeAcpAgent.prompt — early idle handling", () => {
       label: "non-slash prompt with early idle is silently skipped",
       sessionId: "s-regular",
       prompt: "hello",
+      knownCommands: undefined,
+      expectsUnsupportedChunk: false,
+      commandInMessage: null,
+    },
+    {
+      label:
+        "known plugin/skill command with early idle is not flagged as unsupported",
+      sessionId: "s-skill",
+      prompt: "/skills-store use my address pr review skill",
+      knownCommands: new Set(["skills-store"]),
       expectsUnsupportedChunk: false,
       commandInMessage: null,
     },
@@ -113,7 +129,11 @@ describe("ClaudeAcpAgent.prompt — early idle handling", () => {
 
   it.each(cases)("$label", async (tc) => {
     const { agent, client } = makeAgent();
-    const query = installFakeSession(agent, tc.sessionId);
+    const query = installFakeSession(
+      agent,
+      tc.sessionId,
+      tc.knownCommands as Set<string> | undefined,
+    );
 
     const promptPromise = agent.prompt({
       sessionId: tc.sessionId,

package/src/adapters/claude/claude-agent.ts

@@ -43,6 +43,7 @@ import {
   type Query,
   query,
   type SDKUserMessage,
+  type SlashCommand,
 } from "@anthropic-ai/claude-agent-sdk";
 import { v7 as uuidv7 } from "uuid";
 import packageJson from "../../../package.json" with { type: "json" };
@@ -83,6 +84,11 @@ import {
   handleSystemMessage,
   handleUserAssistantMessage,
 } from "./conversion/sdk-to-acp";
+import {
+  rehydrateTaskState,
+  type TaskState,
+  taskStateToPlanEntries,
+} from "./conversion/task-state";
 import type { EnrichedReadCache } from "./hooks";
 import { createLocalToolsMcpServer } from "./mcp/local-tools";
 import {
@@ -94,6 +100,10 @@ import {
 import { canUseTool } from "./permissions/permission-handlers";
 import { getAvailableSlashCommands } from "./session/commands";
 import { parseMcpServers } from "./session/mcp-config";
+import {
+  applyAvailableModelsAllowlist,
+  resolveInitialModelId,
+} from "./session/model-config";
 import {
   DEFAULT_MODEL,
   getEffortOptions,
@@ -143,6 +153,17 @@ function readClaudeMdQuietly(cwd: string, logger: Logger): string | undefined {
   }
 }
 
+function collectKnownSlashCommands(
+  commands: SlashCommand[] | undefined,
+): Set<string> {
+  const names = new Set<string>();
+  if (!commands) return names;
+  for (const cmd of commands) {
+    if (cmd.name) names.add(cmd.name);
+  }
+  return names;
+}
+
 function sanitizeTitle(text: string): string {
   const sanitized = text
     .replace(/[\r\n]+/g, " ")
@@ -225,6 +246,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         },
         loadSession: true,
         sessionCapabilities: {
+          additionalDirectories: {},
           list: {},
           fork: {},
           resume: {},
@@ -257,11 +279,19 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       throw RequestError.authRequired();
     }
 
-    const response = await this.createSession(params, {
-      // Revisit these meta values once we support resume
-      resume: (params._meta as NewSessionMeta | undefined)?.claudeCode?.options
-        ?.resume as string | undefined,
-    });
+    const response = await this.createSession(
+      {
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
+        _meta: params._meta,
+      },
+      {
+        // Revisit these meta values once we support resume
+        resume: (params._meta as NewSessionMeta | undefined)?.claudeCode
+          ?.options?.resume as string | undefined,
+      },
+    );
 
     return response;
   }
@@ -273,13 +303,14 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       {
         cwd: params.cwd,
         mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
         _meta: params._meta,
       },
       { resume: params.sessionId, forkSession: true },
     );
   }
 
-  async unstable_resumeSession(
+  async resumeSession(
     params: ResumeSessionRequest,
   ): Promise<ResumeSessionResponse> {
     // Reuse existing session if it matches
@@ -290,6 +321,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       {
         cwd: params.cwd,
         mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
         _meta: params._meta,
       },
       {
@@ -297,6 +329,8 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       },
     );
 
+    await this.rehydrateTaskStateFromJsonl(params.sessionId);
+
     return response;
   }
 
@@ -309,6 +343,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       {
         cwd: params.cwd,
         mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
         _meta: params._meta,
       },
       { resume: params.sessionId, skipBackgroundFetches: true },
@@ -409,6 +444,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
 
     this.session.promptRunning = true;
     let handedOff = false;
+    let errored = false;
     let lastAssistantTotalUsage: number | null = null;
     let lastStreamUsage = {
       input_tokens: 0,
@@ -416,6 +452,13 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       cache_read_input_tokens: 0,
       cache_creation_input_tokens: 0,
     };
+    // Tracks whether we're inside a compaction. The SDK emits the terminal
+    // `status` (compact_result success/failed) twice for a single failed
+    // compaction, and the two messages are indistinguishable, so we report the
+    // outcome only while a compaction is in progress, then clear this. A fresh
+    // `compacting` status sets it again, so every distinct compaction (e.g.
+    // repeated auto-compactions in a long turn) is still shown.
+    let compactionInProgress = false;
     if (this.session.lastContextWindowSize == null) {
       this.session.lastContextWindowSize = this.getContextWindowForModel(
         this.session.modelId ?? "",
@@ -491,6 +534,54 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             if (message.subtype === "local_command_output") {
               promptReplayed = true;
             }
+            if (message.subtype === "status") {
+              // The SDK signals manual `/compact` completion with a status
+              // message carrying `compact_result`, not the `compact_boundary`
+              // message (which only fires when there's content to compact).
+              // Gate the user-facing outcome on `compactionInProgress` to
+              // dedupe the duplicate terminal status the SDK emits for failed
+              // compactions.
+              if (message.status === "compacting") {
+                compactionInProgress = true;
+                // Fall through to handleSystemMessage so the COMPACTING
+                // extNotification still fires.
+              } else if (
+                message.compact_result === "success" &&
+                compactionInProgress
+              ) {
+                compactionInProgress = false;
+                await this.client.sessionUpdate({
+                  sessionId: params.sessionId,
+                  update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: {
+                      type: "text",
+                      text: "\n\nCompacting completed.",
+                    },
+                  },
+                });
+                break;
+              } else if (
+                message.compact_result === "failed" &&
+                compactionInProgress
+              ) {
+                compactionInProgress = false;
+                const reason = message.compact_error
+                  ? `: ${message.compact_error}`
+                  : ".";
+                await this.client.sessionUpdate({
+                  sessionId: params.sessionId,
+                  update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: {
+                      type: "text",
+                      text: `\n\nCompacting failed${reason}`,
+                    },
+                  },
+                });
+                break;
+              }
+            }
             if (
               message.subtype === "session_state_changed" &&
               (message as Record<string, unknown>).state === "idle"
@@ -500,7 +591,17 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
                 // and produced no output (e.g. /plugin in a non-interactive
                 // context). Without this branch we would loop forever waiting
                 // for an echo that never comes; surface a clear error instead.
-                if (commandMatch) {
+                //
+                // Only fire for commands the SDK does NOT recognize. Plugin
+                // and skill commands (e.g. /skills-store) produce a fresh
+                // user-message echo with a new uuid that our replay check
+                // can't match, so an early idle here is a race, not a real
+                // "unsupported" — fall through and let the loop continue.
+                const cmdName = commandMatch?.[1].slice(1);
+                const known =
+                  cmdName !== undefined &&
+                  this.session.knownSlashCommands?.has(cmdName) === true;
+                if (commandMatch && !known) {
                   const cmd = commandMatch[1];
                   this.logger.warn(
                     "Slash command produced no output; treating as unsupported",
@@ -520,6 +621,8 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
                 }
                 this.logger.debug("Skipping idle state before prompt replay", {
                   sessionId: params.sessionId,
+                  command: commandMatch?.[1],
+                  known,
                 });
                 break;
               }
@@ -540,7 +643,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
                 },
               });
 
-              return { stopReason: "end_turn" };
+              return {
+                stopReason: this.session.cancelled ? "cancelled" : "end_turn",
+              };
             }
             await handleSystemMessage(message, context);
             break;
@@ -814,6 +919,37 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       }
       throw new Error("Session did not end in result");
     } catch (error) {
+      errored = true;
+      // A failed turn typically leaves a trailing `session_state_changed: idle`
+      // (and possibly more) in the query iterator. If we don't drain it here,
+      // the next prompt's first `query.next()` consumes that stale idle and
+      // short-circuits to end_turn with zero usage.
+      try {
+        await this.session.query.interrupt();
+        const MAX_DRAIN = 100;
+        for (let i = 0; i < MAX_DRAIN; i++) {
+          const { value: m, done } = await this.session.query.next();
+          if (done || !m) break;
+          if (
+            m.type === "system" &&
+            m.subtype === "session_state_changed" &&
+            (m as Record<string, unknown>).state === "idle"
+          ) {
+            break;
+          }
+          if (i === MAX_DRAIN - 1) {
+            this.logger.error(
+              `Session ${params.sessionId}: drained ${MAX_DRAIN} messages after error without observing idle`,
+            );
+          }
+        }
+      } catch (drainErr) {
+        this.logger.error(
+          `Session ${params.sessionId}: failed to drain query after prompt error`,
+          { error: drainErr },
+        );
+      }
+
       if (error instanceof RequestError || !(error instanceof Error)) {
         throw error;
       }
@@ -844,10 +980,25 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       this.toolUseStreamCache.clear();
       if (!handedOff) {
         this.session.promptRunning = false;
-        // Resolve all remaining pending prompts so no callers get stuck.
-        for (const [key, pending] of this.session.pendingMessages) {
-          pending.resolve(true);
-          this.session.pendingMessages.delete(key);
+        if (errored) {
+          // The query stream was just drained — handing pending prompts off
+          // onto it would let them race with the recovery. Cancel them so
+          // each waiting prompt() returns stopReason "cancelled" and the
+          // client can decide whether to retry.
+          for (const pending of this.session.pendingMessages.values()) {
+            pending.resolve(true);
+          }
+          this.session.pendingMessages.clear();
+        } else if (this.session.pendingMessages.size > 0) {
+          // Clean exit with queued prompts: hand off the lowest-order one
+          // so it can proceed. The rest stay queued for their own turn.
+          const next = [...this.session.pendingMessages.entries()].sort(
+            (a, b) => a[1].order - b[1].order,
+          )[0];
+          if (next) {
+            next[1].resolve(false);
+            this.session.pendingMessages.delete(next[0]);
+          }
         }
       }
     }
@@ -909,6 +1060,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
 
     const mcpServers = parseMcpServers(
       params as Pick<NewSessionRequest, "mcpServers">,
+      this.logger,
     );
     await this.refreshSession(mcpServers);
     return { refreshed: true };
@@ -1142,6 +1294,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     params: {
       cwd: string;
       mcpServers: NewSessionRequest["mcpServers"];
+      additionalDirectories?: NewSessionRequest["additionalDirectories"];
       _meta?: unknown;
     },
     creationOpts: {
@@ -1181,7 +1334,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     const earlyModelId =
       settingsManager.getSettings().model || meta?.model || "";
     const mcpServers = supportsMcpInjection(earlyModelId)
-      ? parseMcpServers(params)
+      ? parseMcpServers(params, this.logger)
       : {};
 
     // Register the in-process general local-tools MCP server. Tools self-gate
@@ -1226,6 +1379,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         ? (meta.permissionMode as CodeExecutionMode)
         : "default";
 
+    const taskState: TaskState = new Map();
     const options = buildSessionOptions({
       cwd,
       mcpServers,
@@ -1239,7 +1393,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       forkSession,
       additionalDirectories: [
         ...(meta?.claudeCode?.options?.additionalDirectories ?? []),
-        ...(meta?.additionalRoots ?? []),
+        // Prefer the official ACP `additionalDirectories` field. Fall back
+        // to the legacy `_meta.additionalRoots` extension for clients that
+        // haven't been updated yet.
+        ...(params.additionalDirectories ?? meta?.additionalRoots ?? []),
       ],
       disableBuiltInTools: meta?.disableBuiltInTools,
       outputFormat,
@@ -1251,6 +1408,16 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       enrichmentDeps: this.enrichment?.deps,
       enrichedReadCache: this.enrichedReadCache,
       cloudMode: cloudRun,
+      taskState,
+      onTaskStateChange: async () => {
+        await this.client.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "plan",
+            entries: taskStateToPlanEntries(taskState),
+          },
+        });
+      },
     });
 
     // Use the same abort controller that buildSessionOptions gave to the query
@@ -1283,6 +1450,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         systemPrompt: estimateSystemPrompt(systemPrompt),
         rules: estimateRulesTokens(readClaudeMdQuietly(cwd, this.logger)),
       },
+      taskState,
 
       // Custom properties
       cwd,
@@ -1305,6 +1473,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             `Session ${forkSession ? "fork" : "resumption"} timed out for sessionId=${sessionId}`,
           );
         }
+        session.knownSlashCommands = collectKnownSlashCommands(
+          result.value.commands,
+        );
       } catch (err) {
         settingsManager.dispose();
         if (
@@ -1332,7 +1503,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       ? withTimeout(q.initializationResult(), SESSION_VALIDATION_TIMEOUT_MS)
       : undefined;
 
-    const [modelOptions] = await Promise.all([
+    const [rawModelOptions] = await Promise.all([
       this.getModelConfigOptions(
         settingsManager.getSettings().model || meta?.model || undefined,
       ),
@@ -1347,6 +1518,16 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         : []),
     ]);
 
+    // Restrict the model list to the user's `availableModels` allowlist
+    // from settings.json so config UI and downstream resolution stay
+    // consistent with what the user configured. The Default option is
+    // always preserved per the Claude Code docs.
+    const settingsAvailableModels =
+      settingsManager.getSettings().availableModels;
+    const modelOptions = Array.isArray(settingsAvailableModels)
+      ? applyAvailableModelsAllowlist(rawModelOptions, settingsAvailableModels)
+      : rawModelOptions;
+
     if (initPromise) {
       try {
         const initResult = await initPromise;
@@ -1356,6 +1537,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             `Session initialization timed out for sessionId=${sessionId}`,
           );
         }
+        session.knownSlashCommands = collectKnownSlashCommands(
+          initResult.value.commands,
+        );
       } catch (err) {
         settingsManager.dispose();
         this.logger.error("Session initialization failed", {
@@ -1368,10 +1552,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       }
     }
 
-    const settingsModel = settingsManager.getSettings().model;
-    const metaModel = meta?.model;
-    const resolvedModelId =
-      settingsModel || metaModel || modelOptions.currentModelId;
+    const resolvedModelId = resolveInitialModelId(modelOptions, [
+      settingsManager.getSettings().model,
+      meta?.model,
+    ]);
     session.modelId = resolvedModelId;
     session.lastContextWindowSize =
       this.getContextWindowForModel(resolvedModelId);
@@ -1635,6 +1819,35 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     };
   }
 
+  /**
+   * Rebuild the in-memory taskState from JSONL and push a plan update so the
+   * client's plan panel reflects pre-resume tasks. `loadSession` already covers
+   * this via the full `replaySessionHistory` notification stream; resume
+   * deliberately stays quiet (the client keeps its own message history) so we
+   * walk the transcript here for state only.
+   */
+  private async rehydrateTaskStateFromJsonl(sessionId: string): Promise<void> {
+    try {
+      const messages = await getSessionMessages(sessionId, {
+        dir: this.session.cwd,
+      });
+      rehydrateTaskState(messages, this.session.taskState);
+      if (this.session.taskState.size === 0) return;
+      await this.client.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: "plan",
+          entries: taskStateToPlanEntries(this.session.taskState),
+        },
+      });
+    } catch (err) {
+      this.logger.warn("Failed to rehydrate task state", {
+        sessionId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
   private async replaySessionHistory(sessionId: string): Promise<void> {
     try {
       const messages = await getSessionMessages(sessionId, {