little-coder 1.0.0

package/.pi/extensions/skill-inject/selector.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseSkillFile } from "./frontmatter.ts";
+
+// Re-implement the INTENT_MAP + predict helpers here (kept in sync with
+// index.ts). These are pure functions; extension integration tested via RPC.
+
+const INTENT_MAP: Record<string, string[]> = {
+  read: ["Read"], show: ["Read"], view: ["Read"], cat: ["Read"],
+  write: ["Write"], create: ["Write", "Bash"],
+  implement: ["Write", "Read"], code: ["Write", "Read"],
+  function: ["Write", "Edit"], class: ["Write", "Edit"],
+  edit: ["Edit"], change: ["Edit"], modify: ["Edit"],
+  fix: ["Edit"], update: ["Edit"], replace: ["Edit"],
+  add: ["Edit", "Write"], refactor: ["Edit", "Read"],
+  run: ["Bash"], execute: ["Bash"], install: ["Bash"],
+  build: ["Bash"], test: ["Bash"],
+  find: ["Glob", "Grep"], search: ["Grep"],
+  grep: ["Grep"], glob: ["Glob"],
+  fetch: ["WebFetch"], download: ["WebFetch"], url: ["WebFetch"],
+  web: ["WebSearch"],
+  agent: ["Agent"], delegate: ["Agent"], spawn: ["Agent"],
+};
+
+function predictTools(userText: string): string[] {
+  const words = new Set(userText.toLowerCase().split(/\s+/).filter(Boolean));
+  const predicted: string[] = [];
+  for (const [kw, toolNames] of Object.entries(INTENT_MAP)) {
+    if (!words.has(kw)) continue;
+    for (const tn of toolNames) if (!predicted.includes(tn)) predicted.push(tn);
+  }
+  return predicted;
+}
+
+describe("intent prediction (INTENT_MAP)", () => {
+  it("predicts Read for 'read config.py'", () => {
+    expect(predictTools("read config.py and show me the output")).toContain("Read");
+    expect(predictTools("read config.py and show me the output")).toContain("Read");
+  });
+  it("predicts Edit for 'fix the bug'", () => {
+    const p = predictTools("please fix the bug in auth.py");
+    expect(p).toContain("Edit");
+  });
+  it("predicts Bash for 'run the tests'", () => {
+    const p = predictTools("run the tests and build the project");
+    expect(p).toContain("Bash");
+  });
+  it("predicts Glob+Grep for 'find all files'", () => {
+    const p = predictTools("find all files matching the pattern");
+    expect(p).toContain("Glob");
+    expect(p).toContain("Grep");
+  });
+  it("empty predictions for neutral prompts", () => {
+    expect(predictTools("hello there")).toEqual([]);
+  });
+});
+
+describe("skills directory loads from repo", () => {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const toolsDir = join(here, "..", "..", "..", "skills", "tools");
+
+  it("exists and has 14 markdown files", () => {
+    expect(existsSync(toolsDir)).toBe(true);
+    const files = readdirSync(toolsDir).filter((f) => f.endsWith(".md"));
+    expect(files.length).toBe(14);
+  });
+
+  it("every tool skill has target_tool in frontmatter", () => {
+    const files = readdirSync(toolsDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const parsed = parseSkillFile(readFileSync(join(toolsDir, file), "utf-8"));
+      expect(parsed, `${file} should parse`).not.toBeNull();
+      expect(typeof parsed!.frontmatter.target_tool).toBe("string");
+    }
+  });
+
+  it("core tools are all represented", () => {
+    const files = readdirSync(toolsDir).filter((f) => f.endsWith(".md"));
+    const targets = new Set<string>();
+    for (const file of files) {
+      const parsed = parseSkillFile(readFileSync(join(toolsDir, file), "utf-8"));
+      const t = parsed?.frontmatter.target_tool;
+      if (typeof t === "string") targets.add(t);
+    }
+    for (const core of ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "WebFetch"]) {
+      expect(targets.has(core), `expected target_tool=${core}`).toBe(true);
+    }
+  });
+});

