muonroi-cli 1.2.0

package/src/pil/layer5-context.ts

@@ -0,0 +1,125 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { getEmbeddingRaw, searchCollection } from "../ee/bridge.js";
+import { truncateToBudget } from "./budget.js";
+import type { PipelineContext } from "./types.js";
+
+const STALE_THRESHOLD_MS = 30 * 60 * 1000;
+
+async function fetchPrinciples(raw: string, budget: number): Promise<string> {
+  try {
+    const vector = await getEmbeddingRaw(raw, AbortSignal.timeout(60));
+    if (!vector) return "";
+    const [t0, t1] = await Promise.all([
+      searchCollection("experience-principles", vector, 2, AbortSignal.timeout(40)),
+      searchCollection("experience-behavioral", vector, 3, AbortSignal.timeout(40)),
+    ]);
+    const points = [...t0, ...t1].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    if (points.length === 0) return "";
+    const lines = points.map((p) => {
+      const text = p.payload?.text ?? (p.payload?.json ? JSON.parse(p.payload.json as string).solution : "");
+      return `- ${String(text).slice(0, 120)}`;
+    });
+    return truncateToBudget(`[principles: Always-loaded experience]\n${lines.join("\n")}`, budget);
+  } catch {
+    return "";
+  }
+}
+
+async function fetchFlowState(cwd: string, budget: number): Promise<string> {
+  try {
+    const activeRunPath = path.join(cwd, ".muonroi-flow", "active-run");
+    const runId = (await fs.readFile(activeRunPath, "utf8")).trim();
+    if (!runId) return "";
+    const statePath = path.join(cwd, ".muonroi-flow", "runs", runId, "state.md");
+    const state = await fs.readFile(statePath, "utf8");
+    const phaseLine = state.match(/phase:\s*(.+)/i)?.[1]?.trim() ?? "unknown";
+    const statusLine = state.match(/status:\s*(.+)/i)?.[1]?.trim() ?? "unknown";
+    return truncateToBudget(`[flow: phase=${phaseLine}, status=${statusLine}, run=${runId}]`, budget);
+  } catch {
+    return "";
+  }
+}
+
+async function fetchRecentFiles(cwd: string, budget: number): Promise<string> {
+  try {
+    const srcDir = path.join(cwd, "src");
+    const entries = await fs.readdir(srcDir, { recursive: true, withFileTypes: true });
+    const tsFiles: Array<{ name: string; mtime: number }> = [];
+    for (const e of entries) {
+      if (!e.isFile()) continue;
+      if (!e.name.endsWith(".ts") && !e.name.endsWith(".tsx")) continue;
+      if (e.name.includes(".test.") || e.name.includes("__test")) continue;
+      const full = path.join(e.parentPath ?? (e as unknown as { path: string }).path, e.name);
+      const stat = await fs.stat(full);
+      tsFiles.push({ name: path.relative(srcDir, full).replace(/\\/g, "/"), mtime: stat.mtimeMs });
+    }
+    tsFiles.sort((a, b) => b.mtime - a.mtime);
+    const top = tsFiles.slice(0, 10).map((f) => f.name);
+    if (top.length === 0) return "";
+    return truncateToBudget(`[recent-files: ${top.join(", ")}]`, budget);
+  } catch {
+    return "";
+  }
+}
+
+export async function layer5Context(ctx: PipelineContext): Promise<PipelineContext> {
+  const cwd = process.cwd();
+  const parts: string[] = [];
+  const deltaSegments: string[] = [];
+
+  // 1. T0/T1 principles (12% budget)
+  const principlesBudget = Math.floor(ctx.tokenBudget * 0.12);
+  const principles = await fetchPrinciples(ctx.raw, principlesBudget);
+  if (principles) {
+    parts.push(principles);
+    deltaSegments.push(`principles=${principles.length}ch`);
+  }
+
+  // 2. Resume digest (5% budget)
+  const digest = ctx.resumeDigest;
+  if (digest?.trim()) {
+    const isStale = typeof ctx.digestAgeMs === "number" && ctx.digestAgeMs > STALE_THRESHOLD_MS;
+    const stalePrefix = isStale ? "(stale — verify before relying)\n" : "";
+    const hint = `[flow-context: Resume]\n${stalePrefix}${digest.trim()}`;
+    const trimmed = truncateToBudget(hint, Math.floor(ctx.tokenBudget * 0.05));
+    parts.push(trimmed);
+    deltaSegments.push(`digest=${trimmed.length}ch${isStale ? ",stale" : ""}`);
+  }
+
+  // 3. Flow state (5% budget)
+  const flowBudget = Math.floor(ctx.tokenBudget * 0.05);
+  const flowState = await fetchFlowState(cwd, flowBudget);
+  if (flowState) {
+    parts.push(flowState);
+    deltaSegments.push(`flow=${flowState.length}ch`);
+  }
+
+  // 4. Recent file index (3% budget)
+  const filesBudget = Math.floor(ctx.tokenBudget * 0.03);
+  const fileIndex = await fetchRecentFiles(cwd, filesBudget);
+  if (fileIndex) {
+    parts.push(fileIndex);
+    deltaSegments.push(`files=${fileIndex.length}ch`);
+  }
+
+  if (parts.length === 0) {
+    return {
+      ...ctx,
+      layers: [...ctx.layers, { name: "context-enrichment", applied: false, delta: "no-context-sources" }],
+    };
+  }
+
+  return {
+    ...ctx,
+    enriched: `${ctx.enriched}\n${parts.join("\n")}`,
+    layers: [
+      ...ctx.layers,
+      {
+        name: "context-enrichment",
+        applied: true,
+        delta: deltaSegments.join(" "),
+      },
+    ],
+  };
+}

