@webpresso/agent-kit 3.1.28 → 3.2.0

package/dist/esm/cli/commands/dash/tui/state.js

@@ -7,6 +7,7 @@ import { CONTROL_PLANE_HOSTS } from "#cli/commands/dash/tui/hosts.js";
 import { isWizardProvider } from "#cli/commands/dash/session-wizard.js";
 import { browserOverlayLines, createBlueprintBrowser, reduceBlueprintBrowserKey, } from "#cli/commands/dash/tui/browser.js";
 import { filterWorktreePickerItems } from "#cli/commands/dash/worktree-picker.js";
+import { DEFAULT_CONTROL_PLANE_CHAT_MODE, reduceChatModeSwitch, toggleControlPlaneChatMode, } from "#cli/commands/dash/tui/chat-mode.js";
 export function createInitialTuiState(input) {
     const menu = {
         selectedKey: input.agents[0] ? `group:${input.agents[0].key ?? "claude"}` : null,
@@ -16,6 +17,10 @@ export function createInitialTuiState(input) {
         menu: reconcileSelection(menu, input.agents),
         agents: input.agents,
         permissionMode: input.permissionMode,
+        chatMode: input.chatMode ?? DEFAULT_CONTROL_PLANE_CHAT_MODE,
+        chatSession: null,
+        chatDraft: "",
+        chatOpenGeneration: 0,
         overlay: { kind: "none" },
         status: null,
         warnings: [],
@@ -53,7 +58,7 @@ export function reduceTuiKey(state, key) {
     if (state.overlay.kind === "help") {
         if (key.kind === "escape" ||
             (key.kind === "char" && (key.value === "?" || key.value === "q"))) {
-            return { state: { ...state, overlay: { kind: "none" } }, effects: [] };
+            return { state: dismissTransientOverlay(state), effects: [] };
         }
         return { state, effects: [] };
     }
@@ -63,6 +68,10 @@ export function reduceTuiKey(state, key) {
     if (state.overlay.kind === "browser" && state.browser) {
         return reduceBrowserKey(state, key);
     }
+    // Integrated-chat overlay uses browser chrome without blueprint browser state.
+    if (state.overlay.kind === "browser" && !state.browser && state.chatMode === "integrated-chat") {
+        return reduceIntegratedChatKey(state, key);
+    }
     if (state.overlay.kind === "wizard" && state.wizard) {
         return reduceWizardKey(state, key);
     }
@@ -110,6 +119,19 @@ export function reduceTuiKey(state, key) {
             effects: [{ kind: "launch", command: "wp fleet watch", provider: "fleet", newRun: true }],
         };
     }
+    if (key.kind === "char" && key.value === "m") {
+        return {
+            state: {
+                ...state,
+                browser: null,
+                overlay: { kind: "browser", title: "Plan-once merge", lines: ["loading…"] },
+            },
+            effects: [{ kind: "palette-command", id: "merge.status" }],
+        };
+    }
+    if (key.kind === "char" && key.value === "c") {
+        return toggleChatMode(state);
+    }
     if (key.kind === "char" && key.value === "n") {
         const provider = wizardProviderFromSelection(state) ?? "claude";
         const blocked = hostBlockedReason(state, provider);
@@ -269,7 +291,7 @@ function reducePaletteKey(state, key) {
     const { query, cursor } = state.overlay;
     const matches = filterPaletteCommands(query);
     if (key.kind === "escape" || (key.kind === "ctrl" && key.value === "c")) {
-        return { state: { ...state, overlay: { kind: "none" } }, effects: [] };
+        return { state: dismissTransientOverlay(state), effects: [] };
     }
     if (key.kind === "backspace") {
         const nextQuery = query.slice(0, -1);
@@ -310,8 +332,9 @@ function reducePaletteKey(state, key) {
     if (key.kind === "enter") {
         const command = matches[cursor];
         if (!command)
-            return { state: { ...state, overlay: { kind: "none" } }, effects: [] };
-        return applyPaletteCommand({ ...state, overlay: { kind: "none" } }, command.id);
+            return { state: dismissTransientOverlay(state), effects: [] };
+        // Dismiss palette first; integrated-chat restores compose overlay when still active.
+        return applyPaletteCommand(dismissTransientOverlay(state), command.id);
     }
     if (key.kind === "char") {
         const nextQuery = query + key.value;
@@ -433,6 +456,21 @@ export function applyPaletteCommand(state, id) {
             return reduceTuiKey(state, { kind: "char", value: "b" });
         case "fleet.open":
             return reduceTuiKey(state, { kind: "char", value: "f" });
+        case "merge.status":
+            return reduceTuiKey(state, { kind: "char", value: "m" });
+        case "chat.mode.toggle":
+            return toggleChatMode(state);
+        case "chat.mode.open":
+            // Runtime-owned open; pure path only re-emits when already requesting open.
+            return {
+                state,
+                effects: [{ kind: "palette-command", id: "chat.mode.open" }],
+            };
+        case "chat.mode.send":
+            return {
+                state,
+                effects: [{ kind: "palette-command", id: "chat.mode.send" }],
+            };
         case "permission.toggle":
             return reduceTuiKey(state, { kind: "char", value: "d" });
         case "help.open":
@@ -445,6 +483,221 @@ export function applyPaletteCommand(state, id) {
             return { state, effects: [] };
     }
 }
+/**
+ * Toggle host-pane ↔ integrated-chat. Integrated chat requires an ACP-capable
+ * selected host and an existing dash run identity (no second registry).
+ */
+export function toggleChatMode(state) {
+    if (state.chatMode === "integrated-chat") {
+        return leaveIntegratedChat(state);
+    }
+    const host = selectedDashProvider(state);
+    const target = toggleControlPlaneChatMode(state.chatMode);
+    const decision = reduceChatModeSwitch({
+        mode: state.chatMode,
+        target,
+        host,
+    });
+    if (!decision.ok) {
+        // Refused: no persist effect.
+        return { state: { ...state, status: decision.error }, effects: [] };
+    }
+    const run = closeTargetFromState(state);
+    if (!run?.runId) {
+        return {
+            state: {
+                ...state,
+                status: "Select a host session (run) before switching to integrated chat",
+            },
+            effects: [],
+        };
+    }
+    const nextGen = state.chatOpenGeneration + 1;
+    return {
+        state: {
+            ...state,
+            chatMode: "integrated-chat",
+            chatDraft: "",
+            chatOpenGeneration: nextGen,
+            browser: null,
+            wizard: null,
+            status: "mode:integrated-chat (opening…)",
+            overlay: {
+                kind: "browser",
+                title: "Integrated chat",
+                lines: ["opening chat bridge…", "type to compose · ⏎ send · esc → host-pane"],
+            },
+        },
+        // Persist after bridge open succeeds in runtime; open effect only here.
+        effects: [{ kind: "palette-command", id: "chat.mode.open" }],
+    };
+}
+/**
+ * After agents load: if preferred is integrated-chat and gates pass, apply the
+ * normal toggle path once. Never forces integrated-chat chrome without host/run.
+ */
+export function applyPreferredChatModeSeed(state, preferred) {
+    if (preferred === "host-pane") {
+        if (state.chatMode === "host-pane")
+            return { state, effects: [] };
+        return leaveIntegratedChat(state);
+    }
+    // preferred integrated-chat
+    if (state.chatMode === "integrated-chat")
+        return { state, effects: [] };
+    return toggleChatMode(state);
+}
+function leaveIntegratedChat(state) {
+    return {
+        state: {
+            ...state,
+            chatMode: "host-pane",
+            chatSession: null,
+            chatDraft: "",
+            // Bump generation so in-flight open/send cannot re-enter chat mode.
+            chatOpenGeneration: state.chatOpenGeneration + 1,
+            overlay: { kind: "none" },
+            browser: null,
+            status: "mode:host-pane",
+        },
+        effects: [{ kind: "persist-chat-mode", mode: "host-pane" }],
+    };
+}
+function reduceIntegratedChatKey(state, key) {
+    // Escape (or Ctrl+C with empty draft) returns to host-pane. Printable `c` is
+    // a normal composer character so operators can type freely.
+    if (key.kind === "escape") {
+        return leaveIntegratedChat(state);
+    }
+    // Empty draft: pass through menu global chords (?, q, palette, help).
+    if (state.chatDraft.length === 0) {
+        if (key.kind === "ctrl" && (key.value === "p" || key.value === "k")) {
+            return {
+                state: { ...state, overlay: { kind: "palette", query: "", cursor: 0 } },
+                effects: [],
+            };
+        }
+        if (key.kind === "ctrl" && key.value === "x") {
+            return { state: { ...state, overlay: { kind: "help" } }, effects: [] };
+        }
+        if (key.kind === "char" && key.value === "q") {
+            return { state: { ...state, quit: true }, effects: [{ kind: "quit" }] };
+        }
+        if (key.kind === "char" && key.value === "?") {
+            return { state: { ...state, overlay: { kind: "help" } }, effects: [] };
+        }
+    }
+    if (key.kind === "ctrl" && key.value === "c") {
+        if (state.chatDraft.length === 0)
+            return leaveIntegratedChat(state);
+        return {
+            state: withChatOverlay({ ...state, chatDraft: "" }),
+            effects: [],
+        };
+    }
+    if (key.kind === "backspace") {
+        if (state.chatDraft.length === 0)
+            return { state, effects: [] };
+        return {
+            state: withChatOverlay({ ...state, chatDraft: state.chatDraft.slice(0, -1) }),
+            effects: [],
+        };
+    }
+    if (key.kind === "enter") {
+        const text = state.chatDraft.trim();
+        if (!text) {
+            return { state: { ...state, status: "type a message before send" }, effects: [] };
+        }
+        if (!state.chatSession) {
+            return {
+                state: { ...state, status: "chat session not open yet" },
+                effects: [],
+            };
+        }
+        // Keep draft until runtime drains it after send.
+        return {
+            state: {
+                ...withChatOverlay({
+                    ...state,
+                    chatDraft: text,
+                    status: "sending…",
+                }),
+            },
+            effects: [{ kind: "palette-command", id: "chat.mode.send" }],
+        };
+    }
+    if (key.kind === "char") {
+        const nextDraft = state.chatDraft + key.value;
+        return {
+            state: withChatOverlay({ ...state, chatDraft: nextDraft }),
+            effects: [],
+        };
+    }
+    return { state, effects: [] };
+}
+function withChatOverlay(state) {
+    return {
+        ...state,
+        overlay: {
+            kind: "browser",
+            title: "Integrated chat",
+            lines: formatIntegratedChatLines(state),
+        },
+    };
+}
+/** Dismiss help/palette without stranding integrated-chat (restore browser compose overlay). */
+function dismissTransientOverlay(state) {
+    if (state.chatMode === "integrated-chat") {
+        return withChatOverlay(state);
+    }
+    return { ...state, overlay: { kind: "none" } };
+}
+function formatIntegratedChatLines(state) {
+    const session = state.chatSession;
+    const body = session
+        ? [
+            `chat · ${session.host} · run ${session.runId.slice(0, 8)}`,
+            session.label ? `label · ${session.label}` : "label · —",
+            "scope · integrated-chat (⏎ send · esc → host-pane)",
+            "─".repeat(32),
+            ...session.messages.map((msg) => {
+                const tag = msg.role === "user" ? "you" : msg.role === "assistant" ? "host" : "sys";
+                return `${tag} · ${msg.text}`;
+            }),
+        ]
+        : ["opening chat bridge…"];
+    return [...body, "", `compose> ${state.chatDraft}█`];
+}
+function selectedDashProvider(state) {
+    const host = wizardProviderFromSelection(state);
+    return host && isDashProvider(host) ? host : null;
+}
+/** Runtime applies hermetic/real bridge result into state + overlay. */
+export function applyChatBridgeSession(state, session, error, options = {}) {
+    // Stale completion: operator already left or re-entered chat.
+    if (options.expectedGeneration !== undefined &&
+        options.expectedGeneration !== state.chatOpenGeneration) {
+        return state;
+    }
+    if (error || !session) {
+        return {
+            ...state,
+            chatMode: "host-pane",
+            chatSession: null,
+            chatDraft: "",
+            overlay: { kind: "none" },
+            status: error ?? "chat bridge failed",
+        };
+    }
+    const next = {
+        ...state,
+        chatMode: "integrated-chat",
+        chatSession: session,
+        browser: null,
+        status: `mode:integrated-chat · ${session.host}`,
+    };
+    return withChatOverlay(next);
+}
 /** Open the worktree/permission wizard with a real wizard object (not overlay-only). */
 export function openLaunchWizard(state, provider) {
     return {

package/dist/esm/cli/commands/doctor.js

@@ -1,4 +1,5 @@
 import { auditBlueprintLifecycleSql } from "#audit/blueprint-lifecycle-sql";
+import { auditCiGuardrailsWiring } from "#audit/ci-guardrails-wiring";
 import { readConfig } from "#cli/commands/init/config";
 import { auditCatalogDrift, auditDocsFrontmatter, formatRepoAuditReport, } from "#audit/repo-guardrails";
 import { countWorktreeLifecycleScripts } from "#worktrees/lifecycle-scripts.js";
@@ -7,6 +8,9 @@ const REMEDIATIONS = {
     "Catalog drift — single package (no workspace file)": "none needed",
     "Docs frontmatter": "wp audit docs-frontmatter --fix",
     "Blueprint lifecycle": "wp audit blueprint-lifecycle",
+    // Name the missing invocation explicitly so an operator sees which CI step to
+    // restore, not just a generic "drifted" signal.
+    "CI guardrails wiring": "restore the `wp audit guardrails` CI step (run `wp setup`)",
 };
 export async function runDoctor(options = {}) {
     try {
@@ -17,6 +21,7 @@ export async function runDoctor(options = {}) {
                 docsRoot: options.docsRoot,
                 fix: options.fix,
             }),
+            auditCiGuardrailsWiring(root),
             await auditBlueprintLifecycleSql(root, { includeRuntimePlans: options.runtimePlans }),
         ];
         let failed = false;

package/dist/esm/cli/commands/format.js

@@ -19,8 +19,6 @@ const OXFMT_EXTENSIONS = new Set([
     ".json",
     ".md",
     ".mdx",
-    ".sh",
-    ".tmpl",
     ".yaml",
     ".yml",
 ]);

package/dist/esm/cli/commands/hook.d.ts

@@ -1,4 +1,9 @@
 import type { CAC } from "cac";
+/**
+ * Registered GUARD_* codes emitted by the hook-command fail-closed path.
+ * Consumed by the guard-outcome registry-completeness test.
+ */
+export declare const HOOK_FALLBACK_GUARD_CODES: readonly ["GUARD_PRETOOL_FAILURE"];
 declare const HOOK_NAMES: readonly ["pretool-guard", "post-tool", "stop-qa", "stop-ultragoal", "guard-switch", "sessionstart-routing", "precompact-snapshot", "permission-request", "test-quality-check"];
 export type HookName = (typeof HOOK_NAMES)[number];
 export declare function isHookName(value: string): value is HookName;

package/dist/esm/cli/commands/hook.js

@@ -2,8 +2,16 @@ import { performance } from "node:perf_hooks";
 import { reportHookDegradation, takeHookDegradation, } from "#hooks/errors/index.js";
 import { recordHookInvocation, summarizeHookText, takeRememberedHookStdin, } from "#hooks/logs/store.js";
 import { createSyntheticProcessExit, isSyntheticProcessExit, } from "#hooks/shared/synthetic-process-exit.js";
-import { writeHookOutput } from "#hooks/shared/hook-bootstrap";
+import { writeGuardStderr, writeHookOutput } from "#hooks/shared/hook-bootstrap";
+import { formatGuardReason } from "#hooks/shared/guard-outcome.js";
 import { buildDenyEnvelope } from "#hooks/shared/types.js";
+/**
+ * Registered GUARD_* codes emitted by the hook-command fail-closed path.
+ * Consumed by the guard-outcome registry-completeness test.
+ */
+export const HOOK_FALLBACK_GUARD_CODES = [
+    "GUARD_PRETOOL_FAILURE",
+];
 import { resolveHookProjectDirFromText } from "#hooks/shared/project-dir.js";
 import { createManagedHookExecutionContext, } from "#hooks/shared/session-memory-deadline.js";
 const HOOK_NAMES = [
@@ -101,13 +109,9 @@ function exitCodeFrom(value) {
 }
 function writePretoolDeny(reason) {
     writeHookOutput(`${JSON.stringify(buildDenyEnvelope({ reason }))}\n`);
-    // Best-effort stderr reason for Claude/Codex exit-2 UX (may be suppressed in some runners).
-    try {
-        process.stderr.write(`${reason}\n`);
-    }
-    catch {
-        // ignore
-    }
+    // Deliver to the REAL stderr too: Claude reads stderr on an exit-2 PreToolUse
+    // deny, and it is suppressed for decorative output.
+    writeGuardStderr(`${reason}\n`);
 }
 function emitFallback(name, error) {
     const metadata = HOOK_METADATA[name];
@@ -121,7 +125,9 @@ function emitFallback(name, error) {
         detail,
     });
     if (metadata.fallback === "fail-closed-deny") {
-        writePretoolDeny(`webpresso pretool guard failed: ${detail}`);
+        // Coded fail-closed denial so the host still sees a stable GUARD_ code even
+        // when the guard handler itself threw.
+        writePretoolDeny(formatGuardReason("GUARD_PRETOOL_FAILURE", `webpresso pretool guard failed: ${detail}`));
         // Exit 2 so Grok (and exit-code runners) treat fail-closed as an explicit deny.
         return 2;
     }

package/dist/esm/cli/commands/init/config.d.ts

@@ -27,7 +27,6 @@ export interface AgentkitConfig {
         visibility?: Record<string, Record<string, VisibilityStatus>>;
     };
     mcp?: {
-        serverName?: string;
         toolPrefix?: string;
     };
     /** Pretool-guard routing policy. `mechanism` lives in agent-kit; this is the

package/dist/esm/cli/commands/init/config.js

@@ -4,7 +4,7 @@
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, normalize } from "node:path";
-import { REQUIRED_CORE_CAPABILITIES } from "./host-visibility.js";
+import { AGENT_HOSTS, REQUIRED_CORE_CAPABILITIES } from "./host-visibility.js";
 export const CONFIG_VERSION = "1";
 export const CONFIG_FILENAME = ".webpressorc.json";
 export const LEGACY_CONFIG_FILENAME = ".agent-kitrc.json";
@@ -105,11 +105,8 @@ function parseConfigFile(path) {
         const overrides = Array.isArray(rules?.overrides) ? rules.overrides : [];
         const durablePlanningRoot = readOptionalString(parsed.durablePlanningRoot);
         const blueprintsDir = readOptionalString(parsed.blueprintsDir);
-        const serverName = readOptionalString(mcp?.serverName);
         const toolPrefix = readOptionalString(mcp?.toolPrefix);
-        const normalizedMcp = serverName || toolPrefix
-            ? { ...(serverName ? { serverName } : {}), ...(toolPrefix ? { toolPrefix } : {}) }
-            : undefined;
+        const normalizedMcp = toolPrefix ? { toolPrefix } : undefined;
         const guard = parsed.guard;
         const packageManager = guard?.packageManager === "vp-only" ? "vp-only" : undefined;
         const rawScriptRoutes = guard?.scriptRoutes && typeof guard.scriptRoutes === "object"
@@ -139,7 +136,7 @@ function parseConfigFile(path) {
             }
             : undefined;
         const selectedHosts = Array.isArray(hosts?.selected)
-            ? hosts.selected.filter((s) => ["codex", "claude", "opencode"].includes(String(s)))
+            ? hosts.selected.filter((s) => AGENT_HOSTS.includes(String(s)))
             : [];
         const requiredCapabilities = Array.isArray(hosts?.requiredCapabilities)
             ? hosts.requiredCapabilities.filter((s) => typeof s === "string")

package/dist/esm/cli/commands/init/convergence-apply.d.ts

@@ -0,0 +1,24 @@
+import { type ConvergeUnit } from "./convergence.js";
+export { resolveUntrackedCollision } from "./untracked-collision.js";
+export type AuthorCommitStatus = "committed" | "no-change" | "skipped-ci" | "failed" | "rolled-back";
+export interface AuthorCommitResult {
+    readonly status: AuthorCommitStatus;
+    readonly ok: boolean;
+    readonly commit?: string;
+    readonly allowlist: readonly string[];
+    readonly unexpectedPaths?: readonly string[];
+    readonly missingPaths?: readonly string[];
+    readonly error?: string;
+}
+export interface AuthorCommitOptions {
+    readonly repoRoot: string;
+    readonly appliedUnits: readonly ConvergeUnit[];
+    readonly message: string;
+    readonly isCi?: boolean;
+}
+export interface AppliedConvergenceCandidate {
+    readonly targetPath: string;
+    readonly reason: string;
+}
+export declare function collectAppliedConvergeUnits(repoRoot: string, candidates: readonly AppliedConvergenceCandidate[]): ConvergeUnit[];
+export declare function authorConvergenceCommit(options: AuthorCommitOptions): AuthorCommitResult;