@selesai/code 0.13.9 → 0.13.11

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.11] - 2026-09-02
+
+### Added
+- **RPC rev-4 `get_skills` command.** New RPC command returning the resolved skill catalog (one entry per discovered skill with its effective enablement) plus the raw merged `global + project` `settings.skills` patterns, so hosts can mirror the TUI `/skills` toggle surface without reimplementing `isEnabledByOverrides` semantics. Exposed on the typed client as `RpcClient.getSkills()`.
+- **RPC `working` loader parity.** `ctx.ui.setWorkingMessage()`, `setWorkingVisible()`, and `setWorkingIndicator()` now emit a fire-and-forget `extension_ui_request {method: "working"}` (message/visible/frames/intervalMs patch fields) instead of no-oping in RPC mode, so the host can render the streaming loader row.
+- **Herdr agent-state extension.** New bundled extension that reports session/lifecycle state (`working`/`blocked`/`idle`) plus session references to the Herdr pane over `HERDR_SOCKET_PATH`. Instance state lives inside the factory so successor sessions after `/new`, fork, resume, or reload keep reporting; only the monotonic `reportSeq` stays module-level to satisfy Herdr's per-source sequence guard.
+
+### Fixed
+- **handoff-new no longer fails session creation.** The `setup` callback read the session name from the (already replaced) extension ctx, throwing the stale-ctx error and aborting `newSession` with "Failed to create session". The name is now captured before `newSession()` and passed into `setup` as a plain value; the session name still carries over as before.
+
+## [0.13.10] - 2026-09-02
+
+### Added
+- **RPC rev-3 interactive-TUI parity batch.** New RPC commands `navigate_tree`, `list_sessions`, `rename_session`, `delete_session`, and `set_session_models`; new option fields for `prompt.queueWhileCompacting`, `cycle_model.direction`, `get_available_models.refresh`, and theme passthrough for `export_html`/`share_gist`.
+
+### Changed
+- **handoff-new carries the session name.** The new session started by `/handoff-new` (and RPC `handoff_new`) now inherits the current session's name as its starting name.
+- **pi-subagents uses only built-in agents.** The bundled pi-subagents extension now ships only the built-in agents (`advisor`, `delegate`, `oracle`, `researcher`, `reviewer`, `scout`, `worker`) and drops the custom agent definitions and Claude Code / Codex / Cursor agent adapters, so subagents work in any host without external CLIs.
+
 ## [0.13.9] - 2026-09-01
 
 ### Changed

package/dist/core/agent-session.d.ts

