@d3ara1n/pi-scout 1.1.0 → 1.1.1

package/src/model-switch.ts

@@ -12,26 +12,26 @@ import type { ModelRolesAPI } from "@d3ara1n/pi-model-roles";
  * @returns true if the switch was successful
  */
 export async function switchToRole(
-	pi: ExtensionAPI,
-	roleName: string,
-	rolesApi: ModelRolesAPI,
+  pi: ExtensionAPI,
+  roleName: string,
+  rolesApi: ModelRolesAPI,
 ): Promise<boolean> {
-	const resolved = await rolesApi.resolveRoleAsync(roleName);
+  const resolved = await rolesApi.resolveRoleAsync(roleName);
 
-	if (!resolved.model) {
-		console.warn(`[pi-scout] Role "${roleName}" could not be resolved — model not available`);
-		return false;
-	}
+  if (!resolved.model) {
+    console.warn(`[pi-scout] Role "${roleName}" could not be resolved — model not available`);
+    return false;
+  }
 
-	const success = await pi.setModel(resolved.model);
-	if (!success) {
-		console.warn(`[pi-scout] setModel() returned false for role "${roleName}" — no API key?`);
-		return false;
-	}
+  const success = await pi.setModel(resolved.model);
+  if (!success) {
+    console.warn(`[pi-scout] setModel() returned false for role "${roleName}" — no API key?`);
+    return false;
+  }
 
-	if (resolved.config.thinking) {
-		pi.setThinkingLevel(resolved.config.thinking);
-	}
+  if (resolved.config.thinking) {
+    pi.setThinkingLevel(resolved.config.thinking);
+  }
 
-	return true;
+  return true;
 }

package/src/scout-prompt.ts

