pi-midcompact 0.5.0 → 0.5.2

package/README.md

@@ -29,7 +29,7 @@ That is planning guidance, not an enforced token target: semantic importance win
 
 ### A selective projection, prepared on a temporary branch
 
-`/midcompact start` freezes the current session leaf as an **anchor**. Planning happens on a disposable child branch, so the discussion used to create and edit the draft never becomes part of the committed working context.
+`/midcompact:start` freezes the current session leaf as an **anchor**. Planning happens on a disposable child branch, so the discussion used to create and edit the draft never becomes part of the committed working context.
 
 ```text
 Frozen anchor: raw session history
@@ -42,7 +42,7 @@ Planning is isolated on a temporary branch:
   ... [latest work] ──┬── [transaction] ── [draft v1] ── [draft v2]  ◀ review / edit
                       │                    (abandoned at commit)
                       └── [midcompact-state]                         ◀ committed leaf
-                            (reviewed selection metadata, not a model message; written only by /midcompact commit)
+                            (reviewed selection metadata, not a model message; written only by /midcompact:commit)
 
 Later model requests see a selective projection:
 
@@ -91,10 +91,10 @@ pi-midcompact — mid-context compression, review, then human commit
 
 | | Pi `/compact` | `pi-midcompact` |
 | --- | --- | --- |
-| Starts | Automatically near the context limit, or with `/compact` | At an explicit natural checkpoint with `/midcompact start` |
+| Starts | Automatically near the context limit, or with `/compact` | At an explicit natural checkpoint with `/midcompact:start` |
 | Selects | One older contiguous prefix; keeps a recent token-budgeted tail | One or more reviewed ranges, including non-contiguous ranges and `KEEP` holes |
 | Planning | Optional one-shot instruction to focus the generated summary | User states scope and retention depth; the Agent discusses trade-offs and drafts selective ranges and summaries |
-| Decision gate | Generates a compaction checkpoint directly | Draft → TUI or browser review → explicit human `/midcompact commit` |
+| Decision gate | Generates a compaction checkpoint directly | Draft → TUI or browser review → explicit human `/midcompact:commit` |
 | Best fit | Automatic context maintenance and overflow recovery | Deliberate cleanup of completed phases while retaining specific decisions verbatim |
 
 `pi-midcompact` does not disable or replace Pi's automatic compaction; it gives you a separate, human-reviewed way to make selective reductions. See [Pi's compaction documentation](https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/docs/compaction.md) for the built-in mechanism.
@@ -124,13 +124,13 @@ Start a transaction at a natural breakpoint: the current work is complete enough
 Run:
 
 ```text
-/midcompact start
+/midcompact:start
 ```
 
-Pi opens a three-way chooser before creating transaction state: **Drop**, **Agent direct**, or **User manual**. Agent direct starts the existing inventory-first Agent workflow. User manual sends the same transaction guidance with a final “acknowledge only” instruction; after the Agent replies briefly, the Selection workbench opens. It does not start planning or mutate the DraftPlan until the user hands off later. Save the initial DraftPlan, close the UI, then tell the Agent to continue when you are ready. You can include an initial focus in the same command:
+Pi opens a three-way chooser before creating transaction state: **Agent direct**, **User manual**, or **Drop**. Agent direct is the first and default-highlighted option, matching the previous fast path. The chooser is the standard `select` dialog, identical in interactive and RPC mode; RPC carries it as an extension UI `select` message with a bounded timeout, so an unresponsive client cancels instead of blocking. print/JSON modes have no dialog and default to **Agent direct**. Agent direct starts the existing inventory-first Agent workflow. User manual sends the same transaction guidance with a final “acknowledge only” instruction; after the Agent replies briefly, the Selection workbench opens (browser-based outside interactive mode). It does not start planning or mutate the DraftPlan until the user hands off later. Save the initial DraftPlan, close the UI, then tell the Agent to continue when you are ready. You can include an initial focus in the same command:
 
 ```text
