pi-reasoning-zip 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0] - 2026-07-02
+
+### Added
+
+- Added developer release checklist to README.
+
+### Changed
+
+- Updated package description to "Compact reasoning blocks to keep the context short."
+
+## [0.1.0] - 2026-07-02
+
+### Added
+
+- Scaffolded Pi extension package for `pi-reasoning-zip`.
+- Settings resolver for `reasoningZip` defaults and partial config.
+- Provider targeting helpers for llama.cpp/local/all modes.
+- Pure assistant `thinking` block compaction transform.
+- OpenAI-compatible local compactor client and compaction prompt builder.
+- Conservative grug-style prompt injection for target provider requests.
+- Vitest coverage for settings, targeting, prompt injection, prompt building, and message transformation.
+- MIT license metadata and license file.
+- Compiled-extension smoke harness for hook registration, compaction, and prompt injection.
+- GitHub/package banner image metadata.
+
+### Changed
+
+- Trimmed npm package contents to runtime build, smoke harness, README, changelog, and license only.
+- Reworked README structure to match the concise Pi package style used by sibling packages.
+- Added package motto to README.
+- Added npm release metadata: description, keywords, repository links, exports, and Node engine.
+
+[Unreleased]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/Ryu-CZ/pi-reasoning-zip/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryu-CZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,251 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Ryu-CZ/pi-reasoning-zip/main/media/banner.webp" alt="pi-reasoning-zip banner" />
+</p>
+
+# pi-reasoning-zip
+
+<p>
+  <a href="https://www.npmjs.com/package/pi-reasoning-zip">
+    <img src="https://img.shields.io/npm/v/pi-reasoning-zip" alt="npm version">
+  </a>
+  <a href="https://www.npmjs.com/package/pi-reasoning-zip">
+    <img src="https://img.shields.io/npm/dt/pi-reasoning-zip" alt="npm downloads">
+  </a>
+  <a href="LICENSE">
+    <img src="https://img.shields.io/npm/l/pi-reasoning-zip" alt="license">
+  </a>
+  <a href="https://pi.dev/packages/pi-reasoning-zip">
+    <img src="https://img.shields.io/badge/pi-package-1a1a2e" alt="pi package">
+  </a>
+</p>
+
+Compress reasoning blocks to keep the context short.
+
+`pi-reasoning-zip` compresses new Pi-visible assistant `thinking` blocks into compact reasoning traces before they are stored in the session.
+
+```text
+verbose thinking block  ->  facts / decisions / constraints / failed / next
+```
+
+Use this when local models expose long reasoning and you want future Pi turns to replay compact traces instead of raw reasoning haystacks.
+
+## Install
+
+```bash
+# From npm, after publish
+pi install npm:pi-reasoning-zip
+
+# From git
+pi install git:github.com/Ryu-CZ/pi-reasoning-zip
+
+# Development
+npm install
+npm run check
+npm run smoke
+```
+
+For local development you can also load the built extension directly:
+
+```bash
+npm run build
+pi -e ./dist/index.js
+```
+
+## Features
+
+- **Forward-only compaction** — modifies only the new assistant message being finalized.
+- **Stored compact traces** — future turns naturally replay compact `thinking` because that is what Pi stored.
+- **Local compactor** — calls a configured OpenAI-compatible `/chat/completions` endpoint directly.
+- **llama.cpp-first targeting** — defaults to llama.cpp-like providers such as `llama-server=http://127.0.0.1:7484`.
+- **Prompt minimization** — optional grug-style request injection for target local providers.
+- **Fail-open safety** — preserves original messages on errors, timeouts, invalid output, or unknown payloads.
+- **Opaque reasoning guard** — skips signed/encrypted/provider-opaque reasoning metadata.
+
+## Commands
+
+None.
+
+`pi-reasoning-zip` works through Pi lifecycle hooks:
+
+| Hook | Purpose |
+|---|---|
+| `message_end` | Compact eligible new assistant `thinking` blocks before storage |
+| `before_provider_request` | Optionally inject terse-reasoning guidance for target local providers |
+
+## Configuration
+
+Settings live in project `.pi/settings.json` or global `~/.pi/agent/settings.json` under the `reasoningZip` key. Project settings take precedence.
+
+```json
+{
+  "reasoningZip": {
+    "enabled": true,
+    "mode": "llama-only",
+    "storageMode": "compact-new",
+    "injectPrompt": true,
+    "compactor": {
+      "baseUrl": "http://127.0.0.1:7484/v1",
+      "model": "unsloth",
+      "apiKey": "sk-placeholder",
+      "maxTokens": 512,
+      "temperature": 0.1,
+      "timeoutMs": 30000
+    },
+    "thresholds": {
+      "minChars": 1000,
+      "targetRatio": 0.15,
+      "maxTraceChars": 2000
+    }
+  }
+}
+```
+
+### Modes
+
+| Mode | Behavior |
+|---|---|
+| `llama-only` | Compact llama.cpp-like providers only |
+| `local-only` | Compact local URL providers and llama.cpp-like providers |
+| `all` | Compact any eligible plain Pi `thinking` block |
+| `disabled` | No-op |
+
+### Storage modes
+
+| Storage mode | Behavior |
+|---|---|
+| `compact-new` | Compact new assistant thinking before storage |
+| `off` | Do not alter assistant messages |
+
+## Compactor endpoint
+
+The compactor must expose an OpenAI-compatible chat completions endpoint:
+
+```text
+POST {baseUrl}/chat/completions
+```
+
+The extension asks the compactor to produce terse output like:
+
+```text
+facts:
+- ...
+decisions:
+- ...
+constraints:
+- ...
+failed:
+- ...
+next:
+- ...
+```
+
+If the compactor returns `none`, empty output, output longer than the original, or output over `thresholds.maxTraceChars`, the original block is preserved.
+
+## Safety model
+
+This extension does **not**:
+
+- rewrite previous sessions
+- backfill older entries in the current session
+- mutate replayed context with the `context` hook
+- claim to reduce hidden provider-side reasoning tokens
+- touch signed, encrypted, or opaque provider reasoning metadata
+
+It skips:
+
+- non-assistant messages
+- messages without array content
+- short thinking below `thresholds.minChars`
+- unknown providers by default in `llama-only`
+- hosted/non-local providers in `local-only`
+
+## Smoke tests
+
+Automated local smoke test:
+
+```bash
+npm run smoke
+```
+
+This loads `dist/index.js`, registers the Pi hooks against a mock extension API, uses a temporary `.pi/settings.json`, mocks the OpenAI-compatible compactor, and verifies thinking compaction plus targeted prompt injection.
+
+Manual Pi smoke test:
+
+1. Start a local llama.cpp/OpenAI-compatible server that can compact text.
+2. Configure `reasoningZip.compactor.baseUrl` and `reasoningZip.compactor.model`.
+3. Enable `mode: "llama-only"` and use a llama.cpp provider in Pi.
+4. Ask a prompt that produces long visible reasoning/thinking.
+5. Inspect the session JSONL.
+6. Confirm the new assistant message contains compact `thinking`, not raw verbose reasoning.
+7. Confirm older session entries were not changed.
+8. Send another prompt and confirm Pi replays the compact trace because that is what was stored.
+
+## Development
+
+```bash
+npm run typecheck
+npm test
+npm run build
+npm run check
+npm run smoke
+npm pack --dry-run
+```
+
+## Release checklist
+
+1. Update the version in `package.json` and `package-lock.json`.
+
+   ```bash
+   npm version <patch|minor|major> --no-git-tag-version
+   ```
+
+2. Move completed `CHANGELOG.md` entries from `[Unreleased]` to the new version section.
+
+   ```md
+   ## [Unreleased]
+
+   ## [x.y.z] - YYYY-MM-DD
+   ```
+
+3. Update changelog links at the bottom.
+
+   ```md
+   [Unreleased]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/vx.y.z...HEAD
+   [x.y.z]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/vprevious...vx.y.z
+   ```
+
+   For the first release, link the version to the release page:
+
+   ```md
+   [0.1.0]: https://github.com/Ryu-CZ/pi-reasoning-zip/releases/tag/v0.1.0
+   ```
+
+4. Verify build, smoke test, package contents, and npm publish metadata.
+
+   ```bash
+   npm run check
+   npm run smoke
+   npm pack --dry-run
+   npm publish --dry-run
+   ```
+
+5. Commit and tag the release.
+
+   ```bash
+   git add package.json package-lock.json CHANGELOG.md
+   git commit -m "chore: release vx.y.z"
+   git tag -a vx.y.z -m "vx.y.z"
+   ```
+
+6. Push branch and tag.
+
+   ```bash
+   git push origin main
+   git push origin vx.y.z
+   ```
+
+7. Publish to npm when ready.
+
+   ```bash
+   npm publish
+   ```

