@phi-code-admin/phi-code 0.86.0 → 0.88.0

package/extensions/phi/productivity.ts

@@ -332,7 +332,8 @@ export default function productivityExtension(pi: ExtensionAPI) {
 	// /title
 	// ------------------------------------------------------------------------
 	pi.registerCommand("title", {
-		description: "Derive a session title + kebab-case branch name from the first user message (deterministic, no LLM).",
+		description:
+			"Derive a session title + kebab-case branch name from the first user message (deterministic, no LLM).",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
 			try {
 				const source = firstUserMessageText(ctx);
@@ -387,7 +388,8 @@ export default function productivityExtension(pi: ExtensionAPI) {
 	// /dream
 	// ------------------------------------------------------------------------
 	pi.registerCommand("dream", {
-		description: "Deterministic memory consolidation: report exact-duplicate notes that could be merged (no deletion).",
+		description:
+			"Deterministic memory consolidation: report exact-duplicate notes that could be merged (no deletion).",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
 			try {
 				const files = memory.notes.list();

package/extensions/phi/providers/agent-def.ts

@@ -15,7 +15,7 @@
  * resolves to a real agents/ directory in both.
  */
 
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 

package/extensions/phi/providers/alibaba.ts

@@ -51,16 +51,65 @@ export interface AlibabaModelSpec {
  * are multimodal); the qwen3-coder / qwen3-max / glm / MiniMax entries are text.
  */
 export const ALIBABA_MODELS: readonly AlibabaModelSpec[] = [
-	{ id: "qwen3.7-plus", name: "Qwen 3.7 Plus", contextWindow: 1_000_000, maxTokens: 16_384, reasoning: true, vision: true },
-	{ id: "qwen3.6-plus", name: "Qwen 3.6 Plus", contextWindow: 1_000_000, maxTokens: 16_384, reasoning: true, vision: true },
-	{ id: "qwen3.5-plus", name: "Qwen 3.5 Plus", contextWindow: 1_000_000, maxTokens: 16_384, reasoning: true, vision: true },
-	{ id: "qwen3-max-2026-01-23", name: "Qwen 3 Max", contextWindow: 262_144, maxTokens: 16_384, reasoning: true, vision: false },
-	{ id: "qwen3-coder-plus", name: "Qwen 3 Coder Plus", contextWindow: 1_000_000, maxTokens: 16_384, reasoning: true, vision: false },
-	{ id: "qwen3-coder-next", name: "Qwen 3 Coder Next", contextWindow: 1_000_000, maxTokens: 16_384, reasoning: true, vision: false },
+	{
+		id: "qwen3.7-plus",
+		name: "Qwen 3.7 Plus",
+		contextWindow: 1_000_000,
+		maxTokens: 16_384,
+		reasoning: true,
+		vision: true,
+	},
+	{
+		id: "qwen3.6-plus",
+		name: "Qwen 3.6 Plus",
+		contextWindow: 1_000_000,
+		maxTokens: 16_384,
+		reasoning: true,
+		vision: true,
+	},
+	{
+		id: "qwen3.5-plus",
+		name: "Qwen 3.5 Plus",
+		contextWindow: 1_000_000,
+		maxTokens: 16_384,
+		reasoning: true,
+		vision: true,
+	},
+	{
+		id: "qwen3-max-2026-01-23",
+		name: "Qwen 3 Max",
+		contextWindow: 262_144,
+		maxTokens: 16_384,
+		reasoning: true,
+		vision: false,
+	},
+	{
+		id: "qwen3-coder-plus",
+		name: "Qwen 3 Coder Plus",
+		contextWindow: 1_000_000,
+		maxTokens: 16_384,
+		reasoning: true,
+		vision: false,
+	},
+	{
+		id: "qwen3-coder-next",
+		name: "Qwen 3 Coder Next",
+		contextWindow: 1_000_000,
+		maxTokens: 16_384,
+		reasoning: true,
+		vision: false,
+	},
 	{ id: "kimi-k2.5", name: "Kimi K2.5", contextWindow: 262_144, maxTokens: 16_384, reasoning: true, vision: true },
 	{ id: "glm-5", name: "GLM 5", contextWindow: 200_000, maxTokens: 128_000, reasoning: true, vision: false },
 	{ id: "glm-4.7", name: "GLM 4.7", contextWindow: 200_000, maxTokens: 128_000, reasoning: true, vision: false },
-	{ id: "MiniMax-M2.5", name: "MiniMax M2.5", contextWindow: 1_000_000, maxTokens: 16_384, reasoning: true, vision: false },
+	{
+		id: "MiniMax-M2.5",
+		name: "MiniMax M2.5",
+		contextWindow: 1_000_000,
+		maxTokens: 16_384,
+		reasoning: true,
+		vision: false,
+	},
 ] as const;
 
 export const ALIBABA_RATE_LIMITS = {

package/extensions/phi/providers/context-window.ts

@@ -44,7 +44,10 @@ export function inferContextWindow(modelId: string, apiValue?: number, providerI
 
 /** Parse a context-window value like "256k", "1M", "1.5m", or "200000". */
 export function parseContextWindow(input: string): number | undefined {
-	const m = input.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*([km])?$/);
+	const m = input
+		.trim()
+		.toLowerCase()
+		.match(/^(\d+(?:\.\d+)?)\s*([km])?$/);
 	if (!m) return undefined;
 	const n = Number.parseFloat(m[1]);
 	if (!Number.isFinite(n) || n <= 0) return undefined;

package/extensions/phi/providers/live-models.ts

@@ -19,13 +19,9 @@
  * are exposed so the wizard can show *something* before the first live fetch.
  */
 
-import {
-	OPENCODE_GO_FALLBACK_MODELS,
-	getOpenCodeGoModels,
-	pingOpenCodeGo,
-} from "./opencode-go.js";
 import { ALIBABA_MODELS, ALIBABA_PROVIDERS, pingAlibaba } from "./alibaba.js";
 import { inferContextWindow } from "./context-window.js";
+import { getOpenCodeGoModels, OPENCODE_GO_FALLBACK_MODELS, pingOpenCodeGo } from "./opencode-go.js";
 
 export const LAST_VERIFIED = "2026-07-10";
 
@@ -66,11 +62,7 @@ function isCacheValid(entry: CacheEntry | undefined, now: number): boolean {
 	return entry !== undefined && now - entry.fetchedAt < CACHE_TTL_MS;
 }
 
-async function fetchJson(
-	url: string,
-	headers: Record<string, string>,
-	timeoutMs: number,
-): Promise<unknown> {
+async function fetchJson(url: string, headers: Record<string, string>, timeoutMs: number): Promise<unknown> {
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(), timeoutMs);
 	try {
@@ -401,10 +393,7 @@ async function dispatchFetch(providerId: string, options: FetchOptions): Promise
  *  3. Previous cache entry, if any (even if stale).
  *  4. Static fallback (versioned).
  */
-export async function fetchLiveModels(
-	providerId: string,
-	options: FetchOptions = {},
-): Promise<LiveModelsResult> {
+export async function fetchLiveModels(providerId: string, options: FetchOptions = {}): Promise<LiveModelsResult> {
 	const now = Date.now();
 	const force = options.forceRefresh === true;
 
@@ -425,9 +414,7 @@ export async function fetchLiveModels(
 		const models = await promise;
 		if (models.length === 0) {
 			const fallback = staticFallbackFor(providerId);
-			return fallback.length > 0
-				? { models: fallback, source: "fallback" }
-				: { models: [], source: "unsupported" };
+			return fallback.length > 0 ? { models: fallback, source: "fallback" } : { models: [], source: "unsupported" };
 		}
 		cache.set(providerId, { models, fetchedAt: now });
 		return { models, source: "live" };
@@ -466,9 +453,7 @@ export async function pingProvider(
 		default: {
 			try {
 				const models = await dispatchFetch(providerId, { apiKey, timeoutMs, forceRefresh: true });
-				return models.length > 0
-					? { ok: true }
-					: { ok: false, error: "no models returned" };
+				return models.length > 0 ? { ok: true } : { ok: false, error: "no models returned" };
 			} catch (err) {
 				return { ok: false, error: err instanceof Error ? err.message : String(err) };
 			}

package/extensions/phi/providers/orchestrator-helpers.ts

@@ -21,14 +21,40 @@ export function parsePhaseVerdict(content: string): PhaseVerdict | null {
 }
 
 /**
- * Extract the body of a markdown section by heading name (e.g. "BLOCKING",
- * "HANDOFF"), up to the next heading or end of file. Returns "" if absent.
+ * Extract the body of a section by name (e.g. "BLOCKING", "HANDOFF"), up to the
+ * next section header or end of file. Returns "" if absent.
+ *
+ * Tolerant of the three header shapes models actually emit for the same
+ * section: a markdown heading (`## HANDOFF`), a standalone bold label
+ * (`**HANDOFF**`), or a plain label line (`HANDOFF:`). Termination stops at the
+ * next markdown heading or the next standalone bold/plain label line, so a
+ * report written entirely with bold labels still splits into sections instead
+ * of the first one swallowing the rest.
  */
 export function extractSection(content: string, heading: string): string {
 	if (!content) return "";
-	const re = new RegExp(`#{1,6}\\s*\\**\\s*${heading}\\b[^\\n]*\\n([\\s\\S]*?)(?:\\n#{1,6}\\s|$)`, "i");
-	const m = content.match(re);
-	return m ? m[1].trim() : "";
+	// Header line, in one of three shapes, anchored to line start:
+	//   `## HANDOFF ...`  (markdown heading — trailing text allowed)
+	//   `**HANDOFF**`     (bold label — closing stars, then only trailing space)
+	//   `HANDOFF:` / `HANDOFF` (plain label — must be the whole line or end in ":")
+	// The plain form requires ":" or end-of-line after the name so a prose line
+	// like "Blocking issues remain: 2" is not mistaken for a "BLOCKING" header.
+	const start = new RegExp(
+		`(?:^|\\n)[ \\t]{0,3}(?:` +
+			`#{1,6}[ \\t]*\\*{0,2}[ \\t]*${heading}\\b[^\\n]*` + // heading
+			`|\\*{2}[ \\t]*${heading}[ \\t]*\\*{2}[ \\t]*` + // bold label
+			`|${heading}[ \\t]*:?[ \\t]*` + // plain label (bare or "name:")
+			`)\\n`,
+		"i",
+	);
+	const m = start.exec(content);
+	if (!m) return "";
+	const rest = content.slice(m.index + m[0].length);
+	// Next section boundary: a markdown heading line, or a line that is ONLY a
+	// bold label (`**LABEL**`) — not inline bold inside a bullet, which would
+	// truncate the body.
+	const end = rest.search(/\n[ \t]{0,3}(?:#{1,6}[ \t]|\*{2}[A-Za-z][^\n]*\*{2}[ \t]*(?:\n|$))/);
+	return (end === -1 ? rest : rest.slice(0, end)).trim();
 }
 
 export function extractBlockingFindings(content: string): string {

package/extensions/phi/providers/phase-machine.ts

@@ -0,0 +1,283 @@
+/**
+ * Pure decision core of the /plan orchestrator's phase state machine.
+ *
+ * orchestrator.ts owns the I/O (UI notifications, queue mutation, checkpoint
+ * files, model switching); everything DECIDABLE from a finished phase's
+ * messages and report lives here so the exact transition behavior is unit
+ * tested — including what happens when a model deviates from the text
+ * contracts (missing report, unparseable verdict, zero tool calls).
+ *
+ * Behavior contract (mirrors the agent_end hook, in priority order):
+ *   user abort > auth error (401) > transient retry (once, fallback model)
+ *   > BLOCKED pause > review-FAIL fix cycle (once, unless looping)
+ *   > continue (with diagnostics).
+ */
+
+import {
+	extractBlockingFindings,
+	extractHandoff,
+	isTransientError,
+	type PhaseVerdict,
+	parsePhaseVerdict,
+} from "./orchestrator-helpers.js";
+
+export interface PhaseEndAnalysis {
+	userAborted: boolean;
+	hasAuthError: boolean;
+	transient: boolean;
+	toolCallCount: number;
+	filesWritten: string[];
+	filesEdited: string[];
+	errorsHit: string[];
+	testResults: string[];
+	calledMemorySearch: boolean;
+	calledMemoryWrite: boolean;
+}
+
+interface LooseMessage {
+	role?: string;
+	content?: unknown;
+	name?: string;
+	toolName?: string;
+	isError?: boolean;
+	stopReason?: string;
+}
+
+function messageText(msg: LooseMessage): string {
+	if (typeof msg.content === "string") return msg.content;
+	if (Array.isArray(msg.content)) {
+		return msg.content.map((c: { text?: string }) => c?.text || "").join("");
+	}
+	return JSON.stringify(msg.content ?? "");
+}
+
+/**
+ * Analyze a finished phase's message list into the facts the transition
+ * decision needs. Pure: no I/O, no state.
+ */
+export function analyzePhaseMessages(rawMessages: readonly unknown[]): PhaseEndAnalysis {
+	const messages = (rawMessages || []) as LooseMessage[];
+
+	const userAborted = messages.some((m) => m.role === "assistant" && m.stopReason === "aborted");
+
+	const hasAuthError = messages.some((m) => {
+		const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content || "");
+		return (
+			content.includes("401") &&
+			(content.includes("invalid access token") ||
+				content.includes("token expired") ||
+				content.includes("Unauthorized"))
+		);
+	});
+
+	const filesWritten: string[] = [];
+	const filesEdited: string[] = [];
+	const errorsHit: string[] = [];
+	const testResults: string[] = [];
+	let toolCallCount = 0;
+	const toolNames: string[] = [];
+
+	for (const msg of messages) {
+		// Pi uses role: "toolResult" instead of "tool"
+		if (msg.role !== "tool" && msg.role !== "function" && msg.role !== "toolResult") continue;
+		toolCallCount++;
+		const content = messageText(msg);
+		const name = msg.name || msg.toolName || "";
+		toolNames.push(name);
+
+		// Track writes
+		if (name === "write" && content.includes("Successfully wrote")) {
+			const match = content.match(/wrote \d+ bytes to (.+)/);
+			if (match) filesWritten.push(match[1]);
+		}
+		// Track edits — the edit tool returns "Successfully replaced N block(s) in <path>."
+		// Anchor the path capture so it does not over-capture unrelated text.
+		if (name === "edit" && !content.includes("ERR") && !msg.isError) {
+			const match = content.match(/replaced \d+ block\(s\) in (.+?)\.?$/m);
+			if (match) filesEdited.push(match[1]);
+		}
+		// Track errors — but filter out edit retries (old_text mismatch = normal retry, not error)
+		if (
+			(content.includes("ERR:") || content.includes("Error:") || content.includes("FAIL")) &&
+			!content.includes("old text must match") &&
+			!content.includes("The old text") &&
+			!content.includes("oldText not found") &&
+			!content.includes("old_text not found")
+		) {
+			const preview = content.slice(0, 150).replace(/\n/g, " ");
+			errorsHit.push(`${name}: ${preview}`);
+		}
+		// Track test results
+		if (content.includes("PASS") || content.includes("✅") || content.includes("✗") || content.includes("❌")) {
+			const lines = content.split("\n").filter((l: string) => /PASS|FAIL|✅|❌|✗/.test(l));
+			testResults.push(...lines.slice(0, 10));
+		}
+	}
+
+	return {
+		userAborted,
+		hasAuthError,
+		transient: isTransientError(rawMessages),
+		toolCallCount,
+		filesWritten,
+		filesEdited,
+		errorsHit,
+		testResults,
+		calledMemorySearch: toolNames.includes("memory_search"),
+		calledMemoryWrite: toolNames.includes("memory_write"),
+	};
+}
+
+/** Build the heuristic summary injected into the next phase's instruction. */
+export function buildPhaseSummary(analysis: PhaseEndAnalysis, maxToolCallsPerPhase: number): string {
+	const parts: string[] = [];
+	parts.push(`Tool calls: ${analysis.toolCallCount}`);
+	if (analysis.toolCallCount > maxToolCallsPerPhase) {
+		parts.push(
+			`⚠️ WARNING: Phase used ${analysis.toolCallCount} tool calls (limit: ${maxToolCallsPerPhase}). Possible loop detected.`,
+		);
+	}
+	if (analysis.filesWritten.length > 0) parts.push(`Files created/written: ${analysis.filesWritten.join(", ")}`);
+	if (analysis.filesEdited.length > 0) parts.push(`Files edited: ${analysis.filesEdited.join(", ")}`);
+	if (analysis.testResults.length > 0) parts.push(`Test results:\n${analysis.testResults.join("\n")}`);
+	if (analysis.errorsHit.length > 0)
+		parts.push(`Errors encountered: ${analysis.errorsHit.length}\n${analysis.errorsHit.slice(0, 5).join("\n")}`);
+	if (!analysis.calledMemorySearch) parts.push(`⚠️ Phase did NOT call memory_search (mandatory)`);
+	if (!analysis.calledMemoryWrite) parts.push(`⚠️ Phase did NOT call memory_write (mandatory)`);
+	return parts.join("\n");
+}
+
+/**
+ * Prefer the phase's canonical "## HANDOFF" block over the heuristic summary;
+ * fall back to the heuristic when the model did not write one.
+ */
+export function buildNextBrief(
+	analysis: PhaseEndAnalysis,
+	handoff: string,
+	phaseLabel: string,
+	maxToolCallsPerPhase: number,
+): string {
+	return handoff
+		? `Tool calls: ${analysis.toolCallCount}\n## HANDOFF (from ${phaseLabel})\n${handoff}`
+		: buildPhaseSummary(analysis, maxToolCallsPerPhase);
+}
+
+export type PhaseDecision =
+	| { action: "stop"; reason: "user-abort" | "auth-error" }
+	| { action: "retry-fallback" }
+	| { action: "pause-blocked" }
+	| { action: "review-fix-cycle" }
+	| {
+			action: "continue";
+			/** The phase answered with prose only — warn and nudge the next phase. */
+			zeroToolCalls: boolean;
+			/**
+			 * The phase was expected to write a "VERDICT:" line but none parsed —
+			 * a model deviated from the text contract. Surface it instead of
+			 * silently treating the phase as passed.
+			 */
+			missingVerdict: boolean;
+	  };
+
+export interface PhaseDecisionInput {
+	analysis: PhaseEndAnalysis;
+	/** Currently executing phase, or null when the queue raced. */
+	phase: { key: string; retried?: boolean } | null;
+	/** Resolved verdict (structured phase_result or parsed report; null = none). */
+	verdict: PhaseVerdict | null;
+	/** Completed review-fix cycles so far (bounded to one). */
+	reviewFixRounds: number;
+	maxToolCallsPerPhase: number;
+}
+
+/**
+ * Structured phase result: what a phase agent emits by CALLING the
+ * `phase_result` tool (robust primary path), instead of only writing markdown
+ * that has to be regex-scraped (fragile fallback). All fields optional — a
+ * partial structured emission is merged field-by-field with the parsed report.
+ */
+export interface StructuredPhaseResult {
+	verdict?: PhaseVerdict;
+	blocking?: string;
+	handoff?: string;
+}
+
+export interface EffectivePhaseOutcome {
+	verdict: PhaseVerdict | null;
+	blocking: string;
+	handoff: string;
+	/** Where each resolved field came from — for diagnostics and tests. */
+	source: "structured" | "text" | "mixed" | "none";
+}
+
+/**
+ * Resolve a phase's effective outcome, preferring the structured tool emission
+ * and falling back to the regex-scraped markdown report per field. This is the
+ * heart of the "structured primary, text fallback" contract: when the model
+ * calls phase_result the outcome is exact; when it doesn't, behavior is
+ * identical to the pure-text path that shipped before.
+ */
+export function resolvePhaseOutcome(
+	structured: StructuredPhaseResult | null,
+	reportText: string | null,
+): EffectivePhaseOutcome {
+	const textVerdict = reportText ? parsePhaseVerdict(reportText) : null;
+	const textBlocking = reportText ? extractBlockingFindings(reportText) : "";
+	const textHandoff = reportText ? extractHandoff(reportText) : "";
+
+	const verdict = structured?.verdict ?? textVerdict;
+	const blocking = structured?.blocking?.trim() || textBlocking;
+	const handoff = structured?.handoff?.trim() || textHandoff;
+
+	const usedStructured = Boolean(
+		structured && (structured.verdict || structured.blocking?.trim() || structured.handoff?.trim()),
+	);
+	const usedText = Boolean(textVerdict || textBlocking || textHandoff);
+	let source: EffectivePhaseOutcome["source"] = "none";
+	if (usedStructured && usedText) source = "mixed";
+	else if (usedStructured) source = "structured";
+	else if (usedText) source = "text";
+
+	return { verdict, blocking, handoff, source };
+}
+
+/** Phases whose contract REQUIRES a verdict (structured or a leading VERDICT: line). */
+const VERDICT_PHASES = new Set(["test", "review"]);
+
+/**
+ * Decide the transition after a phase's agent loop completed. Pure — the
+ * caller interprets the decision (notifications, queue edits, checkpoints).
+ */
+export function decidePhaseTransition(input: PhaseDecisionInput): PhaseDecision {
+	const { analysis, phase, verdict, reviewFixRounds, maxToolCallsPerPhase } = input;
+
+	if (analysis.userAborted) return { action: "stop", reason: "user-abort" };
+	if (analysis.hasAuthError) return { action: "stop", reason: "auth-error" };
+
+	// Transient provider/proxy failure: retry the SAME phase once on the
+	// fallback model (a different family often gets through).
+	if (phase && !phase.retried && analysis.transient) {
+		return { action: "retry-fallback" };
+	}
+
+	if (verdict === "BLOCKED" && phase) return { action: "pause-blocked" };
+
+	const looped = analysis.toolCallCount > maxToolCallsPerPhase;
+	if (phase?.key === "review" && verdict === "FAIL" && reviewFixRounds < 1 && !looped) {
+		return { action: "review-fix-cycle" };
+	}
+
+	// A TEST/REVIEW phase must produce a verdict (structured phase_result is
+	// mandatory for them, with the report's VERDICT line as fallback). If it
+	// completed with tool work but no verdict either way, that is a contract
+	// deviation worth surfacing — not silently passing. The zero-tool-call case
+	// has its own warning, so exclude it here to avoid a double warning.
+	const missingVerdict =
+		phase !== null && VERDICT_PHASES.has(phase.key) && verdict === null && analysis.toolCallCount > 0;
+
+	return {
+		action: "continue",
+		zeroToolCalls: analysis.toolCallCount === 0,
+		missingVerdict,
+	};
+}