@oh-my-pi/pi-coding-agent 14.5.7 → 14.5.9

package/src/prompts/tools/task.md

@@ -1,167 +1,54 @@
 Launches subagents to parallelize workflows.
 
 {{#if asyncEnabled}}
-- Use `read jobs://` to inspect state; `read jobs://<job_id>` for detail.
-- Use the `job` tool (with `poll`) to wait until completion. You **MUST NOT** poll `read jobs://` in a loop.
+- `read jobs://` for state, `read jobs://<id>` for detail.
+- Use `job` (with `poll`) to wait. **MUST NOT** poll `read jobs://` in a loop.
 {{/if}}
 
-{{#if defaultMode}}
-Current input mode: `default`. Shared `context` and custom task-call `schema` are available.
-{{/if}}
-{{#if schemaFreeMode}}
-Current input mode: `schema-free`. Shared `context` is available; custom task-call `schema` is disabled. For structured output, rely on the agent definition or inherited session schema.
-{{/if}}
-{{#if independentMode}}
-Current input mode: `independent`. Shared `context` and custom `schema` are both disabled. Every assignment must stand on its own.
-{{/if}}
-
-{{#if contextEnabled}}
-Subagents lack your conversation history. Every decision, file content, and user requirement they need **MUST** be explicit in `context` or `assignment`.
-{{else}}
-Subagents lack your conversation history. Every decision, file content, and user requirement they need **MUST** be explicit in each task `assignment`.
-{{/if}}
+Subagents have no access to your conversation history. Every fact, file path, and decision they need **MUST** be explicit in {{#if contextEnabled}}`context` or `assignment`{{else}}each `assignment`{{/if}}.
 
 <parameters>
-- `agent`: Agent type for all tasks.
-  - `.id`: CamelCase, max 32 chars
-  - `.description`: UI display only — subagent never sees it
-  - `.assignment`: Complete self-contained instructions. One-liners PROHIBITED; missing acceptance criteria = too vague.
-{{#if contextEnabled}}
-- `context`: Shared background prepended to every assignment. Session-specific info only.
-{{/if}}
-{{#if customSchemaEnabled}}
-- `schema`: JSON-encoded JTD schema for expected output. Format lives here — **MUST NOT** be duplicated in assignments.
-{{/if}}
-- `tasks`: Tasks to execute in parallel.
-{{#if isolationEnabled}}
-- `isolated`: Run in isolated environment; returns patches. Use when tasks edit overlapping files.
-{{/if}}
+- `agent`: agent type for all tasks
+- `tasks`: tasks to execute in parallel
+ - `.id`: CamelCase, ≤32 chars
+ - `.description`: UI label only — subagent never sees it
+ - `.assignment`: complete self-contained instructions; one-liners and missing acceptance criteria are PROHIBITED
+{{#if contextEnabled}}- `context`: shared background prepended to every assignment; session-specific only{{/if}}
+{{#if customSchemaEnabled}}- `schema`: JTD schema for expected structured output (do not put format rules in assignments){{/if}}
+{{#if isolationEnabled}}- `isolated`: run in isolated env; use when tasks edit overlapping files{{/if}}
 </parameters>
 
-<critical>
-{{#if contextEnabled}}
-- **MUST NOT** duplicate shared constraints across assignments — put them in `context` once.
-{{else}}
-- Every `assignment` must repeat any constraints, reference paths, and acceptance criteria it needs — there is no shared `context` field.
-{{/if}}
-- **MUST NOT** tell tasks to run project-wide build/test/lint. Parallel agents share the working tree; each task edits, stops. Caller verifies after all complete.
-- For large payloads (traces, JSON blobs), write to `local://<path>` and pass the path in {{#if contextEnabled}}`context`{{else}}the relevant `assignment`{{/if}}.
-- Prefer `task` agents that investigate **and** edit in one pass. Launch a dedicated read-only discovery step only when affected files are genuinely unknown.
-</critical>
-
-<scope>
-Each task: **at most 3–5 files**. Globs, "update all", or package-wide scope = too broad. Enumerate files explicitly and fan out to a cluster of agents.
-</scope>
+<rules>
+- **MUST NOT** assign tasks to run project-wide build/test/lint. Caller verifies after the batch.
+- Each task: ≤3–5 explicit files. No globs, no "update all", no package-wide scope. Fan out to a cluster instead.
+- Pass large payloads via `local://<path>` URIs, not inline.
+{{#if contextEnabled}}- Put shared constraints in `context` once; do not duplicate across assignments.{{/if}}
+- Prefer agents that investigate **and** edit in one pass; only spin a read-only discovery step when affected files are genuinely unknown.
+</rules>
 
 <parallelization>
-**Test:** Can task B produce correct output without seeing A's result? Yes → parallel. No → sequential.
-
-|Sequential first|Then|Reason|
-|---|---|---|
-|Types/interfaces|Consumers|Need contract|
-|API exports|Callers|Need signatures|
-|Core module|Dependents|Import dependency|
-|Schema/migration|App logic|Schema dependency|
-
-**Safe to parallelize:** independent modules, isolated file-scoped refactors, tests for existing code.
+Test: can task B run correctly without seeing A's output? If no, sequence A → B.
+Sequential when one task produces a contract (types, API, schema, core module) the other consumes.
+Parallel when tasks touch disjoint files or are independent refactors/tests.
 </parallelization>
 
-<templates>
-{{#if contextEnabled}}
-**context:**
-```
-## Goal         ← one sentence: what the batch accomplishes
-## Non-goals    ← what tasks must not touch
-## Constraints  ← MUST/MUST NOT rules and session decisions
-## API Contract ← exact types/signatures if tasks share an interface (omit if N/A)
-## Acceptance   ← definition of done; build/lint runs AFTER all tasks complete
-```
-{{else}}
-No shared `context` field exists in this mode. Fold goal, non-goals, constraints, and acceptance criteria into each `assignment`.
-{{/if}}
-**assignment:**
-```
-## Target       ← exact file paths; named symbols; explicit non-goals
-## Change       ← step-by-step what to add/remove/rename; patterns/APIs to use
-## Edge Cases   ← tricky inputs; existing behavior that must survive
-## Acceptance   ← observable result proving the task is done; no project-wide commands
-```
-</templates>
-
-<checklist>
-Before invoking:
 {{#if contextEnabled}}
-- `context` contains only session-specific info
-{{else}}
-- Every `assignment` includes its own goal, constraints, and acceptance criteria (no shared context)
+<context-fmt>
+# Goal         ← one sentence: what the batch accomplishes
+# Constraints  ← **MUST**/**MUST NOT** rules and session decisions
+# Contract     ← exact types/signatures if tasks share an interface
+</context-fmt>
 {{/if}}
-- Every `assignment` follows the template; no one-liners; edge cases covered
-- Tasks are truly parallel — you can articulate why none depends on another's output
-- File paths are explicit; no globs
-{{#if customSchemaEnabled}}
-- `schema` is set if you expect structured output
-{{else}}
-- Do not pass a custom task-call `schema` in this mode
-{{/if}}
-</checklist>
-
-{{#if contextEnabled}}
-<example label="Rename exported symbol + update all call sites">
-Two tasks with non-overlapping file sets — demonstrates scope partitioning.
 
-<context>
-## Goal
-Rename `parseConfig` → `loadConfig` in `src/config/parser.ts` and all callers.
-## Non-goals
-No behavior or signature changes; rename only.
-## Acceptance (global)
-Caller runs `bun check:ts` after both tasks complete. Tasks must NOT run it.
-</context>
-<tasks>
-  <task name="RenameExport">
-    <assignment>
-## Target
-- `src/config/parser.ts`: function `parseConfig`
-- If `src/config/index.ts` re-exports it, update the re-export
-- Non-goals: do not touch callers or tests
-
-## Change
-- Rename `parseConfig` → `loadConfig` (declaration + any JSDoc references)
-
-## Edge Cases
-- Rename all overload signatures if overloaded
-- Internal helpers like `_parseConfigValue` are different symbols — leave untouched
-- Do not add a backwards-compat alias
-
-## Acceptance
-- `parseConfig` no longer appears as a top-level export in `parser.ts`
-    </assignment>
-  </task>
-  <task name="UpdateCallers">
-    <assignment>
-## Target
-- `src/cli/init.ts`, `src/server/bootstrap.ts`, `src/worker/index.ts`
-- Non-goals: do not touch `src/config/parser.ts` or `src/config/index.ts`
-
-## Change
-- Replace `import { parseConfig }` → `import { loadConfig }`
-- Replace every call site `parseConfig(` → `loadConfig(`
-- For `import * as cfg` users, update `cfg.parseConfig` property access
-
-## Edge Cases
-- String literals containing "parseConfig" (logs, comments) are documentation — leave them
-- If a file re-exports to an external package boundary, keep the old name via `export { loadConfig as parseConfig }` with a `// TODO: remove after next major` comment
-
-## Acceptance
-- No bare `parseConfig` identifier remains in the three target files
-    </assignment>
-  </task>
-</tasks>
-</example>
-{{/if}}
+<assignment-fmt>
+# Target       ← exact files and symbols; explicit non-goals
+# Change       ← step-by-step add/remove/rename; APIs and patterns
+# Acceptance   ← observable result; no project-wide commands
+</assignment-fmt>
 
+<agents>
 {{#list agents join="\n"}}
-### Agent: {{name}}
-**Tools:** {{default (join tools ", ") "All"}}
+# {{name}}
 {{description}}
 {{/list}}
+</agents>

package/src/prompts/tools/todo-write.md

@@ -1,69 +1,33 @@
-Manages a phased task list through an `ops` array of flat operations.
-The next pending task is auto-promoted to `in_progress` after completing the current one.
+Manages a phased task list. Pass `ops`: a flat array of operations.
+The next pending task is auto-promoted to `in_progress` after each completion.
 
-<protocol>
-## Shape
+## Operations
 
-Pass an object with an `ops` array:
-
-```ts
-{
-  ops: [
-    { op: "replace", phases: [...] },
-    { op: "start", task: "task-3" },
-    { op: "done", phase: "Implementation" },
-    { op: "rm" },
-    { op: "drop", task: "task-9" },
-    { op: "append", phase: "Implementation", items: [{ id: "task-10", label: "Run tests" }] },
-  ],
-}
-```
-
-## Operation fields
-
-|Field|Type|When to use|
+|`op`|Required fields|Effect|
 |---|---|---|
-|`op`|string|Required. One of `replace`, `start`, `done`, `rm`, `drop`, `append`, `note`|
-|`task`|string|Task id for `start`, or a task target for `done` / `rm` / `drop`|
-|`phase`|string|Phase target for `done` / `rm` / `drop`, or append destination for `append`|
-|`items`|{id, label}[]|Required for `append`. If the phase does not exist, it is created at the end|
-|`phases`|Phase[]|Only for `replace`. Keeps initial phased setup available for harness bootstrap and full restructures|
-|`text`|string|Required for `note`. The note text appended to `task.notes` (which is a list, joined with newlines on render)|
-
-## Semantics
-- `start`: requires `task`; sets that task to `in_progress`
-- `done`: marks one task, one phase, or all tasks completed
-- `rm`: removes one task, one phase's tasks, or all tasks
-- `drop`: marks one task, one phase, or all tasks abandoned
-- `append`: appends `items` to `phase`; creates the phase if missing
-- `replace`: replaces the full todo list
-- `note`: append `text` as a new note attached to `task`. Notes are append-only context the user added; they only render to you when the task is `in_progress`. Other tasks display only a `+N` marker. Use this when you want to leave a follow-up reminder for yourself when you reach a later task.
-
-If `done`, `rm`, or `drop` omits both `task` and `phase`, it applies to all tasks.
-
-## Task Anatomy
-- `label`: Short label (5-10 words). What is being done, not how.
-- `replace` task `content` should stay short and specific.
-
-## Phase Anatomy
-- `name`: Short, human-readable noun phrase (1-3 words). Capitalize naturally.
-- Always prefix with a roman-numeral ordinal (`I.`, `II.`, `III.`, `IV.`, …) to convey ordering — e.g. `I. Foundation`, `II. Auth`, `III. Routing`. Single-phase plans use `I.` too.
-- You **MUST NOT** use snake_case, `Phase1_*`, arabic numerals (`1.`), or letter prefixes (`A.`) — they render as ugly identifiers.
+|`replace`|`phases`|Replace the full list (initial setup, full restructure)|
+|`start`|`task`|Set task to `in_progress`|
+|`done`|`task` or `phase` (or neither = all)|Mark completed|
+|`drop`|`task` or `phase` (or neither = all)|Mark abandoned|
+|`rm`|`task` or `phase` (or neither = all)|Remove|
+|`append`|`phase`, `items: {id, label}[]`|Append tasks; creates phase if missing|
+|`note`|`task`, `text`|Append a note to `task.notes`. Only use to leave reminders for future-you.|
+
+## Anatomy
+- **Task `label`**: 5–10 words, what is being done, not how.
+- **Phase `name`**: short noun phrase prefixed with a roman numeral — `I. Foundation`, `II. Auth`, `III. Verification`. Single-phase plans still use `I.`. Never use snake_case, arabic numerals, or letter prefixes.
 
 ## Rules
 - Mark tasks done immediately after finishing — never defer.
-- Complete phases in order — do not skip ahead while earlier ones are pending.
-- On blockers, append a new task to the active phase.
+- Complete phases in order.
+- On blockers, `append` a new task to the active phase.
 - Keep ids stable once introduced.
-</protocol>
 
-<conditions>
-Create a todo list when:
-1. Task requires 3+ distinct steps
-2. User explicitly requests one
-3. User provides a set of tasks to complete
-4. New instructions arrive mid-task — capture before proceeding
-</conditions>
+## When to create a list
+- Task requires 3+ distinct steps
+- User explicitly requests one
+- User provides a set of tasks to complete
+- New instructions arrive mid-task — capture before proceeding
 
 <examples>
 # Initial setup (multi-phase)
@@ -81,9 +45,3 @@ Create a todo list when:
 # Append tasks to a phase
 `{"ops":[{"op":"append","phase":"II. Auth","items":[{"id":"task-8","label":"Handle retries"},{"id":"task-9","label":"Run tests"}]}]}`
 </examples>
-
-<avoid>
-- Single-step tasks — act directly
-- Conversational or informational requests
-- Tasks completable in under 3 trivial steps
-</avoid>

package/src/session/compaction/compaction.ts

@@ -26,6 +26,7 @@ import {
 	getOpenAIResponsesHistoryPayload,
 	normalizeResponsesToolCallId,
 } from "@oh-my-pi/pi-ai/utils";
+import { countTokens } from "@oh-my-pi/pi-natives";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import compactionShortSummaryPrompt from "../../prompts/compaction/compaction-short-summary.md" with { type: "text" };
 import compactionSummaryPrompt from "../../prompts/compaction/compaction-summary.md" with { type: "text" };
@@ -218,7 +219,7 @@ export function shouldCompact(contextTokens: number, contextWindow: number, sett
 	return contextTokens > thresholdTokens;
 }
 
-function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
+export function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
 	// Fixed token limit takes priority over percentage
 	const thresholdTokens = settings.thresholdTokens;
 	if (typeof thresholdTokens === "number" && Number.isFinite(thresholdTokens) && thresholdTokens > 0) {
@@ -240,67 +241,79 @@ function resolveThresholdTokens(contextWindow: number, settings: CompactionSetti
 // ============================================================================
 
 /**
- * Estimate token count for a message using chars/4 heuristic.
- * This is conservative (overestimates tokens).
+ * Image content has no tokenizer representation; charge a fixed estimate
+ * matching what providers typically bill for inline images.
+ */
+const IMAGE_TOKEN_ESTIMATE = 1200;
+
+/**
+ * Estimate token count for a message using cl100k_base via the native
+ * tokenizer. This is not Claude's first-party tokenizer (Anthropic doesn't
+ * publish one) but is within ~5–10% across English/code text.
  */
 export function estimateTokens(message: AgentMessage): number {
-	let chars = 0;
+	const fragments: string[] = [];
+	let extra = 0;
 
 	switch (message.role) {
 		case "user": {
 			const content = (message as { content: string | Array<{ type: string; text?: string }> }).content;
 			if (typeof content === "string") {
-				chars = content.length;
+				fragments.push(content);
 			} else if (Array.isArray(content)) {
 				for (const block of content) {
 					if (block.type === "text" && block.text) {
-						chars += block.text.length;
+						fragments.push(block.text);
 					}
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "assistant": {
 			const assistant = message as AssistantMessage;
 			for (const block of assistant.content) {
 				if (block.type === "text") {
-					chars += block.text.length;
+					fragments.push(block.text);
 				} else if (block.type === "thinking") {
-					chars += block.thinking.length;
+					fragments.push(block.thinking);
 				} else if (block.type === "toolCall") {
-					chars += block.name.length + JSON.stringify(block.arguments).length;
+					fragments.push(block.name);
+					fragments.push(JSON.stringify(block.arguments));
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "hookMessage":
 		case "toolResult": {
 			if (typeof message.content === "string") {
-				chars = message.content.length;
+				fragments.push(message.content);
 			} else {
 				for (const block of message.content) {
 					if (block.type === "text" && block.text) {
-						chars += block.text.length;
-					}
-					if (block.type === "image") {
-						chars += 4800; // Estimate images as 4000 chars, or 1200 tokens
+						fragments.push(block.text);
+					} else if (block.type === "image") {
+						extra += IMAGE_TOKEN_ESTIMATE;
 					}
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "bashExecution": {
-			chars = message.command.length + message.output.length;
-			return Math.ceil(chars / 4);
+			fragments.push(message.command);
+			fragments.push(message.output);
+			break;
 		}
 		case "branchSummary":
 		case "compactionSummary": {
-			chars = message.summary.length;
-			return Math.ceil(chars / 4);
+			fragments.push(message.summary);
+			break;
 		}
+		default:
+			return 0;
 	}
 
-	return 0;
+	if (fragments.length === 0) return extra;
+	return extra + countTokens(fragments);
 }
 
 function estimateEntriesTokens(entries: SessionEntry[], startIndex: number, endIndex: number): number {

package/src/session/session-dump-format.ts

@@ -114,6 +114,7 @@ export function formatSessionDumpText(options: FormatSessionDumpTextOptions): st
 				if (c.type === "text") {
 					lines.push(c.text);
 				} else if (c.type === "thinking") {
+					if (c.thinking.trim().length === 0) continue;
 					lines.push("<thinking>");
 					lines.push(c.thinking);
 					lines.push("</thinking>\n");

package/src/slash-commands/builtin-registry.ts

@@ -123,11 +123,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 	},
 	{
 		name: "loop",
-		description: "Loop the agent: re-submit the same prompt every time it yields (Esc to stop)",
-		inlineHint: "<prompt>",
-		allowArgs: true,
-		handle: async (command, runtime) => {
-			await runtime.ctx.handleLoopCommand(command.args || undefined);
+		description:
+			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleLoopCommand();
 			runtime.ctx.editor.setText("");
 		},
 	},
@@ -356,6 +355,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "context",
+		description: "Show estimated context usage breakdown",
+		handle: (_command, runtime) => {
+			runtime.ctx.handleContextCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "extensions",
 		aliases: ["status"],