@webpresso/agent-kit 3.3.3 → 3.3.5

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

@@ -1,10 +1,22 @@
 /**
- * Blueprint-domain product handlers: `blueprints.list` is a real
- * implementation over the `blueprints/<status>/` directories; `blueprints.exec`
- * is not implemented (exec remains CLI-owned).
+ * Blueprint-domain product handlers.
+ *
+ * - `blueprints.list` enumerates the `blueprints/<status>/` directories.
+ * - `blueprints.exec` composes an executor launch spec and prepares it as an
+ *   opaque, single-use launch handle. It returns **only** identifiers: no
+ *   command, no argv, no cwd, no env ever crosses to the webview, and this
+ *   module never spawns anything (spawning is Rust-only, through the PTY
+ *   manager, after a rust-credentialed `launch.claim`).
+ * - `blueprints.execBind` is rust-role-only and records the spawned PTY
+ *   session against the job so attribution survives a UI restart.
+ * - `blueprints.execStatus` joins ledger rows with executor-written blueprint
+ *   frontmatter metadata. Status is never parsed out of PTY output — the
+ *   terminal stream is human-viewing only.
  */
 import { readdirSync, existsSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { composeBlueprintExecSpec, readBlueprintExecProgress, } from "#daemon/domains/blueprint-exec.js";
+import { asRecord, requireString } from "./shared.js";
 function listBlueprintRows(repoRoot) {
     const statuses = ["completed", "in-progress", "planned", "parked", "draft", "archived"];
     const rows = [];
@@ -21,16 +33,146 @@ function listBlueprintRows(repoRoot) {
     rows.sort((a, b) => a.slug.localeCompare(b.slug));
     return rows;
 }
+/**
+ * Executor statuses that mean the run is over. Mirrors `executionStatusSchema`
+ * terminal values; a job in one of these retires from the ledger.
+ */
+const TERMINAL_EXECUTION_STATUSES = new Set([
+    "completed",
+    "failed",
+    "stopped",
+]);
+function optionalString(record, key) {
+    const value = record[key];
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string") {
+        throw new Error(`param ${key} must be a string when present`);
+    }
+    return value;
+}
+/**
+ * Params `blueprints.exec` accepts. `requestNonce`/`confirmationToken` belong
+ * to the auth envelope and may still be present on the domain record.
+ *
+ * The protocol contract's strict Zod schema is a declarative helper and is not
+ * applied on the dispatch path, so unknown keys would otherwise be silently
+ * ignored rather than refused. Ignoring is already fail-safe here (the handler
+ * reads only known keys), but refusing is what makes "exec params are data,
+ * not command" an enforced boundary instead of an aspirational one — and it
+ * stops a future edit that naively spreads params from becoming an injection.
+ */
+const EXEC_ALLOWED_PARAM_KEYS = new Set([
+    "slug",
+    "taskId",
+    "confirmationToken",
+    "requestNonce",
+]);
+/** O(#keys) on a bounded record. Never echoes caller-controlled key text. */
+function assertNoSmuggledExecParams(record) {
+    for (const key of Object.keys(record)) {
+        if (!EXEC_ALLOWED_PARAM_KEYS.has(key)) {
+            throw new Error("unexpected param for blueprints.exec: only slug and taskId are accepted " +
+                "(command, args, cwd, and env are composed by the daemon)");
+        }
+    }
+}
+function requireSessionId(record) {
+    const value = record["sessionId"];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error("missing or invalid param: sessionId");
+    }
+    return value;
+}
+function requireExecDeps(deps) {
+    const { launchLedger, execLedger } = deps;
+    if (launchLedger === undefined || execLedger === undefined) {
+        throw new Error("blueprints exec is unavailable: daemon ledgers are not wired");
+    }
+    return { launchLedger, execLedger };
+}
 /**
  * Build blueprint-domain handlers scoped to `repoRoot`.
+ *
+ * The ledgers are created once per daemon (not per connection) and passed in,
+ * because the webview peer registers the job while the rust peer binds the
+ * session — two different connections must observe the same ledger.
  */