package/src/pil/layer6-output.ts

@@ -0,0 +1,113 @@
+/**
+ * src/pil/layer6-output.ts
+ *
+ * Layer 6: Output optimization.
+ * Appends a per-task-type system prompt suffix via applyPilSuffix().
+ * Each suffix is tuned to minimize output tokens while preserving quality.
+ * Conversational turns (taskType=null) pass through unchanged.
+ *
+ * PIL-03: When ctx.outputStyle is null and ctx.taskType is not null,
+ * calls classifyViaBrain with a 50ms timeout for multilingual output style
+ * detection (Vietnamese+code mix that regex cannot handle). Fail-open:
+ * if brain returns null/timeout, ctx.outputStyle stays null.
+ */
+
+import type { ToolSet } from "ai";
+import type { OutputStyle, PipelineContext } from "./types.js";
+import { buildResponseTools } from "./response-tools.js";
+
+const SUFFIXES: Record<string, Record<OutputStyle, string>> = {
+  refactor: {
+    concise: `\nOUTPUT RULES (refactor): Show only changed code. Prefer unified diff or replacement function. No prose unless architecture changes. One sentence max if explanation needed. No preamble.`,
+    balanced: `\nOUTPUT RULES (refactor): Show changed code with brief rationale. Unified diff preferred. Short explanation allowed when architecture changes. Keep prose under 3 sentences.`,
+    detailed: `\nOUTPUT RULES (refactor): Show changed code with full rationale. Explain why each change improves the code. Include before/after comparison when helpful. Unified diff preferred.`,
+  },
+  debug: {
+    concise: `\nOUTPUT RULES (debug): Format = Hypothesis → Root cause (1 line) → Fix (code only) → Verify command. No preamble. No "I think" hedging.`,
+    balanced: `\nOUTPUT RULES (debug): Format = Hypothesis → Root cause → Fix (code) → Verify command. Brief explanation of why the bug occurs. Keep prose minimal.`,
+    detailed: `\nOUTPUT RULES (debug): Format = Hypothesis → Root cause analysis → Fix (code) → Verify command → Prevention. Explain the underlying mechanism and why this fix is correct.`,
+  },
+  plan: {
+    concise: `\nOUTPUT RULES (plan): Numbered steps only. Each step: action verb + acceptance criterion. No prose paragraphs. Add "Assumptions:" section only if needed.`,
+    balanced: `\nOUTPUT RULES (plan): Numbered steps with brief rationale per step. Each step: action verb + acceptance criterion + why. Add "Assumptions:" and "Risks:" sections if applicable.`,
+    detailed: `\nOUTPUT RULES (plan): Numbered steps with full rationale. Each step: action verb + acceptance criterion + why + alternatives considered. Include "Assumptions:", "Risks:", and "Trade-offs:" sections.`,
+  },
+  analyze: {
+    concise: `\nOUTPUT RULES (analyze): Bullet findings with evidence (file:line or direct quote). Add severity label (High/Med/Low) when applicable. No filler sentences.`,
+    balanced: `\nOUTPUT RULES (analyze): Bullet findings with evidence (file:line or direct quote). Add severity label and brief explanation. Context for each finding.`,
+    detailed: `\nOUTPUT RULES (analyze): Bullet findings with evidence (file:line or direct quote). Add severity label, root cause analysis, and recommended action. Provide context and impact assessment.`,
+  },
+  documentation: {
+    concise: `\nOUTPUT RULES (documentation): Markdown only. Lead with a code example, then explanation. No "This function..." openers. All examples in fenced code blocks.`,
+    balanced: `\nOUTPUT RULES (documentation): Markdown only. Lead with a code example, then explanation with context. Cover common use cases. All examples in fenced code blocks.`,
+    detailed: `\nOUTPUT RULES (documentation): Markdown only. Lead with a code example, then thorough explanation. Cover use cases, edge cases, and gotchas. All examples in fenced code blocks. Include parameter descriptions and return value explanations.`,
+  },
+  generate: {
+    concise: `\nOUTPUT RULES (generate): Complete, runnable code only. Include all imports. Brief inline comments for non-obvious logic only. No prose outside code blocks. No partial snippets.`,
+    balanced: `\nOUTPUT RULES (generate): Complete, runnable code with brief explanation. Include all imports. Inline comments for key decisions. Short prose before code block explaining approach.`,
+    detailed: `\nOUTPUT RULES (generate): Complete, runnable code with full explanation. Include all imports. Inline comments for logic and decisions. Explain design choices, alternatives considered, and trade-offs before the code.`,
+  },
+  general: {
+    concise: `\nAnswer directly. No preamble.`,
+    balanced: `\nAnswer with brief context.`,
+    detailed: `\nAnswer thoroughly.`,
+  },
+};
+
+export function applyPilSuffix(systemPrompt: string, ctx: PipelineContext, responseToolsActive = false): string {
+  if (!ctx.taskType || !SUFFIXES[ctx.taskType]) return systemPrompt;
+  if (responseToolsActive) {
+    return (
+      systemPrompt +
+      `\nOUTPUT FORMAT: When you finish your work, use the respond_${ctx.taskType} tool to structure your final answer. You may write free-form text to explain your reasoning during the process. Use action tools (bash, read_file, edit_file, etc.) as needed, then summarize your result via respond_${ctx.taskType}.`
+    );
+  }
+  const style: OutputStyle = ctx.outputStyle ?? "concise";
+  return systemPrompt + SUFFIXES[ctx.taskType][style];
+}
+
+export function getResponseToolSet(ctx: PipelineContext): ToolSet {
+  if (!ctx.taskType) return {};
+  return buildResponseTools(ctx.taskType);
+}
+
+export async function layer6Output(ctx: PipelineContext): Promise<PipelineContext> {
+  try {
+    if (ctx.taskType === null) {
+      return {
+        ...ctx,
+        layers: [...ctx.layers, { name: "output-optimization", applied: false, delta: null }],
+      };
+    }
+
+    // Style already resolved by L1 (brain detection) + L2 (config fallback)
+    const style: OutputStyle = ctx.outputStyle ?? "concise";
+
+    const taskKey = ctx.taskType as string;
+    const suffixEntry = SUFFIXES[taskKey];
+    if (!suffixEntry) {
+      return {
+        ...ctx,
+        layers: [...ctx.layers, { name: "output-optimization", applied: false, delta: "no-suffix-entry" }],
+      };
+    }
+
+    const suffix = suffixEntry[style];
+    return {
+      ...ctx,
+      layers: [
+        ...ctx.layers,
+        {
+          name: "output-optimization",
+          applied: true,
+          delta: `suffix=${ctx.taskType},style=${style},chars=${suffix.trim().length}`,
+        },
+      ],
+    };
+  } catch {
+    return {
+      ...ctx,
+      layers: [...ctx.layers, { name: "output-optimization", applied: false, delta: null }],
+    };
+  }
+}

