@dieulc/workflow 0.5.0 → 0.5.2

package/README.md

@@ -41,7 +41,7 @@ Manage it with `pi list`, `pi update --extensions`, `pi remove npm:@dieulc/workf
 | `/review-prompt [global]` | Edit the reviewer's guidance (defaults to "align with the existing framework and industry best practice") |
 | `/review-status` | Show review phase, model, plan hash, findings and any error |
 | `/review` | Run one review round against the current plan file now |
-| `/commit` | Commit staged changes with an AI-summarized message (`-a`: stage tracked changes first). Confirmation-gated |
+| `/commit` | Commit staged changes with an AI-summarized message (`-a`: stage tracked changes first). Confirmation-gated; the confirmation arms the commit exemption for that run |
 | `/commit-policy [never\|ask\|allow] [global\|project]` | View or set the commit policy (default `never`: the agent cannot `git add`/`commit`/`push` — you commit, or use `/commit`) |
 
 ## Model Profiles
@@ -69,7 +69,9 @@ A profile is a **named combination of role model settings** — one `{provider,
 
 **Why**: mix models from different providers in one workflow (frontier planner + cheap explorer), keep one profile per provider to control budget per provider, run concurrent sessions on different providers to work around per-provider concurrency limits, and exploit cheaper starter plans across several providers.
 
-Profile config lives in `~/.pi/agent/profiles.json` v1 (user) with optional per-project override at `<cwd>/.pi/profiles.json` (per-profile replace, project wins). Names are case-insensitively unique, ≤ 40 chars, no whitespace (keep them CLI-addressable), and `none`/`auto` are reserved. A missing file is the normal empty state; a corrupt or wrong-version file is never rewritten (warning + in-memory empty config).
+Profile config lives in `~/.pi/agent/profiles.json` v1 (user) with optional per-project override at `<cwd>/.pi/profiles.json` (per-profile replace, project wins). Names are case-insensitively unique, ≤ 40 chars, no whitespace (keep them CLI-addressable), and `none`/`auto`/`off` are reserved (`off` is a `/profile use` deactivate keyword, so a profile can never be named it). A missing file is the normal empty state; a corrupt or wrong-version file is never rewritten (warning + in-memory empty config).
+
+**Argument completion** follows pi's full-argument contract (the same one pi's `/mcp` uses): accepting a suggestion replaces the entire typed argument text, so completing `/profile use Syn-␣` inserts `/profile use Syn-Deepseek-…` with the subcommand intact — it never collapses to `/profile <name>`. The dropdown closes (and the first Enter submits) once the typed token is already an exact, unique match. This applies positionally to `/profile` (`use|edit|show|delete|rename <old>|default <name> [global|project]`), `/commit-policy` (`never|ask|allow [global|project]`) and `/role` (`set <role> <provider/model> [thinking]`, `use <role|auto>`, `remove <name>`).
 
 ## Review Mode
 
