feat(cli-acp): enable vendor resume for configured ACP backends advertising session/load

apps/cli/src/agent/acp/AcpBackend.ts

@@ -766,6 +766,7 @@ export class AcpBackend implements AgentBackend {
   private readonly sessionUpdateShapeLogger = createEventShapeLoggerForLog({ logger, scope: 'acp-backend' });
   private connection: AcpClientConnection | null = null;
   private acpSessionId: string | null = null;
+  private agentCapabilities: InitializeResponse['agentCapabilities'] | null = null;
   private disposed = false;
   private replayCapture: AcpReplayCapture | null = null;
   /** Sole tool lifecycle/merge/timeout/finalization owner. */
@@ -956,6 +957,7 @@ export class AcpBackend implements AgentBackend {
     this.process = null;
     this.connection = null;
     this.acpSessionId = null;
+    this.agentCapabilities = null;
 
     connection?.close();
 
@@ -1577,6 +1579,8 @@ export class AcpBackend implements AgentBackend {
 
     logger.debug(`[AcpBackend] Initialize completed`);
 
+    this.agentCapabilities = (initResponse as InitializeResponse | null)?.agentCapabilities ?? null;
+
     if (this.options.authentication) {
       const advertisedMethodIds = new Set<string>();
       const methods = (initResponse as InitializeResponse | null)?.authMethods ?? [];
@@ -1642,6 +1646,14 @@ export class AcpBackend implements AgentBackend {
   }
 }
 
+  /**
+   * Whether the connected agent advertised ACP `session/load` support in its
+   * initialize capabilities. False until initialize completes.
+   */
+  supportsSessionLoad(): boolean {
+    return this.agentCapabilities?.loadSession === true;
+  }
+
   async startSession(initialPrompt?: string): Promise<StartSessionResult> {
     if (this.disposed) {
       throw new Error('Backend has been disposed');

apps/cli/src/agent/acp/__tests__/AcpBackend.loadSessionCapability.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+
+import { AcpBackend } from '../AcpBackend';
+import { writeAcpTestAgentScript } from '../testkit/subprocessHarness';
+import { withTempDir } from '@/testkit/fs/tempDir';
+
+function writeCapabilityAgentScript(params: { dir: string; declareLoadSession: boolean }): string {
+  return writeAcpTestAgentScript({
+    dir: params.dir,
+    fileName: params.declareLoadSession ? 'fake-acp-load-capable.mjs' : 'fake-acp-load-incapable.mjs',
+    source: `
+      import readline from 'node:readline';
+      const rl = readline.createInterface({ input: process.stdin });
+      const send = (value) => process.stdout.write(JSON.stringify(value) + '\\n');
+      rl.on('line', (line) => {
+        const request = JSON.parse(line);
+        if (request.method === 'initialize') {
+          send({
+            jsonrpc: '2.0',
+            id: request.id,
+            result: {
+              protocolVersion: 1,
+              authMethods: [],
+              agentCapabilities: { loadSession: ${params.declareLoadSession} },
+            },
+          });
+          return;
+        }
+        if (request.method === 'session/new') {
+          send({ jsonrpc: '2.0', id: request.id, result: { sessionId: 'fresh-session' } });
+          return;
+        }
+        send({ jsonrpc: '2.0', id: request.id, result: {} });
+      });
+    `,
+  });
+}
+
+describe('AcpBackend session load capability', () => {
+  it('reports session load support when the agent advertises loadSession', async () => {
+    await withTempDir('happier-acp-load-capable-', async (dir) => {
+      const scriptPath = writeCapabilityAgentScript({ dir, declareLoadSession: true });
+      const backend = new AcpBackend({
+        agentName: 'test',
+        cwd: dir,
+        command: process.execPath,
+        args: [scriptPath],
+      });
+      try {
+        await backend.startSession();
+        expect(backend.supportsSessionLoad()).toBe(true);
+      } finally {
+        await backend.dispose();
+      }
+    });
+  }, 20_000);
+
+  it('reports no session load support when the agent omits the capability', async () => {
+    await withTempDir('happier-acp-load-incapable-', async (dir) => {
+      const scriptPath = writeCapabilityAgentScript({ dir, declareLoadSession: false });
+      const backend = new AcpBackend({
+        agentName: 'test',
+        cwd: dir,
+        command: process.execPath,
+        args: [scriptPath],
+      });
+      try {
+        await backend.startSession();
+        expect(backend.supportsSessionLoad()).toBe(false);
+      } finally {
+        await backend.dispose();
+      }
+    });
+  }, 20_000);
+
+  it('reports no session load support before initialize completes', () => {
+    const backend = new AcpBackend({
+      agentName: 'test',
+      cwd: '/tmp',
+      command: process.execPath,
+      args: ['-e', ''],
+    });
+    expect(backend.supportsSessionLoad()).toBe(false);
+  });
+});

apps/cli/src/agent/acp/catalog/configured/createConfiguredAcpRuntime.ts

@@ -14,6 +14,7 @@ import { getSessionNotificationTitle } from '@/agent/runtime/readyNotificationCo
 import type { SessionProviderInputConsumer } from '@/agent/runtime/sessionInput/types';
 
 import { createConfiguredAcpBackend } from './createConfiguredAcpBackend';
+import { createConfiguredAcpSessionIdentityPublication } from './createConfiguredAcpSessionIdentityPublication';
 import type { ResolvedConfiguredAcpBackend } from './resolveConfiguredAcpBackendFromAccountSettings';
 
 type CreateConfiguredAcpRuntimeParams = Readonly<{
@@ -52,6 +53,11 @@ export function createConfiguredAcpRuntime(params: CreateConfiguredAcpRuntimePar
     }
   };
 
+  // The backend is created lazily by ensureBackend (below) and only learns
+  // whether the adapter supports session/load once the ACP initialize
+  // handshake completes; the identity publication re-checks on every bind.
+  let sessionLoadSupportProbe: { supportsSessionLoad?: () => boolean } | null = null;
+
   return createAcpRuntime({
     provider: `acp:${params.backend.backendId}`,
     directory: params.directory,
@@ -61,10 +67,10 @@ export function createConfiguredAcpRuntime(params: CreateConfiguredAcpRuntimePar
     mcpServers: params.mcpServers,
     permissionHandler: params.permissionHandler,
     onThinkingChange: params.onThinkingChange,
-    sessionIdentity: {
-      kind: 'runtime-only',
-      reason: 'vendor-resume-unsupported',
-    },
+    sessionIdentity: createConfiguredAcpSessionIdentityPublication({
+      session: params.session,
+      isSessionLoadSupported: () => sessionLoadSupportProbe?.supportsSessionLoad?.() === true,
+    }),
     memoryRecallGuidance: params.memoryRecallGuidance,
     hooks: {
       onPermissionRequest: (evt) => {
@@ -86,6 +92,7 @@ export function createConfiguredAcpRuntime(params: CreateConfiguredAcpRuntimePar
         permissionHandler: params.permissionHandler,
         ...(permissionMode ? { permissionMode } : {}),
       });
+      sessionLoadSupportProbe = backend as unknown as { supportsSessionLoad?: () => boolean };
       logger.debug(`[${params.loggerLabel}] Backend created`);
       return backend as unknown as AgentBackend;
     },

apps/cli/src/agent/acp/catalog/configured/createConfiguredAcpSessionIdentityPublication.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+
+import { createConfiguredAcpSessionIdentityPublication } from './createConfiguredAcpSessionIdentityPublication';
+
+function createFakeSession(initial: Record<string, unknown> = {}) {
+  let metadata: Record<string, unknown> = { ...initial };
+  const updateCalls: Array<Record<string, unknown>> = [];
+  return {
+    session: {
+      sessionId: 'happier-session-1',
+      getMetadataSnapshot: () => metadata as never,
+      updateMetadata: (updater: (value: Record<string, unknown>) => Record<string, unknown>) => {
+        metadata = updater(metadata);
+        updateCalls.push(metadata);
+      },
+    },
+    getMetadata: () => metadata,
+    updateCalls,
+  };
+}
+
+describe('createConfiguredAcpSessionIdentityPublication', () => {
+  it('publishes the bound ACP session id to customAcpSessionId metadata when the adapter supports session load', async () => {
+    const fake = createFakeSession();
+    const publication = createConfiguredAcpSessionIdentityPublication({
+      session: fake.session as never,
+      isSessionLoadSupported: () => true,
+    });
+
+    expect(publication.kind).toBe('persist-bound');
+    if (publication.kind !== 'persist-bound') throw new Error('expected persist-bound');
+    await publication.persistBound({ generation: 0, operation: 'create', vendorSessionId: 'acp-session-1' });
+
+    expect(fake.getMetadata().customAcpSessionId).toBe('acp-session-1');
+  });
+
+  it('publishes nothing when the adapter does not support session load', async () => {
+    const fake = createFakeSession();
+    const publication = createConfiguredAcpSessionIdentityPublication({
+      session: fake.session as never,
+      isSessionLoadSupported: () => false,
+    });
+
+    if (publication.kind !== 'persist-bound') throw new Error('expected persist-bound');
+    await publication.persistBound({ generation: 0, operation: 'create', vendorSessionId: 'acp-session-1' });
+
+    expect(fake.updateCalls).toHaveLength(0);
+    expect(fake.getMetadata().customAcpSessionId).toBeUndefined();
+  });
+
+  it('re-evaluates adapter support on every publication so capability is read after initialize', async () => {
+    const fake = createFakeSession();
+    let supported = false;
+    const publication = createConfiguredAcpSessionIdentityPublication({
+      session: fake.session as never,
+      isSessionLoadSupported: () => supported,
+    });
+
+    if (publication.kind !== 'persist-bound') throw new Error('expected persist-bound');
+    await publication.persistBound({ generation: 0, operation: 'create', vendorSessionId: 'acp-session-1' });
+    expect(fake.getMetadata().customAcpSessionId).toBeUndefined();
+
+    supported = true;
+    await publication.persistBound({ generation: 1, operation: 'create', vendorSessionId: 'acp-session-2' });
+    expect(fake.getMetadata().customAcpSessionId).toBe('acp-session-2');
+  });
+});

apps/cli/src/agent/acp/catalog/configured/createConfiguredAcpSessionIdentityPublication.ts

@@ -0,0 +1,32 @@
+import type { AcpSessionIdentityPublication } from '@/agent/acp/runtime/sessionIdentityBinding';
+import type { ApiSessionClient } from '@/api/session/sessionClient';
+import { createVendorResumeIdMetadataPublisher } from '@/session/metadata/createVendorResumeIdMetadataPublisher';
+
+/**
+ * Session identity publication for configured (user-defined) ACP backends.
+ *
+ * Unlike built-in catalog agents, a configured backend is an arbitrary ACP
+ * adapter: some implement `session/load` (vendor resume), many do not. The ACP
+ * `initialize` handshake advertises this via `agentCapabilities.loadSession`,
+ * so publication is gated on the adapter's declared capability at bind time:
+ * adapters without load support publish nothing, their sessions carry no
+ * `customAcpSessionId`, and the runtime_checked resume policy keeps resume
+ * unavailable for them instead of failing against an adapter that cannot load.
+ */
+export function createConfiguredAcpSessionIdentityPublication(params: Readonly<{
+  session: ApiSessionClient;
+  isSessionLoadSupported: () => boolean;
+}>): AcpSessionIdentityPublication {
+  const publisher = createVendorResumeIdMetadataPublisher({
+    agentId: 'customAcp',
+    getMetadataSnapshot: () => params.session.getMetadataSnapshot(),
+    updateMetadata: (updater) => params.session.updateMetadata(updater),
+  });
+  return {
+    kind: 'persist-bound',
+    persistBound: async (event) => {
+      if (!params.isSessionLoadSupported()) return;
+      await publisher.persistBound(event);
+    },
+  };
+}

apps/cli/src/agent/acp/catalog/runCatalogDefinedAcpAgent.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 
-import type { AgentId } from '@happier-dev/agents';
+import type { AgentId, VendorResumeSupportLevel } from '@happier-dev/agents';
 import { AGENTS_CORE, getProviderCliRuntimeSpec } from '@happier-dev/agents';
 
 import type { Credentials } from '@/persistence';
@@ -67,7 +67,7 @@ export async function runCatalogDefinedAcpAgent(
         messageBuffer,
         mcpServers,
         permissionHandler,
-        sessionIdentity: AGENTS_CORE[agentId].resume.vendorResume === 'unsupported'
+        sessionIdentity: (AGENTS_CORE[agentId].resume.vendorResume as VendorResumeSupportLevel) === 'unsupported'
           ? { kind: 'runtime-only', reason: 'vendor-resume-unsupported' }
           : { kind: 'manifest-metadata' },
         onThinkingChange: setThinking,

apps/cli/src/agent/acp/runtime/createCatalogProviderAcpRuntime.ts

@@ -14,7 +14,7 @@ import {
 } from '@/settings/notifications/permissionRequestPush';
 import { createAgentSessionMediaPersister } from '@/session/sessionMedia/createAgentSessionMediaPersister';
 import { createSessionMediaAccessPolicy } from '@/session/sessionMedia/createSessionMediaAccessPolicy';
-import { AGENTS_CORE, getProviderCliRuntimeSpec, isAgentMediaCapabilitySupported } from '@happier-dev/agents';
+import { AGENTS_CORE, getProviderCliRuntimeSpec, isAgentMediaCapabilitySupported, type VendorResumeSupportLevel } from '@happier-dev/agents';
 import { getSessionNotificationTitle } from '@/agent/runtime/readyNotificationContext';
 import type { SessionProviderInputConsumer } from '@/agent/runtime/sessionInput/types';
 import { createVendorResumeIdMetadataPublisher } from '@/session/metadata/createVendorResumeIdMetadataPublisher';
@@ -125,7 +125,7 @@ export function createCatalogProviderAcpRuntime<TBackendOptions extends object =
       return { kind: 'persist-bound' as const, persistBound: params.sessionIdentity.persistBound };
     }
     if (params.sessionIdentity.kind === 'runtime-only'
-      && AGENTS_CORE[params.provider].resume.vendorResume !== 'unsupported') {
+      && (AGENTS_CORE[params.provider].resume.vendorResume as VendorResumeSupportLevel) !== 'unsupported') {
       throw new Error(`Agent ${params.provider} advertises vendor resume and cannot use runtime-only session identity`);
     }
     return params.sessionIdentity;

apps/cli/src/api/types.ts

@@ -554,6 +554,7 @@ export type Metadata = {
     serviceIds: ConnectedServiceId[],
   },
   codexSessionId?: string, // Codex session/conversation ID (uuid)
+  customAcpSessionId?: string, // Configured ACP backend session ID (vendor resume)
   codexBackendMode?: 'mcp' | 'acp' | 'appServer',
   agentRuntimeDescriptorV1?: unknown,
   // Compact, count-only workflow activity headline (CWF3). The live invalidation pointer to durable

apps/cli/src/capabilities/registry/toolExecutionRuns.feat.execution.runs.test.ts

@@ -65,7 +65,7 @@ describe('executionRunsCapability', () => {
     expect(typeof res.backends.kiro.supportsVendorResume).toBe('boolean');
     expect(res.backends.customAcp).toMatchObject({
       available: true,
-      supportsVendorResume: false,
+      supportsVendorResume: true,
     });
     expect(res.backends.pi).toBeTruthy();
     expect(typeof res.backends.pi.supportsVendorResume).toBe('boolean');

apps/cli/src/daemon/sessions/runtimeSnapshot/resolveSessionRuntimeSnapshot.test.ts

@@ -285,6 +285,39 @@ describe('resolveSessionRuntimeSnapshot', () => {
     expect(result.spawnOptions.resume).toBeUndefined();
   });
 
+  it('inherits the configured-backend vendor resume id from customAcp metadata for configured ACP attaches', () => {
+    const result = resolveSessionRuntimeSnapshot({
+      incomingOptions: baseIncomingOptions({
+        backendTarget: { kind: 'configuredAcpBackend', backendId: 'custom-kiro' },
+      }),
+      persistedMetadata: {
+        flavor: 'acp:custom-kiro',
+        customAcpSessionId: 'acp-session-1',
+      },
+    });
+
+    expect(result.snapshot.vendorResumeId).toEqual({
+      value: 'acp-session-1',
+      updatedAt: null,
+    });
+    expect(result.spawnOptions.resume).toBe('acp-session-1');
+  });
+
+  it('drops the resume id when the persisted customAcp metadata belongs to a different configured backend', () => {
+    const result = resolveSessionRuntimeSnapshot({
+      incomingOptions: baseIncomingOptions({
+        backendTarget: { kind: 'configuredAcpBackend', backendId: 'custom-kiro' },
+      }),
+      persistedMetadata: {
+        flavor: 'acp:other-backend',
+        customAcpSessionId: 'acp-session-1',
+      },
+    });
+
+    expect(result.snapshot.vendorResumeId).toBeNull();
+    expect(result.spawnOptions.resume).toBeUndefined();
+  });
+
   it('preserves incoming controls without timestamps when no persisted or tracked snapshot exists', () => {
     const result = resolveSessionRuntimeSnapshot({
       incomingOptions: baseIncomingOptions({