package/src/pil/ollama-classify.ts

@@ -0,0 +1,49 @@
+/**
+ * src/pil/ollama-classify.ts
+ *
+ * Ollama-based intent classification fallback for Layer 1.
+ * Called only when regex classifier and keyword fallback both miss.
+ * 150ms timeout via AbortController — fail-open on any error.
+ */
+
+import type { TaskType } from "./types.js";
+
+export interface OllamaClassifyResult {
+  taskType: TaskType;
+  confidence: number;
+}
+
+const OLLAMA_TIMEOUT_MS = 150;
+const OLLAMA_BASE_URL = "http://localhost:11434";
+const OLLAMA_MODEL = "gemma2:2b";
+
+const VALID_TASK_TYPES: TaskType[] = ["refactor", "debug", "plan", "analyze", "documentation", "generate"];
+
+export async function ollamaClassify(prompt: string): Promise<OllamaClassifyResult | null> {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), OLLAMA_TIMEOUT_MS);
+
+    const response = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: OLLAMA_MODEL,
+        prompt: `Classify this prompt into exactly one category: refactor, debug, plan, analyze, documentation, generate, or none. Reply with ONLY the category name.\n\nPrompt: "${prompt}"`,
+        stream: false,
+      }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timer);
+    if (!response.ok) return null;
+
+    const data = (await response.json()) as { response?: string };
+    const raw = (data.response ?? "").trim().toLowerCase();
+    const matched = VALID_TASK_TYPES.find((t) => raw.includes(t));
+
+    return matched ? { taskType: matched, confidence: 0.55 } : null;
+  } catch {
+    return null;
+  }
+}