@@ -267,7 +269,7 @@ Settings live under `workflow.reviewMode` in `~/.pi/agent/settings.json` (global
 
 ## Commit policy
 
-By default the agent **cannot touch your git history**: the tool gate deterministically blocks `git add`, `git commit` and `git push` — including compound commands (`git add -A && git commit -m x`), global-option forms (`git -C path add`) and `powershell` wrappers. You commit manually, or run `/commit` for an AI-summarized, confirmation-gated commit (its own `git commit` runs under a one-turn bypass; `push` is never bypassed). Read-only git (`status`, `log`, `diff`, `branch -a`, `config --get`, …) stays free, and plan mode keeps its stricter read-only rules regardless.
+By default the agent **cannot touch your git history**: the tool gate deterministically blocks `git add`, `git commit` and `git push` — including compound commands (`git add -A && git commit -m x`), global-option forms (`git -C path add`) and `powershell` wrappers. You commit manually, or run `/commit` for an AI-summarized, confirmation-gated commit. Read-only git (`status`, `log`, `diff`, `branch -a`, `config --get`, …) stays free, and plan mode keeps its stricter read-only rules regardless.
 
 The default exists because prompt-only rules are soft: models habitually commit per plan step, and "never commit unless asked" instructions in CLAUDE.md-style files are famously ignored (anthropics/claude-code#58883, #68724, #7029). Claude Code, Codex CLI and OpenCode all treat agent-initiated commits as something to gate or approve — so the policy here is enforced where commands execute, not in prose:
 
@@ -288,6 +290,16 @@ The default exists because prompt-only rules are soft: models habitually commit
 
 The status line always shows the active policy (`▶ build 2/5 · commits:never`), so you can see at a glance what the agent may do to history.
 
+### `/commit` under any policy
+
+`/commit` works under `never` and `allow`-during-a-plan because it is the user's own request. The flow is multi-turn (read the staged diff → confirm the message in a questionnaire → commit), so the exemption is **armed at the user's confirmation**, not when the flow starts:
+
+- `/commit` records a *pending flow* and injects its agent turn. Nothing is exempted yet.
+- When the confirmation questionnaire is answered **positively** (✅ Commit, or a custom message), the extension arms a scoped *commit authorization*. Choosing ❌ Cancel clears the flow and arms nothing.
+- The authorization exempts **only `git commit`** — `git add` and `git push` stay blocked — and is valid until the run settles (`agent_settled`), additionally bounded by a 10-minute TTL and a 10-commit cap. It is also dropped on `session_shutdown` and on rewind (`session_tree`).
+
+The confirmation step is required: with no positive answer no authorization exists and the policy keeps blocking. `-a` staging happens extension-side before the flow, outside the tool gate.
+
 ```text
 /commit-policy                # status: mode, which scope supplied it, both settings paths
 /commit-policy never          # set globally (~/.pi/agent/settings.json)

package/commit-policy.ts

@@ -23,6 +23,8 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { ArgumentCompletion } from "./utils.ts";
+import { joinArgumentValue, suppressExactArgumentMatch } from "./utils.ts";
 
 /** Pi's project config directory. Mirrors WORKFLOW_CONFIG_DIR without importing review.ts (which pulls provider modules). */
 export const COMMIT_CONFIG_DIR = ".pi";
@@ -321,6 +323,176 @@ export function stepCommitDecision(
   };
 }
 
+// ── /commit authorization (scoped exemption from the gate) ───────────
+//
+// The /commit flow is multi-turn (read diff → confirm via questionnaire →
+// commit), so a single-turn exemption is always disarmed before the commit
+// runs. Instead the flow starts a PendingCommitFlow and the authorization is
+// armed only when the user CONFIRMS in the extension-owned questionnaire
+// tool. The authorization is valid until the run settles, bounded by a TTL and
+// a commit cap, and exempts ONLY `git commit` (never `add`/`push`).
+
+/** How long a /commit flow may sit awaiting the user's decision. */
+export const COMMIT_FLOW_TTL_MS = 30 * 60 * 1000;
+
+/** How long an armed authorization stays valid (run-settle is the primary bound). */
+export const COMMIT_AUTH_TTL_MS = 10 * 60 * 1000;
+
+/** Defense-in-depth cap on commits made under one /commit authorization. */
+export const COMMIT_AUTH_MAX_COMMITS = 10;
+
+let commitFlowCounter = 0;
+
+/** A /commit flow awaiting the user's confirmation. */
+export interface PendingCommitFlow {
+  id: string;
+  startedAt: number;
+  expiresAt: number;
+}
+
+/** An armed exemption from the commit gate, created at the user's confirmation. */
+export interface CommitAuthorizationState {
+  flowId: string;
+  armedAt: number;
+  expiresAt: number;
+  commits: number;
+  maxCommits: number;
+}
+
+/** Start a new /commit flow (id is unique within the process). */
+export function startCommitFlow(
+  now: number,
+  ttlMs: number = COMMIT_FLOW_TTL_MS,
+): PendingCommitFlow {
+  commitFlowCounter += 1;
+  return {
+    id: `commit-${now}-${commitFlowCounter}`,
+    startedAt: now,
+    expiresAt: now + ttlMs,
+  };
+}
+
+/** Arm the exemption for one flow. Never throws. */
+export function armCommitAuthorization(input: {
+  flowId: string;
+  now: number;
+  ttlMs?: number;
+  maxCommits?: number;
+}): CommitAuthorizationState {
+  const ttlMs = input.ttlMs ?? COMMIT_AUTH_TTL_MS;
+  return {
+    flowId: input.flowId,
+    armedAt: input.now,
+    expiresAt: input.now + ttlMs,
+    commits: 0,
+    maxCommits: input.maxCommits ?? COMMIT_AUTH_MAX_COMMITS,
+  };
+}
+
+/** True only while an authorization is present, unexpired and under its cap. */
+export function isAuthorizationActive(
+  auth: CommitAuthorizationState | null | undefined,
+  now: number,
+): boolean {
+  if (!auth) return false;
+  if (!(now < auth.expiresAt)) return false;
+  return auth.commits < auth.maxCommits;
+}
+
+/** A normalized questionnaire question (only the fields the detector needs). */
+export interface CommitConfirmationQuestion {
+  question?: string;
+  header?: string;
+  options?: { label?: string; description?: string }[];
+}
+
+/**
+ * Is this questionnaire the /commit confirmation? Signals, in order: the
+ * "Commit" header, the canonical question text, or the "✅ Commit" option
+ * label. Deliberately tolerant — a missed match leaves the policy blocking
+ * (fail safe), so false negatives are a UX regression, false positives a risk.
+ */
+export function isCommitConfirmation(
+  questions: readonly CommitConfirmationQuestion[] | undefined,
+): boolean {
+  if (!Array.isArray(questions)) return false;
+  return questions.some((q) => {
+    if (!q || typeof q !== "object") return false;
+    if (typeof q.header === "string" && /^commit$/i.test(q.header.trim())) {
+      return true;
+    }
+    if (
+      typeof q.question === "string" &&
+      /commit these staged changes/i.test(q.question)
+    ) {
+      return true;
+    }
+    return (q.options ?? []).some(
+      (o: { label?: string; description?: string }) =>
+        typeof o?.label === "string" && /✅\s*commit/i.test(o.label),
+    );
+  });
+}
+
+/** One questionnaire answer, as far as the decision needs to know. */
+export interface CommitConfirmationAnswer {
+  answer?: string;
+  wasCustom?: boolean;
+}
+
+/**
+ * Did the user authorize the commit? Cancel (`cancelled` or a ❌/cancel-only
+ * label) never arms. Freeform text always arms (it is the user's own commit
+ * message) unless it is exactly a cancel token. A canned label arms unless it
+ * reads as cancel without commit.
+ */
+export function isPositiveCommitDecision(input: {
+  cancelled?: boolean;
+  answer?: CommitConfirmationAnswer;
+}): boolean {
+  if (input?.cancelled) return false;
+  const answer = input?.answer;
+  if (!answer) return false;
+  const label = String(answer.answer ?? "").trim();
+  if (!label) return false;
+  const isBareCancel = /^(❌\s*)?cancel[.!]?$/i.test(label);
+  if (isBareCancel) return false;
+  if (answer.wasCustom) return true;
+  if (/\bcancel\b/i.test(label) && !/\bcommit\b/i.test(label)) return false;
+  return true;
+}
+
+/** The commit-policy gate outcome for one tool call. */
+export type CommitGateDecision = "allow" | "block" | "ask";
+
+/** Git subcommands the commit policy gates (mirrors permissions.ts CommitPolicyHit). */
+export type CommitGateHit = "add" | "commit" | "push";
+
+export interface CommitGateInput {
+  policy: CommitPolicyMode;
+  hit: CommitGateHit;
+  hasTodos: boolean;
+  auth?: CommitAuthorizationState | null;
+  now: number;
+}
+
+/**
+ * The pure commit-policy decision. Ordering mirrors the original inline gate:
+ * an `allow` policy with no active plan owns nothing → allow; `ask` keeps
+ * fresh staging free; an armed authorization exempts ONLY `git commit`; then
+ * never/allow block and anything left (`ask`) prompts. Never throws.
+ */
+export function decideCommitGate(input: CommitGateInput): CommitGateDecision {
+  const { policy, hit, hasTodos } = input;
+  if (policy === "allow" && !hasTodos) return "allow";
+  if (policy === "ask" && hit === "add") return "allow";
+  if (hit === "commit" && isAuthorizationActive(input.auth, input.now)) {
+    return "allow";
+  }
+  if (policy === "never" || policy === "allow") return "block";
+  return "ask";
+}
+
 /**
  * Read-modify-write `workflow.commitPolicy` into a settings file, preserving
  * every other key in that file (Pi owns settings.json — we must not clobber it).
@@ -356,3 +528,104 @@ export function writeCommitPolicyConfig(
     };
   }
 }
+
+// ── Argument completions (/commit-policy) ────────────────────────────
+
+/** One /commit-policy subcommand with its usage hint. */
+const COMMIT_POLICY_SUBS: readonly {
+  name: string;
+  label: string;
+  description: string;
+}[] = [
+  {
+    name: "never",
+    label: "never",
+    description: "agent cannot git add/commit/push — you commit (or /commit)",
+  },
+  {
+    name: "ask",
+    label: "ask",
+    description: "agent may commit; each git commit/push asks first",
+  },
+  {
+    name: "allow",
+    label: "allow",
+    description: "agent may commit freely (per-step during plan execution)",
+  },
+];
+
+const COMMIT_POLICY_SCOPES: readonly {
+  token: string;
+  description: string;
+}[] = [
+  { token: "global", description: "write to ~/.pi/agent/settings.json" },
+  { token: "project", description: "write to <cwd>/.pi/settings.json" },
+];
+
+/** commit-policy subcommands take an optional scope → trailing-space values. */
+const COMMIT_POLICY_MODE_TOKENS: ReadonlySet<string> = new Set([
+  "never",
+  "ask",
+  "allow",
+]);
+
+/**
+ * Argument completions for `/commit-policy` (pure; unit-tested in
+ * commit-policy.test.ts).
+ *
+ * Follows the pi-tui full-argument contract (see `joinArgumentValue` and the
+ * /mcp extension): the first token completes a mode, the second token
+ * completes the write scope, and every returned `value` is the complete
+ * replacement for the typed argument text (`"ask project"`, never
+ * `"project"`). Returns null when nothing useful can be offered, including
+ * when the typed token is already an exact unique match (exact-match
+ * suppression — the dropdown closes so the first Enter submits).
+ */
+export function commitPolicyArgumentCompletions(
+  argumentPrefix: string,
+): ArgumentCompletion[] | null {
+  const raw = String(argumentPrefix ?? "");
+  const join = (token: string) => joinArgumentValue(raw, token);
+
+  // ── Subcommand position: no whitespace typed yet ────────────────────
+  if (!raw.trim() || !/\s/.test(raw)) {
+    const lower = raw.trim().toLowerCase();
+    const matching = COMMIT_POLICY_SUBS.filter((s) =>
+      s.name.startsWith(lower),
+    );
+    if (matching.length === 0) return null;
+    return matching.map((s) => ({
+      value: `${s.name} `,
+      label: s.label,
+      description: s.description,
+    }));
+  }
+
+  // ── Argument position: mode already committed → complete the scope ──
+  const tokens = raw.trim().split(/\s+/).filter(Boolean);
+  const mode = (tokens[0] ?? "").toLowerCase();
+  if (!COMMIT_POLICY_MODE_TOKENS.has(mode)) return null;
+  const endsWithWs = /\s$/.test(raw);
+  const partial = endsWithWs ? "" : (tokens[tokens.length - 1] ?? "");
+  const items: ArgumentCompletion[] = COMMIT_POLICY_SCOPES.flatMap((s) =>
+    s.token.startsWith(partial.toLowerCase())
+      ? [
+          {
+            value: join(s.token),
+            label: s.token,
+            description: s.description,
+          },
+        ]
+      : [],
+  );
+  if (items.length === 0) return null;
+  if (
+    suppressExactArgumentMatch(
+      items.map((i) => i.label),
+      partial,
+    )
+  ) {
+    return null;
+  }
+  return items;
+}

package/index.ts

@@ -89,12 +89,25 @@ import {
   type WorkflowRole,
 } from "./permissions.ts";
 import {
+  COMMIT_AUTH_MAX_COMMITS,
+  COMMIT_AUTH_TTL_MS,
+  COMMIT_FLOW_TTL_MS,
+  armCommitAuthorization,
   commitConfigPaths,
+  commitPolicyArgumentCompletions,
+  decideCommitGate,
   describeCommitPolicyMode,
+  isAuthorizationActive,
+  isCommitConfirmation,
+  isPositiveCommitDecision,
   readCommitPolicyConfig,
+  startCommitFlow,
   stepCommitDecision,
   writeCommitPolicyConfig,
+  type CommitAuthorizationState,
+  type CommitGateHit,
   type CommitPolicyMode,
+  type PendingCommitFlow,
   type StepCommitCandidate,
 } from "./commit-policy.ts";
 import {
@@ -110,6 +123,7 @@ import {
   defaultRoleConfig,
   loadRoleConfigDetailed,
   rolesFingerprint,
+  roleArgumentCompletions,
   saveRoleConfig,
   getRole,
   formatRolesForDisplay,
@@ -133,6 +147,7 @@ import {
   getProfile,
   formatProfilesForDisplay,
   describeProfile,
+  profileArgumentCompletions,
   validateProfileName,
   applyProfileOverlay,
   missingProfileRoles,
@@ -400,11 +415,19 @@ export default function workflowExtension(pi: ExtensionAPI) {
   let todoItems: TodoItem[] = [];
   // Plan file the current todo list was derived from (drives merge vs replace).
   let todoPlanPath: string | undefined;
-  // Armed while the user-invoked /commit flow's agent turn is running: its
-  // `git commit` bypasses the commit-policy gate (staging already happened
-  // extension-side via piExecGit, outside the tool gate). Cleared on
-  // turn_end/agent_settled so the window stays one turn wide.
-  let commitBypassActive = false;
+  // ── /commit flow authorization ──
+  // The /commit flow is multi-turn (read diff → confirm → commit), so a
+  // single-turn exemption is always disarmed before the commit runs. Instead:
+  //   pendingCommitFlow  — set when /commit injects its agent turn, cleared on
+  //                        the user's confirmation (or a negative/cancel answer),
+  //                        so only THIS flow's questionnaire can arm.
+  //   commitAuthorization — armed only when the user confirms in that
+  //                        questionnaire; exempts ONLY `git commit` (never
+  //                        add/push) until the run settles, bounded by a TTL
+  //                        and a commit cap.
+  // Both are cleared on agent_settled, session_shutdown and session_tree.
+  let pendingCommitFlow: PendingCommitFlow | null = null;
+  let commitAuthorization: CommitAuthorizationState | null = null;
   // ── Deterministic per-step commits (allow mode) ──
   // In 'allow' mode the EXTENSION — not the model — owns commit timing:
   // exactly one commit per batch of newly completed plan steps, made at the
@@ -1567,39 +1590,11 @@ export default function workflowExtension(pi: ExtensionAPI) {
       );
       updateStatus(ctx as any);
     },
-    getArgumentCompletions: (prefix: string) => {
-      const flags = [
-        {
-          value: "never",
-          label: "never",
-          description:
-            "agent cannot git add/commit/push — you commit (or /commit)",
-        },
-        {
-          value: "ask",
-          label: "ask",
-          description: "agent may commit; each git commit/push asks first",
-        },
-        {
-          value: "allow",
-          label: "allow",
-          description:
-            "agent may commit freely (per-step during plan execution)",
-        },
-        {
-          value: "global",
-          label: "global",
-          description: "write to ~/.pi/agent/settings.json",
-        },
-        {
-          value: "project",
-          label: "project",
-          description: "write to <cwd>/.pi/settings.json",
-        },
-      ];
-      const filtered = flags.filter((f) => f.value.startsWith(prefix));
-      return filtered.length ? filtered : null;
-    },
+    // pi-tui full-argument contract (see commitPolicyArgumentCompletions):
+    // modes first, then the write scope, with values that replace the whole
+    // typed argument text ("ask project", never bare "project").
+    getArgumentCompletions: (prefix: string) =>
+      commitPolicyArgumentCompletions(prefix),
   });
 
   pi.registerCommand("review-prompt", {
@@ -2532,16 +2527,28 @@ export default function workflowExtension(pi: ExtensionAPI) {
 
     // Inject a user message → triggers an agent turn that proposes + confirms + commits
     const message = buildCommitPrompt(statSummary, stageAll);
-    // Arm the commit-policy bypass for exactly this agent turn: its `git
-    // commit` must run even under policy 'never'. Disarmed on turn_end /
-    // agent_settled, so the window is one turn wide.
-    commitBypassActive = true;
-    if ((pi as any).sendUserMessage) {
-      (pi as any).sendUserMessage(message);
-    } else {
-      (pi as any).sendMessage?.(
-        { customType: "workflow-commit", content: message, display: true },
-        { triggerTurn: true, deliverAs: "followUp" },
+    // Start a commit flow. The exemption is NOT armed here: it is armed only
+    // when the user confirms in THIS flow's questionnaire (see the
+    // questionnaire tool), so an unconfirmed commit stays blocked under any
+    // policy. A flow TTL bounds an abandoned confirmation.
+    pendingCommitFlow = startCommitFlow(Date.now(), COMMIT_FLOW_TTL_MS);
+    commitAuthorization = null;
+    try {
+      if ((pi as any).sendUserMessage) {
+        await (pi as any).sendUserMessage(message);
+      } else {
+        await (pi as any).sendMessage?.(
+          { customType: "workflow-commit", content: message, display: true },
+          { triggerTurn: true, deliverAs: "followUp" },
+        );
+      }
+    } catch (e: any) {
+      // The turn never started → no questionnaire can arm; do not leave a
+      // stale flow behind.
+      pendingCommitFlow = null;
+      ctx.ui.notify(
+        `Failed to start the commit flow: ${String(e?.message ?? e ?? e)}`,
+        "error",
       );
     }
   }
@@ -3010,6 +3017,21 @@ export default function workflowExtension(pi: ExtensionAPI) {
 
   pi.registerCommand("role", {
     description: "Configure one model + thinking per role — opens picker UI",
+    // pi-tui full-argument contract (see roleArgumentCompletions): positional
+    // set/use/remove completions whose values replace the whole typed
+    // argument text ("set planner <provider/model>"), never bare tokens.
+    getArgumentCompletions: (prefix: string) => {
+      // No ctx here — use the live session cwd so project-scope roles.json is
+      // honored, matching the handler's ensureRoleConfig(cwd) key.
+      ensureRoleConfig((currentSessionCtx as any)?.cwd);
+      const models = collectRoleCatalog(currentSessionCtx as any).all.map(
+        (e) => formatModelRef({ provider: e.provider, id: e.id } as RoleModel),
+      );
+      return roleArgumentCompletions(prefix, {
+        roleNames: roleConfig.roles.map((r) => r.name),
+        models,
+      });
+    },
     handler: async (args, ctx) => {
       const cwd = (ctx as any)?.cwd as string | undefined;
       ensureRoleConfig(cwd);
@@ -4521,90 +4543,31 @@ export default function workflowExtension(pi: ExtensionAPI) {
         return;
       }
 
-      // Bare profile name → show detail (mirrors /role <name>).
+      // Bare profile name → show detail (mirrors /role <name>). The hint
+      // matters: this branch is where the old completion bug dropped users
+      // who meant `/profile use <name>`.
       const named = getProfile(profilesConfig, sub);
       if (named) {
-        ctx.ui.notify(describeProfile(named), "info");
+        ctx.ui.notify(
+          `${describeProfile(named)}\n\nActivate it with /profile use ${named.name}.`,
+          "info",
+        );
         return;
       }
       ctx.ui.notify(PROFILE_USAGE, "info");
     },
+    // pi-tui contract: argument completions replace the ENTIRE typed argument
+    // text with item.value (see profileArgumentCompletions / utils.joinArgument
+    // Value). The old inline completer returned bare profile names, so
+    // accepting a suggestion rewrote "/profile use X" → "/profile X" and the
+    // command silently showed details instead of activating.
     getArgumentCompletions: (prefix: string) => {
-      ensureProfilesConfig();
-      const subs = [
-        { value: "list", label: "list", description: "show all profiles" },
-        {
-          value: "use",
-          label: "use <name|none>",
-          description: "activate/deactivate for this session",
-        },
-        {
-          value: "create",
-          label: "create <name>",
-          description: "create a profile (seeded from current models)",
-        },
-        {
-          value: "edit",
-          label: "edit <name>",
-          description: "open the tabbed model editor",
-        },
-        {
-          value: "rename",
-          label: "rename <old> <new>",
-          description: "rename a profile",
-        },
-        {
-          value: "delete",
-          label: "delete <name>",
-          description: "delete a profile",
-        },
-        {
-          value: "default",
-          label: "default [name|none] [global|project]",
-          description: "default profile for new sessions",
-        },
-        {
-          value: "show",
-          label: "show <name>",
-          description: "show one profile's models",
-        },
-      ];
-      const lower = String(prefix || "").toLowerCase();
-      if (lower.includes(" ")) {
-        // Completing an argument after a subcommand → profile names where relevant.
-        const cmd = lower.trim().split(/\s+/)[0];
-        const wantsNames =
-          cmd === "use" ||
-          cmd === "edit" ||
-          cmd === "delete" ||
-          cmd === "show" ||
-          cmd === "default";
-        if (!wantsNames) return null;
-        const last = lower.trim().split(/\s+/).pop() ?? "";
-        const names = profilesConfig.profiles
-          .filter((p) => p.name.toLowerCase().startsWith(last))
-          .map((p) => ({
-            value: p.name,
-            label: p.name,
-            description: p.description || undefined,
-          }));
-        return cmd === "use" || cmd === "default"
-          ? [
-              ...names,
-              { value: "none", label: "none", description: "no profile" },
-            ]
-          : names;
-      }
-      const matching = subs.filter((s) => s.value.startsWith(lower));
-      if (matching.length > 0) return matching;
-      const names = profilesConfig.profiles
-        .filter((p) => p.name.toLowerCase().startsWith(lower))
-        .map((p) => ({
-          value: p.name,
-          label: p.name,
-          description: p.description || undefined,
-        }));
-      return names.length ? names : null;
+      // The completion callback gets no ctx — use the live session cwd so
+      // project-scope profiles (<cwd>/.pi/profiles.json) are included and the
+      // profiles cache key matches the handler's (a cwd-less reload could
+      // otherwise deactivate an active project-scope profile).
+      ensureProfilesConfig((currentSessionCtx as any)?.cwd);
+      return profileArgumentCompletions(prefix, profilesConfig.profiles);
     },
   });
 
@@ -5801,6 +5764,34 @@ export default function workflowExtension(pi: ExtensionAPI) {
         overlayActive = false;
       }
 
+      // /commit authorization: arm the commit-policy exemption ONLY when the
+      // user confirms THIS flow's commit questionnaire. A cancel (or any
+      // non-confirmation questionnaire) clears the pending flow and arms
+      // nothing, so the policy keeps blocking. Headless never reaches here
+      // (early return above), which is the intended fail-closed behaviour.
+      if (pendingCommitFlow && isCommitConfirmation(questions)) {
+        const cancelled = !result || result.cancelled === true;
+        const answer =
+          !result || result.cancelled ? undefined : result.answers?.[0];
+        if (isPositiveCommitDecision({ cancelled, answer })) {
+          commitAuthorization = armCommitAuthorization({
+            flowId: pendingCommitFlow.id,
+            now: Date.now(),
+            ttlMs: COMMIT_AUTH_TTL_MS,
+            maxCommits: COMMIT_AUTH_MAX_COMMITS,
+          });
+          try {
+            ctx.ui.notify?.(
+              "Commit authorized — this run may commit the staged changes.",
+              "info",
+            );
+          } catch (_e) {
+            void _e;
+          }
+        }
+        pendingCommitFlow = null;
+      }
+
       if (!result || result.cancelled) {
         return {
           content: [{ type: "text", text: "User cancelled questionnaire" }],
@@ -6421,6 +6412,10 @@ export default function workflowExtension(pi: ExtensionAPI) {
     }
     ctx.ui.setStatus("workflow", undefined);
     ctx.ui.setWidget("workflow-todos", undefined);
+    // Drop any /commit authorization or flow: a reload/quit must never leave
+    // an exemption armed for whatever runs next.
+    commitAuthorization = null;
+    pendingCommitFlow = null;
     // Release the reviewer session (and its custom tools) on shutdown so a
     // reload or quit never leaves an orphaned in-process session behind.
     await teardownReview();
@@ -6432,6 +6427,9 @@ export default function workflowExtension(pi: ExtensionAPI) {
     todoItems = [];
     todoPlanPath = undefined;
     btwNotes = [];
+    // A rewind must not preserve a /commit exemption across branches.
+    commitAuthorization = null;
+    pendingCommitFlow = null;
     try {
       const branch = ctx.sessionManager.getBranch();
       for (const e of branch as any[]) {
@@ -6468,32 +6466,52 @@ export default function workflowExtension(pi: ExtensionAPI) {
    *   allow → automatic per-step commits while a plan todo list is active
    * (the extension owns commit timing — model-initiated git add/commit/push
    * are blocked); outside a plan the model may commit as before. The
-   * user-invoked /commit flow arms `commitBypassActive` so its own `git
-   * commit` runs (staging is extension-side; `push` and `add` are never
-   * bypassed).
+   * user-invoked /commit flow arms `commitAuthorization` ONLY when the user
+   * confirms its questionnaire; that exemption covers just `git commit` for
+   * the rest of the run (staging is extension-side; `push` and `add` are
+   * never exempted).
+   *
+   * The decision itself is the pure `decideCommitGate`; this wrapper supplies
+   * the runtime inputs and renders the block reasons / ask overlay.
    */
   async function commitPolicyGate(
     event: any,
     ctx: any,
     cwd: string,
   ): Promise<{ block: true; reason: string } | undefined> {
-    const policy = readCommitPolicyConfig(cwd, getAgentDir()).config.mode;
-    // allow outside a plan: no per-step automation to own commit timing, so
-    // the model keeps its previous freedom.
-    if (policy === "allow" && todoItems.length === 0) return undefined;
     const cmd = String(event?.input?.command ?? "");
     const hit = gitCommitPolicyHit(cmd);
     if (!hit) return undefined;
-    // `add` is only gated in `never` mode; `ask` prompts on commit/push only
-    // (staging alone pollutes nothing).
-    if (policy === "ask" && hit === "add") return undefined;
-    // /commit bypass: only the flow's own `git commit` is exempt — `add` and
-    // `push` are not.
-    if (commitBypassActive && hit === "commit") {
+    const policy = readCommitPolicyConfig(cwd, getAgentDir()).config.mode;
+    const now = Date.now();
+    const decision = decideCommitGate({
+      policy,
+      hit: hit as CommitGateHit,
+      hasTodos: todoItems.length > 0,
+      auth: commitAuthorization,
+      now,
+    });
+    if (decision === "allow") {
+      // Count a granted `git commit` against the authorization, but only when
+      // the authorization was actually the deciding factor (never/ask, or
+      // allow-with-an-active-plan). `allow` outside a plan is free regardless.
+      const authWasDecisive =
+        hit === "commit" &&
+        commitAuthorization !== null &&
+        !(policy === "allow" && todoItems.length === 0);
+      if (authWasDecisive && commitAuthorization) {
+        const auth = commitAuthorization;
+        if (!isAuthorizationActive(auth, now)) {
+          commitAuthorization = null;
+        } else {
+          const next = { ...auth, commits: auth.commits + 1 };
+          commitAuthorization = next.commits >= next.maxCommits ? null : next;
+        }
+      }
       return undefined;
     }
 
-    if (policy === "never" || policy === "allow") {
+    if (decision === "block") {
       return {
         block: true,
         reason:
@@ -6507,7 +6525,7 @@ export default function workflowExtension(pi: ExtensionAPI) {
               cmd,
       };
     }
-    // policy === "ask" → confirmation overlay. Headless has no one to ask →
+    // decision === "ask" → confirmation overlay. Headless has no one to ask →
     // fail closed rather than commit unbidden.
     const ui = ctx?.ui;
     if (!ui || !ctx.hasUI) {
@@ -6886,9 +6904,11 @@ export default function workflowExtension(pi: ExtensionAPI) {
   });
 
   pi.on("agent_settled", async () => {
-    // Belt-and-braces: the run is over (completed, aborted or errored) — the
-    // /commit bypass must not leak into whatever runs next.
-    commitBypassActive = false;
+    // The run is over (completed, aborted or errored). The /commit flow lives
+    // within one run, so both the armed exemption and any unconfirmed flow are
+    // dropped here — nothing that runs next inherits them.
+    commitAuthorization = null;
+    pendingCommitFlow = null;
     // keep persisted CustomEntry for reload, clear in-memory tombstone only on explicit prune; for now no clear to survive fork
   });
 
@@ -7067,10 +7087,10 @@ export default function workflowExtension(pi: ExtensionAPI) {
 
   // Track progress (all modes, whenever todos exist)
   pi.on("turn_end", async (event, ctx) => {
-    // Disarm the /commit bypass as soon as any turn ends: the /commit flow's
-    // `git commit` runs as a tool call WITHIN its turn, so this never disarms
-    // too early — and nothing after the turn inherits the exemption.
-    commitBypassActive = false;
+    // NOTE: do NOT disarm the /commit authorization here. `turn_end` fires
+    // after EVERY assistant response, but /commit is multi-turn (read diff →
+    // confirm → commit), so disarming per turn kills the exemption before the
+    // commit turn. Lifetime is the run: `agent_settled` clears it.
     if (todoItems.length === 0) return;
     if (!isAssistantMessage(event.message as AgentMessage)) return;
     const text = getTextContent(event.message as AssistantMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dieulc/workflow",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "private": false,
   "keywords": ["pi-package", "workflow", "plan-mode", "review-mode", "questionnaire", "rewind"],

package/profiles.ts

@@ -40,6 +40,8 @@ import {
   roleIcon,
 } from "./roles.ts";
 import { COMMIT_CONFIG_DIR, WORKFLOW_SETTINGS_KEY } from "./commit-policy.ts";
+import type { ArgumentCompletion } from "./utils.ts";
+import { joinArgumentValue, suppressExactArgumentMatch } from "./utils.ts";
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -66,7 +68,7 @@ export const PROFILE_CONFIG_VERSION = 1;
 export const MAX_PROFILE_NAME_LENGTH = 40;
 
 /** Reserved words — they collide with `/profile use <name|none>` and `/role use` style keywords. */
-export const RESERVED_PROFILE_NAMES: readonly string[] = ["none", "auto"];
+export const RESERVED_PROFILE_NAMES: readonly string[] = ["none", "auto", "off"];
 
 /** Fallback thinking level when a sanitized model omits an invalid one. */
 const DEFAULT_THINKING: ThinkingLevel = "medium";
@@ -615,3 +617,208 @@ export function writeDefaultProfileSetting(
     };
   }
 }
+
+// ── Argument completions (/profile) ──────────────────────────────────
+
+/** Subcommands that take a profile-name argument (position 2). */
+const PROFILE_NAME_SUBS: ReadonlySet<string> = new Set([
+  "use",
+  "edit",
+  "show",
+  "delete",
+  "default",
+  "rename",
+]);
+
+/** Aliases the /profile handler accepts, mapped to their canonical subcommand. */
+const PROFILE_CMD_ALIASES: Readonly<Record<string, string>> = {
+  activate: "use",
+  config: "edit",
+  remove: "delete",
+  rm: "delete",
+  mv: "rename",
+  new: "create",
+  add: "create",
+};
+
+/** Write-scope descriptions for `/profile default <name> <scope>` completions. */
+const SCOPE_DESCRIPTIONS: Readonly<Record<string, string>> = {
+  global: "write to ~/.pi/agent/settings.json",
+  project: "write to <cwd>/.pi/settings.json",
+};
+
+interface ProfileSubMeta {
+  name: string;
+  /** Takes an argument → completion `value` carries a trailing space. */
+  takesArg: boolean;
+  label: string;
+  description: string;
+}
+
+const PROFILE_SUBS: readonly ProfileSubMeta[] = [
+  {
+    name: "list",
+    takesArg: false,
+    label: "list",
+    description: "show all profiles",
+  },
+  {
+    name: "use",
+    takesArg: true,
+    label: "use <name|none>",
+    description: "activate/deactivate for this session",
+  },
+  {
+    name: "create",
+    takesArg: true,
+    label: "create <name>",
+    description: "create a profile (seeded from current models)",
+  },
+  {
+    name: "edit",
+    takesArg: true,
+    label: "edit <name>",
+    description: "open the tabbed model editor",
+  },
+  {
+    name: "rename",
+    takesArg: true,
+    label: "rename <old> <new>",
+    description: "rename a profile",
+  },
+  {
+    name: "delete",
+    takesArg: true,
+    label: "delete <name>",
+    description: "delete a profile",
+  },
+  {
+    name: "default",
+    takesArg: true,
+    label: "default [name|none] [global|project]",
+    description: "default profile for new sessions",
+  },
+  {
+    name: "show",
+    takesArg: true,
+    label: "show <name>",
+    description: "show one profile's models",
+  },
+];
+
+/** Profile names matching a lowercased partial token, case-insensitively. */
+function profileNameMatches(
+  profiles: readonly Profile[],
+  partial: string,
+): Profile[] {
+  if (!partial) return [...profiles];
+  return profiles.filter((p) =>
+    p.name.toLowerCase().startsWith(partial.toLowerCase()),
+  );
+}
+
+function profileCompletions(
+  profiles: readonly Profile[],
+  join: (token: string) => string,
+): ArgumentCompletion[] {
+  return profiles.map((p) => ({
+    value: join(p.name),
+    label: p.name,
+    ...(p.description ? { description: p.description } : {}),
+  }));
+}
+
+/**
+ * Argument completions for `/profile` (pure; unit-tested in profiles.test.ts).
+ *
+ * `argumentPrefix` is the ENTIRE typed argument text after "/profile " (what
+ * pi's CombinedAutocompleteProvider passes). Per the pi-tui contract, every
+ * returned item's `value` is the complete replacement for that argument text
+ * (`joinArgumentValue`), never a bare token — accepting `"use Syn-De" →
+ * "Syn-…"` would otherwise drop the `use` subcommand (see the /mcp
+ * extension for the reference implementation).
+ *
+ * Returns null when there is nothing useful to offer (unknown subcommand,
+ * `rename <old> <new>` second arg, `create`, …) or when the typed token is
+ * already an exact, unique match (exact-match suppression → the dropdown
+ * closes and the first Enter submits the command).
+ */
+export function profileArgumentCompletions(
+  argumentPrefix: string,
+  profiles: readonly Profile[],
+): ArgumentCompletion[] | null {
+  const raw = String(argumentPrefix ?? "");
+  const join = (token: string) => joinArgumentValue(raw, token);
+
+  // ── Subcommand position: no whitespace typed yet ────────────────────
+  if (!raw.trim() || !/\s/.test(raw)) {
+    const lower = raw.trim().toLowerCase();
+    const matching = PROFILE_SUBS.filter((s) =>
+      s.name.startsWith(lower),
+    );
+    if (matching.length > 0) {
+      return matching.map((s) => ({
+        value: s.takesArg ? `${s.name} ` : s.name,
+        label: s.label,
+        description: s.description,
+      }));
+    }
+    // Bare profile name → `/profile <name>` shows detail (mirrors /role).
+    const names = profileNameMatches(profiles, lower);
+    if (names.length === 0) return null;
+    return profileCompletions(names, join);
+  }
+
+  // ── Argument position ────────────────────────────────────────────────
+  const tokens = raw.trim().split(/\s+/).filter(Boolean);
+  const head = tokens[0] ?? "";
+  const canonical = PROFILE_CMD_ALIASES[head.toLowerCase()] ?? head.toLowerCase();
+  const endsWithWs = /\s$/.test(raw);
+  const committedCount = endsWithWs ? tokens.length : tokens.length - 1;
+  const partial = endsWithWs ? "" : (tokens[tokens.length - 1] ?? "");
+
+  let items: ArgumentCompletion[] | null = null;
+
+  if (canonical === "default") {
+    if (committedCount <= 1) {
+      // Second token: profile name | none.
+      const names = profileNameMatches(profiles, partial);
+      const none: ArgumentCompletion[] =
+        "none".startsWith(partial.toLowerCase())
+          ? [{ value: join("none"), label: "none", description: "no profile" }]
+          : [];
+      items = [...profileCompletions(names, join), ...none];
+    } else {
+      // Third token: scope.
+      items = ["global", "project"].flatMap((s) =>
+        s.startsWith(partial.toLowerCase())
+          ? [
+              {
+                value: join(s),
+                label: s,
+                description: SCOPE_DESCRIPTIONS[s],
+              },
+            ]
+          : [],
+      );
+    }
+  } else if (canonical === "rename") {
+    // First arg: existing name; second arg (new name) is free text.
+    if (committedCount <= 1) {
+      items = profileCompletions(profileNameMatches(profiles, partial), join);
+    }
+  } else if (PROFILE_NAME_SUBS.has(canonical)) {
+    const names = profileNameMatches(profiles, partial);
+    const none: ArgumentCompletion[] =
+      canonical === "use" && "none".startsWith(partial.toLowerCase())
+        ? [{ value: join("none"), label: "none", description: "no profile" }]
+        : [];
+    items = [...profileCompletions(names, join), ...none];
+  }
+  // create|new|add (new name is free text), list, unknown → items stays null.
+
+  if (!items || items.length === 0) return null;
+  const candidateTokens = items.map((i) => i.label);
+  if (suppressExactArgumentMatch(candidateTokens, partial)) return null;
+  return items;
+}

package/roles.ts

@@ -13,6 +13,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ArgumentCompletion } from "./utils.ts";
+import {
+  joinArgumentValue,
+  suppressExactArgumentMatch,
+} from "./utils.ts";
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -430,3 +435,140 @@ export function formatRolesForDisplay(config: RoleConfig): string {
   );
   return lines.join("\n");
 }
+
+// ── Argument completions (/role) ─────────────────────────────────────
+
+interface RoleSubMeta {
+  name: string;
+  /** Takes an argument → completion `value` carries a trailing space. */
+  takesArg: boolean;
+  label: string;
+  description: string;
+}
+
+const ROLE_SUBS: readonly RoleSubMeta[] = [
+  { name: "list", takesArg: false, label: "list", description: "show all roles" },
+  {
+    name: "show",
+    takesArg: false,
+    label: "show",
+    description: "show all roles (alias of list)",
+  },
+  {
+    name: "config",
+    takesArg: true,
+    label: "config",
+    description: "open the role config screen (picker)",
+  },
+  {
+    name: "set",
+    takesArg: true,
+    label: "set <role> <provider/model> [thinking]",
+    description: "configure one role's model",
+  },
+  {
+    name: "add",
+    takesArg: true,
+    label: "add <name> [provider/model] [thinking]",
+    description: "add a custom role",
+  },
+  {
+    name: "remove",
+    takesArg: true,
+    label: "remove <name>",
+    description: "remove a custom role",
+  },
+  {
+    name: "reset",
+    takesArg: false,
+    label: "reset",
+    description: "reset roles to defaults",
+  },
+  {
+    name: "use",
+    takesArg: true,
+    label: "use <role|auto>",
+    description: "activate one role for the whole workflow",
+  },
+];
+
+/**
+ * Argument completions for `/role` (pure; unit-tested in roles.test.ts).
+ *
+ * Follows the pi-tui full-argument contract (see `joinArgumentValue` and the
+ * /mcp extension): every returned `value` is the complete replacement for the
+ * typed argument text — `set planner opencode-go/muse-…`, never a bare token.
+ * Positional rules mirror the /role handler:
+ *   - `set` arg1 = existing role names, arg2 = model refs (`provider/id`,
+ *     null when `opts.models` is empty), arg3 = thinking levels;
+ *   - `use` = role names + `auto`;
+ *   - `remove` = role names;
+ *   - `add` arg1 is a NEW name → no completions.
+ * Returns null when nothing useful can be offered, including when the typed
+ * token is already an exact unique match (exact-match suppression — the
+ * dropdown closes so the first Enter submits).
+ */
+export function roleArgumentCompletions(
+  argumentPrefix: string,
+  opts: { roleNames: readonly string[]; models?: readonly string[] },
+): ArgumentCompletion[] | null {
+  const raw = String(argumentPrefix ?? "");
+  const join = (token: string) => joinArgumentValue(raw, token);
+
+  // ── Subcommand position: no whitespace typed yet ────────────────────
+  if (!raw.trim() || !/\s/.test(raw)) {
+    const lower = raw.trim().toLowerCase();
+    const matching = ROLE_SUBS.filter((s) => s.name.startsWith(lower));
+    if (matching.length === 0) return null;
+    return matching.map((s) => ({
+      value: s.takesArg ? `${s.name} ` : s.name,
+      label: s.label,
+      description: s.description,
+    }));
+  }
+
+  // ── Argument position ────────────────────────────────────────────────
+  const tokens = raw.trim().split(/\s+/).filter(Boolean);
+  const cmd = (tokens[0] ?? "").toLowerCase();
+  const endsWithWs = /\s$/.test(raw);
+  const committedCount = endsWithWs ? tokens.length : tokens.length - 1;
+  const partial = endsWithWs ? "" : (tokens[tokens.length - 1] ?? "");
+  const matchToken = (t: string) => t.toLowerCase().startsWith(partial.toLowerCase());
+
+  const roleNameItems = (): ArgumentCompletion[] =>
+    opts.roleNames.flatMap((n) =>
+      matchToken(n) ? [{ value: join(n), label: n }] : [],
+    );
+
+  let items: ArgumentCompletion[] | null = null;
+
+  if (cmd === "set") {
+    if (committedCount <= 1) {
+      items = roleNameItems();
+    } else if (committedCount === 2) {
+      items = (opts.models ?? []).flatMap((m) =>
+        matchToken(m) ? [{ value: join(m), label: m }] : [],
+      );
+    } else {
+      items = VALID_THINKING_LEVELS.flatMap((t) =>
+        matchToken(t) ? [{ value: join(t), label: t }] : [],
+      );
+    }
+  } else if (cmd === "use") {
+    items = [
+      ...roleNameItems(),
+      ...("auto".startsWith(partial.toLowerCase())
+        ? [{ value: join("auto"), label: "auto" }]
+        : []),
+    ];
+  } else if (cmd === "remove") {
+    items = roleNameItems();
+  }
+  // add (new name is free text), config, list/show, reset, unknown → null.
+
+  if (!items || items.length === 0) return null;
+  if (suppressExactArgumentMatch(items.map((i) => i.label), partial)) {
+    return null;
+  }
+  return items;
+}

package/utils.ts

@@ -1583,3 +1583,63 @@ export function renderReviewContextBlock(
   }
   return out;
 }
+
+// ── Slash-command argument completions (pi-tui contract) ─────────────
+//
+// `CombinedAutocompleteProvider.getSuggestions` (pi-tui dist/autocomplete.js)
+// passes `getArgumentCompletions(argumentText)` the ENTIRE typed argument
+// text after the command name and, on accept, `applyCompletion` replaces
+// that whole argument text with `item.value` (the slash-argument branch:
+// `newLine = beforePrefix + item.value`). So an argument-position item's
+// `value` must be the complete replacement — e.g. `"use <name>"`, never the
+// bare token. Pi's own /mcp extension follows this contract
+// (`value: `${action} ${name}``). `joinArgumentValue` is the single helper
+// that enforces it: it keeps every committed token and appends (or replaces
+// the last partial token with) `token`.
+
+/** One slash-command argument completion item (pi-tui `AutocompleteItem` shape). */
+export interface ArgumentCompletion {
+  value: string;
+  label: string;
+  description?: string;
+}
+
+/**
+ * Build the full-argument replacement `value` for a completion token.
+ *
+ * `prefix` is the typed argument text so far. Tokens separated by whitespace
+ * are "committed"; if `prefix` ends with whitespace the user is starting a
+ * fresh token, so `token` is appended — otherwise it replaces the trailing
+ * partial token. Pure; never throws.
+ *
+ *   joinArgumentValue("use Syn-De", "Syn-Deepseek-v4.1-Flash-Planner")
+ *     → "use Syn-Deepseek-v4.1-Flash-Planner"
+ *   joinArgumentValue("use ", "none") → "use none"
+ *   joinArgumentValue("", "list")     → "list"
+ */
+export function joinArgumentValue(prefix: string, token: string): string {
+  const raw = String(prefix ?? "");
+  const endsWithWs = /\s$/.test(raw);
+  const parts = raw.trim().split(/\s+/).filter(Boolean);
+  const committed = endsWithWs ? parts : parts.slice(0, -1);
+  return [...committed, token].join(" ");
+}
+
+/**
+ * Exact-match suppression for slash-command argument completions: when the
+ * token being typed (`partial`, "" while the prefix ends with whitespace)
+ * already equals the ONLY remaining candidate, return true so the completer
+ * yields null — pi's editor then closes the dropdown and the FIRST Enter
+ * submits instead of being consumed by the completion-accept handler
+ * (editor.js `tui.select.confirm`). Pure.
+ */
+export function suppressExactArgumentMatch(
+  candidates: readonly string[],
+  partial: string,
+): boolean {
+  if (!partial) return false;
+  return (
+    candidates.length === 1 &&
+    candidates[0].toLowerCase() === partial.toLowerCase()
+  );
+}