mono-pilot 0.1.0 → 0.2.0

package/README.md

@@ -1,39 +1,19 @@
 # MonoPilot
 
-> Cursor-compatible coding agent profile powered by pi-mono.
+> Cursor-compatible coding agent profile powered by [pi](https://github.com/badlogic/pi-mono).
 
-**⚠️ Disclaimer:** This project is an independent compatibility implementation and is **not affiliated with Cursor** or Anysphere Inc.
+MonoPilot is a lightweight, highly customizable Cursor-compatible coding agent built on top of the [pi](https://github.com/badlogic/pi-mono) framework. It is designed for developers who want full control over how their coding agent behaves, prefer not to pay a middleman, and want to explore the limits of a lean agent architecture.
 
-## MVP Scope (Current)
+## Why MonoPilot
 
-This repository is intentionally in a **minimal MVP** stage:
+- Transparent prompt/runtime envelope with inspection tooling.
+- Cursor-styled tool layer replaces default pi tools so launch-time capability and behavior are defined by MonoPilot.
+- Extensible tool layer with MCP support for custom tools and resources.
 
-- ✅ Core toolset is wired through `mono-pilot` extensions (`read`, `rg`, `glob`, `shell`, `delete`, `apply_patch`).
-- ✅ Built-in `edit` / `write` are removed from default exposed tools.
-- ✅ File mutation is funneled through `apply_patch` (which internally delegates to robust pi-mono primitives).
-- ✅ Additional tools can be migrated incrementally without changing the launcher architecture.
-
-## What ships now
-
-- `src/cli.ts` – `mono-pilot` launcher that wraps `pi`
-- `src/extensions/mono-pilot.ts` – extension entrypoint (wires the current toolset)
-- `tools/*.ts` – tool implementations (`read`, `rg`, `glob`, `shell`, `delete`, `apply_patch`)
-- `tools/*.md` – tool prompt specs injected at runtime
-
-## Local development setup
-
-```bash
-git clone https://github.com/qianwan/mono-pilot.git
-cd mono-pilot
-npm install
-npm run build
-```
-
-## Use in any repository
+## Quickstart
 
 ```bash
 # Run directly without global install
-cd /path/to/your/project
 npx mono-pilot
 
 # Or install globally
@@ -58,30 +38,115 @@ By default, `mono-pilot` launches pi with:
 
 - `--no-extensions`
 - `--extension <mono-pilot extension>`
-- `--tools read,bash,grep,find,ls`
+- `--tools ls` (only when you do not pass `--tools` or `--no-tools`)
+
+If you pass `--tools`, MonoPilot removes built-in `edit`, `write`, `read`, `grep`, `glob`, and `bash` so the extension-provided Cursor-styled tools are used instead. If the list becomes empty, it falls back to `ls`. The write path is provided by the `ApplyPatch` tool from the extension.
+
+## What ships now
+
+- `src/cli.ts` – launcher that wraps `pi`
+- `src/extensions/mono-pilot.ts` – extension entrypoint (tool wiring)
+- `src/extensions/system-prompt.ts` – provider-agnostic prompt stack
+- `src/extensions/user-message.ts` – user message envelope assembly
+- `tools/` – tool implementations and descriptions (see `tools/README.md`)
+
+## Cursor-styled tools
+
+MonoPilot exposes a Cursor-style tool set to highlight capability at launch:
+
+These replace pi defaults such as `edit`, `write`, `read`, `grep`, `glob`, and `bash`.
+
+Default-to-MonoPilot mapping:
+
+- `edit` / `write` → `ApplyPatch`
+- `read` → `ReadFile`
+- `grep` → `rg`
+- `glob` → `Glob`
+- `bash` → `Shell`
+
+The full Cursor-styled tool list exposed by the extension:
+
+- `Shell` – execute shell commands in the workspace
+- `Glob` – find paths by glob pattern
+- `rg` – search file content with ripgrep
+- `ReadFile` – read file content with pagination
+- `Delete` – delete files or directories
+- `SemanticSearch` – semantic search by intent
+- `WebSearch` – search the web with snippets
+- `WebFetch` – fetch and render web content
+- `AskQuestion` – collect structured multiple-choice answers
+- `Subagent` – launch delegated subprocesses
+- `ListMcpResources` – list MCP resources from config
+- `FetchMcpResource` – fetch a specific MCP resource
+- `ListMcpTools` – discover MCP tools and schemas
+- `CallMcpTool` – invoke MCP tools by name
+- `SwitchMode` – switch interaction mode (`/plan`)
+- `ApplyPatch` – apply single-file patches
 
-So the exposed write path is `apply_patch`, not built-in `edit` / `write`.
-If you pass `--tools` manually and include `edit`/`write`, MonoPilot strips them automatically.
+## User rules
 
-## Publishing
+MonoPilot can inject workspace user rules into the runtime envelope on each input (handled by `src/extensions/user-message.ts`).
+
+- Rules live in `.pi/rules/*.rule.txt` under the workspace root
+- Each file becomes one `<user_rule>` block wrapped by a `<rules>` envelope
+- Files are read in filename order; empty files are ignored
+- If no rules are present, the `<rules>` section is omitted
+
+## MCP
+
+- The user message envelope issues a lightweight MCP server `initialize` request to collect server instructions.
+- MCP tools then progressively load and surface resources, schemas, and execution only when needed.
+
+## Local development
 
 ```bash
-# 1) Validate and build
-npm run check
+git clone https://github.com/qianwan/mono-pilot.git
+cd mono-pilot
+npm install
 npm run build
+```
+
+Source-mode development (no build needed on each change):
+
+```bash
+# Run from TypeScript sources directly
+npm run dev
+
+# Optional: auto-restart on file changes
+npm run dev:watch
 
-# 2) Verify package contents
-npm pack --dry-run
+# Continue the latest session from source mode
+npm run dev:continue
 
-# 3) Publish
-npm publish
+# Auto-restart + continue latest session
+npm run dev:watch:continue
 ```
 
-## Roadmap
+## Prompt inspection
+
+```bash
+# Build first (ensures dist extension exists)
+npm run build
+
+# Print injected system prompt + runtime envelope (snippet)
+npm run inspect:injection
+
+# Print full prompt and envelope to stdout
+npm run inspect:injection:full
 
-- Gradually migrate other Cursor-style tools from `tools/`
-- Keep compatibility behavior focused and testable, one tool at a time
+# Provide a custom user query to render
+node scripts/inspect-injection.mjs --query="Summarize this repo"
+```
+
+The report shows:
+- the final system prompt after tool injection
+- the runtime envelope built from `<rules>`, `<mcp_instructions>`, `<system_reminder>`, and `<user_query>`
+
+
+## Roadmap
 
----
+Project status: MVP (core capabilities are in place and actively evolving).
 
-*Not affiliated with Cursor or Anysphere Inc. Cursor is a trademark of Anysphere Inc.*
+- Gradually migrate additional Cursor-style tools from `tools/`.
+- Keep compatibility behavior focused and testable, one tool at a time.
+- Expand docs and examples for customization.

package/dist/src/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
@@ -47,9 +48,22 @@ function sanitizeToolsArgs(args) {
     }
     return sanitized;
 }
+function resolveExtensionPath(here) {
+    const candidates = [
+        resolve(here, "extensions", "mono-pilot.js"),
+        resolve(here, "extensions", "mono-pilot.ts"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Fallback keeps previous behavior even if file is unexpectedly missing.
+    return candidates[0];
+}
 function buildPiArgs(userArgs) {
     const here = dirname(fileURLToPath(import.meta.url));
-    const extensionPath = resolve(here, "extensions", "mono-pilot.js");
+    const extensionPath = resolveExtensionPath(here);
     const sanitizedUserArgs = sanitizeToolsArgs(userArgs);
     const args = ["--no-extensions", "--extension", extensionPath];
     if (!hasFlag(sanitizedUserArgs, ["--tools", "--no-tools"])) {

package/dist/src/extensions/mode-runtime.js

@@ -0,0 +1,124 @@
+export const MODE_STATE_ENTRY_TYPE = "switch-mode-state";
+export const PLAN_MODE_STILL_ACTIVE_REMINDER = `<system_reminder>
+Plan mode is still active. Continue with the task in the current mode.
+</system_reminder>`;
+export const AGENT_MODE_SWITCH_REMINDER = `<system_reminder>
+You are now in Agent mode. Continue with the task in the new mode.
+</system_reminder>`;
+export function parseModeStateEntry(entry) {
+    if (typeof entry !== "object" || entry === null)
+        return undefined;
+    const record = entry;
+    if (record.type !== "custom")
+        return undefined;
+    if (record.customType !== MODE_STATE_ENTRY_TYPE)
+        return undefined;
+    const data = record.data;
+    if (typeof data !== "object" || data === null)
+        return undefined;
+    const state = data;
+    if (state.activeMode === "plan" || state.activeMode === "agent") {
+        return {
+            activeMode: state.activeMode,
+            pendingReminder: state.pendingReminder === "plan-entry" || state.pendingReminder === "agent-entry"
+                ? state.pendingReminder
+                : undefined,
+        };
+    }
+    if (typeof state.planModeActive === "boolean") {
+        return {
+            activeMode: state.planModeActive ? "plan" : "agent",
+            pendingReminder: undefined,
+        };
+    }
+    return undefined;
+}
+export function deriveInitialModeState(fromPlanFlag) {
+    if (fromPlanFlag) {
+        return { activeMode: "plan", pendingReminder: "plan-entry" };
+    }
+    return { activeMode: "agent" };
+}
+export function createModeStateData(snapshot) {
+    return {
+        activeMode: snapshot.activeMode,
+        pendingReminder: snapshot.pendingReminder,
+        planModeActive: snapshot.activeMode === "plan",
+    };
+}
+export function hasMessageEntries(entries) {
+    for (const entry of entries) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const record = entry;
+        if (record.type === "message")
+            return true;
+    }
+    return false;
+}
+export function buildRuntimeEnvelope(userQuery, reminder, mcpInstructions, rulesEnvelope) {
+    const sections = [];
+    if (rulesEnvelope) {
+        sections.push(rulesEnvelope.trim());
+    }
+    if (mcpInstructions) {
+        sections.push(mcpInstructions.trim());
+    }
+    if (reminder) {
+        sections.push(reminder.trim());
+    }
+    sections.push(`<user_query>\n${userQuery}\n</user_query>`);
+    return sections.join("\n\n");
+}
+class ModeRuntimeStore {
+    state = { activeMode: "agent" };
+    initialize(snapshot) {
+        this.state = { ...snapshot };
+    }
+    getSnapshot() {
+        return { ...this.state };
+    }
+    setMode(nextMode) {
+        if (this.state.activeMode === nextMode) {
+            return { changed: false, snapshot: this.getSnapshot() };
+        }
+        this.state.activeMode = nextMode;
+        this.state.pendingReminder = nextMode === "plan" ? "plan-entry" : "agent-entry";
+        return { changed: true, snapshot: this.getSnapshot() };
+    }
+    toggleMode() {
+        const nextMode = this.state.activeMode === "plan" ? "agent" : "plan";
+        return this.setMode(nextMode);
+    }
+    consumeReminder(planEntryReminder) {
+        if (this.state.activeMode === "plan") {
+            if (this.state.pendingReminder === "plan-entry") {
+                this.state.pendingReminder = undefined;
+                return {
+                    reminder: planEntryReminder,
+                    changed: true,
+                    snapshot: this.getSnapshot(),
+                };
+            }
+            return {
+                reminder: PLAN_MODE_STILL_ACTIVE_REMINDER,
+                changed: false,
+                snapshot: this.getSnapshot(),
+            };
+        }
+        if (this.state.pendingReminder === "agent-entry") {
+            this.state.pendingReminder = undefined;
+            return {
+                reminder: AGENT_MODE_SWITCH_REMINDER,
+                changed: true,
+                snapshot: this.getSnapshot(),
+            };
+        }
+        return {
+            reminder: undefined,
+            changed: false,
+            snapshot: this.getSnapshot(),
+        };
+    }
+}
+export const modeRuntimeStore = new ModeRuntimeStore();

package/dist/src/extensions/mono-pilot.js

@@ -3,14 +3,38 @@ import globExtension from "../../tools/glob.js";
 import rgExtension from "../../tools/rg.js";
 import readFileExtension from "../../tools/read-file.js";
 import deleteExtension from "../../tools/delete.js";
+import semanticSearchExtension from "../../tools/semantic-search.js";
+import webSearchExtension from "../../tools/web-search.js";
+import webFetchExtension from "../../tools/web-fetch.js";
+import askQuestionExtension from "../../tools/ask-question.js";
+import subagentExtension from "../../tools/subagent.js";
+import listMcpResourcesExtension from "../../tools/list-mcp-resources.js";
+import fetchMcpResourceExtension from "../../tools/fetch-mcp-resource.js";
+import listMcpToolsExtension from "../../tools/list-mcp-tools.js";
+import callMcpToolExtension from "../../tools/call-mcp-tool.js";
+import switchModeExtension from "../../tools/switch-mode.js";
 import applyPatchExtension from "../../tools/apply-patch.js";
+import userMessageExtension from "./user-message.js";
+import systemPromptExtension from "./system-prompt.js";
 const toolExtensions = [
     shellExtension,
     globExtension,
     rgExtension,
     readFileExtension,
     deleteExtension,
+    semanticSearchExtension,
+    webSearchExtension,
+    webFetchExtension,
+    askQuestionExtension,
+    subagentExtension,
+    listMcpResourcesExtension,
+    fetchMcpResourceExtension,
+    listMcpToolsExtension,
+    callMcpToolExtension,
+    switchModeExtension,
     applyPatchExtension,
+    userMessageExtension,
+    systemPromptExtension,
 ];
 export default function monoPilotExtension(pi) {
     for (const register of toolExtensions) {

package/dist/src/extensions/system-prompt.js

@@ -0,0 +1,301 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+const NO_DESCRIPTION_PLACEHOLDER = "No short description provided.";
+const PROJECT_CONTEXT_HEADER = "# Project Context";
+const CURRENT_DATETIME_PREFIX = "Current date and time:";
+const CURRENT_WORKING_DIRECTORY_PREFIX = "Current working directory:";
+const AVAILABLE_TOOLS_TOKEN = "{{AVAILABLE_TOOLS_BULLETS}}";
+const PROJECT_CONTEXT_TOKEN = "{{PROJECT_CONTEXT_BLOCK}}";
+const CURRENT_DATETIME_TOKEN = "{{CURRENT_DATETIME}}";
+const CURRENT_WORKING_DIRECTORY_TOKEN = "{{CURRENT_WORKING_DIRECTORY}}";
+const PI_README_PATH_TOKEN = "{{PI_README_PATH}}";
+const PI_DOCS_PATH_TOKEN = "{{PI_DOCS_PATH}}";
+const PI_EXAMPLES_PATH_TOKEN = "{{PI_EXAMPLES_PATH}}";
+const UNIFIED_SYSTEM_PROMPT_TEMPLATE = `You are an expert coding assistant operating inside MonoPilot (a pi-coding-agent compatibility harness) on a user's computer.
+You help users by reading files, executing commands, editing code, and writing new files.
+
+<oververbosity>
+## Desired oververbosity for the final answer (not analysis): 2
+An oververbosity of 1 means the model should respond using only the minimal content necessary to satisfy the request, using concise phrasing and avoiding extra detail or explanation."
+An oververbosity of 10 means the model should provide maximally detailed, thorough responses with context, explanations, and possibly multiple examples."
+The desired oververbosity should be treated only as a *default*. Defer to any user or developer requirements regarding response length, if present.
+</oververbosity>
+
+<general>
+- Each time the user sends a message, we may automatically attach some information about their current state, such as what files they have open, where their cursor is, recently viewed files, edit history in their session so far, linter errors, and more. This information may or may not be relevant to the coding task, it is up for you to decide.
+- When using the Shell tool, your terminal session is persisted across tool calls. On the first call, you should cd to the appropriate directory and do necessary setup. On subsequent calls, you will have the same environment.
+- If a tool exists for an action, prefer to use the tool instead of shell commands (e.g ReadFile over cat).
+- Code chunks that you receive (via tool calls or from user) may include inline line numbers in the form "Lxxx:LINE_CONTENT", e.g. "L123:LINE_CONTENT". Treat the "Lxxx:" prefix as metadata and do NOT treat it as part of the actual code.
+</general>
+
+<system-communication>
+Users can reference context like files and folders using the @ symbol, e.g. @src/components/ is a reference to the src/components/ folder.
+</system-communication>
+
+<tools>
+Available tools:
+${AVAILABLE_TOOLS_TOKEN}
+In addition to the tools above, custom extension tools may also be available.
+</tools>
+
+<persistence>
+## Autonomy and persistence
+
+Persist until the task is fully handled end-to-end within the current turn whenever feasible: do not stop at analysis or partial fixes; carry changes through implementation, verification, and a clear explanation of outcomes unless the user explicitly pauses or redirects you.
+
+Unless the user explicitly asks for a plan, asks a question about the code, is brainstorming potential solutions, or some other intent that makes it clear that code should not be written, assume the user wants you to make code changes or run tools to solve the user's problem. In these cases, it's bad to output your proposed solution in a message, you should go ahead and actually implement the change. If you encounter challenges or blockers, you should attempt to resolve them yourself.
+</persistence>
+
+<editing_constraints>
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+- Add succinct code comments that explain what is going on if code is not self-explanatory. You should not add comments like "Assigns the value to the variable", but a brief comment might be useful ahead of a complex code block that the user would otherwise have to spend time parsing out. Usage of these comments should be rare.
+- Try to use \`ApplyPatch\` for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use \`ApplyPatch\` for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).
+- You may be in a dirty git worktree.
+  - NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
+  - If asked to make a commit or code edits and there are unrelated changes to your work or changes that you didn't make in those files, don't revert those changes.
+  - If the changes are in files you've touched recently, you should read carefully and understand how you can work with the changes rather than reverting them.
+  - If the changes are in unrelated files, just ignore them and don't revert them.
+- Do not amend a commit unless explicitly requested to do so.
+- While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
+- **NEVER** use destructive commands like \`git reset --hard\` or \`git checkout --\` unless specifically requested or approved by the user.
+</editing_constraints>
+
+<special_user_requests>
+- If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command (such as \`date\`), you should do so.
+- If the user asks for a "review", default to a code review mindset: prioritise identifying bugs, risks, behavioural regressions, and missing tests. Findings must be the primary focus of the response - keep summaries or overviews brief and only after enumerating the issues. Present findings first (ordered by severity with file/codeblock references), follow with open questions or assumptions, and offer a change-summary only as a secondary detail. If no findings are discovered, state that explicitly and mention explicitly and mention any residual risks or testing gaps.
+</special_user_requests>
+
+<mode_selection>
+Choose the best interaction mode for the user's current goal before proceeding. Reassess when the goal changes or you're stuck. If another mode would work better, call \`SwitchMode\` now and include a brief explanation.
+
+- **Plan**: user asks for a plan, or the task is large/ambiguous or has meaningful trade-offs
+
+Consult the \`SwitchMode\` tool description for detailed guidance on each mode and when to use it. Be proactive about switching to the optimal mode—this significantly improves your ability to help the user.
+</mode_selection>
+
+<linter_errors>
+After substantive edits, use the ReadLints tool to check recently edited files for linter errors. If you've introduced any, fix them if you can easily figure out how.
+</linter_errors>
+
+<pi_docs_policy>
+- Only when user asks about pi/pi-mono itself (its SDK, extensions, themes, skills, or TUI), consult:
+  - ${PI_README_PATH_TOKEN}
+  - ${PI_DOCS_PATH_TOKEN}
+  - ${PI_EXAMPLES_PATH_TOKEN}
+- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md)
+- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
+- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)
+</pi_docs_policy>
+
+<project_context>
+${PROJECT_CONTEXT_TOKEN}
+</project_context>
+
+<working_with_the_user>
+## Working with the user
+
+You are producing plain text that will later be styled by Cursor. Follow these rules exactly. Formatting should make results easy to scan, but not feel mechanical. Use judgment to decide how much structure adds value.
+
+- Default: be very concise; friendly teammate tone.
+- Do not begin responses with conversational interjections. Avoid openers such as acknowledgements ("Done —", "Got it", "Great question, ") or framing phrases.
+- Ask only when needed; suggest ideas; mirror the user's style.
+- For substantial work, summarize clearly; follow final-answer formatting.
+- Skip heavy formatting for simple confirmations.
+- Don't dump large files you've written; reference paths only.
+- No "save/copy this file", user is on the same machine.
+- Offer logical next steps (tests, commits, build) briefly; add verify steps if you couldn't do something.
+- For code changes:
+  - Lead with a quick explanation of the change, and then give more details on the context covering where and why a change was made. Do not start this explanation with "summary", just jump right in.
+- The user does not see command execution outputs. When asked to show the output of a command (e.g. \`git show\`), relay the important details in your answer or summarize the key lines so the user understands the result.
+
+## Final answer structure and style guidelines
+
+- Use Markdown formatting.
+- Plain text: Cursor handles styling; use structure only when it helps scanability or when response is several paragraphs.
+- Headers: optional; short Title Case (1-5 words) starting with ## or ###; add only if they truly help.
+- Bullets: use - ; merge related points; keep to one line when possible; 4-6 per list ordered by importance; keep phrasing consistent.
+- Monospace: backticks for commands/paths/env vars/code ids and inline examples; use for literal keyword bullets; never combine with **.
+- Structure: group related bullets; order sections general → specific → supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
+- Tone: collaborative, concise, factual; present tense, active voice; self-contained; no "above/below"; parallel wording.
+- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short—wrap/reformat if long; avoid naming formatting styles in answers.
+- Adaptation: code explanations → precise, structured with code refs; simple tasks → lead with outcome; big changes → logical walkthrough + rationale + next actions; casual one-offs → plain sentences, no headers/bullets.
+- Path and Symbol References: When referencing a file, directory or symbol, always surround it with backticks. Ex: \`getSha256()\`, \`src/app.ts\`. NEVER include line numbers or other info.
+
+## Citing Code Blocks
+
+- Cite code when it illustrates better than words
+- Don't overuse or cite large blocks; don't use codeblocks to show the final code since can already review them in UI
+- Citing code that is in the codebase:\`\`\`startLine:endLine:filepath
+// ... existing code ...
+\`\`\`
+  - Do not add anything besides the startLine:endLine:filepath (no language tag, line numbers)
+  - Example:\`\`\`12:14:app/components/Todo.tsx
+// ... existing code ...
+\`\`\`
+  - Code blocks should contain the code content from the file
+  - You can truncate the code, add your own edits, or add comments for readability
+  - If you do truncate the code, include a comment to indicate that there is more code that is not shown
+  - YOU MUST SHOW AT LEAST 1 LINE OF CODE IN THE CODE BLOCK OR ELSE THE BLOCK WILL NOT RENDER PROPERLY IN THE EDITOR.
+- Proposing new code that is not in the codebase
+  - Use fenced blocks with language tags; nothing else
+  - Prefer updating files directly, unless the user clearly wants you to propose code without editing files
+- For both methods of citing code blocks:
+  - Always put a newline before the code fences (\n\`\`\`); no indentation between \n and \`\`\`; no newline between \`\`\` and startLine:endLine:filepath
+  - Remember that line numbers must NOT be included for non-codeblock citations (e.g. citing a filepath)
+
+<intermediary_updates>
+## Intermediary updates
+- User updates are short updates while you are working, they are NOT final answers.
+- You use 1-2 sentence user updates to communicate progress and new information to the user as you are doing work.
+- Do not begin responses with conversational interjections. Avoid openers such as acknowledgements ("Done —", "Got it", "Great question, ") or framing phrases.
+- You provide user updates frequently, every 20s.
+- Before exploring or doing substantial work, you start with a user update acknowledging the request and explaining your first step. You should include your understanding of the user request and explain what you will do.
+- When exploring, e.g. searching, reading files you provide user updates as you go, every 20s, explaining what context you are gathering and what you've learned. Vary your sentence structure when providing these updates to avoid sounding repetitive - in particular, don't start each sentence the same way.
+- After you have sufficient context, and the work is substantial you provide a longer plan (this is the only user update that may be longer than 2 sentences and can contain formatting).
+- Before performing file edits of any kind, you provide updates explaining what edits you are making.
+- As you are thinking, you very frequently provide updates even if not taking any actions, informing the user of your progress. You interrupt your thinking and send multiple updates in a row if thinking for more than 100 words.
+</intermediary_updates>
+</working_with_the_user>
+
+<main_goal>
+Your main goal is to follow the USER's instructions at each message, denoted by the <user_query> tag.
+</main_goal>
+
+<runtime_context>
+Current date and time: ${CURRENT_DATETIME_TOKEN}
+Current working directory: ${CURRENT_WORKING_DIRECTORY_TOKEN}
+</runtime_context>`;
+function getFirstDescriptionLine(description) {
+    if (!description)
+        return NO_DESCRIPTION_PLACEHOLDER;
+    for (const line of description.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return NO_DESCRIPTION_PLACEHOLDER;
+}
+function buildActiveToolBullets(activeToolNames, allTools) {
+    const activeSet = new Set(activeToolNames);
+    const lines = allTools
+        .filter((tool) => activeSet.has(tool.name))
+        .map((tool) => `- ${tool.name}: ${getFirstDescriptionLine(tool.description)}`);
+    return lines.length > 0 ? lines.join("\n") : "- (none)";
+}
+function extractProjectContextBlock(systemPrompt) {
+    const lines = systemPrompt.split(/\r?\n/);
+    const headerIndex = lines.findIndex((line) => line.trim() === PROJECT_CONTEXT_HEADER);
+    if (headerIndex === -1)
+        return undefined;
+    let endIndex = lines.length;
+    for (let i = headerIndex + 1; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith(CURRENT_DATETIME_PREFIX) || trimmed.startsWith(CURRENT_WORKING_DIRECTORY_PREFIX)) {
+            endIndex = i;
+            break;
+        }
+    }
+    const block = lines.slice(headerIndex + 1, endIndex).join("\n").trim();
+    if (block.length > 0)
+        return block;
+    return "Project-specific instructions were not provided.";
+}
+function extractValueAfterPrefix(systemPrompt, prefix) {
+    for (const line of systemPrompt.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith(prefix)) {
+            const value = trimmed.slice(prefix.length).trim();
+            if (value.length > 0)
+                return value;
+        }
+    }
+    return undefined;
+}
+function renderTemplate(template, values) {
+    return template
+        .split(AVAILABLE_TOOLS_TOKEN)
+        .join(values.tools)
+        .split(PROJECT_CONTEXT_TOKEN)
+        .join(values.projectContext)
+        .split(CURRENT_DATETIME_TOKEN)
+        .join(values.currentDateTime)
+        .split(CURRENT_WORKING_DIRECTORY_TOKEN)
+        .join(values.cwd)
+        .split(PI_README_PATH_TOKEN)
+        .join(values.piReadmePath)
+        .split(PI_DOCS_PATH_TOKEN)
+        .join(values.piDocsPath)
+        .split(PI_EXAMPLES_PATH_TOKEN)
+        .join(values.piExamplesPath);
+}
+function getFallbackDateTimeText() {
+    return new Date().toString();
+}
+function resolvePiPackageRoot() {
+    try {
+        const entryUrl = import.meta.resolve("@mariozechner/pi-coding-agent");
+        const entryPath = fileURLToPath(entryUrl);
+        let currentDir = dirname(entryPath);
+        while (true) {
+            const packageJsonPath = join(currentDir, "package.json");
+            if (existsSync(packageJsonPath)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+                    if (pkg.name === "@mariozechner/pi-coding-agent") {
+                        return currentDir;
+                    }
+                }
+                catch {
+                    // Continue walking upward.
+                }
+            }
+            const parent = dirname(currentDir);
+            if (parent === currentDir)
+                break;
+            currentDir = parent;
+        }
+    }
+    catch {
+        // Fall through to undefined.
+    }
+    return undefined;
+}
+function resolvePiDocsPaths() {
+    const packageRoot = resolvePiPackageRoot();
+    if (!packageRoot) {
+        return {
+            readmePath: "@mariozechner/pi-coding-agent/README.md",
+            docsPath: "@mariozechner/pi-coding-agent/docs",
+            examplesPath: "@mariozechner/pi-coding-agent/examples",
+        };
+    }
+    return {
+        readmePath: resolve(join(packageRoot, "README.md")),
+        docsPath: resolve(join(packageRoot, "docs")),
+        examplesPath: resolve(join(packageRoot, "examples")),
+    };
+}
+export default function systemPromptExtension(pi) {
+    pi.on("before_agent_start", (event) => {
+        const tools = buildActiveToolBullets(pi.getActiveTools(), pi.getAllTools());
+        const piDocsPaths = resolvePiDocsPaths();
+        const projectContext = extractProjectContextBlock(event.systemPrompt) ?? "Project-specific instructions were not provided.";
+        const currentDateTime = extractValueAfterPrefix(event.systemPrompt, CURRENT_DATETIME_PREFIX) ?? getFallbackDateTimeText();
+        const cwd = extractValueAfterPrefix(event.systemPrompt, CURRENT_WORKING_DIRECTORY_PREFIX) ?? process.cwd();
+        const unifiedPrompt = renderTemplate(UNIFIED_SYSTEM_PROMPT_TEMPLATE, {
+            tools,
+            projectContext,
+            currentDateTime,
+            cwd,
+            piReadmePath: piDocsPaths.readmePath,
+            piDocsPath: piDocsPaths.docsPath,
+            piExamplesPath: piDocsPaths.examplesPath,
+        });
+        if (unifiedPrompt === event.systemPrompt) {
+            return undefined;
+        }
+        return { systemPrompt: unifiedPrompt };
+    });
+}