codsh-cli 0.2.0 → 0.4.0

package/README.md

@@ -1,77 +1,9 @@
-# codsh
+# codsh-cli
 
-> npm: [`codsh-cli`](https://www.npmjs.com/package/codsh-cli) · command: `codsh`
+The `codsh` command: a **zero-dependency launcher** for [codsh](https://github.com/Blackman99/codsh), a Claude Code-style coding agent for the terminal composed on the DeepSeek Harness (dsh).
 
-English | [中文](README.zh.md)
+This package bundles nothing. It finds the dsh you already have (`DSH_BIN`, a resolvable `@deepseek-ai/dsh`, or `dsh` on PATH), registers the [`codsh-bundle`](https://www.npmjs.com/package/codsh-bundle) runtime into a dsh `code` profile on first run, and boots `dsh --profile code`. No dsh yet? `npm install -g @deepseek-ai/dsh` first.
 
-A terminal coding agent whose interaction design fuses the best of today's agent CLIs, composed on the [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) plugin runtime. codsh is a dsh *bundle*: it ships the interactive TTY surface and a coding agent preset, and everything underneath — the agent loop, tools, sessions, sandboxing, model adapters — is the released dsh packages from npm.
+Set `DSH_BIN=/path/to/dsh` to pin a specific dsh; set `CODSH_BUNDLE_SPEC` to register a bundle other than the launcher's paired `codsh-bundle@^<version>` (development installs use a `file:` tarball here, which the launcher never overwrites).
 
-## Install
-
-```sh
-npm install -g codsh-cli
-codsh
-```
-
-The first run registers this package into a dsh `code` profile under `$DSH_HOME` (default `~/.dsh`) and installs the packaged `code-cli` agent preset; every later run boots straight into the prompt. The model key is read from `DEEPSEEK_API_KEY` (environment or `.env`).
-
-`codsh` is exactly `dsh --profile code` — the wrapper only performs the one-time profile registration. Flags after `codsh` reach the app: `codsh --resume <session-id>`, `codsh --continue`, `codsh -p "one-shot task"`.
-
-## What you get
-
-- **A session that is its own space**: codsh takes the alternate screen, so your shell's scrollback is untouched and waiting when you leave. The transcript scrolls in a buffer the session owns — mouse wheel, PgUp/PgDn, Shift+↑/↓ — under an input box that never moves from the bottom; scrolled back, the viewport says how far and new output keeps accumulating without yanking you to it. Every frame paints as one synchronized update, and quitting drops a two-line summary (session id, spend, the `--resume` command) into your shell.
-- **Select to copy**: drag with the mouse and the selection is on your clipboard the moment you release — highlighted in place, sent through OSC 52 and the platform clipboard both (`CODSH_CLIPBOARD=osc52|system|off` narrows it). Long finished blocks — thinking, tool output, and answers past a screenful — collapse to their head lines once you move on; Ctrl-O swaps every one of them between summary and full form.
-- **An input box that owns the keyboard**: multi-line editing (Alt-Enter), history across sessions, and completion for commands, arguments, and `@`-mentioned files (fuzzy, workspace-wide), opened as you type.
-- **Streaming rendering**: Markdown with code highlighting and table layout, reasoning models' thinking dim under `✻ thinking`, tool calls as presenter-driven cards with diffs, and Ctrl-O to reprint the last clipped output in full.
-- **Decisions as selections**: approvals, questions, `/model`, and `/resume` are arrow-key widgets; plan mode toggles on Shift-Tab and tints the box frame.
-- **Session flow**: `/clear` starts fresh in place, `/resume` picks from recorded sessions with titles and ages, Escape twice recalls your previous message for editing, and `!cmd` runs in your shell with the outcome injected as model-visible context — no turn spent.
-- **Canned prompts**: `/init` drafts an `AGENTS.md`; your own Markdown files under `$DSH_HOME/commands/` or `<workspace>/.dsh/commands/` become slash commands with `$ARGUMENTS` templating.
-- Status line (model, preset, permissions, tokens, context left, branch), terminal-title updates, a bell when a decision waits, and a `--print` mode for scripts.
-
-Off a TTY (pipes, scripts) the same surface degrades to a line reader: selections become typed answers, lists replace widgets, and nothing draws.
-
-## Development
-
-```sh
-pnpm install
-pnpm run dev          # build → sync into .dev-home → boot; seconds per iteration
-MOCK=markdown pnpm run dev    # keyless, against the e2e mock model
-pnpm run build        # tsdown runtime bundles + tsc declarations into lib/
-pnpm run typecheck
-pnpm test             # unit suites (pure modules: editor, markdown, transcript, …)
-pnpm run test:e2e     # packs this repo, registers it into a dsh profile, and
-                      # drives the INSTALLED dsh binary through pipes and a real PTY
-```
-
-`pnpm run dev` keeps a repo-local dsh home in `.dev-home`: the first run does a real profile install of the packed tree, and every later run just copies the fresh `lib/` over the profile's unpacked package — so edits reach the running surface in seconds. `MOCK=<write|bash|slow|markdown|reasoning|echo|tall>` swaps in the keyless e2e model for UI work without a key, arguments pass through (`pnpm run dev -- --resume <id>`), and `INSPECT=1` opens the Node inspector on the app process (`chrome://inspect` or a VS Code attach). Off-TTY logic is easiest to step through piped — `printf 'task\n/exit\n' | MOCK=echo pnpm run dev` — where raw mode and the repaint region are out of the picture; keep `console.*` out of debug prints on a TTY (they tear the managed region) and log to a file instead.
-
-The e2e suites test the release artifact: `npm pack` output installed into a real profile, booted by the dsh launcher from npm, with a keyless mock model. What passes there is what a user installs.
-
-### Debugging against dsh sources
-
-Day to day, dsh is an ordinary npm dependency. To step into harness code, clone [deepseek-harness](https://github.com/deepseek-ai/deepseek-harness) beside this repo, build it (`pnpm install && pnpm run build`), then point the packages you are debugging at the checkout:
-
-```jsonc
-// package.json — remove again when done; keep npm as the default
-"pnpm": {
-  "overrides": {
-    "@deepseek-ai/dsh-agent-loop": "link:../deepseek-harness/packages/core/agent-loop"
-  }
-}
-```
-
-and re-run `pnpm install`. Changes you want upstream go to the harness repo as ordinary PRs; this repository never forks it.
-
-### Keeping up with dsh releases
-
-codsh consumes the harness as published `@deepseek-ai/dsh-*` packages, so "syncing with dsh" means tracking harness **releases**, not merging source. Three layers keep it automatic:
-
-1. **Detect** — [Renovate](renovate.json) watches `@deepseek-ai/dsh-*` (plus co-released cordis packages) and opens dependency PRs; a nightly [sync workflow](.github/workflows/sync-dsh.yml) does the same without third-party services.
-2. **Bump** — `pnpm run sync:dsh` rewrites every `@deepseek-ai/dsh-*` range to the latest published release, refreshes the lockfile, writes a changeset, and exits `1` from `--check` when newer versions exist (that is what the nightly job keys on).
-3. **Prove** — the same command re-verifies `cordis.patch.yml`: every plugin id it disables or configures must still be declared by an installed dsh bundle, and every package it inserts must resolve. Then it runs typecheck/build/unit (add `--e2e` to boot the real patched bundle), and CI repeats all of that on the resulting PR.
-
-Because every dsh package is a prerelease (`0.1.0-rc.N`), plain semver ranges do **not** float across releases — the sync command is the source of truth, not `pnpm update`.
-
-## License
-
-MIT
+Full documentation: [github.com/Blackman99/codsh](https://github.com/Blackman99/codsh)

package/bin/codsh.mjs

@@ -1,61 +1,123 @@
 #!/usr/bin/env node
 /**
- * The `codsh` command: the dsh launcher booted onto the code profile, with
- * this package registered as that profile's bundle on first run.
+ * The `codsh` command: a zero-dependency launcher over the dsh you already
+ * have.
  *
- * dsh owns profiles, plugin installation, and the boot; this wrapper only
- * makes `codsh` a one-command experience — it is exactly
- * `dsh plugin --profile code add <this package>` once, then
- * `dsh --profile code <args>` every time.
+ * This package deliberately bundles NOTHING — the ~300MB dsh runtime lives
+ * once on a machine, not once per tool. The wrapper finds a dsh (`DSH_BIN`,
+ * then a resolvable `@deepseek-ai/dsh` install, then `dsh` on PATH), registers
+ * the `codsh-bundle` runtime into the `code` profile on first run, and boots
+ * `dsh --profile code` with the arguments passed through.
  */
 
 import { spawnSync } from 'node:child_process'
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
-import { homedir, tmpdir } from 'node:os'
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { createRequire } from 'node:module'
 
-const require = createRequire(import.meta.url)
-const ownDir = fileURLToPath(new URL('..', import.meta.url))
-const dshPackage = require.resolve('@deepseek-ai/dsh/package.json')
-const dshBinField = JSON.parse(readFileSync(dshPackage, 'utf8')).bin
-const dshBin = join(dirname(dshPackage), typeof dshBinField === 'string' ? dshBinField : dshBinField.dsh)
-
-/** Whether the code profile already carries this package. */
-function registered() {
-  const home = process.env.DSH_HOME ?? join(homedir(), '.dsh')
-  const manifest = join(home, 'profiles', 'code', 'package.json')
-  if (!existsSync(manifest)) return false
+const requireFromHere = createRequire(import.meta.url)
+const own = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
+
+/** The bundle package this launcher pairs with, lockstep-versioned. */
+const BUNDLE = 'codsh-bundle'
+
+/**
+ * Locate a dsh launcher without carrying one.
+ * @returns how to spawn it, or undefined when the machine has none.
+ */
+function findDsh() {
+  const pinned = process.env.DSH_BIN
+  if (pinned !== undefined && pinned !== '') {
+    // A JS entry runs through this Node; anything else is an executable.
+    return /\.[cm]?js$/.test(pinned)
+      ? { command: process.execPath, prefix: [pinned] }
+      : { command: pinned, prefix: [] }
+  }
   try {
-    const profile = JSON.parse(readFileSync(manifest, 'utf8'))
-    return 'codsh-cli' in (profile.dependencies ?? {})
+    const manifest = requireFromHere.resolve('@deepseek-ai/dsh/package.json')
+    const bin = JSON.parse(readFileSync(manifest, 'utf8')).bin
+    const entry = join(dirname(manifest), typeof bin === 'string' ? bin : bin.dsh)
+    return { command: process.execPath, prefix: [entry] }
   } catch {
-    return false
+    // Not installed beside this package; the PATH is next.
   }
+  const probe = spawnSync('dsh', ['--version'], { stdio: 'ignore', shell: process.platform === 'win32' })
+  if (probe.error === undefined && probe.status !== null) return { command: 'dsh', prefix: [] }
+  return undefined
+}
+
+const dsh = findDsh()
+if (dsh === undefined) {
+  console.error(`codsh: no dsh runtime found. codsh launches the dsh you already have —
+the runtime is not bundled, so a machine never carries a second copy.
+
+  install one:      npm install -g @deepseek-ai/dsh
+  or point at one:  DSH_BIN=/path/to/dsh codsh`)
+  process.exit(1)
+}
+
+/** Run the found dsh with arguments, inheriting the terminal. */
+function run(args) {
+  const result = spawnSync(dsh.command, [...dsh.prefix, ...args], { stdio: 'inherit' })
+  return result.status ?? 1
 }
 
-if (!registered()) {
-  console.error('codsh: registering this package into the dsh code profile (first run)')
-  // A bare directory installs as `link:`, whose dependencies never reach the
-  // profile's resolver. A development checkout (it has node_modules) packs to
-  // the release tarball; an installed copy is clean and `file:` copies it,
-  // with its dependencies resolved by the profile install either way.
-  let spec = `file:${ownDir}`
-  let scratch
-  if (existsSync(join(ownDir, 'node_modules'))) {
-    scratch = mkdtempSync(join(tmpdir(), 'codsh-pack-'))
-    const packed = spawnSync('npm', ['pack', '--pack-destination', scratch], { cwd: ownDir, encoding: 'utf8' })
-    if (packed.status !== 0) {
-      console.error(packed.stderr ?? 'codsh: npm pack failed')
-      process.exit(packed.status ?? 1)
+/** `a > b` for plain x.y.z versions, which is all this pair publishes. */
+function newer(a, b) {
+  const pa = String(a).split('.').map(Number)
+  const pb = String(b).split('.').map(Number)
+  for (let index = 0; index < 3; index += 1) {
+    if ((pa[index] ?? 0) !== (pb[index] ?? 0)) return (pa[index] ?? 0) > (pb[index] ?? 0)
+  }
+  return false
+}
+
+const home = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+const manifestPath = join(home, 'profiles', 'code', 'package.json')
+
+/** What the code profile currently carries, or undefined before first run. */
+function profile() {
+  if (!existsSync(manifestPath)) return undefined
+  try {
+    return JSON.parse(readFileSync(manifestPath, 'utf8'))
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Decide whether — and what — to register into the profile this run.
+ * @returns the spec to `dsh plugin add`, or undefined when nothing is due.
+ */
+function registration() {
+  const spec = process.env.CODSH_BUNDLE_SPEC ?? `${BUNDLE}@^${own.version}`
+  const manifest = profile()
+  const dependencies = manifest?.dependencies ?? {}
+  // The pre-split layout carried the whole runtime under this launcher's own
+  // name; migrate it out so both bundles don't fight over the terminal.
+  if (manifest !== undefined && 'codsh-cli' in dependencies) {
+    console.error('codsh: migrating the profile to the split codsh-bundle runtime')
+    delete manifest.dependencies['codsh-cli']
+    const bundles = manifest?.dsh?.profile?.bundles
+    if (Array.isArray(bundles)) {
+      manifest.dsh.profile.bundles = bundles.filter(name => name !== 'codsh-cli')
     }
-    spec = join(scratch, packed.stdout.trim().split('\n').at(-1) ?? '')
+    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+    return spec
   }
-  const setup = spawnSync(process.execPath, [dshBin, 'plugin', '--profile', 'code', 'add', spec], { stdio: 'inherit' })
-  if (scratch !== undefined) rmSync(scratch, { recursive: true, force: true })
-  if (setup.status !== 0) process.exit(setup.status ?? 1)
+  const current = dependencies[BUNDLE]
+  if (current === undefined) return spec
+  // A file:/link: registration is a development pin; never clobber it.
+  if (!current.startsWith('^')) return undefined
+  return newer(own.version, current.slice(1)) ? spec : undefined
+}
+
+const spec = registration()
+if (spec !== undefined) {
+  console.error(`codsh: registering ${spec} into the dsh code profile`)
+  const status = run(['plugin', '--profile', 'code', 'add', spec])
+  if (status !== 0) process.exit(status)
 }
 
-const run = spawnSync(process.execPath, [dshBin, '--profile', 'code', ...process.argv.slice(2)], { stdio: 'inherit' })
-process.exit(run.status ?? 0)
+process.exit(run(['--profile', 'code', ...process.argv.slice(2)]))

package/package.json

@@ -1,132 +1,24 @@
 {
   "name": "codsh-cli",
-  "description": "A Claude Code-style coding agent for the terminal, composed on the DeepSeek Harness (dsh): interactive TTY surface, plan mode, approvals, custom commands, and session management over the dsh plugin runtime",
-  "version": "0.2.0",
+  "description": "A Claude Code-style coding agent for the terminal, composed on the DeepSeek Harness (dsh). This is the zero-dependency launcher: it finds your dsh, registers the codsh-bundle runtime into a profile, and boots it.",
+  "version": "0.4.0",
   "type": "module",
   "license": "MIT",
   "bin": {
     "codsh": "./bin/codsh.mjs"
   },
-  "main": "lib/index.js",
-  "types": "lib/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "default": "./lib/index.js"
-    },
-    "./startup": {
-      "types": "./lib/types/startup.d.ts",
-      "default": "./lib/startup.js"
-    },
-    "./invariant": {
-      "types": "./lib/types/invariant.d.ts",
-      "default": "./lib/invariant.js"
-    },
-    "./cordis.patch.yml": "./cordis.patch.yml",
-    "./package.json": "./package.json",
-    "./agent-presets/*": "./agent-presets/*"
-  },
   "files": [
-    "lib/index.js",
-    "lib/invariant.js",
-    "lib/startup.js",
     "bin",
-    "cordis.patch.yml",
-    "agent-presets",
-    "lib/types/**/*.d.ts"
+    "README.md"
   ],
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  },
-  "dependencies": {
-    "@deepseek-ai/dsh": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-agent-instructions": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-agent-presets": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-cmdline": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-code-runtime-worker-thread": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-command-compact": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-compaction-basic": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-compaction-tool-result-pruner": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-lsp": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-lsp-stdio": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-persona": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-plan-mode": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-skill-filesystem": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-terminal": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-terminal-bash": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-ask-user": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-bash": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-fs": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-fs-search": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-goal": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-jobs": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-lsp": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-pwsh": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-ralph": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-skill": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-subagent": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-subagent-control": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-terminal": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-todo": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-web": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tool-workflow": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-workflow-worker-thread": "^0.1.0-rc.7",
-    "@deepseek-ai/schemastery": "^3.18.1",
-    "commander": "^15.0.0",
-    "diff": "^9.0.0",
-    "string-width": "^8.2.2"
-  },
-  "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.2",
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-agent-default-model": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-commands": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-permission-presets": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session-query": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-token-meter": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-user-approval": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-user-questions": "^0.1.0-rc.7"
-  },
-  "devDependencies": {
-    "@changesets/cli": "^3.0.0",
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.2",
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-agent-default-model": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-commands": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-permission-presets": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session-query": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-token-meter": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-user-approval": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-user-questions": "^0.1.0-rc.7",
-    "@types/node": "^24.0.0",
-    "execa": "^9.0.0",
-    "tsdown": "^0.15.0",
-    "tsx": "^4.20.0",
-    "typescript": "^5.9.0",
-    "vitest": "^4.0.0"
+  "engines": {
+    "node": ">=22.19"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Blackman99/codsh.git"
+    "url": "git+https://github.com/Blackman99/codsh.git",
+    "directory": "packages/cli"
   },
-  "homepage": "https://github.com/Blackman99/codsh#readme",
-  "bugs": "https://github.com/Blackman99/codsh/issues",
   "keywords": [
     "cli",
     "coding-agent",
@@ -136,16 +28,6 @@
     "ai",
     "agent"
   ],
-  "engines": {
-    "node": ">=22.19"
-  },
-  "scripts": {
-    "build": "tsdown && tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:e2e": "pnpm run build && vitest run --config vitest.e2e.config.ts",
-    "dev": "node scripts/dev.mjs",
-    "sync:dsh": "node scripts/sync-dsh.mjs",
-    "release": "pnpm run build && changeset publish"
-  }
+  "homepage": "https://github.com/Blackman99/codsh#readme",
+  "bugs": "https://github.com/Blackman99/codsh/issues"
 }

package/README.zh.md

@@ -1,76 +0,0 @@
-# codsh
-
-> npm 包名：[`codsh-cli`](https://www.npmjs.com/package/codsh-cli) · 命令：`codsh`
-
-[English](README.md) | 中文
-
-一款汲取了当今主流 agent CLI 交互体验精髓的终端编码 agent，组合在 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（dsh）插件运行时之上。codsh 是一个 dsh *bundle*：它携带交互式 TTY 界面与编码 agent preset，其下的一切——agent 循环、工具、会话、沙箱、模型适配器——都是 npm 上已发布的 dsh 包。
-
-## 安装
-
-```sh
-npm install -g codsh-cli
-codsh
-```
-
-首次运行会把本包注册进 `$DSH_HOME`（默认 `~/.dsh`）下的 dsh `code` profile 并安装自带的 `code-cli` agent preset；之后每次运行直接进入提示符。模型密钥从 `DEEPSEEK_API_KEY` 读取（环境变量或 `.env`）。
-
-`codsh` 严格等价于 `dsh --profile code`——包装器只做一次性的 profile 注册。`codsh` 之后的参数直达应用：`codsh --resume <会话 id>`、`codsh --continue`、`codsh -p "一次性任务"`。
-
-## 你会得到什么
-
-- **会话是自己的空间**：codsh 进入备用屏幕，你的 shell 滚回历史原封不动、退出即恢复。transcript 在会话自有的缓冲里滚动——鼠标滚轮、PgUp/PgDn、Shift+↑/↓——输入框钉在底部从不移动；向上翻阅时视口会标注离尾部多远，新输出继续累积而不把你拽回去。每一帧以同步更新原子绘制；退出时向 shell 留下两行摘要（会话 id、用量、`--resume` 命令）。
-- **接管键盘的输入框**：多行编辑（Alt-Enter）、跨会话历史，命令、参数与 `@` 文件提及（全工作区模糊搜索）的补全随输入自动打开。
-- **流式渲染**：Markdown 带代码高亮与表格排版，推理模型的思考在 `✻ thinking` 下暗色显示，工具调用按 presenter 驱动的卡片渲染（含 diff），Ctrl-O 完整重印最近被截断的输出。
-- **决定用选择**：审批、提问、`/model` 与 `/resume` 都是方向键组件；Shift-Tab 切换 plan 模式并为框着色。
-- **会话流**：`/clear` 原地开新会话，`/resume` 从带标题和时间的会话列表里选，连按两次 Escape 召回上一条消息编辑，`!cmd` 在你自己的 shell 里运行并把结果注入为模型可见上下文——不花回合。
-- **固定 prompt**：`/init` 起草 `AGENTS.md`；`$DSH_HOME/commands/` 或 `<工作区>/.dsh/commands/` 下的 Markdown 文件即成为斜杠命令，支持 `$ARGUMENTS` 模板。
-- 状态行（模型、preset、权限、token、剩余上下文、分支）、终端标题跟随、有决定等待时的铃声，以及面向脚本的 `--print` 模式。
-
-非 TTY 环境（管道、脚本）下同一界面降级为行读取器：选择变为键入回答、组件变为列表、不绘制任何东西。
-
-## 开发
-
-```sh
-pnpm install
-pnpm run dev          # build → 同步进 .dev-home → 启动；秒级迭代
-MOCK=markdown pnpm run dev    # 无 key，对着 e2e mock 模型
-pnpm run build        # tsdown 运行时 bundle + tsc 声明文件，输出到 lib/
-pnpm run typecheck
-pnpm test             # 单测（纯函数模块：editor、markdown、transcript……）
-pnpm run test:e2e     # 打包本仓库、注册进 dsh profile，然后经管道与真实 PTY
-                      # 驱动 npm 安装的 dsh 可执行文件
-```
-
-`pnpm run dev` 在 `.dev-home` 维护一个仓库本地的 dsh home：首次运行对打包后的工作树做一次真实 profile 安装，之后每次只把新构建的 `lib/` 覆盖到 profile 里解包的本包上——改动秒级到达运行中的界面。`MOCK=<write|bash|slow|markdown|reasoning|echo|tall>` 换上 keyless e2e 模型、无 key 调 UI；参数透传（`pnpm run dev -- --resume <id>`）；`INSPECT=1` 在应用进程上打开 Node inspector（`chrome://inspect` 或 VS Code attach）。逻辑问题优先用管道形态单步——`printf 'task\n/exit\n' | MOCK=echo pnpm run dev`——那里没有 raw mode 和重绘区域的干扰；在 TTY 上调试不要用 `console.*` 打点（会撕裂受管理区域），改写文件日志。
-
-e2e 测试的是发布产物：`npm pack` 的输出装进真实 profile，由 npm 上的 dsh launcher 启动，配 keyless mock 模型。那里通过的就是用户装到的。
-
-### 对着 dsh 源码调试
-
-日常里 dsh 是普通的 npm 依赖。需要单步进 harness 代码时，把 [deepseek-harness](https://github.com/deepseek-ai/deepseek-harness) clone 到本仓库旁边并构建（`pnpm install && pnpm run build`），然后把要调试的包指向 checkout：
-
-```jsonc
-// package.json —— 调完删掉；npm 始终是默认
-"pnpm": {
-  "overrides": {
-    "@deepseek-ai/dsh-agent-loop": "link:../deepseek-harness/packages/core/agent-loop"
-  }
-}
-```
-
-再执行 `pnpm install`。想进上游的改动以普通 PR 提交到 harness 仓库；本仓库绝不 fork 它。
-
-### 跟随 dsh 发布版本
-
-codsh 消费的是已发布的 `@deepseek-ai/dsh-*` npm 包，所以"与 dsh 同步"跟踪的是 harness 的**发布**，不是合并源码。三层机制让这件事全自动：
-
-1. **发现**——[Renovate](renovate.json) 盯着 `@deepseek-ai/dsh-*`（及同步发布的 cordis 包）自动开依赖 PR；[夜间 sync 工作流](.github/workflows/sync-dsh.yml) 不依赖第三方服务也能做同样的事。
-2. **升级**——`pnpm run sync:dsh` 把所有 `@deepseek-ai/dsh-*` 范围改写到最新发布版、刷新锁文件、写 changeset；`--check` 模式在存在新版本时以退出码 1 报告（夜间任务就靠它判断）。
-3. **验证**——同一命令重新核对 `cordis.patch.yml`：每个被禁用/配置的插件 id 必须仍被已安装的 dsh bundle 声明，每个 insert 的包必须可解析；然后跑 typecheck/build/单测（加 `--e2e` 会真正启动打补丁后的 bundle），CI 在生成的 PR 上再全部跑一遍。
-
-因为所有 dsh 包都是预发布版本（`0.1.0-rc.N`），普通 semver 范围**不会**跨版本浮动——同步命令才是事实来源，`pnpm update` 不是。
-
-## 许可
-
-MIT