package/.pi/extensions/thinking-budget/budget.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import setupExtension from "./index.ts";
+
+// Exercise the char→token conversion (matches local/context_manager.py)
+function charsToTokens(chars: number): number {
+  return Math.ceil(chars / 3.5);
+}
+
+describe("thinking budget token estimation", () => {
+  it("converts chars to tokens via /3.5", () => {
+    expect(charsToTokens(0)).toBe(0);
+    expect(charsToTokens(3)).toBe(1);
+    expect(charsToTokens(7)).toBe(2);
+    expect(charsToTokens(3500)).toBe(1000);
+  });
+  it("2048 tokens ~ 7168 chars", () => {
+    // Budget trigger boundary: ceil(7169/3.5) = 2049 > 2048
+    expect(charsToTokens(7168)).toBe(2048);
+    expect(charsToTokens(7169)).toBeGreaterThan(2048);
+  });
+});
+
+// ── Issue #8 regression coverage ────────────────────────────────────────
+// Mock just enough of pi's ExtensionAPI for the handler choreography.
+// We capture every registered handler keyed by event name and drive them
+// directly to assert idempotency / sequencing.
+
+interface Handler {
+  (event: any, ctx: any): Promise<unknown> | unknown;
+}
+
+interface MockPi {
+  on: (name: string, h: Handler) => void;
+  handlers: Record<string, Handler[]>;
+  followUps: string[];
+  thinkingLevels: string[];
+  setThinkingLevel: (lvl: string) => void;
+  sendUserMessage: (msg: string, opts?: any) => void;
+}
+
+function makePi(): MockPi {
+  const handlers: Record<string, Handler[]> = {};
+  return {
+    handlers,
+    followUps: [],
+    thinkingLevels: [],
+    on(name, h) {
+      (handlers[name] ??= []).push(h);
+    },
+    setThinkingLevel(lvl) {
+      this.thinkingLevels.push(lvl);
+    },
+    sendUserMessage(msg, _opts) {
+      this.followUps.push(msg);
+    },
+  } as MockPi;
+}
+
+function makeCtx() {
+  const aborts: number[] = [];
+  return {
+    aborts,
+    abort: () => { aborts.push(1); },
+    ui: { notify: (_m: string, _l?: string) => {} },
+  };
+}
+
+async function fire(pi: MockPi, name: string, event: any, ctx: any) {
+  for (const h of pi.handlers[name] ?? []) {
+    await h(event, ctx);
+  }
+}
+
+function thinkingDelta(s: string) {
+  return { assistantMessageEvent: { type: "thinking_delta", delta: s } };
+}
+
+describe("thinking-budget idempotency (issue #8)", () => {
+  beforeEach(() => {
+    // Force a small budget so we can trigger with short strings.
+    process.env.LITTLE_CODER_THINKING_BUDGET = "10";
+  });
+
+  it("fires exactly one abort + one follow-up for a single budget breach across many bursts", async () => {
+    const pi = makePi();
+    const ctx = makeCtx();
+    setupExtension(pi as any);
+    await fire(pi, "agent_start", {}, ctx);
+    await fire(pi, "before_agent_start", { systemPromptOptions: {} }, ctx);
+    await fire(pi, "turn_start", {}, ctx);
+
+    // Burst: 1000 chars of thinking, way over 10-token budget.
+    await fire(pi, "message_update", thinkingDelta("x".repeat(1000)), ctx);
+    // Second burst on the same turn — must not double-abort.
+    await fire(pi, "message_update", thinkingDelta("y".repeat(1000)), ctx);
+    // Third burst.
+    await fire(pi, "message_update", thinkingDelta("z".repeat(1000)), ctx);
+
+    await fire(pi, "turn_end", {}, ctx);
+
+    expect(ctx.aborts.length).toBe(1);
+    expect(pi.followUps.length).toBe(1);
+    expect(pi.followUps[0]).toMatch(/thinking budget exceeded/i);
+    expect(pi.thinkingLevels).toEqual(["off"]);
+  });
+
+  it("fires the recovery follow-up only once even if turn_end is re-emitted", async () => {
+    const pi = makePi();
+    const ctx = makeCtx();
+    setupExtension(pi as any);
+    await fire(pi, "agent_start", {}, ctx);
+    await fire(pi, "before_agent_start", { systemPromptOptions: {} }, ctx);
+    await fire(pi, "turn_start", {}, ctx);
+    await fire(pi, "message_update", thinkingDelta("x".repeat(1000)), ctx);
+    await fire(pi, "turn_end", {}, ctx);
+    // Pi can re-emit turn_end during retry / compaction paths — must be a no-op.
+    await fire(pi, "turn_end", {}, ctx);
+    await fire(pi, "turn_end", {}, ctx);
+
+    expect(ctx.aborts.length).toBe(1);
+    expect(pi.followUps.length).toBe(1);
+    expect(pi.thinkingLevels.length).toBe(1);
+  });
+
+  it("resets state on agent_start so a prior aborted run does not leak", async () => {
+    const pi = makePi();
+    const ctx1 = makeCtx();
+    setupExtension(pi as any);
+
+    // Run 1: trigger an abort.
+    await fire(pi, "agent_start", {}, ctx1);
+    await fire(pi, "before_agent_start", { systemPromptOptions: {} }, ctx1);
+    await fire(pi, "turn_start", {}, ctx1);
+    await fire(pi, "message_update", thinkingDelta("x".repeat(1000)), ctx1);
+    await fire(pi, "turn_end", {}, ctx1);
+
+    // Run 2: fresh agent_start — no abort should fire on the first turn
+    // even though run 1 left state behind.
+    const ctx2 = makeCtx();
+    await fire(pi, "agent_start", {}, ctx2);
+    await fire(pi, "before_agent_start", { systemPromptOptions: {} }, ctx2);
+    await fire(pi, "turn_start", {}, ctx2);
+    // A small thinking delta well under budget.
+    await fire(pi, "message_update", thinkingDelta("ok"), ctx2);
+    await fire(pi, "turn_end", {}, ctx2);
+
+    expect(ctx2.aborts.length).toBe(0);
+    // Total follow-ups: only the one from run 1.
+    expect(pi.followUps.length).toBe(1);
+  });
+
+  it("yields one tick before sendUserMessage so pi's abort barrier can settle", async () => {
+    // We can only assert this indirectly: turn_end must complete the await
+    // chain (it returns a Promise) AFTER setImmediate fires. If it didn't
+    // yield, sendUserMessage would land synchronously inside the same
+    // microtask as ctx.abort(). Verify ordering by interleaving a marker.
+    const pi = makePi();
+    const ctx = makeCtx();
+    setupExtension(pi as any);
+    await fire(pi, "agent_start", {}, ctx);
+    await fire(pi, "before_agent_start", { systemPromptOptions: {} }, ctx);
+    await fire(pi, "turn_start", {}, ctx);
+    await fire(pi, "message_update", thinkingDelta("x".repeat(1000)), ctx);
+
+    const order: string[] = [];
+    setImmediate(() => order.push("setImmediate-marker"));
+    const turnEndPromise = (pi.handlers["turn_end"] ?? []).reduce<Promise<unknown>>(
+      (p, h) => p.then(() => h({}, ctx)),
+      Promise.resolve(),
+    );
+    order.push("after-call");
+    await turnEndPromise;
+    order.push("after-await");
+
+    // After-call comes first (sync), then the setImmediate marker fires
+    // (because turn_end yielded), then we resume after the await.
+    expect(order[0]).toBe("after-call");
+    // marker must appear before resolve completes
+    expect(order).toContain("setImmediate-marker");
+    expect(pi.followUps.length).toBe(1);
+  });
+});