-/midcompact start Compress the early repository exploration, but keep user requirements verbatim.
+/midcompact:start Compress the early repository exploration, but keep user requirements verbatim.
 ```
 
 ### 2. Discuss what to compress with the Agent
@@ -150,7 +150,7 @@ The Agent locates relevant parts of the frozen conversation, proposes one or mor
 Run:
 
 ```text
-/midcompact review
+/midcompact:review
 ```
 
 In interactive mode, the native TUI displays the frozen conversation as a linear timeline. Each item is marked either `KEEP` or as belonging to a proposed range. Review the range boundaries and the summary that will replace each range.
@@ -158,14 +158,14 @@ In interactive mode, the native TUI displays the frozen conversation as a linear
 For RPC, print, or other no-TUI modes, use the editable local browser interface instead:
 
 ```text
-/midcompact review-webui
+/midcompact:review-webui
 ```
 
 Use Selection to create or change ranges and KEEP holes:
 
 ```text
-/midcompact select
-/midcompact select-webui
+/midcompact:select
+/midcompact:select-webui
 ```
 
 Use the TUI or local browser Review surface to edit summaries/topics and reject ranges. Review deliberately does not create or resize ranges; reopen Selection for boundary changes. To continue with Agent after a user-created plan, send a normal message asking it to continue the current midcompact draft; the Agent is prompted to read the existing plan first.
@@ -175,7 +175,7 @@ Use the TUI or local browser Review surface to edit summaries/topics and reject
 When the plan is correct, run:
 
 ```text
-/midcompact commit
+/midcompact:commit
 ```
 
 This is deliberately a human command. The Agent cannot commit compression itself.
@@ -187,14 +187,14 @@ Pi returns to the anchor, discards the temporary planning branch, stores the rev
 Keep working normally after committing. If you decide not to compress, run:
 
 ```text
-/midcompact abort
+/midcompact:abort
 ```
 
 This returns to the anchor and discards the transaction without changing the active context.
 
 ## Native TUI Controls
 
-Inside `/midcompact review`:
+Inside `/midcompact:review`:
 
 ```text
 n/p or Left/Right  select a proposed range
@@ -211,14 +211,14 @@ Enter/Esc/q        close
 
 | Command | Result |
 | --- | --- |
-| `/midcompact start [instructions]` | Opens Drop / Agent direct / User manual, then starts a transaction at the current session-tree leaf. |
-| `/midcompact select` | Opens the native TUI Selection workbench for range and KEEP editing. |
-| `/midcompact select-webui` | Opens the local browser Selection workbench. |
-| `/midcompact review` | Opens summary/topic review in the native TUI. |
-| `/midcompact review-webui` | Opens summary/topic review in a local browser. |
-| `/midcompact commit` | Commits the reviewed draft. Human only. |
-| `/midcompact abort` | Abandons the transaction and returns to the anchor. |
-| `/midcompact status` | Displays the current draft, or the committed compression state on this branch. |
+| `/midcompact:start [instructions]` | Opens Agent direct / User manual / Drop, then starts a transaction at the current session-tree leaf. |
+| `/midcompact:select` | Opens the native TUI Selection workbench for range and KEEP editing. |
+| `/midcompact:select-webui` | Opens the local browser Selection workbench. |
+| `/midcompact:review` | Opens summary/topic review in the native TUI. |
+| `/midcompact:review-webui` | Opens summary/topic review in a local browser. |
+| `/midcompact:commit` | Commits the reviewed draft. Human only. |
+| `/midcompact:abort` | Abandons the transaction and returns to the anchor. |
+| `/midcompact:status` | Displays the current draft, or the committed compression state on this branch. |
 
 The extension shows planning status in Pi's footer only while a transaction is active. It disappears after commit or abort.
 
@@ -227,7 +227,7 @@ The extension shows planning status in Pi's footer only while a transaction is a
 - **Original history is retained.** Compression changes what later model requests see, not the stored Pi messages.
 - **Fail-open projection.** If an exact reviewed sequence no longer resolves, the extension sends the raw history unchanged rather than removing uncertain content.
 - **State is branch-local.** Navigating with `/tree` to a point before a committed state restores raw history; returning to its descendant restores the projection.