package/src/pil/pipeline.ts

@@ -0,0 +1,112 @@
+/**
+ * src/pil/pipeline.ts
+ *
+ * runPipeline() entry point: orchestrates 6 sequential layers with a 200ms timeout.
+ * Fail-open: any unhandled error or timeout returns the original fallback context.
+ *
+ * CRITICAL: fallback is captured BEFORE runLayers() starts to ensure the timeout
+ * path returns a pristine context (Pitfall 4 from RESEARCH.md).
+ */
+
+import { DEFAULT_TOKEN_BUDGET } from "./budget.js";
+import { layer1Intent } from "./layer1-intent.js";
+import { layer2Personality } from "./layer2-personality.js";
+import { layer3EeInjection } from "./layer3-ee-injection.js";
+import { layer4Gsd } from "./layer4-gsd.js";
+import { layer5Context } from "./layer5-context.js";
+import { layer6Output } from "./layer6-output.js";
+import { PipelineContextSchema } from "./schema.js";
+import { setPilLastResult } from "./store.js";
+import { resolveAfter } from "./timeout.js";
+import type { PipelineContext } from "./types.js";
+
+const SKIPPED_LAYERS = [
+  "personality-adaptation",
+  "ee-experience-injection",
+  "gsd-workflow-structuring",
+  "context-enrichment",
+];
+
+async function runLayers(ctx: PipelineContext): Promise<PipelineContext> {
+  const pipelineStart = Date.now();
+  const timings: Array<{ name: string; ms: number }> = [];
+
+  async function timed(name: string, fn: (c: PipelineContext) => Promise<PipelineContext>): Promise<void> {
+    const start = Date.now();
+    ctx = await fn(ctx);
+    timings.push({ name, ms: Date.now() - start });
+  }
+
+  await timed("layer1-intent", layer1Intent);
+
+  if (ctx.taskType !== null) {
+    await timed("layer2-personality", layer2Personality);
+    await timed("layer3-ee-injection", layer3EeInjection);
+    await timed("layer4-gsd-structuring", layer4Gsd);
+    await timed("layer5-context-enrichment", layer5Context);
+  } else {
+    for (const name of SKIPPED_LAYERS) {
+      timings.push({ name: `layer-${name}`, ms: 0 });
+    }
+    ctx = {
+      ...ctx,
+      layers: [
+        ...ctx.layers,
+        ...SKIPPED_LAYERS.map((name) => ({ name, applied: false, delta: "skipped:null-taskType" })),
+      ],
+    };
+  }
+
+  await timed("layer6-output", layer6Output);
+
+  const suffixCharsMatch = ctx.layers.find((l) => l.name === "output-optimization")?.delta?.match(/chars=(\d+)/);
+  const suffixChars = suffixCharsMatch ? parseInt(suffixCharsMatch[1], 10) : 0;
+
+  const enrichmentCharsAdded = Math.max(0, ctx.enriched.length - ctx.raw.length);
+
+  ctx = {
+    ...ctx,
+    metrics: {
+      totalMs: Date.now() - pipelineStart,
+      layerTimings: timings,
+      inputChars: ctx.raw.length,
+      outputChars: ctx.enriched.length,
+      estimatedTokensSaved: Math.round(suffixChars / 4),
+      enrichmentTokensAdded: Math.round(enrichmentCharsAdded / 4),
+    },
+  };
+
+  return ctx;
+}
+
+export interface PipelineOptions {
+  gsdPhase?: string | null;
+  resumeDigest?: string | null;
+  activeRunId?: string | null;
+}
+
+export async function runPipeline(raw: string, options?: PipelineOptions): Promise<PipelineContext> {
+  const fallback: PipelineContext = {
+    raw,
+    enriched: raw,
+    taskType: null,
+    domain: null,
+    confidence: 0,
+    outputStyle: null,
+    tokenBudget: DEFAULT_TOKEN_BUDGET,
+    metrics: null,
+    layers: [],
+    gsdPhase: options?.gsdPhase ?? null,
+    resumeDigest: options?.resumeDigest ?? null,
+    activeRunId: options?.activeRunId ?? null,
+  };
+  try {
+    const result = await Promise.race([runLayers({ ...fallback }), resolveAfter(200, fallback)]);
+    const validated = PipelineContextSchema.safeParse(result).success ? result : fallback;
+    setPilLastResult(validated);
+    return validated;
+  } catch {
+    setPilLastResult(fallback);
+    return fallback;
+  }
+}

