dsh-desktop-kit 2.2.1 → 2.7.3

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

@@ -0,0 +1,182 @@
+/**
+ * User-defined project hooks.
+ *
+ * `.dsh/hooks.json` is opt-in: commands run only when `.dsh/hooks.trusted`
+ * exists. Events mirror the useful subset of Claude Code hooks:
+ * PreToolUse, PostToolUse, Stop, FileChanged, SessionStart, SessionEnd.
+ */
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { findDshDir, loadHooks } from "./project.js";
+
+const MAX_OUTPUT = 12_000;
+const DEFAULT_TIMEOUT = 30_000;
+const MAX_TIMEOUT = 120_000;
+
+function sessionCwd(agent) {
+  const cwd = agent?.session?.header?.cwd;
+  return typeof cwd === "string" && cwd.length > 0 ? cwd : "";
+}
+
+function hookProject(cwd, fallbackFile) {
+  const start = cwd || (typeof fallbackFile === "string" ? path.dirname(fallbackFile) : process.cwd());
+  return findDshDir(start);
+}
+
+function matcherMatches(matcher, value) {
+  if (typeof matcher !== "string" || matcher.trim().length === 0) return true;
+  try {
+    return new RegExp(matcher, "iu").test(String(value ?? ""));
+  } catch {
+    return false;
+  }
+}
+
+function runCommand(hook, payload, cwd, sessionId) {
+  return new Promise((resolve) => {
+    const timeout = Math.max(1_000, Math.min(MAX_TIMEOUT, Number(hook.timeoutMs) || DEFAULT_TIMEOUT));
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let child;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      try { child?.kill(); } catch { /* best effort */ }
+      finish({ code: 124, stdout, stderr: `${stderr}\nhook timed out after ${timeout}ms`.trim(), timedOut: true });
+    }, timeout);
+    try {
+      child = spawn(String(hook.command), {
+        cwd,
+        shell: true,
+        windowsHide: true,
+        env: {
+          ...process.env,
+          DSH_HOOK_EVENT: String(hook.event ?? ""),
+          DSH_PROJECT_DIR: cwd,
+          DSH_SESSION_ID: sessionId,
+        },
+      });
+    } catch (error) {
+      finish({ code: 1, stdout: "", stderr: String(error) });
+      return;
+    }
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < MAX_OUTPUT) stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < MAX_OUTPUT) stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => finish({ code: 1, stdout, stderr: String(error) }));
+    child.on("close", (code) => finish({ code: Number(code) || 0, stdout, stderr }));
+    try {
+      child.stdin?.end(JSON.stringify(payload));
+    } catch {
+      /* no stdin */
+    }
+  });
+}
+
+export function registerProjectHooks(ctx) {
+  const disposers = [];
+  const logger = ctx.logger;
+
+  async function runEvent(event, agent, payload, matchValue) {
+    const project = hookProject(sessionCwd(agent), payload?.file ?? payload?.path);
+    const loaded = loadHooks(project.root, project.dsh);
+    if (!loaded.trusted) return { blocked: false, results: [], untrusted: true };
+    const hooks = Array.isArray(loaded.hooks?.[event]) ? loaded.hooks[event] : [];
+    if (hooks.length === 0) return { blocked: false, results: [] };
+    const results = [];
+    for (const hook of hooks) {
+      if (!hook || typeof hook.command !== "string" || hook.command.trim().length === 0) continue;
+      if (!matcherMatches(hook.matcher, matchValue)) continue;
+      const result = await runCommand(hook, { event, ...payload }, project.root, String(agent?.id ?? ""));
+      results.push({ ...result, command: hook.command });
+      const code = result.code;
+      if (code !== 0) {
+        logger?.warn?.(`[agent-extensions] ${event} hook exited ${code}: ${(result.stderr || result.stdout).slice(0, 300)}`);
+      }
+      if (code === 2) return { blocked: true, results, reason: (result.stderr || result.stdout || `${event} hook blocked`).trim() };
+    }
+    return { blocked: false, results };
+  }
+
+  const on = (event, handler) => {
+    try {
+      const dispose = ctx.on(event, handler);
+      if (typeof dispose === "function") disposers.push(dispose);
+    } catch (error) {
+      logger?.warn?.(`[agent-extensions] ${event} hook skipped: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+
+  on("tools/pre-execute", async (exec, next) => {
+    const result = await runEvent("PreToolUse", exec?.agent, {
+      tool: exec?.name,
+      arguments: exec?.arguments ?? {},
+    }, exec?.name);
+    if (result.blocked) return { kind: "deny", reason: `project hook: ${result.reason}` };
+    return typeof next === "function" ? next() : { kind: "allow" };
+  });
+
+  on("tools/result", async (exec, result) => {
+    await runEvent("PostToolUse", exec?.agent, {
+      tool: exec?.name,
+      arguments: exec?.arguments ?? {},
+      ok: result?.isError !== true,
+    }, exec?.name);
+  });
+
+  on("fs/write-intent", async (target, actor, next) => {
+    const file = target?.displayPath ?? target?.path ?? "";
+    const result = await runEvent("FileChanged", actor, { file, operation: "write" }, file);
+    if (result.blocked) throw new Error(`project hook: ${result.reason}`);
+    return typeof next === "function" ? next() : undefined;
+  });
+
+  on("fs/edit-intent", async (target, actor, next) => {
+    const file = target?.displayPath ?? target?.path ?? "";
+    const result = await runEvent("FileChanged", actor, { file, operation: "edit" }, file);
+    if (result.blocked) throw new Error(`project hook: ${result.reason}`);
+    return typeof next === "function" ? next() : undefined;
+  });
+
+  on("agent/turn-stopping", async (payload) => {
+    const agent = payload?.agent;
+    const result = await runEvent("Stop", agent, { turn: payload?.turn ?? 0 }, "");
+    if (result.blocked) {
+      try {
+        agent?.steer?.({
+          id: `hook-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+          role: "user",
+          content: [{ type: "text", text: `<project-hook-stop>\n${result.reason}\n</project-hook-stop>` }],
+          source: { kind: "user" },
+        });
+      } catch (error) {
+        logger?.warn?.(`[agent-extensions] stop steer failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  });
+
+  on("agent/created", async (payload) => {
+    await runEvent("SessionStart", payload?.agent, { session: String(payload?.agent?.id ?? "") }, "");
+  });
+  on("agent/disposed", async (payload) => {
+    await runEvent("SessionEnd", payload?.agent, { session: String(payload?.agent?.id ?? "") }, "");
+  });
+
+  return {
+    dispose() {
+      for (const dispose of disposers) {
+        try { dispose(); } catch { /* best effort */ }
+      }
+    },
+  };
+}
+
+export { runCommand, matcherMatches };

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

@@ -0,0 +1,84 @@
+/**
+ * Enforcement for project subagents.
+ *
+ * DSH's subagents service starts a child before a parent can attach a policy,
+ * so `project_agent` reserves the child id, records the policy, and only then
+ * starts the child. The global pre-execute hook denies calls made by that child
+ * when its tool allowlist or permission level forbids them.
+ */
+const MUTATING_TOOLS = new Set(["write", "edit", "apply_patch", "patch", "delete", "move", "mkdir", "touch"]);
+const SHELL_TOOLS = new Set(["bash", "pwsh", "powershell", "shell", "sh", "zsh", "cmd", "terminal"]);
+const MUTATING_SHELL = /(?:^|[;&|]\s*|\s)(?:rm|rmdir|mv|cp|mkdir|touch|truncate|tee|dd|chmod|chown|Set-Content|Add-Content|Out-File|New-Item|Remove-Item|Move-Item|Copy-Item|git\s+(?:commit|push|reset|checkout|clean|merge|rebase)|npm\s+(?:install|uninstall|update)|pnpm\s+(?:add|remove|install)|composer\s+(?:install|update)|php\s+artisan\s+(?:migrate|db:)|dropdb|createdb|psql\b[^\n]*(?:insert|update|delete|drop|truncate|alter))/iu;
+
+const policies = new Map();
+
+export function parseAllowedTools(value) {
+  if (typeof value !== "string") return new Set();
+  return new Set(value.split(/[,\s]+/u).map((name) => name.trim()).filter(Boolean));
+}
+
+export function setChildPolicy(childId, definition) {
+  if (!childId) return;
+  policies.set(String(childId), {
+    name: definition?.name ?? "project-agent",
+    allowed: parseAllowedTools(definition?.tools),
+    permission: definition?.permission === "read-only" || definition?.permission === "workspace-write"
+      ? definition.permission
+      : "full",
+  });
+}
+
+export function clearChildPolicy(childId) {
+  if (childId) policies.delete(String(childId));
+}
+
+export function checkChildTool(exec) {
+  const id = String(exec?.agent?.id ?? "");
+  const policy = policies.get(id);
+  if (!policy) return null;
+  const tool = String(exec?.name ?? "");
+  if (policy.permission === "read-only") {
+    if (MUTATING_TOOLS.has(tool)) {
+      return { kind: "deny", reason: `subagent ${policy.name}: permission read-only запрещает ${tool}` };
+    }
+    if (SHELL_TOOLS.has(tool)) {
+      const command = exec?.arguments && typeof exec.arguments === "object" ? exec.arguments.command : "";
+      if (typeof command === "string" && MUTATING_SHELL.test(command)) {
+        return { kind: "deny", reason: `subagent ${policy.name}: permission read-only запрещает изменяющую shell-команду` };
+      }
+    }
+  }
+  if (policy.allowed.size > 0 && !policy.allowed.has(tool)) {
+    return { kind: "deny", reason: `subagent ${policy.name}: tool ${tool} не входит в allowlist` };
+  }
+  return null;
+}
+
+export function registerChildPolicyHook(ctx) {
+  const disposers = [];
+  const on = (event, handler) => {
+    try {
+      const dispose = ctx.on(event, handler);
+      if (typeof dispose === "function") disposers.push(dispose);
+    } catch (error) {
+      ctx.logger?.warn?.(`[agent-extensions] policy hook ${event} skipped: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  on("tools/pre-execute", (exec, next) => {
+    const hit = checkChildTool(exec);
+    if (hit) return { kind: "deny", reason: hit.reason };
+    return typeof next === "function" ? next() : { kind: "allow" };
+  });
+  on("agent/disposed", (payload) => clearChildPolicy(payload?.agent?.id));
+  return {
+    dispose() {
+      for (const dispose of disposers) {
+        try { dispose(); } catch { /* best effort */ }
+      }
+    },
+  };
+}
+
+export function childPolicyCount() {
+  return policies.size;
+}

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

@@ -0,0 +1,144 @@
+/**
+ * Project discovery for agent extensions.
+ *
+ * Everything is optional and project-local: `.dsh/hooks.json`,
+ * `.dsh/agents/*.md`, `.dsh/commands/*.md`, `.dsh/verify.json`. A project
+ * without `.dsh` simply gets no extra hooks/commands/agents.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+export const BUILTIN_COMMANDS = new Set(["init", "doctor", "verify", "hooks", "checkpoint", "rewind", "project"]);
+
+export function findDshDir(start) {
+  let current = path.resolve(start || process.cwd());
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = path.join(current, ".dsh");
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) return { root: current, dsh: candidate };
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return { root: path.resolve(start || process.cwd()), dsh: null };
+}
+
+export function projectFor(cwd) {
+  if (typeof cwd !== "string" || cwd.trim().length === 0) return { root: process.cwd(), dsh: null };
+  return findDshDir(cwd);
+}
+
+export function parseFrontmatter(text) {
+  const source = String(text ?? "").replace(/^\uFEFF/u, "");
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/u.exec(source);
+  if (!match) return { meta: {}, body: source.trim() };
+  const meta = {};
+  for (const line of match[1].split(/\r?\n/u)) {
+    const pair = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/u.exec(line.trim());
+    if (!pair) continue;
+    let value = pair[2].trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (value === "true") value = true;
+    else if (value === "false") value = false;
+    meta[pair[1]] = value;
+  }
+  return { meta, body: source.slice(match[0].length).trim() };
+}
+
+function listMarkdown(directory) {
+  try {
+    return fs
+      .readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && /\.md$/iu.test(entry.name))
+      .map((entry) => entry.name)
+      .sort((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+
+export function loadAgents(projectDir, dshDir) {
+  const directory = dshDir ? path.join(dshDir, "agents") : null;
+  if (!directory || !fs.existsSync(directory)) return [];
+  const agents = [];
+  for (const name of listMarkdown(directory)) {
+    try {
+      const parsed = parseFrontmatter(fs.readFileSync(path.join(directory, name), "utf8"));
+      const id = String(parsed.meta.name || name.replace(/\.md$/iu, "")).trim();
+      if (!/^[a-z0-9][a-z0-9_-]{0,48}$/iu.test(id)) continue;
+      if (!parsed.body) continue;
+      agents.push({
+        name: id,
+        description: typeof parsed.meta.description === "string" ? parsed.meta.description : "",
+        model: typeof parsed.meta.model === "string" ? parsed.meta.model : "",
+        tools: typeof parsed.meta.tools === "string" ? parsed.meta.tools : "",
+        permission: typeof parsed.meta.permission === "string" ? parsed.meta.permission : "full",
+        body: parsed.body,
+        file: path.join(directory, name),
+      });
+    } catch {
+      /* unreadable agent */
+    }
+  }
+  return agents;
+}
+
+export function loadCommands(projectDir, dshDir) {
+  const directory = dshDir ? path.join(dshDir, "commands") : null;
+  if (!directory || !fs.existsSync(directory)) return [];
+  const commands = [];
+  for (const name of listMarkdown(directory)) {
+    const id = name.replace(/\.md$/iu, "").trim().toLowerCase();
+    if (!/^[a-z0-9][a-z0-9_-]{0,40}$/u.test(id) || BUILTIN_COMMANDS.has(id)) continue;
+    try {
+      const parsed = parseFrontmatter(fs.readFileSync(path.join(directory, name), "utf8"));
+      if (!parsed.body) continue;
+      commands.push({
+        name: id,
+        description: typeof parsed.meta.description === "string" ? parsed.meta.description : `Проектная команда /${id}`,
+        body: parsed.body,
+        file: path.join(directory, name),
+      });
+    } catch {
+      /* unreadable command */
+    }
+  }
+  return commands;
+}
+
+export function loadHooks(projectDir, dshDir) {
+  const file = dshDir ? path.join(dshDir, "hooks.json") : null;
+  if (!file || !fs.existsSync(file)) return { hooks: {}, trusted: false, file };
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return { hooks: {}, trusted: false, file, error: "hooks.json: invalid JSON" };
+  }
+  const hooks = parsed && typeof parsed.hooks === "object" && parsed.hooks !== null ? parsed.hooks : {};
+  const trusted = Boolean(dshDir && fs.existsSync(path.join(dshDir, "hooks.trusted")));
+  return { hooks, trusted, file };
+}
+
+export function loadVerify(projectDir, dshDir) {
+  const file = dshDir ? path.join(dshDir, "verify.json") : null;
+  if (file && fs.existsSync(file)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+      if (Array.isArray(parsed?.commands)) {
+        return { commands: parsed.commands.filter((item) => typeof item === "string" && item.trim()).slice(0, 10), source: file };
+      }
+    } catch {
+      /* fall through */
+    }
+  }
+  return { commands: [], source: null };
+}
+
+export function projectSummary(projectDir) {
+  const agents = loadAgents(projectDir, path.join(projectDir, ".dsh"));
+  const commands = loadCommands(projectDir, path.join(projectDir, ".dsh"));
+  const hooks = loadHooks(projectDir, path.join(projectDir, ".dsh"));
+  return { agents, commands, hooks };
+}

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

