@webpresso/agent-kit 3.1.28 → 3.1.30

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/format.js

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

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

@@ -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"

package/dist/esm/cli/commands/init/scaffolders/agent-hooks/emitters/claude.d.ts

@@ -12,12 +12,11 @@ import type { HooksMap, MatcherSet } from "#cli/commands/init/scaffolders/agent-
  * event key. Specs with a `matcher` key reference the corresponding field
  * in the provided MatcherSet.
  *
- * PreToolUse (pretool-guard) is special-cased for spawn reduction:
- * - Non-Bash security tools keep a full always-on group (no `if`).
- * - Bash is emitted as a git-scoped group with `if: Bash(git *)` for git-hot
- *   paths (commit-author / git discipline).
- * - Bash security catch-all without `if` preserves catastrophic command checks
- *   (e.g. `rm -rf`) for non-git Bash (residual: git Bash may hit both groups).
+ * PreToolUse (pretool-guard) keeps the Bash matcher in its own group but emits
+ * exactly one guard entry per tool, so the guard spawns once per call. A prior
+ * git-scoped `if: Bash(git *)` group was removed: its command was byte-identical
+ * to the Bash catch-all, so it added no enforcement, doubled guard spawns on
+ * git commands, and tripped the hook-surface duplicate-managed-hook audit.
  */
 export declare function buildClaudeHookGroups(input: {
     resolveBin: (name: string) => string;

package/dist/esm/cli/commands/init/scaffolders/agent-hooks/emitters/claude.js

@@ -5,7 +5,7 @@
  * Extracted from buildWebpressoHookGroups in index.ts. The function
  * buildWebpressoHookGroups in index.ts now delegates here for backward compat.
  */
-import { CLAUDE_PRETOOL_GIT_IF, WP_HOOK_SPECS, } from "#cli/commands/init/scaffolders/agent-hooks/ir.js";
+import { WP_HOOK_SPECS } from "#cli/commands/init/scaffolders/agent-hooks/ir.js";
 function pushGroup(result, event, group) {
     const existing = result[event] ?? [];
     result[event] = [...existing, group];
@@ -28,12 +28,11 @@ function splitPreToolMatchers(matcher) {
  * event key. Specs with a `matcher` key reference the corresponding field
  * in the provided MatcherSet.
  *
- * PreToolUse (pretool-guard) is special-cased for spawn reduction:
- * - Non-Bash security tools keep a full always-on group (no `if`).
- * - Bash is emitted as a git-scoped group with `if: Bash(git *)` for git-hot
- *   paths (commit-author / git discipline).
- * - Bash security catch-all without `if` preserves catastrophic command checks
- *   (e.g. `rm -rf`) for non-git Bash (residual: git Bash may hit both groups).
+ * PreToolUse (pretool-guard) keeps the Bash matcher in its own group but emits
+ * exactly one guard entry per tool, so the guard spawns once per call. A prior
+ * git-scoped `if: Bash(git *)` group was removed: its command was byte-identical
+ * to the Bash catch-all, so it added no enforcement, doubled guard spawns on
+ * git commands, and tripped the hook-surface duplicate-managed-hook audit.
  */
 export function buildClaudeHookGroups(input) {
     const { resolveBin, matchers } = input;
@@ -54,12 +53,6 @@ export function buildClaudeHookGroups(input) {
                 });
             }
             if (hasBash) {
-                // Git-hot path: only spawn when Bash looks like git (spawn reduction).
-                pushGroup(result, "PreToolUse", {
-                    matcher: "Bash",
-                    hooks: [{ ...baseHook, if: CLAUDE_PRETOOL_GIT_IF }],
-                });
-                // Security catch-all for non-git Bash (catastrophic commands, etc.).
                 pushGroup(result, "PreToolUse", {
                     matcher: "Bash",
                     hooks: [baseHook],

package/dist/esm/cli/commands/init/scaffolders/agent-hooks/ir.d.ts

@@ -22,8 +22,6 @@ export type HookGroup = {
     hooks: HookEntry[];
 };
 export type HooksMap = Record<string, HookGroup[]>;
-/** Claude-only PreToolUse `if` for git-hot Bash paths (commit-author / git discipline). */
-export declare const CLAUDE_PRETOOL_GIT_IF = "Bash(git *)";
 export declare const HOOK_EVENT_NAMES: readonly ["SessionStart", "PreToolUse", "PostToolUse", "PostToolUseFailure", "UserPromptSubmit", "Stop", "PermissionRequest", "SubagentStart", "SubagentStop", "SessionEnd", "PreCompact", "PostCompact"];
 export type HookEventName = (typeof HOOK_EVENT_NAMES)[number];
 export type MatcherSet = {

package/dist/esm/cli/commands/init/scaffolders/agent-hooks/ir.js

@@ -7,8 +7,6 @@
  * output formats.
  */
 import { assertValidHookSpecs } from "./contract.js";
-/** Claude-only PreToolUse `if` for git-hot Bash paths (commit-author / git discipline). */
-export const CLAUDE_PRETOOL_GIT_IF = "Bash(git *)";
 // Known hook event names across the documented Claude/Codex lifecycle. Used by
 // migration/validation paths to identify legacy flat-form keys and by CLI
 // helpers like `wp hooks dispatch` / `wp hooks demo` to accept a wider event

package/dist/esm/cli/commands/init/scaffolders/agent-hooks/merge.d.ts

@@ -6,9 +6,12 @@
  */
 import type { HookGroup, HooksMap } from "./ir.js";
 /**
- * Ensure `group` is present in `groups`. If a group already contains a hook
- * with the same managed identity (command + matcher + if), update its metadata
- * (matcher, timeout, if) but preserve the consumer's materialized command form.
+ * Ensure `group` is present in `groups`. The first hook with the same managed
+ * identity (command target + matcher) is updated to mirror the incoming spec
+ * metadata (matcher, timeout, `if` — dropped when the spec no longer sets it)
+ * while preserving the consumer's materialized command form. Any further hooks
+ * with the same identity are stale spec revisions (e.g. a legacy `if`-gated
+ * duplicate) and are pruned so repair converges to one entry per identity.
  * If no matching hook is found, append the group.
  */
 export declare function ensureGroup(groups: HookGroup[], group: HookGroup): HookGroup[];

package/dist/esm/cli/commands/init/scaffolders/agent-hooks/merge.js

@@ -36,18 +36,16 @@ function commandMatches(left, right) {
     return leftTarget !== null && extractCommandTarget(right) === leftTarget;
 }
 /**
- * Managed hooks can legitimately emit multiple groups that share the same
- * command target but differ by matcher and/or permission-rule `if` (e.g. Claude
- * PreToolUse: non-Bash group + Bash(git *) + Bash catch-all). Identity is
- * (command target, matcher, if) — not command alone.
+ * Managed hooks may emit multiple groups that share the same command target
+ * only when their matchers differ (e.g. Claude PreToolUse: non-Bash group +
+ * Bash group). Identity is (command target, matcher). The permission-rule `if`
+ * is spec-owned metadata, not identity: treating it as identity let a spec
+ * revision that changed `if` strand the old entry as a duplicate that
+ * `wp audit hook-surface` then flagged (duplicate-managed-hook).
  */
 function sameManagedHookIdentity(existingGroup, existingHook, incomingGroup, incomingHook) {
     if (!commandMatches(existingHook.command, incomingHook.command))
         return false;
-    const existingIf = typeof existingHook.if === "string" ? existingHook.if : "";
-    const incomingIf = typeof incomingHook.if === "string" ? incomingHook.if : "";
-    if (existingIf !== incomingIf)
-        return false;
     const existingMatcher = existingGroup.matcher ?? "";
     const incomingMatcher = incomingGroup.matcher ?? "";
     if (existingMatcher === incomingMatcher)
@@ -57,38 +55,53 @@ function sameManagedHookIdentity(existingGroup, existingHook, incomingGroup, inc
     return existingMatcher === "" || incomingMatcher === "";
 }
 /**
- * Ensure `group` is present in `groups`. If a group already contains a hook
- * with the same managed identity (command + matcher + if), update its metadata
- * (matcher, timeout, if) but preserve the consumer's materialized command form.
+ * Ensure `group` is present in `groups`. The first hook with the same managed
+ * identity (command target + matcher) is updated to mirror the incoming spec
+ * metadata (matcher, timeout, `if` — dropped when the spec no longer sets it)
+ * while preserving the consumer's materialized command form. Any further hooks
+ * with the same identity are stale spec revisions (e.g. a legacy `if`-gated
+ * duplicate) and are pruned so repair converges to one entry per identity.
  * If no matching hook is found, append the group.
  */
 export function ensureGroup(groups, group) {
     const incomingHook = group.hooks[0];
     if (!incomingHook)
         return groups;
-    let changed = false;
-    const nextGroups = groups.map((existingGroup) => {
-        const hookIndex = existingGroup.hooks.findIndex((hook) => sameManagedHookIdentity(existingGroup, hook, group, incomingHook));
-        if (hookIndex === -1)
-            return existingGroup;
-        changed = true;
-        const hooks = existingGroup.hooks.map((hook, index) => index === hookIndex
-            ? {
+    let updated = false;
+    const nextGroups = [];
+    for (const existingGroup of groups) {
+        const hooks = [];
+        let matchedHere = false;
+        for (const hook of existingGroup.hooks) {
+            if (!sameManagedHookIdentity(existingGroup, hook, group, incomingHook)) {
+                hooks.push(hook);
+                continue;
+            }
+            if (updated)
+                continue; // stale duplicate of an already-updated identity
+            updated = true;
+            matchedHere = true;
+            const merged = {
                 ...hook,
                 ...incomingHook,
                 // Preserve the consumer's already-materialized command form when
                 // only the matcher/timeout/if changed. Codex command path migration is
                 // handled by normalizeCodexAgentKitCommands before this merge.
                 command: hook.command,
-            }
-            : hook);
-        return {
+            };
+            if (incomingHook.if === undefined)
+                delete merged.if;
+            hooks.push(merged);
+        }
+        if (hooks.length === 0)
+            continue; // group held only stale duplicates
+        nextGroups.push({
             ...existingGroup,
-            ...(group.matcher !== undefined ? { matcher: group.matcher } : {}),
+            ...(matchedHere && group.matcher !== undefined ? { matcher: group.matcher } : {}),
             hooks,
-        };
-    });
-    if (changed)
+        });
+    }
+    if (updated)
         return nextGroups;
     return [...groups, group];
 }