package/src/pil/response-tools.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import type { ToolSet } from "ai";
+
+const RefactorSchema = z.object({
+  summary: z.string().describe("One-line summary of what changed"),
+  changes: z.array(
+    z.object({
+      file: z.string().describe("File path"),
+      diff: z.string().describe("Unified diff or replacement code"),
+    }),
+  ),
+  verify_command: z.string().optional().describe("Command to verify the change"),
+});
+
+const DebugSchema = z.object({
+  hypothesis: z.string().describe("What you think is wrong"),
+  root_cause: z.string().describe("Confirmed root cause, one line"),
+  fix: z.object({
+    file: z.string(),
+    diff: z.string().describe("Code fix as unified diff"),
+  }),
+  verify_command: z.string().describe("Command to verify the fix"),
+});
+
+const PlanSchema = z.object({
+  steps: z.array(
+    z.object({
+      action: z.string().describe("Action verb + what to do"),
+      criterion: z.string().describe("How to know this step is done"),
+      rationale: z.string().optional().describe("Why this step"),
+    }),
+  ),
+  assumptions: z.array(z.string()).optional(),
+  risks: z.array(z.string()).optional(),
+});
+
+const AnalyzeSchema = z.object({
+  findings: z.array(
+    z.object({
+      text: z.string().describe("Finding description"),
+      evidence: z.string().describe("file:line or direct quote"),
+      severity: z.enum(["high", "medium", "low"]).describe("Impact level"),
+    }),
+  ),
+});
+
+const DocsSchema = z.object({
+  content: z.string().describe("Markdown documentation"),
+  examples: z
+    .array(
+      z.object({
+        code: z.string(),
+        description: z.string(),
+      }),
+    )
+    .optional(),
+});
+
+const GenerateSchema = z.object({
+  files: z.array(
+    z.object({
+      path: z.string().describe("Output file path"),
+      content: z.string().describe("Complete file content with all imports"),
+      language: z.string().describe("Language identifier"),
+    }),
+  ),
+  explanation: z.string().optional().describe("Brief design rationale"),
+});
+
+const GeneralSchema = z.object({
+  response: z.string().describe("Direct answer to the user"),
+  reasoning: z.string().optional().describe("Optional brief reasoning"),
+});
+
+const RESPONSE_SCHEMAS: Record<string, z.ZodType> = {
+  refactor: RefactorSchema,
+  debug: DebugSchema,
+  plan: PlanSchema,
+  analyze: AnalyzeSchema,
+  documentation: DocsSchema,
+  generate: GenerateSchema,
+  general: GeneralSchema,
+};
+
+export const RESPONSE_TOOL_PREFIX = "respond_";
+
+export function isResponseTool(toolName: string): boolean {
+  return toolName.startsWith(RESPONSE_TOOL_PREFIX);
+}
+
+export function getResponseTaskType(toolName: string): string | null {
+  const suffix = toolName.slice(RESPONSE_TOOL_PREFIX.length);
+  return suffix in RESPONSE_SCHEMAS ? suffix : null;
+}
+
+export function buildResponseTools(taskType: string): ToolSet {
+  const schema = RESPONSE_SCHEMAS[taskType];
+  if (!schema) return {};
+
+  const toolName = `${RESPONSE_TOOL_PREFIX}${taskType}`;
+  return {
+    [toolName]: {
+      description: `Return your ${taskType} response as structured JSON. Always use this tool to respond.`,
+      inputSchema: schema,
+      execute: async (input: unknown) => input,
+    },
+  };
+}
+
+export { RefactorSchema, DebugSchema, PlanSchema, AnalyzeSchema, DocsSchema, GenerateSchema, GeneralSchema };