package/dist/compactPrompt.d.ts

@@ -0,0 +1 @@
+export declare function buildCompactionPrompt(thinking: string): string;

package/dist/compactPrompt.js

@@ -0,0 +1,12 @@
+export function buildCompactionPrompt(thinking) {
+    return `Compress this model reasoning into a compact decision trace for future coding-agent context.
+
+Keep exact paths, commands, symbols, errors, decisions, constraints, failed attempts, and next actions.
+Drop self-talk, repeated planning, obvious reasoning, filler, and prose.
+Use terse bullets under: facts, decisions, constraints, failed, next.
+Target 10-20% of original length.
+If no useful content remains, output exactly: none
+
+Reasoning:
+${thinking}`;
+}

package/dist/compactorClient.d.ts

@@ -0,0 +1,2 @@
+import type { ReasoningZipSettings } from "./types.js";
+export declare function compactWithOpenAI(thinking: string, settings: ReasoningZipSettings): Promise<string>;

package/dist/compactorClient.js

@@ -0,0 +1,34 @@
+import { buildCompactionPrompt } from "./compactPrompt.js";
+export async function compactWithOpenAI(thinking, settings) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), settings.compactor.timeoutMs);
+    try {
+        const response = await fetch(`${settings.compactor.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${settings.compactor.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: settings.compactor.model,
+                messages: [
+                    { role: "system", content: "You compress reasoning traces. Output only compact trace." },
+                    { role: "user", content: buildCompactionPrompt(thinking) },
+                ],
+                max_tokens: settings.compactor.maxTokens,
+                temperature: settings.compactor.temperature,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            throw new Error(`Compactor HTTP ${response.status}`);
+        const json = (await response.json());
+        const content = json.choices?.[0]?.message?.content;
+        if (typeof content !== "string")
+            throw new Error("Compactor response missing message content");
+        return content.trim();
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function reasoningZipExtension(pi: ExtensionAPI): void;

package/dist/index.js

@@ -0,0 +1,50 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { compactWithOpenAI } from "./compactorClient.js";
+import { compactAssistantMessage } from "./messageTransform.js";
+import { injectReasoningZipPrompt } from "./promptInjection.js";
+import { resolveReasoningZipSettings } from "./settings.js";
+function globalSettingsPath() {
+    return join(process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"), "settings.json");
+}
+function projectSettingsPath(cwd) {
+    return cwd ? join(cwd, ".pi", "settings.json") : undefined;
+}
+function readSettingsSection(path) {
+    if (!path)
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return parsed.reasoningZip;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRawSettings(cwd) {
+    return readSettingsSection(projectSettingsPath(cwd)) ?? readSettingsSection(globalSettingsPath());
+}
+function eventProvider(event) {
+    const message = event.message;
+    if (typeof message?.provider === "string")
+        return message.provider;
+    if (typeof event.provider === "string")
+        return event.provider;
+    return undefined;
+}
+export default function reasoningZipExtension(pi) {
+    const extension = pi;
+    extension.on("message_end", async (event, ctx) => {
+        const settings = resolveReasoningZipSettings(readRawSettings(ctx?.cwd));
+        const result = await compactAssistantMessage(event.message, settings, (thinking) => compactWithOpenAI(thinking, settings));
+        if (result.changed)
+            return { message: result.message };
+        return undefined;
+    });
+    extension.on("before_provider_request", (event, ctx) => {
+        const settings = resolveReasoningZipSettings(readRawSettings(ctx?.cwd));
+        const nextPayload = injectReasoningZipPrompt(event.payload, eventProvider(event), settings);
+        return nextPayload === event.payload ? undefined : nextPayload;
+    });
+}

package/dist/messageTransform.d.ts

@@ -0,0 +1,6 @@
+import type { PiMessage, ReasoningZipSettings } from "./types.js";
+export type CompactText = (thinking: string) => Promise<string>;
+export declare function compactAssistantMessage(message: PiMessage, settings: ReasoningZipSettings, compactText: CompactText): Promise<{
+    message: PiMessage;
+    changed: boolean;
+}>;

package/dist/messageTransform.js

@@ -0,0 +1,49 @@
+import { shouldHandleMessage } from "./target.js";
+function isThinkingBlock(block) {
+    return block.type === "thinking" && typeof block.thinking === "string";
+}
+function hasOpaqueReasoningMetadata(block) {
+    return (typeof block.signature === "string" ||
+        typeof block.reasoning_signature === "string" ||
+        typeof block.encrypted_content === "string" ||
+        Array.isArray(block.reasoning_details));
+}
+function acceptableCompaction(original, compacted, settings) {
+    const text = compacted.trim();
+    if (!text || text === "none")
+        return undefined;
+    if (text.length >= original.length)
+        return undefined;
+    if (text.length > settings.thresholds.maxTraceChars)
+        return undefined;
+    return text;
+}
+export async function compactAssistantMessage(message, settings, compactText) {
+    if (!shouldHandleMessage(message, settings))
+        return { message, changed: false };
+    if (!Array.isArray(message.content))
+        return { message, changed: false };
+    let changed = false;
+    const nextContent = [];
+    for (const block of message.content) {
+        if (!isThinkingBlock(block) || hasOpaqueReasoningMetadata(block) || block.thinking.length < settings.thresholds.minChars) {
+            nextContent.push(block);
+            continue;
+        }
+        try {
+            const compacted = acceptableCompaction(block.thinking, await compactText(block.thinking), settings);
+            if (!compacted) {
+                nextContent.push(block);
+                continue;
+            }
+            nextContent.push({ ...block, thinking: compacted });
+            changed = true;
+        }
+        catch {
+            nextContent.push(block);
+        }
+    }
+    if (!changed)
+        return { message, changed: false };
+    return { message: { ...message, content: nextContent }, changed: true };
+}

package/dist/promptInjection.d.ts

@@ -0,0 +1,4 @@
+import type { ReasoningZipSettings } from "./types.js";
+export declare const PROMPT_MARKER = "<!-- pi-reasoning-zip -->";
+export declare const PROMPT_INJECTION = "<!-- pi-reasoning-zip -->\nYou are Grug. Save token, save world.\nVisible reasoning: terse, keyword-heavy trace only. Keep facts, decisions, constraints, failed paths, next action. No prose reasoning, no self-talk.\nFinal answer: no conversational fluff, no repeated question, minimal markdown. If code is enough, give only code. Think hard, output few tokens.";
+export declare function injectReasoningZipPrompt(payload: unknown, provider: string | undefined, settings: ReasoningZipSettings): unknown;

package/dist/promptInjection.js

@@ -0,0 +1,37 @@
+import { shouldTargetProvider } from "./target.js";
+export const PROMPT_MARKER = "<!-- pi-reasoning-zip -->";
+export const PROMPT_INJECTION = `${PROMPT_MARKER}\nYou are Grug. Save token, save world.\nVisible reasoning: terse, keyword-heavy trace only. Keep facts, decisions, constraints, failed paths, next action. No prose reasoning, no self-talk.\nFinal answer: no conversational fluff, no repeated question, minimal markdown. If code is enough, give only code. Think hard, output few tokens.`;
+function appendToContent(content) {
+    if (typeof content === "string") {
+        if (content.includes(PROMPT_MARKER))
+            return content;
+        return `${content}\n\n${PROMPT_INJECTION}`;
+    }
+    if (Array.isArray(content)) {
+        if (content.some((part) => typeof part === "object" && part && "text" in part && typeof part.text === "string" && part.text.includes(PROMPT_MARKER))) {
+            return content;
+        }
+        return [...content, { type: "text", text: PROMPT_INJECTION }];
+    }
+    return content;
+}
+export function injectReasoningZipPrompt(payload, provider, settings) {
+    if (!settings.injectPrompt || !shouldTargetProvider(provider, settings))
+        return payload;
+    if (!payload || typeof payload !== "object")
+        return payload;
+    const typed = payload;
+    if (!Array.isArray(typed.messages))
+        return payload;
+    const messages = typed.messages;
+    const existing = JSON.stringify(messages).includes(PROMPT_MARKER);
+    if (existing)
+        return payload;
+    const index = messages.findIndex((message) => message.role === "system" || message.role === "developer");
+    if (index >= 0) {
+        const nextMessages = messages.slice();
+        nextMessages[index] = { ...messages[index], content: appendToContent(messages[index].content) };
+        return { ...typed, messages: nextMessages };
+    }
+    return { ...typed, messages: [{ role: "system", content: PROMPT_INJECTION }, ...messages] };
+}

package/dist/settings.d.ts

@@ -0,0 +1,3 @@
+import type { ReasoningZipSettings } from "./types.js";
+export declare const DEFAULT_SETTINGS: ReasoningZipSettings;
+export declare function resolveReasoningZipSettings(input: unknown): ReasoningZipSettings;

package/dist/settings.js

@@ -0,0 +1,61 @@
+export const DEFAULT_SETTINGS = {
+    enabled: true,
+    mode: "llama-only",
+    storageMode: "compact-new",
+    injectPrompt: true,
+    compactor: {
+        baseUrl: "http://127.0.0.1:7484/v1",
+        model: "unsloth",
+        apiKey: "sk-placeholder",
+        maxTokens: 512,
+        temperature: 0.1,
+        timeoutMs: 30000,
+    },
+    thresholds: {
+        minChars: 1000,
+        targetRatio: 0.15,
+        maxTraceChars: 2000,
+    },
+};
+const modes = new Set(["llama-only", "local-only", "all", "disabled"]);
+const storageModes = new Set(["compact-new", "off"]);
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value, fallback) {
+    return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function booleanValue(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function numberValue(value, fallback, min = 0) {
+    return typeof value === "number" && Number.isFinite(value) && value >= min ? value : fallback;
+}
+export function resolveReasoningZipSettings(input) {
+    const root = asObject(input);
+    const compactor = asObject(root.compactor);
+    const thresholds = asObject(root.thresholds);
+    const mode = modes.has(root.mode) ? root.mode : DEFAULT_SETTINGS.mode;
+    const storageMode = storageModes.has(root.storageMode)
+        ? root.storageMode
+        : DEFAULT_SETTINGS.storageMode;
+    return {
+        enabled: booleanValue(root.enabled, DEFAULT_SETTINGS.enabled),
+        mode,
+        storageMode,
+        injectPrompt: booleanValue(root.injectPrompt, DEFAULT_SETTINGS.injectPrompt),
+        compactor: {
+            baseUrl: stringValue(compactor.baseUrl, DEFAULT_SETTINGS.compactor.baseUrl).replace(/\/$/, ""),
+            model: stringValue(compactor.model, DEFAULT_SETTINGS.compactor.model),
+            apiKey: stringValue(compactor.apiKey, DEFAULT_SETTINGS.compactor.apiKey),
+            maxTokens: numberValue(compactor.maxTokens, DEFAULT_SETTINGS.compactor.maxTokens, 1),
+            temperature: numberValue(compactor.temperature, DEFAULT_SETTINGS.compactor.temperature, 0),
+            timeoutMs: numberValue(compactor.timeoutMs, DEFAULT_SETTINGS.compactor.timeoutMs, 1),
+        },
+        thresholds: {
+            minChars: numberValue(thresholds.minChars, DEFAULT_SETTINGS.thresholds.minChars, 0),
+            targetRatio: numberValue(thresholds.targetRatio, DEFAULT_SETTINGS.thresholds.targetRatio, 0),
+            maxTraceChars: numberValue(thresholds.maxTraceChars, DEFAULT_SETTINGS.thresholds.maxTraceChars, 1),
+        },
+    };
+}

package/dist/target.d.ts

@@ -0,0 +1,5 @@
+import type { PiMessage, ReasoningZipSettings } from "./types.js";
+export declare function isLlamaProvider(providerId: string | undefined): boolean;
+export declare function isLocalUrl(value: string | undefined): boolean;
+export declare function shouldHandleMessage(message: PiMessage, settings: ReasoningZipSettings): boolean;
+export declare function shouldTargetProvider(provider: string | undefined, settings: ReasoningZipSettings): boolean;

package/dist/target.js

@@ -0,0 +1,42 @@
+export function isLlamaProvider(providerId) {
+    if (!providerId)
+        return false;
+    const id = providerId.toLowerCase();
+    return id.startsWith("llama-server=") || id.includes("llama.cpp") || id.includes("llamacpp");
+}
+export function isLocalUrl(value) {
+    if (!value)
+        return false;
+    try {
+        const url = new URL(value.includes("://") ? value : `http://${value}`);
+        return ["127.0.0.1", "localhost", "::1", "0.0.0.0"].includes(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+export function shouldHandleMessage(message, settings) {
+    if (!settings.enabled || settings.mode === "disabled" || settings.storageMode !== "compact-new")
+        return false;
+    if (message.role !== "assistant")
+        return false;
+    const provider = typeof message.provider === "string" ? message.provider : undefined;
+    if (settings.mode === "all")
+        return true;
+    if (settings.mode === "llama-only")
+        return isLlamaProvider(provider);
+    if (settings.mode === "local-only")
+        return isLocalUrl(provider) || isLlamaProvider(provider);
+    return false;
+}
+export function shouldTargetProvider(provider, settings) {
+    if (!settings.enabled || settings.mode === "disabled")
+        return false;
+    if (settings.mode === "all")
+        return true;
+    if (settings.mode === "llama-only")
+        return isLlamaProvider(provider);
+    if (settings.mode === "local-only")
+        return isLocalUrl(provider) || isLlamaProvider(provider);
+    return false;
+}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+export type ReasoningZipMode = "llama-only" | "local-only" | "all" | "disabled";
+export type ReasoningZipStorageMode = "compact-new" | "off";
+export interface ReasoningZipSettings {
+    enabled: boolean;
+    mode: ReasoningZipMode;
+    storageMode: ReasoningZipStorageMode;
+    injectPrompt: boolean;
+    compactor: {
+        baseUrl: string;
+        model: string;
+        apiKey: string;
+        maxTokens: number;
+        temperature: number;
+        timeoutMs: number;
+    };
+    thresholds: {
+        minChars: number;
+        targetRatio: number;
+        maxTraceChars: number;
+    };
+}
+export interface PiMessageBlock {
+    type?: string;
+    text?: string;
+    thinking?: string;
+    [key: string]: unknown;
+}
+export interface PiMessage {
+    role?: string;
+    content?: string | PiMessageBlock[];
+    provider?: string;
+    model?: string;
+    api?: string;
+    [key: string]: unknown;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "pi-reasoning-zip",
+  "version": "0.2.0",
+  "private": false,
+  "description": "Compact reasoning blocks to keep the context short.",
+  "license": "MIT",
+  "author": "Ryu-CZ <thandeus@gmail.com> (https://github.com/Ryu-CZ)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "scripts/smoke-extension.mjs",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "reasoning",
+    "thinking",
+    "context",
+    "llama-cpp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://git@github.com/Ryu-CZ/pi-reasoning-zip.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Ryu-CZ/pi-reasoning-zip/issues"
+  },
+  "homepage": "https://github.com/Ryu-CZ/pi-reasoning-zip#readme",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "check": "npm run typecheck && npm test && npm run build",
+    "prepack": "npm run build",
+    "smoke": "npm run build && node scripts/smoke-extension.mjs"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.80.3",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  },
+  "pi": {
+    "extensions": [
+      "dist/index.js"
+    ],
+    "image": "https://raw.githubusercontent.com/Ryu-CZ/pi-reasoning-zip/main/media/banner.webp"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

package/scripts/smoke-extension.mjs

@@ -0,0 +1,83 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import reasoningZipExtension from "../dist/index.js";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+const cwd = await mkdtemp(join(tmpdir(), "pi-reasoning-zip-smoke-"));
+try {
+  await mkdir(join(cwd, ".pi"), { recursive: true });
+  await writeFile(
+    join(cwd, ".pi", "settings.json"),
+    JSON.stringify({
+      reasoningZip: {
+        mode: "llama-only",
+        thresholds: { minChars: 5, maxTraceChars: 100 },
+        compactor: { baseUrl: "http://mock.local/v1", model: "mock", timeoutMs: 1000 },
+      },
+    }),
+    "utf8",
+  );
+
+  const handlers = new Map();
+  reasoningZipExtension({ on: (name, handler) => handlers.set(name, handler) });
+
+  assert(handlers.has("message_end"), "message_end hook was not registered");
+  assert(handlers.has("before_provider_request"), "before_provider_request hook was not registered");
+
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url, init) => {
+    assert(String(url) === "http://mock.local/v1/chat/completions", "compactor URL mismatch");
+    const body = JSON.parse(init.body);
+    assert(body.messages[1].content.includes("abcdefghijklmnopqrstuvwxyz"), "compactor prompt missing thinking text");
+    return {
+      ok: true,
+      json: async () => ({ choices: [{ message: { content: "facts:\n- smoke compacted" } }] }),
+    };
+  };
+
+  try {
+    const compacted = await handlers.get("message_end")(
+      {
+        message: {
+          role: "assistant",
+          provider: "llama-server=http://127.0.0.1:7484",
+          content: [
+            { type: "text", text: "answer" },
+            { type: "thinking", thinking: "abcdefghijklmnopqrstuvwxyz" },
+          ],
+          metadata: { keep: true },
+        },
+      },
+      { cwd },
+    );
+
+    assert(compacted?.message?.content?.[0]?.text === "answer", "text block was not preserved");
+    assert(compacted.message.content[1].thinking === "facts:\n- smoke compacted", "thinking block was not compacted");
+    assert(compacted.message.metadata.keep === true, "assistant metadata was not preserved");
+
+    const injected = handlers.get("before_provider_request")(
+      {
+        provider: "llama-server=http://127.0.0.1:7484",
+        payload: { messages: [{ role: "system", content: "sys" }, { role: "user", content: "hi" }] },
+      },
+      { cwd },
+    );
+    assert(injected.messages[0].content.includes("<!-- pi-reasoning-zip -->"), "prompt marker was not injected");
+
+    const skipped = handlers.get("before_provider_request")(
+      { provider: "openai", payload: { messages: [{ role: "system", content: "sys" }] } },
+      { cwd },
+    );
+    assert(skipped === undefined, "non-target provider should not be modified");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+
+  console.log("pi-reasoning-zip smoke passed");
+} finally {
+  await rm(cwd, { recursive: true, force: true });
+}