system-prompt-omni 0.2.0

package/LICENSE

@@ -0,0 +1,217 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   COPYRIGHT AND ATTRIBUTION NOTICE
+
+   pi-system-prompt
+   Copyright 2026 Alex (jandrikus) and pi-system-prompt contributors
+   https://github.com/jandrikus/pi-system-prompt
+
+   system-prompt-omni modifications
+   Copyright 2026 weiwch
+   https://github.com/weiwch/system-prompt-omni
+
+   system-prompt-omni is a modified fork of pi-system-prompt. Modifications
+   include prompt-source export, effective system-prompt session recording,
+   tests, documentation, and compatibility updates. The Apache License,
+   Version 2.0 above applies to the original work and this fork.

package/README.md

@@ -0,0 +1,91 @@
+# system-prompt-omni
+
+Display the full [pi coding agent](https://pi.dev) system prompt — with all injected tools,
+guidelines, context files, and skills — in a scrollable full-screen overlay. The extension can
+also export safe `SYSTEM.md` and `APPEND_SYSTEM.md` source files globally or for the current
+project, and records each changed effective prompt in the current session.
+
+## Usage
+
+```text
+/system-prompt
+/system-prompt export
+/system-prompt export system global
+/system-prompt export system project
+/system-prompt export append global
+/system-prompt export append project
+```
+
+Inside the prompt viewer:
+
+| Key | Action |
+|-----|--------|
+| `↑↓` / `j` `k` | Scroll line |
+| `PgUp` / `PgDn` | Scroll page |
+| `Home` / `End` | Jump to top/bottom |
+| `c` | Copy full prompt and tool definitions to clipboard |
+| `e` | Open the export wizard |
+| `Esc` / `q` | Close |
+
+The export wizard writes to one of these locations:
+
+| Scope | `SYSTEM.md` | `APPEND_SYSTEM.md` |
+|-------|-------------|--------------------|
+| Global | `$PI_CODING_AGENT_DIR/SYSTEM.md` or `~/.pi/agent/SYSTEM.md` | `$PI_CODING_AGENT_DIR/APPEND_SYSTEM.md` or `~/.pi/agent/APPEND_SYSTEM.md` |
+| Project | `<cwd>/.pi/SYSTEM.md` | `<cwd>/.pi/APPEND_SYSTEM.md` |
+
+`SYSTEM.md` export is intentionally safe: if a custom prompt is already configured, its source
+text is exported. Otherwise, the extension removes dynamically injected append text, project
+context, skills, and current working directory from the assembled prompt before writing the
+static default prefix. Pi will inject those dynamic sections again when it loads the exported
+file.
+
+`APPEND_SYSTEM.md` export writes the currently configured append text. If none is configured,
+the wizard can create an empty starter file. Existing files are never overwritten without
+confirmation. Run `/reload` after exporting to load the new file.
+
+## Prompt recording
+
+Before each provider request, the package compares the SHA-256 hash of the effective system
+prompt with the latest snapshot on the active session branch. When it changes, a durable custom
+session entry with type `pi-system-prompt` records:
+
+- the full effective system prompt, its hash, and UTF-8 byte length;
+- provider, model, API, and thinking-level metadata;
+- active tool names and definitions; and
+- provider-level system/developer instructions extracted from the serialized request.
+
+The recorder never stores the complete provider payload, never adds its custom entries to the
+LLM context, and returns the payload unchanged. Load this package after extensions that rewrite
+provider requests if you want those rewritten provider instructions included in the snapshot.
+
+## Install
+
+```bash
+pi install git:github.com/weiwch/system-prompt-omni
+```
+
+For local development:
+
+```bash
+pi install /path/to/system-prompt-omni
+```
+
+## Development
+
+```bash
+npm test
+```
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE), which also contains the upstream attribution and a summary
+of this fork's modifications.
+
+## Upstream and acknowledgements
+
+This project is a modified fork of
+[jandrikus/pi-system-prompt](https://github.com/jandrikus/pi-system-prompt). Many thanks to
+Alex (`jandrikus`) and the upstream contributors for the original system-prompt viewer. The
+upstream work and this fork are distributed under the Apache License 2.0; the original license
+and attribution are retained.

package/extensions/pi-system-prompt-recorder.ts

@@ -0,0 +1,58 @@
+/**
+ * Persist the effective system prompt when it changes.
+ *
+ * Custom entries are durable but are not added to the LLM context. Load this
+ * extension last if another extension rewrites the serialized provider payload
+ * in before_provider_request.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import {
+  extractProviderSystemInstructions,
+  latestSystemPromptSha256,
+  sha256,
+  SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION,
+  SYSTEM_PROMPT_ENTRY_TYPE,
+} from "../lib/system-prompt-recorder.ts";
+
+export default function systemPromptRecorder(pi: ExtensionAPI): void {
+  pi.on("before_provider_request", (event, ctx) => {
+    const systemPrompt = ctx.getSystemPrompt();
+    const systemPromptSha256 = sha256(systemPrompt);
+
+    // Compare with the latest snapshot on the active branch. This also avoids
+    // duplicates after process restarts, session resume, and extension reloads.
+    if (latestSystemPromptSha256(ctx.sessionManager.getBranch()) === systemPromptSha256) {
+      return undefined;
+    }
+
+    const providerSystemInstructions = extractProviderSystemInstructions(event.payload);
+    const model = ctx.model;
+    const activeTools = pi.getActiveTools();
+    const toolsByName = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
+    const tools = activeTools.flatMap((name) => {
+      const tool = toolsByName.get(name);
+      if (!tool) return [];
+      return [{ name: tool.name, description: tool.description, parameters: tool.parameters }];
+    });
+
+    pi.appendEntry(SYSTEM_PROMPT_ENTRY_TYPE, {
+      schemaVersion: SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION,
+      captureStage: "before_provider_request",
+      capturedAt: new Date().toISOString(),
+      systemPrompt,
+      systemPromptSha256,
+      systemPromptUtf8Bytes: Buffer.byteLength(systemPrompt, "utf8"),
+      provider: model?.provider,
+      modelId: model?.id,
+      api: model?.api,
+      thinkingLevel: pi.getThinkingLevel(),
+      activeTools,
+      tools,
+      providerSystemInstructions,
+    });
+
+    // Returning undefined leaves the provider payload unchanged.
+    return undefined;
+  });
+}

package/extensions/system-prompt.ts

@@ -0,0 +1,616 @@
+/**
+ * /system-prompt — Display the full system prompt and tool definitions
+ * in a full-screen scrollable overlay, with safe prompt-file export.
+ *
+ * Modified from jandrikus/pi-system-prompt for system-prompt-omni.
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type Theme,
+  type ToolInfo,
+} from "@earendil-works/pi-coding-agent";
+import {
+  matchesKey,
+  truncateToWidth,
+  type TUI,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+import {
+  getPromptFileContent,
+  type PromptFileKind,
+} from "../lib/export-content.ts";
+
+type ExportScope = "global" | "project";
+type ViewResult = "export" | null;
+
+interface ExportRequest {
+  kind?: PromptFileKind;
+  scope?: ExportScope;
+}
+
+export default function (pi: ExtensionAPI) {
+  // Listen for date from pi-today extension.
+  let todayDate: string | undefined;
+  pi.events.on("today:date", (data: unknown) => {
+    if (typeof data === "string") {
+      todayDate = data;
+    }
+  });
+
+  pi.registerCommand("system-prompt", {
+    description: "Show or export the current system prompt and tool definitions",
+    getArgumentCompletions: (prefix: string) => {
+      const choices = [
+        { value: "export", label: "export", description: "Open the export wizard" },
+        {
+          value: "export system global",
+          label: "export system global",
+          description: "Write global SYSTEM.md",
+        },
+        {
+          value: "export system project",
+          label: "export system project",
+          description: "Write project .pi/SYSTEM.md",
+        },
+        {
+          value: "export append global",
+          label: "export append global",
+          description: "Write global APPEND_SYSTEM.md",
+        },
+        {
+          value: "export append project",
+          label: "export append project",
+          description: "Write project .pi/APPEND_SYSTEM.md",
+        },
+      ];
+      const normalized = prefix.trim().toLowerCase();
+      const matches = choices.filter((choice) => choice.value.startsWith(normalized));
+      return matches.length > 0 ? matches : null;
+    },
+    handler: async (args, ctx) => {
+      await ctx.waitForIdle();
+
+      const parsed = parseCommandArgs(args);
+      if (parsed.error) {
+        ctx.ui.notify(parsed.error, "error");
+        return;
+      }
+      if (parsed.exportRequest) {
+        await exportPromptFile(ctx, parsed.exportRequest);
+        return;
+      }
+
+      let prompt = ctx.getSystemPrompt();
+
+      // Prepend the date from pi-today for display only. Export uses Pi's base
+      // prompt inputs and never persists this display-only line.
+      if (todayDate) {
+        prompt = `${todayDate}\n\n${prompt}`;
+      }
+
+      const promptLines = prompt.split("\n");
+      const charCount = prompt.length;
+      const lineCount = promptLines.length;
+
+      // Gather tool definitions.
+      const active = new Set(pi.getActiveTools());
+      const activeTools = pi.getAllTools().filter((tool) => active.has(tool.name));
+      const toolLines = buildToolLines(activeTools);
+
+      const allLines = [
+        ...promptLines,
+        "",
+        "────────────────────────────────────────",
+        "",
+        ...toolLines,
+      ];
+
+      const result = await ctx.ui.custom<ViewResult>(
+        (tui, theme, _keybindings, done) =>
+          new SystemPromptView(
+            tui,
+            allLines,
+            activeTools,
+            lineCount,
+            charCount,
+            allLines.length,
+            theme,
+            done,
+          ),
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "95%",
+            maxHeight: "92%",
+            anchor: "center",
+            margin: 0,
+          },
+        },
+      );
+
+      if (result === "export") {
+        await exportPromptFile(ctx, {});
+      }
+    },
+  });
+}
+
+function parseCommandArgs(args: string): {
+  exportRequest?: ExportRequest;
+  error?: string;
+} {
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) {
+    return {};
+  }
+  if (tokens[0]?.toLowerCase() !== "export") {
+    return { error: exportUsage() };
+  }
+  if (tokens.length > 3) {
+    return { error: exportUsage() };
+  }
+
+  const kind = tokens[1] ? parsePromptFileKind(tokens[1]) : undefined;
+  if (tokens[1] && !kind) {
+    return { error: `Unknown prompt file ${JSON.stringify(tokens[1])}.\n${exportUsage()}` };
+  }
+
+  const scope = tokens[2] ? parseExportScope(tokens[2]) : undefined;
+  if (tokens[2] && !scope) {
+    return { error: `Unknown export scope ${JSON.stringify(tokens[2])}.\n${exportUsage()}` };
+  }
+
+  return { exportRequest: { kind, scope } };
+}
+
+function parsePromptFileKind(value: string): PromptFileKind | undefined {
+  switch (value.toLowerCase()) {
+    case "system":
+    case "system.md":
+      return "system";
+    case "append":
+    case "append_system.md":
+    case "append-system":
+      return "append";
+    default:
+      return undefined;
+  }
+}
+
+function parseExportScope(value: string): ExportScope | undefined {
+  switch (value.toLowerCase()) {
+    case "global":
+    case "user":
+      return "global";
+    case "project":
+    case "current":
+    case "local":
+      return "project";
+    default:
+      return undefined;
+  }
+}
+
+function exportUsage(): string {
+  return [
+    "Usage:",
+    "  /system-prompt",
+    "  /system-prompt export [system|append] [global|project]",
+  ].join("\n");
+}
+
+async function exportPromptFile(
+  ctx: ExtensionCommandContext,
+  request: ExportRequest,
+): Promise<void> {
+  const kind = request.kind ?? (await selectPromptFileKind(ctx));
+  if (!kind) {
+    return;
+  }
+
+  const scope = request.scope ?? (await selectExportScope(ctx));
+  if (!scope) {
+    return;
+  }
+
+  if (scope === "project" && !ctx.isProjectTrusted()) {
+    const proceed = await ctx.ui.confirm(
+      "Project is not trusted",
+      `Write ${fileNameForKind(kind)} under ${join(ctx.cwd, CONFIG_DIR_NAME)} anyway? ` +
+        "Pi will not load it until the project is trusted and reloaded.",
+    );
+    if (!proceed) {
+      return;
+    }
+  }
+
+  let content: string;
+  try {
+    content = getPromptFileContent(kind, ctx.getSystemPrompt(), ctx.getSystemPromptOptions());
+  } catch (error) {
+    ctx.ui.notify(`Could not export ${fileNameForKind(kind)}: ${formatError(error)}`, "error");
+    return;
+  }
+
+  const targetPath = resolveExportPath(kind, scope, ctx.cwd);
+
+  let existingContent: string | undefined;
+  try {
+    existingContent = await readFile(targetPath, "utf8");
+  } catch (error) {
+    if (!isNotFoundError(error)) {
+      ctx.ui.notify(`Could not read ${targetPath}: ${formatError(error)}`, "error");
+      return;
+    }
+  }
+
+  if (existingContent === content) {
+    ctx.ui.notify(`${targetPath} is already up to date.`, "info");
+    return;
+  }
+
+  if (kind === "append" && content.length === 0) {
+    const createEmpty = await ctx.ui.confirm(
+      "No append prompt is active",
+      `Create an empty starter file at ${targetPath}?`,
+    );
+    if (!createEmpty) {
+      return;
+    }
+  }
+
+  if (existingContent !== undefined) {
+    const overwrite = await ctx.ui.confirm(
+      `Overwrite ${fileNameForKind(kind)}?`,
+      `${targetPath} already exists and contains different content.`,
+    );
+    if (!overwrite) {
+      return;
+    }
+  }
+
+  try {
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, content, "utf8");
+  } catch (error) {
+    ctx.ui.notify(`Could not write ${targetPath}: ${formatError(error)}`, "error");
+    return;
+  }
+
+  ctx.ui.notify(`Exported ${fileNameForKind(kind)} to ${targetPath}. Run /reload to load it.`, "info");
+}
+
+async function selectPromptFileKind(
+  ctx: ExtensionCommandContext,
+): Promise<PromptFileKind | undefined> {
+  const selected = await ctx.ui.select("Export which prompt source?", [
+    "SYSTEM.md — custom/default static prefix",
+    "APPEND_SYSTEM.md — appended instructions",
+  ]);
+  if (selected?.startsWith("SYSTEM.md")) {
+    return "system";
+  }
+  if (selected?.startsWith("APPEND_SYSTEM.md")) {
+    return "append";
+  }
+  return undefined;
+}
+
+async function selectExportScope(ctx: ExtensionCommandContext): Promise<ExportScope | undefined> {
+  const selected = await ctx.ui.select("Export scope", [
+    `Global — ${getAgentDir()}`,
+    `Current project — ${join(ctx.cwd, CONFIG_DIR_NAME)}`,
+  ]);
+  if (selected?.startsWith("Global")) {
+    return "global";
+  }
+  if (selected?.startsWith("Current project")) {
+    return "project";
+  }
+  return undefined;
+}
+
+function resolveExportPath(kind: PromptFileKind, scope: ExportScope, cwd: string): string {
+  const directory = scope === "global" ? getAgentDir() : join(cwd, CONFIG_DIR_NAME);
+  return join(directory, fileNameForKind(kind));
+}
+
+function fileNameForKind(kind: PromptFileKind): "SYSTEM.md" | "APPEND_SYSTEM.md" {
+  return kind === "system" ? "SYSTEM.md" : "APPEND_SYSTEM.md";
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "ENOENT"
+  );
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function buildToolLines(tools: ToolInfo[]): string[] {
+  const lines: string[] = [];
+  if (tools.length === 0) {
+    lines.push("No tools registered.");
+    return lines;
+  }
+
+  lines.push(`Tool Definitions (${tools.length} tools)`);
+  lines.push("");
+
+  for (const tool of tools) {
+    const source = tool.sourceInfo?.source ?? "unknown";
+    const sourceText = source === "builtin" ? "built-in" : source === "sdk" ? "SDK" : source;
+
+    lines.push(`name: ${tool.name}`);
+    lines.push(`  description: ${tool.description}`);
+    lines.push(`  source: ${sourceText}`);
+    lines.push("  parameters:");
+
+    const paramLines = JSON.stringify(tool.parameters, null, 2).split("\n");
+    for (const line of paramLines) {
+      lines.push(`    ${line}`);
+    }
+
+    lines.push("");
+  }
+
+  return lines;
+}
+
+interface DisplayLine {
+  text: string;
+  originalIndex: number;
+  continuation: boolean;
+}
+
+type LineStyle = "tools" | "guidelines" | "heading" | "bullet" | "toolLine" | "plain";
+
+function lineStyle(originalLine: string): LineStyle {
+  if (originalLine.startsWith("Available tools:")) return "tools";
+  if (originalLine.startsWith("Guidelines:")) return "guidelines";
+  if (/^#+\s/.test(originalLine)) return "heading";
+  if (originalLine.startsWith("- ")) return "bullet";
+  if (originalLine.startsWith("  ") || originalLine.startsWith("    ")) return "toolLine";
+  return "plain";
+}
+
+function styleFirstLine(theme: Theme, text: string, style: LineStyle): string {
+  switch (style) {
+    case "tools":
+      return theme.fg("success", theme.bold(text));
+    case "guidelines":
+    case "heading":
+      return theme.fg("accent", theme.bold(text));
+    case "bullet":
+      return theme.fg("muted", text);
+    default:
+      return text;
+  }
+}
+
+function styleContinuation(theme: Theme, text: string, style: LineStyle): string {
+  switch (style) {
+    case "bullet":
+      return theme.fg("muted", text);
+    case "heading":
+      return theme.fg("dim", text);
+    default:
+      return theme.fg("dim", text);
+  }
+}
+
+function enableMouse(): void {
+  process.stdout.write("\x1b[?1000h");
+  process.stdout.write("\x1b[?1006h");
+}
+
+function disableMouse(): void {
+  process.stdout.write("\x1b[?1006l");
+  process.stdout.write("\x1b[?1000l");
+}
+
+function parseSgrMouse(data: string): { wheelUp: number; wheelDown: number } | null {
+  if (!data.startsWith("\x1b[<") || !data.endsWith("M")) return null;
+  const parts = data.slice(3, -1).split(";");
+  if (parts.length !== 3) return null;
+  const button = Number.parseInt(parts[0] ?? "", 10);
+  if (Number.isNaN(button)) return null;
+  if (button === 64) return { wheelUp: 3, wheelDown: 0 };
+  if (button === 65) return { wheelUp: 0, wheelDown: 3 };
+  return null;
+}
+
+class SystemPromptView {
+  private scrollOffset = 0;
+  private copiedAt = 0;
+  private readonly fullText: string;
+  private totalDisplayLines = 0;
+
+  constructor(
+    private readonly tui: TUI,
+    private readonly allLines: string[],
+    private readonly allTools: ToolInfo[],
+    private readonly promptLineCount: number,
+    private readonly promptCharCount: number,
+    private readonly combinedLineCount: number,
+    private readonly theme: Theme,
+    private readonly done: (result: ViewResult) => void,
+  ) {
+    this.fullText = allLines.join("\n");
+    enableMouse();
+  }
+
+  handleInput(data: string): void {
+    const visible = this.visibleLines();
+    const total = this.totalDisplayLines || this.combinedLineCount;
+
+    const mouse = parseSgrMouse(data);
+    if (mouse) {
+      if (mouse.wheelUp > 0) {
+        this.scrollOffset = Math.max(0, this.scrollOffset - mouse.wheelUp);
+      }
+      if (mouse.wheelDown > 0) {
+        this.scrollOffset = Math.min(
+          Math.max(0, total - visible),
+          this.scrollOffset + mouse.wheelDown,
+        );
+      }
+      this.tui.requestRender?.();
+      return;
+    }
+
+    if (matchesKey(data, "up") || matchesKey(data, "k")) {
+      if (this.scrollOffset > 0) this.scrollOffset--;
+      this.tui.requestRender?.();
+      return;
+    }
+    if (matchesKey(data, "down") || matchesKey(data, "j")) {
+      if (this.scrollOffset < total - visible) this.scrollOffset++;
+      this.tui.requestRender?.();
+      return;
+    }
+    if (matchesKey(data, "pageUp")) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - visible);
+      this.tui.requestRender?.();
+      return;
+    }
+    if (matchesKey(data, "pageDown")) {
+      this.scrollOffset = Math.min(Math.max(0, total - visible), this.scrollOffset + visible);
+      this.tui.requestRender?.();
+      return;
+    }
+    if (matchesKey(data, "home")) {
+      this.scrollOffset = 0;
+      this.tui.requestRender?.();
+      return;
+    }
+    if (matchesKey(data, "end")) {
+      this.scrollOffset = Math.max(0, total - visible);
+      this.tui.requestRender?.();
+      return;
+    }
+    if (matchesKey(data, "c")) {
+      this.copyToClipboard();
+      this.tui.requestRender?.();
+      return;
+    }
+    if (matchesKey(data, "e")) {
+      this.done("export");
+      return;
+    }
+    if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+      this.done(null);
+    }
+  }
+
+  private visibleLines(): number {
+    const height = this.tui.terminal.rows;
+    if (!height || height <= 0) return 30;
+    return Math.max(1, Math.floor(height * 0.92) - 4);
+  }
+
+  private buildDisplayLines(contentWidth: number): DisplayLine[] {
+    const displayLines: DisplayLine[] = [];
+    for (let index = 0; index < this.allLines.length; index++) {
+      const wrapped = wrapTextWithAnsi(this.allLines[index] ?? "", contentWidth);
+      for (let wrappedIndex = 0; wrappedIndex < wrapped.length; wrappedIndex++) {
+        displayLines.push({
+          text: wrapped[wrappedIndex] ?? "",
+          originalIndex: index,
+          continuation: wrappedIndex > 0,
+        });
+      }
+    }
+    return displayLines;
+  }
+
+  render(width: number): string[] {
+    const theme = this.theme;
+    const innerWidth = Math.max(1, width - 2);
+    const contentWidth = Math.max(1, innerWidth - 1);
+    const visible = this.visibleLines();
+
+    const displayLines = this.buildDisplayLines(contentWidth);
+    this.totalDisplayLines = displayLines.length;
+
+    const pad = (text: string, length: number) => {
+      const currentWidth = visibleWidth(text);
+      return text + " ".repeat(Math.max(0, length - currentWidth));
+    };
+
+    const row = (content: string) => {
+      const fitted = truncateToWidth(content, innerWidth, "");
+      return theme.fg("border", "│") + pad(fitted, innerWidth) + theme.fg("border", "│");
+    };
+
+    const output: string[] = [];
+    output.push(theme.fg("border", `╭${"─".repeat(innerWidth)}╮`));
+    output.push(
+      row(
+        ` ${theme.fg("accent", theme.bold("System Prompt"))}  ${theme.fg("dim", `— ${this.promptLineCount} lines, ${this.promptCharCount.toLocaleString()} chars`)}  ${theme.fg("dim", `|  ${this.allTools.length} tools`)}`,
+      ),
+    );
+    output.push(row(""));
+
+    const end = Math.min(this.scrollOffset + visible, displayLines.length);
+    for (let index = this.scrollOffset; index < end; index++) {
+      const displayLine = displayLines[index];
+      if (!displayLine) continue;
+      const originalLine = this.allLines[displayLine.originalIndex] ?? "";
+      const style = lineStyle(originalLine);
+      const styled = displayLine.continuation
+        ? styleContinuation(theme, displayLine.text, style)
+        : styleFirstLine(theme, displayLine.text, style);
+      output.push(row(` ${styled}`));
+    }
+
+    for (let index = end - this.scrollOffset; index < visible; index++) {
+      output.push(row(""));
+    }
+
+    const percentage =
+      displayLines.length > 0
+        ? Math.round((this.scrollOffset / displayLines.length) * 100)
+        : 0;
+    const footerLeft = `${this.scrollOffset + 1}-${end}/${displayLines.length} (${percentage}%)`;
+    const copyLabel = Date.now() - this.copiedAt < 2000 ? theme.fg("success", "copied") : "copy";
+    const footerRight = `e export  c ${copyLabel}  ↑↓/jk pgup/pgdn home/end  Esc/q`;
+    const gap = Math.max(
+      1,
+      innerWidth - 1 - visibleWidth(footerLeft) - visibleWidth(footerRight),
+    );
+    const footer =
+      ` ${theme.fg("dim", footerLeft)}` +
+      `${" ".repeat(gap)}${theme.fg("dim", footerRight)}`;
+    output.push(row(""));
+    output.push(row(footer));
+    output.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
+
+    return output;
+  }
+
+  private copyToClipboard(): void {
+    const base64 = Buffer.from(this.fullText, "utf8").toString("base64");
+    process.stdout.write(`\x1b]52;c;${base64}\x07`);
+    this.copiedAt = Date.now();
+  }
+
+  invalidate(): void {}
+
+  dispose(): void {
+    disableMouse();
+  }
+}

package/lib/export-content.ts

@@ -0,0 +1,114 @@
+export type PromptFileKind = "system" | "append";
+
+export interface PromptContextFile {
+  path: string;
+  content: string;
+}
+
+export interface PromptSkill {
+  name: string;
+  description: string;
+  filePath: string;
+  disableModelInvocation?: boolean;
+}
+
+export interface PromptBuildOptions {
+  customPrompt?: string;
+  selectedTools?: string[];
+  appendSystemPrompt?: string;
+  cwd: string;
+  contextFiles?: PromptContextFile[];
+  skills?: PromptSkill[];
+}
+
+/**
+ * Return content that is safe to persist as one of Pi's prompt source files.
+ * SYSTEM.md contains only the custom/default prefix; Pi will append dynamic
+ * context, skills, and cwd again when it loads the file.
+ */
+export function getPromptFileContent(
+  kind: PromptFileKind,
+  systemPrompt: string,
+  options: PromptBuildOptions,
+): string {
+  if (kind === "append") {
+    return options.appendSystemPrompt ?? "";
+  }
+
+  // Pi treats a truthy customPrompt as the complete SYSTEM.md/template prefix.
+  if (options.customPrompt) {
+    return options.customPrompt;
+  }
+
+  const dynamicSuffix = buildDynamicSuffix(options);
+  if (!systemPrompt.endsWith(dynamicSuffix)) {
+    throw new Error(
+      "The current prompt does not match Pi's base prompt layout. " +
+        "A per-turn extension may have changed it; refusing to export dynamic context into SYSTEM.md.",
+    );
+  }
+
+  return systemPrompt.slice(0, -dynamicSuffix.length);
+}
+
+function buildDynamicSuffix(options: PromptBuildOptions): string {
+  let suffix = "";
+
+  if (options.appendSystemPrompt) {
+    suffix += `\n\n${options.appendSystemPrompt}`;
+  }
+
+  const contextFiles = options.contextFiles ?? [];
+  if (contextFiles.length > 0) {
+    suffix += "\n\n<project_context>\n\n";
+    suffix += "Project-specific instructions and guidelines:\n\n";
+    for (const contextFile of contextFiles) {
+      suffix += `<project_instructions path="${contextFile.path}">\n`;
+      suffix += `${contextFile.content}\n`;
+      suffix += "</project_instructions>\n\n";
+    }
+    suffix += "</project_context>\n";
+  }
+
+  const hasReadTool = !options.selectedTools || options.selectedTools.includes("read");
+  if (hasReadTool) {
+    suffix += formatSkills(options.skills ?? []);
+  }
+
+  suffix += `\nCurrent working directory: ${options.cwd.replace(/\\/g, "/")}`;
+  return suffix;
+}
+
+function formatSkills(skills: PromptSkill[]): string {
+  const visibleSkills = skills.filter((skill) => !skill.disableModelInvocation);
+  if (visibleSkills.length === 0) {
+    return "";
+  }
+
+  const lines = [
+    "\n\nThe following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>",
+  ];
+
+  for (const skill of visibleSkills) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join("\n");
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}

package/lib/system-prompt-recorder.ts

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+
+export const SYSTEM_PROMPT_ENTRY_TYPE = "pi-system-prompt";
+export const SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION = 1;
+
+interface CustomEntryLike {
+  type?: unknown;
+  customType?: unknown;
+  data?: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function jsonSnapshot(value: unknown): unknown {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return "[unserializable provider system instruction]";
+  }
+}
+
+function pushField(
+  result: Array<Record<string, unknown>>,
+  root: Record<string, unknown>,
+  key: string,
+  prefix = "$",
+): void {
+  if (!Object.prototype.hasOwnProperty.call(root, key)) return;
+  const value = root[key];
+  if (value === undefined || value === null) return;
+  result.push({ path: `${prefix}.${key}`, value: jsonSnapshot(value) });
+}
+
+function pushRoleMessages(
+  result: Array<Record<string, unknown>>,
+  root: Record<string, unknown>,
+  key: string,
+  prefix = "$",
+): void {
+  const messages = root[key];
+  if (!Array.isArray(messages)) return;
+
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!isRecord(message)) continue;
+    if (message.role !== "system" && message.role !== "developer") continue;
+
+    result.push({
+      path: `${prefix}.${key}[${index}].content`,
+      role: message.role,
+      value: jsonSnapshot(message.content),
+    });
+  }
+}
+
+/**
+ * Extract provider-level system instructions without persisting the complete
+ * request payload, which would duplicate the conversation and tool schemas.
+ */
+export function extractProviderSystemInstructions(
+  payload: unknown,
+): Array<Record<string, unknown>> {
+  if (!isRecord(payload)) return [];
+
+  const result: Array<Record<string, unknown>> = [];
+  const roots = [{ value: payload, prefix: "$" }];
+
+  // Some custom transports wrap the JSON body one level down.
+  if (isRecord(payload.body)) {
+    roots.push({ value: payload.body, prefix: "$.body" });
+  }
+
+  for (const { value: root, prefix } of roots) {
+    for (const key of [
+      "instructions",
+      "system",
+      "system_instruction",
+      "systemInstruction",
+      "systemPrompt",
+      "preamble",
+    ]) {
+      pushField(result, root, key, prefix);
+    }
+    pushRoleMessages(result, root, "messages", prefix);
+    pushRoleMessages(result, root, "input", prefix);
+  }
+
+  return result;
+}
+
+export function sha256(text: string): string {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+export function latestSystemPromptSha256(entries: readonly CustomEntryLike[]): string | undefined {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry?.type !== "custom" || entry.customType !== SYSTEM_PROMPT_ENTRY_TYPE) continue;
+    if (!isRecord(entry.data)) continue;
+    if (typeof entry.data.systemPromptSha256 === "string") {
+      return entry.data.systemPromptSha256;
+    }
+    // Compatibility with snapshots written before the hash field existed.
+    if (typeof entry.data.systemPrompt === "string") {
+      return sha256(entry.data.systemPrompt);
+    }
+  }
+  return undefined;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "system-prompt-omni",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "Display, export, and record the effective pi coding agent system prompt",
+  "keywords": ["pi-package", "pi-extension", "system-prompt", "debugging", "recorder"],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/weiwch/system-prompt-omni"
+  },
+  "homepage": "https://github.com/weiwch/system-prompt-omni#readme",
+  "bugs": {
+    "url": "https://github.com/weiwch/system-prompt-omni/issues"
+  },
+  "files": ["extensions", "lib"],
+  "scripts": {
+    "test": "node --test test/*.test.ts"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "pi": {
+    "extensions": ["./extensions"]
+  }
+}