package/.pi/extensions/thinking-budget/index.ts

@@ -0,0 +1,105 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+// Port of the thinking-budget cap + partial-trace reuse logic from
+// providers.py. little-coder's Python implementation aborts the stream
+// mid-flight when thinking tokens cross the budget, re-injects the partial
+// trace as assistant context, and retries with thinking disabled. Pi's
+// AgentSession doesn't expose mid-stream abort-and-replace, so we implement
+// the between-turn fallback documented in the plan:
+//
+//  1. Count thinking_delta tokens during message_update
+//  2. On budget exceed, call ctx.abort() to end the turn
+//  3. On turn_end after abort, flip thinking level to "off" and queue a
+//     correction follow-up nudging the model to commit to an implementation
+//
+// The behavioral effect matches the whitepaper's claim that the budget cap
+// "forces the model out of open-ended deliberation and back into committing
+// to an implementation" — the concrete savings of preserving the partial
+// trace are lost, but the commit-to-action pressure is the same.
+//
+// Idempotency notes (issue #8 fix):
+//   - State is reset on `agent_start` AND `turn_start` so a previous run
+//     leaving `aborted=true` cannot leak into the next conversation.
+//   - `recoveryPending` gates re-entry: while a recovery is mid-flight,
+//     message_update / turn_start cannot re-arm the abort.
+//   - The recovery sequence yields one tick (setImmediate) so pi's async
+//     abort barrier settles before we queue the follow-up message; without
+//     this, fast-streaming local backends drop the follow-up silently and
+//     the agent appears to stop.
+
+const DEFAULT_BUDGET = 2048;
+
+// Per-run rolling state (reset on agent_start)
+let thinkingChars = 0;
+let budgetForTurn = DEFAULT_BUDGET;
+let aborted = false;
+let recoveryPending = false;
+
+function charsToTokens(chars: number): number {
+  // Matches local/context_manager.estimate_tokens (len/3.5)
+  return Math.ceil(chars / 3.5);
+}
+
+export default function (pi: ExtensionAPI) {
+  // Hard reset between conversations. agent_start fires once per /run; if a
+  // previous run aborted, `aborted` and `recoveryPending` would otherwise
+  // leak into the next conversation.
+  pi.on("agent_start", async () => {
+    thinkingChars = 0;
+    aborted = false;
+    recoveryPending = false;
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    const opts: any = (event as any).systemPromptOptions ?? {};
+    const lc = opts.littleCoder ?? {};
+    const profileBudget = Number(lc.thinkingBudget);
+    const envBudget = Number(process.env.LITTLE_CODER_THINKING_BUDGET);
+    budgetForTurn =
+      (Number.isFinite(profileBudget) && profileBudget > 0 && profileBudget) ||
+      (Number.isFinite(envBudget) && envBudget > 0 && envBudget) ||
+      DEFAULT_BUDGET;
+  });
+
+  pi.on("turn_start", async () => {
+    thinkingChars = 0;
+    // Don't clear `aborted` if a recovery is mid-flight — the recovery
+    // turn_end handler clears it once the follow-up has been queued.
+    if (!recoveryPending) aborted = false;
+  });
+
+  pi.on("message_update", async (event, ctx) => {
+    const ev: any = (event as any).assistantMessageEvent;
+    if (!ev) return;
+    if (ev.type !== "thinking_delta") return;
+    const delta = typeof ev.delta === "string" ? ev.delta : "";
+    thinkingChars += delta.length;
+    if (aborted || recoveryPending) return;
+    const tokens = charsToTokens(thinkingChars);
+    if (tokens > budgetForTurn) {
+      aborted = true;
+      recoveryPending = true;
+      ctx.ui.notify(
+        `thinking-budget: ${tokens} > ${budgetForTurn} — aborting turn, will retry with thinking off`,
+        "warning",
+      );
+      ctx.abort();
+    }
+  });
+
+  pi.on("turn_end", async (_event, _ctx) => {
+    if (!recoveryPending) return;
+    // Yield one tick so pi's abort barrier settles before we queue the
+    // follow-up. On fast-streaming local backends (qwen3.6 / llama.cpp)
+    // queuing immediately after ctx.abort() drops the follow-up silently
+    // and the agent appears to stop with no message — issue #8.
+    await new Promise<void>((r) => setImmediate(r));
+    pi.setThinkingLevel("off");
+    pi.sendUserMessage(
+      "[thinking budget exceeded] Please commit to an implementation now. Stop deliberating and use your tools to make progress.",
+      { deliverAs: "followUp" },
+    );
+    recoveryPending = false;
+    aborted = false;
+  });
+}