@@ -6,8 +6,8 @@ import type { ScoutConfig } from "./types.ts";
 
 /** Previous turn context for better routing decisions. */
 export interface PrevTurnContext {
-	userPrompt: string;
-	assistantSummary: string;
+  userPrompt: string;
+  assistantSummary: string;
 }
 
 /**
@@ -17,30 +17,30 @@ export interface PrevTurnContext {
  * understand follow-up prompts like "continue", "change that", etc.
  */
 export function buildScoutUserMessage(
-	userPrompt: string,
-	currentRole: string,
-	prevTurn?: PrevTurnContext,
+  userPrompt: string,
+  currentRole: string,
+  prevTurn?: PrevTurnContext,
 ): string {
-	const parts: string[] = [];
+  const parts: string[] = [];
 
-	parts.push(`Current role: ${currentRole}`);
+  parts.push(`Current role: ${currentRole}`);
 
-	if (prevTurn && (prevTurn.userPrompt || prevTurn.assistantSummary)) {
-		parts.push(``);
-		parts.push(`## Previous Turn`);
-		if (prevTurn.userPrompt) {
-			parts.push(`User: ${prevTurn.userPrompt}`);
-		}
-		if (prevTurn.assistantSummary) {
-			parts.push(`Assistant: ${prevTurn.assistantSummary}`);
-		}
-	}
+  if (prevTurn && (prevTurn.userPrompt || prevTurn.assistantSummary)) {
+    parts.push(``);
+    parts.push(`## Previous Turn`);
+    if (prevTurn.userPrompt) {
+      parts.push(`User: ${prevTurn.userPrompt}`);
+    }
+    if (prevTurn.assistantSummary) {
+      parts.push(`Assistant: ${prevTurn.assistantSummary}`);
+    }
+  }
 
-	parts.push(``);
-	parts.push(`## Current User Prompt`);
-	parts.push(userPrompt);
+  parts.push(``);
+  parts.push(`## Current User Prompt`);
+  parts.push(userPrompt);
 
-	return parts.join("\n");
+  return parts.join("\n");
 }
 
 /**
@@ -52,48 +52,52 @@ export function buildScoutUserMessage(
  * prompt caching to activate.
  */
 export function buildScoutSystemPrompt(
-	config: ScoutConfig,
-	skillsList: string,
-	rolesList: string,
+  config: ScoutConfig,
+  skillsList: string,
+  rolesList: string,
 ): string {
-	const parts: string[] = [];
+  const parts: string[] = [];
 
-	parts.push(`You are a scout. Analyze the user's request and decide which skills and model role to use.`);
-	parts.push(``);
-	parts.push(`## Response Format`);
-	parts.push(`Respond with ONLY a JSON object, no markdown, no explanation outside the JSON:`);
-	parts.push(`{`);
-	parts.push(`  "skills": ["skill-name-1", "skill-name-2"],`);
-	parts.push(`  "role": "role-name-or-null",`);
-	parts.push(`  "reasoning": "one sentence explanation"`);
-	parts.push(`}`);
-	parts.push(``);
-	parts.push(`## Rules`);
-	parts.push(`- Select at most ${config.maxSelectedSkills} skills. Select 0 if none are relevant.`);
-	parts.push(`- Only select skills that will materially help with the task.`);
-	parts.push(`- If the task is trivial (simple question, acknowledgment), select 0 skills.`);
-	parts.push(`- "role" should be null if the current role is appropriate.`);
-	parts.push(`- Only suggest a role change when the task clearly benefits from a different model.`);
-	parts.push(`- Be conservative: prefer fewer skills and no role change when uncertain.`);
-	parts.push(`- Use the Previous Turn context to understand follow-up requests (e.g. "continue", "change that", "no, the other one").`);
+  parts.push(
+    `You are a scout. Analyze the user's request and decide which skills and model role to use.`,
+  );
+  parts.push(``);
+  parts.push(`## Response Format`);
+  parts.push(`Respond with ONLY a JSON object, no markdown, no explanation outside the JSON:`);
+  parts.push(`{`);
+  parts.push(`  "skills": ["skill-name-1", "skill-name-2"],`);
+  parts.push(`  "role": "role-name-or-null",`);
+  parts.push(`  "reasoning": "one sentence explanation"`);
+  parts.push(`}`);
+  parts.push(``);
+  parts.push(`## Rules`);
+  parts.push(`- Select at most ${config.maxSelectedSkills} skills. Select 0 if none are relevant.`);
+  parts.push(`- Only select skills that will materially help with the task.`);
+  parts.push(`- If the task is trivial (simple question, acknowledgment), select 0 skills.`);
+  parts.push(`- "role" should be null if the current role is appropriate.`);
+  parts.push(`- Only suggest a role change when the task clearly benefits from a different model.`);
+  parts.push(`- Be conservative: prefer fewer skills and no role change when uncertain.`);
+  parts.push(
+    `- Use the Previous Turn context to understand follow-up requests (e.g. "continue", "change that", "no, the other one").`,
+  );
 
-	// Stable prefix ends here. Sections below are injected conditionally per
-	// module toggle: a disabled module contributes no candidates, so the side
-	// agent has nothing to choose from for it (and the application layer zeros
-	// out its field regardless). The longer section (skills) comes first so
-	// toggling the later module (roles) only invalidates the cache tail —
-	// Anthropic prefix-cache matches the longest common prefix.
-	if (config.modules.skillRouter) {
-		parts.push(``);
-		parts.push(`## Available Skills`);
-		parts.push(skillsList || "(none)");
-	}
+  // Stable prefix ends here. Sections below are injected conditionally per
+  // module toggle: a disabled module contributes no candidates, so the side
+  // agent has nothing to choose from for it (and the application layer zeros
+  // out its field regardless). The longer section (skills) comes first so
+  // toggling the later module (roles) only invalidates the cache tail —
+  // Anthropic prefix-cache matches the longest common prefix.
+  if (config.modules.skillRouter) {
+    parts.push(``);
+    parts.push(`## Available Skills`);
+    parts.push(skillsList || "(none)");
+  }
 
-	if (config.modules.modelRouter) {
-		parts.push(``);
-		parts.push(`## Available Roles`);
-		parts.push(rolesList);
-	}
+  if (config.modules.modelRouter) {
+    parts.push(``);
+    parts.push(`## Available Roles`);
+    parts.push(rolesList);
+  }
 
-	return parts.join("\n");
+  return parts.join("\n");
 }

package/src/short-circuit.test.ts

