@howaboua/pi-notes-compaction 0.0.0-stage → 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @howaboua/pi-notes-compaction
+
+## 0.0.2
+
+- Added a `/notes` settings panel for normal compaction, idle rollover, continuity status and confirmed pruning, replacing the subcommands and JSON status output.
+
+## 0.0.1
+
+- Added Notes Compaction: local checkpoint notes, searchable session history and notes-guided context windows for any Pi model, with optional Codex Conversion integration and cached remote lookup.

package/PCC-INTEGRATION.md

@@ -0,0 +1,100 @@
+# PCC takeover contract, protocol 1
+
+This contract is implemented by Pi Codex Conversion in this checkout and by this extension's `src/bridge.ts`. The extension stays inactive when legacy context tools exist without an acknowledged bridge.
+
+Use Pi's public `pi.events` bus. Do not import PCC internals into this package or create a dependency cycle. `src/bridge.ts` defines the exact TypeScript signatures. Bus objects and callbacks are process-local, not serialized session data.
+
+## Discovery and one registration owner
+
+Two request channels use synchronous callbacks:
+
+```ts
+// PCC asks whether an external continuity owner is installed.
+pi.events.emit("pi-notes-compaction:owner:v1", {
+  protocol: 1,
+  reply(owner) { /* retain the NotesOwner for this runtime */ }
+})
+
+// PCC publishes its optional adapter before session_start.
+pi.events.on("pi-notes-compaction:bridge:v1", request => {
+  if (request.protocol === 1) request.reply(bridge)
+})
+```
+
+Every extension finishes loading before `session_start`. Both sides must discover again at that boundary. PCC must check for the external owner before its first session initialization and before every activation-plan or tool rewrite. This works in either load order. No prefix edit, timer or module-global import is discovery.
+
+`bridge.claim(owner)` returns either `{ claimed: false, reason }` or `{ claimed: true, registerTools }`. A success synchronously transfers continuity policy ownership. The callback `registerTools(tools, ctx)` registers the supplied four definitions **through PCC's own `pi.registerTool` API**, replacing PCC's existing definitions in place. The new extension does not register duplicate names when takeover succeeds. Pi cannot unregister tools. Hiding a legacy definition in another extension is not sufficient because registry precedence depends on extension order.
+
+PCC may defer its legacy registrations until discovery, but it must still use the same PCC-owned registration callback on takeover. With no external owner, PCC retains all existing behavior. A failed claim must leave its legacy owner intact. Do not acknowledge a partial takeover.
+
+## PCC owners that must yield
+
+Add an explicit external-owner branch to `adapter/activation/runtime-plan.ts` and every continuity consumer. The external owner takes notes, history routing, context identities, reminders, manual checkpoint policy, idle input admission and window rollover. Disable PCC's corresponding Local, Tree and Remote policy owners, not its provider services.
+
+Required boundaries in the current source:
+
+- `context-management/tools.ts` and `extension/tools.ts`: replace the four tools through the registration callback. Active-tool and schema rewrites must preserve delegated definitions. Do not reinstall legacy routers on model changes or settings changes.
+- `extension/session-lifecycle.ts` and `extension/turn-lifecycle.ts`: skip legacy notes/window initialization, input holding, checkpoint admission, note freshness, reminders, settlement records and continuation scheduling. Leave PCC's prompt preparation, runtime synchronization, Notebook status, voice, quota and provider lifecycle active.
+- `extension/compaction-lifecycle.ts`: skip only legacy `contextWindows.prepareCompaction` and notes checkpoint overrides. When this extension allows normal compaction, run the unchanged installed PCC normal-compaction path. Overflow stays in the same window. Notebook checkpointing, native compaction, replay, transport reset and presentation remain PCC-owned.
+- `context-management/window-manager.ts`, `window-request.ts` and native replay serializers: use `owner.identity(ctx)` and `owner.projectBranch(entries)` for the active window and retirement boundary. Preserve PCC request metadata and zero-based generation semantics. Do not recreate remote history-ingest requirements for local notes.
+- PCC message preparation and `adapter/developer-messages.ts`: preserve `notes-compaction:window:v1` and `notes-compaction:checkpoint:v1` custom messages on every model. Compatible Responses routes may promote them to developer messages. Ordinary Pi conversion must retain them on other routes. Use `owner.projectMessages(messages)` before native replay/prewarm, without overwriting another extension's preparation.
+- Settings UI: show notes continuity as externally managed. Preserve old PCC values for sessions without the external extension. Do not add another compaction setting to this extension.
+
+Normal compaction output belongs exclusively to Pi and PCC. This package does not port V2, copy encrypted compaction checkpoints or persist its own compaction records.
+
+`beforeWindow(ctx, signal?)` is optional. PCC can checkpoint Notebook and reset owned transport/window state there. It must fail before a new marker is appended if preparation fails. A rollover continuation is a settled **user** kickoff. Both the checkpoint and successor must run the complete `input` and `before_agent_start` chain, not a captured prompt or developer-message turn.
+
+## Code and Notebook
+
+`configureTools(tools, ctx, contracts)` receives the delegated definitions and compact `notes` and `history` usage strings. Reuse PCC's existing `toNestedTool` and `registerCodeModeExtensionTools` machinery inside PCC:
+
+- Defer notes/history schemas and full contracts through discovery. Keep them callable and discoverable in `ALL_TOOLS` without per-tool provider schemas or standing usage.
+- Calls use ordinary query and text arguments, not encrypted model arguments.
+- Plain local results remain ordinary JavaScript values. For results containing opaque remote responses, JavaScript gets a receipt and the model gets protected delivery.
+- Preserve current-call and original-exec ancestry through `exec` and `wait`. Propagate the successful local note-write receipt to PCC's existing saved-note presentation if needed.
+- Preserve `details.notesCompaction` on direct write results. Nested exec/wait must keep PCC's `contextNotesSaved` success or failure outcome, including a failed write after an earlier successful write. Checkpoint freshness requires completed write results, not receipt existence alone.
+- `new_context` is `model-only`, sequential and **never nested**. Keep its native schema in Code and Notebook. Do not expose it through `tools` or execute a rollover under an exec cell.
+
+Configuration is repeated on session start and model selection. It must be idempotent. Do not rewrite earlier tool calls or results.
+
+## Remote response cache and provider projection
+
+Optional `lookup(query, ctx, signal?)` handles read-only notes/history operations through PCC's existing authenticated backend. The query is `{ namespace: "notes" | "history", params }`. Paths sent to lookup are fully qualified virtual paths. Writes never go to the remote backend.
+
+Return `CachedResponse[]`, with each element containing:
+
+- `query`: the exact query whose result these bytes represent.
+- `bytes`: the unchanged backend response bytes as `Uint8Array`.
+- `source`: the existing backend/source identity needed to project the response.
+- `encoding`: the response encoding, normally `application/json`.
+- `fetchedAt`: the access timestamp in milliseconds.
+- `coverage`: `complete`, `partial` or `unknown`. This describes that response, not the entire remote archive.
+
+Return the requested response and any additional complete query responses already present on access. Do not fabricate plaintext file indexes from encrypted lists or searches. The new extension caches every returned response, then projects responses matching the requested query. A network failure reuses the newest cached exact-query response per source and labels it offline. Database or delivery failure remains a failure.
+
+`canProject(ctx)` must return false when the active model cannot consume encrypted results. Without compatible projection, ciphertext stays cached and local data remains available.
+
+`projectResult(result, responses, callId, ctx, signal?)` returns a fresh `AgentToolResult`. Decode only the response envelope to recover its original `encrypted_output` and useful plain attachment hint. Do not decrypt, concatenate ciphertext strings, invent an old call ID or reuse an old protected-delivery record. The provider boundary must emit the actual current tool call's function output as native blocks:
+
+```ts
+{
+  type: "function_call_output",
+  call_id: actualCurrentCallId,
+  output: [
+    { type: "input_text", text: localResultAndCoverage },
+    { type: "encrypted_content", encrypted_content: unchangedEncryptedOutput }
+  ]
+}
+```
+
+Multiple responses stay distinct blocks. Local append overlays stay labelled as overlays, not a decrypted merge. Local replacements supersede remote path reads. Opaque lists/searches can still describe old paths, so preserve the local-authority labels.
+
+For direct calls, extend PCC's `codexHistoryNotes` extraction and Responses conversion to accept the fresh cache-backed result. For nested calls, use PCC's existing authenticated opaque capture and protocol-2 original-exec relay. Cache-backed responses need a new honest delivery envelope for the current call. Retain necessary existing source metadata, but do not add an account-binding, portability, export or key-management framework.
+
+**Persistence boundary:** `Uint8Array` is only the in-process adapter type. Any bytes placed in persisted result details must be encoded explicitly, for example base64 with the declared encoding. JSON serialization of a typed array is not a supported cache or replay format. SQLite stores the original BLOB. PCC retains its existing serialized opaque-delivery format where possible.
+
+Optional `agentName(ctx)` and `route(query, callId, ctx, signal?)` adapt existing PCC family identity and sharing routes. `route` returns `undefined` for current-agent requests. For another agent it returns the normal routed result, preserving that owner's freshness and delivery semantics. Without this capability, cross-agent targets fail explicitly rather than reading another session by guesswork.
+
+## Validation required for the PCC patch
+
+Use the real Pi registry in both extension orders. Check that only PCC owns the four delegated registrations and that its remaining prompt/tool rewrites retain them. Capture final provider schemas and instructions separately in normal, Code and Notebook modes. Exercise direct and original-exec cached opaque delivery, including `wait`, offline lookup, incompatible model selection and persisted replay. Run abort/error checkpoint paths and a later extension's preparation hook. Existing PCC alone must remain unchanged.