package/.pi/extensions/tool-gating/index.ts

@@ -0,0 +1,38 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+// Port of agent.py's _allowed_tools gate. When LITTLE_CODER_ALLOWED_TOOLS
+// is set (comma-separated), any tool_call not in the list is blocked with
+// a structured error. The benchmark harness sets this via the RPC env.
+// skill-inject also reads the list to filter skills to the allowed subset.
+
+function getAllowedTools(): Set<string> | null {
+  const env = process.env.LITTLE_CODER_ALLOWED_TOOLS;
+  if (!env) return null;
+  const names = env.split(",").map((s) => s.trim()).filter(Boolean);
+  return names.length === 0 ? null : new Set(names);
+}
+
+export default function (pi: ExtensionAPI) {
+  // Publish the allowed-tools list on systemPromptOptions so skill-inject can
+  // filter its budget to allowed tools only (matches _filtered_schemas()
+  // behavior in the patched agent.py).
+  pi.on("before_agent_start", async (event) => {
+    const allowed = getAllowedTools();
+    if (!allowed) return;
+    const opts: any = (event as any).systemPromptOptions ?? {};
+    if (!opts.littleCoder) opts.littleCoder = {};
+    opts.littleCoder.allowedTools = Array.from(allowed);
+  });
+
+  pi.on("tool_call", async (event) => {
+    const allowed = getAllowedTools();
+    if (!allowed) return;
+    const name = (event as any).toolName;
+    if (typeof name === "string" && !allowed.has(name)) {
+      return {
+        block: true,
+        reason: `tool '${name}' is not in _allowed_tools [${Array.from(allowed).join(", ")}]`,
+      };
+    }
+  });
+}