-export function createBlueprintsHandlers(repoRoot) {
+export function createBlueprintsHandlers(repoRoot, deps = {}) {
+    const allowlistedRoots = deps.allowlistedRoots !== undefined && deps.allowlistedRoots.length > 0
+        ? deps.allowlistedRoots
+        : [repoRoot];
     return {
         "blueprints.list": () => ({
             blueprints: listBlueprintRows(repoRoot),
         }),
-        "blueprints.exec": () => {
-            throw new Error("blueprints.exec is not implemented (exec remains CLI-owned)");
+        "blueprints.exec": (_session, params) => {
+            const { launchLedger, execLedger } = requireExecDeps(deps);
+            const record = asRecord(params);
+            assertNoSmuggledExecParams(record);
+            const slug = requireString(record, "slug");
+            const taskId = optionalString(record, "taskId");
+            // Validation, path confinement, and daemon-side argv composition.
+            const spec = composeBlueprintExecSpec({
+                slug,
+                taskId,
+                repoRoot,
+                allowlistedRoots,
+            });
+            const { handle } = launchLedger.prepareComposed({
+                command: spec.command,
+                args: spec.args,
+                cwd: spec.cwd,
+                env: spec.env,
+            });
+            const { jobId } = execLedger.register({
+                slug: spec.slug,
+                taskId: spec.taskId,
+                launchHandle: handle,
+            });
+            // Opaque only: the rust-role claim is what yields command/args/env.
+            return { jobId, handle };
+        },
+        "blueprints.execBind": (_session, params) => {
+            const { execLedger } = requireExecDeps(deps);
+            const record = asRecord(params);
+            const jobId = requireString(record, "jobId");
+            const sessionId = requireSessionId(record);
+            const job = execLedger.bindSession(jobId, sessionId);
+            return { jobId: job.jobId, sessionId: job.sessionId, state: job.state };
+        },
+        "blueprints.execStatus": (_session, params) => {
+            const { execLedger } = requireExecDeps(deps);
+            const record = asRecord(params);
+            const slugFilter = optionalString(record, "slug");
+            const jobs = execLedger
+                .list()
+                .filter((job) => slugFilter === null || job.slug === slugFilter)
+                .map((job) => {
+                // Executor-written frontmatter metadata — never PTY bytes.
+                const progress = readBlueprintExecProgress(repoRoot, job.slug);
+                // Drive the terminal transition from the executor's own status.
+                // This is what keeps `markTerminal` (and therefore ledger eviction)
+                // live in production without inventing a push transport: the daemon
+                // has no server-push seam, so the pull that reports status is also
+                // the pull that retires the job.
+                const settled = progress !== null && TERMINAL_EXECUTION_STATUSES.has(progress.status)
+                    ? execLedger.markTerminal(job.jobId)
+                    : null;
+                const state = settled?.state ?? job.state;
+                return {
+                    jobId: job.jobId,
+                    slug: job.slug,
+                    taskId: job.taskId,
+                    sessionId: job.sessionId,
+                    state,
+                    startedAt: job.startedAt,
+                    executionId: progress?.executionId ?? null,
+                    executionStatus: progress?.status ?? null,
+                    executionUpdatedAt: progress?.updatedAt ?? null,
+                };
+            });
+            return { jobs };
         },
     };
 }

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

@@ -5,11 +5,21 @@
  * Domain implementations live in the sibling `*-handlers.ts` files; this
  * module only aggregates them into the map `startDaemonServer` consumes.
  */
+import type { BlueprintExecLedger } from "#daemon/domains/blueprint-exec-ledger.js";
+import type { LaunchLedger } from "#daemon/domains/launch.js";
 import type { MethodHandler } from "#daemon/rpc.js";
 /**
  * Build the default handler map. Callers may override individual methods via
  * `startDaemonServer({ handlers })` — overrides win.
+ *
+ * `launchLedger` / `execLedger` are daemon-scoped (one per server, not one per
+ * connection): blueprint exec registers a job on the webview connection and
+ * binds the PTY session on the rust connection, so both peers must see the
+ * same ledger instances.
  */
 export declare function createDefaultProductHandlers(options?: {
     readonly repoRoot?: string;
+    readonly allowlistedRoots?: readonly string[];
+    readonly launchLedger?: LaunchLedger;
+    readonly execLedger?: BlueprintExecLedger;
 }): Readonly<Partial<Record<string, MethodHandler>>>;

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

@@ -6,13 +6,22 @@ import { deployHandlers } from "./deploy-handlers.js";
 /**
  * Build the default handler map. Callers may override individual methods via
  * `startDaemonServer({ handlers })` — overrides win.
+ *
+ * `launchLedger` / `execLedger` are daemon-scoped (one per server, not one per
+ * connection): blueprint exec registers a job on the webview connection and
+ * binds the PTY session on the rust connection, so both peers must see the
+ * same ledger instances.
  */
 export function createDefaultProductHandlers(options) {
     const repoRoot = options?.repoRoot ?? process.cwd();
     return {
         ...gitHandlers,
         ...createFleetHandlers(repoRoot),
-        ...createBlueprintsHandlers(repoRoot),
+        ...createBlueprintsHandlers(repoRoot, {
+            launchLedger: options?.launchLedger,
+            execLedger: options?.execLedger,
+            allowlistedRoots: options?.allowlistedRoots,
+        }),
         ...createSessionsHandlers(repoRoot),
         ...deployHandlers,
     };

package/dist/esm/daemon/methods.d.ts

@@ -148,6 +148,26 @@ export declare const DAEMON_METHOD_REGISTRY: {
         readonly requireHandshake: true;
         readonly uiFacing: true;
     };
+    /** Read-only exec attribution + executor-written progress. Never PTY-derived. */
+    readonly "blueprints.execStatus": {
+        readonly privileged: true;
+        readonly requiresConfirmation: false;
+        readonly mutates: false;
+        readonly requireHandshake: true;
+        readonly uiFacing: true;
+    };
+    /**
+     * Rust-only: binds the spawned PTY session id to an exec job. Not UI-facing —
+     * the webview must never be able to re-point a job at another session.
+     */
+    readonly "blueprints.execBind": {
+        readonly privileged: true;
+        readonly requiresConfirmation: false;
+        readonly mutates: true;
+        readonly requireHandshake: true;
+        readonly allowedRoles: readonly ["rust"];
+        readonly uiFacing: false;
+    };
     readonly "deploy.run": {
         readonly privileged: true;
         readonly requiresConfirmation: true;
@@ -171,7 +191,7 @@ export type UiRpcMethod = {
     [M in DaemonRpcMethod]: (typeof DAEMON_METHOD_REGISTRY)[M]["uiFacing"] extends true ? M : never;
 }[DaemonRpcMethod];
 export declare const UI_RPC_METHODS: UiRpcMethod[];
-export declare const DESTRUCTIVE_METHODS: ("auth.issueNonce" | "blueprints.exec" | "blueprints.list" | "daemon.envMap.push" | "deploy.run" | "fleet.status" | "git.commit" | "git.createPr" | "git.diff" | "handshake" | "launch.claim" | "launch.permissionState" | "launch.prepare" | "ping" | "sessions.list" | "sessions.search" | "worktrees.list")[];
+export declare const DESTRUCTIVE_METHODS: ("auth.issueNonce" | "blueprints.exec" | "blueprints.execBind" | "blueprints.execStatus" | "blueprints.list" | "daemon.envMap.push" | "deploy.run" | "fleet.status" | "git.commit" | "git.createPr" | "git.diff" | "handshake" | "launch.claim" | "launch.permissionState" | "launch.prepare" | "ping" | "sessions.list" | "sessions.search" | "worktrees.list")[];
 export declare function getMethodCapability(method: string): MethodCapability | null;
 export declare function isDaemonRpcMethod(method: string): method is DaemonRpcMethod;
 export declare function isUiRpcMethod(method: string): method is UiRpcMethod;

package/dist/esm/daemon/methods.js

@@ -116,6 +116,26 @@ export const DAEMON_METHOD_REGISTRY = {
         requireHandshake: true,
         uiFacing: true,
     },
+    /** Read-only exec attribution + executor-written progress. Never PTY-derived. */
+    "blueprints.execStatus": {
+        privileged: true,
+        requiresConfirmation: false,
+        mutates: false,
+        requireHandshake: true,
+        uiFacing: true,
+    },
+    /**
+     * Rust-only: binds the spawned PTY session id to an exec job. Not UI-facing —
+     * the webview must never be able to re-point a job at another session.
+     */
+    "blueprints.execBind": {
+        privileged: true,
+        requiresConfirmation: false,
+        mutates: true,
+        requireHandshake: true,
+        allowedRoles: ["rust"],
+        uiFacing: false,
+    },
     "deploy.run": {
         privileged: true,
         requiresConfirmation: true,

package/dist/esm/daemon/protocol/contract.d.ts

@@ -79,6 +79,8 @@ export type HandshakeResult = z.infer<typeof handshakeResultSchema>;
 export declare const daemonRpcMethodSchema: z.ZodEnum<{
     "auth.issueNonce": "auth.issueNonce";
     "blueprints.exec": "blueprints.exec";
+    "blueprints.execBind": "blueprints.execBind";
+    "blueprints.execStatus": "blueprints.execStatus";
     "blueprints.list": "blueprints.list";
     "daemon.envMap.push": "daemon.envMap.push";
     "deploy.run": "deploy.run";
@@ -98,6 +100,7 @@ export declare const daemonRpcMethodSchema: z.ZodEnum<{
 export declare const uiRpcMethodSchema: z.ZodEnum<{
     "auth.issueNonce": "auth.issueNonce";
     "blueprints.exec": "blueprints.exec";
+    "blueprints.execStatus": "blueprints.execStatus";
     "blueprints.list": "blueprints.list";
     "deploy.run": "deploy.run";
     "fleet.status": "fleet.status";
@@ -303,11 +306,42 @@ export declare const blueprintsListResultSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const blueprintsExecParamsSchema: z.ZodObject<{
     slug: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
     confirmationToken: z.ZodString;
 }, z.core.$strict>;
+/**
+ * Opaque only. `jobId` is the durable exec-attribution key; `handle` is the
+ * single-use launch handle the Rust peer claims. Deliberately carries no
+ * command, args, cwd, or env — those never cross to the webview.
+ */
 export declare const blueprintsExecResultSchema: z.ZodObject<{
+    jobId: z.ZodString;
     handle: z.ZodString;
 }, z.core.$strict>;
+export declare const blueprintsExecStatusParamsSchema: z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Execution status is sourced from executor-written blueprint metadata, never
+ * from PTY output. The terminal stream is human-viewing only.
+ */
+export declare const blueprintsExecStatusResultSchema: z.ZodObject<{
+    jobs: z.ZodArray<z.ZodObject<{
+        jobId: z.ZodString;
+        slug: z.ZodString;
+        taskId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodNumber>;
+        state: z.ZodEnum<{
+            preparing: "preparing";
+            running: "running";
+            terminal: "terminal";
+        }>;
+        startedAt: z.ZodNumber;
+        executionId: z.ZodNullable<z.ZodString>;
+        executionStatus: z.ZodNullable<z.ZodString>;
+        executionUpdatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const deployRunParamsSchema: z.ZodObject<{
     cwd: z.ZodString;
     lane: z.ZodString;
@@ -499,12 +533,36 @@ export declare const UI_METHOD_SCHEMAS: {
     readonly "blueprints.exec": {
         readonly params: z.ZodObject<{
             slug: z.ZodString;
+            taskId: z.ZodOptional<z.ZodString>;
             confirmationToken: z.ZodString;
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
+            jobId: z.ZodString;
             handle: z.ZodString;
         }, z.core.$strict>;
     };
+    readonly "blueprints.execStatus": {
+        readonly params: z.ZodObject<{
+            slug: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            jobs: z.ZodArray<z.ZodObject<{
+                jobId: z.ZodString;
+                slug: z.ZodString;
+                taskId: z.ZodNullable<z.ZodString>;
+                sessionId: z.ZodNullable<z.ZodNumber>;
+                state: z.ZodEnum<{
+                    preparing: "preparing";
+                    running: "running";
+                    terminal: "terminal";
+                }>;
+                startedAt: z.ZodNumber;
+                executionId: z.ZodNullable<z.ZodString>;
+                executionStatus: z.ZodNullable<z.ZodString>;
+                executionUpdatedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    };
     readonly "deploy.run": {
         readonly params: z.ZodObject<{
             cwd: z.ZodString;

package/dist/esm/daemon/protocol/contract.js

@@ -301,14 +301,48 @@ export const blueprintsListResultSchema = z
 export const blueprintsExecParamsSchema = z
     .object({
     slug: z.string().min(1),
+    /** Optional attribution only; never becomes part of the composed argv. */
+    taskId: z.string().min(1).optional(),
     confirmationToken: z.string().min(1),
 })
     .strict();
+/**
+ * Opaque only. `jobId` is the durable exec-attribution key; `handle` is the
+ * single-use launch handle the Rust peer claims. Deliberately carries no
+ * command, args, cwd, or env — those never cross to the webview.
+ */
 export const blueprintsExecResultSchema = z
     .object({
+    jobId: z.string().min(1),
     handle: opaqueHandleSchema,
 })
     .strict();
+export const blueprintsExecStatusParamsSchema = z
+    .object({
+    slug: z.string().min(1).optional(),
+})
+    .strict();
+/**
+ * Execution status is sourced from executor-written blueprint metadata, never
+ * from PTY output. The terminal stream is human-viewing only.
+ */
+export const blueprintsExecStatusResultSchema = z
+    .object({
+    jobs: z.array(z
+        .object({
+        jobId: z.string().min(1),
+        slug: z.string().min(1),
+        taskId: z.string().nullable(),
+        sessionId: z.number().int().nonnegative().nullable(),
+        state: z.enum(["preparing", "running", "terminal"]),
+        startedAt: z.number().int().nonnegative(),
+        executionId: z.string().nullable(),
+        executionStatus: z.string().nullable(),
+        executionUpdatedAt: z.string().nullable(),
+    })
+        .strict()),
+})
+    .strict();
 export const deployRunParamsSchema = z
     .object({
     cwd: z.string().min(1),
@@ -344,6 +378,10 @@ export const UI_METHOD_SCHEMAS = {
     "worktrees.list": { params: worktreesListParamsSchema, result: worktreesListResultSchema },
     "blueprints.list": { params: blueprintsListParamsSchema, result: blueprintsListResultSchema },
     "blueprints.exec": { params: blueprintsExecParamsSchema, result: blueprintsExecResultSchema },
+    "blueprints.execStatus": {
+        params: blueprintsExecStatusParamsSchema,
+        result: blueprintsExecStatusResultSchema,
+    },
     "deploy.run": { params: deployRunParamsSchema, result: deployRunResultSchema },
 };
 // ---------------------------------------------------------------------------

package/dist/esm/daemon/server.js

@@ -10,6 +10,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, sta
 import { createConnection, createServer } from "node:net";
 import { dirname, join } from "node:path";
 import { createDaemonAuthz } from "./authz.js";
+import { createBlueprintExecLedger } from "./domains/blueprint-exec-ledger.js";
 import { createLaunchLedger } from "./domains/launch.js";
 import { createDefaultProductHandlers } from "./handlers/product.js";
 import { getDefaultDaemonSocketPath } from "./paths.js";
@@ -104,6 +105,9 @@ export async function startDaemonServer(options = {}) {
         const server = createServer();
         const connections = new Set();
         const launchLedger = createLaunchLedger();
+        // Daemon-scoped, not per-connection: the webview registers an exec job and
+        // the rust peer binds the PTY session from a different connection.
+        const execLedger = createBlueprintExecLedger();
         server.on("connection", (socket) => {
             connections.add(socket);
             socket.on("close", () => connections.delete(socket));
@@ -137,6 +141,9 @@ export async function startDaemonServer(options = {}) {
                 handlers: {
                     ...createDefaultProductHandlers({
                         repoRoot: options.allowlistedRoots?.[0] ?? process.cwd(),
+                        allowlistedRoots: options.allowlistedRoots,
+                        launchLedger,
+                        execLedger,
                     }),
                     ...options.handlers,
                 },

package/dist/esm/docs-linter/blueprint-plan.js

@@ -1,3 +1,4 @@
+import { extractBlockedReason } from "#markdown/blocked-line";
 /**
  * Blueprint Plan Format Validator
  *
@@ -394,7 +395,6 @@ function validateLifecycleContract(filePath, content) {
     const taskBlocks = extractTaskBlocks(content);
     for (const task of taskBlocks) {
         const statusMatch = task.section.match(/\*\*Status:\*\*\s*(.+)/i);
-        const blockedMatch = task.section.match(/\*\*Blocked:\*\*\s*(.+)/i);
         const checkboxMatches = Array.from(task.section.matchAll(/^- \[([ x])\]/gm));
         const total = checkboxMatches.length;
         const checked = checkboxMatches.filter((match) => match[1] === "x").length;
@@ -407,7 +407,7 @@ function validateLifecycleContract(filePath, content) {
             errors.push(createTaskStatusInvalidError(filePath, task.id, taskStatus));
             continue;
         }
-        const blockedReason = blockedMatch?.[1]?.trim() ?? "";
+        const blockedReason = extractBlockedReason(task.section) ?? "";
         if (taskStatus === "blocked" && !blockedReason) {
             errors.push(createBlockedReasonRequiredError(filePath, task.id));
         }

package/dist/esm/errors/wp-error.js

@@ -11,8 +11,23 @@ export function validateWpErrorDocsUrl(value) {
     return value;
 }
 function redactStringValue(value, explicitSecrets) {
-    let next = redactText(value) ?? value;
-    let redacted = next !== value;
+    // Caller-declared secrets are masked FIRST, against the untouched original
+    // string, and always resolve to the full `[REDACTED]` form. The generic
+    // shared-redactor (`redactText`) runs SECOND, on whatever the explicit pass
+    // left behind.
+    //
+    // The order is load-bearing: `redactText`'s pattern set is broad (see
+    // `_shared/redact.ts`) and grows over time (h-010). A caller-supplied
+    // secret can incidentally match one of those generic shapes (e.g. a value
+    // adjacent to a `TOKEN=`/`SECRET:` key). Running the generic pass first
+    // would replace the literal with a *partial* mask (`CA***23`) before the
+    // explicit pass ever sees it, so `next.includes(secret)` fails silently and
+    // the caller's declared secret ends up under-redacted relative to what the
+    // caller explicitly asked to fully hide. A value the caller names as a
+    // secret is a stronger, more specific signal than a generic pattern match
+    // and must win.
+    let next = value;
+    let redacted = false;
     for (const secret of [...explicitSecrets].sort((left, right) => right.length - left.length)) {
         if (!secret)
             continue;
@@ -21,6 +36,10 @@ function redactStringValue(value, explicitSecrets) {
             redacted = true;
         }
     }
+    const generic = redactText(next) ?? next;
+    if (generic !== next)
+        redacted = true;
+    next = generic;
     return { value: next, redacted };
 }
 function redactUnknownEvidence(value, explicitSecrets) {

package/dist/esm/hooks/doctor.d.ts

@@ -57,6 +57,9 @@ export interface ResolvePackageRootForRuntimeOptions {
 }
 export declare function resolvePackageRootForRuntime(options?: ResolvePackageRootForRuntimeOptions): string | null;
 export declare function findOwningPackageRoot(startDir: string): string | null;
+export declare function checkFreestandingRtkSurface(cwd?: string): DoctorCheck | null;
+/** Non-mutating warn for user-global freestanding RTK rewriters (rtk init -g). */
+export declare function checkGlobalFreestandingRtkSurface(): DoctorCheck | null;
 export declare function checkRtkOnPath(cwd?: string): Promise<DoctorCheck | null>;
 export declare function checkRootLauncherContract(): DoctorCheck;
 export declare function checkRuntimePluginCacheStaleSurfaceRepair(options?: {
@@ -66,6 +69,14 @@ export declare function checkRuntimePluginCacheStaleSurfaceRepair(options?: {
 }): DoctorCheck;
 export declare function checkNativePluginRuntime(): DoctorCheck;
 export declare function checkPhase2RuntimeTypecheckParity(): DoctorCheck;
+/**
+ * Codex must receive `webpresso` over exactly one channel — the bundled Codex
+ * plugin. Report the retired user-global `[mcp_servers.webpresso]` block that
+ * `wp setup` removes, and call out a double registration distinctly. A
+ * user-authored block (a live `wp` outside every agent-kit root) is never
+ * removed by setup, so it gets its own manual-action finding.
+ */
+export declare function classifyLegacyCodexWebpressoChannel(configPath?: string, homeDir?: string): string | null;
 export declare function checkPackagedHostArtifacts(cwd?: string): DoctorCheck;
 export declare function checkHostArtifactOwnership(cwd?: string): DoctorCheck;
 export declare function checkHostLifecycleDepth(): DoctorCheck;