package/README.md

@@ -1,3 +1,43 @@
-# Temporary Holding Version
+# Pi Notes Compaction
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Keep working across fresh context windows with local checkpoint notes, searchable session history and optional remote lookup. Works with any Pi model.
+
+## Install
+
+Requires Pi 1.1.0 or newer and Node.js 22.18 or newer.
+
+```sh
+pi install npm:@howaboua/pi-notes-compaction
+```
+
+Reload Pi, then ask the agent to save a checkpoint and start a new context window. It can read those notes and search earlier session history to continue.
+
+With Pi Codex Conversion 3.0.48 or newer, local notes work alongside Codex tools, Code Mode, Notebook and normal compaction. Older PCC versions without this integration leave the extension inactive. Run `/notes` to check activation and available capabilities. Extension authors can read the [integration contract](PCC-INTEGRATION.md).
+
+## Notes and windows
+
+The agent keeps the familiar `notes`, `history`, `new_context` and `get_context_remaining` tools. Notes use virtual paths. Relative paths belong to the current agent. History searches the selected Pi session branch, including earlier windows. It does not create a second transcript archive.
+
+By default, `new_context` starts a fresh window without generating a summary. The agent receives recent note paths, and Pi's saved history remains available for lookup.
+
+Reminders arrive at 85% and 90% context use. `/compact` requests a notes checkpoint and opens a new window only after a completed run with fresh saved notes. Abort, errors and failed writes retain the old context. Overflow recovery still uses Pi's normal compaction.
+
+Idle rollover is off by default. Choose 5, 15, 25 or 55 minutes in `/notes`. After that interval, the next input waits for rollover only if the latest completed turn saved fresh notes. Otherwise it proceeds in the current window without requesting a checkpoint. These intervals are user preferences, not provider cache-expiry guarantees. Held input retains its original text, attachments and SDK options. A failed rollover keeps input pending. Submit another prompt to retry, or reload to cancel it.
+
+## Management
+
+`/notes` opens the settings panel in interactive Pi. It shows continuity status, storage counts and remote capabilities. Changes save immediately.
+
+- **Normal compaction** includes the installed Pi or PCC compaction flow on `new_context`. Off keeps notes-only rollover, the default.
+- **Idle rollover** selects the interval or disables it.
+- **Prune missing sessions** removes records for missing session files after confirmation. Unknown paths, permission errors and the active session are retained.
+
+Notes are stored as plaintext in `<Pi agent directory>/notes-compaction/notes.sqlite`, honoring `PI_CODING_AGENT_DIR`. Saved session snapshots preserve notes across forks and branch navigation, including after database pruning. Existing plaintext PCC notes remain readable without an import.
+
+## Optional remote lookup
+
+With the documented provider bridge, reads and searches automatically combine local notes or JSONL history with remote results. Remote response bytes are cached verbatim in SQLite. Cached lookups can be reused offline, with their original coverage and an explicit exact-query limit. Encrypted listings cannot be searched or expanded locally into queries that were never cached.
+
+New writes always stay local and work with any model. `write_file` replaces the local path and takes precedence over a remote read of that path. `append_to_file` adds a local overlay when no local replacement exists. Remote base content and the overlay remain separate. List and search results label local replacements as authoritative because opaque remote results can contain older versions.
+
+Encrypted remote content needs a compatible provider bridge and the user's compatible OpenAI setup. The cache does not decrypt content or make it portable across incompatible setups. Without compatible delivery, local notes remain usable and the result reports that cached remote content is unavailable.