package/src/pil/schema.ts

@@ -0,0 +1,49 @@
+/**
+ * src/pil/schema.ts
+ *
+ * Zod schemas for runtime validation of PIL pipeline output.
+ * Used in runPipeline() with safeParse — fail-open on invalid data.
+ */
+
+import { z } from "zod";
+
+export const TaskTypeSchema = z.enum(["refactor", "debug", "plan", "analyze", "documentation", "generate"]);
+
+export const OutputStyleSchema = z.enum(["concise", "detailed", "balanced"]);
+
+export const LayerResultSchema = z.object({
+  name: z.string(),
+  applied: z.boolean(),
+  delta: z.string().nullable(),
+});
+
+export const LayerTimingSchema = z.object({
+  name: z.string(),
+  ms: z.number().min(0),
+});
+
+export const PipelineMetricsSchema = z.object({
+  totalMs: z.number().min(0),
+  layerTimings: z.array(LayerTimingSchema),
+  inputChars: z.number().min(0),
+  outputChars: z.number().min(0),
+  estimatedTokensSaved: z.number().min(0),
+  enrichmentTokensAdded: z.number().min(0),
+});
+
+export const PipelineContextSchema = z.object({
+  raw: z.string(),
+  enriched: z.string(),
+  taskType: TaskTypeSchema.nullable(),
+  domain: z.string().nullable(),
+  confidence: z.number().min(0).max(1),
+  outputStyle: OutputStyleSchema.nullable(),
+  tokenBudget: z.number().positive(),
+  metrics: PipelineMetricsSchema.nullable(),
+  layers: z.array(LayerResultSchema),
+  // P2: optional context fields
+  gsdPhase: z.string().nullable().optional(),
+  resumeDigest: z.string().nullable().optional(),
+  activeRunId: z.string().nullable().optional(),
+  digestAgeMs: z.number().nullable().optional(),
+});

package/src/pil/store.ts

