Merge branch 'feat/acp-2-bridge' into feat/acp-3-multi-session

examples/README.md

@@ -12,7 +12,7 @@ A mock model + echo tool + stdio UI + JSONL persistence demo. Demonstrates:
 - Persisting session events to JSONL via the `session/event` + `session/flush` pattern
 - A minimal stdio UI consuming `agent/stream-chunk` and session events
 
-Run with: `yarn demo:echo`
+Run with: `pnpm run demo:echo`
 
 When prompted, type "echo <something>" to trigger a tool call round-trip.
 
@@ -20,4 +20,4 @@ When prompted, type "echo <something>" to trigger a tool call round-trip.
 
 The real thing: DeepSeek V4 + the bash tool suite + stdio chat + JSONL persistence, wired from `cordis.yml`. Where echo-agent proves the skeleton with mocks, this is a usable coding assistant.
 
-Run with: `yarn demo:coding` (needs `DEEPSEEK_API_KEY` in the environment or a gitignored repo-root `.env`). See [coding-agent/README.md](coding-agent/README.md) for details.
+Run with: `pnpm run demo:coding` (needs `DEEPSEEK_API_KEY` in the environment or a gitignored repo-root `.env`). See [coding-agent/README.md](coding-agent/README.md) for details.

examples/acp-agent/README.md

@@ -3,7 +3,7 @@
 The DeepSeek Harness coding agent exposed as an **Agent Client Protocol (ACP)** server over JSON-RPC stdio — drive it from Zed or any other ACP client.
 
 ```sh
-yarn demo:acp          # needs DEEPSEEK_API_KEY (repo-root .env or env)
+pnpm run demo:acp          # needs DEEPSEEK_API_KEY (repo-root .env or env)
 ```
 
 This boots `@deepseek-ai/dsh-acp` over the shared provider/tool core (`../base.yml`), with `agent-loop` configured with **no pre-created agents** (ACP `session/new` creates them on demand) and JSONL session persistence (so `session/load` works).