package/changelog.ts

@@ -0,0 +1,337 @@
+// Generated extension packages copy this file during changelog:extensions.
+
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	DynamicBorder,
+	type ExtensionAPI,
+	getAgentDir,
+	getMarkdownTheme,
+} from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+
+const ENTRY_TYPE = "@howaboua/pi-stuff/changelog";
+const REGISTRATION_CHANNEL = "@howaboua/pi-stuff/changelog/register/v1";
+const STATE_FILENAME = "howaboua-pi-stuff-changelog.json";
+const SUPPRESS_KEY = "suppress";
+const LOCK_STALE_MS = 30_000;
+const LOCK_TIMEOUT_MS = 2_000;
+
+interface PackageMetadata {
+	name: string;
+	version: string;
+}
+
+interface PackageRegistration extends PackageMetadata {
+	changelogPath: string;
+}
+
+interface RegistrationEvent {
+	accept: () => void;
+	registration: PackageRegistration;
+}
+
+interface ChangelogEntry {
+	content: string;
+	version: string;
+}
+
+interface ChangelogEntryData {
+	markdown: string;
+}
+
+type ChangelogState = Record<string, boolean | string>;
+
+function packageRegistration(): PackageRegistration {
+	const packageDirectory = fileURLToPath(new URL(".", import.meta.url));
+	const metadata = JSON.parse(
+		readFileSync(join(packageDirectory, "package.json"), "utf8"),
+	) as Partial<PackageMetadata>;
+	if (typeof metadata.name !== "string" || typeof metadata.version !== "string")
+		throw new Error(`Invalid package metadata in ${packageDirectory}`);
+	return {
+		name: metadata.name,
+		version: metadata.version,
+		changelogPath: join(packageDirectory, "CHANGELOG.md"),
+	};
+}
+
+function isRegistrationEvent(value: unknown): value is RegistrationEvent {
+	if (!value || typeof value !== "object") return false;
+	const event = value as Partial<RegistrationEvent>;
+	return (
+		typeof event.accept === "function" &&
+		typeof event.registration?.name === "string" &&
+		typeof event.registration.version === "string" &&
+		typeof event.registration.changelogPath === "string"
+	);
+}
+
+function parseChangelog(markdown: string): ChangelogEntry[] {
+	const entries: ChangelogEntry[] = [];
+	let currentLines: string[] = [];
+	let currentVersion: string | undefined;
+
+	for (const line of markdown.split("\n")) {
+		const version = line.match(/^##\s+\[?(\d+\.\d+\.\d+)\]?(?:\s.*)?$/)?.[1];
+		if (version) {
+			if (currentVersion)
+				entries.push({
+					content: currentLines.join("\n").trim(),
+					version: currentVersion,
+				});
+			currentVersion = version;
+			currentLines = [line];
+		} else if (currentVersion) {
+			currentLines.push(line);
+		}
+	}
+
+	if (currentVersion)
+		entries.push({
+			content: currentLines.join("\n").trim(),
+			version: currentVersion,
+		});
+	return entries;
+}
+
+function compareVersions(left: string, right: string): number {
+	const leftParts = left.split(".").map(Number);
+	const rightParts = right.split(".").map(Number);
+	for (let index = 0; index < 3; index++) {
+		const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+
+function isStableVersion(version: string): boolean {
+	return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+function statePath(): string {
+	return join(getAgentDir(), STATE_FILENAME);
+}
+
+async function readState(path: string): Promise<ChangelogState> {
+	let text: string;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+		throw error;
+	}
+	const parsed = JSON.parse(text) as unknown;
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+		throw new Error(`${path} must contain a JSON object`);
+	for (const [name, value] of Object.entries(parsed)) {
+		if (name === SUPPRESS_KEY) {
+			if (typeof value !== "boolean")
+				throw new Error(`${path} ${SUPPRESS_KEY} must be a boolean`);
+		} else if (typeof value !== "string") {
+			throw new Error(`${path} version for ${name} must be a string`);
+		}
+	}
+	return parsed as ChangelogState;
+}
+
+async function acquireLock(path: string): Promise<() => Promise<void>> {
+	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	while (true) {
+		try {
+			await mkdir(path);
+			return () => rm(path, { force: true, recursive: true });
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			const info = await stat(path).catch(() => undefined);
+			if (info && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+				await rm(path, { force: true, recursive: true });
+				continue;
+			}
+			if (Date.now() >= deadline)
+				throw new Error(`Timed out waiting for ${path}`);
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+	}
+}
+
+async function writeState(path: string, state: ChangelogState): Promise<void> {
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		const ordered = Object.fromEntries(
+			Object.entries(state).sort(([left], [right]) =>
+				left.localeCompare(right),
+			),
+		);
+		await writeFile(temporaryPath, `${JSON.stringify(ordered, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		await rename(temporaryPath, path);
+	} catch (error) {
+		await rm(temporaryPath, { force: true });
+		throw error;
+	}
+}
+
+function packageMarkdown(
+	registration: PackageRegistration,
+	entries: ChangelogEntry[],
+): string {
+	const body = (entry: ChangelogEntry) =>
+		entry.content
+			.replace(/^##[^\n]*\n*/, "")
+			.replace(/^###\s+(?:Changes|Minor Changes|Patch Changes)\s*\n*/gim, "")
+			.replace(/^###\s+(.+)$/gm, "**$1**");
+	if (entries.length === 1) {
+		const [entry] = entries;
+		if (!entry) return "";
+		return `## ${registration.name} ${entry.version}\n\n${body(entry)}`;
+	}
+	return [
+		`## ${registration.name}`,
+		...entries.map((entry) => `**${entry.version}**\n\n${body(entry)}`),
+	].join("\n\n");
+}
+
+async function claimUpdates(
+	registrations: Iterable<PackageRegistration>,
+): Promise<{ errors: string[]; markdown?: string }> {
+	const stableRegistrations = [...registrations]
+		.filter((registration) => isStableVersion(registration.version))
+		.sort((left, right) => left.name.localeCompare(right.name));
+	if (stableRegistrations.length === 0) return { errors: [] };
+	const path = statePath();
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const release = await acquireLock(`${path}.lock`);
+	try {
+		const state = await readState(path);
+		const errors: string[] = [];
+		const sections: string[] = [];
+		let changed = false;
+		if (state[SUPPRESS_KEY] === true) {
+			for (const registration of stableRegistrations) {
+				const seenVersion = state[registration.name];
+				if (
+					typeof seenVersion !== "string" ||
+					compareVersions(registration.version, seenVersion) > 0
+				) {
+					state[registration.name] = registration.version;
+					changed = true;
+				}
+			}
+			if (changed) await writeState(path, state);
+			return { errors };
+		}
+		for (const registration of stableRegistrations) {
+			const seenVersion = state[registration.name];
+			if (
+				typeof seenVersion === "string" &&
+				compareVersions(registration.version, seenVersion) <= 0
+			)
+				continue;
+			try {
+				const entries = parseChangelog(
+					await readFile(registration.changelogPath, "utf8"),
+				).filter(
+					(entry) =>
+						compareVersions(entry.version, registration.version) <= 0 &&
+						(typeof seenVersion === "string"
+							? compareVersions(entry.version, seenVersion) > 0
+							: entry.version === registration.version),
+				);
+				if (entries.length === 0) {
+					errors.push(
+						`No ${registration.version} changelog entry found for ${registration.name}`,
+					);
+					continue;
+				}
+				sections.push(packageMarkdown(registration, entries));
+				state[registration.name] = registration.version;
+				changed = true;
+			} catch (error) {
+				errors.push(
+					`Could not read the ${registration.name} changelog: ${error instanceof Error ? error.message : String(error)}`,
+				);
+			}
+		}
+		if (changed) await writeState(path, state);
+		return {
+			errors,
+			...(sections.length > 0 ? { markdown: sections.join("\n\n") } : {}),
+		};
+	} finally {
+		await release();
+	}
+}
+
+function registerCoordinator(
+	pi: ExtensionAPI,
+	registration: PackageRegistration,
+): void {
+	let accepted = false;
+	pi.events.emit(REGISTRATION_CHANNEL, {
+		registration,
+		accept: () => {
+			accepted = true;
+		},
+	} satisfies RegistrationEvent);
+	if (accepted) return;
+
+	const registrations = new Map([[registration.name, registration]]);
+	pi.events.on(REGISTRATION_CHANNEL, (value) => {
+		if (!isRegistrationEvent(value)) return;
+		registrations.set(value.registration.name, value.registration);
+		value.accept();
+	});
+	pi.registerEntryRenderer<ChangelogEntryData>(
+		ENTRY_TYPE,
+		(entry, _options, theme) => {
+			if (!entry.data) return undefined;
+			const container = new Container();
+			container.addChild(new DynamicBorder());
+			container.addChild(
+				new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(
+				new Markdown(entry.data.markdown.trim(), 1, 0, getMarkdownTheme()),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(new DynamicBorder());
+			return container;
+		},
+	);
+	pi.on("session_start", async (event, ctx) => {
+		if (event.reason === "reload" || ctx.mode !== "tui") return;
+		if (
+			ctx.sessionManager
+				.getEntries()
+				.some((entry) =>
+					["branch_summary", "compaction", "message"].includes(entry.type),
+				)
+		)
+			return;
+		try {
+			const update = await claimUpdates(registrations.values());
+			if (update.markdown)
+				pi.appendEntry<ChangelogEntryData>(ENTRY_TYPE, {
+					markdown: update.markdown,
+				});
+			for (const error of update.errors) ctx.ui.notify(error, "warning");
+		} catch (error) {
+			ctx.ui.notify(
+				`Could not update Howaboua changelog state: ${error instanceof Error ? error.message : String(error)}`,
+				"warning",
+			);
+		}
+	});
+}
+
+export default function howabouaPackageChangelog(pi: ExtensionAPI): void {
+	registerCoordinator(pi, packageRegistration());
+}

package/package.json

@@ -1,6 +1,51 @@
 {
-  "name": "@howaboua/pi-notes-compaction",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@howaboua/pi-notes-compaction",
+	"version": "0.0.2",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/IgorWarzocha/howaboua-pi-stuff.git",
+		"directory": "packages/pi-notes-compaction"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"PCC-INTEGRATION.md",
+		"changelog.ts",
+		"CHANGELOG.md"
+	],
+	"engines": {
+		"node": ">=22.18.0"
+	},
+	"type": "module",
+	"description": "Provider-neutral session notes and notes-guided context windows for Pi",
+	"license": "MIT",
+	"pi": {
+		"extensions": [
+			"./changelog.ts",
+			"./src/index.ts"
+		]
+	},
+	"main": "src/index.ts",
+	"scripts": {
+		"check": "bun run lint && bun run typecheck",
+		"lint": "biome check .",
+		"format": "biome check --write .",
+		"typecheck": "tsgo --noEmit"
+	},
+	"dependencies": {
+		"better-sqlite3": "13.0.3"
+	},
+	"devDependencies": {
+		"@types/better-sqlite3": "9.6.0"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": ">=1.1.0",
+		"@earendil-works/pi-agent-core": ">=1.0.4",
+		"@earendil-works/pi-ai": ">=1.0.4",
+		"@earendil-works/pi-tui": ">=1.0.4",
+		"typebox": "*"
+	}
+}