@ericrisco/rsc 3.0.5 → 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.5",
+  "version": "3.0.7",
   "counts": {
     "skills": 270,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.5",
+  "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/auto-update.mjs

@@ -11,7 +11,7 @@
 //     `node .rsc/auto-update.mjs` on its first turn, and to relay what it prints.
 import { readFileSync, existsSync, writeFileSync, openSync } from 'node:fs';
 import { spawn } from 'node:child_process';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 // Update check: compare the installed version (.rsc/.version, written at install)
@@ -86,12 +86,21 @@ function launchUpdate(root, version, env) {
   const targets = declaredTargets(root);
   const args = [...base.slice(1), 'sync', ...(targets.length ? ['--target', targets.join(',')] : [])];
   const log = openSync(logFile(root), 'w');
-  const child = spawn(base[0], args, {
+  // #293 — on Windows npx is npx.cmd, which Node only starts through a shell, and a shell is one more
+  // console that can flash. So npx runs as what it is, a script of the npm that ships with Node,
+  // started by node itself. Only when that script cannot be found (a runtime that is not Node, e.g.
+  // OpenCode's Bun) does it fall back to the shell — still hidden.
+  const npxCli = !env.RSC_AUTO_UPDATE_CMD && process.platform === 'win32' && !process.versions.bun
+    ? [join(dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npx-cli.js')].find((p) => existsSync(p))
+    : null;
+  const [command, argv] = npxCli ? [process.execPath, [npxCli, ...args]] : [base[0], args];
+  const viaShell = !npxCli && process.platform === 'win32';
+  const child = spawn(command, argv, {
     cwd: root,
     detached: true,
     stdio: ['ignore', log, log],
     windowsHide: true,
-    shell: process.platform === 'win32', // npx is npx.cmd there; every argument was validated above
+    shell: viaShell, // fallback only (see above); every argument was validated above
     env: { ...env, RSC_NO_UPDATE_CHECK: '1', RSC_AUTO_UPDATE_TO: version },
   });
   child.on('error', () => {});

package/targets/branch-guard.mjs

@@ -45,7 +45,7 @@ export function effectiveDir(command, base) {
 }
 
 const gitAt = (dir) => (...args) => {
-  const r = spawnSync('git', ['-C', dir, ...args], { encoding: 'utf8' });
+  const r = spawnSync('git', ['-C', dir, ...args], { windowsHide: true, encoding: 'utf8' });
   return r.status === 0 ? (r.stdout || '').trim() : null;
 };
 

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/git-permissions.js

@@ -41,7 +41,7 @@ const FILES = Object.freeze({
 });
 
 const git = (cwd, args) => {
-  try { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+  try { return execFileSync('git', args, { windowsHide: true, cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
 };
 const rel = (cwd, path) => relative(cwd, path).split(sep).join('/');
 

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-sync.mjs

@@ -65,6 +65,7 @@ export const isKnowledge = (path) => KNOWLEDGE.some((k) => path.startsWith(k)) &
 function run(root, args, { timeout = LOCAL_TIMEOUT_MS, input, env } = {}) {
   try {
     const out = execFileSync('git', args, {
+      windowsHide: true,
       cwd: root, encoding: 'utf8', timeout, input, maxBuffer: 16 * 1024 * 1024,
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C', ...env },

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']],
 });
@@ -33,7 +35,7 @@ const EVENTS = Object.freeze({
 export const KNOWLEDGE_TARGETS = Object.freeze(Object.keys(CONFIG));
 
 const git = (cwd, args) => {
-  try { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+  try { return execFileSync('git', args, { windowsHide: true, cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
 };
 const rel = (cwd, path) => relative(cwd, path).split(sep).join('/');
 const tracked = (cwd, path) => Boolean(git(cwd, ['ls-files', '--', rel(cwd, path)]));

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',
@@ -35,7 +37,7 @@ export function memoryEnabledForProject(cwd = process.cwd()) {
 }
 
 function git(cwd, args) {
-  try { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+  try { return execFileSync('git', args, { windowsHide: true, cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
 }
 
 function rel(cwd, path) {
@@ -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/sello.mjs

@@ -103,7 +103,7 @@ export function isEnabled(root) {
 // The CLI can run from any subdirectory; the guard always runs from the project
 // root. Both must compute the same candidate, so both resolve to the git toplevel.
 export function resolveRoot(root) {
-  const r = spawnSync('git', ['-C', root, 'rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+  const r = spawnSync('git', ['-C', root, 'rev-parse', '--show-toplevel'], { windowsHide: true, encoding: 'utf8' });
   return r.status === 0 ? (r.stdout || '').trim() || root : root;
 }
 
@@ -211,7 +211,7 @@ export function lensesRequired(tier, cfg = null) {
 // name matches no file on disk, so the file would hash as deleted and any later
 // mutation of it would sail through the gate. -z gives raw NUL-separated paths.
 function git(root, ...args) {
-  const r = spawnSync('git', ['-C', root, '-c', 'core.quotePath=false', ...args], {
+  const r = spawnSync('git', ['-C', root, '-c', 'core.quotePath=false', ...args], { windowsHide: true,
     encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
   });
   return r.status === 0 ? (r.stdout || '') : null;

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/session-memory-core.mjs

@@ -48,7 +48,7 @@ function cleanId(value, prefix = 'session') {
 
 function git(cwd, args) {
   try {
-    return { ok: true, out: execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 2 * 1024 * 1024 }).trim() };
+    return { ok: true, out: execFileSync('git', args, { windowsHide: true, cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 2 * 1024 * 1024 }).trim() };
   } catch {
     return { ok: false, out: '' };
   }

package/targets/ship-guard.mjs

@@ -67,7 +67,7 @@ const MERGE = /\bgit\s+merge\b/;
 if (!TRUNK.test(command) && !MERGE.test(command)) allow();
 
 const git = (...args) => {
-  const r = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
+  const r = spawnSync('git', ['-C', root, ...args], { windowsHide: true, encoding: 'utf8' });
   return r.status === 0 ? (r.stdout || '').trim() : null;
 };
 

package/targets/team-safe-start.mjs

@@ -16,7 +16,7 @@ import { existsSync, mkdirSync, realpathSync, writeFileSync } from 'node:fs';
 import { basename, join, sep } from 'node:path';
 
 const git = (root, args) => {
-  try { return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 8000 }).trim(); }
+  try { return execFileSync('git', args, { windowsHide: true, cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 8000 }).trim(); }
   catch { return null; }
 };
 const ok = (root, args) => git(root, args) !== null;

package/targets/trunk-policy.mjs

@@ -28,7 +28,7 @@ const TEAM_COMMITS = 50;
 
 function git(root, args) {
   try {
-    return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000 }).trim();
+    return execFileSync('git', args, { windowsHide: true, cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000 }).trim();
   } catch { return null; }
 }
 

package/targets/update-wiring.js

@@ -19,18 +19,19 @@ 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());
 
 const git = (cwd, args) => {
-  try { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+  try { return execFileSync('git', args, { windowsHide: true, cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
 };
 const rel = (cwd, path) => relative(cwd, path).split(sep).join('/');
 const tracked = (cwd, path) => Boolean(git(cwd, ['ls-files', '--', rel(cwd, path)]));

package/targets/worktree-reaper.mjs

@@ -72,7 +72,7 @@ function git(cwd, args) {
   // 64 MiB, because node's 1 MiB default kills git mid-write on any worktree with a few thousand
   // stray files and hands back a truncated-but-successful-looking result. Measured: in the 1.0-1.15 MB
   // band the same unchanged worktree flipped between verdicts across runs.
-  const r = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  const r = spawnSync('git', ['-C', cwd, ...args], { windowsHide: true, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
   // `raw` matters for porcelain output: its leading space is a status code, not padding, and
   // trimming it shifted every path by one character — so the message naming the file about to be
   // lost named a file that does not exist. A refusal has to be true to be actionable (P6).