-- **Human review is required.** The Agent can propose a plan but cannot execute `/midcompact commit`.
+- **Human review is required.** The Agent can propose a plan but cannot execute `/midcompact:commit`.
 - **Tool protocol is protected.** Unknown, incomplete, or orphaned tool exchanges are not compressible.
 - **Repeated transactions work.** Later transactions can compress newly accumulated raw context; existing summaries remain protected.
 - **Native Pi `/compact` interaction needs more real-session validation.** Avoid relying on mixed automatic/native compaction behavior for critical work until it has been exercised in your environment.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-midcompact",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Branch-aware mid-context compression for the Pi coding agent",
   "author": "frostime",
   "repository": {

package/skills/midcompact/SKILL.md

@@ -18,9 +18,11 @@ This skill handles two independent tasks: planning compression and recalling com
 
 The state-specific runtime prompt is authoritative. Recall does not enter planning or mutate the DraftPlan. During the User-manual acknowledgement turn, the no-tool instruction overrides every other route.
 
+The tool groups parameters by `action`: each action accepts only its own fields, and fields from other actions are rejected. Read `references/tool-interface.md` before adding workload-specific parameters, and treat the action-specific field lists there as exhaustive.
+
 ## Plan compression
 
-Selected ranges become summaries in future model context; content outside them stays verbatim. Originals remain stored, but recall is a recovery path, not a substitute for a sufficient summary. Agent and user edit one DraftPlan; the user retains final control through review and `/midcompact commit`.
+Selected ranges become summaries in future model context; content outside them stays verbatim. Originals remain stored, but recall is a recovery path, not a substitute for a sufficient summary. Agent and user edit one DraftPlan; the user retains final control through review and `/midcompact:commit`.
 
 The start mode controls how the first draft is created. It does not determine whether a user selection is final, how much initiative the Agent should take, or how deeply the history should be investigated.
 
@@ -107,7 +109,7 @@ Length follows the information that must survive, not a target ratio. Final test
 
 Call `action="plan", op="show"`. Check that the intended semantic phases are covered, KEEP holes remain outside ranges, every range has a summary, and the summaries conserve the future working state.
 
-Describe the completed proposal with the same recognizable landmarks used during alignment. Direct the user to `/midcompact select` or `/midcompact select-webui` for boundaries and KEEP holes, and to `/midcompact review` or `/midcompact review-webui` for summary inspection or rejection. Use browser variants when the TUI is unavailable or preferred. Ask the user to run `/midcompact commit` when ready; never commit for them.
+Describe the completed proposal with the same recognizable landmarks used during alignment. Direct the user to `/midcompact:select` or `/midcompact:select-webui` for boundaries and KEEP holes, and to `/midcompact:review` or `/midcompact:review-webui` for summary inspection or rejection. Use browser variants when the TUI is unavailable or preferred. Ask the user to run `/midcompact:commit` when ready; never commit for them.
 
 ## Recall compressed content
 

package/skills/midcompact/references/tool-interface.md

@@ -2,6 +2,10 @@
 
 Read this reference when exact call requirements, limits, rejection behavior, repeated compression, or recall truncation matters. The main workflow remains in `../SKILL.md`.
 
+## Parameter grouping
+
+The tool schema is a discriminated union on `action`: selecting an action admits exactly the fields documented in that action's section, and no fields from other actions. A call that mixes actions (for example `locate` fields on `plan`) is invalid; do not repair it by dropping fields, re-issue the call with only the selected action's parameters. Shared field names (`ref`, `pattern`, `limit`, `detail`) are defined independently per action with the meaning documented in that section.
+
 ## Inspect
 
 Without `spans`, `action="inspect"` inventories the frozen anchor. It returns factual structure and bounded user landmarks, not full message bodies, assistant/tool previews, summaries, or image base64.

package/src/index.ts

@@ -6,8 +6,6 @@ import {
   type ExtensionContext,
   type SessionEntry,
 } from "@earendil-works/pi-coding-agent";
-import type { AutocompleteItem } from "@earendil-works/pi-tui";
-
 import { buildAtoms, formatLocatedAtom, isProtectedAtom, locateAtomMatches } from "./atoms.js";
 import { buildInventory, formatInventory, formatSpanInspection } from "./inventory.js";
 import { messageText } from "./messages.js";
@@ -17,8 +15,20 @@ import { projectMessages } from "./projection.js";
 import { registerStateRenderer, stateTreeLabel } from "./renderers.js";
 import { showReviewUi } from "./review-ui.js";
 import { showSelectionUi } from "./selection-ui.js";
-import { showStartChoiceUi } from "./start-ui.js";
+import { showStartChoice } from "./start-ui.js";
 import { showReviewWebUi } from "./review-webui.js";
+
+/**
+ * Browser opener for the web workbenches. Tests override it to keep the suites
+ * from spawning a system browser; production leaves it undefined and opens the
+ * default browser.
+ */
+export let openReviewWebBrowser: ((url: string) => void) | undefined;
+
+/** Test seam setter; see `openReviewWebBrowser`. */
+export function setOpenReviewWebBrowser(opener?: (url: string) => void): void {
+  openReviewWebBrowser = opener;
+}
 import {
   DRAFT_ENTRY,
   STATE_ENTRY,
@@ -57,8 +67,20 @@ const TOOL_DESCRIPTION =
 const STATUS_KEY = "midcompact";
 const START_PROMPT_PREFIX = "A mid-compaction transaction is active on a frozen anchor snapshot.";
 
-const Params = Type.Object({
-  action: StringEnum(["inspect", "locate", "plan", "recall"] as const),
+// The tool is a discriminated union: `action` selects the only parameter
+// group that applies. The schema exposes just that group's fields, so a call
+// cannot mix parameters from different actions, and cross-action misuse
+// becomes a compile-time error in the handler types rather than a runtime rule.
+const InspectParams = Type.Object({
+  action: Type.Literal("inspect"),
+  // inventory pagination or explicit candidate-span measurement
+  spans: Type.Optional(Type.Array(Type.Object({ start: Type.String(), end: Type.String() }))),
+  page_size: Type.Optional(Type.Number()),
+  cursor: Type.Optional(Type.String()),
+});
+
+const LocateParams = Type.Object({
+  action: Type.Literal("locate"),
   ref: Type.Optional(Type.String()),
   pattern: Type.Optional(Type.String()),
   source: Type.Optional(StringEnum(["any", "user", "assistant", "tool_call", "tool_result"] as const)),
@@ -66,19 +88,34 @@ const Params = Type.Object({
   direction: Type.Optional(StringEnum(["oldest", "newest"] as const)),
   limit: Type.Optional(Type.Number()),
   detail: Type.Optional(StringEnum(["brief", "full"] as const)),
+});
+
+const PlanParams = Type.Object({
+  action: Type.Literal("plan"),
   op: Type.Optional(StringEnum(["show", "add", "update", "remove"] as const)),
   start: Type.Optional(Type.String()),
   end: Type.Optional(Type.String()),
   draft_id: Type.Optional(Type.String()),
   topic: Type.Optional(Type.String()),
   summary: Type.Optional(Type.String()),
-  // inspect inventory pagination or explicit candidate-span measurement
-  page_size: Type.Optional(Type.Number()),
-  cursor: Type.Optional(Type.String()),
-  spans: Type.Optional(Type.Array(Type.Object({ start: Type.String(), end: Type.String() }))),
+  detail: Type.Optional(StringEnum(["brief", "full"] as const)),
 });
 
+const RecallParams = Type.Object({
+  action: Type.Literal("recall"),
+  ref: Type.Optional(Type.String()),
+  pattern: Type.Optional(Type.String()),
+  limit: Type.Optional(Type.Number()),
+  detail: Type.Optional(StringEnum(["brief", "full"] as const)),
+});
+
+const Params = Type.Union([InspectParams, LocateParams, PlanParams, RecallParams]);
+
 type ParamsType = Static<typeof Params>;
+type InspectParamsType = Static<typeof InspectParams>;
+type LocateParamsType = Static<typeof LocateParams>;
+type PlanParamsType = Static<typeof PlanParams>;
+type RecallParamsType = Static<typeof RecallParams>;
 
 type RuntimeSnapshot = { atoms: Atom[]; anchorState?: CompressionState };
 
@@ -160,48 +197,63 @@ export default function (pi: ExtensionAPI) {
     return { messages: projectMessages(event.messages as MessageLike[], activeState) as typeof event.messages };
   });
 
-  pi.registerCommand("midcompact", {
-    description: "Start, select, review, commit, inspect, or abort a branch-isolated mid-context compression transaction",
-    getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
-      const query = prefix.trimStart().toLowerCase();
-      if (/\s/.test(query)) return null;
-      const items: AutocompleteItem[] = [
-        { value: "start", label: "start — Start a new midcompact transaction at the current anchor" },
-        { value: "abort", label: "abort — Abort the active transaction and return to anchor" },
-        { value: "commit", label: "commit — Commit the current draft to the branch state" },
-        { value: "review", label: "review — Open interactive TUI to inspect and edit the draft" },
-        { value: "review-webui", label: "review-webui — Open a local web page to inspect and edit the draft (works without TUI)" },
-        { value: "select", label: "select — Open the TUI Selection surface to edit range boundaries" },
-        { value: "select-webui", label: "select-webui — Open Selection in a local browser" },
-        { value: "status", label: "status — Show current transaction and draft status" },
-      ];
-      const filtered = items.filter((item) => item.value.startsWith(query));
-      return filtered.length > 0 ? filtered : null;
-    },
+  // One command per operation; the `midcompact:` prefix follows the same
+  // naming convention as Pi's own `skill:<name>` commands. The former
+  // composite `/midcompact <subcommand>` command is gone.
+  pi.registerCommand("midcompact:start", {
+    description: "Start a new midcompact transaction at the current anchor. Optional trailing text becomes the initial focus.",
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       await ctx.waitForIdle();
-      const rawArgs = args.trim();
-      const lower = rawArgs.toLowerCase();
-
-      if (lower === "abort") return abortTransaction(ctx);
-      if (lower === "commit") return commitTransaction(ctx);
-      if (lower === "review") return reviewTransaction(ctx, "tui");
-      if (lower === "review-webui") return reviewTransaction(ctx, "web");
-      if (lower === "select") return openSelectionUi(ctx, "auto");
-      if (lower === "select-webui") return openSelectionUi(ctx, "web");
-      if (lower === "status") return showStatus(ctx);
-
-      // start [instructions...]
-      const startMatch = rawArgs.match(/^start\b\s*(.*)$/i);
-      if (startMatch) {
-        const instructions = (startMatch[1] ?? "").trim();
-        return startTransaction(ctx, instructions || undefined);
-      }
-
-      ctx.ui.notify(
-        "Usage: /midcompact start [instructions] | /midcompact select[-webui] | /midcompact review[-webui] | /midcompact commit | /midcompact status | /midcompact abort",
-        "warning",
-      );
+      return startTransaction(ctx, args.trim() || undefined);
+    },
+  });
+  pi.registerCommand("midcompact:abort", {
+    description: "Abort the active transaction and return to the anchor",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await ctx.waitForIdle();
+      return abortTransaction(ctx);
+    },
+  });
+  pi.registerCommand("midcompact:commit", {
+    description: "Commit the current draft to the branch state",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await ctx.waitForIdle();
+      return commitTransaction(ctx);
+    },
+  });
+  pi.registerCommand("midcompact:review", {
+    description: "Open the interactive TUI review to inspect and edit the draft",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await ctx.waitForIdle();
+      return reviewTransaction(ctx, "tui");
+    },
+  });
+  pi.registerCommand("midcompact:review-webui", {
+    description: "Open a local web page to inspect and edit the draft (works without TUI)",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await ctx.waitForIdle();
+      return reviewTransaction(ctx, "web");
+    },
+  });
+  pi.registerCommand("midcompact:select", {
+    description: "Open the TUI Selection surface to edit range boundaries",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await ctx.waitForIdle();
+      return openSelectionUi(ctx, "auto");
+    },
+  });
+  pi.registerCommand("midcompact:select-webui", {
+    description: "Open Selection in a local browser",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await ctx.waitForIdle();
+      return openSelectionUi(ctx, "web");
+    },
+  });
+  pi.registerCommand("midcompact:status", {
+    description: "Show current transaction and draft status",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await ctx.waitForIdle();
+      return showStatus(ctx);
     },
   });
 
