@webpresso/agent-kit 3.1.30 → 3.2.0

package/dist/esm/daemon/domains/git-actions.js

@@ -1,8 +1,18 @@
 /**
  * Daemon-side git helpers for review panel RPCs (Task 1.5).
  * Runs real git via child_process — never re-implements porcelain.
+ *
+ * `gitCreatePr` additionally spawns `gh` (same class of utility-binary spawn
+ * as the `git` calls above — see Trust Dossier Material Decision MD1 on the
+ * desktop-daemon-rpc-completion blueprint overview for why this does not
+ * cross the daemon's "no agent-child spawn" invariant). It adapts
+ * the gh-wrapping logic from `src/mcp/tools/pr-upsert.ts` (preflight,
+ * collision detection, canonical re-fetch, output redaction) to this
+ * module's synchronous-git / injectable-deps pattern.
  */
 import { execFileSync } from "node:child_process";
+import { runCommand, isRunFailure } from "#mcp/tools/_shared/run-command.js";
+import { redactText } from "#mcp/tools/_shared/redact.js";
 export function gitDiff(cwd) {
     const out = execFileSync("git", ["status", "--porcelain=v1", "-uall", "--no-renames"], {
         cwd,
@@ -45,3 +55,129 @@ export function gitCommit(cwd, message, paths, options) {
     }).trim();
     return { commitSha };
 }
+/** Same default timeoutMs `src/mcp/tools/pr-upsert.ts` already uses for `gh` calls. */
+const GH_TIMEOUT_MS = 120_000;
+function defaultCurrentBranch(cwd) {
+    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    if (!branch || branch === "HEAD") {
+        throw new Error("git.createPr requires a named branch (HEAD is detached)");
+    }
+    return branch;
+}
+function defaultGh(args, cwd) {
+    return runCommand("gh", args, { cwd, timeoutMs: GH_TIMEOUT_MS });
+}
+function outcomeText(outcome) {
+    if (isRunFailure(outcome))
+        return outcome.error.message;
+    return [outcome.stdout, outcome.stderr].filter(Boolean).join("\n");
+}
+function outcomeOk(outcome) {
+    return !isRunFailure(outcome) && outcome.exitCode === 0;
+}
+function parseTarget(outcome) {
+    if (!outcomeOk(outcome))
+        return undefined;
+    try {
+        const parsed = JSON.parse(outcome.stdout);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const value = parsed;
+        return {
+            number: typeof value.number === "number" ? value.number : undefined,
+            url: typeof value.url === "string" ? value.url : undefined,
+            title: typeof value.title === "string" ? value.title : undefined,
+            state: typeof value.state === "string" ? value.state : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Mirrors `src/mcp/tools/pr-upsert.ts`'s `isNoPr` string-matching (do not reinvent). */
+function isNoPr(outcome) {
+    if (outcomeOk(outcome))
+        return false;
+    const text = outcomeText(outcome).toLowerCase();
+    return (text.includes("no pull requests found") ||
+        text.includes("no pull request found") ||
+        text.includes("could not find pull request"));
+}
+/** Mirrors `src/mcp/tools/pr-upsert.ts`'s `isCreateCollision` string-matching (do not reinvent). */
+function isCreateCollision(outcome) {
+    if (outcomeOk(outcome))
+        return false;
+    const text = outcomeText(outcome).toLowerCase();
+    return text.includes("already exists") || text.includes("a pull request already");
+}
+function throwGhFailure(action, outcome) {
+    const detail = redactText(outcomeText(outcome)) || "unknown error";
+    throw new Error(`git.createPr: gh ${action} failed: ${detail}`);
+}
+function requireUrl(target, context) {
+    if (!target.url) {
+        throw new Error(`git.createPr: ${context} did not return a PR url`);
+    }
+    return target.url;
+}
+function buildEditArgs(branch, title, body) {
+    const args = ["pr", "edit", branch, "--title", title];
+    if (body !== undefined)
+        args.push("--body", body);
+    return args;
+}
+function buildCreateArgs(branch, base, title, body) {
+    const args = ["pr", "create", "--head", branch, "--base", base, "--title", title];
+    if (body !== undefined)
+        args.push("--body", body);
+    return args;
+}
+/**
+ * Upsert semantics (the frozen daemon contract has no create/update `mode`
+ * field, see Trust Dossier MD2): edit the PR for the current branch if one
+ * already exists, else create it against the repo's default branch. Every
+ * success path re-fetches the canonical PR view rather than trusting
+ * `gh pr create`'s stdout alone (matches `src/mcp/tools/pr-upsert.ts`'s
+ * canonical-refetch pattern) so a create-collision (two callers racing)
+ * still returns the real PR instead of throwing.
+ */
+export async function gitCreatePr(cwd, title, body, deps) {
+    const currentBranch = deps?.currentBranch ?? defaultCurrentBranch;
+    const gh = deps?.gh ?? defaultGh;
+    const branch = currentBranch(cwd);
+    const preflight = await gh(["pr", "view", branch, "--json", "number,url,title,state"], cwd);
+    if (outcomeOk(preflight)) {
+        const target = parseTarget(preflight);
+        if (!target)
+            throwGhFailure("pr view (preflight)", preflight);
+        const edit = await gh(buildEditArgs(branch, title, body), cwd);
+        if (!outcomeOk(edit))
+            throwGhFailure("pr edit", edit);
+        return { url: requireUrl(target, "pr view (preflight)"), number: target.number };
+    }
+    if (!isNoPr(preflight))
+        throwGhFailure("pr view (preflight)", preflight);
+    const repoView = await gh(["repo", "view", "--json", "defaultBranchRef", "-q", ".defaultBranchRef.name"], cwd);
+    if (!outcomeOk(repoView))
+        throwGhFailure("repo view (default branch)", repoView);
+    const base = repoView.stdout.trim();
+    if (!base) {
+        throw new Error("git.createPr: could not resolve the repository default branch");
+    }
+    const create = await gh(buildCreateArgs(branch, base, title, body), cwd);
+    if (!outcomeOk(create) && !isCreateCollision(create)) {
+        throwGhFailure("pr create", create);
+    }
+    const canonical = await gh(["pr", "view", branch, "--json", "number,url,title,state"], cwd);
+    const canonicalTarget = parseTarget(canonical);
+    if (!canonicalTarget)
+        throwGhFailure("pr view (canonical)", canonical);
+    return {
+        url: requireUrl(canonicalTarget, "pr view (canonical)"),
+        number: canonicalTarget.number,
+    };
+}

package/dist/esm/daemon/domains/run-registry-interop.d.ts

@@ -2,6 +2,8 @@
  * Cross-process run-registry interop between wp dash and the desktop app (1.6).
  * Reuses the existing dash run-registry store paths — no second registry.
  */
+import type { DashRun } from "#cli/commands/dash/run-types.js";
+import type { SessionsListResult, SessionSummary } from "#daemon/protocol/contract.js";
 export type RunRegistrySnapshot = {
     readonly root: string;
     readonly runIds: readonly string[];
@@ -12,3 +14,17 @@ export type RunRegistrySnapshot = {
  * `root` should be the directory that contains per-run JSON sidecars.
  */
 export declare function listRunRegistry(root: string): RunRegistrySnapshot;
+/** Pure mapping from a dash run to the daemon's UI-facing session shape. */
+export declare function toSessionSummary(run: DashRun): SessionSummary;
+export interface ListDaemonSessionsOptions {
+    readonly cwd?: string;
+    readonly limit?: number;
+}
+/**
+ * Daemon `sessions.list` backing implementation: reads the real dash
+ * run-registry (no second registry) and maps it to the daemon wire shape.
+ * Complexity: O(n log n) for the updatedAt-descending sort (n = dash runs at
+ * one repo root — small/bounded); no additional filesystem scans beyond the
+ * single locked registry read `readDashRuns` already performs.
+ */
+export declare function listDaemonSessions(options?: ListDaemonSessionsOptions): Promise<SessionsListResult>;

package/dist/esm/daemon/domains/run-registry-interop.js

@@ -4,6 +4,7 @@
  */
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { readDashRuns } from "#cli/commands/dash/run-registry.js";
 /**
  * List run ids under a dash-compatible registry root.
  * `root` should be the directory that contains per-run JSON sidecars.
@@ -27,3 +28,47 @@ export function listRunRegistry(root) {
     }
     return { root, runIds: runIds.sort(), readable: true };
 }
+/**
+ * Daemon `providerIdSchema` (src/daemon/protocol/contract.ts) only accepts
+ * 'claude' | 'codex' | 'opencode' | 'fleet'. `DashRun.provider` can also be
+ * 'grok' (src/cli/commands/dash/provider-capabilities.ts DASH_PROVIDERS).
+ * `parseUiMethodResult` is `.strict()` and would throw on the whole response
+ * for one out-of-enum row, so an unrecognized provider is omitted (the field
+ * is optional on `SessionSummary`) rather than passed through or fabricated.
+ */
+const KNOWN_DAEMON_PROVIDERS = new Set([
+    "claude",
+    "codex",
+    "opencode",
+    "fleet",
+]);
+function isKnownDaemonProvider(provider) {
+    return KNOWN_DAEMON_PROVIDERS.has(provider);
+}
+/** Pure mapping from a dash run to the daemon's UI-facing session shape. */
+export function toSessionSummary(run) {
+    return {
+        id: run.id,
+        ...(isKnownDaemonProvider(run.provider) ? { provider: run.provider } : {}),
+        label: run.label,
+        state: run.state,
+        cwd: run.cwd,
+        permissionMode: run.permissionMode,
+        updatedAt: run.updatedAt,
+    };
+}
+/**
+ * Daemon `sessions.list` backing implementation: reads the real dash
+ * run-registry (no second registry) and maps it to the daemon wire shape.
+ * Complexity: O(n log n) for the updatedAt-descending sort (n = dash runs at
+ * one repo root — small/bounded); no additional filesystem scans beyond the
+ * single locked registry read `readDashRuns` already performs.
+ */
+export async function listDaemonSessions(options = {}) {
+    const { runs } = await readDashRuns({ cwd: options.cwd });
+    const sorted = [...runs].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    const limited = typeof options.limit === "number" && options.limit >= 0
+        ? sorted.slice(0, options.limit)
+        : sorted;
+    return { sessions: limited.map(toSessionSummary) };
+}

package/dist/esm/daemon/domains/sessions-search.d.ts

@@ -18,3 +18,14 @@ export declare function searchSessions(backend: SessionSearchBackend, options: {
     readonly query: string;
     readonly limit?: number;
 }): readonly SessionSearchHit[];
+/**
+ * Production backend: opens the real `SessionMemoryStore` FTS index (porter
+ * → trigram → Levenshtein fallback, same engine behind `wp_session_search`)
+ * and reuses its indexed search — never a table scan. A fresh store is
+ * opened and closed per call, mirroring the exact pattern
+ * `src/mcp/tools/session-restore.ts`'s `buildRecallPayload` already uses for
+ * the identical class (avoids a stale open SQLite/WAL handle). Caching a
+ * store across daemon-lifetime calls is intentionally deferred (YAGNI) until
+ * there is evidence of per-RPC latency pressure.
+ */
+export declare function createSessionMemorySearchBackend(indexDbPath: string): SessionSearchBackend;

package/dist/esm/daemon/domains/sessions-search.js

@@ -2,6 +2,7 @@
  * Session search domain (Task 3.7).
  * Pure ranking/filter helpers + injectable FTS backend (session-memory store).
  */
+import { SessionMemoryStore } from "#session-memory/store.js";
 /** Normalize and bound a search query; empty → no search. */
 export function normalizeSearchQuery(query) {
     return query.trim().replace(/\s+/gu, " ").slice(0, 200);
@@ -14,3 +15,31 @@ export function searchSessions(backend, options) {
     const limit = Math.min(Math.max(options.limit ?? 20, 1), 100);
     return backend.search(q, limit);
 }
+/**
+ * Production backend: opens the real `SessionMemoryStore` FTS index (porter
+ * → trigram → Levenshtein fallback, same engine behind `wp_session_search`)
+ * and reuses its indexed search — never a table scan. A fresh store is
+ * opened and closed per call, mirroring the exact pattern
+ * `src/mcp/tools/session-restore.ts`'s `buildRecallPayload` already uses for
+ * the identical class (avoids a stale open SQLite/WAL handle). Caching a
+ * store across daemon-lifetime calls is intentionally deferred (YAGNI) until
+ * there is evidence of per-RPC latency pressure.
+ */
+export function createSessionMemorySearchBackend(indexDbPath) {
+    return {
+        search(query, limit) {
+            const store = new SessionMemoryStore(indexDbPath);
+            try {
+                return store.search({ query, limit }).map((hit) => ({
+                    id: hit.id,
+                    source: hit.source,
+                    text: hit.text,
+                    score: hit.score,
+                }));
+            }
+            finally {
+                store.close();
+            }
+        },
+    };
+}

package/dist/esm/daemon/handlers/blueprints-handlers.d.ts

@@ -0,0 +1,5 @@
+import type { MethodHandler } from "#daemon/rpc.js";
+/**
+ * Build blueprint-domain handlers scoped to `repoRoot`.
+ */
+export declare function createBlueprintsHandlers(repoRoot: string): Readonly<Partial<Record<string, MethodHandler>>>;

package/dist/esm/daemon/handlers/blueprints-handlers.js

@@ -0,0 +1,36 @@
+/**
+ * Blueprint-domain product handlers: `blueprints.list` is a real
+ * implementation over the `blueprints/<status>/` directories; `blueprints.exec`
+ * is not implemented (exec remains CLI-owned).
+ */
+import { readdirSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+function listBlueprintRows(repoRoot) {
+    const statuses = ["completed", "in-progress", "planned", "parked", "draft", "archived"];
+    const rows = [];
+    for (const status of statuses) {
+        const dir = join(repoRoot, "blueprints", status);
+        if (!existsSync(dir) || !statSync(dir).isDirectory())
+            continue;
+        for (const name of readdirSync(dir)) {
+            if (name.startsWith("."))
+                continue;
+            rows.push({ slug: name, status });
+        }
+    }
+    rows.sort((a, b) => a.slug.localeCompare(b.slug));
+    return rows;
+}
+/**
+ * Build blueprint-domain handlers scoped to `repoRoot`.
+ */
+export function createBlueprintsHandlers(repoRoot) {
+    return {
+        "blueprints.list": () => ({
+            blueprints: listBlueprintRows(repoRoot),
+        }),
+        "blueprints.exec": () => {
+            throw new Error("blueprints.exec is not implemented (exec remains CLI-owned)");
+        },
+    };
+}

package/dist/esm/daemon/handlers/deploy-handlers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Deploy-domain product handlers: `deploy.run` is not implemented (no deploy
+ * job ledger; refuse fabricated handles).
+ */
+import type { MethodHandler } from "#daemon/rpc.js";
+export declare const deployHandlers: Readonly<Partial<Record<string, MethodHandler>>>;

package/dist/esm/daemon/handlers/deploy-handlers.js

@@ -0,0 +1,5 @@
+export const deployHandlers = {
+    "deploy.run": () => {
+        throw new Error("deploy.run is not implemented (no deploy job ledger; refuse fabricated handles)");
+    },
+};

package/dist/esm/daemon/handlers/fleet-handlers.d.ts

@@ -0,0 +1,15 @@
+import type { MethodHandler } from "#daemon/rpc.js";
+import { type FleetStatus } from "#fleet/status.js";
+import type { FleetStatusResult } from "#daemon/protocol/contract.js";
+/**
+ * Adapt the rich `collectFleetStatus` output down to the FROZEN daemon wire
+ * contract `{ agents: [{ id, state, label? }] }` that
+ * apps/desktop/src-tauri/src/commands/fleet.rs already destructures. Pure /
+ * unit-testable without spawning real git or gh. Complexity: O(worktrees).
+ */
+export declare function toFleetStatusResult(status: FleetStatus): FleetStatusResult;
+/**
+ * Build fleet-domain handlers. `repoRoot` is the default worktree root used
+ * when a request does not supply its own `repoRoot` param.
+ */
+export declare function createFleetHandlers(repoRoot: string): Readonly<Partial<Record<string, MethodHandler>>>;

package/dist/esm/daemon/handlers/fleet-handlers.js

@@ -0,0 +1,91 @@
+/**
+ * Fleet-domain product handlers: `worktrees.list` is a real implementation
+ * over `git worktree list`; `fleet.status` calls the production
+ * `collectFleetStatus` engine and adapts its shape to the frozen daemon
+ * wire contract.
+ */
+import { execFileSync } from "node:child_process";
+import { collectFleetStatus } from "#fleet/status.js";
+import { asRecord } from "./shared.js";
+function worktreeRows(repoRoot) {
+    try {
+        const out = execFileSync("git", ["worktree", "list", "--porcelain"], {
+            cwd: repoRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const rows = [];
+        let path;
+        let branch;
+        for (const line of out.split("\n")) {
+            if (line.startsWith("worktree ")) {
+                if (path)
+                    rows.push({ path, branch });
+                path = line.slice("worktree ".length).trim();
+                branch = undefined;
+            }
+            else if (line.startsWith("branch ")) {
+                branch = line
+                    .slice("branch ".length)
+                    .trim()
+                    .replace(/^refs\/heads\//u, "");
+            }
+            else if (line === "") {
+                if (path)
+                    rows.push({ path, branch });
+                path = undefined;
+                branch = undefined;
+            }
+        }
+        if (path)
+            rows.push({ path, branch });
+        return rows;
+    }
+    catch {
+        return [{ path: repoRoot }];
+    }
+}
+/** Single-string worktree classification the frozen daemon wire contract carries as `state`. */
+function classifyWorktreeState(git) {
+    if (git.dirtyFiles === null)
+        return "unknown";
+    if (git.dirtyFiles > 0)
+        return "dirty";
+    if ((git.ahead ?? 0) > 0 || (git.behind ?? 0) > 0)
+        return "drifted";
+    return "clean";
+}
+/**
+ * Adapt the rich `collectFleetStatus` output down to the FROZEN daemon wire
+ * contract `{ agents: [{ id, state, label? }] }` that
+ * apps/desktop/src-tauri/src/commands/fleet.rs already destructures. Pure /
+ * unit-testable without spawning real git or gh. Complexity: O(worktrees).
+ */
+export function toFleetStatusResult(status) {
+    return {
+        agents: status.worktrees.map((worktree) => ({
+            id: worktree.path,
+            state: classifyWorktreeState(worktree.git),
+            ...(worktree.label ? { label: worktree.label } : {}),
+        })),
+    };
+}
+/**
+ * Build fleet-domain handlers. `repoRoot` is the default worktree root used
+ * when a request does not supply its own `repoRoot` param.
+ */
+export function createFleetHandlers(repoRoot) {
+    return {
+        "fleet.status": async () => {
+            const status = await collectFleetStatus({ cwd: repoRoot });
+            return toFleetStatusResult(status);
+        },
+        "worktrees.list": (_session, params) => {
+            const record = asRecord(params);
+            const root = typeof record.repoRoot === "string" && record.repoRoot.length > 0
+                ? record.repoRoot
+                : repoRoot;
+            return { worktrees: worktreeRows(root) };
+        },
+    };
+}

package/dist/esm/daemon/handlers/git-handlers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Git-domain product handlers: `git.diff`, `git.commit`, and `git.createPr`
+ * are real implementations over `src/daemon/domains/git-actions.ts`.
+ */
+import type { MethodHandler } from "#daemon/rpc.js";
+export declare const gitHandlers: Readonly<Partial<Record<string, MethodHandler>>>;

package/dist/esm/daemon/handlers/git-handlers.js

@@ -0,0 +1,27 @@
+import { gitDiff, gitCommit, gitCreatePr } from "#daemon/domains/git-actions.js";
+import { asRecord, requireString } from "./shared.js";
+export const gitHandlers = {
+    "git.diff": (_session, params) => {
+        const record = asRecord(params);
+        const cwd = requireString(record, "cwd");
+        return gitDiff(cwd);
+    },
+    "git.commit": (_session, params) => {
+        const record = asRecord(params);
+        const cwd = requireString(record, "cwd");
+        const message = requireString(record, "message");
+        const paths = Array.isArray(record.paths)
+            ? record.paths.filter((p) => typeof p === "string")
+            : undefined;
+        return gitCommit(cwd, message, paths);
+    },
+    "git.createPr": (_session, params) => {
+        const record = asRecord(params);
+        const cwd = requireString(record, "cwd");
+        const title = requireString(record, "title");
+        // confirmationToken is already consumed by DaemonAuthz before this
+        // handler runs (methods.ts requiresConfirmation) — no re-check needed here.
+        const body = typeof record.body === "string" ? record.body : undefined;
+        return gitCreatePr(cwd, title, body);
+    },
+};

package/dist/esm/daemon/handlers/product.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Default production handlers for registered product-domain RPC methods.
+ * Wired at daemon start so callers do not need ad-hoc injection.
+ *
+ * Domain implementations live in the sibling `*-handlers.ts` files; this
+ * module only aggregates them into the map `startDaemonServer` consumes.
+ */
 import type { MethodHandler } from "#daemon/rpc.js";
 /**
  * Build the default handler map. Callers may override individual methods via

package/dist/esm/daemon/handlers/product.js

@@ -1,78 +1,8 @@
-/**
- * Default production handlers for registered product-domain RPC methods.
- * Wired at daemon start so callers do not need ad-hoc injection.
- */
-import { readdirSync, existsSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { execFileSync } from "node:child_process";
-import { gitDiff, gitCommit } from "#daemon/domains/git-actions.js";
-function asRecord(params) {
-    if (params === null || typeof params !== "object" || Array.isArray(params)) {
-        return {};
-    }
-    return params;
-}
-function requireString(record, key) {
-    const v = record[key];
-    if (typeof v !== "string" || v.length === 0) {
-        throw new Error(`missing string param: ${key}`);
-    }
-    return v;
-}
-function listBlueprintRows(repoRoot) {
-    const statuses = ["completed", "in-progress", "planned", "parked", "draft", "archived"];
-    const rows = [];
-    for (const status of statuses) {
-        const dir = join(repoRoot, "blueprints", status);
-        if (!existsSync(dir) || !statSync(dir).isDirectory())
-            continue;
-        for (const name of readdirSync(dir)) {
-            if (name.startsWith("."))
-                continue;
-            rows.push({ slug: name, status });
-        }
-    }
-    rows.sort((a, b) => a.slug.localeCompare(b.slug));
-    return rows;
-}
-function worktreeRows(repoRoot) {
-    try {
-        const out = execFileSync("git", ["worktree", "list", "--porcelain"], {
-            cwd: repoRoot,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const rows = [];
-        let path;
-        let branch;
-        for (const line of out.split("\n")) {
-            if (line.startsWith("worktree ")) {
-                if (path)
-                    rows.push({ path, branch });
-                path = line.slice("worktree ".length).trim();
-                branch = undefined;
-            }
-            else if (line.startsWith("branch ")) {
-                branch = line
-                    .slice("branch ".length)
-                    .trim()
-                    .replace(/^refs\/heads\//u, "");
-            }
-            else if (line === "") {
-                if (path)
-                    rows.push({ path, branch });
-                path = undefined;
-                branch = undefined;
-            }
-        }
-        if (path)
-            rows.push({ path, branch });
-        return rows;
-    }
-    catch {
-        return [{ path: repoRoot }];
-    }
-}
+import { gitHandlers } from "./git-handlers.js";
+import { createFleetHandlers } from "./fleet-handlers.js";
+import { createBlueprintsHandlers } from "./blueprints-handlers.js";
+import { createSessionsHandlers } from "./sessions-handlers.js";
+import { deployHandlers } from "./deploy-handlers.js";
 /**
  * Build the default handler map. Callers may override individual methods via
  * `startDaemonServer({ handlers })` — overrides win.
@@ -80,49 +10,10 @@ function worktreeRows(repoRoot) {
 export function createDefaultProductHandlers(options) {
     const repoRoot = options?.repoRoot ?? process.cwd();
     return {
-        "git.diff": (_session, params) => {
-            const record = asRecord(params);
-            const cwd = requireString(record, "cwd");
-            return gitDiff(cwd);
-        },
-        "git.commit": (_session, params) => {
-            const record = asRecord(params);
-            const cwd = requireString(record, "cwd");
-            const message = requireString(record, "message");
-            const paths = Array.isArray(record.paths)
-                ? record.paths.filter((p) => typeof p === "string")
-                : undefined;
-            return gitCommit(cwd, message, paths);
-        },
-        "git.createPr": () => {
-            throw new Error("git.createPr is not implemented in agent-kit daemon (host policy / gh required)");
-        },
-        "fleet.status": () => {
-            throw new Error("fleet.status is not implemented (no worktree fleet integration; refuse empty success)");
-        },
-        "worktrees.list": (_session, params) => {
-            const record = asRecord(params);
-            const root = typeof record.repoRoot === "string" && record.repoRoot.length > 0
-                ? record.repoRoot
-                : repoRoot;
-            return { worktrees: worktreeRows(root) };
-        },
-        "blueprints.list": () => ({
-            blueprints: listBlueprintRows(repoRoot),
-        }),
-        "blueprints.exec": () => {
-            throw new Error("blueprints.exec is not implemented (exec remains CLI-owned)");
-        },
-        "sessions.list": () => {
-            throw new Error("sessions.list is not implemented (PTY sessions are Tauri-owned; refuse empty success)");
-        },
-        "deploy.run": () => {
-            throw new Error("deploy.run is not implemented (no deploy job ledger; refuse fabricated handles)");
-        },
-        "launch.permissionState": () => ({
-            mode: "safe",
-            yoloPreference: false,
-            isolationWarning: "permission state is advisory until full permission UX lands",
-        }),
+        ...gitHandlers,
+        ...createFleetHandlers(repoRoot),
+        ...createBlueprintsHandlers(repoRoot),
+        ...createSessionsHandlers(repoRoot),
+        ...deployHandlers,
     };
 }

package/dist/esm/daemon/handlers/sessions-handlers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Session/launch-domain product handlers: `sessions.list` reads the real
+ * dash run-registry; `sessions.search` reuses the session-memory FTS index;
+ * `launch.permissionState` returns the advisory permission-state stub.
+ */
+import type { MethodHandler } from "#daemon/rpc.js";
+/**
+ * Build session-domain handlers scoped to `repoRoot`. `repoRoot` doubles as
+ * the dash run-registry cwd (sessions.list) and the session-memory index
+ * root (sessions.search) — both already resolve per-repo paths on their own.
+ */
+export declare function createSessionsHandlers(repoRoot: string): Readonly<Partial<Record<string, MethodHandler>>>;