@@ -5,114 +5,101 @@
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import {
-	normalizeAckPrompt,
-	buildAckSet,
-	evaluateShortCircuit,
-} from "./short-circuit.ts";
+import { normalizeAckPrompt, buildAckSet, evaluateShortCircuit } from "./short-circuit.ts";
 import type { ShortCircuitConfig } from "./types.ts";
 
 const CFG = (overrides: Partial<ShortCircuitConfig> = {}): ShortCircuitConfig => ({
-	trivialAck: true,
-	maxAckLength: 12,
-	ackPhrases: [],
-	...overrides,
+  trivialAck: true,
+  maxAckLength: 12,
+  ackPhrases: [],
+  ...overrides,
 });
 
 // ── normalizeAckPrompt ─────────────────────────────────────────
 
 test("normalizeAckPrompt strips trailing CJK/Latin punctuation", () => {
-	assert.equal(normalizeAckPrompt("好的。"), "好的");
-	assert.equal(normalizeAckPrompt("OK!"), "ok");
-	assert.equal(normalizeAckPrompt("  嗯  "), "嗯");
-	assert.equal(normalizeAckPrompt("はい。"), "はい");
-	assert.equal(normalizeAckPrompt("네!"), "네");
+  assert.equal(normalizeAckPrompt("好的。"), "好的");
+  assert.equal(normalizeAckPrompt("OK!"), "ok");
+  assert.equal(normalizeAckPrompt("  嗯  "), "嗯");
+  assert.equal(normalizeAckPrompt("はい。"), "はい");
+  assert.equal(normalizeAckPrompt("네!"), "네");
 });
 
 test("normalizeAckPrompt preserves internal punctuation", () => {
-	assert.equal(normalizeAckPrompt("好的，那我们继续"), "好的，那我们继续");
+  assert.equal(normalizeAckPrompt("好的，那我们继续"), "好的，那我们继续");
 });
 
 test("normalizeAckPrompt lowercases", () => {
-	assert.equal(normalizeAckPrompt("OK"), "ok");
-	assert.equal(normalizeAckPrompt("Sure"), "sure");
+  assert.equal(normalizeAckPrompt("OK"), "ok");
+  assert.equal(normalizeAckPrompt("Sure"), "sure");
 });
 
 test("normalizeAckPrompt empty for pure punctuation", () => {
-	assert.equal(normalizeAckPrompt("。。。"), "");
-	assert.equal(normalizeAckPrompt("   "), "");
+  assert.equal(normalizeAckPrompt("。。。"), "");
+  assert.equal(normalizeAckPrompt("   "), "");
 });
 
 // ── buildAckSet ────────────────────────────────────────────────
 
 test("buildAckSet includes defaults and user extras, normalized+deduped", () => {
-	const set = buildAckSet(["收到啦", "OK", "  custom  "]);
-	assert.ok(set.has("好的"));
-	assert.ok(set.has("ok"));
-	assert.ok(set.has("はい"));
-	assert.ok(set.has("네"));
-	assert.ok(set.has("收到啦"));
-	assert.ok(set.has("custom"));
+  const set = buildAckSet(["收到啦", "OK", "  custom  "]);
+  assert.ok(set.has("好的"));
+  assert.ok(set.has("ok"));
+  assert.ok(set.has("はい"));
+  assert.ok(set.has("네"));
+  assert.ok(set.has("收到啦"));
+  assert.ok(set.has("custom"));
 });
 
 test("buildAckSet ignores empty normalized entries", () => {
-	const set = buildAckSet(["。。。", ""]);
-	assert.equal(set.size > 0, true);
-	assert.ok(!set.has(""));
+  const set = buildAckSet(["。。。", ""]);
+  assert.equal(set.size > 0, true);
+  assert.ok(!set.has(""));
 });
 
 // ── evaluateShortCircuit ───────────────────────────────────────
 
 test("trivial ack short-circuits across 中/英/日/韓", () => {
-	const cfg = CFG();
-	for (const prompt of ["好的", "ok", "はい", "네", "嗯嗯", "sure", "了解"]) {
-		const r = evaluateShortCircuit(prompt, cfg);
-		assert.ok(r, `expected short-circuit for: ${prompt}`);
-		assert.equal(r!.reasoning, "trivial ack");
-	}
+  const cfg = CFG();
+  for (const prompt of ["好的", "ok", "はい", "네", "嗯嗯", "sure", "了解"]) {
+    const r = evaluateShortCircuit(prompt, cfg);
+    assert.ok(r, `expected short-circuit for: ${prompt}`);
+    assert.equal(r!.reasoning, "trivial ack");
+  }
 });
 
 test("trivial ack tolerates trailing punctuation", () => {
-	const r = evaluateShortCircuit("好的。", CFG());
-	assert.ok(r);
-	assert.equal(r!.reasoning, "trivial ack");
+  const r = evaluateShortCircuit("好的。", CFG());
+  assert.ok(r);
+  assert.equal(r!.reasoning, "trivial ack");
 });
 
 test("long prompt starting with ack is NOT short-circuited", () => {
-	const r = evaluateShortCircuit("好的，那我们重构整个模块吧", CFG());
-	assert.equal(r, null);
+  const r = evaluateShortCircuit("好的，那我们重构整个模块吧", CFG());
+  assert.equal(r, null);
 });
 
 test("prompt longer than maxAckLength is not an ack", () => {
-	assert.equal(
-		evaluateShortCircuit("understood thank you", CFG({ maxAckLength: 5 })),
-		null,
-	);
+  assert.equal(evaluateShortCircuit("understood thank you", CFG({ maxAckLength: 5 })), null);
 });
 
 test("trivialAck disabled → ack falls through to model", () => {
-	const r = evaluateShortCircuit("好的", CFG({ trivialAck: false }));
-	assert.equal(r, null);
+  const r = evaluateShortCircuit("好的", CFG({ trivialAck: false }));
+  assert.equal(r, null);
 });
 
 test("user ackPhrases extend the table", () => {
-	const r = evaluateShortCircuit("收到啦", CFG({ ackPhrases: ["收到啦"] }));
-	assert.ok(r);
-	assert.equal(r!.reasoning, "trivial ack");
+  const r = evaluateShortCircuit("收到啦", CFG({ ackPhrases: ["收到啦"] }));
+  assert.ok(r);
+  assert.equal(r!.reasoning, "trivial ack");
 });
 
 test("empty / punctuation-only prompt is not an ack", () => {
-	assert.equal(evaluateShortCircuit("", CFG()), null);
-	assert.equal(evaluateShortCircuit("。。。", CFG()), null);
+  assert.equal(evaluateShortCircuit("", CFG()), null);
+  assert.equal(evaluateShortCircuit("。。。", CFG()), null);
 });
 
 test("ordinary prompt falls through to model", () => {
-	assert.equal(
-		evaluateShortCircuit("帮我看看这个函数有没有性能问题", CFG()),
-		null,
-	);
-	assert.equal(
-		evaluateShortCircuit("what is the weather today", CFG()),
-		null,
-	);
+  assert.equal(evaluateShortCircuit("帮我看看这个函数有没有性能问题", CFG()), null);
+  assert.equal(evaluateShortCircuit("what is the weather today", CFG()), null);
 });

