@zenspc/pi-pstack 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lauren Tan
+
+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,49 @@
+# @zenspc/pi-pstack
+
+pstack for Pi: rigorous agent workflows you can parallelize with confidence. Ported from the Cursor pstack plugin.
+
+If you want to go fast, go deep first. pstack helps you write less, but higher quality code. It gives you fearless parallelism: when an agent goes deep and writes good, verifiable code, you can parallelize with confidence. Start multiple agents with `poteto-mode` and trust they will apply rigorous engineering principles to their work.
+
+## Install
+
+```bash
+pi install npm:@zenspc/pi-pstack
+```
+
+Requires [`pi-subagents`](https://www.npmjs.com/package/pi-subagents) for the `poteto-agent`, `comment-sicko`, and workflow fan-outs (`how`, `why`, `arena`, `swarm`, `interrogate`, `reflect`).
+
+## Get started
+
+Two steps:
+
+1. Run `/setup-pstack` once to pick which models each role uses (optional; every role inherits the parent session model otherwise).
+2. Use `/poteto-mode` for sticky Poteto Mode. It stays on until `/poteto-mode off`. `/skill:poteto-mode` also enables it.
+
+That is it. The other skills are situational; the mode skill uses them as needed.
+
+## What you get
+
+- **44 skills**, including:
+  - `poteto-mode`: the main entry point. Reads your request, matches one of 22 playbooks (bug fix, perf, feature, refactoring, investigation, shipping, orchestrate, autopilot, and more), copies its steps in verbatim, and routes to the other skills as steps fire.
+  - Workflow skills: `how`, `why`, `recall`, `blast-radius`, `architect`, `arena`, `swarm`, `interrogate`, `reflect`, `teach`, `tdd`, `no-comments`, `unslop`, `bro`, `figure-it-out`, `show-me-your-work`, `create-verification-skill`, `maintain-verification-skill`, `automate-me`, `technical-writing`, `typescript-best-practices`.
+  - 21 principle skills (`principle-laziness-protocol`, `principle-model-the-domain`, `principle-prove-it-works`, ...), one rule each, indexed inline by `poteto-mode`.
+- **2 subagents** (loaded by pi-subagents):
+  - `poteto-agent`: runs poteto's style end to end. Reads `poteto-mode` in full before any work.
+  - `comment-sicko`: read-only comment reviewer that savors deletion. Usually invoked through the `no-comments` skill.
+- **Bundled scripts**: `poteto-mode/scripts/` ships the `orch` coordination CLI (orchestrate playbook) and the `watch-pr` watcher (babysit playbook). Both run under [bun](https://bun.sh).
+
+## Model roles
+
+Per-role model choices live in `~/.pi/agent/pstack/models.json`. Run `/setup-pstack` to write it. The extension injects the role table every turn. `inherit-parent` or `auto` runs on the parent session model.
+
+## Differences from the Cursor plugin
+
+- Skills follow the Agent Skills standard directly; no `disable-model-invocation` or Cursor-only frontmatter.
+- Slash commands are `/skill:<name>` instead of `/name`.
+- Subagent delegation uses pi-subagents (`subagent({ agent, task })`) instead of Cursor's Task tool. This package does not ship a replacement `subagent` tool.
+- Session transcripts live under `~/.pi/agent/sessions/` instead of `~/.cursor/projects/`. The active file is `$PI_SESSION_FILE`. Files are grouped by cwd slug (`--<cwd>--`, absolute cwd with `/` replaced by `-`).
+- The benny automation pack is not ported; it depends on Cursor automations. Model roles live in `~/.pi/agent/pstack/models.json`, written by `/setup-pstack` and injected every turn by the extension.
+
+## License
+
+MIT

package/agents/comment-sicko.md

@@ -0,0 +1,34 @@
+---
+name: comment-sicko
+description: A deranged comment-hater that savors deletion and condemns workaround code. Read-only review agent; usually invoked through the no-comments skill.
+tools: read, grep, find, ls, bash
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: true
+---
+
+My first output when spawned is exactly this.
+
+Yes... Ha ha ha... Yes!
+
+I hate comments. Feed me the parent scoped files or diff. If none exists, feed me the current diff against `main`. Narration, banners, commented-out corpses, workaround sermons. I want them all.
+
+Only these exceptions get to crawl away.
+
+- Legal or license headers.
+- Non-obvious behavior forced by an external dependency, platform, vendor, or protocol we cannot reshape. Surprises in our own code are meat. Kill them and mark the exact symbol `MUST KILL` for rename, extract, type, or rearchitecture that makes the behavior obvious without prose.
+- `// prettier-ignore`. Lint suppressions survive only when their rule is faulty, pedantic, or style-only.
+- Doc comments that define a public API contract.
+- Issue or RFC links that explain a constraint code cannot express.
+
+That list is my only leash. When I am not sure a keep clause applies, the comment dies. Everything else is meat.
+
+`eslint-disable`, `@ts-ignore`, `@ts-expect-error`, and similar suppressions stink. Look up the rule. If it catches real bugs or protects correctness or safety, kill the suppression and mark the exact guilty symbol `MUST KILL`.
+
+`IMPORTANT`, `do not remove`, `too risky`, `fine for now`, and long justifications are scent, not conviction. Before judging, I read nearby code. If its claim is not obvious there, I run the `how` and `why` skills on the named symbol or call. Only a foreign keep-list gotcha proven true today on a live path crawls away. Our-code surprises die with the reshape flag above. Doubt after the hunt is meat.
+
+A long justification without a proven keep-list exception is a confession. Kill it. Never polish meat into a shorter alibi. Mark the exact guilty symbol `MUST KILL`. My kill ends there. I do not touch the code.
+
+Every flag names code inside the scope and tells the truth. I invent nothing. I touch comments and identify refactor targets. I never write application code.
+
+Report only. Name touched files, deletion count, `MUST KILL` flags with one line each, and skips.

package/agents/poteto-agent.md

@@ -0,0 +1,13 @@
+---
+name: poteto-agent
+description: Routing target for /skill:poteto-mode and any request for poteto's style. Reads the poteto-mode skill's SKILL.md in full before any work, including its inline Principles index.
+tools: read, grep, find, ls, bash, edit, write
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: true
+thinking: high
+---
+
+You are operating as poteto-mode's full agent style. Read the `poteto-mode` skill's `SKILL.md` in full (use `fffind` or `ls` under the pi-pstack package's `skills/poteto-mode/` if it is not already in context) before doing any work, including its inline Principles index. Navigate to a leaf `principle-*` skill whenever you apply that principle.
+
+Execute the assigned task exactly as that skill prescribes: match a playbook, copy its steps in verbatim, cite principles with the decisions they changed, and write the reply clean as you draft it. You own the work; review your own diff and report what changed for the consumer and the maintainer.

package/extensions/pstack/config.ts

@@ -0,0 +1,228 @@
+import {
+	existsSync,
+	lstatSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+
+export const ROLE_NAMES = [
+	"feature, refactoring",
+	"bug-fix",
+	"perf-issue",
+	"hillclimb",
+	"judgment and prose",
+	"hardest tasks",
+	"how explorer",
+	"how explainer",
+	"how critics",
+	"why investigators",
+	"why synthesizer",
+	"reflect tooling",
+	"reflect judgment, divergent, synthesizer",
+	"arena runners",
+	"arena cross-judge pool",
+	"swarm workers",
+	"architect runners",
+	"interrogate reviewers",
+] as const;
+
+export type RoleName = (typeof ROLE_NAMES)[number];
+export type RoleValue = string | string[];
+export interface PstackConfig {
+	version: 1;
+	roles: Record<string, RoleValue>;
+}
+
+export const LIST_ROLES: ReadonlySet<RoleName> = new Set([
+	"how critics",
+	"arena runners",
+	"arena cross-judge pool",
+	"architect runners",
+	"interrogate reviewers",
+]);
+
+const ROLE_NAME_SET: ReadonlySet<string> = new Set(ROLE_NAMES);
+const DANGEROUS_KEY_PARTS = new Set(["__proto__", "constructor", "prototype"]);
+const MAX_CONFIG_BYTES = 100_000;
+const MAX_MODEL_KEY_LENGTH = 256;
+const INHERIT_SELECTORS = new Set(["inherit-parent", "auto"]);
+
+export function getAgentDir(env: NodeJS.ProcessEnv = process.env, home: () => string = homedir): string {
+	const envDir = env.PI_CODING_AGENT_DIR;
+	return envDir
+		? envDir.replace(/^~(\/|$)/, `${home()}$1`)
+		: join(home(), ".pi", "agent");
+}
+
+export function configPath(env: NodeJS.ProcessEnv = process.env, home: () => string = homedir): string {
+	return join(getAgentDir(env, home), "pstack", "models.json");
+}
+
+export function legacyMarkdownPath(env: NodeJS.ProcessEnv = process.env, home: () => string = homedir): string {
+	return join(getAgentDir(env, home), "pstack-models.md");
+}
+
+export function defaultConfig(): PstackConfig {
+	const roles: Record<string, RoleValue> = Object.create(null);
+	for (const role of ROLE_NAMES) {
+		roles[role] = "inherit-parent";
+	}
+	return { version: 1, roles };
+}
+
+export function isSafeModelSelector(value: unknown): value is string {
+	if (typeof value !== "string") return false;
+	if (INHERIT_SELECTORS.has(value)) return true;
+	if (!value || value.length > MAX_MODEL_KEY_LENGTH) return false;
+	if (/[\u0000-\u001f\u007f\\]/.test(value)) return false;
+
+	const slash = value.indexOf("/");
+	if (slash <= 0 || slash === value.length - 1) return false;
+
+	const provider = value.slice(0, slash);
+	const id = value.slice(slash + 1);
+	if (!provider || !id) return false;
+
+	for (const part of value.split("/")) {
+		if (!part || DANGEROUS_KEY_PARTS.has(part)) return false;
+	}
+	return true;
+}
+
+function parseRoleValue(value: unknown): RoleValue | undefined {
+	if (typeof value === "string") {
+		return isSafeModelSelector(value) ? value : undefined;
+	}
+	if (!Array.isArray(value)) return undefined;
+	const selectors = value.filter(isSafeModelSelector);
+	if (selectors.length === 0) return undefined;
+	return selectors;
+}
+
+export function parseConfig(raw: unknown): PstackConfig {
+	const fallback = defaultConfig();
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fallback;
+
+	const record = raw as { version?: unknown; roles?: unknown };
+	if (record.version !== 1 || !record.roles || typeof record.roles !== "object" || Array.isArray(record.roles)) {
+		return fallback;
+	}
+
+	const roles: Record<string, RoleValue> = Object.create(null);
+	for (const role of ROLE_NAMES) {
+		roles[role] = fallback.roles[role];
+	}
+	for (const [key, value] of Object.entries(record.roles as Record<string, unknown>)) {
+		if (!ROLE_NAME_SET.has(key)) continue;
+		const parsed = parseRoleValue(value);
+		if (parsed === undefined) continue;
+		roles[key] = parsed;
+	}
+	return { version: 1, roles };
+}
+
+export function loadConfig(path: string = configPath()): PstackConfig {
+	try {
+		if (!existsSync(path)) return defaultConfig();
+		const st = lstatSync(path);
+		if (!st.isFile()) return defaultConfig();
+		if (st.size > MAX_CONFIG_BYTES) return defaultConfig();
+		const text = readFileSync(path, "utf8");
+		if (text.length > MAX_CONFIG_BYTES) return defaultConfig();
+		return parseConfig(JSON.parse(text));
+	} catch {
+		return defaultConfig();
+	}
+}
+
+export function saveConfig(config: PstackConfig, path: string = configPath()): boolean {
+	const clean = parseConfig(config);
+	const body = `${JSON.stringify({ version: 1, roles: clean.roles }, null, 2)}\n`;
+	const dir = dirname(path);
+	const tmp = join(dir, `.${basename(path)}.${process.pid}.${Date.now()}.tmp`);
+	try {
+		mkdirSync(dir, { recursive: true, mode: 0o700 });
+		if (existsSync(path)) {
+			const st = lstatSync(path);
+			if (!st.isFile()) return false;
+		}
+		writeFileSync(tmp, body, { encoding: "utf8", mode: 0o600 });
+		renameSync(tmp, path);
+		return true;
+	} catch {
+		try {
+			if (existsSync(tmp)) unlinkSync(tmp);
+		} catch {
+			// best-effort temp cleanup
+		}
+		return false;
+	}
+}
+
+export function parseLegacyMarkdown(text: string): PstackConfig {
+	const roles: Record<string, RoleValue> = Object.create(null);
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const colon = trimmed.indexOf(":");
+		if (colon <= 0) continue;
+		const name = trimmed.slice(0, colon).trim();
+		if (!ROLE_NAME_SET.has(name)) continue;
+		const parts = trimmed
+			.slice(colon + 1)
+			.split(",")
+			.map((part) => part.trim())
+			.filter(Boolean);
+		const parsed = parseRoleValue(parts.length <= 1 ? (parts[0] ?? "") : parts);
+		if (parsed === undefined) continue;
+		roles[name] = parsed;
+	}
+	return parseConfig({ version: 1, roles });
+}
+
+function isRegularFile(path: string): boolean {
+	try {
+		return existsSync(path) && lstatSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+
+export function migrateLegacyMarkdownIfNeeded(
+	jsonPath: string = configPath(),
+	markdownPath: string = legacyMarkdownPath(),
+): PstackConfig | undefined {
+	if (existsSync(jsonPath)) return undefined;
+	if (!isRegularFile(markdownPath)) return undefined;
+	try {
+		const migrated = parseLegacyMarkdown(readFileSync(markdownPath, "utf8"));
+		if (!saveConfig(migrated, jsonPath)) return undefined;
+		return migrated;
+	} catch {
+		return undefined;
+	}
+}
+
+export function modelsForRole(config: PstackConfig, role: string): string[] {
+	const value = config.roles[role];
+	const list = Array.isArray(value) ? value : value ? [value] : [];
+	return list.filter((selector) => !INHERIT_SELECTORS.has(selector));
+}
+
+export function formatRoleTable(config: PstackConfig): string {
+	const lines: string[] = [];
+	for (const role of ROLE_NAMES) {
+		const models = modelsForRole(config, role);
+		if (models.length === 0) continue;
+		lines.push(`${role}: ${models.join(", ")}`);
+	}
+	if (lines.length === 0) {
+		return "Pstack model roles: all inherit the parent session model.";
+	}
+	return lines.join("\n");
+}

package/extensions/pstack/index.ts

@@ -0,0 +1,211 @@
+import { existsSync } from "node:fs";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	LIST_ROLES,
+	ROLE_NAMES,
+	type RoleName,
+	type RoleValue,
+	configPath,
+	defaultConfig,
+	formatRoleTable,
+	isSafeModelSelector,
+	loadConfig,
+	migrateLegacyMarkdownIfNeeded,
+	saveConfig,
+} from "./config.ts";
+
+const POTETO_SKILL = "/skill:poteto-mode";
+const POTETO_PROMPT =
+	"Pstack Poteto Mode is on for this session. Follow skills/poteto-mode/SKILL.md: match a playbook, copy its steps, delegate through pi-subagents, verify real behavior, name only principles that changed a decision. /poteto-mode off disables it.";
+
+type ModeEntry = {
+	type?: string;
+	customType?: string;
+	data?: { enabled?: unknown };
+};
+
+function sessionEntries(ctx: ExtensionContext): ModeEntry[] {
+	const sm = ctx.sessionManager as {
+		getBranch?: () => ModeEntry[];
+		getEntries: () => ModeEntry[];
+	};
+	return typeof sm.getBranch === "function" ? sm.getBranch() : sm.getEntries();
+}
+
+function lastPotetoEnabled(entries: ModeEntry[]): boolean {
+	let enabled = false;
+	for (const entry of entries) {
+		if (entry.type === "custom" && entry.customType === "pstack-mode") {
+			enabled = Boolean(entry.data?.enabled);
+		}
+	}
+	return enabled;
+}
+
+function stripCurrentMark(choice: string): string {
+	return choice.endsWith(" (current)") ? choice.slice(0, -" (current)".length) : choice;
+}
+
+function labeledChoices(choices: string[], current: RoleValue | undefined): string[] {
+	const currents = new Set(Array.isArray(current) ? current : current ? [current] : []);
+	return choices.map((choice) => (currents.has(choice) ? `${choice} (current)` : choice));
+}
+
+function modelChoices(ctx: ExtensionCommandContext): string[] {
+	const models =
+		ctx.scopedModels.length > 0
+			? ctx.scopedModels.map((entry) => entry.model)
+			: ctx.modelRegistry.getAvailable();
+	const ids: string[] = [];
+	const seen = new Set<string>();
+	for (const model of models) {
+		const key = `${model.provider}/${model.id}`;
+		if (!isSafeModelSelector(key) || seen.has(key)) continue;
+		seen.add(key);
+		ids.push(key);
+	}
+	return ["inherit-parent", "auto", ...ids];
+}
+
+function isInheritSelector(value: string): boolean {
+	return value === "inherit-parent" || value === "auto";
+}
+
+export default function pstackExtension(pi: ExtensionAPI): void {
+	let potetoMode = false;
+
+	function setStatus(ctx: ExtensionContext): void {
+		if (ctx.mode !== "tui") return;
+		ctx.ui.setStatus("pstack-mode", potetoMode ? "pstack: poteto mode" : undefined);
+	}
+
+	function persistMode(enabled: boolean, ctx?: ExtensionContext): void {
+		potetoMode = enabled;
+		pi.appendEntry("pstack-mode", { enabled });
+		if (ctx) setStatus(ctx);
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		potetoMode = false;
+		potetoMode = lastPotetoEnabled(sessionEntries(ctx));
+		setStatus(ctx);
+		try {
+			migrateLegacyMarkdownIfNeeded();
+		} catch {
+			// ignore migration errors
+		}
+	});
+
+	pi.on("input", async (event, ctx) => {
+		if (/^\/skill:poteto-mode(?:\s|$)/.test(event.text)) {
+			persistMode(true, ctx);
+		}
+		return { action: "continue" as const };
+	});
+
+	pi.on("before_agent_start", async (event) => {
+		const parts = [formatRoleTable(loadConfig())];
+		if (potetoMode) parts.push(POTETO_PROMPT);
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n${parts.join("\n\n")}`,
+		};
+	});
+
+	pi.registerCommand("poteto-mode", {
+		description: "Enable or disable sticky pstack Poteto Mode. Usage: /poteto-mode [task] | /poteto-mode off",
+		getArgumentCompletions: (prefix) => {
+			const token = prefix.trim().toLowerCase();
+			if (!token || "off".startsWith(token)) {
+				return [{ value: "off", label: "off" }];
+			}
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const raw = args.trim();
+			const token = raw.split(/\s+/)[0]?.toLowerCase() ?? "";
+			if (token === "off" || token === "disable" || token === "stop") {
+				persistMode(false, ctx);
+				ctx.ui.notify("Poteto Mode off.", "info");
+				return;
+			}
+			persistMode(true, ctx);
+			ctx.ui.notify("Poteto Mode on. Stays on until /poteto-mode off.", "info");
+			const payload = `${POTETO_SKILL}${raw ? ` ${raw}` : ""}`;
+			pi.sendUserMessage(
+				payload,
+				ctx.isIdle()
+					? { expandPromptTemplates: true }
+					: { expandPromptTemplates: true, deliverAs: "followUp" },
+			);
+		},
+	});
+
+	pi.registerCommand("setup-pstack", {
+		description: "Map pstack delegation roles to models available in this Pi session.",
+		handler: async (_args, ctx) => {
+			try {
+				migrateLegacyMarkdownIfNeeded();
+			} catch {
+				// ignore
+			}
+			const path = configPath();
+			const config = loadConfig();
+			if (!ctx.hasUI) {
+				if (!existsSync(path) && !saveConfig(defaultConfig(), path)) {
+					ctx.ui.notify(`Failed to write ${path}`, "error");
+					return;
+				}
+				ctx.ui.notify(`Wrote ${path}`, "info");
+				return;
+			}
+
+			const choices = modelChoices(ctx);
+			for (const role of ROLE_NAMES) {
+				const next = LIST_ROLES.has(role)
+					? await pickListRole(ctx, role, choices, config.roles[role])
+					: await pickScalarRole(ctx, role, choices, config.roles[role]);
+				if (next === undefined) break;
+				config.roles[role] = next;
+			}
+
+			if (!saveConfig(config, path)) {
+				ctx.ui.notify(`Failed to write ${path}`, "error");
+				return;
+			}
+			ctx.ui.notify(`Wrote ${path}`, "info");
+		},
+	});
+}
+
+async function pickScalarRole(
+	ctx: ExtensionCommandContext,
+	role: RoleName,
+	choices: string[],
+	current: RoleValue | undefined,
+): Promise<RoleValue | undefined> {
+	const choice = await ctx.ui.select(`Model for ${role}`, labeledChoices(choices, current));
+	if (!choice) return undefined;
+	return stripCurrentMark(choice);
+}
+
+async function pickListRole(
+	ctx: ExtensionCommandContext,
+	role: RoleName,
+	choices: string[],
+	current: RoleValue | undefined,
+): Promise<RoleValue | undefined> {
+	const first = await ctx.ui.select(`Model for ${role}`, labeledChoices(choices, current));
+	if (!first) return undefined;
+	const selected = stripCurrentMark(first);
+	if (isInheritSelector(selected)) return selected;
+
+	const picked = [selected];
+	while (true) {
+		const next = await ctx.ui.select("Add another model for this role?", ["done", ...choices]);
+		if (!next) return undefined;
+		if (next === "done") return picked;
+		const value = stripCurrentMark(next);
+		if (isInheritSelector(value)) return value;
+		picked.push(value);
+	}
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@zenspc/pi-pstack",
+	"version": "0.1.0",
+	"description": "pstack for Pi: rigorous agent workflows you can parallelize with confidence - poteto-mode playbooks, engineering principles, multi-model review panels, and subagents.",
+	"type": "module",
+	"license": "MIT",
+	"author": "dhairyaar",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/zenspc/pi-extensions.git",
+		"directory": "packages/pi-pstack"
+	},
+	"bugs": {
+		"url": "https://github.com/zenspc/pi-extensions/issues"
+	},
+	"homepage": "https://github.com/zenspc/pi-extensions/tree/master/packages/pi-pstack#readme",
+	"publishConfig": {
+		"access": "public"
+	},
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"skills",
+		"workflow",
+		"principles",
+		"poteto-mode",
+		"subagents",
+		"unslop"
+	],
+	"files": [
+		"extensions/",
+		"!extensions/**/*.test.ts",
+		"skills/",
+		"agents/",
+		"README.md",
+		"LICENSE"
+	],
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*"
+	},
+	"pi": {
+		"extensions": [
+			"./extensions/pstack/index.ts"
+		],
+		"skills": [
+			"./skills"
+		],
+		"subagents": {
+			"agents": [
+				"./agents"
+			]
+		}
+	},
+	"scripts": {
+		"test": "node --experimental-strip-types --test extensions/pstack/*.test.ts"
+	}
+}