@webpresso/agent-kit 3.1.30 → 3.3.0

package/dist/esm/cli/optional-tool-freshness.d.ts

@@ -15,6 +15,16 @@ export interface OptionalToolFreshnessCache {
     readonly version: 1;
     readonly tools: Partial<Record<ManagedToolName, OptionalToolFreshnessRecord>>;
 }
+export interface OptionalToolRefreshLeaseRecord {
+    readonly pid: number | null;
+    readonly startedAt: number;
+    readonly heartbeatAt: number;
+    readonly expiresAt: number;
+}
+export interface OptionalToolRefreshLeaseCache {
+    readonly version: 1;
+    readonly tools: Partial<Record<ManagedToolName, OptionalToolRefreshLeaseRecord>>;
+}
 export type OptionalToolFreshnessMode = "force" | "if-needed";
 export type OptionalToolFreshnessResult = {
     readonly kind: "missing";
@@ -66,9 +76,22 @@ export interface OptionalToolFreshnessDeps {
     }) => SpawnSyncReturns<string>;
     readonly readCache?: () => OptionalToolFreshnessCache;
     readonly writeCache?: (cache: OptionalToolFreshnessCache) => void;
+    readonly readLeaseCache?: () => OptionalToolRefreshLeaseCache;
+    readonly writeLeaseCache?: (cache: OptionalToolRefreshLeaseCache) => void;
+    readonly clearLease?: (tool: ManagedToolName) => void;
+    readonly spawnDetached?: (command: string, args: readonly string[], options: {
+        readonly cwd: string;
+    }) => {
+        readonly pid?: number | undefined;
+        readonly unref?: () => void;
+    };
 }
 export declare function readOptionalToolFreshnessCache(path?: string): OptionalToolFreshnessCache;
 export declare function writeOptionalToolFreshnessCache(cache: OptionalToolFreshnessCache, path?: string): void;