@@ -20,8 +20,8 @@ Add to your Zed `settings.json` under `agent_servers`:
 {
   "agent_servers": {
     "DeepSeek Harness": {
-      "command": "yarn",
-      "args": ["demo:acp"],
+      "command": "pnpm",
+      "args": ["run", "demo:acp"],
       "env": { "DEEPSEEK_API_KEY": "sk-…" }
     }
   }

examples/coding-agent/README.md

@@ -9,7 +9,7 @@ The first REAL agent wiring: DeepSeek V4 + the bash tool suite + stdio chat
 # repo root .env (gitignored) or exported env:
 #   DEEPSEEK_API_KEY=sk-…
 #   DEEPSEEK_BASE_URL=https://…   # optional; defaults to the public API
-yarn demo:coding
+pnpm run demo:coding
 ```
 
 Type a coding task. The agent's only tools are `bash` (+ `bash_output` / `bash_kill` for background tasks): file reads, writes, searches, and test runs all happen through shell commands, each in a fresh `bash -c` (the system prompt tells the model to pass `workdir` instead of `cd`). Reasoning streams dimmed; tool calls/results render inline.
@@ -22,6 +22,16 @@ Type a coding task. The agent's only tools are `bash` (+ `bash_output` / `bash_k
   …
 ```
 
+### Resuming a prior session
+
+Each run starts a fresh session by default (its event log lands under `./.sessions/`). To **continue** a previous conversation, set `RESUME_SESSION_ID` to that session's id — the `main` agent then rehydrates the persisted log instead of starting fresh, so the model sees the earlier turns as history:
+
+```sh
+RESUME_SESSION_ID=<prior-session-id> pnpm run demo:coding
+```
+
+The id is wired through `cordis.yml` (`resumeSessionId: !!js process.env.RESUME_SESSION_ID`); unset, the agent starts a new session. A missing/unreadable id is non-fatal — it logs a warning and starts no `main` agent.
+
 ## What each plugin demonstrates
 
 | Entry | Demonstrates |
@@ -32,9 +42,10 @@ Type a coding task. The agent's only tools are `bash` (+ `bash_output` / `bash_k
 | `session-persistence` (`dsh-session-persistence-jsonl`) | durable JSONL persistence (`root: ./.sessions`): append-only event log per session, crash-safe atomic writes — the shared backend, no per-example file |
 | `src/stdio-chat.ts` | UI as a plugin; copied from echo-agent with reasoning-dimming and an exit-on-idle close handler for piped stdin. Example-local on purpose — extract a shared UI package when a third example needs it |
 
-## End-to-end tests (`yarn test:e2e`, key-gated)
+## End-to-end tests (`pnpm run test:e2e`, key-gated)
 
 - `tests/full-loop.e2e.ts` — the canary: real model runs `echo e2e-ok` through the real bash tool; asserts `tool/call`/`tool/result` session events and the final answer.
 - `tests/coding-task.e2e.ts` — the swebench-style smoke: a temp dir holds `add.js` (with `a - b` where `a + b` belongs) and a failing `add.test.js`; the agent must fix the bug and verify. The test re-runs `node add.test.js` ITSELF and inspects the files — agent claims are not trusted.
+- `tests/resume.e2e.ts` — durable continuity across processes: run 1 tells the real model a secret code and persists the turn to a temp JSONL root, then the whole context is disposed; run 2 is a fresh context over the same root that RESUMES the session id and asks the model to recall the code. The recall can only come from the rehydrated log.
 
 Both self-skip without `DEEPSEEK_API_KEY`.

examples/coding-agent/cordis.yml

@@ -32,6 +32,9 @@
     agents:
       - id: main
         model: deepseek-v4-flash
+        # Set RESUME_SESSION_ID to continue a prior persisted session (the ids
+        # live under ./.sessions); unset starts a fresh session each run.
+        resumeSessionId: !!js process.env.RESUME_SESSION_ID
         systemPrompt: |
           You are coding-agent, a CLI coding assistant.
 

examples/coding-agent/tests/harness.ts

@@ -9,6 +9,7 @@ import AgentLoop, { LoopAgent } from '@deepseek-ai/dsh-agent-loop'
 import { LocalBashExecutor } from '@deepseek-ai/dsh-bash-local'
 import * as ToolBash from '@deepseek-ai/dsh-tool-bash'
 import * as LlmDeepSeek from '@deepseek-ai/dsh-llm-deepseek'
+import SessionPersistenceJsonl from '@deepseek-ai/dsh-session-persistence-jsonl'
 
 /**
  * Shared harness for the coding-agent e2e suites: the full plugin stack
@@ -20,7 +21,7 @@ export const SYSTEM_PROMPT = 'You are a coding agent. Your only tool is bash; '
   + 'do file operations with cat/grep/heredocs, check [exit code: N] markers, '
   + 'and report results briefly.'
 
-export async function codingHarness(workdir: string): Promise<Context> {
+export async function codingHarness(workdir: string, persistenceRoot?: string): Promise<Context> {
   const ctx = new Context()
   await ctx.plugin(LlmService)
   await ctx.plugin(SessionStore)
@@ -31,6 +32,10 @@ export async function codingHarness(workdir: string): Promise<Context> {
   await ctx.plugin(LlmDeepSeek, { models: ['deepseek-v4-flash'] })
   await ctx.plugin(LocalBashExecutor, { cwd: workdir, timeoutMs: 30_000 })
   await ctx.plugin(ToolBash)
+  // Durable JSONL persistence is opt-in: only the resume e2e needs it, and the
+  // other suites stay file-free. Loaded last so a resume's deferred
+  // `ctx.inject(['sessionPersistence'])` resolves once this is present.
+  if (persistenceRoot !== undefined) await ctx.plugin(SessionPersistenceJsonl, { root: persistenceRoot })
   return ctx
 }
 

examples/coding-agent/tests/resume.e2e.ts

@@ -0,0 +1,69 @@
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import type { Context } from 'cordis'
+import type { LoopAgent } from '@deepseek-ai/dsh-agent-loop'
+import { codingHarness, finalText, SYSTEM_PROMPT, waitForIdle } from './harness.ts'
+
+/**
+ * Proves durable conversation continuity end-to-end: run 1 tells the REAL model
+ * a fact and persists the turn to JSONL; run 2 is a fresh harness (new Context,
+ * same `.sessions` root) that RESUMES the persisted session id and asks the
+ * model to recall the fact. The recall can only come from the rehydrated event
+ * log — a fresh session would have no idea. Key-gated like the other e2es.
+ */
+
+const SECRET = 'plum-galaxy-1791'
+const SESSION_ID = 'resume-e2e-session'
+
+let ctx: Context | undefined
+let root: string | undefined
+
+afterEach(async () => {
+  // Dispose even on failure/retry: agent-loop teardown stops the loop and the
+  // JSONL backend flushes; then drop the on-disk session log.
+  await ctx?.fiber.dispose()
+  ctx = undefined
+  if (root !== undefined) await rm(root, { recursive: true, force: true })
+  root = undefined
+})
+
+describe.skipIf(!process.env.DEEPSEEK_API_KEY)('resume: continue a persisted session across processes', () => {
+  it('recalls a fact stored in a prior, separately-disposed session', async () => {
+    root = await mkdtemp(join(tmpdir(), 'dsh-resume-e2e-'))
+
+    // Run 1: a fresh agent on a KNOWN session id learns a secret, then we
+    // dispose the whole context (simulating process exit) so only the JSONL
+    // log on disk survives.
+    ctx = await codingHarness(process.cwd(), root)
+    const first = ctx.agents.create({
+      agentId: 'resume-1',
+      sessionId: SESSION_ID,
+      agentOptions: { model: 'deepseek-v4-flash', systemPrompt: SYSTEM_PROMPT },
+    }) as LoopAgent
+    first.send([{ type: 'text', text: `Remember this code for later: ${SECRET}. Just acknowledge it.` }])
+    await waitForIdle(ctx, first)
+    await ctx.fiber.dispose()
+    ctx = undefined
+
+    // Run 2: a brand-new context over the SAME root resumes the persisted
+    // session. The loaded event log seeds the live session, so the model sees
+    // run 1's exchange as conversation history.
+    ctx = await codingHarness(process.cwd(), root)
+    const resumed = await ctx.agents.resume({
+      agentId: 'resume-2',
+      resumeSessionId: SESSION_ID,
+      agentOptions: { model: 'deepseek-v4-flash', systemPrompt: SYSTEM_PROMPT },
+    }) as LoopAgent
+    expect(resumed.session.id).toBe(SESSION_ID)
+    // The prior user turn is in the rehydrated log before the model is asked.
+    expect(JSON.stringify(resumed.session.deriveMessages())).toContain(SECRET)
+
+    resumed.send([{ type: 'text', text: 'What was the code I asked you to remember? Reply with just the code.' }])
+    await waitForIdle(ctx, resumed)
+
+    // The model recalls it — only possible from the resumed history.
+    expect(finalText([...resumed.session.events])).toContain(SECRET)
+  }, 180_000)
+})

examples/echo-agent/README.md

@@ -24,7 +24,7 @@ Persistence is the shared `@deepseek-ai/dsh-session-persistence-jsonl` plugin (n
 ## Run
 
 ```sh
-yarn demo:echo
+pnpm run demo:echo
 # or:
 node --expose-internals --import tsx examples/echo-agent/start.ts
 ```