@@ -218,23 +270,18 @@ export default function (pi: ExtensionAPI) {
       ctx.ui.notify("Cannot start midcompact without a session leaf.", "error");
       return;
     }
-    if (ctx.hasUI && ctx.mode !== "tui") {
-      const ok = await ctx.ui.confirm(
-        "Start midcompact transaction?",
-        "The current context snapshot will be frozen as an anchor. You will need to review and explicitly commit or abort later.",
-      );
-      if (!ok) {
-        ctx.ui.notify("Midcompact start cancelled.", "info");
-        return;
-      }
-    }
     // Mode choice: Agent-first or User-first. Both operate on the same DraftPlan;
-    // neither freezes boundaries. No mode flags on the command line.
+    // neither freezes boundaries. Drop maps to cancellation, so this one chooser
+    // replaces the separate confirmation. No mode flags on the command line.
     const modeChoice = await chooseStartMode(ctx);
     if (modeChoice === "cancelled") {
       ctx.ui.notify("Midcompact start cancelled.", "info");
       return;
     }
+    if (modeChoice === "unrecognized") {
+      ctx.ui.notify("Midcompact start cancelled: the dialog returned an unrecognized choice.", "warning");
+      return;
+    }
     const startMode: StartMode = modeChoice;
     transaction = {
       version: 1,
@@ -261,9 +308,11 @@ export default function (pi: ExtensionAPI) {
     await openSelectionUi(ctx);
   }
 
-  async function chooseStartMode(ctx: ExtensionCommandContext): Promise<StartMode | "cancelled"> {
-    if (!ctx.hasUI || ctx.mode !== "tui") return "agent";
-    return showStartChoiceUi(ctx);
+  async function chooseStartMode(ctx: ExtensionCommandContext): Promise<StartMode | "cancelled" | "unrecognized"> {
+    // The standard `select` dialog works identically in TUI and RPC; modes
+    // without any UI (json/print) cannot prompt and default to Agent-first.
+    if (!ctx.hasUI) return "agent";
+    return showStartChoice(ctx);
   }
 
   async function openSelectionUi(ctx: ExtensionCommandContext, mode: "auto" | "tui" | "web" = "auto"): Promise<void> {
@@ -312,7 +361,7 @@ export default function (pi: ExtensionAPI) {
           pi.appendEntry(DRAFT_ENTRY, draft);
           updateStatus(ctx, currentTx, draft, planningLock.owner);
         },
-      }, "selection");
+      }, "selection", { openBrowser: openReviewWebBrowser });
       ctx.ui.notify("Selection closed. The DraftPlan is saved; tell the Agent to continue when ready.", "info");
     } finally {
       releaseUi(planningLock);
@@ -457,14 +506,14 @@ export default function (pi: ExtensionAPI) {
         editSummary: (id, summary) => commitMutation(updateDraftRange(draft ?? emptyDraft(currentTx.id), id, { summary })),
         editTopic: (id, topic) => commitMutation(updateDraftRange(draft ?? emptyDraft(currentTx.id), id, { topic: topic || undefined })),
         remove: (id) => commitMutation(removeDraftRange(draft ?? emptyDraft(currentTx.id), id)),
-      });
+      }, undefined, { openBrowser: openReviewWebBrowser });
       ctx.ui.notify("Midcompact review-webui closed.", "info");
       return;
     }
 
     if (ctx.mode !== "tui") {
       ctx.ui.notify(
-        "Interactive TUI review is only available in interactive (tui) mode. Use /midcompact review-webui to open a local web page instead.",
+        "Interactive TUI review is only available in interactive (tui) mode. Use /midcompact:review-webui to open a local web page instead.",
         "warning",
       );
       return;
@@ -529,7 +578,7 @@ export default function (pi: ExtensionAPI) {
         if (params.action === "recall") return toolResult(handleRecall(params, ctx));
         const restored = restoreTransaction(ctx.sessionManager.getBranch() as SessionEntry[]);
         const currentTx = withCompatDefaults(restored.transaction ?? transaction);
-        if (!currentTx) return toolResult("No active midcompact transaction. Ask the user to run `/midcompact start` first.");
+        if (!currentTx) return toolResult("No active midcompact transaction. Ask the user to run `/midcompact:start` first.");
         transaction = currentTx;
         draft = restored.draft ? { ...restored.draft, ranges: restored.draft.ranges.map(coerceDraftRange) } : (draft ?? emptyDraft(currentTx.id));
         if (!requireAgentAccess(ctx)) {
@@ -560,7 +609,7 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
-  function handleInspect(params: ParamsType, atoms: Atom[], tx: TransactionState): string {
+  function handleInspect(params: InspectParamsType, atoms: Atom[], tx: TransactionState): string {
     if (params.spans) {
       if (params.page_size !== undefined || params.cursor !== undefined) {
         throw new Error("inspect spans cannot be combined with inventory pagination.");
@@ -571,7 +620,7 @@ export default function (pi: ExtensionAPI) {
     return formatInventory(page);
   }
 
-  function handleRecall(params: ParamsType, ctx: ExtensionContext): string {
+  function handleRecall(params: RecallParamsType, ctx: ExtensionContext): string {
     const sm = ctx.sessionManager;
     const branchState = restoreCompressionState(sm.getBranch() as SessionEntry[]) ?? activeState;
     if (!branchState?.blocks.length) return "No compressed blocks are active on this branch.";
@@ -607,7 +656,7 @@ export default function (pi: ExtensionAPI) {
 
 // ---- Pure handlers ----
 
-function handleLocate(params: ParamsType, atoms: Atom[]): string {
+function handleLocate(params: LocateParamsType, atoms: Atom[]): string {
   const hasFilter = Boolean(params.pattern || params.tool_name || (params.source && params.source !== "any"));
   if (params.ref && hasFilter) {
     throw new Error("locate accepts either one direct ref or search filters, not both.");
@@ -639,7 +688,7 @@ type PlanHandleResult =
   | { op: "show"; draft: DraftPlan }
   | { op: "add" | "update" | "remove"; draft: DraftPlan; changedId: string };
 
-function handlePlan(params: ParamsType, current: DraftPlan, atoms: Atom[]): PlanHandleResult {
+function handlePlan(params: PlanParamsType, current: DraftPlan, atoms: Atom[]): PlanHandleResult {
   const op = params.op ?? "show";
   if (op === "show") return { op, draft: current };
   if (op === "remove") {

package/src/start-ui.ts

@@ -1,57 +1,52 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 
 import type { StartMode } from "./types.js";
 
-export type StartChoice = StartMode | "cancelled";
+export type StartChoice = StartMode | "cancelled" | "unrecognized";
 
-export async function showStartChoiceUi(ctx: ExtensionCommandContext): Promise<StartChoice> {
-  if (ctx.mode !== "tui") return "agent";
-  return ctx.ui.custom<StartChoice>(
-    (tui, theme, _keybindings, done) => {
-      const choices: Array<{ value: StartChoice; title: string; detail: string }> = [
-        { value: "cancelled", title: "Drop", detail: "Leave the session unchanged" },
-        { value: "agent", title: "Agent direct", detail: "Inspect and draft with Agent" },
-        { value: "user", title: "User manual", detail: "Select the initial DraftPlan yourself" },
-      ];
-      let selected = 1;
-      const component = {
-        render(width: number): string[] {
-          const w = Math.max(48, Math.min(width, 94));
-          const line = (text: string) => theme.fg("border", `| ${truncateToWidth(text, w - 4, "...", true).padEnd(w - 4)} |`);
-          const rule = theme.fg("border", `+${"-".repeat(w - 2)}+`);
-          const rows = choices.map((choice, index) => {
-            const marker = index === selected ? theme.fg("accent", ">") : " ";
-            const rawTitle = choice.title.padEnd(18);
-            const title = index === selected ? theme.fg("accent", theme.bold(rawTitle)) : rawTitle;
-            return line(`${marker} ${String(index + 1)}  ${title} ${theme.fg("dim", choice.detail)}`);
-          });
-          return [
-            rule,
-            line(theme.fg("accent", theme.bold("Midcompact | Freeze current context"))),
-            line(theme.fg("dim", "Choose how to enter. Only Agent direct starts a model turn.")),
-            rule,
-            ...rows,
-            rule,
-            line(theme.fg("dim", "left/right or j/k move | Enter choose | Esc drop")),
-            rule,
-          ];
-        },
-        invalidate(): void {},
-        handleInput(data: string): void {
-          if (matchesKey(data, Key.escape) || data === "q") { done("cancelled"); return; }
-          if (matchesKey(data, Key.enter)) { done(choices[selected]!.value); return; }
-          if (data === "1") { done("cancelled"); return; }
-          if (data === "2") { done("agent"); return; }
-          if (data === "3") { done("user"); return; }
-          if (matchesKey(data, Key.left) || matchesKey(data, Key.up) || data === "k") selected = (selected + choices.length - 1) % choices.length;
-          else if (matchesKey(data, Key.right) || matchesKey(data, Key.down) || data === "j") selected = (selected + 1) % choices.length;
-          else return;
-          tui.requestRender();
-        },
-      };
-      return component;
-    },
-    { overlay: true, overlayOptions: { width: "76%", maxHeight: 13, anchor: "center" } },
-  );
+interface StartChoiceOption {
+  value: StartChoice;
+  label: string;
 }
+
+/**
+ * The three entry decisions. Shared by TUI and RPC so every mode offers the
+ * same choice set in the same order. Agent direct comes first: the standard
+ * selector highlights the first option, so Enter on open keeps the fast
+ * Agent-first start path, and RPC clients see the recommended entry first.
+ */
+const START_CHOICES: StartChoiceOption[] = [
+  { value: "agent", label: "Agent direct — Inspect and draft with Agent" },
+  { value: "user", label: "User manual — Select the initial DraftPlan yourself" },
+  { value: "cancelled", label: "Drop — Leave the session unchanged" },
+];
+
+/**
+ * Bound for RPC dialog waits. The timeout exists only as a safety net: when
+ * the RPC client never answers, the extension-UI sub-protocol auto-resolves
+ * the dialog (`undefined`) so the start cancels instead of blocking the
+ * extension forever. 120s is generous for the human on the other side of the
+ * wire (pi's own examples use 5s for urgent security confirms) while still
+ * bounding the worst-case stall. TUI mode passes no timeout: interactive
+ * users may take as long as they want.
+ */
+const START_DIALOG_TIMEOUT_MS = 120_000;
+
+/**
+ * Standard `select` dialog for the start mode, used identically in TUI and
+ * RPC. It serializes as an extension UI `select` request over the RPC
+ * sub-protocol, while interactive mode renders the built-in selector.
+ */
+export async function showStartChoice(ctx: ExtensionCommandContext): Promise<StartChoice> {
+  const options = START_CHOICES.map((choice) => choice.label);
+  const choice = await ctx.ui.select(
+    "Midcompact start — freeze the current context as an anchor; review, then commit or abort explicitly",
+    options,
+    ctx.mode === "rpc" ? { timeout: START_DIALOG_TIMEOUT_MS } : undefined,
+  );
+  if (choice === undefined) return "cancelled";
+  // A value outside the offered options is a protocol mismatch on the client
+  // side, not a user decision; keep it distinguishable from a real Drop.
+  const index = options.indexOf(choice);
+  return index >= 0 ? START_CHOICES[index]!.value : "unrecognized";
+}

package/src/types.ts

@@ -178,7 +178,7 @@ export interface TransactionState {
   startedAt: string;
   /** Initial routing chosen at start: Agent-first prompt or User-first UI. */
   startMode?: StartMode;
-  /** Frozen awareness captured when /midcompact starts; informational, never a target. */
+  /** Frozen awareness captured when /midcompact:start runs; informational, never a target. */
   anchorUsage?: ContextUsageSnapshot;
 }