+export declare function readOptionalToolRefreshLeaseCache(path?: string): OptionalToolRefreshLeaseCache;
+export declare function writeOptionalToolRefreshLeaseCache(cache: OptionalToolRefreshLeaseCache, path?: string): void;
+export declare function clearOptionalToolRefreshLease(tool: ManagedToolName, path?: string): void;
+export declare function optionalToolRefreshLeaseRecord(pid: number | null, now: number): OptionalToolRefreshLeaseRecord;
 export declare function supportsOptionalToolFreshness(adapter: OptionalToolAdapter): boolean;
 /**
  * Resolve a WP-managed optional-tool adapter for a dash provider.
@@ -78,4 +101,8 @@ export declare function tryResolveProviderToolAdapter(provider: DashProvider): O
 export declare function resolveProviderToolAdapter(provider: DashProvider): OptionalToolAdapter;
 export declare function refreshOptionalToolSync(input: OptionalToolFreshnessInput, deps?: OptionalToolFreshnessDeps): OptionalToolFreshnessResult;
 export declare function ensureOptionalToolFreshnessForLaunch(input: Omit<OptionalToolFreshnessInput, "mode">, deps?: OptionalToolFreshnessDeps): Promise<OptionalToolFreshnessResult>;
+export declare function runOptionalToolRefreshWorker(args: readonly string[], deps?: OptionalToolFreshnessDeps & {
+    readonly readOwnershipState?: () => ToolingOwnershipState;
+    readonly resolveVpCommand?: () => GlobalCapableVpCommandInput | null;
+}): number;
 export {};

package/dist/esm/cli/optional-tool-freshness.js

@@ -1,16 +1,19 @@
-import { mkdirSync, existsSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { mkdirSync, existsSync, rmSync } from "node:fs";
 import { dirname } from "node:path";
-import { spawnSync } from "node:child_process";
 import { UPDATE_CHECK_INTERVAL_MS } from "#cli/auto-update/cache.js";
+import { buildSelfInvocationCommand } from "#cli/auto-update/self-invocation.js";
 import { compareVersions } from "#cli/auto-update/version.js";
-import { appendGlobalCapableVpArgs } from "#cli/global-vp.js";
-import { optionalToolCanonicalCommand, resolveOptionalTool, } from "#cli/optional-tools.js";
-import { isUserOwnedTool, } from "#cli/tooling-ownership.js";
+import { appendGlobalCapableVpArgs, resolveGlobalCapableVpCommand, } from "#cli/global-vp.js";
+import { optionalToolCanonicalCommand, OPTIONAL_TOOL_ADAPTERS, resolveOptionalTool, } from "#cli/optional-tools.js";
+import { isUserOwnedTool, readToolingOwnershipState, } from "#cli/tooling-ownership.js";
 import { getSurfacePath, withLock } from "#paths/state-root.js";
 import { readTrustedJsonFile } from "#shared-utils/read-json-file.js";
 import { writeJsonFileAtomic } from "#shared-utils/write-json-file.js";
 const OPTIONAL_TOOL_FRESHNESS_CACHE = "optional-tool-freshness.json";
+const OPTIONAL_TOOL_REFRESH_LEASE = "optional-tool-refresh-lease.json";
 const VERSION_RE = /v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?/u;
+const UNKNOWN_VERSION = "unknown";
 /**
  * Hot-path budget for version probes (`<tool> --version`) and registry
  * latest-version queries (`vp info <pkg>`). These run on the dash/launch turn
@@ -30,9 +33,15 @@ export const OPTIONAL_TOOL_UPDATE_TIMEOUT_MS = 600_000;
 function emptyCache() {
     return { version: 1, tools: {} };
 }
+function emptyLeaseCache() {
+    return { version: 1, tools: {} };
+}
 function cachePath() {
     return getSurfacePath(OPTIONAL_TOOL_FRESHNESS_CACHE, "user");
 }
+function leasePath() {
+    return getSurfacePath(OPTIONAL_TOOL_REFRESH_LEASE, "user");
+}
 export function readOptionalToolFreshnessCache(path = cachePath()) {
     if (!existsSync(path))
         return emptyCache();
@@ -61,6 +70,44 @@ export function writeOptionalToolFreshnessCache(cache, path = cachePath()) {
     mkdirSync(dirname(path), { recursive: true });
     writeJsonFileAtomic(path, cache);
 }
+export function readOptionalToolRefreshLeaseCache(path = leasePath()) {
+    if (!existsSync(path))
+        return emptyLeaseCache();
+    try {
+        const parsed = readTrustedJsonFile(path);
+        if (parsed.version !== 1 || parsed.tools === null || typeof parsed.tools !== "object") {
+            return emptyLeaseCache();
+        }
+        return {
+            version: 1,
+            tools: Object.fromEntries(Object.entries(parsed.tools).filter((entry) => {
+                const record = entry[1];
+                return (record !== undefined &&
+                    (typeof record.pid === "number" || record.pid === null) &&
+                    typeof record.startedAt === "number" &&
+                    typeof record.heartbeatAt === "number" &&
+                    typeof record.expiresAt === "number");
+            })),
+        };
+    }
+    catch {
+        return emptyLeaseCache();
+    }
+}
+export function writeOptionalToolRefreshLeaseCache(cache, path = leasePath()) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeJsonFileAtomic(path, cache);
+}
+export function clearOptionalToolRefreshLease(tool, path = leasePath()) {
+    const cache = readOptionalToolRefreshLeaseCache(path);
+    const tools = { ...cache.tools };
+    delete tools[tool];
+    if (Object.keys(tools).length === 0) {
+        rmSync(path, { force: true });
+        return;
+    }
+    writeOptionalToolRefreshLeaseCache({ version: 1, tools }, path);
+}
 function nextCache(cache, tool, record) {
     return {
         version: 1,
@@ -70,6 +117,15 @@ function nextCache(cache, tool, record) {
         },
     };
 }
+function nextLeaseCache(cache, tool, record) {
+    return {
+        version: 1,
+        tools: {
+            ...cache.tools,
+            [tool]: record,
+        },
+    };
+}
 function readFreshRecord(cache, tool, observedVersion, now) {
     const record = cache.tools[tool];
     if (!record)
@@ -80,6 +136,14 @@ function readFreshRecord(cache, tool, observedVersion, now) {
         return null;
     return record;
 }
+function readFreshLaunchRecord(cache, tool, now) {
+    const record = cache.tools[tool];
+    if (!record)
+        return null;
+    if (now - record.checkedAt > UPDATE_CHECK_INTERVAL_MS)
+        return null;
+    return record;
+}
 function parseVersion(output) {
     const match = VERSION_RE.exec(output.trim());
     return match?.[0] ?? null;
@@ -142,6 +206,72 @@ function persistRecord(deps, adapter, record) {
 function cachedWarnings(record) {
     return record.status === "warning" && record.warning ? [record.warning] : [];
 }
+function launchCacheResult(adapter, record, fromCache) {
+    return {
+        kind: "ready",
+        adapter,
+        observedVersion: record?.observedVersion ?? UNKNOWN_VERSION,
+        latestVersion: record?.latestVersion ?? null,
+        updated: false,
+        warnings: record ? cachedWarnings(record) : [],
+        fromCache,
+    };
+}
+function refreshLeaseIsActive(record, now) {
+    return record !== undefined && record.expiresAt > now;
+}
+export function optionalToolRefreshLeaseRecord(pid, now) {
+    return {
+        pid,
+        startedAt: now,
+        heartbeatAt: now,
+        // The worker may run a real package update with the foreground update
+        // deadline, so the launch lease must cover that blocking child.
+        expiresAt: now + OPTIONAL_TOOL_UPDATE_TIMEOUT_MS + 60_000,
+    };
+}
+function defaultSpawnDetached(command, args, options) {
+    const child = spawn(command, [...args], {
+        cwd: options.cwd,
+        detached: true,
+        env: process.env,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+    return child;
+}
+function spawnOptionalToolRefreshWorker(input, deps, now) {
+    const readLease = deps.readLeaseCache ?? readOptionalToolRefreshLeaseCache;
+    const writeLease = deps.writeLeaseCache ?? writeOptionalToolRefreshLeaseCache;
+    const clearLease = deps.clearLease ?? clearOptionalToolRefreshLease;
+    const lease = readLease();
+    if (refreshLeaseIsActive(lease.tools[input.adapter.id], now))
+        return;
+    const command = buildSelfInvocationCommand([
+        "optional-tool-refresh",
+        input.adapter.id,
+        "--cwd",
+        input.cwd,
+    ]);
+    try {
+        writeLease(nextLeaseCache(lease, input.adapter.id, optionalToolRefreshLeaseRecord(null, now)));
+        const child = (deps.spawnDetached ?? defaultSpawnDetached)(command[0], command.slice(1), {
+            cwd: input.cwd,
+        });
+        child.unref?.();
+    }
+    catch (error) {
+        clearLease(input.adapter.id);
+        persistRecord(deps, input.adapter, {
+            checkedAt: now,
+            observedVersion: UNKNOWN_VERSION,
+            latestVersion: null,
+            status: "warning",
+            warning: `${input.adapter.ownershipName} optional refresh could not start; launching without freshness proof.${error instanceof Error ? ` ${error.message}.` : ""}`,
+        });
+    }
+}
 export function supportsOptionalToolFreshness(adapter) {
     return adapter.namespace === "base" && Boolean(adapter.packageName && adapter.executableName);
 }
@@ -312,8 +442,88 @@ export function refreshOptionalToolSync(input, deps = {}) {
     };
 }
 export async function ensureOptionalToolFreshnessForLaunch(input, deps = {}) {
-    return withLock("user", () => refreshOptionalToolSync({
-        ...input,
-        mode: "if-needed",
-    }, deps));
+    if (!isUserOwnedTool(input.ownershipState, input.adapter.id)) {
+        return {
+            kind: "unmanaged",
+            adapter: input.adapter,
+            observedVersion: UNKNOWN_VERSION,
+            warning: `${input.adapter.ownershipName} is installed but not WP-owned. Run \`${optionalToolCanonicalCommand(input.adapter)}\` to let WP keep it current.`,
+        };
+    }
+    return withLock("user", () => {
+        const now = deps.now?.() ?? Date.now();
+        const readCache = deps.readCache ?? readOptionalToolFreshnessCache;
+        const cache = readCache();
+        const fresh = readFreshLaunchRecord(cache, input.adapter.id, now);
+        if (fresh)
+            return launchCacheResult(input.adapter, fresh, true);
+        const stale = cache.tools[input.adapter.id] ?? null;
+        spawnOptionalToolRefreshWorker(input, deps, now);
+        return launchCacheResult(input.adapter, stale, stale !== null);
+    });
+}
+export function runOptionalToolRefreshWorker(args, deps = {}) {
+    const [tool, ...rest] = args;
+    const adapter = OPTIONAL_TOOL_ADAPTERS.find((candidate) => candidate.id === tool);
+    if (!adapter || !supportsOptionalToolFreshness(adapter)) {
+        console.error(`optional-tool-refresh: unsupported tool ${tool ?? "<missing>"}`);
+        return 2;
+    }
+    let cwd = process.cwd();
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        if (arg === "--cwd") {
+            const value = rest[index + 1];
+            if (!value) {
+                console.error("optional-tool-refresh: --cwd requires a value");
+                return 2;
+            }
+            cwd = value;
+            index += 1;
+            continue;
+        }
+        console.error(`optional-tool-refresh: unsupported argument ${arg}`);
+        return 2;
+    }
+    const now = deps.now?.() ?? Date.now();
+    const writeLease = deps.writeLeaseCache ?? writeOptionalToolRefreshLeaseCache;
+    const readLease = deps.readLeaseCache ?? readOptionalToolRefreshLeaseCache;
+    const clearLease = deps.clearLease ?? clearOptionalToolRefreshLease;
+    writeLease(nextLeaseCache(readLease(), adapter.id, optionalToolRefreshLeaseRecord(typeof process.pid === "number" ? process.pid : null, now)));
+    try {
+        const vpCommand = deps.resolveVpCommand !== undefined
+            ? deps.resolveVpCommand()
+            : resolveGlobalCapableVpCommand();
+        if (!vpCommand) {
+            persistRecord(deps, adapter, {
+                checkedAt: now,
+                observedVersion: UNKNOWN_VERSION,
+                latestVersion: null,
+                status: "warning",
+                warning: `${adapter.ownershipName} optional refresh skipped because no global-capable Vite+ runner was found.`,
+            });
+            return 0;
+        }
+        const result = refreshOptionalToolSync({
+            adapter,
+            mode: "if-needed",
+            ownershipState: deps.readOwnershipState?.() ?? readToolingOwnershipState(),
+            vpCommand,
+            cwd,
+        }, deps);
+        if (result.kind === "missing") {
+            persistRecord(deps, adapter, {
+                checkedAt: now,
+                observedVersion: UNKNOWN_VERSION,
+                latestVersion: null,
+                status: "warning",
+                warning: result.warning,
+            });
+            return 0;
+        }
+        return 0;
+    }
+    finally {
+        clearLease(adapter.id);
+    }
 }

package/dist/esm/daemon/domains/git-actions.d.ts

@@ -1,7 +1,16 @@
 /**
  * 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 { type RunOutcome } from "#mcp/tools/_shared/run-command.js";
 export type DiffFile = {
     readonly path: string;
     readonly status: string;
@@ -16,3 +25,23 @@ export declare function gitCommit(cwd: string, message: string, paths?: readonly
 }): {
     readonly commitSha: string;
 };
+export type CreatePrResult = {
+    readonly url: string;
+    readonly number?: number;
+};
+export interface GitCreatePrDeps {
+    /** Resolve the current branch name; throws on detached HEAD. Injectable for tests. */
+    readonly currentBranch?: (cwd: string) => string;
+    /** Invoke `gh` with args in `cwd`. Injectable for tests (no real `gh` binary required). */
+    readonly gh?: (args: readonly string[], cwd: string) => Promise<RunOutcome>;
+}
+/**
+ * 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 declare function gitCreatePr(cwd: string, title: string, body: string | undefined, deps?: GitCreatePrDeps): Promise<CreatePrResult>;

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>>>;