dsh-git-idea 0.1.0

package/lib/index.js

@@ -0,0 +1,2701 @@
+/* GENERATED by build-package.mjs from 13 fragments under src/ — edit those, not this file. */
+/* ── the real-package Host half ──
+
+   The fragments under src/host/ were written for the dynamic Cordis bridge:
+   that realm handed the plugin a \`harness\` (\`defineTool\` / \`registerTool\` /
+   \`handle\`) and a façade \`ctx\`. A real package gets neither, so this prelude
+   supplies the same three ways to speak over the services a real \`ctx\` has.
+   The body after it is the same text the dynamic bridge loads — one body, two
+   builds — and host-post.js exports the plugin object. */
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+/* The one route the browser half calls: same origin as the page, so no CORS.
+   The same-origin check below is what keeps another page on loopback from
+   driving git in this reader's working directory. */
+const RPC_PATH = '/dsh-git-idea/rpc'
+const RPC_MAX_BYTES = 1048576
+
+/* Every handler the Client registered through \`harness.handle\`, keyed by the
+   method string it passed to \`host.call\`. */
+const rpcHandlers = new Map()
+
+function detail(error) {
+  return error != null && error.message !== undefined ? String(error.message) : String(error)
+}
+
+function sendJson(response, status, payload) {
+  response.writeHead(status, {
+    'cache-control': 'no-store',
+    'content-type': 'application/json; charset=utf-8',
+  })
+  response.end(JSON.stringify(payload))
+}
+
+/* Required on every POST: the port is reachable from any page on this machine,
+   and these methods run git in the reader's own working directory. */
+function sameOrigin(request) {
+  const origin = request.headers.origin
+  const host = request.headers.host
+  if (origin === undefined || host === undefined) return false
+  try {
+    return new URL(origin).host === host
+  } catch (error) {
+    return false
+  }
+}
+
+async function readJsonBody(request) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    size += buffer.length
+    if (size > RPC_MAX_BYTES) throw new Error('request body too large')
+    chunks.push(buffer)
+  }
+  const text = Buffer.concat(chunks).toString('utf8')
+  return text.length === 0 ? null : JSON.parse(text)
+}
+
+/* The dynamic bridge refused an unregistered method with "... is not
+   registered", and 10-state.js retries exactly that sentence while the Host
+   half is still coming up. The 404 below keeps the same words, so that retry
+   survives the move to a real package. */
+async function rpcRoute(request, response) {
+  if (request.method !== 'POST') {
+    sendJson(response, 405, { ok: false, error: 'rpc is POST only' })
+    return
+  }
+  if (!sameOrigin(request)) {
+    sendJson(response, 403, { ok: false, error: 'same-origin requests only' })
+    return
+  }
+  let body
+  try {
+    body = await readJsonBody(request)
+  } catch (error) {
+    sendJson(response, 400, { ok: false, error: detail(error) })
+    return
+  }
+  const method = body != null && typeof body.method === 'string' ? body.method : ''
+  const handler = rpcHandlers.get(method)
+  if (handler === undefined) {
+    sendJson(response, 404, { ok: false, error: method + ' is not registered' })
+    return
+  }
+  try {
+    const value = await handler(body.payload)
+    sendJson(response, 200, { ok: true, value: value === undefined ? null : value })
+  } catch (error) {
+    sendJson(response, 200, { ok: false, error: detail(error) })
+  }
+}
+
+const harness = {
+  defineTool: function (options) { return defineTool(options) },
+  registerTool: function (ctx, tool) { return ctx.tools.register(tool) },
+  handle: function (method, handler) {
+    rpcHandlers.set(method, handler)
+    return function () { rpcHandlers.delete(method) }
+  },
+}
+
+export const name = 'dsh-git-idea'
+
+const plugin = (function () {
+return {
+  apply(ctx) {
+
+const shell = ctx.get('shell')
+if (shell === undefined) {
+  console.error('git plugin: the shell Service is unavailable; no tools registered')
+  return
+}
+
+/* ─────────────── primitives ─────────────── */
+
+function shq(value) {
+  return "'" + String(value).replace(/'/g, "'\\''") + "'"
+}
+
+function isStr(value) {
+  return typeof value === 'string'
+}
+
+/* One field of a record git printed as a separated line. A field git had nothing
+   to put in is simply absent from the split, and every reader wants the same
+   thing there: the empty string, never `undefined` leaking into a reply the
+   Client will render. Longhand this is `fields[3] === undefined ? '' : fields[3]`
+   — a forty-two times repeated question, asked once here. */
+function field(split, index) {
+  const value = split[index]
+  return value === undefined ? '' : value
+}
+
+function sessionCwd(exec) {
+  if (exec == null || exec.agent == null) return undefined
+  const session = exec.agent.session
+  const header = session != null ? session.header : undefined
+  const cwd = header != null ? header.cwd : undefined
+  return isStr(cwd) && cwd.length > 0 ? cwd : undefined
+}
+
+function workdirFor(args, exec) {
+  if (args != null && isStr(args.repo) && args.repo.trim().length > 0) return args.repo.trim()
+  return sessionCwd(exec)
+}
+
+function here(args, exec) {
+  const cwd = workdirFor(args, exec)
+  return cwd === undefined ? null : cwd
+}
+
+/* ── whose sandbox these commands run under ──
+
+   A shell call that names no policy gets the *deployment* default, not the
+   session's. Measured on this deployment: the default is `workspace-write` rooted
+   at the deployment's own directory (/mnt/c/Users/mayou here) while the session is
+   `danger-full-access` — so every writing git command failed with "Permission
+   denied" on `.git/index.lock` for any repository outside that one directory,
+   while reads were fine and it looked like git refusing to work.
+
+   The session's mode and its cwd are exactly what the reader's own commands run
+   under, so they are what this plugin asks for: `sessions` says which session,
+   `sandboxPolicy` says what that session resolved to, and a session that is
+   read-only keeps this plugin read-only. Without either service the request goes
+   out unchanged and the shell layer falls back as before. */
+function sandboxFor(args, exec) {
+  const policy = ctx.get('sandboxPolicy')
+  if (policy === undefined) return undefined
+  let session = null
+  try {
+    if (exec != null && exec.agent != null && exec.agent.session != null) {
+      session = exec.agent.session
+    } else if (args != null && isStr(args.sessionId) && args.sessionId.length > 0) {
+      const sessions = ctx.get('sessions')
+      if (sessions !== undefined) session = sessions.get(args.sessionId)
+    }
+    if (session == null) return undefined
+    const resolved = policy.resolve({ session: session })
+    return resolved == null ? undefined : resolved
+  } catch (error) {
+    console.error('dsh-git-idea: could not resolve this session\'s sandbox policy', String(error))
+    return undefined
+  }
+}
+
+async function invoke(command, args, exec, options) {
+  const opts = options == null ? {} : options
+  const request = {
+    command: command,
+    timeoutMs: typeof opts.timeoutMs === 'number' && opts.timeoutMs > 0 ? opts.timeoutMs : 120000,
+    stdoutMaxBytes: typeof opts.maxBytes === 'number' ? opts.maxBytes : 1048576,
+  }
+  const workdir = workdirFor(args, exec)
+  if (workdir !== undefined) request.workdir = workdir
+  if (isStr(opts.stdin)) request.stdin = opts.stdin
+  const sandbox = sandboxFor(args, exec)
+  if (sandbox !== undefined) request.sandboxPolicy = sandbox
+  const raw = await shell.run(shell.resolve(request))
+  const out = raw.stdout == null ? null : raw.stdout
+  const err = raw.stderr == null ? null : raw.stderr
+  return {
+    exitCode: raw.exitCode == null ? null : raw.exitCode,
+    stdout: out !== null && isStr(out.text) ? out.text : '',
+    stderr: err !== null && isStr(err.text) ? err.text : '',
+    truncated: (out !== null && out.truncated === true) || (err !== null && err.truncated === true),
+    spillPath: out !== null && isStr(out.spillPath) ? out.spillPath : null,
+    timedOut: raw.timedOut === true,
+    aborted: raw.aborted === true,
+    sandboxDenied: raw.sandbox != null && raw.sandbox.denied === true,
+    cwd: workdir === undefined ? null : workdir,
+  }
+}
+
+/* The three wrappers differ only in what they put in front of the command: the
+   package prefix is the whole of the difference, so it is the only argument. */
+async function shellGit(prefix, args, argv, exec, options) {
+  const result = await invoke(prefix + 'git ' + argv.map(shq).join(' '), args, exec, options)
+  result.command = 'git ' + argv.join(' ')
+  result.ok = result.exitCode === 0
+  return result
+}
+
+async function git(args, argv, exec, options) {
+  return await shellGit('', args, argv, exec, options)
+}
+
+/* Network commands must never sit waiting for a credential prompt: the panel has
+   no terminal to answer one, so the call would hang until its timeout fires. */
+async function gitNet(args, argv, exec, options) {
+  return await shellGit('GIT_TERMINAL_PROMPT=0 GIT_ASKPASS=true ', args, argv, exec, options)
+}
+
+/* for-each-ref's %(upstream:track) is the one atom git translates. The switcher
+   shows the numbers out of it, so the words around them have to be predictable
+   rather than whatever locale the machine happens to use. */
+async function gitC(args, argv, exec, options) {
+  return await shellGit('LC_ALL=C ', args, argv, exec, options)
+}
+
+/* ─────────────── safety classification ─────────────── */
+
+const READ_ONLY_SUBCOMMANDS = [
+  'status', 'diff', 'log', 'show', 'blame', 'grep', 'shortlog', 'describe',
+  'rev-parse', 'rev-list', 'ls-files', 'ls-tree', 'cat-file', 'for-each-ref',
+  'show-ref', 'diff-tree', 'diff-index', 'diff-files', 'merge-base', 'name-rev',
+  'symbolic-ref', 'var', 'version', 'check-ignore', 'check-attr', 'whatchanged',
+  'range-diff', 'cherry', 'fsck', 'count-objects', 'verify-commit', 'verify-tag',
+]
+
+const PROTECTED_BRANCHES = ['main', 'master']
+
+function scanArgv(argv) {
+  let index = 0
+  while (index < argv.length) {
+    const token = argv[index]
+    if (token === '-C' || token === '-c' || token === '--git-dir' || token === '--work-tree'
+      || token === '--namespace' || token === '--exec-path' || token === '--config-env') {
+      index += 2
+      continue
+    }
+    if (isStr(token) && token.length > 1 && token.charAt(0) === '-') {
+      index += 1
+      continue
+    }
+    break
+  }
+  return { sub: argv[index], rest: argv.slice(index + 1) }
+}
+
+function hasAny(list, names) {
+  for (let i = 0; i < names.length; i += 1) if (list.indexOf(names[i]) >= 0) return true
+  return false
+}
+
+function shortFlag(list, letters) {
+  for (let i = 0; i < list.length; i += 1) {
+    const token = list[i]
+    if (!isStr(token) || token.length < 2 || token.charAt(0) !== '-' || token.charAt(1) === '-') continue
+    const body = token.slice(1)
+    for (let j = 0; j < letters.length; j += 1) if (body.indexOf(letters[j]) >= 0) return letters[j]
+  }
+  return null
+}
+
+function refspecTargetsProtected(refspec) {
+  let spec = refspec.charAt(0) === '+' ? refspec.slice(1) : refspec
+  const colon = spec.lastIndexOf(':')
+  if (colon >= 0) spec = spec.slice(colon + 1)
+  return isProtectedBranch(spec)
+}
+
+/* "main", "heads/main" and "refs/heads/main" are one ref written three ways, and
+   git accepts all three. Only the longest spelling was recognised here, so a
+   force push written `-f origin heads/main` classified as merely destructive
+   instead of forbidden — the rule read as if it held while the ref it names went
+   through. */
+function bareBranchName(name) {
+  let spec = name
+  if (spec.indexOf('refs/') === 0) spec = spec.slice('refs/'.length)
+  if (spec.indexOf('heads/') === 0) spec = spec.slice('heads/'.length)
+  return spec
+}
+
+function isProtectedBranch(name) {
+  return PROTECTED_BRANCHES.indexOf(bareBranchName(name)) >= 0
+}
+
+/* ── a value is not an option ──
+
+   The structured tools hand caller strings straight into git's argv: a revision,
+   a path, a remote, a branch name. A string that starts with "-" is not that
+   value any more — git reads it as an option and the tool does something else
+   entirely. Measured on this deployment: `git_sync` with branch "--force" ran
+   `git push origin --force` (a force push with no confirmation), `git_log` with
+   ref "--output=/tmp/x" wrote an empty log to that path and returned nothing, and
+   `git_branch` with name "--force" ran `git branch --force`. The escape hatch
+   has a classifier for this because its argv is open-ended; the named arguments
+   here only need the one rule. */
+function optionLike(fields) {
+  for (let i = 0; i < fields.length; i += 1) {
+    const value = fields[i][1]
+    if (isStr(value) && value.length > 0 && value.charAt(0) === '-') {
+      return {
+        field: fields[i][0],
+        value: value,
+        reason: fields[i][0] + ' may not start with "-" (' + value + ' would be read by git as an option, not as a value)',
+      }
+    }
+  }
+  return null
+}
+
+/* ── a path that stays inside the repository ──
+
+   Every path the panel sends is one git itself listed, so it is relative to the
+   work-tree root. Three of the four diff reads pass it as a pathspec, which git
+   keeps inside the repository on its own. The untracked read cannot: it is
+   `git diff --no-index -- /dev/null <path>`, and that command reads whatever the
+   path names. Measured here, an absolute path came back with the contents of
+   /etc/hostname — a file no reader of a git panel asked for. So anything
+   absolute, or stepping up with "..", is refused rather than resolved. */
+function repoRelativePath(path) {
+  if (!isStr(path) || path.length === 0) return 'path is required'
+  if (path.charAt(0) === '/' || path.charAt(0) === '\\') return 'path must be relative to the repository root'
+  if (path.length > 1 && path.charAt(1) === ':') return 'path must be relative to the repository root'
+  if (path.indexOf('\u0000') >= 0) return 'path may not contain a NUL byte'
+  const parts = path.split(/[\\/]/)
+  for (let i = 0; i < parts.length; i += 1) {
+    if (parts[i] === '..') return 'path may not step outside the repository'
+  }
+  return ''
+}
+
+function classify(argv) {
+  const scan = scanArgv(argv)
+  const sub = scan.sub
+  const rest = scan.rest
+  if (sub === undefined) return { level: 'read', why: '' }
+
+  if (sub === 'filter-branch' || sub === 'filter-repo') {
+    return { level: 'forbidden', why: sub + ' rewrites published history and is never allowed through this tool' }
+  }
+  if (sub === 'update-ref' && hasAny(rest, ['-d', '--delete'])) {
+    return { level: 'forbidden', why: 'update-ref -d deletes refs directly, bypassing every safety net' }
+  }
+  if (sub === 'reflog' && rest[0] === 'expire') {
+    return { level: 'forbidden', why: 'reflog expire destroys the log that makes mistakes recoverable' }
+  }
+  if (sub === 'gc' && rest.some(function (token) { return isStr(token) && token.indexOf('--prune') === 0 })) {
+    return { level: 'forbidden', why: 'gc --prune destroys unreachable objects permanently' }
+  }
+
+  const reasons = []
+  if (sub === 'reset' && hasAny(rest, ['--hard'])) reasons.push('reset --hard discards working-tree changes')
+  if (sub === 'clean' && (hasAny(rest, ['-f', '--force']) || shortFlag(rest, 'f') !== null)) reasons.push('clean -f deletes untracked files')
+  if (sub === 'checkout' && (hasAny(rest, ['-f', '--force']) || shortFlag(rest, 'f') !== null)) reasons.push('checkout --force discards local changes')
+  if ((sub === 'checkout' || sub === 'restore') && rest.indexOf('.') >= 0) reasons.push('restoring "." discards every working-tree change')
+  if (sub === 'switch' && hasAny(rest, ['-f', '--force', '--discard-changes'])) reasons.push('switch --force discards local changes')
+  if (sub === 'branch' && (shortFlag(rest, 'D') !== null || (hasAny(rest, ['--delete']) && hasAny(rest, ['--force'])))) reasons.push('force-deleting a branch discards unmerged commits')
+  if (sub === 'stash' && rest[0] === 'clear') reasons.push('stash clear drops every stash entry')
+  if (sub === 'stash' && rest[0] === 'drop') reasons.push('stash drop discards a stash entry')
+  if (sub === 'reflog' && rest[0] === 'delete') reasons.push('reflog delete removes recovery entries')
+  if (sub === 'worktree' && rest[0] === 'remove' && hasAny(rest, ['-f', '--force'])) reasons.push('worktree remove --force deletes a worktree that still has changes')
+  if (sub === 'submodule' && rest[0] === 'deinit' && hasAny(rest, ['-f', '--force'])) reasons.push('submodule deinit --force removes a submodule checkout')
+  if (sub === 'tag' && hasAny(rest, ['-d', '--delete'])) reasons.push('deleting a tag removes a published reference')
+  if (argv.indexOf('--no-verify') >= 0) reasons.push('--no-verify skips the repository hooks')
+
+  if (sub === 'push') {
+    const positional = rest.filter(function (token) { return isStr(token) && token.charAt(0) !== '-' })
+    const refspecs = positional.slice(1)
+    const forced = hasAny(rest, ['--force', '--mirror']) || shortFlag(rest, 'f') !== null
+    const leased = rest.some(function (token) { return isStr(token) && token.indexOf('--force-with-lease') === 0 })
+    const deleting = hasAny(rest, ['--delete']) || refspecs.some(function (token) { return token.charAt(0) === ':' })
+    if (forced && refspecs.some(refspecTargetsProtected)) {
+      return { level: 'forbidden', why: 'force-pushing to a protected branch (main/master) is never allowed' }
+    }
+    if (forced) reasons.push('push --force overwrites remote history')
+    if (leased) reasons.push('push --force-with-lease overwrites remote history')
+    if (deleting) reasons.push('push --delete removes a remote reference')
+    if (refspecs.some(function (token) { return token.charAt(0) === '+' })) reasons.push('a "+" refspec forces the remote update')
+  }
+
+  if (reasons.length > 0) return { level: 'destructive', why: reasons.join('; ') }
+  if (READ_ONLY_SUBCOMMANDS.indexOf(sub) >= 0) return { level: 'read', why: '' }
+  return { level: 'write', why: '' }
+}
+
+/* ─────────────── renderers ─────────────── */
+
+/* The header every renderer prints when a git command came back non-zero. Three
+   of them wrote it out by hand. */
+function renderCommandFailure(title, value) {
+  const stderr = isStr(value.stderr) ? value.stderr.replace(/\n+$/, '') : ''
+  return title + ' failed in ' + String(value.cwd) + '\n' + stderr + '\n[exit code: ' + String(value.exitCode) + ']'
+}
+
+function renderPassthrough(value) {
+  const lines = ['$ ' + value.command]
+  if (value.cwd !== null) lines.push('cwd: ' + value.cwd)
+  if (value.blocked === 'invalid-args') {
+    lines.push('INVALID ARGUMENTS: ' + value.reason)
+    lines.push('Nothing was executed.')
+    return lines.join('\n')
+  }
+  if (value.blocked === 'forbidden') {
+    lines.push('BLOCKED by git plugin policy: ' + value.reason)
+    return lines.join('\n')
+  }
+  if (value.blocked === 'confirmation-required') {
+    lines.push('CONFIRMATION REQUIRED: ' + value.reason)
+    lines.push('Nothing was executed. Re-call with confirm: true only if this destructive operation is really intended.')
+    return lines.join('\n')
+  }
+  /* Guarded rather than assumed: three of the refusal paths above return no
+     stdout at all, and a renderer that throws takes the answer with it. */
+  const out = isStr(value.stdout) ? value.stdout.replace(/\n+$/, '') : ''
+  const err = isStr(value.stderr) ? value.stderr.replace(/\n+$/, '') : ''
+  if (out.length > 0) lines.push(out)
+  if (err.length > 0) lines.push('[stderr]\n' + err)
+  if (out.length === 0 && err.length === 0) lines.push('(no output)')
+  lines.push('[exit code: ' + String(value.exitCode) + ']')
+  if (value.timedOut === true) lines.push('(timed out)')
+  if (value.sandboxDenied === true) lines.push('(denied by the file sandbox)')
+  if (value.truncated === true) lines.push('(output truncated' + (value.spillPath !== null ? '; full output at ' + value.spillPath : '') + ')')
+  return lines.join('\n')
+}
+
+function renderOutcome(value, title) {
+  const lines = [title]
+  if (value.cwd !== undefined && value.cwd !== null) lines.push('cwd: ' + String(value.cwd))
+  if (value.blocked === 'forbidden') { lines.push('BLOCKED by git plugin policy: ' + value.reason); return lines.join('\n') }
+  if (value.blocked === 'confirmation-required') {
+    lines.push('CONFIRMATION REQUIRED: ' + value.reason)
+    lines.push('Nothing was executed. Re-call with confirm: true only if this is really intended.')
+    return lines.join('\n')
+  }
+  const out = isStr(value.stdout) ? value.stdout.replace(/\n+$/, '') : ''
+  const err = isStr(value.stderr) ? value.stderr.replace(/\n+$/, '') : ''
+  if (value.ok === true) {
+    if (out.length > 0) lines.push(out)
+    if (err.length > 0) lines.push('[stderr]\n' + err)
+    if (out.length === 0 && err.length === 0) lines.push('ok')
+    return lines.join('\n')
+  }
+  if (err.length > 0) lines.push(err)
+  if (out.length > 0) lines.push(out)
+  lines.push('[exit code: ' + String(value.exitCode) + ']')
+  return lines.join('\n')
+}
+
+const STATUS_LABELS = {
+  M: 'modified', A: 'added', D: 'deleted', R: 'renamed', C: 'copied',
+  T: 'typechange', U: 'unmerged', '.': 'unchanged',
+}
+
+function statusLabel(code) {
+  return STATUS_LABELS[code] === undefined ? code : STATUS_LABELS[code]
+}
+
+function parseStatusV2(stdout) {
+  const parsed = {
+    branch: null, detached: false, upstream: null, ahead: 0, behind: 0,
+    staged: [], unstaged: [], untracked: [], unmerged: [],
+  }
+  const lines = stdout.split('\n')
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i]
+    if (line.length === 0) continue
+    if (line.charAt(0) === '#') {
+      const head = line.slice(2)
+      const space = head.indexOf(' ')
+      const key = space < 0 ? head : head.slice(0, space)
+      const rest = space < 0 ? '' : head.slice(space + 1)
+      if (key === 'branch.head') {
+        if (rest === '(detached)') parsed.detached = true
+        else parsed.branch = rest
+      } else if (key === 'branch.upstream') {
+        parsed.upstream = rest
+      } else if (key === 'branch.ab') {
+        const parts = rest.split(' ')
+        if (parts.length === 2) {
+          parsed.ahead = parseInt(parts[0].slice(1), 10) || 0
+          parsed.behind = parseInt(parts[1].slice(1), 10) || 0
+        }
+      }
+      continue
+    }
+    const marker = line.charAt(0)
+    if (marker === '?') { parsed.untracked.push(line.slice(2)); continue }
+    if (marker === '!') continue
+    if (marker === '1' || marker === '2' || marker === 'u') {
+      const fields = line.split(' ')
+      const xy = fields[1] === undefined ? '..' : fields[1]
+      let path = ''
+      if (marker === '1') path = fields.slice(8).join(' ')
+      else if (marker === '2') path = fields.slice(9).join(' ').split('\t')[0]
+      else path = fields.slice(10).join(' ')
+      const entry = { path: path, code: xy, label: statusLabel(xy.charAt(0)) + '/' + statusLabel(xy.charAt(1)) }
+      if (marker === 'u') { parsed.unmerged.push(entry); continue }
+      if (xy.charAt(0) !== '.') parsed.staged.push(entry)
+      if (xy.charAt(1) !== '.') parsed.unstaged.push(entry)
+    }
+  }
+  return parsed
+}
+
+function renderStatus(value) {
+  if (value.ok !== true) return renderCommandFailure('git status', value)
+  const lines = []
+  lines.push('repo:      ' + String(value.cwd))
+  const head = value.detached === true ? '(detached HEAD)' : String(value.branch)
+  const track = value.upstream === null ? '' : ' -> ' + value.upstream + '  ahead ' + String(value.ahead) + ', behind ' + String(value.behind)
+  lines.push('branch:    ' + head + track)
+  if (value.unmerged.length > 0) {
+    lines.push('conflicts: ' + String(value.unmerged.length))
+    for (let i = 0; i < value.unmerged.length; i += 1) lines.push('  ' + value.unmerged[i].code + '  ' + value.unmerged[i].path)
+  }
+  lines.push('staged:    ' + String(value.staged.length))
+  for (let i = 0; i < value.staged.length; i += 1) lines.push('  ' + value.staged[i].code + '  ' + value.staged[i].path)
+  lines.push('unstaged:  ' + String(value.unstaged.length))
+  for (let i = 0; i < value.unstaged.length; i += 1) lines.push('  ' + value.unstaged[i].code + '  ' + value.unstaged[i].path)
+  lines.push('untracked: ' + String(value.untracked.length))
+  for (let i = 0; i < value.untracked.length; i += 1) lines.push('  ??  ' + value.untracked[i])
+  if (value.clean === true) lines.push('working tree clean')
+  return lines.join('\n')
+}
+
+function renderLog(value) {
+  if (value.ok !== true) return renderCommandFailure('git log', value)
+  if (value.commits.length === 0) return 'no commits matched in ' + String(value.cwd)
+  const lines = []
+  for (let i = 0; i < value.commits.length; i += 1) {
+    const entry = value.commits[i]
+    const refs = entry.refs.length > 0 ? '  (' + entry.refs + ')' : ''
+    lines.push(entry.short + '  ' + entry.date + '  ' + entry.author + '  ' + entry.subject + refs)
+  }
+  return lines.join('\n')
+}
+
+function renderDiff(value) {
+  if (value.ok !== true) return renderCommandFailure('git diff', value)
+  const lines = ['diff mode: ' + value.mode, 'cwd: ' + String(value.cwd), 'changed files: ' + String(value.paths.length)]
+  for (let i = 0; i < value.paths.length; i += 1) lines.push('  ' + value.paths[i])
+  if (value.note !== null) lines.push('note: ' + value.note)
+  if (value.cardAvailable === true) lines.push('(a native diff card is attached to this call)')
+  if (value.truncated === true) lines.push('(some file content was truncated in the card)')
+  if (value.patch !== null) { lines.push(''); lines.push(value.patch.replace(/\n+$/, '')) }
+  return lines.join('\n')
+}
+
+function renderBranches(value) {
+  if (value.ok !== true) return renderOutcome(value, 'git branch')
+  const lines = ['current: ' + (value.current === null ? '(detached or unknown)' : value.current)]
+  for (let i = 0; i < value.branches.length; i += 1) {
+    const entry = value.branches[i]
+    const track = entry.upstream.length > 0 ? ' -> ' + entry.upstream : ''
+    lines.push((entry.current ? '* ' : '  ') + entry.name + track + (entry.subject.length > 0 ? '  ' + entry.subject : ''))
+  }
+  return lines.join('\n')
+}
+
+function renderStashes(value) {
+  if (value.ok !== true) return renderOutcome(value, 'git stash')
+  if (value.stashes.length === 0) return 'no stash entries'
+  const lines = []
+  for (let i = 0; i < value.stashes.length; i += 1) {
+    const entry = value.stashes[i]
+    lines.push(entry.ref + '  ' + entry.date + '  ' + entry.subject)
+  }
+  return lines.join('\n')
+}
+
+/* ─────────────── diff helpers ─────────────── */
+
+function parseNulList(stdout) {
+  const parts = stdout.split('\u0000')
+  const out = []
+  for (let i = 0; i < parts.length; i += 1) if (parts[i].length > 0) out.push(parts[i])
+  return out
+}
+
+function capText(text) {
+  const lines = text.split('\n')
+  if (lines.length > 4000) return { text: lines.slice(0, 4000).join('\n'), cut: true }
+  if (text.length > 300000) return { text: text.slice(0, 300000), cut: true }
+  return { text: text, cut: false }
+}
+
+/* A path is data, and `cat <path>` did not treat it as data: a file called `-n`
+   is an option to cat, so the card showed it as empty rather than as itself.
+   (`:./path` would be the other half of this — except that git already resolves
+   `:<path>` correctly even when the path contains a colon, and `./` would break
+   the case where the repository path is a subdirectory, so the spec is left as
+   git's plain `:<path>` form.) */
+async function readBlob(args, spec, exec) {
+  const result = await git(args, ['show', spec], exec, { maxBytes: 400000 })
+  if (result.exitCode !== 0) return null
+  return result.stdout
+}
+
+async function readWorktreeFile(args, path, exec) {
+  const result = await invoke('cat -- ' + shq(path), args, exec, { maxBytes: 400000 })
+  if (result.exitCode !== 0) return null
+  return result.stdout
+}
+
+const CARD_TOTAL_LIMIT = 500000
+
+/* ─────────────── tool registration ─────────────── */
+
+function define(name, definition) {
+  definition.name = name
+  ctx.effect(function () {
+    return harness.registerTool(ctx, harness.defineTool(definition))
+  }, 'dsh-git-idea tool ' + name)
+}
+
+define('git', {
+  description: 'Run any git command as a token array: the complete escape hatch behind the structured git_* tools. There is no argument allowlist, so every git subcommand works (clone, init, worktree, submodule, bisect, tag, merge, rebase, cherry-pick, revert, blame, gc, ...). Destructive commands are refused unless confirm: true is also passed. Always check the reported exit code.',
+  parameters: {
+    args: {
+      type: 'array',
+      items: { type: 'string' },
+      required: true,
+      description: 'git arguments as separate tokens, WITHOUT the leading "git". Example: ["log", "--oneline", "-n", "5"].',
+    },
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+    stdin: { type: 'string', description: 'Text piped to git standard input.' },
+    timeoutMs: { type: 'number', description: 'Timeout in milliseconds. Default 120000.' },
+    confirm: { type: 'boolean', description: 'Must be true to allow a destructive command. Without it the command is refused and nothing runs.' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) { return [{ type: 'text', text: renderPassthrough(value) }] },
+  },
+  isConcurrencySafe: function (args) {
+    return classify(Array.isArray(args.args) ? args.args.filter(isStr) : []).level === 'read'
+  },
+  execute: async function (args, exec) {
+    const argv = Array.isArray(args.args) ? args.args.filter(isStr) : []
+    const cwd = here(args, exec)
+    if (argv.length === 0) {
+      return { ok: false, blocked: 'invalid-args', reason: 'args must hold at least one git token, e.g. ["status"]', command: 'git', cwd: cwd }
+    }
+    const verdict = classify(argv)
+    if (verdict.level === 'forbidden') {
+      return { ok: false, blocked: 'forbidden', reason: verdict.why, command: 'git ' + argv.join(' '), cwd: cwd }
+    }
+    if (verdict.level === 'destructive' && args.confirm !== true) {
+      return { ok: false, blocked: 'confirmation-required', reason: verdict.why, command: 'git ' + argv.join(' '), cwd: cwd }
+    }
+    const options = {}
+    if (isStr(args.stdin)) options.stdin = args.stdin
+    if (typeof args.timeoutMs === 'number') options.timeoutMs = args.timeoutMs
+    return await git(args, argv, exec, options)
+  },
+})
+
+define('git_status', {
+  description: 'Structured repository status: current branch, detached state, upstream, ahead/behind counts, and the staged, unstaged, untracked and unmerged file lists. Reads git status --porcelain=v2, so it is stable across git versions.',
+  parameters: {
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) { return [{ type: 'text', text: renderStatus(value) }] },
+  },
+  isConcurrencySafe: function () { return true },
+  execute: async function (args, exec) {
+    /* A read must not take .git/index.lock: `git status` would happily refresh
+       the index cache, and a tool call that overlaps anyone else's `git add`
+       makes THEIR command fail with "Unable to create index.lock". */
+    const result = await git(args, ['--no-optional-locks', '-c', 'core.quotePath=false', 'status', '--porcelain=v2', '--branch', '--untracked-files=all'], exec, {})
+    if (result.exitCode !== 0) {
+      return { ok: false, cwd: result.cwd, exitCode: result.exitCode, stderr: result.stderr, error: 'not-a-repository' }
+    }
+    const parsed = parseStatusV2(result.stdout)
+    parsed.ok = true
+    parsed.cwd = result.cwd
+    parsed.exitCode = result.exitCode
+    parsed.clean = parsed.staged.length === 0 && parsed.unstaged.length === 0 && parsed.untracked.length === 0 && parsed.unmerged.length === 0
+    parsed.stderr = result.stderr
+    return parsed
+  },
+})
+
+define('git_log', {
+  description: 'Structured commit history: hash, short hash, author, ISO date, subject line and the refs each commit carries. Supports a revision range, a path filter and a result cap.',
+  parameters: {
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+    maxCount: { type: 'number', description: 'Maximum commits to return. Default 20, hard cap 200.' },
+    ref: { type: 'string', description: 'Revision or range to walk, e.g. "HEAD", "main..feature", "v1.0.0". Default HEAD.' },
+    path: { type: 'string', description: 'Limit history to one path.' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) { return [{ type: 'text', text: renderLog(value) }] },
+  },
+  isConcurrencySafe: function () { return true },
+  execute: async function (args, exec) {
+    const requested = typeof args.maxCount === 'number' && args.maxCount > 0 ? Math.floor(args.maxCount) : 20
+    const maxCount = requested > 200 ? 200 : requested
+    const ref = isStr(args.ref) ? args.ref.trim() : ''
+    const path = isStr(args.path) ? args.path.trim() : ''
+    /* A revision is positional, so a "-"-leading one is an option to git. A path
+       is not guarded here: it travels after `--`, where git already reads it as a
+       path, and a file called `-notes.txt` is a legitimate name. */
+    const bad = optionLike([['ref', ref]])
+    if (bad !== null) {
+      return { ok: false, cwd: here(args, exec), exitCode: null, stderr: bad.reason, error: 'option-like-value' }
+    }
+    const argv = ['-c', 'core.quotePath=false', 'log', '--max-count=' + String(maxCount), '--pretty=format:%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%D%x1e']
+    if (ref.length > 0) argv.push(ref)
+    if (path.length > 0) { argv.push('--'); argv.push(path) }
+    const result = await git(args, argv, exec, {})
+    if (result.exitCode !== 0) {
+      return { ok: false, cwd: result.cwd, exitCode: result.exitCode, stderr: result.stderr, error: 'log-failed' }
+    }
+    const commits = []
+    const records = result.stdout.split('\u001e')
+    for (let i = 0; i < records.length; i += 1) {
+      const record = records[i].replace(/^\n+/, '')
+      if (record.length === 0) continue
+      const fields = record.split('\u001f')
+      const rawDate = field(fields, 3)
+      commits.push({
+        hash: field(fields, 0),
+        short: field(fields, 1),
+        author: field(fields, 2),
+        date: rawDate.length >= 16 ? rawDate.slice(0, 16).replace('T', ' ') : rawDate,
+        subject: field(fields, 4),
+        refs: field(fields, 5),
+      })
+    }
+    return { ok: true, cwd: result.cwd, exitCode: result.exitCode, count: commits.length, commits: commits, stderr: result.stderr }
+  },
+})
+
+define('git_diff', {
+  description: 'Diff between two repository states, returning the changed file list plus full before/after content so the UI renders a native diff card. modes: "worktree" (index vs working tree), "staged" (HEAD vs index), "commit" (ref against its first parent), "range" (ref..to). Narrow with paths for a large change set: above maxFiles the card is skipped and the raw unified patch is returned instead.',
+  parameters: {
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+    mode: { type: 'string', required: true, enum: ['worktree', 'staged', 'commit', 'range'], description: 'Which two states to compare.' },
+    ref: { type: 'string', description: 'Base revision: for "commit" the commit to show (default HEAD); for "range" the range start.' },
+    to: { type: 'string', description: 'Range end. Required for mode "range".' },
+    paths: { type: 'array', items: { type: 'string' }, description: 'Limit the diff to these paths.' },
+    maxFiles: { type: 'number', description: 'Maximum files to build the diff card for. Default 12, cap 50.' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) { return [{ type: 'text', text: renderDiff(value) }] },
+    presentationMeta: function (_args, value) {
+      return { mode: value.mode, cardAvailable: value.cardAvailable === true, diffs: value.files }
+    },
+  },
+  isConcurrencySafe: function () { return true },
+  presentResult: function (_args, result) {
+    if (result == null || result.isError === true) return undefined
+    const meta = result.meta
+    if (meta == null || meta.cardAvailable !== true) return undefined
+    const diffs = Array.isArray(meta.diffs) ? meta.diffs : []
+    if (diffs.length === 0) return undefined
+    return { card: 'diff', title: 'git diff (' + String(meta.mode) + ')', diffs: diffs }
+  },
+  execute: async function (args, exec) {
+    const mode = isStr(args.mode) ? args.mode : 'worktree'
+    const bad = optionLike([['ref', isStr(args.ref) ? args.ref.trim() : ''], ['to', isStr(args.to) ? args.to.trim() : '']])
+    if (bad !== null) {
+      return { ok: false, cwd: here(args, exec), exitCode: null, stderr: bad.reason, error: 'option-like-value' }
+    }
+    const requested = typeof args.maxFiles === 'number' && args.maxFiles > 0 ? Math.floor(args.maxFiles) : 12
+    const maxFiles = requested > 50 ? 50 : requested
+    const paths = Array.isArray(args.paths) ? args.paths.filter(isStr) : []
+    const ref = isStr(args.ref) && args.ref.trim().length > 0 ? args.ref.trim() : 'HEAD'
+    const to = isStr(args.to) && args.to.trim().length > 0 ? args.to.trim() : null
+    const suffix = paths.length > 0 ? ['--'].concat(paths) : []
+
+    let listArgv
+    let patchArgv
+    let oldSpec
+    let newSpec
+    let fromWorktree = false
+
+    if (mode === 'worktree') {
+      listArgv = ['-c', 'core.quotePath=false', 'diff', '--name-only', '--no-renames', '-z'].concat(suffix)
+      patchArgv = ['-c', 'core.quotePath=false', 'diff', '--no-color', '-U3'].concat(suffix)
+      oldSpec = function (path) { return ':' + path }
+      fromWorktree = true
+    } else if (mode === 'staged') {
+      listArgv = ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only', '--no-renames', '-z'].concat(suffix)
+      patchArgv = ['-c', 'core.quotePath=false', 'diff', '--cached', '--no-color', '-U3'].concat(suffix)
+      oldSpec = function (path) { return 'HEAD:' + path }
+      newSpec = function (path) { return ':' + path }
+    } else if (mode === 'commit') {
+      listArgv = ['-c', 'core.quotePath=false', 'show', '--name-only', '--no-renames', '-z', '--format=', ref].concat(suffix)
+      patchArgv = ['-c', 'core.quotePath=false', 'show', '--no-color', '-U3', '--format=', ref].concat(suffix)
+      oldSpec = function (path) { return ref + '^:' + path }
+      newSpec = function (path) { return ref + ':' + path }
+    } else if (mode === 'range') {
+      if (to === null) return { ok: false, cwd: here(args, exec), error: 'mode "range" needs a "to" revision' }
+      listArgv = ['-c', 'core.quotePath=false', 'diff', '--name-only', '--no-renames', '-z', ref + '..' + to].concat(suffix)
+      patchArgv = ['-c', 'core.quotePath=false', 'diff', '--no-color', '-U3', ref + '..' + to].concat(suffix)
+      oldSpec = function (path) { return ref + ':' + path }
+      newSpec = function (path) { return to + ':' + path }
+    } else {
+      return { ok: false, cwd: here(args, exec), error: 'unknown mode ' + mode }
+    }
+
+    const listed = await git(args, listArgv, exec, {})
+    if (listed.exitCode !== 0) {
+      return { ok: false, cwd: listed.cwd, exitCode: listed.exitCode, stderr: listed.stderr, error: 'diff-failed' }
+    }
+    const names = parseNulList(listed.stdout)
+    const result = {
+      ok: true, cwd: listed.cwd, exitCode: listed.exitCode, mode: mode,
+      paths: names, files: [], cardAvailable: false, truncated: false, patch: null, note: null, stderr: listed.stderr,
+    }
+    if (names.length === 0) { result.note = 'no differences in this mode'; return result }
+
+    if (names.length > maxFiles) {
+      const patch = await git(args, patchArgv, exec, { maxBytes: 400000 })
+      result.patch = patch.stdout
+      result.note = String(names.length) + ' files changed, more than maxFiles=' + String(maxFiles) + '; pass paths to narrow the diff and get the diff card'
+      return result
+    }
+
+    const files = []
+    let total = 0
+    let cut = false
+    let overLimit = false
+    for (let i = 0; i < names.length; i += 1) {
+      const path = names[i]
+      const rawOld = await readBlob(args, oldSpec(path), exec)
+      let rawNew = null
+      if (fromWorktree) rawNew = await readWorktreeFile(args, path, exec)
+      else rawNew = await readBlob(args, newSpec(path), exec)
+      const oldCapped = rawOld === null ? null : capText(rawOld)
+      const newCapped = capText(rawNew === null ? '' : rawNew)
+      if ((oldCapped !== null && oldCapped.cut) || newCapped.cut) cut = true
+      total += (oldCapped === null ? 0 : oldCapped.text.length) + newCapped.text.length
+      files.push({ path: path, oldText: oldCapped === null ? null : oldCapped.text, newText: newCapped.text })
+      if (total > CARD_TOTAL_LIMIT) { overLimit = true; break }
+    }
+    result.truncated = cut
+    if (overLimit) {
+      const patch = await git(args, patchArgv, exec, { maxBytes: 400000 })
+      result.patch = patch.stdout
+      result.note = 'the combined before/after content is too large for the diff card; the raw patch is returned instead'
+      return result
+    }
+    result.files = files
+    result.cardAvailable = true
+    return result
+  },
+})
+
+define('git_commit', {
+  description: 'Stage and commit in one step. By default it commits exactly what is already staged; pass paths to stage only those paths first, or all: true to stage every change. Reports the new commit hash.',
+  parameters: {
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+    message: { type: 'string', required: true, description: 'Commit message. Passed as a single argument, never through a shell.' },
+    paths: { type: 'array', items: { type: 'string' }, description: 'Stage only these paths before committing.' },
+    all: { type: 'boolean', description: 'Stage every change (git add -A) before committing.' },
+    amend: { type: 'boolean', description: 'Amend the previous commit instead of creating a new one.' },
+    signoff: { type: 'boolean', description: 'Add a Signed-off-by trailer.' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) {
+      if (value.ok === true) return [{ type: 'text', text: 'committed ' + String(value.hash) + (value.amended === true ? ' (amended)' : '') + '\n' + String(value.stdout).replace(/\n+$/, '') }]
+      return [{ type: 'text', text: renderOutcome(value, 'git commit') }]
+    },
+  },
+  isConcurrencySafe: function () { return false },
+  execute: async function (args, exec) {
+    const paths = Array.isArray(args.paths) ? args.paths.filter(isStr) : []
+    if (args.all === true) {
+      const staged = await git(args, ['add', '-A'], exec, {})
+      if (staged.exitCode !== 0) return { ok: false, cwd: staged.cwd, exitCode: staged.exitCode, stdout: staged.stdout, stderr: staged.stderr, error: 'stage-failed' }
+    } else if (paths.length > 0) {
+      const staged = await git(args, ['add', '--'].concat(paths), exec, {})
+      if (staged.exitCode !== 0) return { ok: false, cwd: staged.cwd, exitCode: staged.exitCode, stdout: staged.stdout, stderr: staged.stderr, error: 'stage-failed' }
+    }
+    const argv = ['commit', '-m', args.message]
+    if (args.amend === true) argv.push('--amend')
+    if (args.signoff === true) argv.push('--signoff')
+    const committed = await git(args, argv, exec, {})
+    if (committed.exitCode !== 0) {
+      return { ok: false, cwd: committed.cwd, exitCode: committed.exitCode, stdout: committed.stdout, stderr: committed.stderr, error: 'commit-failed' }
+    }
+    const rev = await git(args, ['rev-parse', '--short', 'HEAD'], exec, {})
+    return {
+      ok: true, cwd: committed.cwd, exitCode: committed.exitCode, amended: args.amend === true,
+      hash: rev.exitCode === 0 ? rev.stdout.trim() : null,
+      message: args.message, stdout: committed.stdout, stderr: committed.stderr,
+    }
+  },
+})
+
+define('git_branch', {
+  description: 'List, create, switch, delete or rename branches. "list" reports local branches with their upstream, head commit and subject; force-deleting needs confirm: true.',
+  parameters: {
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+    action: { type: 'string', required: true, enum: ['list', 'create', 'switch', 'delete', 'rename'], description: 'Operation to perform.' },
+    name: { type: 'string', description: 'Branch name. Required for every action except "list". For "rename" it is the NEW name of the current branch.' },
+    startPoint: { type: 'string', description: 'For "create", the start point; for "switch", creates the branch there first.' },
+    all: { type: 'boolean', description: 'For "list", include remote-tracking branches.' },
+    force: { type: 'boolean', description: 'For "delete", delete even when unmerged (git branch -D). Needs confirm: true.' },
+    confirm: { type: 'boolean', description: 'Must be true when force is used.' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) {
+      if (value.action === 'list') return [{ type: 'text', text: renderBranches(value) }]
+      return [{ type: 'text', text: renderOutcome(value, 'git branch ' + String(value.action)) }]
+    },
+  },
+  isConcurrencySafe: function () { return false },
+  execute: async function (args, exec) {
+    const action = args.action
+    const name = isStr(args.name) && args.name.trim().length > 0 ? args.name.trim() : null
+    if (action !== 'list' && name === null) {
+      return { ok: false, action: action, cwd: here(args, exec), error: 'name is required for action ' + action }
+    }
+    const startPoint = isStr(args.startPoint) ? args.startPoint.trim() : ''
+    const bad = optionLike([['name', name === null ? '' : name], ['startPoint', startPoint]])
+    if (bad !== null) {
+      return { ok: false, action: action, cwd: here(args, exec), exitCode: null, stderr: bad.reason, error: 'option-like-value' }
+    }
+    if (action === 'delete' && args.force === true && args.confirm !== true) {
+      return { ok: false, action: action, cwd: here(args, exec), blocked: 'confirmation-required', reason: 'force-deleting a branch discards commits that are not merged anywhere else' }
+    }
+
+    if (action === 'list') {
+      const argv = ['-c', 'core.quotePath=false', 'branch', '--format=%(refname:short)%1f%(HEAD)%1f%(upstream:short)%1f%(objectname:short)%1f%(contents:subject)']
+      if (args.all === true) argv.push('-a')
+      const listed = await git(args, argv, exec, {})
+      if (listed.exitCode !== 0) {
+        return { ok: false, action: 'list', cwd: listed.cwd, exitCode: listed.exitCode, stdout: listed.stdout, stderr: listed.stderr, error: 'branch-list-failed' }
+      }
+      const branches = []
+      let current = null
+      const rows = listed.stdout.split('\n')
+      for (let i = 0; i < rows.length; i += 1) {
+        const row = rows[i]
+        if (row.length === 0) continue
+        const fields = row.split('\u001f')
+        const isCurrent = fields[1] === '*'
+        if (isCurrent) current = fields[0] === undefined ? null : fields[0]
+        branches.push({
+          name: field(fields, 0),
+          current: isCurrent,
+          upstream: field(fields, 2),
+          head: field(fields, 3),
+          subject: field(fields, 4),
+        })
+      }
+      return { ok: true, action: 'list', cwd: listed.cwd, exitCode: listed.exitCode, current: current, branches: branches, stdout: listed.stdout, stderr: listed.stderr }
+    }
+
+    let argv
+    if (action === 'create') {
+      argv = ['branch', name]
+      if (startPoint.length > 0) argv.push(startPoint)
+    } else if (action === 'switch') {
+      if (startPoint.length > 0) argv = ['switch', '-c', name, startPoint]
+      else argv = ['switch', name]
+    } else if (action === 'delete') {
+      argv = ['branch', args.force === true ? '-D' : '-d', name]
+    } else {
+      argv = ['branch', '-m', name]
+    }
+    const done = await git(args, argv, exec, {})
+    done.action = action
+    return done
+  },
+})
+
+define('git_stash', {
+  description: 'Manage the stash: list entries, push the current changes onto it, pop or apply an entry, show one, or drop/clear entries. Dropping and clearing need confirm: true.',
+  parameters: {
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+    action: { type: 'string', required: true, enum: ['list', 'push', 'pop', 'apply', 'show', 'drop', 'clear'], description: 'Operation to perform.' },
+    message: { type: 'string', description: 'For "push", the stash message.' },
+    index: { type: 'number', description: 'For pop/apply/show/drop, which stash entry (default 0, the most recent).' },
+    paths: { type: 'array', items: { type: 'string' }, description: 'For "push", stash only these paths.' },
+    confirm: { type: 'boolean', description: 'Must be true for "drop" and "clear".' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) {
+      if (value.action === 'list') return [{ type: 'text', text: renderStashes(value) }]
+      return [{ type: 'text', text: renderOutcome(value, 'git stash ' + String(value.action)) }]
+    },
+  },
+  isConcurrencySafe: function () { return false },
+  execute: async function (args, exec) {
+    const action = args.action
+    const rawIndex = typeof args.index === 'number' && args.index >= 0 ? Math.floor(args.index) : 0
+    const selector = 'stash@{' + String(rawIndex) + '}'
+
+    if (action === 'clear') {
+      if (args.confirm !== true) return { ok: false, action: action, cwd: here(args, exec), blocked: 'confirmation-required', reason: 'stash clear drops every stash entry permanently' }
+      const done = await git(args, ['stash', 'clear'], exec, {})
+      done.action = action
+      return done
+    }
+    if (action === 'drop') {
+      if (args.confirm !== true) return { ok: false, action: action, cwd: here(args, exec), blocked: 'confirmation-required', reason: 'stash drop discards a stash entry permanently' }
+      const done = await git(args, ['stash', 'drop', selector], exec, {})
+      done.action = action
+      return done
+    }
+    if (action === 'list') {
+      const listed = await git(args, ['stash', 'list', '--format=%gd%x1f%gs%x1f%aI'], exec, {})
+      if (listed.exitCode !== 0) {
+        return { ok: false, action: 'list', cwd: listed.cwd, exitCode: listed.exitCode, stdout: listed.stdout, stderr: listed.stderr, error: 'stash-list-failed', stashes: [] }
+      }
+      const stashes = []
+      const rows = listed.stdout.split('\n')
+      for (let i = 0; i < rows.length; i += 1) {
+        if (rows[i].length === 0) continue
+        const fields = rows[i].split('\u001f')
+        const stamp = field(fields, 2)
+        stashes.push({
+          ref: field(fields, 0),
+          subject: field(fields, 1),
+          date: stamp.length >= 16 ? stamp.slice(0, 16).replace('T', ' ') : stamp,
+        })
+      }
+      return { ok: true, action: 'list', cwd: listed.cwd, exitCode: listed.exitCode, stashes: stashes, stdout: listed.stdout, stderr: listed.stderr }
+    }
+
+    let argv
+    if (action === 'push') {
+      argv = ['stash', 'push']
+      if (isStr(args.message) && args.message.length > 0) { argv.push('-m'); argv.push(args.message) }
+      const paths = Array.isArray(args.paths) ? args.paths.filter(isStr) : []
+      if (paths.length > 0) argv = argv.concat(['--']).concat(paths)
+    } else {
+      argv = ['stash', action, selector]
+    }
+    const done = await git(args, argv, exec, {})
+    done.action = action
+    return done
+  },
+})
+
+define('git_sync', {
+  description: 'Work with remotes: fetch, pull, push, list remotes, and add/remove/retarget one. A protected branch (main/master) can never be force-pushed, and any force push needs confirm: true.',
+  parameters: {
+    repo: { type: 'string', description: 'Repository directory. Defaults to the session working directory.' },
+    action: { type: 'string', required: true, enum: ['fetch', 'pull', 'push', 'remote-list', 'remote-add', 'remote-remove', 'set-url'], description: 'Operation to perform.' },
+    remote: { type: 'string', description: 'Remote name, e.g. "origin".' },
+    branch: { type: 'string', description: 'Branch to pull or push.' },
+    url: { type: 'string', description: 'Remote URL for remote-add and set-url.' },
+    setUpstream: { type: 'boolean', description: 'For "push", set the upstream tracking branch (git push -u).' },
+    prune: { type: 'boolean', description: 'For "fetch", drop remote-tracking refs that no longer exist (--prune).' },
+    ff: { type: 'string', enum: ['auto', 'only', 'rebase'], description: 'For "pull": "only" passes --ff-only, "rebase" passes --rebase.' },
+    force: { type: 'string', enum: ['none', 'lease', 'force'], description: 'For "push": "lease" passes --force-with-lease, "force" passes --force and needs confirm: true.' },
+    confirm: { type: 'boolean', description: 'Must be true for a force push and for remote-remove.' },
+  },
+  output: {
+    schema: { type: 'json' },
+    render: function (_args, value) { return [{ type: 'text', text: renderOutcome(value, 'git ' + String(value.action)) }] },
+  },
+  isConcurrencySafe: function () { return false },
+  execute: async function (args, exec) {
+    const action = args.action
+    const remote = isStr(args.remote) && args.remote.trim().length > 0 ? args.remote.trim() : null
+    const branch = isStr(args.branch) && args.branch.trim().length > 0 ? args.branch.trim() : null
+    const url = isStr(args.url) && args.url.trim().length > 0 ? args.url.trim() : null
+    const cwd = here(args, exec)
+    const bad = optionLike([['remote', remote], ['branch', branch], ['url', url]])
+    if (bad !== null) {
+      return { ok: false, action: action, cwd: cwd, exitCode: null, stderr: bad.reason, error: 'option-like-value' }
+    }
+
+    if (action === 'push' && args.force === 'force') {
+      /* The branch that is not named is the branch you are on, and "a protected
+         branch can never be force-pushed" has to mean that branch too: without
+         this, `force: 'force'` with no branch force-pushed whatever was checked
+         out after a bare `confirm`. Resolved here, once, on the one path that
+         needs it. */
+      let target = branch
+      if (target === null) {
+        const head = await git(args, ['symbolic-ref', '--quiet', '--short', 'HEAD'], exec, {})
+        target = head.exitCode === 0 ? head.stdout.trim() : null
+      }
+      if (target !== null && isProtectedBranch(target)) {
+        return { ok: false, action: action, cwd: cwd, blocked: 'forbidden', reason: 'force-pushing to a protected branch (main/master) is never allowed' }
+      }
+    }
+    if (action === 'push' && (args.force === 'force' || args.force === 'lease') && args.confirm !== true) {
+      return { ok: false, action: action, cwd: cwd, blocked: 'confirmation-required', reason: 'a force push overwrites remote history' }
+    }
+    if (action === 'remote-remove' && args.confirm !== true) {
+      return { ok: false, action: action, cwd: cwd, blocked: 'confirmation-required', reason: 'remote remove detaches every local branch that tracks it' }
+    }
+    if ((action === 'remote-add' || action === 'set-url') && (remote === null || url === null)) {
+      return { ok: false, action: action, cwd: cwd, error: action + ' needs both remote and url' }
+    }
+    if (action === 'remote-remove' && remote === null) {
+      return { ok: false, action: action, cwd: cwd, error: action + ' needs remote' }
+    }
+
+    let argv
+    if (action === 'fetch') {
+      argv = ['fetch']
+      if (remote !== null) argv.push(remote)
+      if (args.prune === true) argv.push('--prune')
+    } else if (action === 'pull') {
+      argv = ['pull']
+      if (remote !== null) argv.push(remote)
+      if (branch !== null) argv.push(branch)
+      if (args.ff === 'only') argv.push('--ff-only')
+      else if (args.ff === 'rebase') argv.push('--rebase')
+    } else if (action === 'push') {
+      argv = ['push']
+      if (args.setUpstream === true) argv.push('-u')
+      if (args.force === 'lease') argv.push('--force-with-lease')
+      else if (args.force === 'force') argv.push('--force')
+      if (remote !== null) argv.push(remote)
+      if (branch !== null) argv.push(branch)
+    } else if (action === 'remote-list') {
+      argv = ['remote', '-v']
+    } else if (action === 'remote-add') {
+      argv = ['remote', 'add', remote, url]
+    } else if (action === 'remote-remove') {
+      argv = ['remote', 'remove', remote]
+    } else {
+      argv = ['remote', 'set-url', remote, url]
+    }
+
+    const done = await git(args, argv, exec, { timeoutMs: 300000 })
+    done.action = action
+    return done
+  },
+})
+
+/* ─────────────── graph layout ─────────────── */
+
+function layoutGraph(commits, maxLanes) {
+  const lanes = []
+  const rows = []
+  let widest = 1
+  for (let i = 0; i < commits.length; i += 1) {
+    const commit = commits[i]
+    let lane = lanes.indexOf(commit.hash)
+    if (lane < 0) {
+      lane = lanes.indexOf(null)
+      if (lane < 0) {
+        if (lanes.length >= maxLanes) lane = lanes.length - 1
+        else { lanes.push(null); lane = lanes.length - 1 }
+      }
+    }
+    lanes[lane] = null
+    const edges = []
+    for (let k = 0; k < commit.parents.length; k += 1) {
+      const parent = commit.parents[k]
+      let parentLane = lanes.indexOf(parent)
+      if (parentLane < 0) {
+        if (k === 0) { parentLane = lane; lanes[lane] = parent }
+        else {
+          parentLane = lanes.indexOf(null)
+          if (parentLane < 0) {
+            if (lanes.length >= maxLanes) continue
+            lanes.push(parent)
+            parentLane = lanes.length - 1
+          } else lanes[parentLane] = parent
+        }
+      }
+      edges.push({ hash: parent, lane: parentLane })
+      if (parentLane + 1 > widest) widest = parentLane + 1
+    }
+    if (lane + 1 > widest) widest = lane + 1
+    rows.push({ lane: lane, edges: edges })
+  }
+  return { rows: rows, lanes: widest }
+}
+
+/* ── the graph under a filter ──
+
+   The plain layout below walks the commits it is handed, so it can only ever
+   connect two of them: a parent that the filter hid is not in the list, and the
+   lane booked for it is never claimed — the next commit then takes a *fresh*
+   lane. Measured on the reader's repository with `fix` typed in the search box
+   (200 matching commits): 104 lanes' worth of bookings, capped at 14, a 202px
+   column that is mostly empty, 52% of the edges drawn as a one-row stub, and
+   the dots marching right until they all pile onto the last lane. Same search,
+   same repository, the graph was unreadable — while the plain history drew a
+   proper ribbon.
+
+   So a filtered read is laid out on the **real** DAG: the host reads the plain
+   hash+parents history for the span the matches cover (measured: 1518 commits
+   in 190ms for those 200 rows), lays that out, and then places each visible
+   commit on the lane it really holds. An edge is drawn to the nearest *visible*
+   ancestor, and marked dashed when commits in between were filtered out —
+   IDEA's own reading of a dashed line, and the reason its graph stays a graph
+   when a filter is on. Nothing here changes an unfiltered read: that path still
+   goes through layoutGraph alone. */
+const DAG_SKIP_MAX = 5000
+
+function layoutVisible(full, commits, maxLanes) {
+  const base = layoutGraph(full, maxLanes)
+  const rowOf = {}
+  for (let i = 0; i < full.length; i += 1) rowOf[full[i].hash] = i
+  const visible = {}
+  for (let i = 0; i < commits.length; i += 1) visible[commits[i].hash] = true
+  const laneOf = function (hash) {
+    const at = rowOf[hash]
+    return at === undefined ? -1 : base.rows[at].lane
+  }
+
+  const rows = []
+  let widest = 1
+  for (let i = 0; i < commits.length; i += 1) {
+    const commit = commits[i]
+    let lane = laneOf(commit.hash)
+    /* A match that the span does not reach (it is older than the range the DAG
+       read was allowed) has no lane of its own; it joins the row above rather
+       than starting a lane the picture cannot justify. */
+    if (lane < 0) lane = rows.length > 0 ? rows[rows.length - 1].lane : 0
+    const edges = []
+    for (let k = 0; k < commit.parents.length; k += 1) {
+      const parent = commit.parents[k]
+      let cur = parent
+      let dashed = false
+      let guard = 0
+      while (rowOf[cur] !== undefined && visible[cur] !== true) {
+        dashed = true
+        const grand = full[rowOf[cur]].parents
+        if (grand.length === 0) { cur = null; break }
+        cur = grand[0]
+        guard += 1
+        if (guard > DAG_SKIP_MAX) { cur = null; break }
+      }
+      const reached = cur !== null && visible[cur] === true
+      const target = reached ? laneOf(cur) : laneOf(parent)
+      const edgeLane = target < 0 ? lane : target
+      /* Whatever is left is a parent this list does not contain and cannot
+         follow to one: the line leaves the page, and the client draws it that
+         way instead of stopping it a row short. */
+      edges.push({ hash: reached ? cur : parent, lane: edgeLane, dashed: reached ? dashed : true })
+      if (edgeLane + 1 > widest) widest = edgeLane + 1
+    }
+    if (lane + 1 > widest) widest = lane + 1
+    rows.push({ lane: lane, edges: edges })
+  }
+  return { rows: rows, lanes: widest }
+}
+
+/* `git log --pretty=format:%H %P`, one commit per line: the plain history the
+   filtered graph is laid out on. Only the shape of the DAG is needed, so this is
+   the cheapest form of the same walk. */
+function parseDag(stdout) {
+  const commits = []
+  const lines = stdout.split('\n')
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i].replace(/\r$/, '')
+    if (line.length === 0) continue
+    const parts = line.split(' ')
+    const parents = []
+    for (let k = 1; k < parts.length; k += 1) if (parts[k].length > 0) parents.push(parts[k])
+    commits.push({ hash: parts[0], parents: parents })
+  }
+  return commits
+}
+
+function parseCommitRecords(stdout) {
+  const commits = []
+  const records = stdout.split('\u001e')
+  for (let i = 0; i < records.length; i += 1) {
+    const record = records[i].replace(/^\n+/, '')
+    if (record.length === 0) continue
+    const fields = record.split('\u001f')
+    const parents = fields[7] === undefined || fields[7].length === 0 ? [] : fields[7].split(' ')
+    commits.push({
+      hash: field(fields, 0),
+      short: field(fields, 1),
+      author: field(fields, 2),
+      email: field(fields, 3),
+      date: field(fields, 4),
+      subject: field(fields, 5),
+      refs: field(fields, 6),
+      parents: parents,
+    })
+  }
+  return commits
+}
+
+/* ─────────────── Client RPC ─────────────── */
+
+/* ── whose working directory this request means ──
+
+   A request that names no path of its own is about the session's own working
+   directory, which is exactly the directory the shell layer already treats as
+   home when no workdir is given. Both questions below are that one lookup: which
+   repository this request is about, and where a probe of some *other* path may be
+   spawned. A probe must never run with the inspected path as its workdir — when
+   that directory does not exist the spawn itself fails before git is ever reached
+   and the caller sees a rejected promise instead of the diagnosis it asked for. */
+function sessionWorkdir(input) {
+  if (input == null || !isStr(input.sessionId)) return undefined
+  const sessions = ctx.get('sessions')
+  if (sessions === undefined) return undefined
+  try {
+    const session = sessions.get(input.sessionId)
+    const header = session != null ? session.header : undefined
+    const cwd = header != null ? header.cwd : undefined
+    if (isStr(cwd) && cwd.length > 0) return cwd
+  } catch (error) {
+    console.error('dsh-git-idea: could not resolve the session working directory', String(error))
+  }
+  return undefined
+}
+
+function repoFrom(input) {
+  if (input != null && isStr(input.repo) && input.repo.trim().length > 0) return input.repo.trim()
+  return sessionWorkdir(input)
+}
+
+/* Which repository, and on whose behalf. The session id travels with the args so
+   the shell layer can ask for that session's sandbox policy — it is the only
+   thing that says whether these commands may write at all (see `sandboxFor`).
+
+   Every path that builds these args goes through here, including the ones that
+   resolved a path of their own: a request that keeps the repo and drops the
+   session id runs under the *deployment* default policy instead of the reader's
+   own, which is how `git init` came to be denied on a directory nobody had a
+   problem writing to. */
+function argsAt(input, repo) {
+  const out = repo === undefined || repo === null ? {} : { repo: repo }
+  if (input != null && isStr(input.sessionId) && input.sessionId.length > 0) out.sessionId = input.sessionId
+  return out
+}
+
+function argsFor(input) {
+  return argsAt(input, repoFrom(input))
+}
+
+/* ─────────────── per-repository read cache ───────────────
+
+   Opening the panel used to cost nine child processes and nothing was reused,
+   so every open re-read the whole repository. Reads are now memoised per
+   repository and dropped on any mutation.
+
+   Reads do not age out on a timer. Data may be as old as the last explicit
+   invalidation, which is what makes reopening the panel instant; freshness is
+   the watcher's job (git/watch below) plus the mutation and refresh paths.
+
+   A miss stores the *promise*, not the value: two surfaces asking for the same
+   read at the same moment — the composer chip's full read, and the panel opening
+   under it — are one child process instead of two, which on a slow mount is the
+   difference between one seven-second `git status` and two. A rejection is never
+   kept, so a read that failed can be attempted again, and the value is only
+   stored if the entry is still the promise that produced it: an invalidation
+   arriving mid-read must not be undone by that read landing afterwards. */
+
+const readCache = new Map()
+const READ_CACHE_MAX = 300
+
+async function cached(repo, tag, loader) {
+  const key = repo + '\u0000' + tag
+  const hit = readCache.get(key)
+  if (hit !== undefined) return await hit
+  const pending = loader()
+  readCache.set(key, pending)
+  try {
+    const value = await pending
+    if (readCache.get(key) === pending) readCache.set(key, value)
+    return value
+  } catch (error) {
+    if (readCache.get(key) === pending) readCache.delete(key)
+    throw error
+  }
+}
+
+function invalidateRepo(repo) {
+  if (repo === undefined || repo === null) { readCache.clear(); return }
+  const prefix = repo + '\u0000'
+  const doomed = []
+  readCache.forEach(function (_value, key) {
+    if (key.indexOf(prefix) === 0) doomed.push(key)
+  })
+  for (let i = 0; i < doomed.length; i += 1) readCache.delete(doomed[i])
+  /* Oldest first, one key at a time. Clearing the whole map on overflow meant one
+     repository's paging dropped every other repository's reads with it. */
+  while (readCache.size > READ_CACHE_MAX) readCache.delete(readCache.keys().next().value)
+}
+
+/* ─────────────── the identity reads, and reading by pathspec ─────────────── */
+
+/* Diagnostics for the "this path is not a repository" setup page. The workdir is
+   the session's own directory, never the path being inspected (see
+   `sessionWorkdir`). */
+async function probeShell(input, command) {
+  return await invoke(command, argsAt(input, sessionWorkdir(input)), null, { timeoutMs: 20000 })
+}
+
+async function pathKind(input, target) {
+  const probe = await probeShell(input, 'if [ -d ' + shq(target) + ' ]; then echo dir; elif [ -f ' + shq(target) + ' ]; then echo file; else echo none; fi')
+  const kind = probe.stdout.trim()
+  return kind === 'dir' || kind === 'file' ? kind : 'none'
+}
+
+/* One shell process answers everything the setup page needs: whether the path
+   exists, what it is, git's own status with its exit code carried out
+   explicitly, and whether an operation is caught half-done. The previous shape
+   cost two or three spawns for the same information. */
+/* ── the cheap half of a panel read ──
+
+   `git status` stats every tracked file. On a Windows-mounted worktree of a few
+   thousand files that is the whole cost of opening the panel: measured on one
+   here, 7.0s for the status against 0.13s for the four commands below. Nothing
+   in the composer chip, and nothing in the panel's frame, needs the working
+   tree — they need to know whether this path is a repository, which branch it is
+   on, where that branch stands against its upstream, and whether a cherry-pick,
+   merge or rebase is half-done. The working tree is asked for separately, by the
+   request that actually shows it. */
+/* ── one directory, no discovery ──
+
+   A workspace is a repository when **that directory** is one: `$dir/.git` (a
+   directory, or the file a worktree and a submodule keep there). Git's own
+   discovery would instead walk up and answer for whatever repository happens to
+   be above — the panel would name another project's branch, its watcher would
+   follow that repository's refs, and the answer for a bare subdirectory would
+   silently be about a tree the reader never pointed at. So every command below
+   tests that one path and stops there; nothing looks upward, and nothing looks
+   into the directory either. */
+function repoHere(target) {
+  return '[ -e ' + shq(target) + '/.git ]'
+}
+
+/* The five states in which an operation is caught half-done. Both reads below ask
+   for all of them, and they have to stay in step: a state known to one and not
+   the other is a panel that offers "continue" on one screen and not the next. */
+function sequencerShell() {
+  return [
+    "    [ -e \"$gd/CHERRY_PICK_HEAD\" ] && printf 'S:cherry-pick\\n'",
+    "    [ -e \"$gd/REVERT_HEAD\" ] && printf 'S:revert\\n'",
+    "    [ -e \"$gd/MERGE_HEAD\" ] && printf 'S:merge\\n'",
+    "    [ -d \"$gd/rebase-merge\" ] && printf 'S:rebase\\n'",
+    "    [ -d \"$gd/rebase-apply\" ] && printf 'S:rebase\\n'",
+  ].join('\n')
+}
+
+/* The branch half of the identity read, in one git process instead of three.
+
+   The branch name comes out of `$gd/HEAD` itself rather than out of
+   `symbolic-ref`: the gitdir is already in hand, the answer is the one line in
+   that file, and the spawn cost a quarter of this read. Reading it also answers
+   the case for-each-ref cannot — a repository whose branch has no commit yet
+   names that branch, while `refs/heads` is still empty.
+
+   Then one for-each-ref, restricted to that branch, carries the upstream and the
+   ahead/behind numbers together. Asking for them separately re-walked the same
+   ref table for nothing, and asking for *all* branches instead is far worse than
+   it looks: `%(upstream:track)` costs a rev-list pair per branch, 109ms against
+   31ms for the single branch on screen on the repository this was measured
+   against.
+
+   LC_ALL=C is not decoration either: the words around those numbers are
+   translated, and this is the read the composer chip shows. */
+function branchIdentityShell(target) {
+  return [
+    "    b=''",
+    '    if [ -f "$gd/HEAD" ]; then',
+    '      read -r headline < "$gd/HEAD"',
+    '      case "$headline" in',
+    "        'ref: refs/heads/'*) b=${headline#'ref: refs/heads/'} ;;",
+    '      esac',
+    '    fi',
+    '    if [ -n "$b" ]; then',
+    "      printf 'B:%s\\n' \"$b\"",
+    "      printf 'U:%s\\n' \"$(LC_ALL=C git -C " + shq(target) + " for-each-ref --format='%(upstream:short)%1f%(upstream:track)' \"refs/heads/$b\" 2>/dev/null)\"",
+    '    fi',
+  ].join('\n')
+}
+
+/* The shape both reads share: the three answers about the path itself, the one
+   gitdir both of them need, and the half-done-operation markers — with everything
+   that is actually asked of the repository in the middle. Written once because
+   the two commands have to keep answering the same way about the same path, and
+   only their middles should ever differ. */
+function pathShell(target, middle) {
+  const quoted = shq(target)
+  return [
+    'if [ -d ' + quoted + ' ]; then',
+    "  printf 'K:dir\\n'",
+    /* Guarded by `repoHere` and not left to git: without the guard,
+       `git rev-parse` in a directory that is not a repository walks up and
+       answers for a parent one. */
+    '  if ' + repoHere(target) + '; then',
+    '    gd=$(git -C ' + quoted + ' rev-parse --absolute-git-dir 2>/dev/null)',
+    '  else',
+    "    gd=''",
+    '  fi',
+    middle,
+    'elif [ -f ' + quoted + ' ]; then',
+    "  printf 'K:file\\n'",
+    'else',
+    "  printf 'K:none\\n'",
+    'fi',
+  ].join('\n')
+}
+
+function panelIdentityCommand(target) {
+  return pathShell(target, [
+    '  if [ -z "$gd" ]; then',
+    "    printf 'RC:1\\n'",
+    "    printf 'fatal: not a git repository\\n'",
+    '  else',
+    branchIdentityShell(target),
+    sequencerShell(),
+    "    printf 'RC:0\\n'",
+    '  fi',
+  ].join('\n'))
+}
+
+/* ── reading by pathspec instead of by tree ──
+
+   `git status` stats every tracked file and walks every untracked directory, and
+   on a Windows-mounted worktree that is the whole cost of every read this plugin
+   makes. Measured on the reader's repository, one whole-tree status: 7.4s
+   (13.6s cold), 5.3s with `-uno`, 13.0s with `--untracked-files=all`. The same
+   command asked about the 36 paths the changes tree was showing: **0.5s**. The
+   working tree is what the panel is showing, so the reads that keep it fresh ask
+   about those paths, and only a read that has to answer for the whole tree pays
+   for the whole tree.
+
+   The paths come from the client, so each one passes the guard the diff read
+   uses (relative, inside the repository, no NUL), and the list is capped: a
+   pathspec list is a command line, and a command line has a length. */
+const READ_PATHS_MAX = 200
+
+/* How much plain history a filtered graph may lay itself out on. Measured on the
+   reader's repository: 200 `fix` matches span 1518 commits, read in 190ms. The
+   cap is what keeps a search that matches once per thousand commits from turning
+   a keystroke into a whole-history walk — past it, edges leave the page. */
+const DAG_MAX = 4000
+
+function readPaths(input) {
+  if (input == null || !Array.isArray(input.paths)) return []
+  const out = []
+  for (let i = 0; i < input.paths.length && out.length < READ_PATHS_MAX; i += 1) {
+    const path = input.paths[i]
+    if (!isStr(path) || path.length === 0) continue
+    if (repoRelativePath(path) !== '') continue
+    if (out.indexOf(path) >= 0) continue
+    out.push(path)
+  }
+  return out
+}
+
+function pathspecSuffix(paths) {
+  if (paths.length === 0) return ''
+  return ' -- ' + paths.map(shq).join(' ')
+}
+
+function panelCommand(target, paths) {
+  const quoted = shq(target)
+  const asked = paths == null ? [] : paths
+  return pathShell(target, [
+    '  if ' + repoHere(target) + '; then',
+    "    out=$(git -C " + quoted + " --no-optional-locks -c core.quotePath=false status --porcelain=v2 --branch --untracked-files=normal" + pathspecSuffix(asked) + " 2>&1); rc=$?",
+    '  else',
+    "    out='fatal: not a git repository'; rc=1",
+    '  fi',
+    "  printf '%s\n' \"$out\"",
+    "  printf 'RC:%s\n' \"$rc\"",
+    '  if [ -n "$gd" ]; then',
+    sequencerShell(),
+    '  fi',
+  ].join('\n'))
+}
+
+/* One lightweight spawn answers "did anything change?" for the client watcher.
+   It deliberately uses --untracked-files=normal: the per-file walk of `all` is
+   the expensive part on a large tree, and a collapsed untracked directory still
+   changes the signature when its contents do. The ref table and the HEAD file
+   cover what the status walk cannot see: a new commit with no worktree change,
+   and — the one the working tree is silent about — a branch switch, whether it
+   was made here or in a terminal next to us.
+
+   --no-optional-locks is load-bearing, not decoration: a plain `git status`
+   refreshes the index cache and takes .git/index.lock to do it, so a background
+   poller racing the user's own `git add` makes THEIR command fail. Measured on
+   this machine: 15 of 150 adds failed without the flag, 0 of 150 with it, and
+   the reported status is identical either way.
+
+   The rule is not "this one call": it is every read this plugin makes. The full
+   panel read and the `git_status` tool missed it for a while and were caught by
+   a case of exactly this — a fetch that triggered auto-gc was blamed first, but
+   background gc never touches index.lock (it runs pack-objects --indexed-objects,
+   which only reads the index). Whoever writes .git/index is the suspect, and a
+   `git status` writes it. `test/gp34a` now holds both the rule and the probe. */
+/* What "did anything move?" costs. The status is the expensive part — seconds
+   on a slow mount, every tick — and it is only worth paying while something is
+   showing the working tree, which is what `deep` asks for. Everything else in
+   the signature is three stats, one for-each-ref and one small file read. */
+function watchCommand(target, deep, paths) {
+  const quoted = shq(target)
+  const asked = paths == null ? [] : paths
+  /* Every git call below is inside `[ -n "$gd" ]`: on a directory that is not a
+     repository, git would happily answer for one of its parents, and the
+     signature would then follow a tree this workspace does not own. */
+  const whenRepo = function (command) {
+    return '$(if [ -n "$gd" ]; then ' + command + '; fi)'
+  }
+  const out = [
+    "st() { stat -c '%Y:%s' \"$1\" 2>/dev/null || stat -f '%m:%z' \"$1\" 2>/dev/null; }",
+    'if ' + repoHere(target) + '; then',
+    '  gd=$(git -C ' + quoted + ' rev-parse --absolute-git-dir 2>/dev/null)',
+    'else',
+    "  gd=''",
+    'fi',
+  ]
+  if (deep === true) {
+    /* ── the tick asks about the paths on screen ──
+       This runs every few seconds while the changes tab is open, and a
+       whole-tree status is 7.4s on the reader's mount: the tick then takes
+       longer than the interval between ticks, so the poller never stops and
+       every cheap read beside it (for-each-ref went 50ms → 143ms) waits behind
+       it. The same command over the paths the tree was showing is 0.5s. A file
+       that was clean and is now modified is the one thing this cannot see; the
+       panel reads the whole tree for that on its own clock. */
+    out.push('if [ -n "$gd" ]; then git -C ' + quoted + ' --no-optional-locks -c core.quotePath=false status --porcelain=v2 --branch --untracked-files=normal' + pathspecSuffix(asked) + ' 2>&1; fi')
+  }
+  out.push(
+    "printf 'F:%s\\n' \"" + whenRepo("git -C " + quoted + " for-each-ref --format='%(refname):%(objectname)' refs/heads refs/remotes 2>/dev/null") + "\"",
+    "printf 'H:%s\\n' \"" + whenRepo("git -C " + quoted + " rev-parse -q --verify HEAD 2>/dev/null") + "\"",
+    "printf 'I:%s\\n' \"$(st \"$gd/index\")\"",
+    /* The HEAD *file*, not just its stamp. Two branches can point at the same
+       commit — `git switch -c` always does, and so does any pair left level by a
+       fast-forward — and then the ref table, the HEAD sha and often the index are
+       byte-identical, so the branch name written in this file is the only thing
+       that tells them apart. A stamp is not enough on its own either: it carries
+       second resolution, so a switch made in the same second as the previous read
+       looks like nothing happened — and then never becomes visible at all. */
+    "printf 'R:%s\\n' \"$(cat \"$gd/HEAD\" 2>/dev/null) $(st \"$gd/HEAD\")\"",
+    "printf 'P:%s\\n' \"$(st \"$gd/packed-refs\")\"",
+  )
+  return out.join('\n')
+}
+
+/* ─────────────── the panel's own read, and the graph ─────────────── */
+
+function missingPanel(target, reason) {
+  return {
+    ok: false, repo: target, error: 'not-a-repository', reason: reason,
+    stderr: '', exitCode: null, staged: [], unstaged: [], untracked: [], unmerged: [],
+  }
+}
+
+async function readPanelIdentity(input, target) {
+  const probe = await probeShell(input, panelIdentityCommand(target))
+  const lines = probe.stdout.split('\n')
+  const kind = lines.length > 0 ? lines[0] : ''
+  if (kind === 'K:file') return missingPanel(target, 'file')
+  if (kind !== 'K:dir') return missingPanel(target, 'missing')
+
+  let exitCode = null
+  let sequencer = null
+  let branch = null
+  let upstream = null
+  let track = ''
+  for (let i = 1; i < lines.length; i += 1) {
+    const line = lines[i]
+    if (line.indexOf('RC:') === 0) { exitCode = parseInt(line.slice(3), 10); continue }
+    if (line.indexOf('S:') === 0) { if (sequencer === null) sequencer = line.slice(2); continue }
+    if (line.indexOf('B:') === 0) { branch = line.slice(2); continue }
+    /* The upstream and its standing arrive in one line, separated by the same
+       \u001f the rest of the Host uses: one for-each-ref answers both. */
+    if (line.indexOf('U:') === 0) {
+      const fields = line.slice(2).split('\u001f')
+      upstream = field(fields, 0)
+      track = field(fields, 1)
+    }
+  }
+  if (exitCode !== 0) {
+    const failed = missingPanel(target, 'not-a-repo')
+    failed.exitCode = exitCode
+    failed.stderr = ''
+    return failed
+  }
+  const counts = trackCounts(track)
+  return {
+    ok: true, repo: target, branch: branch, detached: branch === null,
+    upstream: upstream !== null && upstream.length > 0 ? upstream : null,
+    ahead: counts.ahead, behind: counts.behind,
+    sequencer: sequencer,
+    staged: [], unstaged: [], untracked: [], unmerged: [],
+    /* Says outright that the working tree was not read, so nothing downstream
+       can mistake "no changes" for "not asked". */
+    partial: true,
+  }
+}
+
+async function readPanel(input, target, paths) {
+  const asked = paths == null ? [] : paths
+  const probe = await probeShell(input, panelCommand(target, asked))
+  const lines = probe.stdout.split('\n')
+  const kind = lines.length > 0 ? lines[0] : ''
+  if (kind === 'K:file') return missingPanel(target, 'file')
+  if (kind !== 'K:dir') return missingPanel(target, 'missing')
+
+  let exitCode = null
+  let sequencer = null
+  const body = []
+  for (let i = 1; i < lines.length; i += 1) {
+    const line = lines[i]
+    if (line.indexOf('RC:') === 0) { exitCode = parseInt(line.slice(3), 10); continue }
+    if (line.indexOf('S:') === 0) { if (sequencer === null) sequencer = line.slice(2); continue }
+    body.push(line)
+  }
+  const output = body.join('\n')
+
+  if (exitCode !== 0) {
+    const outsideRepo = output.indexOf('not a git repository') >= 0
+    const failed = missingPanel(target, outsideRepo ? 'not-a-repo' : 'git-error')
+    failed.exitCode = exitCode
+    failed.stderr = outsideRepo ? '' : output
+    return failed
+  }
+
+  const parsed = parseStatusV2(output)
+  const untracked = []
+  for (let i = 0; i < parsed.untracked.length; i += 1) untracked.push({ path: parsed.untracked[i], code: '??' })
+  const reply = {
+    ok: true, repo: target, branch: parsed.detached ? null : parsed.branch, detached: parsed.detached,
+    upstream: parsed.upstream, ahead: parsed.ahead, behind: parsed.behind,
+    sequencer: sequencer,
+    staged: parsed.staged, unstaged: parsed.unstaged, untracked: untracked, unmerged: parsed.unmerged,
+  }
+  /* A pathspec answer is about those paths and nothing else. It says so, and it
+     names them, so the client can fold it into the snapshot it already has
+     instead of mistaking it for the whole working tree. The whole-tree answer
+     carries neither key — the same convention the identity read uses. */
+  if (asked.length > 0) {
+    reply.partial = true
+    reply.paths = asked
+  }
+  return reply
+}
+
+async function panelSnapshot(input) {
+  const target = repoFrom(input, null)
+  if (target === undefined) return missingPanel(null, 'no-path')
+  /* Two tags, never one: a cheap answer cached under the full read's name would
+     hand an empty working tree to the changes tab. */
+  if (input != null && input.quick === true) {
+    return await cached(target, 'panel-ident', function () { return readPanelIdentity(input, target) })
+  }
+  const paths = readPaths(input)
+  if (paths.length > 0) {
+    /* A partial answer is cached under the question it answered: same paths, same
+       tag. Any mutation drops it with the rest of this repository's entries. */
+    return await cached(target, 'panel|' + paths.join('\u0001'), function () { return readPanel(input, target, paths) })
+  }
+  return await cached(target, 'panel', function () { return readPanel(input, target, []) })
+}
+
+async function readGraph(input, repo) {
+  const args = argsFor(input)
+  const requested = input != null && typeof input.maxCount === 'number' && input.maxCount > 0 ? Math.floor(input.maxCount) : 200
+  const maxCount = requested > 20000 ? 20000 : requested
+
+  const head = await git(args, ['-c', 'core.quotePath=false', 'symbolic-ref', '--quiet', '--short', 'HEAD'], null, {})
+  const currentBranch = head.exitCode === 0 ? head.stdout.trim() : null
+  const allRefs = input != null && input.allRefs === true
+  const asked = input != null && isStr(input.ref) && input.ref.trim().length > 0 ? input.ref.trim() : null
+  const ref = asked !== null ? asked : (currentBranch !== null && currentBranch.length > 0 ? currentBranch : 'HEAD')
+
+  const search = input != null && isStr(input.search) ? input.search.trim() : ''
+  const author = input != null && isStr(input.author) ? input.author.trim() : ''
+  const since = input != null && isStr(input.since) ? input.since.trim() : ''
+  const until = input != null && isStr(input.until) ? input.until.trim() : ''
+  const path = input != null && isStr(input.path) ? input.path.trim() : ''
+
+  /* The two switches the log's search box carries, both off by default so the
+     plain search is unchanged: `regex` hands the text to extended regexp
+     instead of matching it literally, and `caseSensitive` drops git's `-i`. */
+  const regex = input != null && input.regex === true
+  const caseSensitive = input != null && input.caseSensitive === true
+
+  /* One commit more than asked for: the extra row is not returned, it is how
+     "there is more history" is answered without a second read. */
+  const argv = ['-c', 'core.quotePath=false', 'log', '--max-count=' + String(maxCount + 1), '--date-order',
+    '--pretty=format:%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%s%x1f%D%x1f%P%x1e']
+  if ((search.length > 0 && regex !== true) || author.length > 0) argv.push('--fixed-strings')
+  if (search.length > 0) {
+    argv.push('--grep=' + search)
+    if (regex === true) argv.push('--extended-regexp')
+    if (caseSensitive !== true) argv.push('-i')
+  }
+  if (author.length > 0) argv.push('--author=' + author)
+  if (since.length > 0) argv.push('--since=' + since)
+  if (until.length > 0) argv.push('--until=' + until)
+  if (allRefs) argv.push('--all')
+  else argv.push(ref)
+  if (path.length > 0) { argv.push('--'); argv.push(path) }
+
+  const logged = await git(args, argv, null, {})
+  if (logged.exitCode !== 0) {
+    return { ok: false, repo: repo === undefined ? null : repo, error: 'not-a-repository', stderr: logged.stderr, currentBranch: currentBranch, ref: ref, commits: [], rows: [], lanes: 1 }
+  }
+  const parsed = parseCommitRecords(logged.stdout)
+  const hasMore = parsed.length > maxCount
+  const commits = hasMore ? parsed.slice(0, maxCount) : parsed
+  /* ── a filtered list is laid out on the history it was filtered out of ──
+
+     Anything that *hides* commits — the search box, an author, a date range, a
+     path — leaves the plain layout with parents it cannot see, and the lanes it
+     books for them are never claimed (see layoutVisible). So the plain
+     hash+parents history is read for the span those matches cover: everything
+     above the oldest match, plus the oldest itself (its parents came with the
+     filtered read). `--not <oldest>` is exactly that span, and it is what keeps
+     this read proportional to the answer instead of to the repository.
+
+     The scope is the same as the filtered read's — `--all` or the one ref — and
+     deliberately carries none of the hiding flags: this is the history, not the
+     answer. `DAG_MAX` bounds the walk for a search that matches rarely; past it
+     an edge simply leaves the page, which is what the unfiltered graph does at
+     the end of a page too. */
+  const hiding = search.length > 0 || author.length > 0 || since.length > 0 || until.length > 0 || path.length > 0
+  let layout = layoutGraph(commits, 14)
+  if (hiding && commits.length > 0) {
+    const oldest = commits[commits.length - 1].hash
+    const dagArgv = ['-c', 'core.quotePath=false', 'log', '--date-order', '--max-count=' + String(DAG_MAX),
+      '--pretty=format:%H %P']
+    if (allRefs) dagArgv.push('--all')
+    else dagArgv.push(ref)
+    dagArgv.push('--not')
+    dagArgv.push(oldest)
+    const dagged = await git(args, dagArgv, null, {})
+    if (dagged.exitCode === 0) {
+      const full = parseDag(dagged.stdout)
+      const last = commits[commits.length - 1]
+      full.push({ hash: last.hash, parents: last.parents })
+      layout = layoutVisible(full, commits, 14)
+    }
+  }
+  return {
+    ok: true, repo: logged.cwd, currentBranch: currentBranch, ref: ref, allRefs: allRefs,
+    commits: commits, rows: layout.rows, lanes: layout.lanes, hasMore: hasMore, maxCount: maxCount,
+  }
+}
+
+function graphTag(input) {
+  const part = function (value) { return value != null && isStr(value) ? value : '' }
+  return 'graph|' + [
+    input != null && input.allRefs === true ? '1' : '0',
+    part(input != null ? input.ref : null),
+    part(input != null ? input.search : null),
+    input != null && input.regex === true ? 're' : '',
+    input != null && input.caseSensitive === true ? 'cs' : '',
+    part(input != null ? input.author : null),
+    part(input != null ? input.since : null),
+    part(input != null ? input.until : null),
+    part(input != null ? input.path : null),
+    input != null && typeof input.maxCount === 'number' ? String(input.maxCount) : '',
+  ].join('\u0001')
+}
+
+async function graphSnapshot(input) {
+  const repo = repoFrom(input, null)
+  if (repo === undefined) return await readGraph(input, undefined)
+  return await cached(repo, graphTag(input), function () { return readGraph(input, repo) })
+}
+
+/* ─────────────── authors, refs, branches, and switching ─────────────── */
+
+async function readAuthors(input, repo) {
+  const args = argsFor(input)
+  const listed = await git(args, ['--no-pager', 'shortlog', '-sne', '--all'], null, { maxBytes: 200000 })
+  if (listed.exitCode !== 0) {
+    return { ok: false, repo: repo === undefined ? null : repo, error: 'not-a-repository', stderr: listed.stderr, authors: [] }
+  }
+  const authors = []
+  const rows = listed.stdout.split('\n')
+  for (let i = 0; i < rows.length && authors.length < 120; i += 1) {
+    const row = rows[i]
+    if (row.length === 0) continue
+    const tab = row.indexOf('\t')
+    if (tab < 0) continue
+    const count = parseInt(row.slice(0, tab).trim(), 10) || 0
+    const who = row.slice(tab + 1).trim()
+    if (who.length === 0) continue
+    const open = who.lastIndexOf('<')
+    const close = who.lastIndexOf('>')
+    const name = open > 0 ? who.slice(0, open).trim() : who
+    const email = open >= 0 && close > open ? who.slice(open + 1, close).trim() : ''
+    authors.push({ name: name, email: email, count: count })
+  }
+  return { ok: true, repo: listed.cwd, authors: authors }
+}
+
+/* shortlog walks the entire history for every author, so it is the most
+   expensive read there is. It is deferred by the client to the history tab and
+   then held until something invalidates it. */
+async function authorsSnapshot(input) {
+  const repo = repoFrom(input, null)
+  if (repo === undefined) return await readAuthors(input, undefined)
+  return await cached(repo, 'authors', function () { return readAuthors(input, repo) })
+}
+
+async function readRefs(input, repo) {
+  const args = argsFor(input)
+  /* The tracking columns matter as much as the names here: the tree is where a
+     branch and its standing against its upstream are seen together, and the
+     atoms are free once the command is running anyway. */
+  /* `gitC`, not `git`: %(upstream:track) is a translated string and parsing it
+     needs the same pinned locale the branch list already runs under. */
+  const listed = await gitC(args, ['-c', 'core.quotePath=false', 'for-each-ref',
+    '--format=%(refname)%1f%(refname:short)%1f%(HEAD)%1f%(objectname:short)%1f%(upstream:short)%1f%(upstream:track)%1f%(committerdate:unix)',
+    'refs/heads', 'refs/remotes'], null, {})
+  if (listed.exitCode !== 0) {
+    return { ok: false, repo: repo === undefined ? null : repo, error: 'not-a-repository', stderr: listed.stderr, current: [], local: [], remote: [] }
+  }
+  const local = []
+  const current = []
+  const remoteMap = new Map()
+  const rows = listed.stdout.split('\n')
+  for (let i = 0; i < rows.length; i += 1) {
+    if (rows[i].length === 0) continue
+    const fields = rows[i].split('\u001f')
+    const full = field(fields, 0)
+    const short = field(fields, 1)
+    const isCurrent = fields[2] === '*'
+    if (full.indexOf('refs/heads/') === 0) {
+      const counts = trackCounts(field(fields, 5))
+      local.push({
+        segments: short.split('/'), data: short,
+        upstream: field(fields, 4),
+        ahead: counts.ahead, behind: counts.behind,
+        at: parseInt(fields[6], 10) || 0,
+      })
+      if (isCurrent) current.push(short)
+    } else if (full.indexOf('refs/remotes/') === 0) {
+      const slash = short.indexOf('/')
+      const remoteName = slash < 0 ? short : short.slice(0, slash)
+      const rest = slash < 0 ? short : short.slice(slash + 1)
+      if (rest.length === 0 || rest === 'HEAD') continue
+      if (!remoteMap.has(remoteName)) remoteMap.set(remoteName, [])
+      remoteMap.get(remoteName).push({ segments: rest.split('/'), data: short })
+    }
+  }
+  const remote = []
+  remoteMap.forEach(function (entries, name) { remote.push({ name: name, refs: entries }) })
+  return { ok: true, repo: listed.cwd, current: current, local: local, remote: remote }
+}
+
+async function refsSnapshot(input) {
+  const repo = repoFrom(input, null)
+  if (repo === undefined) return await readRefs(input, undefined)
+  return await cached(repo, 'refs', function () { return readRefs(input, repo) })
+}
+
+/* "[ahead 2, behind 3]", "[behind 3]", "[gone]" — the words are English because
+   gitC pins the locale, and only the numbers are wanted here. */
+function trackCounts(raw) {
+  const out = { ahead: 0, behind: 0 }
+  const text = raw == null ? '' : String(raw)
+  const a = text.indexOf('ahead ')
+  if (a >= 0) out.ahead = parseInt(text.slice(a + 6), 10) || 0
+  const b = text.indexOf('behind ')
+  if (b >= 0) out.behind = parseInt(text.slice(b + 7), 10) || 0
+  return out
+}
+
+/* The branch switcher's own list, which the panel's sidebar is not: it is
+   ordered by when each branch last moved, and carries the things a chooser needs
+   but a tree does not — how long ago it moved, what it tracks, how far ahead or
+   behind that is, and where "the previous branch" is, so one row can undo a
+   mistaken switch.
+
+   Local and remote heads come from the same for-each-ref, so grouping them costs
+   nothing extra. A remote branch that already has a local branch of the same
+   name is dropped: the local row already names it as its upstream, and two rows
+   that both mean "dev" would be one row too many.
+
+   Two processes, once per repository per invalidation: the list, and rev-parse
+   for @{-1}, which exits 128 (not a failure worth reporting) in a repository
+   where nothing has been checked out yet. */
+async function readBranches(input, repo) {
+  const args = argsFor(input)
+  const listed = await gitC(args, ['-c', 'core.quotePath=false', 'for-each-ref',
+    '--format=%(refname)%1f%(refname:short)%1f%(HEAD)%1f%(committerdate:unix)%1f%(upstream:short)%1f%(upstream:trackshort)%1f%(upstream:track)%1f%(objectname:short)%1f%(contents:subject)',
+    '--sort=-committerdate', 'refs/heads', 'refs/remotes'], null, {})
+  if (listed.exitCode !== 0) {
+    return { ok: false, repo: repo === undefined ? null : repo, error: 'not-a-repository', stderr: listed.stderr, current: '', previous: '', branches: [], remotes: [] }
+  }
+  const branches = []
+  const remoteRows = []
+  const localNames = []
+  let current = ''
+  const rows = listed.stdout.split('\n')
+  for (let i = 0; i < rows.length; i += 1) {
+    if (rows[i].length === 0) continue
+    const fields = rows[i].split('\u001f')
+    const full = field(fields, 0)
+    const short = field(fields, 1)
+    if (short.length === 0) continue
+    const isCurrent = fields[2] === '*'
+    /* parseInt and a truthiness test rather than Number/isFinite: the restricted
+       Host realm is not the full JavaScript global scope, and parseInt is the one
+       converter the rest of this file already relies on. */
+    const stamp = parseInt(field(fields, 3), 10)
+    /* trackshort is symbols only (=, >, <, <>) and is never translated; the
+       numbers beside it come from :track, whose words are pinned to C by gitC. */
+    const counts = trackCounts(field(fields, 6))
+    const entry = {
+      name: short,
+      current: isCurrent,
+      committedAt: stamp > 0 ? stamp : 0,
+      upstream: field(fields, 4),
+      track: field(fields, 5),
+      ahead: counts.ahead,
+      behind: counts.behind,
+      head: field(fields, 7),
+      subject: field(fields, 8),
+    }
+    if (full.indexOf('refs/heads/') === 0) {
+      if (isCurrent) current = short
+      localNames.push(short)
+      branches.push(entry)
+    } else if (full.indexOf('refs/remotes/') === 0) {
+      const slash = short.indexOf('/')
+      if (slash <= 0) continue
+      const rest = short.slice(slash + 1)
+      if (rest.length === 0 || rest === 'HEAD') continue
+      remoteRows.push({
+        name: rest, remote: short.slice(0, slash), ref: short,
+        committedAt: entry.committedAt, head: entry.head, subject: entry.subject,
+        ahead: 0, behind: 0,
+      })
+    }
+  }
+  const remotes = []
+  for (let i = 0; i < remoteRows.length; i += 1) {
+    if (localNames.indexOf(remoteRows[i].name) < 0) remotes.push(remoteRows[i])
+  }
+  const prev = await git(args, ['rev-parse', '--abbrev-ref', '@{-1}'], null, {})
+  const previous = prev.exitCode === 0 ? prev.stdout.trim() : ''
+  return {
+    ok: true, repo: listed.cwd, current: current,
+    previous: previous === 'HEAD' || previous === current ? '' : previous,
+    branches: branches, remotes: remotes,
+  }
+}
+
+async function branchesSnapshot(input) {
+  const repo = repoFrom(input, null)
+  if (repo === undefined) return await readBranches(input, undefined)
+  return await cached(repo, 'branches', function () { return readBranches(input, repo) })
+}
+
+async function previousBranch(input) {
+  const prev = await git(argsFor(input), ['rev-parse', '--abbrev-ref', '@{-1}'], null, {})
+  if (prev.exitCode !== 0) return ''
+  const name = prev.stdout.trim()
+  return name === 'HEAD' ? '' : name
+}
+
+/* Switching with local changes in the way. git itself decides whether the
+   changes actually conflict, so the cheap path is to try the switch first and
+   only offer to stash when git refuses; stashing unconditionally would turn
+   every switch of a dirty tree into two extra writes and one more chance to
+   conflict on the way back.
+
+   When the caller does ask for the stash, the failure paths matter more than
+   the happy one: if the switch fails after the stash, the work goes back before
+   the error is reported, because leaving someone's edits in a stash they never
+   asked for is worse than the failed switch. A pop that conflicts is not hidden
+   either — git keeps the stash entry in that case, and the caller says so. */
+async function switchBranch(input, name) {
+  const args = argsFor(input)
+  const requested = repoFrom(input, null)
+  const finish = function (result, extra) {
+    invalidateRepo(requested !== undefined ? requested : result.cwd)
+    const out = extra == null ? {} : extra
+    out.ok = result.exitCode === 0
+    out.repo = result.cwd
+    out.stdout = result.stdout
+    out.stderr = result.stderr
+    out.exitCode = result.exitCode
+    out.command = result.command
+    out.sandboxDenied = result.sandboxDenied === true
+    return out
+  }
+
+  if (input == null || input.stash !== true) {
+    const moved = await git(args, ['switch', name], null, {})
+    return finish(moved, { stashed: false, dirty: 0, popConflict: false })
+  }
+
+  /* --no-optional-locks is a top-level option, so it has to sit before the
+     subcommand: git status rejects it in its own option list. Without it this
+     read fights the user's own `git add` for .git/index.lock. */
+  const before = await git(args, ['--no-optional-locks', 'status', '--porcelain=v1', '--untracked-files=normal'], null, {})
+  let dirty = 0
+  const lines = before.stdout.split('\n')
+  for (let i = 0; i < lines.length; i += 1) if (lines[i].length > 0) dirty += 1
+
+  let stashed = false
+  if (dirty > 0 && before.exitCode === 0) {
+    const saved = await git(args, ['stash', 'push', '-u', '-m', 'dsh-git-idea: switch to ' + name], null, {})
+    if (saved.exitCode !== 0) {
+      return finish(saved, { stashed: false, dirty: dirty, popConflict: false, error: 'stash-failed' })
+    }
+    stashed = true
+  }
+
+  const moved = await git(args, ['switch', name], null, {})
+  if (moved.exitCode !== 0) {
+    let restored = false
+    let restoreError = ''
+    if (stashed) {
+      const back = await git(args, ['stash', 'pop'], null, {})
+      restored = back.exitCode === 0
+      restoreError = restored ? '' : back.stderr
+    }
+    return finish(moved, {
+      stashed: stashed, restored: restored, restoreError: restoreError,
+      dirty: dirty, popConflict: false, error: 'switch-failed',
+    })
+  }
+
+  let popConflict = false
+  let popStdout = ''
+  let popStderr = ''
+  if (stashed) {
+    const popped = await git(args, ['stash', 'pop'], null, {})
+    popConflict = popped.exitCode !== 0
+    /* Which stream git chooses is not stable — a conflicting pop narrates the
+       merge on stdout and the failure on stderr — so both travel and the caller
+       shows whichever has something in it. */
+    popStdout = popped.stdout
+    popStderr = popped.stderr
+  }
+  return finish(moved, {
+    stashed: stashed, dirty: dirty, popConflict: popConflict,
+    popStdout: popStdout, popStderr: popStderr,
+  })
+}
+
+/* ─────────────── one commit, one file, one directory, and the one mutation ─────────────── */
+
+async function readCommitDetail(input) {
+  const hash = input != null && isStr(input.hash) ? input.hash.trim() : ''
+  if (hash.length === 0) return { ok: false, error: 'hash is required' }
+  const args = argsFor(input)
+  const meta = await git(args, ['-c', 'core.quotePath=false', 'show', '-s',
+    '--format=%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%s%x1f%b', hash], null, {})
+  if (meta.exitCode !== 0) return { ok: false, error: 'commit-not-found', stderr: meta.stderr }
+  const fields = meta.stdout.split('\u001f')
+
+  const files = []
+  const named = await git(args, ['-c', 'core.quotePath=false', 'show', '--name-status', '-z', '-M', '--first-parent', '--format=', hash], null, { maxBytes: 800000 })
+  if (named.exitCode === 0) {
+    const parts = named.stdout.split('\u0000')
+    let index = 0
+    while (index < parts.length) {
+      const status = parts[index]
+      if (status === undefined || status.length === 0) { index += 1; continue }
+      const head = status.charAt(0)
+      if (head === 'R' || head === 'C') {
+        const from = field(parts, index + 1)
+        const to = field(parts, index + 2)
+        files.push({ status: status, path: to, from: from })
+        index += 3
+      } else {
+        const path = field(parts, index + 1)
+        files.push({ status: status, path: path, from: null })
+        index += 2
+      }
+    }
+  }
+
+  const branches = []
+  const contains = await git(args, ['-c', 'core.quotePath=false', 'branch', '-a', '--contains', hash, '--format=%(refname:short)'], null, {})
+  if (contains.exitCode === 0) {
+    const rows = contains.stdout.split('\n')
+    for (let i = 0; i < rows.length; i += 1) if (rows[i].length > 0) branches.push(rows[i])
+  }
+
+  return {
+    ok: true,
+    hash: fields[0] === undefined ? hash : fields[0],
+    short: field(fields, 1),
+    author: field(fields, 2),
+    email: field(fields, 3),
+    date: field(fields, 4),
+    subject: field(fields, 5),
+    body: field(fields, 6).replace(/\s+$/, ''),
+    files: files,
+    branches: branches,
+  }
+}
+
+/* A commit is immutable, so its detail is held until the repository is mutated
+   (which cannot rewrite an existing hash, so this only frees memory). */
+async function commitDetailSnapshot(input) {
+  const hash = input != null && isStr(input.hash) ? input.hash.trim() : ''
+  if (hash.length === 0) return { ok: false, error: 'hash is required' }
+  const repo = repoFrom(input, null)
+  if (repo === undefined) return await readCommitDetail(input)
+  return await cached(repo, 'detail|' + hash, function () { return readCommitDetail(input) })
+}
+
+/* ── one file's change ──
+
+   The panel could say *which* files changed and nothing else. The changes tree
+   and the file list under a commit both ended on a dead row: there was no read
+   that returned a patch, so a file could be reported as modified and never shown
+   as modified. This is that read.
+
+   Four modes, because that is what the two lists can be looking at: the index
+   against HEAD (`staged`), the working tree against the index (`worktree`), one
+   commit (`commit`, with the old path of a rename travelling along — with only
+   the new path as a pathspec git reports the file as newly added instead), and a
+   file git has never seen (`untracked`, the one case with no HEAD side at all,
+   which needs `--no-index`).
+
+   Nothing is cached. The text is live, and the reader looking at it is the one
+   who just edited the file. `--no-color` because there is no terminal to read
+   colour, `--no-ext-diff` because a configured diff driver is not a viewer, and
+   `core.quotePath=false` so a non-ASCII path arrives as itself.
+
+   `--no-optional-locks` is the same rule every read here follows, and here it is
+   load-bearing rather than decorative: measured on this box after `touch f` made
+   the cached stat stale, a plain `git diff` rewrote `.git/index` in 2 of 20 runs
+   while the flagged one did 0 of 20 (`git status` writes 20 of 20) — a read that
+   may refresh the index may also take the lock, occasionally being exactly the
+   case that hurts. */
+const DIFF_MODES = ['worktree', 'staged', 'commit', 'untracked']
+const DIFF_LINES_MAX = 6000
+const DIFF_CHARS_MAX = 400000
+const DIFF_SHA = /^[0-9a-f]{7,40}$/i
+
+function diffArgv(mode, paths, ref) {
+  const common = ['--no-optional-locks', '-c', 'core.quotePath=false', 'diff', '--no-color', '--no-ext-diff']
+  if (mode === 'commit') {
+    /* `-m --first-parent` is what makes a merge commit readable: without it git
+       prints the combined diff, which for a clean merge is empty — the file list
+       would name a change and the patch would say there is none. */
+    return ['--no-optional-locks', '-c', 'core.quotePath=false', 'show', '--no-color', '--no-ext-diff',
+      '--format=', '--patch', '-m', '--first-parent', ref, '--'].concat(paths)
+  }
+  if (mode === 'untracked') return common.concat(['--no-index', '--', '/dev/null', paths[0]])
+  if (mode === 'staged') return common.concat(['--cached', '--']).concat(paths)
+  return common.concat(['--']).concat(paths)
+}
+
+/* The two numbers IDEA puts in the corner of a file row. `---`/`+++` are the
+   file headers rather than a removed and an added line. */
+function patchCounts(patch) {
+  let added = 0
+  let removed = 0
+  const lines = patch.split('\n')
+  for (let i = 0; i < lines.length; i += 1) {
+    const head = lines[i].charAt(0)
+    if (head === '+') { if (lines[i].indexOf('+++') !== 0) added += 1; continue }
+    if (head === '-') { if (lines[i].indexOf('---') !== 0) removed += 1; continue }
+  }
+  return { added: added, removed: removed }
+}
+
+/* A patch that is not text is not shown as text. A new binary file is printed by
+   git as its own bytes when the file happens to contain no NUL — measured here —
+   and a byte string with a NUL in it cannot survive being handed to a renderer
+   at all, so both are reported as "binary" with no body. */
+function patchLooksBinary(patch) {
+  if (patch.indexOf('\u0000') >= 0) return true
+  if (/^Binary files /m.test(patch)) return true
+  if (/^GIT binary patch/m.test(patch)) return true
+  return patchHasControlBytes(patch)
+}
+
+/* git decides "binary" from the first 8000 bytes, so a NUL-free blob is printed
+   as if it were text: measured here, 400 random bytes came back as one 524-byte
+   line of noise. Text does not carry C0 control characters, and a handful is
+   enough to tell. */
+function patchHasControlBytes(patch) {
+  let seen = 0
+  for (let i = 0; i < patch.length; i += 1) {
+    const code = patch.charCodeAt(i)
+    if (code === 9 || code === 10 || code === 13) continue
+    if (code < 32 || code === 127) {
+      seen += 1
+      if (seen > 8) return true
+    }
+  }
+  return false
+}
+
+async function readFileDiff(input) {
+  const mode = input != null && isStr(input.mode) ? input.mode.trim() : ''
+  if (DIFF_MODES.indexOf(mode) < 0) {
+    return { ok: false, error: 'unknown-mode', exitCode: null, stderr: 'mode must be one of ' + DIFF_MODES.join(', ') }
+  }
+  const path = input != null && isStr(input.path) ? input.path : ''
+  const bad = repoRelativePath(path)
+  if (bad.length > 0) return { ok: false, error: 'invalid-path', exitCode: null, stderr: bad }
+
+  const from = input != null && isStr(input.from) ? input.from : ''
+  const ref = input != null && isStr(input.ref) ? input.ref.trim() : ''
+  if (mode === 'commit' && !DIFF_SHA.test(ref)) {
+    return { ok: false, error: 'invalid-ref', exitCode: null, stderr: 'a commit hash is required' }
+  }
+  const paths = from.length > 0 && from !== path ? [from, path] : [path]
+
+  const result = await git(argsFor(input), diffArgv(mode, paths, ref), null, { maxBytes: 1200000 })
+  /* `git diff --no-index` says "these differ" with exit code 1 and a perfectly
+     good patch on stdout; every other mode says it with exit code 0. */
+  const produced = result.exitCode === 0 || (mode === 'untracked' && result.exitCode === 1 && result.stdout.length > 0)
+  if (!produced) {
+    return { ok: false, error: 'diff-failed', exitCode: result.exitCode, stderr: result.stderr, mode: mode, path: path }
+  }
+
+  const binary = patchLooksBinary(result.stdout)
+  const counts = binary ? { added: 0, removed: 0 } : patchCounts(result.stdout)
+  let patch = binary ? '' : result.stdout
+  let truncated = result.truncated === true
+  const lines = patch.split('\n')
+  if (lines.length > DIFF_LINES_MAX) {
+    patch = lines.slice(0, DIFF_LINES_MAX).join('\n')
+    truncated = true
+  }
+  if (patch.length > DIFF_CHARS_MAX) {
+    patch = patch.slice(0, DIFF_CHARS_MAX)
+    truncated = true
+  }
+  return {
+    ok: true, mode: mode, path: path, from: from, ref: ref,
+    text: patch, added: counts.added, removed: counts.removed,
+    binary: binary, truncated: truncated, empty: patch.length === 0,
+    exitCode: result.exitCode,
+  }
+}
+
+/* ── what is inside an untracked directory ──
+
+   git reports an untracked directory as one entry ending in "/" and says nothing
+   about what is in it, which is exactly why the panel could not show those files:
+   it had nothing to show. Ticking the row needs no answer (`git add -- dir`
+   takes the whole thing); opening it is a second, deliberate act, and that is the
+   right moment to pay — `-uall` on a repository with one large untracked tree is
+   the cost git's own collapsing exists to avoid.
+
+   `ls-files --others --exclude-standard` lists the files `git add <dir>` would
+   take, honours .gitignore the same way, and is a read: `--no-optional-locks`,
+   no index write. Not cached — the directory is the thing most likely to be
+   changing while the reader looks at it. */
+const UNTRACKED_FILES_MAX = 2000
+
+async function readUntrackedTree(input) {
+  const raw = input != null && isStr(input.dir) ? input.dir : ''
+  const dir = raw.replace(/\/+$/, '')
+  const bad = repoRelativePath(dir)
+  if (bad.length > 0) return { ok: false, error: 'invalid-path', stderr: bad }
+  const result = await git(argsFor(input), ['--no-optional-locks', '-c', 'core.quotePath=false',
+    'ls-files', '--others', '--exclude-standard', '-z', '--', dir], null, { maxBytes: 800000 })
+  if (result.exitCode !== 0) {
+    return { ok: false, error: 'ls-files-failed', exitCode: result.exitCode, stderr: result.stderr, dir: dir }
+  }
+  const files = []
+  const parts = result.stdout.split('\u0000')
+  for (let i = 0; i < parts.length; i += 1) {
+    if (parts[i].length > 0 && files.length < UNTRACKED_FILES_MAX) files.push(parts[i])
+  }
+  return {
+    ok: true, dir: dir, files: files,
+    truncated: result.truncated === true || parts.length > UNTRACKED_FILES_MAX + 1,
+  }
+}
+
+async function panelMutate(input, argv, options) {
+  const opts = options == null ? {} : options
+  const requested = repoFrom(input, null)
+  const runner = opts.net === true ? gitNet : git
+  const result = await runner(argsFor(input), argv, null, opts.spawn == null ? {} : opts.spawn)
+  /* Unconditionally, not only on success: a conflicting cherry-pick, merge or
+     revert changes the index and the working tree and then exits non-zero, so
+     gating on exitCode === 0 would leave the panel showing the pre-conflict
+     state and hide the very banner that gets the user out of it. */
+  invalidateRepo(requested !== undefined ? requested : result.cwd)
+  return {
+    ok: result.exitCode === 0, repo: result.cwd, stdout: result.stdout,
+    stderr: result.stderr, exitCode: result.exitCode, command: result.command,
+    /* Says outright that the file sandbox refused the write, so the reader is not
+       left reading git's "Permission denied" as a problem with their repository. */
+    sandboxDenied: result.sandboxDenied === true,
+  }
+}
+
+function panelPaths(input) {
+  return input != null && Array.isArray(input.paths) ? input.paths.filter(isStr) : []
+}
+
+/* ── plugin-side configuration ──
+
+   Split from the browser-local presentation preferences on purpose. "Which
+   branch should a new repository start on" is a property of this plugin, not of
+   whoever happens to be looking at it, so it belongs beside the deployment's
+   own settings rather than in one browser's localStorage. When this becomes an
+   ordinary plugin this file is exactly what its config section would own. */
+
+let configPathCache
+let configCache = null
+
+async function configPath() {
+  if (configPathCache !== undefined) return configPathCache
+  const probe = await invoke('printf %s "${DSH_HOME:-$HOME/.dsh}"', {}, null, { timeoutMs: 10000 })
+  const home = probe.exitCode === 0 ? probe.stdout.trim() : ''
+  configPathCache = home.length > 0 ? home + '/dsh-git-idea.json' : null
+  return configPathCache
+}
+
+function normalizeConfig(raw) {
+  const out = { initBranch: 'main', cherryPickRecord: false }
+  if (raw == null || typeof raw !== 'object') return out
+  if (isStr(raw.initBranch)) out.initBranch = raw.initBranch.trim().slice(0, 120)
+  out.cherryPickRecord = raw.cherryPickRecord === true
+  return out
+}
+
+async function readConfigFile() {
+  if (configCache !== null) return configCache
+  const path = await configPath()
+  const fsService = ctx.get('fs')
+  if (path === null || fsService === undefined) { configCache = normalizeConfig(null); return configCache }
+  try {
+    const target = await fsService.resolve(path)
+    const info = await fsService.stat(target)
+    if (info === undefined) { configCache = normalizeConfig(null); return configCache }
+    configCache = normalizeConfig(JSON.parse(await fsService.readText(target)))
+  } catch (error) {
+    console.error('dsh-git-idea: could not read the plugin config', String(error))
+    configCache = normalizeConfig(null)
+  }
+  return configCache
+}
+
+async function writeConfigFile(raw) {
+  const path = await configPath()
+  if (path === null) return { ok: false, error: '无法确定配置目录' }
+  const fsService = ctx.get('fs')
+  if (fsService === undefined) return { ok: false, error: '文件系统服务不可用' }
+  const next = normalizeConfig(raw)
+  try {
+    const target = await fsService.resolve(path)
+    await fsService.writeText(target, JSON.stringify(next, null, 2) + '\n')
+    configCache = next
+    return { ok: true, path: path, config: next }
+  } catch (error) {
+    const detail = error != null && error.message !== undefined ? String(error.message) : String(error)
+    return { ok: false, error: detail, path: path }
+  }
+}
+
+async function initSnapshot(input) {
+  const target = repoFrom(input, null)
+  if (target === undefined) return { ok: false, error: 'no-path', stderr: '无法确定要初始化的目录', repo: null }
+  const kind = await pathKind(input, target)
+  if (kind !== 'dir') {
+    return {
+      ok: false, error: 'bad-path', repo: target,
+      stderr: kind === 'file' ? '目标是一个文件，不是目录' : '目标目录不存在，无法在此初始化仓库',
+    }
+  }
+  const branch = input != null && isStr(input.branch) ? input.branch.trim() : ''
+  /* Through `argsAt`, so the session id survives: `git init` is a write, and a
+     request that loses its session runs under the deployment's default sandbox
+     policy rather than this reader's — which is a "Permission denied" on a
+     directory the reader can write to perfectly well. */
+  const args = argsAt(input, target)
+  if (branch.length > 0) return await panelMutate(args, ['init', '-b', branch])
+  return await panelMutate(args, ['init'])
+}
+
+/* Every request the Client can make, in one table. Each handler is registered
+   through `ctx.effect` so it belongs to this fiber: stopping or updating the
+   Package removes all of them, which is what makes the bridge's reload safe. */
+function onRpc(name, handler) {
+  ctx.effect(function () { return harness.handle(name, handler) }, 'dsh-git-idea rpc ' + name)
+}
+
+onRpc('git/panel', function (input) { return panelSnapshot(input) })
+
+onRpc('git/init', function (input) { return initSnapshot(input) })
+
+/* The client's refresh button must be able to force a re-read; without this it
+   would only repaint whatever the read cache already held. */
+onRpc('git/flush', function (input) {
+  invalidateRepo(repoFrom(input, null))
+  return { ok: true }
+})
+
+onRpc('git/config', function () {
+  return configPath().then(function (path) {
+    return readConfigFile().then(function (config) {
+      return { ok: true, path: path, config: config }
+    })
+  })
+})
+
+onRpc('git/config-save', function (input) {
+  return writeConfigFile(input != null ? input.config : null)
+})
+
+/* Never cached: its whole purpose is to observe change. `paths` narrows the
+   working-tree half of the signature to what is on screen — see watchCommand for
+   what a whole-tree status costs on a slow mount. */
+onRpc('git/watch', function (input) {
+  const target = repoFrom(input, null)
+  if (target === undefined) return { ok: false, repo: null, sig: '' }
+  const deep = input != null && input.deep === true
+  const paths = deep ? readPaths(input) : []
+  return probeShell(input, watchCommand(target, deep, paths)).then(function (probe) {
+    return { ok: true, repo: target, sig: probe.stdout, paths: paths }
+  })
+})
+
+onRpc('git/graph', function (input) { return graphSnapshot(input) })
+
+onRpc('git/authors', function (input) { return authorsSnapshot(input) })
+
+onRpc('git/refs', function (input) { return refsSnapshot(input) })
+
+onRpc('git/branches', function (input) { return branchesSnapshot(input) })
+
+onRpc('git/commit-detail', function (input) { return commitDetailSnapshot(input) })
+
+/* The one read the panel asks for by path rather than by repository: the patch
+   behind a row in the changes tree or in a commit's file list. Never cached —
+   it is the live text of a file the reader is looking at. */
+onRpc('git/diff', function (input) { return readFileDiff(input) })
+
+/* git collapses an untracked directory into a single entry; this is what is
+   inside it, asked for only when the reader opens that row. */
+onRpc('git/untracked', function (input) { return readUntrackedTree(input) })
+
+onRpc('git/stage', function (input) {
+  const paths = panelPaths(input)
+  if (paths.length === 0) return { ok: false, error: 'no paths given' }
+  return panelMutate(input, ['add', '--'].concat(paths))
+})
+
+onRpc('git/unstage', function (input) {
+  const paths = panelPaths(input)
+  if (paths.length === 0) return { ok: false, error: 'no paths given' }
+  return panelMutate(input, ['restore', '--staged', '--'].concat(paths))
+})
+
+onRpc('git/commit', function (input) {
+  const message = input != null && isStr(input.message) ? input.message.trim() : ''
+  if (message.length === 0) return { ok: false, error: 'a commit message is required' }
+  if (input != null && input.stageAll === true) {
+    return panelMutate(input, ['add', '-A']).then(function (staged) {
+      if (staged.ok !== true) return staged
+      return panelMutate(input, ['commit', '-m', message])
+    })
+  }
+  return panelMutate(input, ['commit', '-m', message])
+})
+
+onRpc('git/checkout', async function (input) {
+  const name = input != null && isStr(input.name) ? input.name.trim() : ''
+  if (name.length === 0) return { ok: false, error: 'a branch name is required' }
+  /* `-` is git's own shorthand for the previous branch; resolve it here so the
+     caller never has to know that the switcher's "previous" row and this
+     argument are the same idea. */
+  let target = name
+  if (name === '-') {
+    target = await previousBranch(input)
+    if (target.length === 0) return { ok: false, error: 'there is no previous branch to switch back to' }
+  }
+  return await switchBranch(input, target)
+})
+
+const NET_SPAWN = { timeoutMs: 180000 }
+
+onRpc('git/fetch', function (input) {
+  return panelMutate(input, ['fetch', '--all', '--prune'], { net: true, spawn: NET_SPAWN })
+})
+
+onRpc('git/pull', function (input) {
+  return panelMutate(input, ['pull'], { net: true, spawn: NET_SPAWN })
+})
+
+onRpc('git/push', function (input) {
+  if (input != null && input.setUpstream === true) {
+    const remote = input != null && isStr(input.remote) && input.remote.trim().length > 0 ? input.remote.trim() : ''
+    const branch = input != null && isStr(input.branch) ? input.branch.trim() : ''
+    if (remote.length === 0) return { ok: false, error: 'no remote is configured to push to' }
+    if (branch.length === 0) return { ok: false, error: 'a branch is required to set an upstream' }
+    return panelMutate(input, ['push', '-u', remote, branch], { net: true, spawn: NET_SPAWN })
+  }
+  return panelMutate(input, ['push'], { net: true, spawn: NET_SPAWN })
+})
+
+/* cherry-pick, revert and merge share one entry point because they also share
+   the way they stop half-done: continue, skip or abort has to be reachable or a
+   conflicted panel would trap the user with no way back. */
+const SEQUENCER_OPS = ['cherry-pick', 'revert', 'merge']
+
+onRpc('git/sequence', function (input) {
+  const op = input != null && isStr(input.op) ? input.op : ''
+  const action = input != null && isStr(input.action) ? input.action : ''
+  const target = input != null && isStr(input.target) ? input.target.trim() : ''
+  if (SEQUENCER_OPS.indexOf(op) < 0) return { ok: false, error: 'unknown operation ' + op }
+
+  if (op === 'merge') {
+    if (action === 'start') {
+      if (target.length === 0) return { ok: false, error: 'a branch or commit is required to merge' }
+      return panelMutate(input, ['merge', '--no-edit', target])
+    }
+    if (action === 'continue') return panelMutate(input, ['commit', '--no-edit'])
+    if (action === 'abort') return panelMutate(input, ['merge', '--abort'])
+    return { ok: false, error: 'merge supports start, continue and abort' }
+  }
+
+  if (action === 'start') {
+    if (target.length === 0) return { ok: false, error: 'a commit is required' }
+    if (op === 'revert') return panelMutate(input, ['revert', '--no-edit', target])
+    if (input != null && input.record === true) return panelMutate(input, ['cherry-pick', '-x', target])
+    return panelMutate(input, ['cherry-pick', target])
+  }
+  if (action === 'continue') return panelMutate(input, ['-c', 'core.editor=true', op, '--continue'])
+  if (action === 'abort') return panelMutate(input, [op, '--abort'])
+  if (action === 'skip') return panelMutate(input, [op, '--skip'])
+  return { ok: false, error: op + ' does not support ' + action }
+})
+
+onRpc('git/branch-create', function (input) {
+  const name = input != null && isStr(input.name) ? input.name.trim() : ''
+  if (name.length === 0) return { ok: false, error: 'a branch name is required' }
+  const at = input != null && isStr(input.at) ? input.at.trim() : ''
+  if (at.length > 0) return panelMutate(input, ['switch', '-c', name, at])
+  return panelMutate(input, ['switch', '-c', name])
+})
+
+onRpc('git/branch-delete', function (input) {
+  const name = input != null && isStr(input.name) ? input.name.trim() : ''
+  if (name.length === 0) return { ok: false, error: 'a branch name is required' }
+  const force = input != null && input.force === true
+  return panelMutate(input, ['branch', force ? '-D' : '-d', name])
+})
+
+onRpc('git/tag', function (input) {
+  const name = input != null && isStr(input.name) ? input.name.trim() : ''
+  if (name.length === 0) return { ok: false, error: 'a tag name is required' }
+  const at = input != null && isStr(input.at) ? input.at.trim() : ''
+  if (at.length > 0) return panelMutate(input, ['tag', name, at])
+  return panelMutate(input, ['tag', name])
+})
+
+  },
+}
+})()
+
+/* The body's own apply, plus the one thing the bridge used to own: the
+   transport to the browser half. \`webServer\` is optional at the type level but
+   present in every web profile; without it the model tools still register and
+   only the panel goes quiet. */
+export function apply(ctx, config) {
+  ctx.inject(['webServer'], function (scope) {
+    scope.effect(function () {
+      return scope.webServer.register({ kind: 'exact', path: RPC_PATH, handler: rpcRoute })
+    }, 'dsh-git-idea rpc route')
+  })
+  return plugin.apply(ctx, config)
+}
+
+/* \`tools\` is the only hard dependency: every fragment reaches it through
+   \`harness.registerTool\`. Every other service is read with \`ctx.get\` and guarded. */
+export const inject = ['tools']