@@ -0,0 +1,29 @@
+/**
+ * src/pil/store.ts
+ *
+ * Module-level last-result store for the /optimize command.
+ * Single-threaded per session — no zustand needed.
+ */
+
+import type { PipelineContext } from "./types.js";
+
+export type OutputMode = "structured" | "text-fallback" | "conversational";
+
+let _last: PipelineContext | null = null;
+let _lastOutputMode: OutputMode = "conversational";
+
+export function setPilLastResult(ctx: PipelineContext): void {
+  _last = ctx;
+}
+
+export function getPilLastResult(): PipelineContext | null {
+  return _last;
+}
+
+export function setLastOutputMode(mode: OutputMode): void {
+  _lastOutputMode = mode;
+}
+
+export function getLastOutputMode(): OutputMode {
+  return _lastOutputMode;
+}

package/src/pil/task-tier-map.ts

@@ -0,0 +1,90 @@
+/**
+ * src/pil/task-tier-map.ts
+ *
+ * Maps PIL TaskTypes to EE routing tiers.
+ * EE tiers: 'fast' | 'balanced' | 'premium'
+ *
+ * Rationale for each mapping:
+ * - fast: Low-complexity tasks where speed matters more than model depth
+ * - balanced: Most coding tasks — needs competence but not premium reasoning
+ * - premium: High-stakes planning tasks requiring deep reasoning
+ */
+
+import type { ModelRole } from "../utils/settings.js";
+
+export type EETier = "fast" | "balanced" | "premium";
+
+const MAP: Record<string, EETier> = {
+  refactor: "balanced",
+  debug: "balanced",
+  plan: "premium",
+  analyze: "balanced",
+  documentation: "fast",
+  generate: "balanced",
+  general: "fast",
+};
+
+/**
+ * Map a PIL taskType to an EE routing tier.
+ * Returns 'fast' for null (conversational turns).
+ * Returns 'balanced' for unknown task types (safe fallback).
+ */
+export function taskTypeToTier(taskType: string | null): EETier {
+  if (!taskType) return "fast";
+  return MAP[taskType] ?? "balanced";
+}
+
+/**
+ * Map a PIL taskType to an appropriate maxOutputTokens budget.
+ * Keeps conversational turns short and reserves headroom for generation-heavy tasks.
+ */
+export function taskTypeToMaxTokens(taskType: string | null): number {
+  switch (taskType) {
+    case "analyze":
+    case "documentation":
+      return 4_096;
+    case "debug":
+    case "refactor":
+      return 6_144;
+    case "plan":
+      return 8_192;
+    case "generate":
+      return 12_288;
+    default:
+      return 4_096; // conversational — keep short
+  }
+}
+
+/**
+ * Map a PIL taskType to a reasoning effort level.
+ * High-stakes planning gets full reasoning; simple tasks get minimal.
+ */
+export function taskTypeToReasoningEffort(taskType: string | null): "low" | "medium" | "high" {
+  switch (taskType) {
+    case "plan":
+      return "high";
+    case "debug":
+    case "refactor":
+    case "generate":
+      return "medium";
+    case "analyze":
+    case "documentation":
+      return "low";
+    default:
+      return "low"; // conversational — minimal reasoning
+  }
+}
+
+const ROLE_MAP: Record<string, ModelRole> = {
+  plan: "leader",
+  analyze: "leader",
+  generate: "implement",
+  refactor: "implement",
+  debug: "verify",
+  documentation: "research",
+};
+
+export function taskTypeToRole(taskType: string | null): ModelRole | null {
+  if (!taskType) return null;
+  return ROLE_MAP[taskType] ?? null;
+}

package/src/pil/timeout.ts

@@ -0,0 +1,10 @@
+/**
+ * src/pil/timeout.ts
+ *
+ * Promise.race timeout helper for the PIL pipeline.
+ * Returns a promise that resolves to `value` after `ms` milliseconds.
+ */
+
+export function resolveAfter<T>(ms: number, value: T): Promise<T> {
+  return new Promise<T>((resolve) => setTimeout(() => resolve(value), ms));
+}