feat(dsh): DeepSeek Harness integration — connect adapter + cordis plugin

README.md

@@ -679,9 +679,11 @@ The agentmemory entry is the **same MCP server block** across every host that us
 | **Continue.dev** | `~/.continue/config.yaml` (preferred) or `config.json` (legacy) | `agentmemory connect continue` creates `config.yaml` from scratch when neither exists, or modifies existing `config.json`. **If you already have `config.yaml`** the adapter prints the exact block to paste under `mcpServers:` — it won't silently rewrite your yaml because preserving comments and anchors safely needs a YAML parser the package doesn't ship. Continue uses array form (not object) for `mcpServers`. |
 | **Zed** | `~/.config/zed/settings.json` | `agentmemory connect zed` writes under `context_servers` (Zed's key, NOT `mcpServers`). Remote MCP servers can be wired via `{"url": "..."}` instead. |
 | **Droid (Factory.ai)** | `~/.factory/mcp.json` | `agentmemory connect droid` writes the standard `mcpServers` block. Project-scoped overrides go in `<repo>/.factory/mcp.json`. Pass `--with-hooks` for native auto-capture. |
+| **DeepSeek Harness (dsh)** | `~/.dsh/profiles/<profile>/cordis.patch.yml` | `agentmemory connect dsh` appends the MCP entry for `@deepseek-ai/dsh-mcp-client` (stdio), writes the memory-usage guideline into `~/.dsh/AGENTS.md` (auto-injected every session), and installs the `agentmemory-sync` skill under `~/.dsh/skills/`. HMR hot-reloads the patch — no restart. |
+| **DeepSeek Harness (full plugin)** | `plugin/dsh/` | `dsh plugin --profile web add @agentmemory/dsh` — cordis plugin: session/created → `/session/start`, first-step context+instructions injection (`agent/pre-step`), `user/message`/`tool/call`/`approval/asked` observations, `compaction/summary` bridge, `session/disposed` → `/session/end` summarization. See [`plugin/dsh/README.md`](plugin/dsh/README.md). |
 | **Goose** | Goose MCP settings UI | Same `mcpServers` block — use `goose configure` → Add Extension → MCP. Direct YAML edit at `~/.config/goose/config.yaml` is supported but the schema uses `extensions:` + `cmd` (not `mcpServers:` + `command`). |
 | **Aider** | n/a | Talk to the REST API directly: `curl -X POST http://localhost:3111/agentmemory/smart-search -d '{"query": "auth"}'`. |
-| **Any agent (32+)** | n/a | `npx skillkit install agentmemory` auto-detects the host and merges. |
+| **Any agent (33+)** | n/a | `npx skillkit install agentmemory` auto-detects the host and merges. |
 
 **Sandboxed MCP clients** (Flatpak / Snap / restrictive containers) that can't reach the host's `localhost`: also set `"AGENTMEMORY_FORCE_PROXY": "1"` in the `env` block, and point `AGENTMEMORY_URL` at a route the sandbox can actually reach (e.g. your LAN IP).
 

docs/dsh-integration.md

@@ -0,0 +1,52 @@
+# agentmemory × DeepSeek Harness (dsh) — Integration Design
+
+## Background
+
+dsh (DeepSeek Harness) is a cordis-based agent harness with no long-term memory: session transcripts and compaction summaries stay per-session and are not semantically retrievable. This PR closes the gap using agentmemory's existing surfaces — the REST lifecycle endpoints (`/session/start`, `/observe`, `/context`, `/session/end`, `/remember`) and the MCP shim (`@agentmemory/mcp`) — mirroring the OpenCode plugin pattern (`plugin/opencode/`).
+
+## Architecture (four layers)
+
+| Layer | What | Where |
+|---|---|---|
+| L1 MCP bridge | `mcp__agentmemory__*` tools via `@deepseek-ai/dsh-mcp-client` (stdio → `@agentmemory/mcp` shim, proxies to the daemon; reduced local fallback when unreachable) | `~/.dsh/profiles/<p>/cordis.patch.yml` entry, written by `agentmemory connect dsh` |
+| L2 Behavior guidance | memory-usage guideline injected into every session (`~/.dsh/AGENTS.md`, read by dsh-agent-instructions) + `agentmemory-sync` skill (`~/.dsh/skills/`) | `src/cli/connect/guidelines.ts` + adapter |
+| L3 Auto-capture plugin | `@agentmemory/dsh` cordis plugin: session lifecycle → REST | `plugin/dsh/` |
+| L4 Deep collaboration | per-agent isolation (`agentId`), compaction bridge, team memory | plugin config / future |
+
+## Event mapping: agentmemory hooks ↔ dsh events
+
+The plugin mirrors the official Claude Code hook semantics 1:1 on dsh's event stream:
+
+| agentmemory hook (Claude Code) | dsh event | Form |
+|---|---|---|
+| SessionStart | `session/created` → `POST /agentmemory/session/start` | injecting (await + timeout + fail silent) |
+| SessionStart stdout injection | `agent/pre-step` (step 1) middleware → first-step batch fold (idempotent per session) | injecting |
+| UserPromptSubmit | `session/event` (`user/message`) → `/observe prompt_submit` | telemetry (fire-and-forget) |
+| PreToolUse (matcher) | `session/event` (`tool/call`) → `/observe post_tool_use` (`mcp__agentmemory__*` self-calls filtered) | telemetry |
+| Notification | `approval/asked` → `/observe notification` (allowlisted fields) | telemetry |
+| Stop / SessionEnd | `session/disposed` → `POST /agentmemory/session/end` | telemetry (30s, promise-tracked) |
+| PreCompact | `compaction/summary` → `POST /agentmemory/remember` (compaction bridge) | telemetry |
+
+Event names are taken from `@deepseek-ai/dsh-session` / `@deepseek-ai/dsh-agent` (`session/created`, `session/disposed`, `session/event` stream types `user/message`/`tool/call`/`tool/result`, `agent/pre-step` middleware with `(_assembly, _context, next)`-style chaining, `approval/asked`, `compaction/summary`).
+
+## Design contract (same as the official hooks)
+
+- Injecting handlers **await + time out + fail silently**; they never throw into cordis (`signal.aborted` returns the unmodified decision).
+- Telemetry handlers are **fire-and-forget** and never block the agent loop; in-flight promises are tracked so nothing is dropped at teardown.
+- Project resolution (`git rev-parse`) is cached per cwd — no child process per event; per-session `{cwd, project}` captured at `session/created`.
+- Zero runtime dependencies: the plugin is a thin REST bridge (Node built-ins only), so dsh `file:` consumers need no build step; `lib/` is committed (repo convention, cf. `plugin/scripts/*.mjs`).
+
+## Verification (live, macOS)
+
+- `npm test`: 1620 passed, 6 failed (all pre-existing environment failures in `embedding-provider.test.ts`, unrelated to this change), 1 skipped out of 1627 total.
+- `@agentmemory/mcp` stdio handshake: initialize + `tools/list` → 53 tools; `memory_sessions` returns real daemon data.
+- dsh `session.create` → daemon registers a session with `agentId=dsh`; observations captured during active sessions.
+- `~/.dsh/AGENTS.md` guideline injected into live dsh sessions; `agentmemory-sync` skill picked up by dsh's skill registry.
+
+## Known environment caveat
+
+A root-owned `~/.npm/_cacache` (npm historical bug) makes `npx -y @agentmemory/mcp` fail with EPERM, so the dsh MCP bridge cannot spawn the shim. Fix: `sudo chown -R "$(id -u):$(id -g)" ~/.npm` (never hard-code UID/GID), or point `--cache` at a private per-user directory in the entry's `args` (the installer generates `~/.cache/npmcache-dsh`; both documented in `plugin/dsh/install/cordis.patch.yml`).
+
+## Installer
+
+`scripts/dsh-install.cjs` applies L1+L2 and declares the L3 plugin dependency idempotently (`--dry-run` preview, `--no-plugin` for config-only).

plugin/dsh/README.md

@@ -0,0 +1,99 @@
+# @agentmemory/dsh — agentmemory for DeepSeek Harness
+
+A cordis plugin that connects agentmemory's long-term memory to DeepSeek Harness (dsh). It registers sessions on start, injects recalled context into the first step, captures user messages and tool calls, bridges compaction summaries into the memory store, and summarizes sessions on dispose — mirroring the official agentmemory hooks for Claude Code on dsh's event stream.
+
+| agentmemory hook (Claude Code) | This plugin (dsh event) | Form |
+|---|---|---|
+| SessionStart | `session/created` → `POST /agentmemory/session/start` | injecting (await + timeout + fail silent) |
+| SessionStart stdout injection | `agent/pre-step` (step 1) middleware → first-step batch fold | injecting |
+| UserPromptSubmit | `session/event` (`user/message`) → `/observe prompt_submit` | telemetry (fire-and-forget) |
+| PreToolUse (matcher) | `session/event` (`tool/call`) → `/observe post_tool_use` (filters `mcp__agentmemory__*` self-calls) | telemetry |
+| Notification | `approval/asked` → `/observe notification` (allowlisted fields) | telemetry |
+| Stop / SessionEnd | `session/disposed` → `POST /agentmemory/session/end` | telemetry (30s, tracked) |
+| PreCompact | `compaction/summary` → `POST /agentmemory/remember` (compaction bridge) | telemetry |
+
+## Install
+
+Prerequisite: the agentmemory daemon is running (`npx @agentmemory/agentmemory`, REST `http://localhost:3111`).
+
+### 1. MCP bridge (tools, optional but recommended)
+
+Append the `mcp-agentmemory` entry from `install/cordis.patch.yml` to `~/.dsh/profiles/<profile>/cordis.patch.yml` (HMR hot-reloads it — no restart). dsh agents then get `mcp__agentmemory__*` tools.
+
+### 2. Plugin (auto-capture)
+
+```bash
+dsh plugin --profile <profile> add @agentmemory/dsh
+```
+
+Development (local repo):
+
+```bash
+# add to ~/.dsh/profiles/web/package.json dependencies:
+#   "@agentmemory/dsh": "file:/path/to/agentmemory/plugin/dsh"
+cd ~/.dsh/profiles/web && pnpm install
+```
+
+Then append to `cordis.patch.yml` (defaults shown; override as needed):
+
+```yaml
+- insert:
+    - id: agentmemory
+      name: '@agentmemory/dsh'
+      config:
+        url: http://localhost:3111   # agentmemory REST
+        secret: ''                   # match the daemon AGENTMEMORY_SECRET
+        agentId: dsh                 # per-agent memory isolation
+        injectInstructions: true     # inject memory-tool guidance on first turn
+        injectContext: true          # inject recalled project context on first turn
+        injectMaxChars: 6000         # injection budget (≈2k tokens)
+        observeToolCalls: true       # capture tool calls as observations
+        compactionBridge: true       # persist compaction summaries as memories
+        summarizeOnDispose: true     # LLM summary on session dispose
+```
+
+Restart dsh (or wait for HMR to load the new plugin).
+
+### 3. Behavior guidance (optional)
+
+- Global guidance: `install/AGENTS.md` → `~/.dsh/AGENTS.md` (auto-injected into every session)
+- Memory skill: `install/skills/agentmemory-sync/` → `~/.dsh/skills/agentmemory-sync/`
+
+## Verify
+
+1. The first turn of a new session should show injected recalled context/guidance.
+2. `curl http://localhost:3111/agentmemory/sessions` lists the dsh sessions.
+3. After ending a session, `curl http://localhost:3111/agentmemory/search -H 'Content-Type: application/json' -d '{"query":"<what you did>"}'` recalls the new memory (add `-H "Authorization: Bearer $AGENTMEMORY_SECRET"` when the daemon requires auth).
+
+## Development
+
+```bash
+npm run build    # tsdown → lib/index.js (zero runtime dependencies)
+npm test         # vitest (20 cases: REST client / event mapping / injection / self-call filter / fail-open)
+```
+
+Design contract (same as the official hooks): injecting handlers await + time out + fail silently; telemetry handlers fire-and-forget and never block the agent loop; REST failures never throw into cordis (with `AGENTMEMORY_DSH_DEBUG=1` they are logged via the REST client).
+
+## Config
+
+| Field | Default | Description |
+|---|---|---|
+| `url` | `http://localhost:3111` | agentmemory REST base URL |
+| `secret` | empty | Bearer auth (only if the daemon sets `AGENTMEMORY_SECRET`) |
+| `agentId` | `dsh` | memory owner agent; isolation key under `AGENTMEMORY_AGENT_SCOPE=isolated` |
+| `injectInstructions` | `true` | inject memory-tool guidance on the first turn |
+| `injectContext` | `true` | inject `/context` recalled project context on the first turn |
+| `injectMaxChars` | `6000` | total injection budget in characters |
+| `observeToolCalls` | `true` | `tool/call` → `post_tool_use` observations |
+| `compactionBridge` | `true` | `compaction/summary` → `/remember` |
+| `summarizeOnDispose` | `true` | `session/disposed` → `/session/end` (LLM summary) |
+
+## Build artifacts
+
+`lib/index.js` (and the hand-written `lib/index.d.ts`) are committed alongside the source: dsh `file:` consumers load `lib/` directly with no publish-time build. After changing `src/index.ts`, run `npm run build` and commit the new `lib/` (the repo already commits build output, cf. `plugin/scripts/*.mjs`).
+
+## Limitations
+
+- Event payload fields follow the running dsh version (`session/created`/`disposed` carry the session object; `agent/pre-step` is middleware; `session/event` stream events are `{type, data}`).
+- `approval/asked` observations are skipped when the payload has no `sessionId`.
+- The plugin only bridges REST; the MCP tools still need step 1's bridge.

plugin/dsh/install/AGENTS.md

@@ -0,0 +1,7 @@
+## Agent memory (agentmemory)
+
+You have persistent long-term memory via the agentmemory MCP server. Tools: `mcp__agentmemory__memory_recall`, `memory_smart_search`, `memory_save`, `memory_sessions`.
+
+- At the START of a task, call `memory_recall` (or `memory_smart_search`) to load relevant past decisions, fixes, and user preferences; do not re-ask.
+- When you learn something durable (a decision, a fix, a gotcha, a preference, a project convention), call `memory_save` to persist it.
+- Prefer recall over re-deriving; save concise reusable facts, not transcripts.

plugin/dsh/install/cordis.patch.yml

@@ -0,0 +1,38 @@
+# ── agentmemory L1: MCP bridge (append into ~/.dsh/profiles/<profile>/cordis.patch.yml) ──
+# Provides mcp__agentmemory__* tools to every DSH agent. The stdio shim
+# proxies to the agentmemory daemon (AGENTMEMORY_URL) and falls back to a
+# reduced local tool set when the daemon is unreachable.
+- insert:
+    - id: mcp-agentmemory
+      name: '@deepseek-ai/dsh-mcp-client'
+      config:
+        transport: stdio
+        serverName: agentmemory
+        command: npx
+        # If npx fails with EPERM (broken ~/.npm cache), point --cache at a
+        # private per-user dir, e.g. '~/.cache/npmcache-dsh' expanded to an
+        # absolute path by the installer (never /tmp — predictable + shared):
+        # args: ['--cache', '/home/<user>/.cache/npmcache-dsh', '-y', '@agentmemory/mcp']
+        args: ['-y', '@agentmemory/mcp']
+        env:
+          AGENTMEMORY_URL: http://localhost:3111
+          # AGENTMEMORY_SECRET: '<match the daemon .env>'
+          # AGENTMEMORY_TOOLS: all          # default: 8 core tools only (saves tokens)
+        toolCallTimeoutMs: 60000
+        failOnStartupError: false
+
+# ── agentmemory L3: cordis plugin (add after 'dsh plugin --profile <p> add @agentmemory/dsh') ──
+# Note: new entries must be wrapped in an insert list; a top-level `- id:` only
+# overrides the config of an existing entry.
+- insert:
+    - id: agentmemory
+      name: '@agentmemory/dsh'
+      config:
+        url: http://localhost:3111
+        secret: ''
+        agentId: dsh
+        injectInstructions: true
+        injectContext: true
+        observeToolCalls: true
+        compactionBridge: true
+        summarizeOnDispose: true

plugin/dsh/install/skills/agentmemory-sync/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: agentmemory-sync
+description: Sync with the agentmemory long-term memory at task start/end. Use when starting a new task, recalling past work, finishing a task, needing cross-session context, or reviewing what was done.
+---
+# agentmemory memory sync
+
+1. At task start: call mcp__agentmemory__memory_recall with the task keywords + project path, format=compact, to bring relevant history into context.
+2. During the task: when you learn something durable (decision/fix/preference/convention), call memory_save immediately (type=fact, concepts: 2-5 keywords).
+3. At task end: call memory_save with a short outcome summary (type=insight), and confirm the session is registered via memory_sessions.
+4. For large handoffs: call memory_smart_search with expandIds for graph-diffusion recall, or use memory_lesson_save/memory_lesson_recall for lessons.

plugin/dsh/lib/index.d.ts

@@ -0,0 +1,45 @@
+export interface PluginContext {
+  on(event: string, listener: (...args: any[]) => unknown): void;
+  effect(callback: () => void | (() => void), label?: string): void;
+  logger: { info(...args: unknown[]): void; warn(...args: unknown[]): void; error(...args: unknown[]): void };
+}
+
+export interface SessionLike {
+  id: string;
+  header?: { cwd?: string };
+}
+
+// Event payloads vary by event type; consumers narrow data at runtime.
+export interface SessionEvent {
+  type: string;
+  seq?: number;
+  data: any;
+}
+
+export interface AgentmemoryConfig {
+  url: string;
+  secret: string;
+  agentId: string;
+  injectInstructions: boolean;
+  injectContext: boolean;
+  injectMaxChars: number;
+  observeToolCalls: boolean;
+  compactionBridge: boolean;
+  summarizeOnDispose: boolean;
+}
+
+export interface RestClient {
+  post<T>(path: string, body: Record<string, unknown>, timeoutMs?: number): Promise<T | null>;
+  fire(path: string, body: Record<string, unknown>, timeoutMs?: number): void;
+}
+
+export function makeRestClient(url: string, secret: string, debug?: boolean): RestClient;
+export function resolveProjectName(cwd: string, env?: Record<string, string | undefined>): string;
+export function isAgentmemoryTool(name: string): boolean;
+export function eventTextContent(content: unknown): string;
+export function userMessagePrompt(event: SessionEvent, maxChars: number): string | null;
+export function toolCallObservation(event: SessionEvent, maxChars: number): Record<string, unknown> | null;
+export function compactionSummary(event: SessionEvent, maxChars: number): string | null;
+
+export const name: string;
+export function apply(ctx: PluginContext, config?: Partial<AgentmemoryConfig>): void;