package/src/short-circuit.ts

@@ -21,8 +21,8 @@ import type { ShortCircuitConfig } from "./types.ts";
 
 /** Result of a successful short-circuit. */
 export interface ShortCircuitResult {
-	/** Short human-readable reason, surfaced in the status bar. */
-	reasoning: string;
+  /** Short human-readable reason, surfaced in the status bar. */
+  reasoning: string;
 }
 
 /**
@@ -33,20 +33,88 @@ export interface ShortCircuitResult {
  * would silently drop routing. User-supplied `ackPhrases` are merged on top.
  */
 const DEFAULT_ACK_PHRASES: string[] = [
-	// 中文
-	"好的", "好", "嗯", "嗯嗯", "嗯呢", "行", "可以", "对", "对的", "是", "是的",
-	"继续", "继续吧", "往下", "没问题", "明白", "收到", "了解", "知道了", "晓得",
-	"中", "成", "行吧", "可以的", "好的呀", "好嘞", "妥", "妥了", "嗯哼",
-	// English
-	"ok", "okay", "oki", "okie", "okk", "k", "sure", "yes", "yeah", "yep",
-	"yup", "continue", "go", "ahead", "go ahead", "sounds good", "got it",
-	"understood", "will do", "agreed", "roger", "proceed", "ack",
-	"acknowledged", "fine",
-	// 日本語
-	"はい", "うん", "おk", "続けて", "了解", "承知", "わかった", "分かった",
-	"ええ", "継続", "進めて", "いいよ", "いいです", "オッケー", "おけ",
-	// 한국어
-	"네", "응", "응응", "계속", "알겠어", "알겠음", "좋아", "그래", "오키",
+  // 中文
+  "好的",
+  "好",
+  "嗯",
+  "嗯嗯",
+  "嗯呢",
+  "行",
+  "可以",
+  "对",
+  "对的",
+  "是",
+  "是的",
+  "继续",
+  "继续吧",
+  "往下",
+  "没问题",
+  "明白",
+  "收到",
+  "了解",
+  "知道了",
+  "晓得",
+  "中",
+  "成",
+  "行吧",
+  "可以的",
+  "好的呀",
+  "好嘞",
+  "妥",
+  "妥了",
+  "嗯哼",
+  // English
+  "ok",
+  "okay",
+  "oki",
+  "okie",
+  "okk",
+  "k",
+  "sure",
+  "yes",
+  "yeah",
+  "yep",
+  "yup",
+  "continue",
+  "go",
+  "ahead",
+  "go ahead",
+  "sounds good",
+  "got it",
+  "understood",
+  "will do",
+  "agreed",
+  "roger",
+  "proceed",
+  "ack",
+  "acknowledged",
+  "fine",
+  // 日本語
+  "はい",
+  "うん",
+  "おk",
+  "続けて",
+  "了解",
+  "承知",
+  "わかった",
+  "分かった",
+  "ええ",
+  "継続",
+  "進めて",
+  "いいよ",
+  "いいです",
+  "オッケー",
+  "おけ",
+  // 한국어
+  "네",
+  "응",
+  "응응",
+  "계속",
+  "알겠어",
+  "알겠음",
+  "좋아",
+  "그래",
+  "오키",
 ];
 
 /**
@@ -56,11 +124,11 @@ const DEFAULT_ACK_PHRASES: string[] = [
  * @internal — exported for testing.
  */
 export function normalizeAckPrompt(input: string): string {
-	return input
-		.trim()
-		.toLowerCase()
-		.replace(/^[。！？.!?,，、~～…·\s]+/, "")
-		.replace(/[。！？.!?,，、~～…·\s]+$/, "");
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/^[。！？.!?,，、~～…·\s]+/, "")
+    .replace(/[。！？.!?,，、~～…·\s]+$/, "");
 }
 
 /**
@@ -69,13 +137,13 @@ export function normalizeAckPrompt(input: string): string {
  * @internal — exported for testing.
  */
 export function buildAckSet(extra: string[]): Set<string> {
-	const all = [...DEFAULT_ACK_PHRASES, ...extra];
-	const set = new Set<string>();
-	for (const phrase of all) {
-		const n = normalizeAckPrompt(phrase);
-		if (n.length > 0) set.add(n);
-	}
-	return set;
+  const all = [...DEFAULT_ACK_PHRASES, ...extra];
+  const set = new Set<string>();
+  for (const phrase of all) {
+    const n = normalizeAckPrompt(phrase);
+    if (n.length > 0) set.add(n);
+  }
+  return set;
 }
 
 /**
@@ -87,16 +155,16 @@ export function buildAckSet(extra: string[]): Set<string> {
  * @param config - Short-circuit tuning
  */
 export function evaluateShortCircuit(
-	prompt: string,
-	config: ShortCircuitConfig,
+  prompt: string,
+  config: ShortCircuitConfig,
 ): ShortCircuitResult | null {
-	if (!config.trivialAck) return null;
+  if (!config.trivialAck) return null;
 
-	const normalized = normalizeAckPrompt(prompt);
-	if (normalized.length === 0 || normalized.length > config.maxAckLength) {
-		return null;
-	}
+  const normalized = normalizeAckPrompt(prompt);
+  if (normalized.length === 0 || normalized.length > config.maxAckLength) {
+    return null;
+  }
 
-	const ackSet = buildAckSet(config.ackPhrases);
-	return ackSet.has(normalized) ? { reasoning: "trivial ack" } : null;
+  const ackSet = buildAckSet(config.ackPhrases);
+  return ackSet.has(normalized) ? { reasoning: "trivial ack" } : null;
 }