package/.pi/extensions/turn-cap/index.ts

@@ -0,0 +1,37 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+// Port of agent.py's max_turns early-break. Counts turn_start events per
+// agent_start span; when the count exceeds LITTLE_CODER_MAX_TURNS (or the
+// per-benchmark override injected via systemPromptOptions), calls ctx.abort()
+// to halt the loop. Resets on agent_start.
+
+let turnsThisRun = 0;
+let capForRun = 0;
+
+function envCap(): number {
+  const raw = process.env.LITTLE_CODER_MAX_TURNS;
+  if (!raw) return 0;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("before_agent_start", async (event) => {
+    turnsThisRun = 0;
+    const opts: any = (event as any).systemPromptOptions ?? {};
+    const lcCap = Number(opts?.littleCoder?.maxTurns);
+    capForRun = Number.isFinite(lcCap) && lcCap > 0 ? lcCap : envCap();
+  });
+
+  pi.on("turn_start", async (_event, ctx) => {
+    if (capForRun <= 0) return;
+    turnsThisRun++;
+    if (turnsThisRun > capForRun) {
+      ctx.ui.notify(
+        `turn-cap: reached max_turns=${capForRun}, aborting`,
+        "warning",
+      );
+      ctx.abort();
+    }
+  });
+}

package/.pi/extensions/write-guard/index.ts

