@webpresso/agent-kit 3.3.2 → 3.3.4

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/git/changed-files.d.ts

@@ -5,6 +5,26 @@ export interface ChangedFilesResult {
     readonly reason: ChangedFilesReason;
 }
 export declare function defaultBranchBaseRef(env?: NodeJS.ProcessEnv): string;
+/**
+ * Latest fork point of `HEAD` from the base branch, given a caller-supplied base.
+ *
+ * CI passes `--base "$PR_BASE_SHA"` (`github.event.pull_request.base.sha`),
+ * which is pinned when the pull request is opened and does NOT advance as the
+ * base branch does. Once the branch is rebased onto a newer base — the
+ * documented recovery flow for a stale branch — that pinned SHA is no longer the
+ * fork point, so `<pinned>...HEAD` reports every commit merged into the base
+ * branch since the PR opened as if this branch had authored it. Scoped gates
+ * then fail a branch for unrelated, already-merged work.
+ *
+ * `git merge-base` against the LIVE base branch ref is recomputed from current
+ * history, so it tracks the rebase and yields the true fork point. Prefer it,
+ * but only when it is provably a descendant of the caller's base (never widen
+ * the range the caller asked for) and does not swallow `HEAD` (a base branch
+ * that already contains `HEAD` would otherwise empty the scope). Otherwise the
+ * caller's base is returned verbatim, so an unrelated or unresolvable live ref
+ * can never silently replace an explicit base.
+ */
+export declare function resolveBranchDiffBase(cwd?: string, base?: string, liveBaseRef?: string): string;
 export declare function getGitTopLevel(cwd?: string): string | null;
 export declare function getStagedFiles(cwd?: string): ChangedFilesResult;
 export declare function getBranchChangedFiles(cwd?: string, base?: string): ChangedFilesResult;

package/dist/esm/git/changed-files.js

@@ -5,6 +5,69 @@ export function defaultBranchBaseRef(env = process.env) {
     const githubBaseRef = env.GITHUB_BASE_REF?.trim();
     return `origin/${githubBaseRef && githubBaseRef.length > 0 ? githubBaseRef : "main"}`;
 }
+/**
+ * Latest fork point of `HEAD` from the base branch, given a caller-supplied base.
+ *
+ * CI passes `--base "$PR_BASE_SHA"` (`github.event.pull_request.base.sha`),
+ * which is pinned when the pull request is opened and does NOT advance as the
+ * base branch does. Once the branch is rebased onto a newer base — the
+ * documented recovery flow for a stale branch — that pinned SHA is no longer the
+ * fork point, so `<pinned>...HEAD` reports every commit merged into the base
+ * branch since the PR opened as if this branch had authored it. Scoped gates
+ * then fail a branch for unrelated, already-merged work.
+ *
+ * `git merge-base` against the LIVE base branch ref is recomputed from current
+ * history, so it tracks the rebase and yields the true fork point. Prefer it,
+ * but only when it is provably a descendant of the caller's base (never widen
+ * the range the caller asked for) and does not swallow `HEAD` (a base branch
+ * that already contains `HEAD` would otherwise empty the scope). Otherwise the
+ * caller's base is returned verbatim, so an unrelated or unresolvable live ref
+ * can never silently replace an explicit base.
+ */
+export function resolveBranchDiffBase(cwd = process.cwd(), base = defaultBranchBaseRef(), liveBaseRef = defaultBranchBaseRef()) {
+    const forkPoint = readMergeBase(cwd, liveBaseRef, "HEAD");
+    if (forkPoint === null || forkPoint === readCommit(cwd, "HEAD"))
+        return base;
+    return isAncestorCommit(cwd, base, forkPoint) ? forkPoint : base;
+}
+function readCommit(cwd, ref) {
+    try {
+        const output = execFileSync("git", ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return output.length > 0 ? output : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readMergeBase(cwd, left, right) {
+    try {
+        const output = execFileSync("git", ["merge-base", left, right], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return output.length > 0 ? output : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAncestorCommit(cwd, ancestor, descendant) {
+    try {
+        execFileSync("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+            cwd,
+            stdio: ["ignore", "ignore", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function getGitTopLevel(cwd = process.cwd()) {
     try {
         const output = execFileSync("git", ["rev-parse", "--show-toplevel"], {

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;