@@ -0,0 +1,151 @@
+/**
+ * Zero-config scaffolding for dsh-desktop-kit.
+ *
+ * Global: `~/.dsh/mcp.json` (empty, valid).
+ * Project: `<project>/.dsh/` with agents/, commands/, hooks.json, verify.json,
+ * mcp.json, PROJECT.md and rules/project.md.
+ *
+ * Trust markers are deliberately NOT created: hooks and project MCP servers
+ * must remain an explicit user decision.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const SCAFFOLD_VERSION = 1;
+
+function writeIfMissing(file, content) {
+  if (fs.existsSync(file)) return false;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content, "utf8");
+  return true;
+}
+
+export function ensureGlobalScaffold(home = process.env.DSH_HOME || path.join(os.homedir(), ".dsh")) {
+  const created = [];
+  const mcpFile = path.join(home, "mcp.json");
+  if (writeIfMissing(mcpFile, `${JSON.stringify({ mcpServers: {} }, null, 2)}\n`)) created.push(mcpFile);
+  const readme = path.join(home, "mcp.README.md");
+  if (
+    writeIfMissing(
+      readme,
+      [
+        "# MCP servers",
+        "",
+        "Add trusted servers to `mcp.json`:",
+        "",
+        "```json",
+        '{ "mcpServers": { "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }, "trusted": true } } }',
+        "```",
+        "",
+        "A server is started only with `trusted: true`. Project-level servers additionally require `.dsh/mcp.trusted` (`/mcp trust`).",
+        "",
+      ].join("\n"),
+    )
+  ) {
+    created.push(readme);
+  }
+  return { home, created };
+}
+
+function isKitRepo(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+    return pkg?.name === "dsh-desktop-kit";
+  } catch {
+    return false;
+  }
+}
+
+export function shouldScaffold(cwd) {
+  if (typeof cwd !== "string" || cwd.length === 0) return false;
+  let resolved;
+  try { resolved = fs.realpathSync(cwd); } catch { return false; }
+  if (!fs.statSync(resolved).isDirectory()) return false;
+  const home = path.resolve(os.homedir());
+  const root = path.parse(resolved).root;
+  if (resolved === home || resolved === root) return false;
+  if (resolved.startsWith(path.join(home, ".dsh"))) return false;
+  if (isKitRepo(resolved)) return false;
+  return true;
+}
+
+export function ensureProjectScaffold(cwd) {
+  if (!shouldScaffold(cwd)) return { skipped: true, created: [] };
+  const dsh = path.join(cwd, ".dsh");
+  const created = [];
+  fs.mkdirSync(dsh, { recursive: true });
+  for (const directory of ["agents", "commands", "rules"]) {
+    const target = path.join(dsh, directory);
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+      created.push(target);
+    }
+  }
+  if (writeIfMissing(path.join(dsh, "agents", ".gitkeep"), "")) created.push(path.join(dsh, "agents", ".gitkeep"));
+  if (writeIfMissing(path.join(dsh, "commands", ".gitkeep"), "")) created.push(path.join(dsh, "commands", ".gitkeep"));
+  if (writeIfMissing(path.join(dsh, "hooks.json"), `${JSON.stringify({ hooks: {} }, null, 2)}\n`)) created.push(path.join(dsh, "hooks.json"));
+  if (writeIfMissing(path.join(dsh, "verify.json"), `${JSON.stringify({ commands: [] }, null, 2)}\n`)) created.push(path.join(dsh, "verify.json"));
+  if (writeIfMissing(path.join(dsh, "mcp.json"), `${JSON.stringify({ mcpServers: {} }, null, 2)}\n`)) created.push(path.join(dsh, "mcp.json"));
+  if (
+    writeIfMissing(
+      path.join(dsh, ".gitignore"),
+      ["hooks.trusted", "mcp.trusted", "checkpoints/", ".kit-scaffold.json", ""].join("\n"),
+    )
+  ) {
+    created.push(path.join(dsh, ".gitignore"));
+  }
+  if (
+    writeIfMissing(
+      path.join(dsh, "README.md"),
+      [
+        "# .dsh",
+        "",
+        "Project-local DSH extensions, created automatically by dsh-desktop-kit.",
+        "",
+        "- `agents/*.md` — custom subagents (`project_agent`).",
+        "- `commands/*.md` — project commands (`/project <name>`).",
+        "- `hooks.json` — lifecycle hooks; run `/hooks trust` after review.",
+        "- `verify.json` — commands for `/verify`.",
+        "- `mcp.json` — project MCP servers; run `/mcp trust` after review.",
+        "- `PROJECT.md` — project context; `/init --force` regenerates it.",
+        "",
+      ].join("\n"),
+    )
+  ) {
+    created.push(path.join(dsh, "README.md"));
+  }
+  const projectFile = path.join(dsh, "PROJECT.md");
+  if (!fs.existsSync(projectFile)) {
+    let pkg = {};
+    try { pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8")); } catch { /* optional */ }
+    fs.writeFileSync(
+      projectFile,
+      [
+        "# Project",
+        "",
+        `Root: ${cwd}`,
+        pkg.name ? `Package: ${pkg.name}${pkg.version ? ` ${pkg.version}` : ""}` : "",
+        pkg.scripts?.test ? `Tests: ${pkg.scripts.test}` : "",
+        "",
+        "Created automatically by dsh-desktop-kit. Edit freely; `/init --force` regenerates.",
+        "",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+      "utf8",
+    );
+    created.push(projectFile);
+  }
+  const ruleFile = path.join(dsh, "rules", "project.md");
+  if (!fs.existsSync(ruleFile)) {
+    fs.writeFileSync(ruleFile, "---\nalways: true\n---\n# Правила проекта\n\n- Источник истины: `.dsh/PROJECT.md`.\n- Перед сдачей — тесты и проверка UI.\n", "utf8");
+    created.push(ruleFile);
+  }
+  const marker = path.join(dsh, ".kit-scaffold.json");
+  if (!fs.existsSync(marker)) {
+    fs.writeFileSync(marker, `${JSON.stringify({ version: SCAFFOLD_VERSION, createdAt: new Date().toISOString() }, null, 2)}\n`, "utf8");
+    created.push(marker);
+  }
+  return { skipped: false, created, dsh };
+}

package/plugins/dsh-agent-extensions/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "dsh-agent-extensions",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./client": {
+      "default": "./client.js"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    }
+  },
+  "description": "Project-local hooks, custom agents, commands and safe checkpoints for DeepSeek Harness — Claude Code-like extensibility.",
+  "license": "MIT"
+}