@ericrisco/rsc 3.0.6 → 3.0.7

package/README.md

@@ -31,6 +31,27 @@ npx @ericrisco/rsc@latest onboard
 
 </div>
 
+## 🐋 New: DeepSeek Harness
+
+[DeepSeek Harness](https://www.npmjs.com/package/@deepseek-ai/dsh) (`dsh`) is now a supported
+assistant, the 18th. Pick it in the wizard or pass `--target deepseek`:
+
+```bash
+npx @ericrisco/rsc@latest onboard --target deepseek
+```
+
+- **Skills** go to `.dsh/skills/`, where dsh finds them on its own.
+- **Instructions** go in the rsc block of `AGENTS.md`, which dsh already reads.
+- **Session memory, knowledge sync and the update notice** run from dsh's own hooks. dsh has no
+  hooks per project, so rsc adds one marked block to `~/.dsh/cordis.patch.yml` once per machine. That
+  block runs the hooks of whichever project the session is in. It works in `dsh web` with several
+  projects open, and in a project without rsc it does nothing. Restart dsh once after the first
+  install. To turn it off, delete the block.
+
+Details: [targets table](#multi-target).
+
+---
+
 ## Your agent needs a harness. It should not improvise one.
 
 A model is only the brain. Real work also needs project memory, tools, domain knowledge, rules and
@@ -89,6 +110,7 @@ someone runs `rsc git-permissions on`.
 | Gemini | `.gemini/settings.json` → `tools.allowed` |
 | OpenCode | `opencode.json` → `permission.bash` (force-push → `ask`) |
 | Cursor | Not covered: its CLI matches only the first word, so allowing a push would allow every git command. |
+| DeepSeek Harness | Not covered: dsh has no per-command allow list. Its own Permissions selector (`/permission`) sets approval for every command at once. |
 
 ```bash
 rsc git-permissions status   # decided or not, and wired per assistant
@@ -241,8 +263,8 @@ no method deciding whether each piece belongs. rsc-harness keeps that constructi
 - **Specialists follow the stack.** The four base agents stay small; installing a
   supported stack adds only its reviewer and build resolver. `rsc add go`, for
   example, adds the Go pair without pulling reviewers for every other language.
-- **A new local session continues the old one.** Claude Code, Codex, Gemini CLI
-  and OpenCode load a bounded checkpoint for the current branch and worktree at
+- **A new local session continues the old one.** Claude Code, Codex, Gemini CLI,
+  OpenCode and DeepSeek Harness load a bounded checkpoint for the current branch and worktree at
   session start. Cursor desktop uses an assisted read-before-action fallback.
 - **Honestly good.** Every skill was built by a research → spec → implement →
   *adversarial review* pipeline and had to clear an objective rubric
@@ -262,7 +284,8 @@ When a new session opens in the same checkout, that state is injected before the
 first agent action. A completed edit is preserved even if the previous client
 closed before its normal session-end event.
 
-- **Full:** Claude Code, Codex, Gemini CLI and OpenCode. Codex asks you to inspect
+- **Full:** Claude Code, Codex, Gemini CLI, OpenCode and DeepSeek Harness (through rsc's machine
+  bridge, see [targets](#multi-target)). Codex asks you to inspect
   and trust the project hook once with `/hooks`; until then `doctor` reports that
   trust is still required.
 - **Assisted:** Cursor desktop. Its start hook is fire-and-forget, so rsc also
@@ -489,7 +512,7 @@ What it will not do, by design:
 | Run where it has no business | No `origin`, no knowledge folders, a rebase in progress, a cloud agent: it stays quiet. |
 
 It is wired into the assistant's own turn hooks (end of turn, new message) in Claude Code, Codex,
-Gemini, Cursor and OpenCode (tested end to end in Claude Code, Codex and OpenCode). The network part runs in the background, so a turn never waits for
+Gemini, Cursor, OpenCode and DeepSeek Harness (tested end to end in Claude Code, Codex and OpenCode). The network part runs in the background, so a turn never waits for
 it. It is kept apart from the [local session memory](#new-sessions-pick-up-the-latest-local-work),
 which promises never to touch the network. The first turn says it is on. To turn it off for the
 project:
@@ -550,7 +573,7 @@ A new install asks whether you want this (yes by default). To turn it off later,
 `.rsc.json` like the other switches. The update can leave harness files changed in git; rsc never
 commits them for you.
 
-Where it runs on its own: **Claude Code, Codex, Gemini CLI, Cursor and OpenCode**, from a
+Where it runs on its own: **Claude Code, Codex, Gemini CLI, Cursor, OpenCode and DeepSeek Harness**, from a
 session-start hook. Every other assistant has no such hook, so the always-on instructions ask the
 agent to run `node .rsc/auto-update.mjs` on its first turn — same rules, but it depends on the agent
 doing it (and some assistants ask your permission before running a command). Codex asks you to
@@ -772,14 +795,23 @@ duplicated. The wizard asks which ones; `--target a,b` does it non-interactively
 | `roo` | `.roo/rsc/<id>/` → symlink | rule in `.roo/rules/rsc-suggest.md` |
 | `amp` | `.amp/rsc/<id>/` → symlink | block in `AGENTS.md` |
 | `opencode` | `.opencode/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `deepseek` | `.dsh/skills/<id>/` → symlink (DeepSeek Harness discovers it natively) | block in `AGENTS.md` |
 | `jules` | `.jules/rsc/<id>/` → symlink | block in `AGENTS.md` |
 | `junie` | `.junie/rsc/<id>/` → symlink | block in `.junie/guidelines.md` |
 | `kiro` | `.kiro/rsc/<id>/` → symlink | doc in `.kiro/steering/rsc-suggest.md` |
 | `aider` | `.aider/rsc/<id>/` → symlink | block in `CONVENTIONS.md` |
 
-> `codex`, `zed`, `amp`, `opencode` and `jules` all share the one root
+> `codex`, `zed`, `amp`, `opencode`, `deepseek` and `jules` all share the one root
 > `AGENTS.md`; the block is idempotent, so picking several writes it once.
 
+> **DeepSeek Harness** (`dsh`) has no project-level hook config: its plugins are per machine. So
+> the `deepseek` target writes the project hooks to `.dsh/hooks.json` (Codex format, untracked) and,
+> once per machine, adds one marked block to `~/.dsh/cordis.patch.yml` (or `$DSH_HOME`) that mounts
+> dsh's Codex-hooks bridge on rsc's dispatcher in `~/.dsh/rsc/`. The dispatcher runs the hooks of
+> whichever project the session is in, so `dsh web` serving several workspaces works too, and a
+> project without rsc runs nothing. Restart dsh once after the first install. Delete the block to
+> turn it off.
+
 The richer surfaces are intentionally narrower than skill support:
 
 | Targets | Stack agents | Native commands | Local session continuation |
@@ -788,6 +820,7 @@ The richer surfaces are intentionally narrower than skill support:
 | Codex | yes | no separate project-command surface | full after `/hooks` trust |
 | Cursor desktop | yes | yes | assisted |
 | Gemini CLI, OpenCode | yes | yes | full |
+| DeepSeek Harness | unsupported | unsupported | full (through the machine bridge) |
 | GitHub Copilot | yes | yes | unsupported |
 | Junie, Kiro | yes | unsupported | unsupported |
 | Windsurf, Cline, Roo | unsupported | yes | unsupported |

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.6",
+  "version": "3.0.7",
   "counts": {
     "skills": 270,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.6",
+  "version": "3.0.7",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {
@@ -46,6 +46,8 @@
     "claude-code",
     "cursor",
     "codex",
+    "deepseek",
+    "deepseek-harness",
     "gemini",
     "antigravity",
     "cli",

package/scripts/install-apply.js

@@ -25,6 +25,7 @@ import {
 import { wireUpdate, unwireUpdate, updateManagedPaths, updateArtifactsPresent } from '../targets/update-wiring.js';
 import { wireKnowledge, unwireKnowledge, knowledgeManagedPaths, knowledgeArtifactsPresent } from '../targets/knowledge-wiring.js';
 import { wireGitPermissions, unwireGitPermissions, gitPermissionsPath } from '../targets/git-permissions.js';
+import { wireDeepseekBridge } from '../targets/deepseek-bridge.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const CLI_VERSION = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')).version;
@@ -320,6 +321,8 @@ export async function applyInstall({ skillIds = [], agentIds = [], target, home,
   // the memory, so the memory's policy does not decide it: wired wherever the assistant can run it.
   const knowledgeResult = wireKnowledge(target, cwd);
   state.knowledge = { mode: knowledgeResult.mode, reason: knowledgeResult.reason || null, paths: knowledgeResult.paths };
+  // DeepSeek Harness only reads hooks through a machine-level bridge (targets/deepseek-bridge.js).
+  if (target === 'deepseek') state.deepseekBridge = wireDeepseekBridge();
   if (gitPermissions === true) state.gitPermissions = wireGitPermissions(target, cwd);
   else if (gitPermissions === false) { unwireGitPermissions(target, cwd); state.gitPermissions = { mode: 'off' }; }
   const context7OptOut = join(cwd, '.rsc', '.no-context7');

package/scripts/rsc.js

@@ -450,6 +450,7 @@ function printNextSteps(targets, ids) {
   say('   Browse the catalog / get picks:   npx @ericrisco/rsc consult "whatever you need"');
   say('────────────────────────────────────────────────────────');
   if (targets.includes('codex')) say('   Codex: review and trust the project lifecycle hook once with `/hooks`; until then memory is reported as requiring trust.');
+  if (targets.includes('deepseek')) say('   DeepSeek Harness: hooks run through rsc\'s bridge in ~/.dsh/cordis.patch.yml (one block, every profile); restart dsh once to load it.');
   if (targets.includes('cursor')) say('   Cursor: startup memory is assisted because its sessionStart hook is fire-and-forget; the installed always-on rule performs the read-before-action fallback.');
   printAgentHandoff();
 }

package/targets/deepseek-bridge.js

@@ -0,0 +1,86 @@
+// DeepSeek Harness (dsh) has no project-level hook or plugin config: plugins are per machine, and
+// its Codex-hooks bridge reads one file named at boot. So the deepseek target needs one machine-level
+// step besides the project files: put rsc's bridge in $DSH_HOME/rsc/ and add one insert to the
+// home patch layer ($DSH_HOME/cordis.patch.yml, applied over every profile). Idempotent, and it only
+// ever touches the block between its own markers. It is never removed on uninstall: other projects on
+// the machine may use it, and with no `.dsh/hooks.json` in a project it does nothing at all.
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const BEGIN = '# rsc-deepseek-bridge:begin';
+const END = '# rsc-deepseek-bridge:end';
+// The points rsc uses. PreToolUse is left out: nothing of rsc's runs there yet, and every tool call
+// would pay a process spawn for nothing.
+const EVENTS = ['SessionStart', 'UserPromptSubmit', 'PostToolUse', 'Stop'];
+
+export function dshHome(env = process.env) {
+  const value = (env.DSH_HOME || '').trim();
+  return value || join(homedir(), '.dsh');
+}
+
+export function deepseekBridgePaths(env = process.env) {
+  const home = dshHome(env);
+  return {
+    home,
+    bridge: join(home, 'rsc', 'bridge.mjs'),
+    hooks: join(home, 'rsc', 'hooks.json'),
+    patch: join(home, 'cordis.patch.yml'),
+  };
+}
+
+const quote = (value) => `'${String(value).replaceAll("'", "''")}'`;
+
+function block(hooksPath) {
+  return [
+    `${BEGIN} — rsc hooks for DeepSeek Harness (delete this block to turn them off)`,
+    '- insert:',
+    '    - id: rsc-hooks',
+    "      name: '@deepseek-ai/dsh-hooks-codex'",
+    '      config:',
+    `        configPath: ${quote(hooksPath)}`,
+    END,
+  ].join('\n');
+}
+
+/** Where the block goes, or null when the file is in a shape we must not guess at. */
+export function patchWithBlock(body, hooksPath) {
+  const ours = block(hooksPath);
+  const start = body.indexOf(BEGIN);
+  const stop = body.indexOf(END);
+  if (start !== -1 && stop > start) return body.slice(0, start) + ours + body.slice(stop + END.length);
+  const lines = body.split('\n');
+  const content = lines.filter((line) => line.trim() && !line.trim().startsWith('#'));
+  if (content.length === 1 && content[0].trim() === '[]') {
+    const kept = lines.filter((line) => line.trim() !== '[]').join('\n').replace(/\n*$/, '');
+    return `${kept ? `${kept}\n` : ''}${ours}\n`;
+  }
+  if (!content.length) return `${body.replace(/\n*$/, '')}${body.trim() ? '\n' : ''}${ours}\n`;
+  if (content[0].startsWith('- ')) return `${body.replace(/\n*$/, '')}\n${ours}\n`;
+  return null;
+}
+
+export function wireDeepseekBridge(env = process.env) {
+  const paths = deepseekBridgePaths(env);
+  mkdirSync(dirname(paths.bridge), { recursive: true });
+  copyFileSync(join(HERE, 'deepseek-bridge.mjs'), paths.bridge);
+  const hooks = {};
+  for (const event of EVENTS) {
+    hooks[event] = [{ hooks: [{ type: 'command', command: `node "${paths.bridge}" ${event}`, timeout: 30 }] }];
+  }
+  writeFileSync(paths.hooks, `${JSON.stringify({ hooks }, null, 2)}\n`);
+  const body = existsSync(paths.patch) ? readFileSync(paths.patch, 'utf8') : '';
+  const next = patchWithBlock(body, paths.hooks);
+  if (next === null) return { mode: 'manual', reason: 'patch-shape-unknown', paths: [paths.bridge, paths.hooks] };
+  if (next !== body) writeFileSync(paths.patch, next);
+  return { mode: 'wired', paths: [paths.bridge, paths.hooks, paths.patch] };
+}
+
+export function inspectDeepseekBridge(env = process.env) {
+  const paths = deepseekBridgePaths(env);
+  const patched = existsSync(paths.patch) && readFileSync(paths.patch, 'utf8').includes(BEGIN);
+  const ready = patched && existsSync(paths.bridge) && existsSync(paths.hooks);
+  return { status: ready ? 'ready' : 'missing', ...paths };
+}

package/targets/deepseek-bridge.mjs

@@ -0,0 +1,90 @@
+// rsc-deepseek-bridge:managed
+// DeepSeek Harness runs Codex-format hooks only from ONE file named at boot, and a boot is per
+// machine, not per project (`dsh web` serves every workspace from one process). So the machine gets
+// one hooks file whose every entry calls this script, and this script runs the hooks of whichever
+// project the session is in: the nearest ancestor of the session's cwd holding `.dsh/hooks.json`.
+// No project there → nothing runs, nothing is printed.
+//
+// Output is folded back into the Codex shape the bridge reads. The bridge drops `systemMessage`
+// (not surfaced yet), so a message for the person travels as model context with an instruction to
+// relay it. Usage: node bridge.mjs <SessionStart|UserPromptSubmit|PostToolUse|Stop>  (payload on stdin)
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const CONTEXT_EVENTS = new Set(['SessionStart', 'UserPromptSubmit', 'PostToolUse']);
+
+export function projectOf(dir) {
+  for (let current = resolve(dir); ; current = dirname(current)) {
+    if (existsSync(join(current, '.dsh', 'hooks.json'))) return current;
+    if (dirname(current) === current) return null;
+  }
+}
+
+// The hooks rsc writes are plain argv (`node ".rsc/x.mjs" args`), so no shell is needed — and none is
+// used, which also keeps Windows from flashing a console (#293). Quotes group, nothing else is special.
+export function argv(command) {
+  const out = [];
+  for (const m of command.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)) out.push(m[1] ?? m[2] ?? m[3]);
+  if (out[0] === 'node') out[0] = process.execPath;
+  return out;
+}
+
+function matches(matcher, subject) {
+  if (!matcher) return true;
+  try { return new RegExp(`^(?:${matcher})$`).test(subject); } catch { return false; }
+}
+
+export function runBridge(event, raw = '', env = process.env) {
+  let payload = {};
+  try { payload = raw.trim() ? JSON.parse(raw) : {}; } catch { payload = {}; }
+  const root = projectOf(payload.cwd || process.cwd());
+  if (!root) return {};
+  let config;
+  try { config = JSON.parse(readFileSync(join(root, '.dsh', 'hooks.json'), 'utf8')); } catch { return {}; }
+  const groups = Array.isArray(config?.hooks?.[event]) ? config.hooks[event] : [];
+  const context = [];
+  let deny = null;
+  for (const group of groups) {
+    if (!matches(group?.matcher, String(payload.tool_name || ''))) continue;
+    for (const hook of Array.isArray(group?.hooks) ? group.hooks : []) {
+      if (typeof hook?.command !== 'string') continue;
+      const seconds = typeof hook.timeout === 'number' ? hook.timeout : 10;
+      const [file, ...args] = argv(hook.command);
+      if (!file) continue;
+      const result = spawnSync(file, args, {
+        cwd: root, input: raw, encoding: 'utf8', timeout: seconds * 1000, windowsHide: true, env,
+      });
+      if (result.status === 2) { deny = (result.stderr || '').trim() || 'blocked by an rsc hook'; continue; }
+      if (result.status !== 0) continue;
+      const out = (result.stdout || '').trim();
+      if (!out) continue;
+      let parsed = null;
+      try { parsed = JSON.parse(out); } catch { parsed = null; }
+      if (!parsed || typeof parsed !== 'object') { context.push(out); continue; }
+      const specific = parsed.hookSpecificOutput || {};
+      if (parsed.decision === 'block' || parsed.decision === 'deny' || specific.permissionDecision === 'deny') {
+        deny = parsed.reason || specific.permissionDecisionReason || 'blocked by an rsc hook';
+      }
+      if (typeof specific.additionalContext === 'string' && specific.additionalContext) context.push(specific.additionalContext);
+      if (typeof parsed.systemMessage === 'string' && parsed.systemMessage) {
+        context.push(`Tell the person this in one line, in their language:\n${parsed.systemMessage}`);
+      }
+    }
+  }
+  const out = {};
+  if (deny) { out.decision = 'block'; out.reason = deny; }
+  if (context.length && CONTEXT_EVENTS.has(event)) {
+    out.hookSpecificOutput = { hookEventName: event, additionalContext: context.join('\n\n') };
+  }
+  return out;
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  let raw = '';
+  try { raw = readFileSync(0, 'utf8'); } catch { raw = ''; }
+  let out = {};
+  try { out = runBridge(String(process.argv[2] || ''), raw); } catch { out = {}; }
+  if (Object.keys(out).length) process.stdout.write(`${JSON.stringify(out)}\n`);
+}

package/targets/index.js

@@ -44,6 +44,8 @@ const SPEC = {
   // AGENTS.md family — all read the same root AGENTS.md
   codex: { root: '.codex/rsc', hook: 'AGENTS.md', adapter: 'md' },
   opencode: { root: '.opencode/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  // DeepSeek Harness discovers <root>/.dsh/skills/<name>/SKILL.md natively.
+  deepseek: { root: '.dsh/skills', hook: 'AGENTS.md', adapter: 'md' },
   amp: { root: '.amp/rsc', hook: 'AGENTS.md', adapter: 'md' },
   jules: { root: '.jules/rsc', hook: 'AGENTS.md', adapter: 'md' },
   zed: { root: '.zed/rsc', hook: 'AGENTS.md', adapter: 'md' },
@@ -78,6 +80,7 @@ export const TARGETS = [
   { id: 'roo', label: 'Roo Code', hint: '.roo/rules/' },
   { id: 'amp', label: 'Amp', hint: 'AGENTS.md' },
   { id: 'opencode', label: 'opencode', hint: 'AGENTS.md' },
+  { id: 'deepseek', label: 'DeepSeek Harness', hint: '.dsh/skills/' },
   { id: 'jules', label: 'Jules', hint: 'AGENTS.md' },
   { id: 'junie', label: 'JetBrains Junie', hint: '.junie/guidelines.md' },
   { id: 'kiro', label: 'Kiro', hint: '.kiro/steering/' },
@@ -118,6 +121,7 @@ export function detectTarget(cwd = process.cwd()) {
   if (has('.kiro')) return 'kiro';
   if (has('.zed')) return 'zed';
   if (has('.opencode')) return 'opencode';
+  if (has('.dsh')) return 'deepseek';
   if (has('.amp')) return 'amp';
   if (has('.jules')) return 'jules';
   if (has('.antigravity')) return 'antigravity';

package/targets/knowledge-wiring.js

@@ -18,6 +18,7 @@ const PLUGIN_MARKER = 'rsc-knowledge:managed';
 const CONFIG = Object.freeze({
   claude: '.claude/settings.local.json',
   codex: '.codex/hooks.json',
+  deepseek: '.dsh/hooks.json',
   cursor: '.cursor/hooks.json',
   gemini: '.gemini/settings.json',
   opencode: '.opencode/plugins/rsc-knowledge.js',
@@ -26,6 +27,7 @@ const CONFIG = Object.freeze({
 const EVENTS = Object.freeze({
   claude: [['UserPromptSubmit', 'request'], ['Stop', 'turn']],
   codex: [['UserPromptSubmit', 'request'], ['Stop', 'turn']],
+  deepseek: [['UserPromptSubmit', 'request'], ['Stop', 'turn']],
   gemini: [['BeforeAgent', 'request'], ['AfterAgent', 'turn']],
   cursor: [['beforeSubmitPrompt', 'request'], ['afterAgentResponse', 'turn']],
 });

package/targets/memory.js

@@ -13,6 +13,7 @@ const PLUGIN_MARKER = 'rsc-memory:managed';
 export const MEMORY_TARGETS = Object.freeze({
   claude: 'full',
   codex: 'full',
+  deepseek: 'full',
   // Cursor documents sessionStart as fire-and-forget. Its best-effort hook is useful,
   // but only the always-on rule can make the read-before-action obligation explicit.
   cursor: 'assisted',
@@ -23,6 +24,7 @@ export const MEMORY_TARGETS = Object.freeze({
 const CONFIG = Object.freeze({
   claude: '.claude/settings.local.json',
   codex: '.codex/hooks.json',
+  deepseek: '.dsh/hooks.json',
   cursor: '.cursor/hooks.json',
   gemini: '.gemini/settings.json',
   opencode: '.opencode/plugins/rsc-memory.js',
@@ -99,6 +101,11 @@ const nestedEvents = {
     ['PostToolUse', 'edit', 'apply_patch|Edit|Write'], ['PostToolUse', 'boundary', 'Bash'],
     ['Stop', 'turn'], ['PreCompact', 'compact'], ['SessionEnd', 'end'],
   ],
+  // DeepSeek Harness runs Codex-format hooks through rsc's bridge: only these five points exist there.
+  deepseek: [
+    ['SessionStart', 'start'], ['UserPromptSubmit', 'request'],
+    ['PostToolUse', 'edit', 'edit|write|str_replace_editor'], ['PostToolUse', 'boundary', 'bash'], ['Stop', 'turn'],
+  ],
   gemini: [
     ['SessionStart', 'start'], ['BeforeAgent', 'request'], ['AfterTool', 'edit', 'write_file|replace'],
     ['AfterTool', 'boundary', 'run_shell_command'], ['AfterAgent', 'turn'], ['PreCompress', 'compact'], ['SessionEnd', 'end'],

package/targets/session-memory-adapter.mjs

@@ -4,7 +4,7 @@ import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve, join, dirname } from 'node:path';
 import { capture, otherActiveSessions, resume } from './session-memory-core.mjs';
 
-const LOCAL_TARGETS = new Set(['claude', 'codex', 'cursor', 'gemini', 'opencode']);
+const LOCAL_TARGETS = new Set(['claude', 'codex', 'cursor', 'deepseek', 'gemini', 'opencode']);
 
 function projectSettings(cwd) {
   try {

package/targets/update-wiring.js

@@ -19,12 +19,13 @@ const PLUGIN_MARKER = 'rsc-update:managed';
 
 const CONFIG = Object.freeze({
   codex: '.codex/hooks.json',
+  deepseek: '.dsh/hooks.json',
   cursor: '.cursor/hooks.json',
   gemini: '.gemini/settings.json',
   opencode: '.opencode/plugins/rsc-update.js',
 });
 
-const EVENT = Object.freeze({ codex: 'SessionStart', gemini: 'SessionStart', cursor: 'sessionStart' });
+const EVENT = Object.freeze({ codex: 'SessionStart', deepseek: 'SessionStart', gemini: 'SessionStart', cursor: 'sessionStart' });
 
 /** Assistants where the update runs on its own. Every other one depends on the agent running it. */
 export const UPDATE_HOOK_TARGETS = Object.freeze(['claude', ...Object.keys(CONFIG)].sort());