@askdkc/dsh-cli 0.11.3

package/presets/liangshen/custom-bash.mjs

@@ -0,0 +1,301 @@
+/**
+ * custom-bash — a Windows-capable `bash` tool that registers under the SAME
+ * name (`bash`) as the official persistent bash, with a Minimal-compatible
+ * description, but executes through `ctx.subprocess.spawn` instead of a PTY.
+ *
+ * WHY: DeepSeek's first-request trajectory anchor keys on the tool SCHEMA
+ * matching the RL training distribution (issue #11: persistent
+ * bash + str_replace_editor anchored 5/5 at maxTokens=256000, pwsh/read
+ * 8/8 standard-like). The official persistent bash uses a PTY, and DSH's PTY
+ * backend is linux/darwin-only — `subprocess-local` throws "terminal
+ * inspection is unsupported on platform win32". A custom tool that presents
+ * the same name and a Minimal-like description but spawns Git Bash through
+ * the ordinary (cross-platform) subprocess seam keeps the schema anchor
+ * without the PTY dependency.
+ *
+ * Executable resolution, in order (an explicit entry is the ONLY candidate:
+ * a miss fails loudly instead of silently substituting a guess):
+ *  1. explicit `config.bashPath` or the `DSH_TUI_LIANGSHEN_BASH_PATH`
+ *     environment variable (absolute path to a Git Bash bash.exe);
+ *  2. a `git` on PATH followed to its installation tree — every Windows Git
+ *     install ships bash next to git, wherever it was installed, so this
+ *     covers installer, portable, and Scoop layouts (a Scoop `.shim` sidecar
+ *     is followed to the real target) — yielding `<root>\bin\bash.exe` and
+ *     `<root>\usr\bin\bash.exe`;
+ *  3. conventional install roots (`ProgramFiles`, `ProgramFiles(x86)`,
+ *     `%LOCALAPPDATA%\Programs\Git`);
+ *  4. Scoop's conventional roots (`%SCOOP%`, else `%USERPROFILE%\scoop`)
+ *     under `apps\git\current\` — Scoop does not always export `SCOOP`;
+ *  5. bare `bash` on PATH.
+ * `C:\Windows\System32\bash.exe` (and Sysnative) is the WSL launcher, not
+ * the Git Bash executor: it is ALWAYS rejected, so a PATH lookup can never
+ * silently hand the model a WSL shell. Resolution runs ONCE at apply time —
+ * a total miss warns and SKIPS registration, so `tool-bootstrap`'s
+ * missing-tool path fails open to the full catalog instead of registering a
+ * `bash` tool whose every call would fail mid-session.
+ *
+ * Semantics mirror the official bash tool: `bash -c <command>` in a fresh
+ * process, bounded output, non-zero exit reported not thrown. No sandbox
+ * confinement on Windows (the sandbox backend is linux-only); the tool
+ * description says so. The bootstrap catalog pairs this with
+ * `str_replace_editor` (Minimal's two tools).
+ */
+
+import { readFileSync } from 'node:fs'
+
+/** Cordis plugin name used by loader diagnostics. */
+export const name = 'custom-bash'
+
+/** The subprocess and tools services must exist before this tool can register. */
+export const inject = ['subprocess', 'tools']
+
+const DEFAULT_TIMEOUT_MS = 120000
+const DEFAULT_MAX_OUTPUT_BYTES = 64000
+
+/** Tool parameter schema for the model-facing command. */
+const commandSchema = {
+  type: 'object',
+  properties: {
+    command: {
+      type: 'string',
+      description: 'The bash command to execute (`bash -c` string domain).',
+    },
+    workdir: {
+      type: 'string',
+      description: 'Optional working directory; defaults to the session cwd.',
+    },
+  },
+  required: ['command'],
+  additionalProperties: false,
+}
+
+function addCandidate(candidates, seen, candidate) {
+  if (typeof candidate !== 'string' || candidate.length === 0) return
+  const key = candidate.toLowerCase()
+  if (seen.has(key)) return
+  seen.add(key)
+  candidates.push(candidate)
+}
+
+/** The explicit override, if any: `config.bashPath`, else the environment variable. */
+function explicitBashPath(config, environment) {
+  for (const value of [config.bashPath, environment.DSH_TUI_LIANGSHEN_BASH_PATH]) {
+    if (typeof value === 'string' && value.length > 0) return value
+  }
+  return undefined
+}
+
+/** Return conventional Git Bash locations in deterministic order (explicit config first). */
+export function windowsBashCandidates(config = {}, environment = process.env) {
+  const explicit = explicitBashPath(config, environment)
+  if (explicit !== undefined) return [explicit]
+
+  const candidates = []
+  const seen = new Set()
+  for (const root of [
+    environment.ProgramFiles,
+    environment['ProgramFiles(x86)'],
+  ]) {
+    if (typeof root !== 'string' || root.length === 0) continue
+    addCandidate(candidates, seen, `${root}\\Git\\bin\\bash.exe`)
+    addCandidate(candidates, seen, `${root}\\Git\\usr\\bin\\bash.exe`)
+  }
+  if (typeof environment.LOCALAPPDATA === 'string' && environment.LOCALAPPDATA.length > 0) {
+    addCandidate(candidates, seen, `${environment.LOCALAPPDATA}\\Programs\\Git\\bin\\bash.exe`)
+    addCandidate(candidates, seen, `${environment.LOCALAPPDATA}\\Programs\\Git\\usr\\bin\\bash.exe`)
+  }
+  // Scoop keeps Git under its own root; SCOOP is exported by some setups, but
+  // the per-user default location works without it.
+  const scoopRoots = []
+  if (typeof environment.SCOOP === 'string' && environment.SCOOP.length > 0) {
+    scoopRoots.push(environment.SCOOP)
+  }
+  if (typeof environment.USERPROFILE === 'string' && environment.USERPROFILE.length > 0) {
+    scoopRoots.push(`${environment.USERPROFILE}\\scoop`)
+  }
+  for (const root of scoopRoots) {
+    addCandidate(candidates, seen, `${root}\\apps\\git\\current\\bin\\bash.exe`)
+    addCandidate(candidates, seen, `${root}\\apps\\git\\current\\usr\\bin\\bash.exe`)
+  }
+  addCandidate(candidates, seen, 'bash')
+  return candidates
+}
+
+/** Windows' System32 bash.exe is a WSL launcher, not the Git Bash executor. */
+export function isWindowsSubsystemLauncher(path) {
+  return /[\\/]windows[\\/](?:system32|sysnative)[\\/]bash\.exe$/i.test(path)
+}
+
+/**
+ * Scoop-style shim launchers keep the real target in a sibling `.shim` text
+ * file (`path = "..."`); follow it so a PATH-resolved git.exe still yields
+ * its installation tree.
+ */
+export function resolveShimTarget(exePath, reader = readFileSync) {
+  for (const sidecar of [exePath.replace(/\.exe$/i, '') + '.shim', `${exePath}.shim`]) {
+    try {
+      const text = reader(sidecar, 'utf8')
+      const match = text.match(/^\s*path\s*=\s*"?(.+?)"?\s*$/mi)
+      if (match !== null) return match[1]
+    } catch { /* not a shim launcher */ }
+  }
+  return exePath
+}
+
+/** Bash candidates derived from a git.exe inside a Git for Windows tree. */
+export function bashCandidatesFromGit(gitPath) {
+  if (typeof gitPath !== 'string' || gitPath.length === 0) return []
+  const parts = gitPath.replace(/\//g, '\\').split('\\').filter(part => part.length > 0)
+  if (parts.at(-1)?.toLowerCase() !== 'git.exe') return []
+  const roots = []
+  const push = root => {
+    if (root.length > 0 && !roots.includes(root)) roots.push(root)
+  }
+  // <root>\cmd\git.exe and <root>\bin\git.exe -> <root>
+  if (parts.length >= 3) push(parts.slice(0, -2).join('\\'))
+  // <root>\mingw64\bin\git.exe -> <root>; a plain <root>\cmd layout must not
+  // also strip its real root.
+  if (parts.length >= 5
+    && parts.at(-2)?.toLowerCase() === 'bin'
+    && /^mingw(32|64)$/.test(parts.at(-3) ?? '')) {
+    push(parts.slice(0, -3).join('\\'))
+  }
+  const candidates = []
+  for (const root of roots) {
+    candidates.push(`${root}\\bin\\bash.exe`, `${root}\\usr\\bin\\bash.exe`)
+  }
+  return candidates
+}
+
+/**
+ * Follow the PATH-visible git executable to its installation tree: every
+ * Windows Git install ships git-bash next to git, wherever it was installed,
+ * so this covers installer, portable, and Scoop layouts without hardcoding.
+ */
+async function gitTreeCandidates(subprocess, failures) {
+  let gitPath
+  try {
+    gitPath = await subprocess.resolveExecutable('git')
+  } catch (error) {
+    failures.push(`git: ${error instanceof Error ? error.message : String(error)}`)
+    return []
+  }
+  return bashCandidatesFromGit(resolveShimTarget(gitPath))
+}
+
+/** Resolve Git Bash without accidentally accepting the WSL compatibility shim. */
+export async function resolveWindowsBash(subprocess, config = {}, environment = process.env) {
+  const failures = []
+  const explicit = explicitBashPath(config, environment)
+  const candidates = explicit !== undefined
+    // An explicit path is honored as-is: never silently substitute a guess.
+    ? [explicit]
+    : [...await gitTreeCandidates(subprocess, failures), ...windowsBashCandidates(config, environment)]
+  for (const candidate of candidates) {
+    try {
+      const resolved = await subprocess.resolveExecutable(candidate)
+      if (isWindowsSubsystemLauncher(resolved)) {
+        failures.push(`${candidate}: resolved to the Windows Subsystem for Linux launcher`)
+        continue
+      }
+      return resolved
+    } catch (error) {
+      failures.push(`${candidate}: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+  throw new Error(`Git Bash executable unavailable (${failures.join('; ')})`)
+}
+
+function warn(ctx, message) {
+  try {
+    ctx.logger.warn(message)
+  } catch {
+    // Logger unavailable — registration is skipped either way.
+  }
+}
+
+/** Register the model-facing `bash` tool. */
+export async function apply(ctx, config) {
+  const source = config === undefined ? {} : config
+  const timeoutMs = Number.isSafeInteger(source.timeoutMs) && source.timeoutMs > 0 ? source.timeoutMs : DEFAULT_TIMEOUT_MS
+  const maxOutputBytes = Number.isSafeInteger(source.maxOutputBytes) && source.maxOutputBytes > 0 ? source.maxOutputBytes : DEFAULT_MAX_OUTPUT_BYTES
+
+  let bashPath
+  try {
+    bashPath = await resolveWindowsBash(ctx.subprocess, source)
+  } catch (error) {
+    // Skip registration on a miss: an absent `bash` in the assembled catalog
+    // makes tool-bootstrap fail open to the full catalog, while a registered
+    // tool that cannot spawn would fail on every call mid-session.
+    warn(ctx, `custom-bash: ${error instanceof Error ? error.message : String(error)} — the Windows bootstrap bash tool is not registered; the bootstrap filter will expose the full catalog`)
+    return
+  }
+
+  ctx.tools.register({
+    name: 'bash',
+    description: [
+      'Run commands in a bash shell (Git Bash on Windows)',
+      '* When invoking this tool, the contents of the "command" parameter does NOT need to be XML-escaped.',
+      "* You don't have access to the internet via this tool.",
+      '* You do have access to a mirror of common linux and python packages via apt and pip.',
+      '* State does NOT persist across command calls: each call runs in a fresh shell.',
+      "* To inspect a particular line range of a file, e.g. lines 10-25, try 'sed -n 10,25p /path/to/the/file'.",
+      '* Please avoid commands that may produce a very large amount of output.',
+      '* NOTE: runs without OS sandbox confinement on Windows (no landlock); treat output as untrusted.',
+    ].join('\n'),
+    parameters: commandSchema,
+    timeoutMs,
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          text: { type: 'string' },
+        },
+        required: ['text'],
+      },
+      render: (_args, value) => [{ type: 'text', text: value.text }],
+    },
+    async execute(args, exec) {
+      const workdir = typeof args.workdir === 'string' && args.workdir.length > 0
+        ? args.workdir
+        : exec?.agent?.session?.header?.cwd
+      const signal = exec?.signal
+      const handle = ctx.subprocess.spawn({
+        argv: [bashPath, '-c', args.command],
+        ...workdir !== undefined ? { cwd: workdir } : {},
+        stdio: {
+          stdin: 'ignore',
+          stdout: { maxBytes: maxOutputBytes },
+          stderr: { maxBytes: maxOutputBytes },
+        },
+        ...signal !== undefined ? { signal } : {},
+        graceMs: 3000,
+      })
+      let outcome
+      try {
+        outcome = await handle.done
+      } catch (error) {
+        // A spawn-level failure (bad executable, EPERM) surfaces as a throw,
+        // which the runtime turns into an isError result.
+        throw new Error(`bash spawn failed: ${String(error)}`)
+      }
+      let stdout = ''
+      let stderr = ''
+      try {
+        stdout = handle.collected.stdout.readFrom(0).text
+        stderr = handle.collected.stderr.readFrom(0).text
+      } catch {
+        // Collected readers may be unavailable on some backends; tolerate.
+      }
+      const text = [stdout, stderr].filter((part) => part.length > 0).join('\n')
+      const tail = text.length > 0 ? text : `exit code: ${outcome.exitCode} (no output)`
+      if (outcome.exitCode !== 0) {
+        // Non-zero exit is a reported failure, not a throw: the model sees the
+        // command output plus the exit code.
+        throw new Error(tail)
+      }
+      return { text: tail }
+    },
+  })
+}

package/presets/liangshen/instruction-hint.mjs

@@ -0,0 +1,190 @@
+/**
+ * instruction-hint — replace `dsh-agent-instructions`' full AGENTS.md/CLAUDE.md
+ * injection with a minimal "these files exist" hint.
+ *
+ * WHY: the full workspace-instruction digest is a large injected block. After
+ * the anchored bootstrap promotes, we want the model to KNOW the instruction
+ * files exist (so it reads them before acting) without dumping their content
+ * into every request. The model reads the files itself via the filesystem
+ * tools when it needs them.
+ *
+ * Behavior:
+ *  - After the session records its first durable promotion signal
+ *    (`promoteOn`, default `either`), ONE hint message is injected (once per
+ *    session — durable event scan, resume-safe), listing which instruction
+ *    files were found:
+ *      - user-global: `$DSH_HOME/AGENTS.md`
+ *      - project chain: AGENTS.md / CLAUDE.md / AGENTS.local.md / CLAUDE.local.md
+ *        walking up from the session cwd to the project root (a directory
+ *        containing `.git`, or the cwd itself).
+ *  - The hint instructs the model to READ the files before acting when
+ *    relevant, without embedding their content.
+ *  - Files are probed via `ctx.fs` (the host filesystem seam); a missing fs
+ *    service or an unreadable probe degrades to no hint (never throws).
+ *  - Pre-promotion requests get NO hint (matches the anchored bootstrap).
+ *
+ * ROW ORDER: this plugin registers its `agent/pre-step` handler with
+ * `prepend: true` and after `tool-bootstrap`, so it runs inside the
+ * bootstrap's outermost strip — but it emits AFTER promotion, when the strip
+ * is inactive. The hint source kind is `instruction-hint`, which is NOT in
+ * `suppressedContextSources`, so it is never stripped.
+ */
+
+import { createEpochPromotion } from './compaction-epoch.mjs'
+import { snapshotSessionEvents } from './session-events.mjs'
+
+/** Cordis plugin name used by loader diagnostics. */
+export const name = 'instruction-hint'
+
+/** Durable session event types that count as a promotion signal per mode. */
+const PROMOTE_EVENTS = {
+  'tool-call': ['tool/call'],
+  'assistant-message': ['assistant/message'],
+  either: ['tool/call', 'assistant/message'],
+}
+
+/** Candidate file names, in probe order, for the project chain and user-global. */
+const PROJECT_CANDIDATES = ['AGENTS.md', 'CLAUDE.md', 'AGENTS.local.md', 'CLAUDE.local.md']
+const USER_GLOBAL_CANDIDATE = 'AGENTS.md'
+
+function parsePromoteOn(value) {
+  if (value === undefined || value === 'either') return PROMOTE_EVENTS.either
+  if (value === 'tool-call' || value === 'assistant-message') return PROMOTE_EVENTS[value]
+  throw new TypeError(`${name}: promoteOn must be one of "tool-call", "assistant-message", "either"; got ${JSON.stringify(value)}`)
+}
+
+/** Find the project root: first ancestor containing any root marker (e.g. .git). */
+async function findProjectRoot(fs, cwd, signal) {
+  let current = cwd
+  for (;;) {
+    for (const marker of ['.git', '.hg', '.svn']) {
+      try {
+        const target = await fs.resolve(joinPath(current, marker), { cwd, signal })
+        const info = await fs.stat(target, signal)
+        if (info !== undefined) return current
+      } catch {
+        // Probe failure = marker absent; continue.
+      }
+    }
+    const parent = parentPath(current)
+    if (parent === current || parent.length === 0) return cwd
+    current = parent
+  }
+}
+
+/** List instruction files present in one directory (project candidates). */
+async function presentInDir(fs, dir, candidates, signal) {
+  const found = []
+  for (const candidate of candidates) {
+    try {
+      const target = await fs.resolve(joinPath(dir, candidate), { cwd: dir, signal })
+      const info = await fs.stat(target, signal)
+      if (info !== undefined && info.type === 'file') found.push(candidate)
+    } catch {
+      // Absent or unreadable — skip.
+    }
+  }
+  return found
+}
+
+/** Join one path segment onto a directory (platform-agnostic string join). */
+function joinPath(dir, segment) {
+  if (dir.endsWith('/') || dir.endsWith('\\')) return dir + segment
+  const sep = dir.includes('\\') ? '\\' : '/'
+  return dir + sep + segment
+}
+
+/** Parent of an absolute Windows or POSIX path. */
+function parentPath(path) {
+  const idx = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'))
+  if (idx <= 0) return path
+  const parent = path.slice(0, idx)
+  return parent.length === 0 ? path : parent
+}
+
+/** Register the post-promotion instruction-hint injector. */
+export function apply(ctx, config) {
+  const promoteEvents = parsePromoteOn(config.promoteOn)
+  if (config.includeSubagents !== undefined && typeof config.includeSubagents !== 'boolean') {
+    throw new TypeError(`${name}: includeSubagents must be a boolean`)
+  }
+  const promotion = createEpochPromotion(promoteEvents, { includeSubagents: config.includeSubagents === true })
+  ctx.on('session/event', (session, event) => promotion.observe(session, event))
+
+  /** Sessions that already received the hint. */
+  const hinted = new Set()
+  let warned = false
+  const warnOnce = (message) => {
+    if (warned) return
+    warned = true
+    try {
+      ctx.logger.warn(message)
+    } catch {
+      // Logger unavailable — the guard exists only to avoid spamming.
+    }
+  }
+
+  ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+    const decision = await next()
+    try {
+      if (promotion.status(agent).promoted !== true) return decision
+      const session = agent.session
+      if (session === undefined || hinted.has(session.id)) return decision
+
+      // Claim this process before inspecting durable state or probing the
+      // filesystem, so concurrent re-entry cannot pass through an await. The
+      // event scan makes resume safe, but is not an atomic cross-process claim:
+      // simultaneous writers can both observe no hint before either persists it.
+      hinted.add(session.id)
+      if (snapshotSessionEvents(session).some(
+        event => event.type === 'user/message' && event.data?.source?.kind === 'instruction-hint',
+      )) return decision
+
+      const fs = ctx.get('fs')
+      if (fs === undefined) return decision
+      const cwd = session.header.cwd ?? process.cwd()
+
+      const projectFiles = []
+      const root = await findProjectRoot(fs, cwd, signal)
+      projectFiles.push(...await presentInDir(fs, root, PROJECT_CANDIDATES, signal))
+
+      const userGlobalFiles = []
+      try {
+        const dshHome = process.env.DSH_HOME ?? (process.env.USERPROFILE ? `${process.env.USERPROFILE}\\.dsh` : undefined)
+        if (dshHome !== undefined) {
+          userGlobalFiles.push(...await presentInDir(fs, dshHome, [USER_GLOBAL_CANDIDATE], signal))
+        }
+      } catch {
+        // Unreadable home probe — ignore.
+      }
+
+      const sections = []
+      if (projectFiles.length > 0) {
+        sections.push(`Workspace instruction files exist: ${projectFiles.join(', ')} (project root: ${root}).`)
+      }
+      if (userGlobalFiles.length > 0) {
+        sections.push(`A user-global instruction file exists: ${USER_GLOBAL_CANDIDATE}.`)
+      }
+      if (sections.length === 0) return decision
+
+      const text = [
+        ...sections,
+        'Do NOT assume their content. When a task touches this workspace, read the relevant instruction files first and follow them.',
+      ].join(' ')
+
+      return {
+        ...decision,
+        messages: [...decision.messages, {
+          id: `instruction-hint-${session.id}`,
+          role: 'user',
+          content: [{ type: 'text', text }],
+          source: { kind: 'instruction-hint', form: 'hint' },
+        }],
+      }
+    } catch (error) {
+      // A hint bug must never hurt the session: skip the hint.
+      warnOnce(`${name}: hint injection failed, skipping: ${String((error && error.message) || error)}`)
+      return decision
+    }
+  }, { prepend: true })
+}

package/presets/liangshen/preset.yml

@@ -0,0 +1,3 @@
+name: 梁神模式
+description: 主 Agent 与子 Agent 首轮均保持 Minimal 双工具，首次工具调用后开放完整目录，压缩后重新锚定。
+order: 5

package/presets/liangshen/session-events.mjs

@@ -0,0 +1,8 @@
+/** Presets are copied outside the package, so this reader stays self-contained. */
+export function snapshotSessionEvents(session) {
+  const events = typeof session.snapshotEvents === 'function'
+    ? session.snapshotEvents()
+    : session.events
+  if (!Array.isArray(events)) throw new TypeError('liangshen: session history must be an array')
+  return events
+}

package/presets/liangshen/skill-search.mjs

@@ -0,0 +1,141 @@
+/**
+ * skill-search — on-demand skill discovery and loading, replacing
+ * `dsh-tool-skill`'s full-catalog injection.
+ *
+ * WHY: the available-skills reminder (`<available_skills>`, ~9KB with many
+ * skills) is injected into the first step by dsh-tool-skill and again after
+ * every promotion/compaction. That large injected block perturbs the
+ * trajectory in tool-heavy requests (issue #6). We remove the catalog injection entirely
+ * and expose two small on-demand tools instead:
+ *
+ *  - `skill_search` — list skills whose name/description match a query
+ *    (summaries only, bounded; no bodies). The model discovers what exists
+ *    without a 9KB dump.
+ *  - `skill_load` — load ONE skill's full instructions by exact name and
+ *    inject them for the NEXT request via `agent.inject` (the non-waking
+ *    next-step inbox). The model (or the user) calls this only when the
+ *    skill is actually needed.
+ *
+ * Discovery reads `ctx.skills` scoped to the calling agent, exactly like
+ * dsh-tool-skill. If skills are unavailable the tools answer with a short
+ * message instead of throwing.
+ *
+ * NOTE: this plugin REPLACES the `dsh-tool-skill` row in the composition —
+ * the composition must NOT mount both, or the catalog injection returns.
+ */
+
+/** Cordis plugin name used by loader diagnostics. */
+export const name = 'skill-search'
+
+/** The agent, tools, and skills services must exist before these tools can register. */
+export const inject = ['agents', 'tools', 'skills']
+
+const MAX_RESULTS = 20
+
+/** Minimal JSON schema compiler for tool parameters (zero dependencies). */
+function toJsonSchema(spec) {
+  const properties = {}
+  const required = []
+  for (const [key, meta] of Object.entries(spec || {})) {
+    const prop = { type: meta.type }
+    if (meta.description) prop.description = meta.description
+    properties[key] = prop
+    if (meta.required) required.push(key)
+  }
+  return { type: 'object', properties, required, additionalProperties: false }
+}
+
+/** Register the two on-demand skill tools. */
+export function apply(ctx) {
+  /** Normalize a query into lowercase tokens for simple substring matching. */
+  const tokens = (text) => (text || '').toLowerCase().split(/[^a-z0-9_-]+/).filter(Boolean)
+
+  ctx.tools.register({
+    name: 'skill_search',
+    description: 'Search the available skills by keyword and return matching skill names with short descriptions. This session keeps NO skill catalog in the prompt — if a task looks like it matches a skill (document conversion, image processing, game reviews, markdown, PDF, spreadsheets, …), call skill_search FIRST to find it, then skill_load to activate it. Do NOT assume skill names from memory.',
+    parameters: toJsonSchema({
+      query: { type: 'string', required: true, description: 'search keywords (e.g. "pdf", "obsidian", "game review")' },
+    }),
+    output: {
+      schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string' } }, required: ['text'] },
+      render: (_a, v) => [{ type: 'text', text: v.text }],
+    },
+    async execute(args, exec) {
+      const wanted = tokens(args.query)
+      const scope = exec?.agent ?? ctx
+      try {
+        const all = await ctx.skills.list({
+          scope,
+          cwd: exec?.agent?.session?.header?.cwd,
+          signal: exec?.signal,
+        })
+        const matches = all.filter((skill) => {
+          if (wanted.length === 0) return true
+          const haystack = tokens(`${skill.name} ${skill.description ?? ''} ${skill.whenToUse ?? ''}`).join(' ')
+          return wanted.every((token) => haystack.includes(token))
+        })
+        const head = matches.slice(0, MAX_RESULTS)
+        const lines = head.map((skill) => {
+          const desc = (skill.description || '').split('\n')[0]
+          return `- ${skill.name}: ${desc}`
+        })
+        if (lines.length === 0) return { text: `No skills match "${args.query}". Use skill_search with other keywords.` }
+        const extra = matches.length > MAX_RESULTS ? `\n…(${matches.length - MAX_RESULTS} more)` : ''
+        return { text: `Matching skills (${matches.length}):\n${lines.join('\n')}${extra}\n\nLoad one with skill_load (exact name).` }
+      } catch (error) {
+        return { text: `skill_search unavailable: ${String((error && error.message) || error)}` }
+      }
+    },
+  })
+
+  ctx.tools.register({
+    name: 'skill_load',
+    description: 'Load the full instructions of ONE skill by its exact name (from skill_search results) and inject them for the next request. Call this before acting on a task that matches the skill.',
+    parameters: toJsonSchema({
+      name: { type: 'string', required: true, description: 'exact skill name (kebab-case, from skill_search)' },
+    }),
+    output: {
+      schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string' } }, required: ['text'] },
+      render: (_a, v) => [{ type: 'text', text: v.text }],
+    },
+    async execute(args, exec) {
+      try {
+        const agent = exec?.agent
+        if (agent === undefined) return { text: 'skill_load requires an agent context.' }
+        const skill = await ctx.skills.get(args.name, {
+          scope: agent,
+          cwd: agent.session.header.cwd,
+          signal: exec?.signal,
+        })
+        if (skill === undefined) {
+          return { text: `No skill named "${args.name}". Run skill_search to list available skills.` }
+        }
+        const body = extractSkillBody(skill)
+        if (body.length === 0) {
+          return { text: `Skill "${args.name}" has no loadable body.` }
+        }
+        // Queue the skill content as a non-waking next-step context message,
+        // exactly like dsh-tool-skill's invocation injection.
+        agent.inject({
+          id: `skill-load-${args.name}-${Date.now()}`,
+          role: 'user',
+          content: [{ type: 'text', text: body }],
+          source: { kind: 'skill-invocation', name: args.name, form: 'instructions' },
+        })
+        return { text: `Skill "${args.name}" loaded; its instructions will be injected for the next request.` }
+      } catch (error) {
+        return { text: `skill_load failed: ${String((error && error.message) || error)}` }
+      }
+    },
+  })
+}
+
+/** Extract the model-facing body of a loaded skill definition. */
+function extractSkillBody(skill) {
+  const content = skill?.content ?? skill?.instructions ?? skill?.body
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content.map((part) => (typeof part === 'string' ? part : JSON.stringify(part))).join('\n')
+  }
+  return ''
+}