@selesai/code 0.3.10 → 0.5.0

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

@@ -28,11 +28,10 @@ function createPiHarness() {
 	return { commands };
 }
 
-test("registers both handoff-new and handover-new commands", () => {
+test("registers handoff-new only", () => {
 	const { commands } = createPiHarness();
 	assert.ok(commands.has("handoff-new"));
-	assert.ok(commands.has("handover-new"));
-	assert.equal(commands.get("handoff-new")?.handler, commands.get("handover-new")?.handler);
+	assert.equal(commands.has("handover-new"), false);
 });
 
 // ---- pure helpers ----
@@ -106,7 +105,6 @@ test("buildAiContext: embeds conversation + goal into one user turn", () => {
 function createCtx(opts: {
 	branch?: SessionEntry[];
 	model?: any;
-	editorResult?: string;
 	customResult?: string | null;
 	mode?: string;
 } = {}) {
@@ -130,7 +128,6 @@ function createCtx(opts: {
 		ui: {
 			notify: (msg: string, kind: string) => calls.notify.push({ msg, kind }),
 			custom: async <T>(_factory: any): Promise<T> => (opts.customResult === undefined ? "HANDOFF PROMPT" : opts.customResult) as unknown as T,
-			editor: async (_title: string, prefill?: string) => ("editorResult" in opts ? opts.editorResult : prefill),
 			setEditorText: (text: string) => {
 				calls.editorText = text;
 			},
@@ -196,14 +193,6 @@ test("custom null (cancelled) does not open new session", async () => {
 	assert.ok(calls.notify.some((n) => /Cancelled/.test(n.msg)));
 });
 
-test("editor cancel does not open new session", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx({ editorResult: undefined });
-	await commands.get("handoff-new")!.handler("goal", ctx);
-	assert.equal(calls.newSession, null);
-	assert.ok(calls.notify.some((n) => /Cancelled/.test(n.msg)));
-});
-
 // sanity: DEFAULT_GOAL exported and non-empty (used by handler)
 test("DEFAULT_GOAL is non-empty", () => {
 	assert.ok(DEFAULT_GOAL.length > 0);

package/dist/extensions/handoff-new.ts

@@ -1,15 +1,14 @@
 /**
  * /handoff-new — generate a handoff prompt and open a clean new session with
- * that content as the editable first prompt (editor text, not hidden system
+ * that content as the first unsent prompt (editor text, not hidden system
  * prompt). Sibling of examples/extensions/handoff.ts, adapted to this repo's
  * import conventions and reduced to the one thing that ships.
  *
  * Usage:
  *   /handoff-new continue implementing the workflow fix
- *   /handover-new ship plan 2
  *
- * If no goal argument is given, a default goal is used. The generated text is
- * shown in the editor for review before the user submits it.
+ * If no goal argument is given, a default goal is used. The new session opens
+ * with the generated text in its editor; the user can change it before submit.
  */
 
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
@@ -17,14 +16,15 @@ import { complete, type Context } from "@earendil-works/pi-ai/compat";
 import type { ExtensionAPI, ExtensionCommandContext, SessionEntry } from "@selesai/code";
 import { BorderedLoader, convertToLlm, serializeConversation } from "@selesai/code";
 
-const SYSTEM_PROMPT = `You are a context transfer assistant. Given a conversation history and the user's goal for a new thread, generate a focused prompt that:
+const SYSTEM_PROMPT = `Write a handoff document summarising the current conversation so a fresh agent can continue the work. Save to the temporary directory of the user's OS - not the current workspace.
 
-1. Summarizes relevant context from the conversation (decisions made, approaches taken, key findings)
-2. Lists any relevant files that were discussed or modified
-3. Clearly states the next task based on the user's goal
-4. Is self-contained - the new thread should be able to proceed without the old conversation
+Include a "suggested skills" section in the document, which suggests skills that the agent should invoke.
 
-Format your response as a prompt the user can send to start the new thread. Be concise but include all necessary context. Do not include any preamble like "Here's the prompt" - just output the prompt itself.`;
+Do not duplicate content already captured in other artifacts (PRDs, plans, ADRs, issues, commits, diffs). Reference them by path or URL instead.
+
+Redact any sensitive information, such as API keys, passwords, or personally identifiable information.
+
+If the user passed arguments, treat them as a description of what the next session will focus on and tailor the doc accordingly.`;
 
 export const DEFAULT_GOAL = "Continue the previous session from this handoff.";
 
@@ -85,13 +85,10 @@ export function buildAiContext(conversationText: string, goal: string): Context
 }
 
 export default function (pi: ExtensionAPI) {
-	// ponytail: single handler behind two command names; no separate config.
-	for (const name of ["handoff-new", "handover-new"]) {
-		pi.registerCommand(name, {
-			description: "Generate a handoff prompt and open a clean new session with it as the first draft",
-			handler: handoffNew,
-		});
-	}
+	pi.registerCommand("handoff-new", {
+		description: "Generate a handoff prompt and open a clean new session with it as the first draft",
+		handler: handoffNew,
+	});
 }
 
 async function handoffNew(args: string, ctx: ExtensionCommandContext) {
@@ -151,17 +148,11 @@ async function handoffNew(args: string, ctx: ExtensionCommandContext) {
 		return;
 	}
 
-	const editedPrompt = await ctx.ui.editor("Edit handoff prompt", result);
-	if (editedPrompt === undefined) {
-		ctx.ui.notify("Cancelled", "info");
-		return;
-	}
-
-	// Editor text, NOT a hidden system prompt: the user reviews and submits.
+	// Editor text, NOT a hidden system prompt: the user can edit before submit.
 	const newSessionResult = await ctx.newSession({
 		parentSession: currentSessionFile,
 		withSession: async (replacementCtx) => {
-			replacementCtx.ui.setEditorText(editedPrompt);
+			replacementCtx.ui.setEditorText(result);
 			replacementCtx.ui.notify("Handoff ready. Submit when ready.", "info");
 		},
 	});

package/dist/extensions/package.json

@@ -6,6 +6,7 @@
 	"pi": {
 		"extensions": [
 			"./copy-turn.ts",
+			"./context-compaction-reminder.ts",
 			"./tool-error-autofix.ts",
 			"./question",
 			"./handoff-new.ts",

package/dist/extensions/pi-powerline-footer/index.ts

@@ -62,6 +62,7 @@ import {
   generateVibesBatch,
 } from "./working-vibes.ts";
 import { setupTpsTracker } from "./tps.ts";
+import { readAsyncSubagentUsage, readSubagentToolResultUsage } from "./session-usage.ts";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Configuration
@@ -928,6 +929,7 @@ export default function powerlineFooter(pi: ExtensionAPI) {
   let getThinkingLevelFn: (() => string) | null = null;
   let currentThinkingLevel: string | null = null;
   let liveAssistantUsage: SessionAssistantUsage | null = null;
+  const completedAsyncSubagentUsage = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }>();
   let isStreaming = false;
   let tuiRef: any = null;
   let restoreFooterStatusRepaintHook: (() => void) | null = null;
@@ -1181,6 +1183,7 @@ export default function powerlineFooter(pi: ExtensionAPI) {
     lastUserPrompt = "";
     isStreaming = false;
     liveAssistantUsage = null;
+    completedAsyncSubagentUsage.clear();
     stashedEditorText = null;
 
     const settings = readSettings(ctx.cwd);
@@ -1222,6 +1225,7 @@ export default function powerlineFooter(pi: ExtensionAPI) {
 
   pi.on("session_shutdown", async () => {
     sessionGeneration++;
+    completedAsyncSubagentUsage.clear();
     dismissWelcomeOverlay?.();
     dismissWelcomeOverlay = null;
     welcomeHeaderActive = false;
@@ -1246,6 +1250,16 @@ export default function powerlineFooter(pi: ExtensionAPI) {
     resetLayoutCache();
   });
 
+  pi.events.on("subagent:async-complete", (event) => {
+    const completed = readAsyncSubagentUsage(event);
+    const sessionId = currentCtx?.sessionManager?.getSessionId?.();
+    if (!completed || !sessionId || completed.sessionId !== sessionId) return;
+
+    completedAsyncSubagentUsage.set(completed.runId, completed.usage);
+    layoutDirty = true;
+    requestImmediateStatusRender({ deferDuringTyping: false });
+  });
+
   // Check if a bash command might change git branch
   const mightChangeGitBranch = (cmd: string): boolean => {
     const gitBranchPatterns = [
@@ -1256,7 +1270,12 @@ export default function powerlineFooter(pi: ExtensionAPI) {
   };
 
   // Invalidate git status on file changes, trigger re-render on potential branch changes
-  pi.on("tool_result", async (event) => {
+  pi.on("tool_result", async (event, ctx) => {
+    if (event.toolName === "subagent") {
+      currentCtx = ctx;
+      layoutDirty = true;
+      requestImmediateStatusRender({ deferDuringTyping: false });
+    }
     if (event.toolName === "write" || event.toolName === "edit") {
       invalidateGitStatus();
     }
@@ -2051,7 +2070,21 @@ export default function powerlineFooter(pi: ExtensionAPI) {
         thinkingLevelFromSession = e.thinkingLevel;
       }
 
-      if (e.type !== "message" || !isSessionAssistantMessage(e.message)) {
+      if (e.type !== "message") {
+        continue;
+      }
+
+      const subagentUsage = readSubagentToolResultUsage(e.message);
+      if (subagentUsage) {
+        input += subagentUsage.input;
+        output += subagentUsage.output;
+        cacheRead += subagentUsage.cacheRead;
+        cacheWrite += subagentUsage.cacheWrite;
+        cost += subagentUsage.cost;
+        continue;
+      }
+
+      if (!isSessionAssistantMessage(e.message)) {
         continue;
       }
 
@@ -2069,6 +2102,14 @@ export default function powerlineFooter(pi: ExtensionAPI) {
       }
     }
 
+    for (const subagentUsage of completedAsyncSubagentUsage.values()) {
+      input += subagentUsage.input;
+      output += subagentUsage.output;
+      cacheRead += subagentUsage.cacheRead;
+      cacheWrite += subagentUsage.cacheWrite;
+      cost += subagentUsage.cost;
+    }
+
     // Calculate context percentage.
     const latestUsage = isStreaming ? liveAssistantUsage ?? lastAssistant?.usage : lastAssistant?.usage;
     const coreContextUsage = isStreaming && liveAssistantUsage ? null : readCoreContextUsage(ctx);

package/dist/extensions/pi-powerline-footer/session-usage.ts

@@ -0,0 +1,44 @@
+import type { UsageStats } from "./types.ts";
+
+type RecordLike = Record<string, unknown>;
+
+function isRecord(value: unknown): value is RecordLike {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function finiteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+/**
+ * Extract the aggregate usage reported by a completed foreground subagent run.
+ * Child agents use separate sessions, so their assistant messages are not in
+ * the parent session branch. The parent records this aggregate on its
+ * `subagent` tool result instead.
+ */
+function readUsage(value: unknown): UsageStats | null {
+  if (!isRecord(value)) return null;
+
+  const { input, output, cacheRead, cacheWrite, cost } = value;
+  if (![input, output, cacheRead, cacheWrite, cost].every(finiteNumber)) return null;
+
+  return { input, output, cacheRead, cacheWrite, cost };
+}
+
+export function readSubagentToolResultUsage(message: unknown): UsageStats | null {
+  if (!isRecord(message) || message.role !== "toolResult" || message.toolName !== "subagent") {
+    return null;
+  }
+
+  const details = isRecord(message.details) ? message.details : null;
+  return readUsage(details?.totalChildUsage);
+}
+
+/** Read usage emitted when an asynchronous subagent run completes. */
+export function readAsyncSubagentUsage(event: unknown): { runId: string; sessionId: string; usage: UsageStats } | null {
+  if (!isRecord(event) || typeof event.sessionId !== "string") return null;
+
+  const runId = typeof event.runId === "string" ? event.runId : typeof event.id === "string" ? event.id : null;
+  const usage = readUsage(event.totalChildUsage);
+  return runId && usage ? { runId, sessionId: event.sessionId, usage } : null;
+}

package/dist/extensions/pi-powerline-footer/tests/session-usage.test.ts

@@ -0,0 +1,47 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readAsyncSubagentUsage, readSubagentToolResultUsage } from "../session-usage.ts";
+
+test("reads all completed subagent usage from a parent tool result", () => {
+  assert.deepEqual(
+    readSubagentToolResultUsage({
+      role: "toolResult",
+      toolName: "subagent",
+      details: {
+        totalChildUsage: {
+          input: 120,
+          output: 34,
+          cacheRead: 56,
+          cacheWrite: 7,
+          cost: 0.123,
+          turns: 2,
+        },
+      },
+    }),
+    { input: 120, output: 34, cacheRead: 56, cacheWrite: 7, cost: 0.123 },
+  );
+});
+
+test("reads asynchronous completion usage", () => {
+  assert.deepEqual(
+    readAsyncSubagentUsage({
+      id: "async-123",
+      sessionId: "parent-session",
+      totalChildUsage: { input: 20, output: 8, cacheRead: 13, cacheWrite: 0, cost: 0.02 },
+    }),
+    {
+      runId: "async-123",
+      sessionId: "parent-session",
+      usage: { input: 20, output: 8, cacheRead: 13, cacheWrite: 0, cost: 0.02 },
+    },
+  );
+});
+
+test("does not treat other tool results or malformed usage as child usage", () => {
+  assert.equal(readSubagentToolResultUsage({ role: "toolResult", toolName: "bash", details: {} }), null);
+  assert.equal(readSubagentToolResultUsage({
+    role: "toolResult",
+    toolName: "subagent",
+    details: { totalChildUsage: { input: 1, output: 2 } },
+  }), null);
+});

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

@@ -155,7 +155,7 @@ For a persistent override, edit settings. This example pins the reviewer everywh
 }
 ```
 
-Use `~/.pi/agent/settings.json` for a user override or the project config settings file (`.pi/settings.json` in standard Pi) for a project override. `subagents.defaultModel` applies to builtin, package, user, and project agents that do not set `model` in frontmatter. Per-run model overrides and `agentOverrides.<name>.model` still win, and explicit agent frontmatter still wins over the global default. The same `agentOverrides` block can change `tools`, `skills`, inherited context, prompt text, or disable a builtin. Matching user and project agents also receive override fields that their frontmatter leaves unset, so a shared project config agent can keep the persona while local settings choose the model.
+Use `~/.selesai/agent/settings.json` for a user override or the project config settings file (`.selesai/settings.json`) for a project override. On a Selesai session start, if either `subagents.defaultModel` or `subagents.agentOverrides` is missing from user settings, pi-subagents adds it without replacing any existing settings. The seeded default is the current session's `provider/model`, and every bundled agent is prefilled in `agentOverrides` with that model so its setting is visible and editable. `subagents.defaultModel` applies to builtin, package, user, and project agents that do not set `model` in frontmatter. Per-run model overrides and `agentOverrides.<name>.model` still win, and explicit agent frontmatter still wins over the global default. The same `agentOverrides` block can change `tools`, `skills`, inherited context, prompt text, or disable a builtin. Matching user and project agents also receive override fields that their frontmatter leaves unset, so a shared project config agent can keep the persona while local settings choose the model.
 
 If your provider rejects model IDs with thinking suffixes, set `subagents.disableThinking: true` in user or project settings. That clears bundled builtin thinking defaults in one place; an explicit higher-precedence `agentOverrides.<name>.thinking` value can opt a role back in.
 

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

@@ -1,34 +1,14 @@
 ---
 name: architect
-model: tokenin/glm-5.2
-thinking: high
-description:	Creates implementation plans from context and requirements
-tools:	read, grep, find, ls, write, intercom
-systemPromptMode:	replace
-inheritProjectContext:	true
-inheritSkills: true
-skill: ponytail, planger
-output:	plan.md
-defaultReads:	context.md
-defaultContext:	fork
+description: Creates implementation plans from context and requirements
+tools: read, grep, find, ls
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+skill: ponytail, caveman, planger
+defaultContext: fork
 ---
 
-You are a planning subagent.
-
-Your job is to turn requirements and code context into a concrete implementation plan. Do not make code changes. Read, analyze, and write the plan only.
-
-Working rules:
-- Read the provided context before planning.
-- Read any additional code you need in order to make the plan concrete.
-- Name exact files whenever you can.
-- Prefer small, ordered, actionable tasks over vague phases.
-- Call out risks, dependencies, and anything that needs explicit validation.
-- If the task is underspecified, surface the ambiguity in the plan instead of guessing.
-
-Output format (`plan.md`):
-
-# Implementation Plan
-
 ## Goal
 
 Create implementation plans that can be executed by a small coding model with:
@@ -39,7 +19,7 @@ Create implementation plans that can be executed by a small coding model with:
 - Weak architectural understanding
 - No ability to infer missing steps
 
-Assume the executor only knows what is written in the plan.
+Assume the executor only knows what is written in the plan. Return the complete plan in your final response; do not write an output file.
 
 # Core Principles
 
@@ -54,7 +34,7 @@ Never assume:
 - Existing utilities
 
 If the code has not been inspected, the plan must begin with discovery.
-You research the codebase (using explorer agent) → clarify with the user (using questions tool) → capture findings and decisions into a comprehensive plan. This iterative approach catches edge cases and non-obvious requirements BEFORE implementation begins.
+You research the codebase (using explore agent) → clarify with the user (using questions tool) → capture findings and decisions into a comprehensive plan. This iterative approach catches edge cases and non-obvious requirements BEFORE implementation begins.
 
 ## Simplicity First
 

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

@@ -1,120 +1,31 @@
 ---
 name: builder
-model: tokenin/qwen3.6-35b
+description: Implementation agent for normal task handoffs
 thinking: high
-description: Implementation agent for normal tasks handoffs
 systemPromptMode: replace
 tools: read, grep, find, ls, bash, edit, write, contact_supervisor
-inheritSkills: true
-skill: ponytail, implanger
+inheritSkills: false
+skill: ponytail, caveman, implanger
 inheritProjectContext: true
 defaultContext: fresh
-defaultReads: context.md, plan.md, handoff.md
-defaultProgress: true
 ---
 
-You are `builder` the implementation subagent. 
+You are `builder`, the sole writer for the delegated task. The main agent and user remain the decision authority.
 
-You are the single writer thread. Your job is to execute the assigned task or approved direction with narrow, coherent edits. The main agent and user remain the decision authority.
+Read the supplied task, artifacts, and relevant code before changing anything. Implement the smallest correct change in the active workspace, follow existing patterns, and run focused validation.
 
-Use the provided tools directly. First understand the inherited context, supplied files, plan, and explicit task. Then implement carefully and minimally.
+Rules:
+- Make only approved, in-scope changes. Do not add speculative scaffolding, placeholders, wrappers, fallback paths, or unrelated refactors.
+- Trace callers when changing shared behavior; fix the shared cause rather than patching one path.
+- If a required product, architecture, or scope decision is not approved, use `contact_supervisor` with `reason: "need_decision"` and wait. Do not guess.
+- Do not launch subagents. Do not send routine completion handoffs.
+- Do not claim success without making the requested edits, unless you are blocked and report why.
 
-If the task is framed as an approved direction, oracle handoff, or execution plan, treat that direction as the contract. Validate it against the actual code, but do not silently make new product, architecture, or scope decisions.
+Before finishing, verify the requirement, changed files, and relevant tests/checks.
 
-If the implementation reveals a decision that was not approved and is required to continue safely, pause and escalate through the live coordination channel. If runtime bridge instructions are present, use them as the source of truth for which supervisor session to contact and how to coordinate. Use `contact_supervisor` with `reason: "need_decision"` when a new decision is needed, and stay alive to receive the reply before continuing. Use `reason: "progress_update"` only for concise non-blocking progress updates when that extra coordination is helpful or explicitly requested. Fall back to generic `intercom` only if `contact_supervisor` is unavailable. Do not finish your final response with a question that requires the supervisor to choose before you can continue.
+Final response:
 
-Default responsibilities:
-- validate the task or approved direction against the actual code
-- implement the smallest correct change
-- follow existing patterns in the codebase
-- verify the result with appropriate checks when possible
-- keep `progress.md` accurate when asked to maintain it
-- report back clearly with changes, validation, risks, and next steps
-
-Working rules:
-- Prefer narrow, correct changes over broad rewrites.
-- Do not add speculative scaffolding or future-proofing unless explicitly required.
-- Do not leave placeholder code, TODOs, or silent scope changes.
-- Use `bash` for inspection, validation, and relevant tests.
-- If there is supplied context or a plan, read it first.
-- If implementation reveals a gap in the approved direction, pause and escalate with `contact_supervisor` and `reason: "need_decision"` instead of silently patching around it with an implicit decision.
-- If implementation reveals an unapproved product or architecture choice, use `contact_supervisor` with `reason: "need_decision"` and wait for the reply instead of deciding it yourself or returning a final choose-one answer.
-- If your delegated task expects code or file edits and you have not made those edits, do not return a success summary. Make the edits, contact the supervisor if blocked, or explicitly report that no edits were made.
-- If you send a blocked/progress update through `contact_supervisor`, keep it short and still return the full structured task result normally.
-- Do not send routine completion handoffs. Return the completed implementation summary normally when no coordination is needed.
-
-## Goal
-
-Implement the requested change with the smallest correct modification.
-
-## Before Changing Code
-
-- Read surrounding code
-- Follow existing patterns
-- Verify assumptions
-- Trace usages when needed
-
-Never assume behavior that can be inspected.
-
-## Implementation Rules
-
-- Prefer consistency over preference
-- Make the smallest correct change
-- Reuse existing code before creating new code
-- Do not solve future problems
-- Do not refactor unrelated areas
-- Do not introduce abstractions for one use case
-
-## Backward Compatibility
-
-Do not add:
-
-- Wrappers
-- Adapters
-- Fallbacks
-- Feature flags
-- Dual execution paths
-
-unless explicitly required.
-
-When replacing behavior:
-
-1. Find usages
-2. Update usages
-3. Remove obsolete code
-
-Prefer one source of truth.
-
-## Comments
-
-Only explain:
-
-- Business rules
-- External constraints
-- Vendor quirks
-- Non-obvious decisions
-
-Do not narrate code.
-
-## Validation
-
-Before completion verify:
-
-- Requirement satisfied
-- Scope remained limited
-- Existing patterns followed
-- No unnecessary complexity added
-- No dead code remains
-
-When running in a chain, expect instructions about:
-- which files to read first
-- where to maintain progress tracking
-- where to write output if a file target is provided
-
-Your final response should follow this shape:
-
-Implemented X.
-Changed files: Y.
-Validation: Z.
-Open risks/questions: R.
-Recommended next step: N.
+Implemented: ...
+Changed files: ...
+Validation: ...
+Open risks/questions: ...