@selesai/code 0.3.10 → 0.4.0

package/dist/defaults/models.json

@@ -16,7 +16,6 @@
           "reasoning": true,
           "input": ["text"],
           "contextWindow": 1000000,
-          "maxTokens": 384000,
           "cost": {
             "input": 0.14,
             "output": 0.28,
@@ -113,7 +112,7 @@
           "name": "GLM-5.2",
           "reasoning": true,
           "input": ["text"],
-          "contextWindow": 1048560,
+          "contextWindow": 1000000,
           "cost": {
             "input": 1.45,
             "output": 4.5,
@@ -129,7 +128,7 @@
           "name": "GLM-5.2 Fast",
           "reasoning": false,
           "input": ["text"],
-          "contextWindow": 1048560,
+          "contextWindow": 1000000,
           "cost": {
             "input": 1.45,
             "output": 4.5,

package/dist/extensions/caveman/index.js

@@ -23,6 +23,20 @@ export function isDeactivationCommand(text) {
   return t === "stop caveman" || t === "normal mode";
 }
 
+export function resolveSessionActive(entries, fallback = true) {
+  if (!Array.isArray(entries)) return fallback;
+
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry?.type !== "custom" || entry?.customType !== "caveman-mode") continue;
+
+    const active = entry?.data?.active;
+    if (typeof active === "boolean") return active;
+  }
+
+  return fallback;
+}
+
 export default function cavemanExtension(pi) {
   let active = true;
   let isActive = false;
@@ -81,7 +95,8 @@ export default function cavemanExtension(pi) {
   });
 
   pi.on("session_start", async (_event, ctx) => {
-    active = true; // ponytail: always ON at session start; OFF is current-session-only
+    const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+    active = resolveSessionActive(entries);
     syncStatus(ctx);
     ctx?.ui?.notify?.(`Caveman loaded: ${active ? "ON" : "OFF"}`, "info");
   });

package/dist/extensions/caveman/test/extension.test.js

@@ -80,23 +80,26 @@ test("disabled caveman skips instruction injection", async () => {
   assert.equal(result, undefined);
 });
 
-test("session_start always ON even if persisted entry is OFF", async () => {
+test("session_start restores persisted OFF state", async () => {
   const { events } = createPiHarness();
   const ctx = createCommandContext({
     sessionManager: {
-      getEntries: () => [
+      getBranch: () => [
         { type: "custom", customType: "caveman-mode", data: { active: false } },
       ],
+      getEntries: () => [
+        { type: "custom", customType: "caveman-mode", data: { active: true } },
+      ],
     },
   });
 
   await events.get("session_start")({ reason: "resume" }, ctx);
   const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
 
-  assert.ok(result.systemPrompt.includes("CAVEMAN MODE ACTIVE"));
+  assert.equal(result, undefined);
 });
 
-test("off then new session_start resets to ON", async () => {
+test("session_start defaults to ON when no persisted entry exists", async () => {
   const { commands, events } = createPiHarness();
   const ctx = createCommandContext();
 

package/dist/extensions/caveman/test/helpers.test.js

@@ -7,6 +7,7 @@ import {
   getCavemanInstructions,
   isDeactivationCommand,
   parseCavemanCommand,
+  resolveSessionActive,
 } from "../index.js";
 
 test("parseCavemanCommand: bare toggles", () => {
@@ -26,7 +27,17 @@ test("parseCavemanCommand: unknown arg is invalid", () => {
   assert.deepEqual(parseCavemanCommand("banana"), { type: "invalid", reason: "unknown-subcommand", arg: "banana" });
 });
 
-
+test("resolveSessionActive: returns last persisted boolean, defaults to true", () => {
+  assert.equal(resolveSessionActive([]), true);
+  assert.equal(resolveSessionActive([{ type: "custom", customType: "caveman-mode", data: { active: false } }]), false);
+  assert.equal(resolveSessionActive([{ type: "custom", customType: "caveman-mode", data: { active: true } }]), true);
+  assert.equal(resolveSessionActive([
+    { type: "custom", customType: "caveman-mode", data: { active: false } },
+    { type: "custom", customType: "caveman-mode", data: { active: true } },
+  ]), true);
+  assert.equal(resolveSessionActive([{ type: "custom", customType: "other", data: {} }]), true);
+  assert.equal(resolveSessionActive(null), true);
+});
 
 test("isDeactivationCommand: only the whole message, case-insensitive, trailing punct ok", () => {
   assert.equal(isDeactivationCommand("stop caveman"), true);

package/dist/extensions/context-compaction-reminder.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
+import contextCompactionReminderExtension, {
+	CONTEXT_COMPACTION_REMINDER_MESSAGE,
+} from "./context-compaction-reminder.ts";
+
+type Handler = (event: unknown, ctx: ExtensionContext) => void | Promise<void>;
+
+function createHarness(tokens: number | null | undefined = undefined) {
+	const handlers = new Map<string, Handler>();
+	const notify = vi.fn();
+	const pi = {
+		on: vi.fn((event: string, handler: Handler) => handlers.set(event, handler)),
+	} as unknown as ExtensionAPI;
+	const ctx = {
+		getContextUsage: () =>
+			tokens === undefined ? undefined : { tokens, contextWindow: 200_000, percent: tokens === null ? null : tokens / 2_000 },
+		ui: { notify },
+	} as unknown as ExtensionContext;
+
+	contextCompactionReminderExtension(pi);
+
+	return {
+		notify,
+		setTokens: (value: number | null | undefined) => {
+			tokens = value;
+		},
+		settle: () => handlers.get("agent_settled")!({ type: "agent_settled" }, ctx),
+		compact: () => handlers.get("session_compact")!({ type: "session_compact" }, ctx),
+	};
+}
+
+describe("context-compaction-reminder", () => {
+	it("warns once when known context reaches 128k", async () => {
+		const { notify, setTokens, settle } = createHarness(127_999);
+
+		await settle();
+		setTokens(128_000);
+		await settle();
+		setTokens(130_000);
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(1);
+		expect(notify).toHaveBeenCalledWith(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
+	});
+
+	it("does not reset the reminder for unavailable or post-compaction usage", async () => {
+		const { notify, setTokens, settle } = createHarness(128_000);
+
+		await settle();
+		setTokens(undefined);
+		await settle();
+		setTokens(null);
+		await settle();
+		setTokens(130_000);
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(1);
+	});
+
+	it("allows another warning after successful compaction", async () => {
+		const { notify, settle, compact } = createHarness(128_000);
+
+		await settle();
+		await compact();
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(2);
+	});
+
+	it("allows another warning after known usage drops below 128k", async () => {
+		const { notify, setTokens, settle } = createHarness(128_000);
+
+		await settle();
+		setTokens(127_999);
+		await settle();
+		setTokens(128_000);
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(2);
+	});
+});

package/dist/extensions/context-compaction-reminder.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI } from "@selesai/code";
+
+export const CONTEXT_COMPACTION_REMINDER_THRESHOLD = 128_000;
+export const CONTEXT_COMPACTION_REMINDER_MESSAGE =
+	"Conversation context has reached 128k tokens. Run /compact to summarize older context.";
+
+export default function contextCompactionReminderExtension(pi: ExtensionAPI): void {
+	let reminderShown = false;
+
+	pi.on("session_compact", () => {
+		reminderShown = false;
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		const tokens = ctx.getContextUsage()?.tokens;
+		if (tokens === undefined || tokens === null) return;
+
+		if (tokens < CONTEXT_COMPACTION_REMINDER_THRESHOLD) {
+			reminderShown = false;
+			return;
+		}
+
+		if (!reminderShown) {
+			ctx.ui.notify(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
+			reminderShown = true;
+		}
+	});
+}

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-subagents/agents/architect.md

@@ -1,188 +1,40 @@
 ---
 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
+output: plan.md
+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.
+You are a planning subagent. Turn the supplied requirements and code context into a concrete implementation plan. Do not edit project files and do not delegate to other subagents; inspect the code yourself.
 
 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.
+- Read supplied artifacts and relevant code before planning. Follow callers and tests when needed.
+- Name exact files, symbols, and validation commands whenever evidence permits.
+- Prefer the smallest maintainable change. Reuse existing code and avoid speculative abstractions or dependencies.
+- Surface unresolved requirements or risks instead of inventing product decisions.
+- The configured output artifact is allowed; do not write any other file.
 
-Output format (`plan.md`):
+Output:
 
 # Implementation Plan
 
 ## Goal
 
-Create implementation plans that can be executed by a small coding model with:
-
-- Limited context window
-- No project knowledge
-- No memory of previous conversation
-- Weak architectural understanding
-- No ability to infer missing steps
-
-Assume the executor only knows what is written in the plan.
-
-# Core Principles
-
-## Discovery First
-
-Never assume:
-
-- File names
-- File locations
-- Ownership of behavior
-- Existing abstractions
-- 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.
-
-## Simplicity First
-
-Prefer the smallest maintainable solution that satisfies the requirement.
-
-Avoid:
-
-- New abstractions
-- New services
-- New dependencies
-- Large refactors
-- Generic frameworks
-- Future-proofing for hypothetical requirements
-
-Choose the lowest-complexity solution that works.
-
-## Reuse Before Build
-
-Before creating anything new (use explorer agent):
-
-- Search for existing implementations
-- Search for existing utilities
-- Search for existing patterns
-- Search for existing tests
-
-Reuse existing code when reasonable.
-
-Do not duplicate behavior unless duplication is clearly preferable.
-
-## Scope Discipline
-
-Only modify code required for the task.
-
-Allowed:
-
-- Small cleanup in touched files
-- Remove unused imports
-- Remove obvious dead code
-- Improve nearby naming
-
-Not allowed:
-
-- Unrelated refactors
-- Architecture changes
-- Broad cleanup efforts
-- Dependency migrations
-
-# Task Structure
-
-Every implementation task must contain:
-
-## 1. Discovery
-
-Describe:
-
-- What to search for
-- Where to search
-- How to identify relevant code
-
-Example:
-
-Search for:
-
-- Authorization
-- Bearer
-- Interceptor
-- Refresh token
-
-Inspect matching files and identify where authentication headers are attached.
-
-## 2. Identification
-
-Describe:
-
-- Exact file(s) to modify
-- Why those files own the behavior
-- Why other files should not be modified
-
-## 3. Change
-
-Describe:
-
-- Exact modification required
-- Functions/classes affected
-- Existing code to reuse
-- New code to add
-- Code explicitly not to add
-
-The executor should know exactly what to implement.
-
-## 4. Verification
-
-Include:
-
-### Success Cases
-
-Expected working behavior.
-
-### Failure Cases
-
-Expected error behavior.
-
-### Regression Checks
-
-Existing behavior that must remain unchanged.
-
-# Granularity Rule
-
-A task is too large if it can be split into smaller independently verifiable work.
-
-Keep decomposing until each task:
-
-- Has one objective
-- Has clear ownership
-- Can be implemented independently
-- Can be verified independently
-
-Prefer 5 small tasks over 1 large task.
+## Findings
+- Relevant files, existing behavior, and constraints.
 
-# Final Review
+## Steps
+1. Exact file and change.
+2. Exact file and change.
 
-Before returning a plan verify:
+## Verification
+- Success cases
+- Failure/regression cases
+- Commands or manual checks
 
-- Discovery exists
-- Ownership is justified
-- Solution is the simplest acceptable approach
-- Existing code is reused when possible
-- No unnecessary abstractions are introduced
-- Scope remains limited
-- Verification is included
-- Every step is executable without additional assumptions
+## Risks / Open Questions