dsh-desktop-kit 2.2.1 → 2.7.3

package/plugins/dsh-agent-extensions/index.js

@@ -0,0 +1,174 @@
+/**
+ * dsh-agent-extensions — Claude-Code-like project extensions for DSH.
+ *
+ * Adds four project-local surfaces:
+ *   - `.dsh/hooks.json` — trusted lifecycle hooks;
+ *   - `.dsh/agents/*.md` — custom subagents via the `project_agent` tool;
+ *   - `.dsh/commands/*.md` — project slash commands;
+ *   - safe git checkpoints + `/rewind`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { registerProjectHooks } from "./lib/hooks.js";
+import { createCheckpoint } from "./lib/checkpoints.js";
+import { runProjectAgent } from "./lib/agents.js";
+import { registerChildPolicyHook } from "./lib/policy.js";
+import { registerCommands } from "./lib/commands.js";
+import { registerAgentApi } from "./lib/api.js";
+import { ensureGlobalScaffold, ensureProjectScaffold } from "./lib/scaffold.js";
+import { findDshDir, loadAgents, projectFor } from "./lib/project.js";
+
+export const inject = ["tools", "systemPrompt"];
+
+const TOOL = "project_agent";
+const AUTO_CHECKPOINT_MS = 10 * 60_000;
+
+function projectFromAgent(agent) {
+  const cwd = agent?.session?.header?.cwd;
+  return projectFor(cwd);
+}
+
+function toolDefinition(ctx) {
+  return {
+    name: TOOL,
+    description:
+      "Run or list project-local custom agents from `.dsh/agents/*.md`. `list` shows names/descriptions/models; `run` starts a child agent with its own context and returns only its final text. Use for repeated specialised work (reviewer, researcher, SEO, migration).",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { type: "string", enum: ["list", "run"], description: "list project agents or run one by name" },
+        name: { type: "string", description: "Agent name from `.dsh/agents/<name>.md`" },
+        task: { type: "string", description: "Task/prompt for the child agent (required for run)" },
+      },
+      required: ["action"],
+    },
+    async execute(input, exec) {
+      const project = projectFromAgent(exec?.agent);
+      const agents = loadAgents(project.root, project.dsh ?? path.join(project.root, ".dsh"));
+      if (input?.action === "list") {
+        const text = agents.length
+          ? agents.map((agent) => `- ${agent.name}${agent.model ? ` · ${agent.model}` : ""}${agent.description ? ` — ${agent.description}` : ""}`).join("\n")
+          : "Нет проектных агентов. Создайте `.dsh/agents/<name>.md`.";
+        return { ok: true, text: `project_agent list:\n${text}` };
+      }
+      if (input?.action !== "run") return { ok: false, text: "project_agent: action must be list or run" };
+      const name = String(input?.name ?? "").trim();
+      const task = String(input?.task ?? "").trim();
+      if (!name || !task) return { ok: false, text: "project_agent: name and task are required for run" };
+      const definition = agents.find((agent) => agent.name === name);
+      if (!definition) return { ok: false, text: `project_agent: unknown agent "${name}"` };
+      try {
+        const result = await runProjectAgent(ctx, exec, definition, task);
+        return { ok: true, text: `project_agent ${name} (${result.stopReason}):\n${result.text}` };
+      } catch (error) {
+        return { ok: false, text: `project_agent ${name}: ${error instanceof Error ? error.message : String(error)}` };
+      }
+    },
+  };
+}
+
+export function apply(ctx) {
+  try {
+    const scaffold = ensureGlobalScaffold();
+    if (scaffold.created.length > 0) ctx.logger?.info?.(`[agent-extensions] scaffolded global: ${scaffold.created.join(", ")}`);
+  } catch (error) {
+    ctx.logger?.warn?.(`[agent-extensions] global scaffold skipped: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const hooks = registerProjectHooks(ctx);
+  ctx.effect(() => () => hooks.dispose(), "agent-extensions: project hooks");
+  const childPolicy = registerChildPolicyHook(ctx);
+  ctx.effect(() => () => childPolicy.dispose(), "agent-extensions: child policy");
+
+  try {
+    ctx.effect(
+      () =>
+        ctx.on("agent/created", (payload) => {
+          try {
+            const cwd = payload?.agent?.session?.header?.cwd;
+            const result = ensureProjectScaffold(cwd);
+            if (!result.skipped && result.created.length > 0) {
+              ctx.logger?.info?.(`[agent-extensions] scaffolded project ${cwd}: ${result.created.length} paths`);
+            }
+          } catch (error) {
+            ctx.logger?.warn?.(`[agent-extensions] project scaffold skipped: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }),
+      "agent-extensions: project scaffold",
+    );
+  } catch (error) {
+    ctx.logger?.warn?.(`[agent-extensions] project scaffold hook skipped: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  try {
+    ctx.effect(() => ctx.tools.register(toolDefinition(ctx)), "agent-extensions: project_agent tool");
+  } catch (error) {
+    ctx.logger?.warn?.(`[agent-extensions] tool registration failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  try {
+    ctx.systemPrompt.context({
+      name: "dsh-agent-extensions: project agents",
+      order: 134,
+      interpolate: false,
+      required: false,
+      text: (assemblyContext) => {
+        try {
+          const session = assemblyContext?.agent?.session;
+          if (!session) return "";
+          const project = projectFromAgent(assemblyContext.agent);
+          const agents = loadAgents(project.root, project.dsh ?? path.join(project.root, ".dsh"));
+          if (agents.length === 0) return "";
+          const lines = agents.slice(0, 20).map((agent) => `- ${agent.name}: ${agent.description || "project agent"}${agent.model ? ` (${agent.model})` : ""}`);
+          return `<project-agents>\n${lines.join("\n")}\nЗапускай через tool project_agent action=run name=<name> task=<...>.\n</project-agents>`;
+        } catch {
+          return "";
+        }
+      },
+    });
+  } catch (error) {
+    ctx.logger?.warn?.(`[agent-extensions] system prompt registration failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  try {
+    ctx.inject(["commands"], (child) => registerCommands(child));
+  } catch (error) {
+    ctx.logger?.warn?.(`[agent-extensions] commands registration failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  try {
+    ctx.inject(["connection"], (child) => registerAgentApi(child));
+  } catch (error) {
+    ctx.logger?.warn?.(`[agent-extensions] agents api skipped: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  /* Auto-checkpoint before the first write in a session (at most once per 10 min). */
+  const lastAuto = new Map();
+  try {
+    ctx.effect(
+      () =>
+        ctx.on("fs/write-intent", async (target, actor, next) => {
+          const file = target?.displayPath ?? target?.path ?? "";
+          const sessionId = String(actor?.id ?? ctx.get("agents")?.currentInitiator?.()?.id ?? "");
+          if (!sessionId || !/\.(?:js|mjs|cjs|ts|tsx|jsx|css|scss|html|vue|svelte|astro|md|json|yml|yaml)$/iu.test(file)) return next();
+          if (/(?:^|[\\/])(?:node_modules|\.git|\.dsh|dist|build|coverage)(?:[\\/]|$)/iu.test(file)) return next();
+          const now = Date.now();
+          if (now - (lastAuto.get(sessionId) ?? 0) < AUTO_CHECKPOINT_MS) return next();
+          lastAuto.set(sessionId, now);
+          try {
+            const project = findDshDir(path.dirname(file));
+            const meta = createCheckpoint({ cwd: project.root, label: "auto before write" });
+            ctx.logger?.debug?.(`[agent-extensions] auto checkpoint ${meta.id}`);
+          } catch (error) {
+            ctx.logger?.debug?.(`[agent-extensions] auto checkpoint skipped: ${error instanceof Error ? error.message : String(error)}`);
+          }
+          return next();
+        }),
+      "agent-extensions: auto checkpoint",
+    );
+  } catch (error) {
+    ctx.logger?.warn?.(`[agent-extensions] auto checkpoint hook skipped: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  ctx.logger?.info?.("[agent-extensions] ready");
+}

package/plugins/dsh-agent-extensions/lib/agents.js

@@ -0,0 +1,76 @@
+/**
+ * Project-local custom agents: `.dsh/agents/<name>.md`.
+ *
+ * The file frontmatter describes when to use the agent; the body becomes the
+ * child prompt. A child runs through the DSH subagents service with its own
+ * context and returns only its final text.
+ */
+import crypto from "node:crypto";
+import { loadAgents } from "./project.js";
+import { clearChildPolicy, setChildPolicy } from "./policy.js";
+
+function textFromOutput(output) {
+  if (!Array.isArray(output)) return "";
+  return output
+    .filter((block) => block && block.type === "text" && typeof block.text === "string")
+    .map((block) => block.text)
+    .join("\n")
+    .trim();
+}
+
+export async function runProjectAgent(ctx, exec, definition, task) {
+  const subagents = ctx.get("subagents");
+  if (!subagents || typeof subagents.startActivation !== "function") {
+    throw new Error("subagents service is unavailable");
+  }
+  const providers = typeof subagents.list === "function" ? subagents.list() : [];
+  const provider = providers.includes("spawn") ? "spawn" : providers[0];
+  if (!provider) throw new Error("no subagent provider is registered");
+  const controller = new AbortController();
+  const signal = exec?.signal;
+  const abort = () => controller.abort(signal?.reason ?? new Error("parent aborted"));
+  if (signal?.aborted) abort();
+  else signal?.addEventListener?.("abort", abort, { once: true });
+  const reservedId = crypto.randomUUID();
+  let activeId = reservedId;
+  setChildPolicy(reservedId, definition);
+  try {
+    const prompt = [`<project-agent name="${definition.name}">`, definition.body, "</project-agent>", "", "Task:", String(task ?? "")].join("\n");
+    const activation = await subagents.startActivation({
+      provider,
+      label: `agent:${definition.name}`,
+      childId: reservedId,
+      request: {
+        prompt: [{ type: "text", text: prompt }],
+        parent: exec.agent,
+        signal: controller.signal,
+        cwd: exec?.agent?.session?.header?.cwd,
+        ...(definition.model ? { agentOptions: { model: definition.model } } : {}),
+      },
+      signal: controller.signal,
+      delivery: "caller",
+    });
+    if (activation.childId && activation.childId !== reservedId) {
+      activeId = String(activation.childId);
+      setChildPolicy(activeId, definition);
+      clearChildPolicy(reservedId);
+    }
+    const result = await activation.result;
+    const text = textFromOutput(result?.output);
+    await activation.dispose?.();
+    if (!text) throw new Error(`project agent ${definition.name} returned no text`);
+    return { text, stopReason: result?.stopReason ?? "completed" };
+  } finally {
+    clearChildPolicy(reservedId);
+    clearChildPolicy(activeId);
+    signal?.removeEventListener?.("abort", abort);
+  }
+}
+
+export function projectAgentSummary(projectDir, dshDir) {
+  return loadAgents(projectDir, dshDir).map((agent) => ({
+    name: agent.name,
+    description: agent.description,
+    model: agent.model,
+  }));
+}

package/plugins/dsh-agent-extensions/lib/api.js

@@ -0,0 +1,53 @@
+/**
+ * Authenticated RPC for the Agents settings page.
+ */
+import { loadAgents, projectFor } from "./project.js";
+
+export const RPC_NAMESPACE = "dsh-agent-extensions";
+const ROUTE_BASE = "/api/dsh-agent-extensions";
+
+function ok(rpcId, value) {
+  return Response.json({ type: "server-response", rpcId, result: { ok: true, value } });
+}
+
+function fail(rpcId, message) {
+  return Response.json({ type: "server-response", rpcId, result: { ok: false, error: { code: "agents/bad-request", message, details: {} } } });
+}
+
+async function envelope(request) {
+  const body = await request.json();
+  if (!body || body.type !== "client-request" || typeof body.rpcId !== "string" || typeof body.method !== "string") throw new Error("bad Connection envelope");
+  return { rpcId: body.rpcId, method: body.method, payload: body.payload ?? {} };
+}
+
+export function registerAgentApi(ctx) {
+  const route = {
+    path: `${ROUTE_BASE}/list`,
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      let rpcId = "invalid-request";
+      try {
+        const value = await envelope(request);
+        rpcId = value.rpcId;
+        if (value.method !== `${RPC_NAMESPACE}/list`) throw new Error("endpoint/method mismatch");
+        const session = value.payload?.sessionId ? ctx.get?.("sessions")?.get?.(value.payload.sessionId) : undefined;
+        const project = projectFor(session?.header?.cwd || value.payload?.cwd || process.cwd());
+        const agents = loadAgents(project.root, project.dsh).map((agent) => ({
+          name: agent.name,
+          description: agent.description,
+          model: agent.model,
+          tools: agent.tools,
+          permission: agent.permission,
+        }));
+        return ok(rpcId, { project: project.root, agents });
+      } catch (error) {
+        return fail(rpcId, error instanceof Error ? error.message : String(error));
+      }
+    },
+  };
+  ctx.effect(() => {
+    const dispose = ctx.connection.fetch.register(route);
+    return () => { try { void Promise.resolve(dispose()).catch(() => {}); } catch { /* unloading */ } };
+  }, "agent-extensions: agents route");
+}

package/plugins/dsh-agent-extensions/lib/checkpoints.js

@@ -0,0 +1,103 @@
+/**
+ * Safe git checkpoints for agent extensions.
+ *
+ * Unlike a normal `git add`, this builds a tree through a temporary index, so
+ * the user's staged changes and HEAD stay untouched. Restore uses
+ * `git restore --source=<commit> --worktree -- .`: it restores tracked files
+ * from the snapshot but never deletes files created later.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+function git(cwd, args, env, allowFail = false) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 30_000,
+    windowsHide: true,
+    env: { ...process.env, ...(env ?? {}) },
+  });
+  if (result.error) throw new Error(`git ${args[0]}: ${result.error.message}`);
+  if (result.status !== 0 && !allowFail) {
+    throw new Error(`git ${args.join(" ")}: ${(result.stderr || result.stdout || "").trim()}`);
+  }
+  return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+
+export function repoRoot(cwd) {
+  return git(cwd, ["rev-parse", "--show-toplevel"]).stdout.trim();
+}
+
+function homeDirectory(home) {
+  return home || process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+}
+
+function checkpointDir(root, home) {
+  const digest = crypto.createHash("sha256").update(root.toLowerCase()).digest("hex").slice(0, 16);
+  return path.join(homeDirectory(home), "agent-extensions", "checkpoints", digest);
+}
+
+export function createCheckpoint({ cwd, label = "", home } = {}) {
+  const root = repoRoot(cwd);
+  const id = `cp-${new Date().toISOString().replace(/[-:T.Z]/gu, "").slice(0, 14)}-${crypto.randomBytes(3).toString("hex")}`;
+  const indexPath = path.join(os.tmpdir(), `dsh-agent-extensions-index-${process.pid}-${Date.now()}`);
+  const env = { GIT_INDEX_FILE: indexPath };
+  try {
+    const hasHead = git(root, ["rev-parse", "--verify", "HEAD"], env, true).ok;
+    if (hasHead) git(root, ["read-tree", "HEAD"], env);
+    else git(root, ["read-tree", "--empty"], env);
+    git(root, ["add", "-A"], env);
+    const tree = git(root, ["write-tree"], env).stdout.trim();
+    const message = `dsh agent checkpoint ${id}${label ? `: ${label}` : ""}`;
+    const args = ["commit-tree", tree];
+    if (hasHead) args.push("-p", "HEAD");
+    args.push("-m", message);
+    const commit = git(root, args, env).stdout.trim();
+    git(root, ["update-ref", `refs/dsh-agent-extensions/${id}`, commit], env);
+    const meta = {
+      id,
+      label: String(label ?? ""),
+      createdAt: new Date().toISOString(),
+      repo: root,
+      commit,
+      tree,
+      files: git(root, ["ls-tree", "-r", "--name-only", commit], env).stdout.trim().split(/\r?\n/u).filter(Boolean).length,
+    };
+    const directory = checkpointDir(root, home);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(path.join(directory, `${id}.json`), `${JSON.stringify(meta, null, 2)}\n`, { mode: 0o600 });
+    return meta;
+  } finally {
+    try { fs.rmSync(indexPath, { force: true }); } catch { /* best effort */ }
+  }
+}
+
+export function listCheckpoints({ cwd, home } = {}) {
+  const root = repoRoot(cwd);
+  const directory = checkpointDir(root, home);
+  if (!fs.existsSync(directory)) return [];
+  return fs
+    .readdirSync(directory)
+    .filter((name) => /^cp-.*\.json$/u.test(name))
+    .map((name) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(directory, name), "utf8"));
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((left, right) => String(right.createdAt).localeCompare(String(left.createdAt)));
+}
+
+export function restoreCheckpoint({ cwd, id, home } = {}) {
+  const root = repoRoot(cwd);
+  const checkpoints = listCheckpoints({ cwd: root, home });
+  const checkpoint = checkpoints.find((item) => item.id === id);
+  if (!checkpoint) throw new Error(`checkpoint not found: ${id}`);
+  git(root, ["restore", "--source", checkpoint.commit, "--worktree", "--", "."]);
+  return checkpoint;
+}

package/plugins/dsh-agent-extensions/lib/commands.js

@@ -0,0 +1,255 @@
+/**
+ * Project commands and the small built-in command set:
+ * /init, /doctor, /verify, /hooks, /checkpoint, /rewind.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { createCheckpoint, listCheckpoints, restoreCheckpoint } from "./checkpoints.js";
+import { loadAgents, loadCommands, loadHooks, loadVerify, projectFor } from "./project.js";
+
+function sessionProject(ctx) {
+  try {
+    const agent = ctx.get("agents")?.currentInitiator?.();
+    const cwd = agent?.session?.header?.cwd;
+    return projectFor(cwd);
+  } catch {
+    return projectFor(process.cwd());
+  }
+}
+
+function listLine(items, empty) {
+  return items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : empty;
+}
+
+function initProject(projectDir, dshDir, force) {
+  fs.mkdirSync(dshDir, { recursive: true });
+  const projectFile = path.join(dshDir, "PROJECT.md");
+  if (fs.existsSync(projectFile) && !force) return `Уже существует: ${projectFile}. Передайте --force для перезаписи.`;
+  let pkg = {};
+  try { pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8")); } catch { /* optional */ }
+  const dirs = [];
+  try {
+    for (const entry of fs.readdirSync(projectDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (["node_modules", ".git", ".dsh", "dist", "build", "coverage"].includes(entry.name)) continue;
+      dirs.push(entry.name);
+    }
+  } catch { /* ignore */ }
+  const lines = [
+    "# Project",
+    "",
+    `Root: ${projectDir}`,
+    pkg.name ? `Package: ${pkg.name}${pkg.version ? ` ${pkg.version}` : ""}` : "",
+    pkg.scripts?.test ? `Tests: ${pkg.scripts.test}` : "",
+    dirs.length > 0 ? `Directories: ${dirs.slice(0, 20).join(", ")}` : "",
+    "",
+    "## Commands",
+    "```",
+    pkg.scripts?.test ? `npm test` : "# tests not detected",
+    pkg.scripts?.build ? `npm run build` : "",
+    "```",
+    "",
+    "## Agent notes",
+    "- Проверяй изменения тестами и browser_qa для UI.",
+    "- Не коммить секреты и локальные данные.",
+  ].filter((line) => line !== "");
+  fs.writeFileSync(projectFile, `${lines.join("\n")}\n`, "utf8");
+  const rulesDir = path.join(dshDir, "rules");
+  fs.mkdirSync(rulesDir, { recursive: true });
+  const ruleFile = path.join(rulesDir, "project.md");
+  if (!fs.existsSync(ruleFile) || force) {
+    fs.writeFileSync(ruleFile, `---\nalways: true\n---\n# Правила проекта\n\n- Источник истины: ${path.basename(projectFile)}.\n- Перед сдачей — тесты и проверка UI.\n`, "utf8");
+  }
+  return `Создано: ${projectFile} и ${ruleFile}.`;
+}
+
+function runVerify(projectDir, dshDir) {
+  const configured = loadVerify(projectDir, dshDir);
+  let commands = configured.commands;
+  if (commands.length === 0) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+      if (typeof pkg.scripts?.test === "string") commands = ["npm test"];
+    } catch { /* optional */ }
+  }
+  if (commands.length === 0) return { text: "Нет .dsh/verify.json и не найден npm test." };
+  const lines = [];
+  for (const command of commands) {
+    const result = spawnSync(command, {
+      cwd: projectDir,
+      shell: true,
+      encoding: "utf8",
+      timeout: 120_000,
+      windowsHide: true,
+    });
+    const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim().split(/\r?\n/u).slice(-12).join("\n");
+    lines.push(`$ ${command}\nexit ${result.status ?? "?"}${output ? `\n${output}` : ""}`);
+    if (result.status !== 0) break;
+  }
+  return { text: lines.join("\n\n") };
+}
+
+function statusText(ctx) {
+  const project = sessionProject(ctx);
+  const dshDir = project.dsh ?? path.join(project.root, ".dsh");
+  const agents = loadAgents(project.root, dshDir);
+  const commands = loadCommands(project.root, dshDir);
+  const hooks = loadHooks(project.root, dshDir);
+  let checkpoints = [];
+  if (project.dsh) {
+    try { checkpoints = listCheckpoints({ cwd: project.root }); } catch { checkpoints = []; }
+  }
+  return [
+    `Project: ${project.root}`,
+    `.dsh: ${project.dsh ?? "нет"}`,
+    `Agents: ${agents.map((agent) => agent.name).join(", ") || "нет"}`,
+    `Commands: ${commands.map((command) => `/${command.name}`).join(", ") || "нет"}`,
+    `Hooks: ${hooks.trusted ? "trusted" : "не доверены"} · событий: ${Object.keys(hooks.hooks ?? {}).length}`,
+    `Checkpoints: ${checkpoints.length}`,
+  ].join("\n");
+}
+
+export function registerCommands(ctx) {
+  const register = (definition) => {
+    try {
+      return ctx.commands.register(definition);
+    } catch (error) {
+      ctx.logger?.warn?.(`[agent-extensions] command /${definition.name} skipped: ${error instanceof Error ? error.message : String(error)}`);
+      return undefined;
+    }
+  };
+
+  register({
+    name: "init",
+    description: "Создать .dsh/PROJECT.md и .dsh/rules/project.md",
+    input: { hint: "[--force]" },
+    recordInput: false,
+    handler: ({ rawInput }) => {
+      const project = sessionProject(ctx);
+      const dshDir = project.dsh ?? path.join(project.root, ".dsh");
+      return { kind: "success", text: initProject(project.root, dshDir, /--force/u.test(String(rawInput ?? ""))) };
+    },
+  });
+
+  register({
+    name: "doctor",
+    description: "Проверить hooks, agents, commands и checkpoints",
+    input: { hint: "" },
+    recordInput: false,
+    handler: () => ({ kind: "success", text: statusText(ctx) }),
+  });
+
+  register({
+    name: "hooks",
+    description: "Статус hooks, trust или отключение",
+    input: { hint: "status | trust | off" },
+    recordInput: false,
+    handler: ({ rawInput }) => {
+      const project = sessionProject(ctx);
+      if (!project.dsh) return { kind: "error", text: "Нет .dsh в проекте." };
+      const action = String(rawInput ?? "").trim().toLowerCase();
+      const marker = path.join(project.dsh, "hooks.trusted");
+      if (action === "trust") {
+        fs.writeFileSync(marker, `${new Date().toISOString()}\n`, "utf8");
+        return { kind: "success", text: "Hooks доверены. Команды из .dsh/hooks.json будут запускаться." };
+      }
+      if (action === "off") {
+        fs.rmSync(marker, { force: true });
+        return { kind: "success", text: "Доверие к hooks снято." };
+      }
+      const hooks = loadHooks(project.root, project.dsh);
+      return { kind: "success", text: `trusted: ${hooks.trusted}\nevents: ${Object.keys(hooks.hooks ?? {}).join(", ") || "none"}` };
+    },
+  });
+
+  register({
+    name: "verify",
+    description: "Запустить проверки проекта из .dsh/verify.json или npm test",
+    input: { hint: "" },
+    recordInput: false,
+    handler: () => {
+      const project = sessionProject(ctx);
+      const dshDir = project.dsh ?? path.join(project.root, ".dsh");
+      return { kind: "success", text: runVerify(project.root, dshDir).text };
+    },
+  });
+
+  register({
+    name: "checkpoint",
+    description: "Создать безопасный git-чекпоинт workspace",
+    input: { hint: "[label]" },
+    recordInput: false,
+    handler: ({ rawInput }) => {
+      const project = sessionProject(ctx);
+      try {
+        const meta = createCheckpoint({ cwd: project.root, label: String(rawInput ?? "").trim() });
+        return { kind: "success", text: `Checkpoint ${meta.id} (${meta.files} файлов).` };
+      } catch (error) {
+        return { kind: "error", text: `checkpoint: ${error instanceof Error ? error.message : String(error)}` };
+      }
+    },
+  });
+
+  register({
+    name: "rewind",
+    description: "Показать или восстановить checkpoint",
+    input: { hint: "[id]" },
+    recordInput: false,
+    handler: ({ rawInput }) => {
+      const project = sessionProject(ctx);
+      const id = String(rawInput ?? "").trim();
+      try {
+        if (!id) {
+          const items = listCheckpoints({ cwd: project.root }).slice(0, 10);
+          return { kind: "success", text: listLine(items.map((item) => `${item.id} · ${item.createdAt} · ${item.label || "без метки"}`), "Нет чекпоинтов.") };
+        }
+        const meta = restoreCheckpoint({ cwd: project.root, id });
+        return { kind: "success", text: `Восстановлен ${meta.id}. Файлы, созданные после, не удалены.` };
+      } catch (error) {
+        return { kind: "error", text: `rewind: ${error instanceof Error ? error.message : String(error)}` };
+      }
+    },
+  });
+
+  /* Project commands are loaded from the project of the *current* session. A
+   * single `/project` command is registered globally because DSH command
+   * names are process-wide; direct `/deploy` aliases would bind to whatever
+   * workspace happened to be first at plugin start. */
+  register({
+    name: "project",
+    description: "Список или запуск проектных команд из .dsh/commands",
+    input: { hint: "list | <name> [args]" },
+    recordInput: false,
+    handler: ({ rawInput }) => {
+      const project = sessionProject(ctx);
+      const dshDir = project.dsh ?? path.join(project.root, ".dsh");
+      const commands = loadCommands(project.root, dshDir);
+      const input = String(rawInput ?? "").trim();
+      if (input.length === 0 || input === "list") {
+        return {
+          kind: "success",
+          text: commands.length
+            ? commands.map((command) => `- /project ${command.name} — ${command.description}`).join("\n")
+            : "Нет .dsh/commands. Создайте файл .dsh/commands/<name>.md.",
+        };
+      }
+      const [name, ...rest] = input.split(/\s+/u);
+      const command = commands.find((item) => item.name === name);
+      if (!command) return { kind: "error", text: `Проектная команда не найдена: ${name}` };
+      try {
+        const agent = ctx.get("agents")?.currentInitiator?.();
+        if (!agent || typeof agent.steer !== "function") throw new Error("нет активного агента");
+        agent.steer({
+          id: `cmd-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+          role: "user",
+          content: [{ type: "text", text: `${command.body}${rest.length > 0 ? `\n\n${rest.join(" ")}` : ""}` }],
+          source: { kind: "user" },
+        });
+        return { kind: "success", text: `Команда /project ${name} передана агенту.` };
+      } catch (error) {
+        return { kind: "error", text: error instanceof Error ? error.message : String(error) };
+      }
+    },
+  });
+}