dsh-desktop-kit 2.7.7 → 2.7.9

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

@@ -45,7 +45,25 @@ window.__ModuleLoader__.load({
       .ag-error{padding:8px 10px;border:1px solid rgba(159,18,57,.16);border-radius:9px;background:rgba(159,18,57,.06);color:#9f1239;font-size:12px;line-height:1.4}
       .ag-loading{color:var(--ag-muted);font-size:13px;padding:18px 0}
       .ag-note{margin:0;color:var(--ag-muted);font-size:11px;line-height:1.45}
-      @media(max-width:860px){.ag-grid{grid-template-columns:1fr}.ag-stats{grid-template-columns:1fr 1fr}}
+      .ag-btn{font:inherit;font-size:11px;font-weight:650;border:1px solid var(--ag-line);background:var(--ag-panel);color:var(--ag-text);border-radius:8px;padding:6px 9px;cursor:pointer;min-height:30px}
+      .ag-btn:hover{border-color:rgba(15,118,110,.35);background:rgba(15,118,110,.05)}
+      .ag-btn:focus-visible{outline:2px solid var(--ag-accent);outline-offset:2px}
+      .ag-section{display:flex;flex-direction:column;gap:8px;min-width:0}
+      .ag-section h3{margin:0;font-size:15px;letter-spacing:-.01em}
+      .ag-hint{margin:0;color:var(--ag-muted);font-size:11.5px;line-height:1.45}
+      .ag-items{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px;min-width:0}
+      .ag-item{border:1px solid var(--ag-line);border-radius:12px;background:var(--ag-panel);padding:11px 12px;min-width:0;display:flex;flex-direction:column;gap:5px}
+      .ag-item-top{display:flex;justify-content:space-between;gap:8px;align-items:baseline;min-width:0}
+      .ag-item-top code{font:inherit;font-weight:650;font-size:12px;color:var(--ag-text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+      .ag-item-top span{flex:none;font-size:9.5px;font-weight:750;letter-spacing:.06em;text-transform:uppercase;color:var(--ag-muted)}
+      .ag-item p{margin:0;color:var(--ag-muted);font-size:11px;line-height:1.4;overflow-wrap:anywhere}
+      .ag-item p.ag-task{display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}
+      .ag-status-running{color:#9a3412;border-color:rgba(154,52,18,.22);background:rgba(154,52,18,.06)}
+      .ag-status-completed{color:#0f766e;border-color:rgba(15,118,110,.22);background:rgba(15,118,110,.06)}
+      .ag-status-failed,.ag-status-canceled{color:#9f1239;border-color:rgba(159,18,57,.18);background:rgba(159,18,57,.05)}
+      .ag-mini-empty{padding:12px;border:1px dashed var(--ag-line);border-radius:10px;color:var(--ag-muted);font-size:11.5px;line-height:1.45;background:linear-gradient(160deg,var(--ag-soft),transparent 80%)}
+      .ag-actions{display:flex;gap:6px;flex-wrap:wrap;align-items:center;margin-top:2px}
+      @media(max-width:860px){.ag-grid{grid-template-columns:1fr}.ag-stats{grid-template-columns:1fr 1fr}.ag-items{grid-template-columns:1fr}}
       @media(max-width:520px){.ag-stats{grid-template-columns:repeat(3,minmax(0,1fr));gap:8px}.ag-stat{padding:10px 12px}.ag-stat b{font-size:20px}.ag-stat span{font-size:9px;letter-spacing:.04em}.ag-root{gap:16px}}
       @media(prefers-reduced-motion:reduce){.ag-card{transition:none}}
     `;
@@ -93,6 +111,7 @@ window.__ModuleLoader__.load({
 
     function AgentsSection(props) {
       const [state, setState] = useState({ loading: true, error: null, data: null });
+      const [canceling, setCanceling] = useState("");
       const useSessions = props && props.useSessions;
       const useWorkspaces = props && props.useWorkspaces;
       const sessionId = useSessions ? useSessions(currentSessionSelector) : undefined;
@@ -102,6 +121,16 @@ window.__ModuleLoader__.load({
         ?? workspaces.find((item) => Array.isArray(item.sessionIds) && item.sessionIds.length > 0)
         ?? workspaces[0];
       const cwd = typeof workspace?.path === "string" ? workspace.path : undefined;
+
+      const load = async () => {
+        try {
+          const data = await call(window.__DSH_AGENTS_CTX__, "list", { sessionId, cwd });
+          setState({ loading: false, error: null, data });
+        } catch (error) {
+          setState({ loading: false, error: fallbackError(error), data: null });
+        }
+      };
+
       useEffect(() => {
         let cancelled = false;
         (async () => {
@@ -114,7 +143,22 @@ window.__ModuleLoader__.load({
         })();
         return () => { cancelled = true; };
       }, [sessionId, cwd]);
+
+      const cancel = async (id) => {
+        setCanceling(id);
+        try {
+          await call(window.__DSH_AGENTS_CTX__, "cancel", { sessionId, cwd, id });
+          await load();
+        } catch (error) {
+          setState((current) => ({ ...current, error: fallbackError(error) }));
+        } finally {
+          setCanceling("");
+        }
+      };
+
       const agents = state.data?.agents ?? [];
+      const worktrees = state.data?.worktrees ?? [];
+      const runs = state.data?.runs ?? [];
       const readOnly = agents.filter((agent) => agent.permission === "read-only").length;
       const models = new Set(agents.map((agent) => agent.model).filter(Boolean)).size;
       return h("section", { className: "ag-root", "aria-label": "Агенты проекта" },
@@ -122,8 +166,9 @@ window.__ModuleLoader__.load({
           h("div", null,
             h("p", { className: "ag-eyebrow" }, "Agents · project roles"),
             h("h2", { className: "ag-title" }, "Агенты"),
-            h("p", { className: "ag-sub" }, "Проектные роли из `.dsh/agents/*.md`. Их `tools`, `permission` и `model` применяются к дочернему агенту при запуске `project_agent`."),
+            h("p", { className: "ag-sub" }, "Проектные роли из `.dsh/agents/*.md`. Их `tools`, `permission` и `model` применяются к дочернему агенту при запуске `project_agent`. Фоновые запуски и worktrees — здесь же."),
           ),
+          h("button", { className: "ag-btn", type: "button", onClick: () => void load() }, "Обновить"),
         ),
         state.error ? h("div", { className: "ag-error", role: "alert" }, state.error) : null,
         h("div", { className: "ag-stats" },
@@ -138,6 +183,38 @@ window.__ModuleLoader__.load({
           h("pre", { className: "ag-code" }, "---\nname: reviewer\ndescription: Ревью диффа\nmodel: deepseek-flash\ntools: read, grep\npermission: read-only\n---\n\nТы ревьюер. Верни только findings."),
         ) : null,
         agents.length > 0 ? h("div", { className: "ag-grid" }, agents.map((agent) => h(AgentCard, { key: agent.name, agent }))) : null,
+        h("div", { className: "ag-section" },
+          h("h3", null, "Worktrees"),
+          h("p", { className: "ag-hint" }, "Изолированные рабочие копии: `project_worktree create` или `project_agent` с `worktree=auto`."),
+          state.data?.worktreeError ? h("div", { className: "ag-error", role: "alert" }, state.data.worktreeError) : null,
+          worktrees.length > 0 ? h("div", { className: "ag-items" }, worktrees.map((tree) => h("article", { className: "ag-item", key: tree.id },
+            h("div", { className: "ag-item-top" },
+              h("code", { title: tree.branch || tree.id }, tree.branch || tree.id),
+              h("span", { className: tree.dirty ? "ag-status-running" : "ag-status-completed" }, tree.dirty ? "dirty" : "clean"),
+            ),
+            h("p", { title: tree.path }, tree.path),
+          ))) : h("div", { className: "ag-mini-empty" }, "Worktree пока нет. Создайте через инструмент `project_worktree`."),
+        ),
+        h("div", { className: "ag-section" },
+          h("h3", null, "Фоновые запуски"),
+          h("p", { className: "ag-hint" }, "`project_agent` с `background=true` возвращает id сразу; статус сохраняется в `.dsh/agents/runs.json`."),
+          runs.length > 0 ? h("div", { className: "ag-items" }, runs.slice().reverse().map((run) => h("article", { className: "ag-item", key: run.id },
+            h("div", { className: "ag-item-top" },
+              h("code", { title: run.id }, run.name),
+              h("span", { className: `ag-status-${run.status}` }, run.status),
+            ),
+            run.task ? h("p", { className: "ag-task", title: run.task }, run.task) : null,
+            h("div", { className: "ag-actions" },
+              run.worktree?.branch ? h("p", null, run.worktree.branch) : null,
+              run.status === "running" ? h("button", {
+                className: "ag-btn",
+                type: "button",
+                disabled: canceling === run.id,
+                onClick: () => void cancel(run.id),
+              }, canceling === run.id ? "Останавливаем…" : "Остановить") : null,
+            ),
+          ))) : h("div", { className: "ag-mini-empty" }, "Фоновых запусков нет."),
+        ),
         h("p", { className: "ag-note" }, state.data?.project ? `Проект: ${state.data.project}` : "Проект определяется по текущей рабочей папке."),
       );
     }

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

@@ -12,6 +12,8 @@ import path from "node:path";
 import { registerProjectHooks } from "./lib/hooks.js";
 import { createCheckpoint } from "./lib/checkpoints.js";
 import { runProjectAgent } from "./lib/agents.js";
+import { cancelRun, listRuns } from "./lib/agents.js";
+import { createWorktree, removeWorktree, worktreeSummary } from "./lib/worktrees.js";
 import { registerChildPolicyHook } from "./lib/policy.js";
 import { registerCommands } from "./lib/commands.js";
 import { registerAgentApi } from "./lib/api.js";
@@ -21,8 +23,13 @@ import { findDshDir, loadAgents, projectFor } from "./lib/project.js";
 export const inject = ["tools", "systemPrompt"];
 
 const TOOL = "project_agent";
+const WORKTREE_TOOL = "project_worktree";
 const AUTO_CHECKPOINT_MS = 10 * 60_000;
 
+function safeSlug(name) {
+  return String(name ?? "agent").toLowerCase().replace(/[^a-z0-9-]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 30) || "agent";
+}
+
 function projectFromAgent(agent) {
   const cwd = agent?.session?.header?.cwd;
   return projectFor(cwd);
@@ -32,14 +39,17 @@ 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).",
+      "Run or list project-local custom agents from `.dsh/agents/*.md`. `run` starts a child agent; `background=true` returns immediately with a run id; `worktree=true|slug` runs the child in an isolated git worktree. `status` lists runs, `cancel` stops one. 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" },
+        action: { type: "string", enum: ["list", "run", "status", "cancel"], description: "list agents, run one, list background runs, or cancel a run" },
         name: { type: "string", description: "Agent name from `.dsh/agents/<name>.md`" },
         task: { type: "string", description: "Task/prompt for the child agent (required for run)" },
+        background: { type: "boolean", description: "Return immediately with a durable run id instead of waiting for the child" },
+        worktree: { type: "string", description: "Run in a git worktree: `auto` picks a name, or pass a lowercase slug" },
+        id: { type: "string", description: "Run id for status/cancel" },
       },
       required: ["action"],
     },
@@ -52,17 +62,92 @@ function toolDefinition(ctx) {
           : "Нет проектных агентов. Создайте `.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" };
+      if (input?.action === "status") {
+        const runs = listRuns(project.root);
+        const text = runs.length
+          ? runs.map((run) => `- ${run.id} · ${run.name} · ${run.status}${run.worktree ? ` · ${run.worktree.branch}` : ""}${run.error ? ` — ${run.error}` : ""}`).join("\n")
+          : "Фоновых запусков нет.";
+        return { ok: true, text: `project_agent status:\n${text}` };
+      }
+      if (input?.action === "cancel") {
+        const id = String(input?.id ?? "").trim();
+        if (!id) return { ok: false, text: "project_agent cancel: id is required" };
+        try {
+          const result = await cancelRun(ctx, exec, id);
+          return { ok: true, text: `project_agent cancel: ${id} (${result.live ? "live" : "already finished"})` };
+        } catch (error) {
+          return { ok: false, text: `project_agent cancel ${id}: ${error instanceof Error ? error.message : String(error)}` };
+        }
+      }
+      if (input?.action !== "run") return { ok: false, text: "project_agent: action must be list, run, status or cancel" };
       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}"` };
+      let worktree = null;
+      try {
+        const requested = input?.worktree;
+        if (requested) {
+          const auto = requested === true || String(requested).toLowerCase() === "auto";
+          const slug = auto ? `${safeSlug(name)}-${Date.now().toString(36).slice(-4)}` : String(requested);
+          worktree = createWorktree({ cwd: project.root, slug });
+        }
+        const result = await runProjectAgent(ctx, exec, definition, task, {
+          background: input?.background === true,
+          worktree,
+          cwd: worktree?.path,
+        });
+        if (result.background) return { ok: true, text: result.text, background: true, id: result.id, worktree };
+        const suffix = worktree ? `\nworktree: ${worktree.branch} → ${worktree.path}` : "";
+        return { ok: true, text: `project_agent ${name} (${result.stopReason}):\n${result.text}${suffix}`, worktree };
+      } catch (error) {
+        const suffix = worktree ? ` (worktree ${worktree.branch} сохранён для разбора)` : "";
+        return { ok: false, text: `project_agent ${name}: ${error instanceof Error ? error.message : String(error)}${suffix}` };
+      }
+    },
+  };
+}
+
+function worktreeToolDefinition() {
+  return {
+    name: WORKTREE_TOOL,
+    description:
+      "Manage isolated git worktrees for project agents. `list` shows branches, paths, dirty state; `create` adds `.dsh/worktrees/<slug>` on branch `dsh/<slug>`; `remove` refuses a dirty worktree unless force=true. The branch is kept after removal.",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { type: "string", enum: ["list", "create", "remove"], description: "list, create or remove a worktree" },
+        slug: { type: "string", description: "Worktree id: lowercase letters, digits, hyphen" },
+        base: { type: "string", description: "Base ref for create; default HEAD" },
+        force: { type: "boolean", description: "Remove a dirty/locked worktree (data loss risk)" },
+      },
+      required: ["action"],
+    },
+    async execute(input, exec) {
+      const project = projectFromAgent(exec?.agent);
       try {
-        const result = await runProjectAgent(ctx, exec, definition, task);
-        return { ok: true, text: `project_agent ${name} (${result.stopReason}):\n${result.text}` };
+        if (input?.action === "list") {
+          const summary = worktreeSummary({ cwd: project.root });
+          const lines = summary.worktrees.map((item) => `- ${item.id} · ${item.branch ?? "detached"} · ${item.path}${item.dirty ? " · dirty" : ""}${item.locked ? " · locked" : ""}`);
+          return { ok: true, text: `project_worktree list (${summary.repo}):\n${lines.length ? lines.join("\n") : "Рабочих worktree нет."}` };
+        }
+        if (input?.action === "create") {
+          const slug = String(input?.slug ?? "").trim();
+          if (!slug) return { ok: false, text: "project_worktree create: slug is required" };
+          const created = createWorktree({ cwd: project.root, slug, base: input?.base });
+          return { ok: true, text: `project_worktree create: ${created.branch} → ${created.path}`, worktree: created };
+        }
+        if (input?.action === "remove") {
+          const slug = String(input?.slug ?? "").trim();
+          if (!slug) return { ok: false, text: "project_worktree remove: slug is required" };
+          const removed = removeWorktree({ cwd: project.root, id: slug, force: input?.force === true });
+          return { ok: true, text: `project_worktree remove: ${slug} (branch ${removed.branchKept ?? "kept"})`, worktree: removed };
+        }
+        return { ok: false, text: "project_worktree: action must be list, create or remove" };
       } catch (error) {
-        return { ok: false, text: `project_agent ${name}: ${error instanceof Error ? error.message : String(error)}` };
+        return { ok: false, text: `project_worktree ${input?.action}: ${error instanceof Error ? error.message : String(error)}` };
       }
     },
   };
@@ -102,6 +187,7 @@ export function apply(ctx) {
 
   try {
     ctx.effect(() => ctx.tools.register(toolDefinition(ctx)), "agent-extensions: project_agent tool");
+    ctx.effect(() => ctx.tools.register(worktreeToolDefinition()), "agent-extensions: project_worktree tool");
   } catch (error) {
     ctx.logger?.warn?.(`[agent-extensions] tool registration failed: ${error instanceof Error ? error.message : String(error)}`);
   }

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

@@ -1,13 +1,16 @@
 /**
  * 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.
+ * A child runs through the DSH subagents service with its own context. It can
+ * run in the foreground (returns final text), in a git worktree, or in the
+ * background with a durable run record under `.dsh/agents/runs.json`.
  */
 import crypto from "node:crypto";
-import { loadAgents } from "./project.js";
+import { loadAgents, projectFor } from "./project.js";
 import { clearChildPolicy, setChildPolicy } from "./policy.js";
+import { loadRuns, runPreview, updateRun, upsertRun } from "./runs.js";
+
+const background = new Map();
 
 function textFromOutput(output) {
   if (!Array.isArray(output)) return "";
@@ -18,7 +21,15 @@ function textFromOutput(output) {
     .trim();
 }
 
-export async function runProjectAgent(ctx, exec, definition, task) {
+function finishRun(projectRoot, id, patch) {
+  try { updateRun(projectRoot, id, patch); } catch { /* registry is best effort */ }
+}
+
+function remember(record, activation, projectRoot, signal, onAbort) {
+  background.set(record.id, { record, activation, projectRoot, signal, onAbort });
+}
+
+export async function runProjectAgent(ctx, exec, definition, task, options = {}) {
   const subagents = ctx.get("subagents");
   if (!subagents || typeof subagents.startActivation !== "function") {
     throw new Error("subagents service is unavailable");
@@ -26,17 +37,21 @@ export async function runProjectAgent(ctx, exec, definition, task) {
   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 project = projectFor(exec?.agent?.session?.header?.cwd);
+  const cwd = options.cwd ?? exec?.agent?.session?.header?.cwd;
+  const isBackground = options.background === true;
   const controller = new AbortController();
-  const signal = exec?.signal;
+  const signal = isBackground ? undefined : 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);
+  let activation;
   try {
     const prompt = [`<project-agent name="${definition.name}">`, definition.body, "</project-agent>", "", "Task:", String(task ?? "")].join("\n");
-    const activation = await subagents.startActivation({
+    activation = await subagents.startActivation({
       provider,
       label: `agent:${definition.name}`,
       childId: reservedId,
@@ -44,7 +59,7 @@ export async function runProjectAgent(ctx, exec, definition, task) {
         prompt: [{ type: "text", text: prompt }],
         parent: exec.agent,
         signal: controller.signal,
-        cwd: exec?.agent?.session?.header?.cwd,
+        cwd,
         ...(definition.model ? { agentOptions: { model: definition.model } } : {}),
       },
       signal: controller.signal,
@@ -55,18 +70,132 @@ export async function runProjectAgent(ctx, exec, definition, task) {
       setChildPolicy(activeId, definition);
       clearChildPolicy(reservedId);
     }
+    if (isBackground) {
+      const startedAt = new Date().toISOString();
+      const record = {
+        id: reservedId,
+        childId: activeId,
+        name: definition.name,
+        task: runPreview(task),
+        cwd,
+        worktree: options.worktree ?? null,
+        parentId: exec?.agent?.session?.id ?? null,
+        startedAt,
+        finishedAt: null,
+        status: "running",
+        stopReason: null,
+        result: "",
+        error: "",
+      };
+      upsertRun(project.root, record);
+      remember(record, activation, project.root, signal, abort);
+      activation.result.then(async (result) => {
+        const currentRecord = loadRuns(project.root).find((item) => item.id === record.id);
+        if (currentRecord?.status !== "canceled") {
+          const text = textFromOutput(result?.output);
+          finishRun(project.root, record.id, {
+            status: result?.stopReason === "completed" ? "completed" : "failed",
+            stopReason: result?.stopReason ?? "completed",
+            finishedAt: new Date().toISOString(),
+            result: runPreview(text),
+            error: result?.stopReason === "completed" ? "" : (result?.diagnostic ?? "agent failed"),
+          });
+        }
+        try { await activation.dispose?.(); } catch { /* best effort */ }
+        clearChildPolicy(activeId);
+        background.delete(record.id);
+        signal?.removeEventListener?.("abort", abort);
+      }).catch((error) => {
+        const currentRecord = loadRuns(project.root).find((item) => item.id === record.id);
+        if (currentRecord?.status !== "canceled") {
+          finishRun(project.root, record.id, {
+            status: "failed",
+            finishedAt: new Date().toISOString(),
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+        clearChildPolicy(activeId);
+        background.delete(record.id);
+        signal?.removeEventListener?.("abort", abort);
+      });
+      return {
+        background: true,
+        id: record.id,
+        childId: activeId,
+        name: definition.name,
+        worktree: record.worktree,
+        text: `Фоновый агент ${definition.name} запущен: ${record.id}${record.worktree ? ` · ${record.worktree.branch}` : ""}`,
+      };
+    }
     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);
+    return { text, stopReason: result?.stopReason ?? "completed", worktree: options.worktree ?? null };
+  } catch (error) {
     clearChildPolicy(activeId);
-    signal?.removeEventListener?.("abort", abort);
+    if (isBackground) {
+      const message = error instanceof Error ? error.message : String(error);
+      const record = {
+        id: reservedId,
+        childId: activeId,
+        name: definition.name,
+        task: runPreview(task),
+        cwd,
+        worktree: options.worktree ?? null,
+        parentId: exec?.agent?.session?.id ?? null,
+        startedAt: new Date().toISOString(),
+        finishedAt: new Date().toISOString(),
+        status: "failed",
+        stopReason: null,
+        result: "",
+        error: message,
+      };
+      try { upsertRun(project.root, record); } catch { /* best effort */ }
+      return { background: true, id: record.id, name: definition.name, error: message, text: `Фоновый агент ${definition.name} не запустился: ${message}` };
+    }
+    throw error;
+  } finally {
+    if (!isBackground) signal?.removeEventListener?.("abort", abort);
   }
 }
 
+export function listRuns(projectRoot) {
+  const persisted = loadRuns(projectRoot);
+  return persisted.map((run) => {
+    const live = background.get(run.id);
+    return {
+      ...run,
+      status: live ? run.status : (run.status === "running" ? "unknown" : run.status),
+      live: Boolean(live),
+    };
+  });
+}
+
+export async function cancelRun(ctx, exec, id) {
+  const entry = background.get(String(id ?? ""));
+  const project = projectFor(exec?.agent?.session?.header?.cwd);
+  if (!entry) {
+    const run = loadRuns(project.root).find((item) => item.id === id);
+    if (!run) throw new Error(`run not found: ${id}`);
+    updateRun(project.root, run.id, { status: "canceled", finishedAt: new Date().toISOString(), error: "cancel requested (not live)" });
+    return { id: run.id, canceled: true, live: false };
+  }
+  const subagents = ctx.get("subagents");
+  try {
+    subagents?.interrupt?.(entry.record.childId, {
+      kind: "user",
+      parentSessionId: entry.record.parentId ?? exec?.agent?.session?.id,
+    });
+  } catch { /* disposal below still stops the local activation */ }
+  try { await entry.activation.dispose?.(); } catch { /* best effort */ }
+  clearChildPolicy(entry.record.childId);
+  background.delete(entry.record.id);
+  entry.signal?.removeEventListener?.("abort", entry.onAbort);
+  updateRun(project.root, entry.record.id, { status: "canceled", finishedAt: new Date().toISOString(), error: "canceled by user" });
+  return { id: entry.record.id, canceled: true, live: true };
+}
+
 export function projectAgentSummary(projectDir, dshDir) {
   return loadAgents(projectDir, dshDir).map((agent) => ({
     name: agent.name,

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

@@ -2,6 +2,8 @@
  * Authenticated RPC for the Agents settings page.
  */
 import { loadAgents, projectFor } from "./project.js";
+import { cancelRun, listRuns } from "./agents.js";
+import { worktreeSummary } from "./worktrees.js";
 
 export const RPC_NAMESPACE = "dsh-agent-extensions";
 const ROUTE_BASE = "/api/dsh-agent-extensions";
@@ -21,7 +23,17 @@ async function envelope(request) {
 }
 
 export function registerAgentApi(ctx) {
-  const route = {
+  const sessionFrom = (payload) => {
+    const sessions = ctx.get?.("sessions");
+    let session = payload?.sessionId ? sessions?.get?.(payload.sessionId) : undefined;
+    if (!session && typeof sessions?.list === "function") {
+      const live = sessions.list();
+      session = live.length > 0 ? live[live.length - 1] : undefined;
+    }
+    return session;
+  };
+
+  const listRoute = {
     path: `${ROUTE_BASE}/list`,
     methods: ["POST"],
     requestBody: "buffered",
@@ -31,12 +43,7 @@ export function registerAgentApi(ctx) {
         const value = await envelope(request);
         rpcId = value.rpcId;
         if (value.method !== `${RPC_NAMESPACE}/list`) throw new Error("endpoint/method mismatch");
-        const sessions = ctx.get?.("sessions");
-        let session = value.payload?.sessionId ? sessions?.get?.(value.payload.sessionId) : undefined;
-        if (!session && typeof sessions?.list === "function") {
-          const live = sessions.list();
-          session = live.length > 0 ? live[live.length - 1] : undefined;
-        }
+        const session = sessionFrom(value.payload);
         const project = projectFor(value.payload?.cwd || session?.header?.cwd || process.cwd());
         const agents = loadAgents(project.root, project.dsh).map((agent) => ({
           name: agent.name,
@@ -45,14 +52,50 @@ export function registerAgentApi(ctx) {
           tools: agent.tools,
           permission: agent.permission,
         }));
-        return ok(rpcId, { project: project.root, agents });
+        let worktrees = [];
+        let worktreeError = "";
+        try {
+          worktrees = worktreeSummary({ cwd: project.root }).worktrees;
+        } catch (error) {
+          worktreeError = error instanceof Error ? error.message : String(error);
+        }
+        return ok(rpcId, {
+          project: project.root,
+          agents,
+          worktrees,
+          worktreeError,
+          runs: listRuns(project.root),
+        });
       } 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");
+
+  const cancelRoute = {
+    path: `${ROUTE_BASE}/cancel`,
+    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}/cancel`) throw new Error("endpoint/method mismatch");
+        const session = sessionFrom(value.payload);
+        const project = projectFor(value.payload?.cwd || session?.header?.cwd || process.cwd());
+        const result = await cancelRun(ctx, { agent: { session } }, String(value.payload?.id ?? ""));
+        return ok(rpcId, { ...result, project: project.root });
+      } catch (error) {
+        return fail(rpcId, error instanceof Error ? error.message : String(error));
+      }
+    },
+  };
+
+  for (const route of [listRoute, cancelRoute]) {
+    ctx.effect(() => {
+      const dispose = ctx.connection.fetch.register(route);
+      return () => { try { void Promise.resolve(dispose()).catch(() => {}); } catch { /* unloading */ } };
+    }, `agent-extensions: ${route.path}`);
+  }
 }

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

@@ -0,0 +1,60 @@
+/**
+ * Durable registry for background project-agent runs.
+ *
+ * A record is intentionally small: ids, worktree/branch, status and a short
+ * preview. Full child transcripts remain in DSH session storage.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+const LIMIT = 100;
+const PREVIEW = 2_000;
+
+export function runsPath(projectRoot) {
+  return path.join(projectRoot, ".dsh", "agents", "runs.json");
+}
+
+function clip(value, max = PREVIEW) {
+  const text = String(value ?? "");
+  return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+
+export function loadRuns(projectRoot) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(runsPath(projectRoot), "utf8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveRuns(projectRoot, runs) {
+  const file = runsPath(projectRoot);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(runs.slice(-LIMIT), null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  fs.renameSync(temp, file);
+}
+
+export function upsertRun(projectRoot, record) {
+  const runs = loadRuns(projectRoot);
+  const index = runs.findIndex((run) => run.id === record.id);
+  const next = { ...(index >= 0 ? runs[index] : {}), ...record };
+  if (index >= 0) runs[index] = next;
+  else runs.push(next);
+  saveRuns(projectRoot, runs);
+  return next;
+}
+
+export function updateRun(projectRoot, id, patch) {
+  const runs = loadRuns(projectRoot);
+  const index = runs.findIndex((run) => run.id === id);
+  if (index < 0) return null;
+  runs[index] = { ...runs[index], ...patch };
+  saveRuns(projectRoot, runs);
+  return runs[index];
+}
+
+export function runPreview(value) {
+  return clip(value);
+}