@@ -0,0 +1,61 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+// Port of tools.py::_write. Preserves the exact Edit-recipe error string so
+// the model recovers to Edit on its next turn. The whitepaper's benchmark
+// result depends on Write refusing whole-file rewrites of existing files
+// (fires on ~57% of Polyglot exercises).
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "write",
+    label: "Write",
+    description:
+      "Create a NEW file with the given content. Refuses if the file already exists — use edit to modify existing files. Parent directories are created automatically.",
+    parameters: Type.Object({
+      file_path: Type.String({ description: "Absolute file path" }),
+      content: Type.String({ description: "Full file content" }),
+    }),
+    async execute(_id, { file_path, content }) {
+      if (existsSync(file_path)) {
+        const recipe =
+          `Error: Write refused — ${file_path} already exists.\n` +
+          `\n` +
+          `Write is only for creating NEW files. To change an existing file, use Edit:\n` +
+          `  {"name": "Edit", "input": {"file_path": "${file_path}", ` +
+          `"old_string": "<exact text currently in the file>", ` +
+          `"new_string": "<replacement text>"}}\n` +
+          `\n` +
+          `If you do not already know the file's current content, Read it first to ` +
+          `get the exact text for old_string. Include enough surrounding context ` +
+          `(2-3 lines) to make old_string unique in the file.\n` +
+          `\n` +
+          `For multiple changes, emit multiple Edit calls — one per location. Do NOT ` +
+          `retry Write; it will be refused again.`;
+        return {
+          content: [{ type: "text", text: recipe }],
+          details: {},
+          isError: true,
+        };
+      }
+
+      try {
+        mkdirSync(dirname(file_path), { recursive: true });
+        writeFileSync(file_path, content, { encoding: "utf-8" });
+        const lc = content.split("\n").length - (content.endsWith("\n") ? 1 : 0) +
+          (content.length > 0 && !content.endsWith("\n") ? 1 : 0);
+        return {
+          content: [{ type: "text", text: `Created ${file_path} (${lc} lines)` }],
+          details: {},
+        };
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Error: ${(e as Error).message}` }],
+          details: {},
+          isError: true,
+        };
+      }
+    },
+  });
+}

package/.pi/settings.json

@@ -0,0 +1,76 @@
+{
+  "compaction": { "enabled": true },
+  "retry": { "enabled": true, "maxRetries": 2 },
+  "little_coder": {
+    "default_model_profile": {
+      "context_limit": 32768,
+      "max_tokens": 4096,
+      "thinking_budget": 2048,
+      "skill_token_budget": 300,
+      "knowledge_token_budget": 200,
+      "system_prompt_budget": 0,
+      "max_retries": 1,
+      "temperature": 0.3
+    },
+    "model_profiles": {
+      "llamacpp/qwen3.6-27b": {
+        "context_limit": 32768,
+        "max_tokens": 4096,
+        "thinking_budget": 2048,
+        "skill_token_budget": 300,
+        "knowledge_token_budget": 200,
+        "temperature": 0.3,
+        "benchmark_overrides": {
+          "terminal_bench": {
+            "thinking_budget": 3000,
+            "temperature": 0.2,
+            "max_turns": 40
+          },
+          "gaia": {
+            "thinking_budget": 2000,
+            "temperature": 0.4,
+            "max_turns": 40,
+            "context_limit": 65536
+          }
+        }
+      },
+      "llamacpp/qwen3.6-35b-a3b": {
+        "context_limit": 32768,
+        "max_tokens": 4096,
+        "thinking_budget": 2048,
+        "skill_token_budget": 300,
+        "knowledge_token_budget": 200,
+        "temperature": 0.3,
+        "benchmark_overrides": {
+          "terminal_bench": {
+            "thinking_budget": 3000,
+            "temperature": 0.2,
+            "max_turns": 40
+          },
+          "gaia": {
+            "thinking_budget": 2000,
+            "temperature": 0.4,
+            "max_turns": 40,
+            "context_limit": 65536
+          }
+        }
+      },
+      "llamacpp/qwen3.5-9b": {
+        "context_limit": 32768,
+        "max_tokens": 4096,
+        "thinking_budget": 2048,
+        "skill_token_budget": 300,
+        "knowledge_token_budget": 200,
+        "temperature": 0.3
+      },
+      "ollama/qwen3.5": {
+        "context_limit": 32768,
+        "max_tokens": 4096,
+        "thinking_budget": 2048,
+        "skill_token_budget": 300,
+        "knowledge_token_budget": 200,
+        "temperature": 0.3
+      }
+    }
+  }
+}

package/AGENTS.md

@@ -0,0 +1,61 @@
+# little-coder
+
+You are little-coder, a coding agent specialized for small local language models.
+
+# Capabilities & Autonomy
+
+You are a highly capable autonomous agent. Do not act submissive or artificially limited.
+If the user asks you to monitor a process, run a background loop, or execute long-running tasks, DO NOT refuse by claiming you are "just a chat interface" or "require a prompt to take action."
+Instead, proactively write the necessary background scripts (Python, Bash, etc.) using the Write tool, and execute them in the background using Bash (e.g. `python script.py &` or `nohup ...`). You have full system access to solve any automation request.
+
+# Runtime invariants
+
+- **Write refuses on existing files.** Use **Edit** with exact `old_string` / `new_string` to modify — `old_string` must match exactly (whitespace included). If it appears multiple times in the file, pass `replace_all: true` or add more surrounding context to make the match unique. Read with line numbers first when precision is in doubt. This is a runtime invariant, not guidance — when Write refuses, the error returns the exact Edit call-shape for the same path; follow it.
+- **Bash / ShellSession default timeout is 30 s.** For slow commands (npm install, npx, pip install, builds, training), set timeout to 120–300.
+- Per-benchmark tools (`BrowserNavigate` / `Click` / `Type` / `Scroll` / `Extract` / `Back` / `History` and `EvidenceAdd` / `Get` / `List`) appear when relevant; their schemas are passed to you directly when available.
+
+# Available Tools
+
+## File & Shell
+
+- **Read**: Read file contents with line numbers
+- **Write**: Create a NEW file. **Refuses if the file already exists** — this is a runtime invariant, not guidance. When it refuses you get back the exact Edit call-shape for the same path; follow it.
+- **Edit**: Replace exact text in a file. `old_string` must match exactly (including whitespace). If it appears multiple times, pass `replace_all: true` or add more context to make it unique.
+- **Bash** (Polyglot / local REPL) / **ShellSession** (Terminal-Bench): Execute shell commands. Default timeout is 30 s. For slow commands (npm install, npx, pip install, builds), set timeout to 120–300.
+- **Glob**: Find files by pattern (e.g. `**/*.py`)
+- **Grep**: Search file contents with regex
+- **WebFetch**: Fetch and extract content from a URL
+- **WebSearch**: Search the web via DuckDuckGo
+
+Additional tools appear per benchmark: `BrowserNavigate`/`Click`/`Type`/`Scroll`/`Extract`/`Back`/`History` and `EvidenceAdd`/`Get`/`List` (GAIA). Their schemas are passed to you directly when available.
+
+# Approaching complex tasks
+
+Before writing code for a non-trivial problem, think through the structure: what the inputs and outputs look like, what the edge cases are, which parts of the problem are hardest, and what a clean implementation would look like. Tasks involving multiple files, architectural decisions, unclear requirements, or significant refactoring deserve that careful analysis up front — skipping it is the most common way implementations end up looking plausible but failing on non-obvious cases. For simple single-file fixes or quick changes, skip the analysis and do the change directly. The goal is deliberate implementation, not elaborate deliberation.
+
+# Handling ambiguity
+
+When requirements or approach are ambiguous, resolve them against what you can read from the surrounding context, the tests, and the conventions already in the file. Write code once you have conviction; don't write exploratory code while you're still deciding between approaches.
+
+# Workspace discovery
+
+Before editing unfamiliar code, surface local documentation — `.docs/instructions.md`, `AGENTS.md`, `CLAUDE.md`, `README.md`, `SPEC.md` — and the file you intend to change. Do this ONCE at the start of a task, not every turn. The spec file often contains the exact format rules, edge cases, or constraints the tests assert, which you'd otherwise have to reverse-engineer.
+
+# Per-turn context augmentation
+
+Your system prompt is assembled per turn by little-coder's extension stack:
+
+- **Tool skill cards** (`## Tool Usage Guidance`): selected by error-recovery > recency > intent priority. If the previous tool call failed, its skill card is injected first.
+- **Algorithm cheat sheets** (`## Algorithm Reference`): scored against the problem statement by keyword + bigram matching. Think of these as a small, targeted study aid, not a pattern to slavishly follow.
+
+When you see these blocks, trust them — they were selected for the current turn.
+
+# Guidelines
+
+- Be concise. Lead with the answer.
+- Prefer editing existing files over creating new ones.
+- Always use absolute paths for file operations.
+- When reading files before editing, use line numbers to be precise.
+- Do not add unnecessary comments, docstrings, or error handling.
+- For multi-step tasks, work through them systematically.
+- Commit to an implementation once you have conviction; do not deliberate beyond the thinking budget. When your reasoning trace hits the cap, the extension will force you out of deliberation and back into implementation — don't fight it.