@@ -108,6 +108,12 @@ export type AgentSessionEvent = Exclude<AgentEvent, {
     delta: string;
 } | {
     type: "image_captioning_start";
+} | {
+    type: "session_tree";
+    newLeafId: string | null;
+    oldLeafId: string | null;
+    summaryEntry?: BranchSummaryEntry | null;
+    fromExtension?: boolean;
 } | {
     type: "image_captioning_end";
     ok: boolean;

package/dist/core/agent-session.js

@@ -2793,14 +2793,16 @@ export class AgentSession {
             // Update agent state
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
-            // Emit session_tree event
-            await this._extensionRunner.emit({
+            // Emit session_tree event (extension runners + RPC stdout subscribers)
+            const treeEvent = {
                 type: "session_tree",
                 newLeafId: this.sessionManager.getLeafId(),
                 oldLeafId,
                 summaryEntry,
                 fromExtension: summaryText ? fromExtension : undefined,
-            });
+            };
+            await this._extensionRunner.emit(treeEvent);
+            this._emit(treeEvent);
             // Emit to custom tools
             return { editorText, cancelled: false, summaryEntry };
         }

package/dist/extensions/handoff-new.test.ts

@@ -138,11 +138,13 @@ describe("handoff-new extension", () => {
 		model?: any;
 		customResult?: string | null;
 		mode?: string;
+		sessionName?: string;
 	} = {}) {
-		const calls: { newSession: any; userMessage: string | null; notify: { msg: string; kind: string }[] } = {
+		const calls: { newSession: any; userMessage: string | null; notify: { msg: string; kind: string }[]; setupName: string | null } = {
 			newSession: null,
 			userMessage: null,
 			notify: [],
+			setupName: null,
 		};
 		const ctx: any = {
 			mode: opts.mode ?? "tui",
@@ -150,6 +152,7 @@ describe("handoff-new extension", () => {
 			sessionManager: {
 				getBranch: () => (opts.branch === undefined ? [userEntry("we decided to build X")] : opts.branch),
 				getSessionFile: () => "/tmp/old.json",
+				getSessionName: () => opts.sessionName ?? undefined,
 			},
 			modelRegistry: {
 				async getApiKeyAndHeaders() {
@@ -165,6 +168,12 @@ describe("handoff-new extension", () => {
 			},
 			async newSession(options: any) {
 				calls.newSession = options;
+				if (options?.setup) {
+					const mgr: any = { named: [] as string[] };
+					mgr.appendSessionInfo = (name: string) => mgr.named.push(name);
+					await options.setup(mgr);
+					calls.setupName = mgr.named.at(-1) ?? null;
+				}
 				if (options?.withSession) {
 					await options.withSession(ctx);
 				}
@@ -183,6 +192,20 @@ describe("handoff-new extension", () => {
 		expect(calls.newSession.cancelled).toBeUndefined();
 	});
 
+	it("session name carries over to the new session", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx({ sessionName: "db migration" });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.setupName).toBe("db migration");
+	});
+
+	it("no session name leaves the new session unnamed for auto-naming", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx({ sessionName: undefined });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.setupName).toBeNull();
+	});
+
 	it("no goal arg uses DEFAULT_GOAL", async () => {
 		const { commands } = createPiHarness();
 		const { ctx, calls } = createCtx();
@@ -275,6 +298,7 @@ describe("handoff-new extension", () => {
 			sessionManager: {
 				getBranch: () => [userEntry("we decided to build X")],
 				getSessionFile: () => "/tmp/old.json",
+				getSessionName: () => undefined,
 			},
 			modelRegistry: {
 				async getApiKeyAndHeaders() {
@@ -372,6 +396,7 @@ describe("handoff-new extension", () => {
 			sessionManager: {
 				getBranch: () => [userEntry("we decided to build X")],
 				getSessionFile: () => "/tmp/old.json",
+				getSessionName: () => undefined,
 			},
 			modelRegistry: {
 				async getApiKeyAndHeaders() {

package/dist/extensions/handoff-new.ts

@@ -108,8 +108,16 @@ async function handoffNew(args: string, ctx: ExtensionCommandContext) {
 		return;
 	}
 
+	// Read the name before newSession: the original ctx is invalidated once
+	// the session is replaced, so it cannot be read inside setup().
+	const sessionName = ctx.sessionManager.getSessionName();
+
 	const newSessionResult = await ctx.newSession({
 		parentSession: currentSessionFile,
+		// Carry the current session's name over to the new session as the starting point.
+		setup: (replacementManager) => {
+			if (sessionName) replacementManager.appendSessionInfo(sessionName);
+		},
 		withSession: async (replacementCtx) => {
 			await replacementCtx.sendUserMessage(result);
 		},

package/dist/extensions/herdr-agent-state.ts

@@ -0,0 +1,310 @@
+// adapted from herdr's pi integration (herdr/src/integration/assets/pi/herdr-agent-state.ts)
+// reports lifecycle state for selesai instead of pi: agent=selesai, source=herdr:selesai
+// HERDR_INTEGRATION_ID=selesai
+// HERDR_INTEGRATION_VERSION=2
+// @ts-nocheck
+//
+// Instance state lives inside the factory, not at module scope. Selesai caches
+// the extension module per cwd and re-invokes the factory for every session, so
+// a module-scoped `released`/`queuedState`/`sendInFlight` from a previous
+// session (handoff-new, auto-handoff, /new, resume, fork, reload) would make
+// every successor instance silently drop its state reports and leave the pane
+// stuck on the last reported state. Only the monotonic reportSeq stays
+// module-level: Herdr guards pane.report_agent per source by seq and drops
+// lower-seq reports, so the successor must never restart the counter below the
+// previous instance's high-water mark.
+
+import net from "node:net";
+
+const HERDR_ENV = process.env.HERDR_ENV;
+const socketPath = process.env.HERDR_SOCKET_PATH;
+const socketEndpoint =
+  process.platform === "win32" && socketPath ? `\\\\.\\pipe\\${socketPath}` : socketPath;
+const paneId = process.env.HERDR_PANE_ID;
+const source = "herdr:selesai";
+
+function enabled() {
+  return HERDR_ENV === "1" && !!socketPath && !!paneId;
+}
+
+function sendRequestAttempt(request: unknown, timeoutMs: number): Promise<boolean> {
+  if (!enabled()) {
+    return Promise.resolve(true);
+  }
+
+  return new Promise((resolve) => {
+    let done = false;
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    const finish = (delivered: boolean) => {
+      if (done) return;
+      done = true;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      socket.destroy();
+      resolve(delivered);
+    };
+
+    const socket = net.createConnection(socketEndpoint!);
+    socket.on("error", () => finish(false));
+    socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+    socket.on("data", () => finish(true));
+    socket.on("end", () => finish(false));
+    timeout = setTimeout(() => finish(false), timeoutMs);
+    timeout.unref?.();
+  });
+}
+
+async function sendRequest(request: unknown): Promise<void> {
+  if (await sendRequestAttempt(request, 500)) {
+    return;
+  }
+  await sendRequestAttempt(request, 1500);
+}
+
+type AgentState = "working" | "blocked" | "idle";
+
+type QueuedState = {
+  state: AgentState;
+  message?: string;
+  seq: number;
+};
+
+// Monotonic across all extension instances in this process. A per-session
+// restart below the previous instance's high-water mark would be dropped by
+// Herdr's per-source seq guard.
+let reportSeq = Date.now() * 1000;
+
+function nextReportSeq(): number {
+  reportSeq = Math.max(reportSeq + 1, Date.now() * 1000);
+  return reportSeq;
+}
+
+export default function (pi) {
+  if (!enabled()) {
+    return;
+  }
+
+  let currentAgentSessionId: string | undefined;
+  let currentAgentSessionPath: string | undefined;
+  let sendInFlight = false;
+  let queuedState: QueuedState | undefined;
+  let activeDrain: Promise<void> = Promise.resolve();
+  let released = false;
+  let agentActive = false;
+  let blockedCount = 0;
+  let blockedMessage: string | undefined;
+  let lastState: AgentState | undefined;
+  let lastMessage: string | undefined;
+  let rootSession = false;
+
+  function updateSessionRef(ctx: any): void {
+    try {
+      const file = ctx?.sessionManager?.getSessionFile?.();
+      currentAgentSessionPath =
+        typeof file === "string" && file.startsWith("/") ? file : undefined;
+    } catch {
+      currentAgentSessionPath = undefined;
+    }
+
+    try {
+      const id = ctx?.sessionManager?.getSessionId?.();
+      currentAgentSessionId = typeof id === "string" && id.length > 0 ? id : undefined;
+    } catch {
+      currentAgentSessionId = undefined;
+    }
+  }
+
+  function withSessionRef(params: Record<string, unknown>): Record<string, unknown> {
+    if (currentAgentSessionPath) {
+      return { ...params, agent_session_path: currentAgentSessionPath };
+    }
+    if (currentAgentSessionId) {
+      return { ...params, agent_session_id: currentAgentSessionId };
+    }
+    return params;
+  }
+
+  function currentSessionRef(): Record<string, unknown> | undefined {
+    if (currentAgentSessionPath) {
+      return { agent_session_path: currentAgentSessionPath };
+    }
+    if (currentAgentSessionId) {
+      return { agent_session_id: currentAgentSessionId };
+    }
+    return undefined;
+  }
+
+  function reportSession(sessionStartSource?: string): Promise<void> {
+    const sessionRef = currentSessionRef();
+    if (!sessionRef) {
+      return Promise.resolve();
+    }
+
+    return sendRequest({
+      id: `${source}:session:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+      method: "pane.report_agent_session",
+      params: {
+        pane_id: paneId,
+        source,
+        agent: "selesai",
+        seq: nextReportSeq(),
+        session_start_source: sessionStartSource,
+        ...sessionRef,
+      },
+    });
+  }
+
+  function sendState(state: AgentState, message?: string, seq = nextReportSeq()): Promise<void> {
+    return sendRequest({
+      id: `${source}:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+      method: "pane.report_agent",
+      params: withSessionRef({
+        pane_id: paneId,
+        source,
+        agent: "selesai",
+        state,
+        message,
+        seq,
+      }),
+    });
+  }
+
+  function queueState(state: AgentState, message?: string): void {
+    if (released) {
+      // The pane was released on quit; a late report would reclaim it and
+      // leave Herdr showing an agent that already exited.
+      return;
+    }
+    queuedState = { state, message, seq: nextReportSeq() };
+    if (!sendInFlight) {
+      activeDrain = drainStateQueue();
+    }
+  }
+
+  async function drainStateQueue(): Promise<void> {
+    if (sendInFlight) {
+      return;
+    }
+
+    sendInFlight = true;
+    try {
+      while (queuedState) {
+        const next = queuedState;
+        queuedState = undefined;
+        await sendState(next.state, next.message, next.seq);
+      }
+    } finally {
+      sendInFlight = false;
+      if (queuedState) {
+        activeDrain = drainStateQueue();
+      }
+    }
+  }
+
+  async function releaseAgent(): Promise<void> {
+    // Stop new reports, drop anything still queued, and wait for the in-flight
+    // send to finish so the release is the last write on the wire; a report
+    // landing after the release would reclaim the pane.
+    released = true;
+    queuedState = undefined;
+    await activeDrain.catch(() => undefined);
+    return sendRequest({
+      id: `${source}:release:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+      method: "pane.release_agent",
+      params: {
+        pane_id: paneId,
+        source,
+        agent: "selesai",
+        seq: nextReportSeq(),
+      },
+    });
+  }
+
+  function desiredState() {
+    if (blockedCount > 0) {
+      return { state: "blocked" as const, message: blockedMessage };
+    }
+    if (agentActive) {
+      return { state: "working" as const, message: undefined };
+    }
+    return { state: "idle" as const, message: undefined };
+  }
+
+  function publishState(force = false) {
+    const next = desiredState();
+    if (!force && next.state === lastState && next.message === lastMessage) {
+      return;
+    }
+    lastState = next.state;
+    lastMessage = next.message;
+    queueState(next.state, next.message);
+  }
+
+  pi.events.on("herdr:blocked", (data) => {
+    if (!rootSession) {
+      return;
+    }
+    if (!data?.active) {
+      blockedCount = Math.max(0, blockedCount - 1);
+      if (blockedCount === 0) {
+        blockedMessage = undefined;
+      }
+      publishState();
+      return;
+    }
+
+    blockedCount += 1;
+    blockedMessage = data.label;
+    publishState();
+  });
+
+  pi.on("session_start", async (event, ctx) => {
+    // TUI only: RPC/JSON/print modes are headless (no PTY herdr can display),
+    // and RPC still reports hasUI=true, so mode is the reliable gate.
+    if (ctx?.mode !== "tui") {
+      return;
+    }
+    rootSession = true;
+    updateSessionRef(ctx);
+    await reportSession(event?.reason);
+    // A reload can replace this extension mid-run without emitting another agent_start.
+    agentActive = ctx?.isIdle?.() === false;
+    publishState(true);
+  });
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (!rootSession) {
+      return;
+    }
+    updateSessionRef(ctx);
+    void reportSession();
+    agentActive = true;
+    publishState();
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (!rootSession || ctx?.isIdle?.() !== true) {
+      return;
+    }
+
+    agentActive = false;
+    publishState();
+  });
+
+  pi.on("session_shutdown", async (event) => {
+    if (!rootSession) {
+      return;
+    }
+    if (event?.reason !== "quit") {
+      // new/resume/fork/reload: a successor instance in this same pane
+      // re-reports immediately. Releasing here races that report, and a
+      // release landing after the successor's report clears the pane.
+      // Silence this instance so no stale queued report lands around it.
+      released = true;
+      queuedState = undefined;
+      return;
+    }
+    await releaseAgent();
+  });
+}

package/dist/extensions/package.json

@@ -15,6 +15,7 @@
 			"./question",
 			"./grep-app",
 			"./handoff-new.ts",
+			"./herdr-agent-state.ts",
 			"./inline-skills.ts",
 			"./rtk.ts",
 			"./tokenin-onboarding.ts",

package/dist/extensions/pi-subagents/README.md

@@ -62,12 +62,6 @@ The extension ships with agents you can use immediately:
 | `reviewer` | Code review and small fixes against the task/plan, tests, edge cases, and simplicity. |
 | `oracle` | A second opinion before acting. Challenges assumptions without editing. |
 | `delegate` | A lightweight general delegate that behaves close to the parent session. |
-| `architect` | Read-only architecture and implementation planning. |
-| `builder` | Mutation-capable scoped implementation. |
-| `commentator` | Read-only evidence-based review. |
-| `explorer` | Read-only local codebase reconnaissance. |
-| `recapper` | Read-only handoff and context synthesis. |
-| `codex-exec`, `claude-code`, `cursor-agent` | External CLI runners with their own adapter contracts. |
 
 Rule of thumb: `scout` before you understand the code, `researcher` before you trust external facts, `worker` to implement, `reviewer` to check, and `oracle` when the decision itself feels risky.
 

package/dist/extensions/pi-subagents/docs/agents.md

@@ -59,120 +59,7 @@ The Pi async run remains the source of truth for status, artifacts, wake/wait, m
 
 External CLI agents use their own runner contract. Do not pass native Pi child options such as model override, structured output, acceptance/agent contract, tool budgets, fast mode, fork context, skills, or native Pi tools unless the adapter explicitly implements them.
 
-The built-in `codex-exec` and `codex-exec-writer` profiles are the supported Codex one-shot modes. Both require an installed and authenticated Codex CLI. The adapters own `codex exec --json` argv with ignored user config and rules, ephemeral sessions, approval policy `never`, and a final-message artifact.
-
-| Profile | Access | Sandbox |
-|---|---|---|
-| `codex-exec` | Read-only analysis | `read-only` |
-| `codex-exec-writer` | Explicit workspace edits | `workspace-write` |
-
-Neither adapter uses full access, approval or sandbox bypasses, automatic approval review, or additional writable roots. User profiles cannot add argv. The `codex-exec` selection identity is reserved for the read-only adapter.
-
-Run it asynchronously:
-
-```text
-Use codex-exec to analyze this change without editing files.
-
-Use codex-exec-writer to make the requested workspace changes.
-```
-
-The adapter validates `codex --version` and `codex exec --help` only when a run launches. Discovery, list, status, and native Pi launches do not probe Codex. JSONL, stderr, and stdout are untrusted. A run succeeds only after bounded valid JSONL contains one `turn.completed` event and the bounded final-message artifact is present.
-
-Maintainers can collect real smoke evidence without making it part of the normal test suite:
-
-```bash
-SELESAI_SUBAGENTS_CODEX_EXEC_SMOKE=1 \
-SELESAI_SUBAGENTS_CODEX_EXEC_SMOKE_REPORT=/tmp/pi-subagents-codex-exec-smoke.json \
-node --experimental-strip-types --import ./test/support/register-loader.mjs \
-  --test test/integration/codex-exec-smoke.test.ts
-
-SELESAI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE=1 \
-SELESAI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE_REPORT=/tmp/pi-subagents-codex-exec-writer-smoke.json \
-node --experimental-strip-types --import ./test/support/register-loader.mjs \
-  --test test/integration/codex-exec-writer-smoke.test.ts
-```
-
-The read-only smoke must report `writeCanaryExists: false`. The writer smoke must report `writeCanaryMatches: true`. Both reports include startup duration and terminal proof without raw protocol output, prompts, or credentials.
-
-The built-in `claude-code` and `claude-code-writer` profiles are the supported Claude Code one-shot modes. Both require an installed Claude Code CLI that is already authenticated through its normal local login. Claude Code 2.1.150 needs the user setting source for normal OAuth/keychain authentication, so both adapters load user settings but exclude project and local settings. User-level Claude Code settings and hooks are therefore an operator-trusted prerequisite. Review or disable unsafe user hooks before using either profile.
-
-| Profile | Access | Permission mode | Built-in tools |
-|---|---|---|---|
-| `claude-code` | Handoff-only read-only advice | `plan` | none |
-| `claude-code-writer` | Explicit workspace file edits | `acceptEdits` | `Read,Write,Edit,Glob,Grep` |
-
-Both adapters own `claude -p` argv with stream JSON, strict empty MCP configuration, user-only setting sources, no session persistence, disabled slash commands, and disabled Chrome integration. The writer mode does not include Bash or any permission bypass. Neither mode uses `--bare`, which does not read normal OAuth/keychain authentication. Neither mode requires `--safe-mode`, which is absent from the installed 2.1.150 help. User profiles cannot add argv. Selecting the code-owned `claude-code-writer` adapter identity is the only way to opt into its write tools; the read-only adapter cannot be widened with user argv.
-
-Run it asynchronously:
-
-```text
-Use claude-code to analyze this handoff without editing files.
-
-Use claude-code-writer to make the requested file changes.
-```
-
-The adapter validates `claude --version` and `claude --help` only when a run launches. Discovery, list, status, and native Pi launches do not probe Claude Code or authentication. JSONL, stderr, and stdout are untrusted. A run succeeds only after bounded valid JSONL contains exactly one successful terminal `result` with non-empty final text. Missing or revoked local authentication, limit stops, malformed JSON, duplicate terminal results, and EOF before a terminal result fail closed.
-
-Maintainers can opt in to separate read-only and writer canaries:
-
-```bash
-SELESAI_SUBAGENTS_CLAUDE_CODE_SMOKE=1 \
-SELESAI_SUBAGENTS_CLAUDE_CODE_SMOKE_REPORT=/tmp/pi-subagents-claude-code-smoke.json \
-node --experimental-strip-types --import ./test/support/register-loader.mjs \
-  --test test/integration/claude-code-smoke.test.ts
-
-SELESAI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE=1 \
-SELESAI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE_REPORT=/tmp/pi-subagents-claude-code-writer-smoke.json \
-node --experimental-strip-types --import ./test/support/register-loader.mjs \
-  --test test/integration/claude-code-writer-smoke.test.ts
-```
-
-Both smoke reports record `authentication: "existing-cli-required"`, `settingSources: "user"`, and `userSettingsTrust: "required"` without recording credential details. For read-only, confirm `terminalState` is `completed` and `writeCanaryExists` is `false`. For writer, confirm `terminalState` is `completed` and `writeCanaryMatches` is `true`. `durationMs` records cold process time. If authentication is missing or revoked, repair the normal local Claude Code login and rerun the smoke. Reports do not contain raw protocol output or credentials.
-
-The built-in `cursor-agent` and `cursor-agent-writer` profiles are the supported Cursor CLI one-shot modes. Both require an installed Cursor CLI and either `CURSOR_API_KEY` or an existing local login.
-
-| Profile | Access | Cursor mode |
-|---|---|---|
-| `cursor-agent` | Read-only analysis | `ask` |
-| `cursor-agent-writer` | Explicit workspace edits | non-interactive print |
-
-Both adapters use stream JSON, the enabled sandbox, and the primary workspace. They write the full handoff to a private `0600` file in a private temporary directory. Process argv contains only a short instruction with that path. The temporary directory is added as a workspace root only when it is outside the primary workspace. The prompt file and directory are removed after completion, failure, or stop.
-
-The adapters do not pass force, yolo, auto-review, MCP approval, plugin, session resume, continue, worktree, or workspace trust flags. User profiles cannot add argv or workspace roots. The `cursor-agent` selection identity is reserved for the read-only adapter.
-
-Launch preflight validates `cursor-agent --version` and `cursor-agent --help` only when a run starts. Discovery, list, status, and native Pi launches do not execute Cursor or probe authentication. A run succeeds only when bounded valid JSONL ends with one successful `result` event that has non-empty final text. Error events, failed results, malformed JSON, output after the terminal event, and EOF before a result fail closed.
-
-These headless smokes rely on saved workspace trust. Cursor documents no passive command that checks workspace trust, so the smoke cannot verify it before launch. The operator must use Cursor's interactive trust flow for the exact disposable workspace and the exact derived prompt directory, `<state-root>/external-0.cursor-prompt`. Keep that prompt directory after the trust step. It must be empty, owned by the operator who runs the smoke, and must not be a symlink. The harness preserves this directory but creates its private handoff with exclusive `0600` access and removes the handoff after every run. Repeat the trust setup if either exact path changes.
-
-The smoke requires two existing, separate operator-managed directories and an explicit disposable-workspace attestation:
-
-```bash
-export SELESAI_SUBAGENTS_CURSOR_SMOKE_WORKSPACE=/tmp/pi-subagents-cursor-smoke-workspace
-export SELESAI_SUBAGENTS_CURSOR_SMOKE_STATE_ROOT=/tmp/pi-subagents-cursor-smoke-state
-export SELESAI_SUBAGENTS_CURSOR_SMOKE_DISPOSABLE=1
-mkdir -p "$SELESAI_SUBAGENTS_CURSOR_SMOKE_WORKSPACE" "$SELESAI_SUBAGENTS_CURSOR_SMOKE_STATE_ROOT"
-mkdir -p "$SELESAI_SUBAGENTS_CURSOR_SMOKE_STATE_ROOT/external-0.cursor-prompt"
-```
-
-Do not place a file at `pi-subagents-cursor-write-canary.txt` in the workspace or any file, including `handoff.txt`, in the prompt directory. The harness refuses the pre-existing canary and any non-empty prompt directory. It does not delete the workspace, state root, or operator-owned prompt directory. It removes only its canary and private handoff file.
-
-Maintainers can then run separate read-only and writer canaries:
-
-```bash
-SELESAI_SUBAGENTS_CURSOR_AGENT_SMOKE=1 \
-SELESAI_SUBAGENTS_CURSOR_AGENT_SMOKE_REPORT=/tmp/pi-subagents-cursor-agent-smoke.json \
-node --experimental-strip-types --import ./test/support/register-loader.mjs \
-  --test test/integration/cursor-agent-smoke.test.ts
-
-SELESAI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE=1 \
-SELESAI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE_REPORT=/tmp/pi-subagents-cursor-agent-writer-smoke.json \
-node --experimental-strip-types --import ./test/support/register-loader.mjs \
-  --test test/integration/cursor-agent-writer-smoke.test.ts
-```
-
-The read-only smoke must report `writeCanaryExists: false`. The writer smoke must report `writeCanaryMatches: true`. Both reports record `workspaceTrust: "operator-managed-saved"`, confirm that the external prompt root was added, and include startup duration and terminal proof without raw protocol output, prompts, or credentials. A trust-required error remains terminal; the harness does not retry with a trust, force, or yolo flag.
-
-Native `oracle` runs inside Pi and can use its configured read tools. The Claude profiles send the assembled prompt to the local Claude Code CLI through stdin. An external-job agent sends the assembled prompt to its registered provider. Provider options and a prompt digest are persisted in Pi run state. The prompt text is delivered through the local host bridge to the provider and is not stored in the public result payload. Do not place secrets in advisory prompts unless the target provider is approved to receive them.
+The bundled code-owned external adapters (`codex-exec`, `claude-code`, `cursor-agent` and their writer variants) were removed in favor of the built-in Pi agents. A custom agent with `runner.type: external-cli` (no adapter) still runs the generic one-shot stdin contract: `command` is executed with the prompt on stdin, and the bounded final output is treated as untrusted text.
 
 ### External-job state table
 

package/dist/extensions/pi-subagents/src/agents/builtin-names.ts

@@ -1,20 +1,9 @@
 export const BUILTIN_AGENT_NAMES = [
-	"architect",
 	"advisor",
-	"builder",
-	"claude-code",
-	"claude-code-writer",
-	"codex-exec",
-	"codex-exec-writer",
-	"commentator",
-	"cursor-agent",
-	"cursor-agent-writer",
 	"delegate",
-	"explorer",
 	"oracle",
-	"recapper",
 	"researcher",
 	"reviewer",
 	"scout",
 	"worker",
-] as const;
+] as const;

package/dist/extensions/pi-subagents/src/extension/tool-description.ts

@@ -5,7 +5,7 @@ import { getAgentDir, getProjectConfigDir } from "../shared/utils.ts";
 
 const CUSTOM_TOOL_DESCRIPTION_FILE = "subagent-tool-description.md";
 const CUSTOM_TOOL_DESCRIPTION_MAX_BYTES = 50 * 1024;
-const EXTERNAL_CLI_RUNNER_GUIDANCE = "External CLI agents (codex-exec, codex-exec-writer, claude-code, claude-code-writer, cursor-agent, cursor-agent-writer) use their own runner contract and do not support native Pi child options such as model override, structured output, acceptance/agent contract, tool budget, fast mode, fork context, skills, or native Pi tools unless the runner explicitly implements them.";
+const EXTERNAL_CLI_RUNNER_GUIDANCE = "External CLI agents (custom external-cli runners; there are no bundled adapter agents) use their own runner contract and do not support native Pi child options such as model override, structured output, acceptance/agent contract, tool budget, fast mode, fork context, skills, or native Pi tools unless the runner explicitly implements them.";
 const WORKFLOW_RESUME_KEY_GUIDANCE = "Each workflow key identifies one result lane: use a new stable workflow key for every distinct retained resume pass; same-key calls are reused only when launch parameters are identical, and incompatible parameters are rejected.";
 const WORKFLOW_OUTPUT_BINDING_GUIDANCE = "For durable workflow child files, set output on runs.run/runs.all; task filename prose is not an output declaration, and return the child's outputReference, outputPathMapping, or artifactPaths instead of inventing a literal path.";
 const WORKFLOW_LANES_GUIDANCE = "For bounded parallel sequential chains, use runs.lanes([{key,stages:[{key,agent,task},{key,resume:'previous',task},...]}]); first stages run together, later stages sequence per lane, and the bounded board reports lane-local failures. Only an explicit structuredOutput.verdict === 'blocked' blocks a successful stage; reviewer prose is not parsed.";