@lastboy/pai 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arik
+
+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,189 @@
+# PAI — Personal AI Supervisor
+
+A local-first tool that observes how you work with AI coding agents (Claude Code
+first) and turns that into knowledge you own.
+
+PAI reads what already exists on your machine — coding-agent session
+transcripts and guidance files — and never sends anything anywhere. It observes
+and informs; it never controls or blocks the coding agent.
+
+See [docs/principles.md](docs/principles.md) for the principles and validation
+layers every feature is built against.
+
+## Install
+
+Requires Node.js 22+ (developed on 24).
+
+```bash
+npm install -g @lastboy/pai
+```
+
+The package is scoped, but the command it installs is `pai`.
+
+### From source
+
+```bash
+npm install
+npm run build
+npm link          # makes `pai` available everywhere
+```
+
+Without `npm link`, run any command through `npm run dev -- <command>`
+(e.g. `npm run dev -- review`).
+
+## Commands
+
+Run `pai --help`, or `pai <command> --help`, for the authoritative list.
+
+### `pai status`
+
+Prints whether PAI is ready and which mode it runs in.
+
+### `pai review`
+
+Reviews a Claude Code session for the **current folder**: title, model, start
+and last-active dates, duration, conversation counts, activity counts, and
+possible corrections with your own words as evidence.
+
+Sessions are discovered automatically from `~/.claude/projects/<encoded-cwd>/`.
+With several sessions for a folder, PAI lists them (short id, started, last
+active, first prompt) and asks which one; pressing Enter picks the most recent.
+Piped/non-interactive input picks the most recent without asking.
+
+```bash
+pai review
+```
+
+### `pai rules`
+
+Shows your guidelines from the CLAUDE.md files that apply to the current
+folder — global (`~/.claude/CLAUDE.md`) and project (`CLAUDE.md`,
+`CLAUDE.local.md`) — grouped by their markdown headings.
+
+| Option | Effect |
+|---|---|
+| `--global` | only global rules |
+| `--project` | only project rules |
+| `--search <text>` | only rules whose text or category starts a word with `<text>` |
+
+```bash
+pai rules
+pai rules --project
+pai rules --global --search decision
+```
+
+Search matches word starts, so `--search ask` finds "Ask me before…" but not
+"Small tasks".
+
+### `pai export`
+
+Exports PAI's own rule store as portable, versioned JSON.
+
+| Option | Effect |
+|---|---|
+| `--out <file>` | write to a file instead of stdout |
+| `--scope global\|project` | export only that scope |
+
+```bash
+pai export                                  # everything, to stdout
+pai export --scope global --out mine.json   # only user-level rules
+```
+
+### `pai import <file>`
+
+Merges a previously exported file into this machine. Rules carry their own
+scope, so global rules land in the global store and project rules in the
+current project's store — no flag needed.
+
+The merge is **non-destructive**: new rules are added, rules you already have
+gain any new evidence, and nothing is overwritten or removed. Re-importing the
+same file changes nothing.
+
+| Option | Effect |
+|---|---|
+| `--dry-run` | report what would change without writing |
+
+```bash
+pai import mine.json --dry-run
+pai import mine.json
+```
+
+Invalid or unsupported files fail with a clear message and a non-zero exit code.
+
+### `pai experiment …`
+
+Experimental commands. They may change or disappear, and they are the only
+place PAI uses an LLM. They require [Ollama](https://ollama.com) running
+locally; nothing else in PAI depends on it.
+
+- `pai experiment correction [--model <name>] [--correction <n>]` — analyzes one
+  correction candidate from a real session: shows the deterministic detector
+  result, the exact context sent to the model, the structured result, and latency.
+- `pai experiment distill [--model <name>] [--limit <n>]` — distills candidate
+  personal-guidance rules from recent user messages, so distillation quality can
+  be judged before rules are stored.
+
+Default model: `qwen2.5:14b`.
+
+## Where PAI stores things
+
+| Path | Contents |
+|---|---|
+| `~/.pai/rules.json` | your user-level rules |
+| `<project>/.pai/rules.json` | rules scoped to that project |
+
+The store is agent-neutral, versioned (`version: 1`), and portable: rule
+identity comes from the rule text, so the same rule learned on two machines
+merges cleanly instead of duplicating. Each rule keeps its category, scope,
+source (`learned` or `manual`) and evidence — your actual words, with session id
+and timestamp.
+
+PAI **never writes** to `~/.claude/` or to any CLAUDE.md file.
+
+## What PAI reads
+
+| Path | Used for |
+|---|---|
+| `~/.claude/projects/<encoded-cwd>/*.jsonl` | session transcripts (read-only) |
+| `~/.claude/CLAUDE.md` | global guidelines |
+| `<project>/CLAUDE.md`, `CLAUDE.local.md` | project guidelines |
+
+The encoded folder name is the project path with every non-alphanumeric
+character replaced by `-`.
+
+## Project layout
+
+```
+src/core/          agent-independent logic (sessions, corrections, rules, review)
+src/adapters/      per-agent integration — currently only claude/
+src/persistence/   PAI's own store on disk
+src/experiments/   local-LLM experiments (Ollama, optional)
+src/cli/           command wiring and rendering
+tests/             vitest suites and sanitized fixtures
+docs/              principles and validation layers
+```
+
+Supporting another agent (e.g. Codex CLI) means adding one adapter that answers
+three questions: where its session logs live, how to parse them into PAI's
+normalized events, and where its guidance file is. Nothing in `core/` changes.
+
+## Development
+
+```bash
+npm run dev -- <command>   # run from source via tsx
+npm test                   # vitest
+npm run typecheck          # tsc, strict
+npm run build              # compile to dist/
+```
+
+Tests use small sanitized fixtures. Real transcripts are never copied into the
+repository.
+
+## Status
+
+Working today: `status`, `review`, `rules`, `export`, `import`, and the two
+experiments.
+
+Next: `pai learn` — scan sessions, distill candidate rules, approve or reject
+them interactively, and store the approved ones. Then auditing sessions against
+stored rules (which rules the agent actually violated, with evidence).

package/dist/adapters/claude/discovery.js

@@ -0,0 +1,99 @@
+import { closeSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { isRealUserPrompt } from './parser.js';
+// Claude Code stores sessions in ~/.claude/projects/<encoded-cwd>/<uuid>.jsonl
+// where the encoded name is the project cwd with every non-alphanumeric
+// character replaced by '-'.
+export function encodeProjectDir(cwd) {
+    return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+function listSessionFiles(cwd, claudeDir) {
+    const projectDir = join(claudeDir, 'projects', encodeProjectDir(cwd));
+    let names;
+    try {
+        names = readdirSync(projectDir);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const name of names) {
+        if (!name.endsWith('.jsonl'))
+            continue;
+        const path = join(projectDir, name);
+        try {
+            files.push({ path, mtime: statSync(path).mtime });
+        }
+        catch {
+            // File disappeared between readdir and stat — skip it.
+        }
+    }
+    return files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+}
+// Reads only the head of the transcript — files can be many MB and the
+// first prompt/timestamp appear early.
+function readSessionPreview(path, maxBytes = 256 * 1024) {
+    let head;
+    try {
+        const fd = openSync(path, 'r');
+        try {
+            const buffer = Buffer.alloc(maxBytes);
+            const bytesRead = readSync(fd, buffer, 0, maxBytes, 0);
+            head = buffer.toString('utf8', 0, bytesRead);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return {};
+    }
+    let startedAt;
+    let firstPrompt;
+    const lines = head.split('\n');
+    // Drop the last line — it may be cut mid-JSON by the byte limit.
+    for (const line of lines.slice(0, -1)) {
+        if (startedAt && firstPrompt)
+            break;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        if (entry['type'] !== 'user' && entry['type'] !== 'assistant')
+            continue;
+        if (entry['isSidechain'] === true || entry['isMeta'] === true)
+            continue;
+        if (!startedAt && typeof entry['timestamp'] === 'string') {
+            const ts = new Date(entry['timestamp']);
+            if (!Number.isNaN(ts.getTime()))
+                startedAt = ts;
+        }
+        if (!firstPrompt && entry['type'] === 'user') {
+            const message = entry['message'];
+            const content = message?.['content'];
+            if (typeof content === 'string') {
+                const text = content.trim();
+                if (isRealUserPrompt(text))
+                    firstPrompt = text;
+            }
+        }
+    }
+    return { startedAt, firstPrompt };
+}
+export function listSessions(cwd, claudeDir = join(homedir(), '.claude')) {
+    return listSessionFiles(cwd, claudeDir).map(({ path, mtime }) => ({
+        path,
+        id: basename(path, '.jsonl'),
+        lastActiveAt: mtime,
+        ...readSessionPreview(path),
+    }));
+}
+export function findLatestSessionFile(cwd, claudeDir = join(homedir(), '.claude')) {
+    return listSessionFiles(cwd, claudeDir)[0]?.path;
+}

package/dist/adapters/claude/events.js

@@ -0,0 +1,71 @@
+import { isRealUserPrompt } from './parser.js';
+function toolTarget(name, input) {
+    const key = name === 'Bash' ? 'command' : name === 'NotebookEdit' ? 'notebook_path' : 'file_path';
+    return typeof input[key] === 'string' ? input[key] : undefined;
+}
+export function parseEvents(jsonl) {
+    const events = [];
+    const toolEventsByUseId = new Map();
+    for (const line of jsonl.split('\n')) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        if (entry['type'] !== 'user' && entry['type'] !== 'assistant')
+            continue;
+        if (entry['isSidechain'] === true || entry['isMeta'] === true)
+            continue;
+        const message = entry['message'];
+        if (!message || typeof message !== 'object')
+            continue;
+        const timestamp = typeof entry['timestamp'] === 'string' ? entry['timestamp'] : undefined;
+        const content = message['content'];
+        if (entry['type'] === 'user') {
+            if (typeof content === 'string') {
+                const text = content.trim();
+                if (isRealUserPrompt(text))
+                    events.push({ kind: 'user', timestamp, text });
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block?.['type'] === 'tool_result' &&
+                        block['is_error'] === true &&
+                        typeof block['tool_use_id'] === 'string') {
+                        const call = toolEventsByUseId.get(block['tool_use_id']);
+                        if (call)
+                            call.failed = true;
+                    }
+                }
+            }
+        }
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block?.['type'] === 'text' && typeof block['text'] === 'string') {
+                    const text = block['text'].trim();
+                    if (text)
+                        events.push({ kind: 'assistant', timestamp, text });
+                }
+                else if (block?.['type'] === 'tool_use' && typeof block['name'] === 'string') {
+                    const event = {
+                        kind: 'tool',
+                        timestamp,
+                        name: block['name'],
+                        target: toolTarget(block['name'], (block['input'] ?? {})),
+                        failed: false,
+                    };
+                    events.push(event);
+                    if (typeof block['id'] === 'string')
+                        toolEventsByUseId.set(block['id'], event);
+                }
+            }
+        }
+    }
+    return events;
+}

package/dist/adapters/claude/guidelines.js

@@ -0,0 +1,32 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// Claude Code guidance locations: ~/.claude/CLAUDE.md (global) and
+// CLAUDE.md / CLAUDE.local.md at the project root. Parent-directory
+// traversal is not implemented yet.
+export function findGuidelineFiles(cwd, home = homedir()) {
+    const candidates = [
+        { path: join(home, '.claude', 'CLAUDE.md'), scope: 'global' },
+        { path: join(cwd, 'CLAUDE.md'), scope: 'project' },
+        { path: join(cwd, 'CLAUDE.local.md'), scope: 'project' },
+    ];
+    return candidates.filter((candidate) => existsSync(candidate.path));
+}
+const HEADING = /^#{1,6}\s+(.+?)\s*$/;
+const BULLET = /^\s*[-*]\s+(.+?)\s*$/;
+export function parseGuidelines(markdown) {
+    const guidelines = [];
+    let category = 'General';
+    for (const line of markdown.split('\n')) {
+        const heading = HEADING.exec(line);
+        if (heading?.[1]) {
+            category = heading[1];
+            continue;
+        }
+        const bullet = BULLET.exec(line);
+        if (bullet?.[1]) {
+            guidelines.push({ category, text: bullet[1] });
+        }
+    }
+    return guidelines;
+}

package/dist/adapters/claude/parser.js

@@ -0,0 +1,117 @@
+// Maps Claude Code tool names to normalized kinds. Anything unknown is 'other'.
+function normalizeToolCall(name, input) {
+    const inputObj = (input ?? {});
+    const str = (key) => typeof inputObj[key] === 'string' ? inputObj[key] : undefined;
+    switch (name) {
+        case 'Read':
+            return { name, kind: 'file-read', target: str('file_path'), failed: false };
+        case 'Edit':
+        case 'Write':
+            return { name, kind: 'file-write', target: str('file_path'), failed: false };
+        case 'NotebookEdit':
+            return { name, kind: 'file-write', target: str('notebook_path'), failed: false };
+        case 'Bash':
+            return { name, kind: 'command', target: str('command'), failed: false };
+        default:
+            return { name, kind: 'other', failed: false };
+    }
+}
+// Real user prompts are string content; strings starting with '<' or '['
+// are UI artifacts (slash-command XML, "[Request interrupted...]").
+export function isRealUserPrompt(text) {
+    return text.length > 0 && !text.startsWith('<') && !text.startsWith('[');
+}
+export function parseTranscript(jsonl, sessionId) {
+    const userMessages = [];
+    const toolCalls = [];
+    const callsByToolUseId = new Map();
+    const assistantMessageIds = new Set();
+    let title;
+    let model;
+    let startedAt;
+    let endedAt;
+    for (const line of jsonl.split('\n')) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        if (entry['type'] === 'ai-title') {
+            // Title lines repeat as the session evolves — the last one wins.
+            if (typeof entry['aiTitle'] === 'string')
+                title = entry['aiTitle'];
+            continue;
+        }
+        if (entry['type'] !== 'user' && entry['type'] !== 'assistant')
+            continue;
+        if (entry['isSidechain'] === true || entry['isMeta'] === true)
+            continue;
+        const message = entry['message'];
+        if (!message || typeof message !== 'object')
+            continue;
+        if (typeof entry['timestamp'] === 'string') {
+            const ts = new Date(entry['timestamp']);
+            if (!Number.isNaN(ts.getTime())) {
+                if (!startedAt || ts < startedAt)
+                    startedAt = ts;
+                if (!endedAt || ts > endedAt)
+                    endedAt = ts;
+            }
+        }
+        const content = message['content'];
+        if (entry['type'] === 'user') {
+            if (typeof content === 'string') {
+                const text = content.trim();
+                if (isRealUserPrompt(text)) {
+                    userMessages.push({
+                        timestamp: typeof entry['timestamp'] === 'string' ? entry['timestamp'] : undefined,
+                        text,
+                    });
+                }
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block?.['type'] === 'tool_result' &&
+                        block['is_error'] === true &&
+                        typeof block['tool_use_id'] === 'string') {
+                        const call = callsByToolUseId.get(block['tool_use_id']);
+                        if (call)
+                            call.failed = true;
+                    }
+                }
+            }
+        }
+        else {
+            if (typeof message['model'] === 'string')
+                model = message['model'];
+            if (typeof message['id'] === 'string')
+                assistantMessageIds.add(message['id']);
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block?.['type'] === 'tool_use' && typeof block['name'] === 'string') {
+                        const call = normalizeToolCall(block['name'], block['input']);
+                        toolCalls.push(call);
+                        if (typeof block['id'] === 'string')
+                            callsByToolUseId.set(block['id'], call);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        id: sessionId,
+        title,
+        model,
+        startedAt,
+        endedAt,
+        userMessages,
+        assistantMessageCount: assistantMessageIds.size,
+        toolCalls,
+    };
+}

package/dist/cli/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { createProgram } from './program.js';
+await createProgram((line) => console.log(line)).parseAsync(process.argv);

package/dist/cli/program.js

@@ -0,0 +1,303 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { Command } from 'commander';
+import { listSessions } from '../adapters/claude/discovery.js';
+import { parseTranscript } from '../adapters/claude/parser.js';
+import { buildReview } from '../core/review.js';
+import { getStatus, renderStatus } from '../core/status.js';
+import { parseEvents } from '../adapters/claude/events.js';
+import { detectPossibleCorrections } from '../core/corrections.js';
+import { analyzeWithOllama, buildCorrectionContext, buildPrompt, } from '../experiments/correction-analysis.js';
+import { ollamaGenerate } from '../experiments/ollama.js';
+import { buildDistillPrompt, parseDistillResponse } from '../experiments/rule-distillation.js';
+import { findGuidelineFiles, parseGuidelines } from '../adapters/claude/guidelines.js';
+import { filterGuidelineGroups } from '../core/guidelines.js';
+import { emptyStore, mergeStores, parseRuleStore, serializeRuleStore, } from '../core/rule-store.js';
+import { globalStorePath, projectStorePath, readStore, writeStore, } from '../persistence/rule-store-files.js';
+import { parseSelection, renderGuidelines, renderReview, renderSessionList } from './render.js';
+async function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(question);
+    rl.close();
+    return answer;
+}
+async function chooseSession(out) {
+    const sessions = listSessions(process.cwd());
+    if (sessions.length === 0) {
+        out('No Claude Code sessions found for this project.');
+        return undefined;
+    }
+    if (sessions.length === 1)
+        return sessions[0];
+    for (const line of renderSessionList(sessions))
+        out(line);
+    out('');
+    if (!process.stdin.isTTY) {
+        out('(non-interactive input: using the most recent session)');
+        out('');
+        return sessions[0];
+    }
+    const answer = await ask(`Select session [1-${sessions.length}, Enter = 1]: `);
+    const index = parseSelection(answer, sessions.length);
+    if (index === undefined) {
+        out('Invalid selection.');
+        return undefined;
+    }
+    out('');
+    return sessions[index];
+}
+// Same relative depth from src/cli and dist/cli.
+function packageVersion() {
+    const pkg = JSON.parse(readFileSync(join(import.meta.dirname, '..', '..', 'package.json'), 'utf8'));
+    return pkg.version ?? '0.0.0';
+}
+export function createProgram(out) {
+    const program = new Command('pai');
+    program.description('PAI — Personal AI Supervisor');
+    program.version(packageVersion(), '-v, --version', 'show the PAI version');
+    program
+        .command('status')
+        .description('Show PAI status')
+        .action(() => {
+        for (const line of renderStatus(getStatus())) {
+            out(line);
+        }
+    });
+    program
+        .command('review')
+        .description('Review the latest Claude Code session for this project')
+        .action(async () => {
+        const chosen = await chooseSession(out);
+        if (!chosen) {
+            process.exitCode = 1;
+            return;
+        }
+        const transcript = await readFile(chosen.path, 'utf8');
+        const session = parseTranscript(transcript, chosen.id);
+        for (const line of renderReview(buildReview(session))) {
+            out(line);
+        }
+    });
+    program
+        .command('rules')
+        .description('Show your guidelines from CLAUDE.md files, categorized')
+        .option('--global', 'only global rules (~/.claude/CLAUDE.md)')
+        .option('--project', 'only project rules (CLAUDE.md, CLAUDE.local.md)')
+        .option('--search <text>', 'only rules whose text or category starts a word with <text>')
+        .action(async (options) => {
+        const files = findGuidelineFiles(process.cwd());
+        const groups = await Promise.all(files.map(async (file) => ({
+            scope: file.scope,
+            path: file.path,
+            guidelines: parseGuidelines(await readFile(file.path, 'utf8')),
+        })));
+        // --global and --project together = no scope filter (same as neither).
+        const scope = options.global && !options.project
+            ? 'global'
+            : options.project && !options.global
+                ? 'project'
+                : undefined;
+        const filtered = filterGuidelineGroups(groups, { scope, search: options.search });
+        if (filtered.length === 0 && groups.length > 0) {
+            out(`No rules matching the given filters.`);
+            return;
+        }
+        for (const line of renderGuidelines(filtered))
+            out(line);
+    });
+    program
+        .command('export')
+        .description('Export PAI rules to a portable JSON file (or stdout)')
+        .option('--out <file>', 'write to this file instead of stdout')
+        .option('--scope <scope>', 'export only "global" or "project" rules')
+        .action((options) => {
+        if (options.scope && options.scope !== 'global' && options.scope !== 'project') {
+            out('--scope must be "global" or "project".');
+            process.exitCode = 1;
+            return;
+        }
+        const global = readStore(globalStorePath());
+        const project = readStore(projectStorePath(process.cwd()));
+        const combined = {
+            ...emptyStore(),
+            rules: [...global.rules, ...project.rules].filter((rule) => options.scope === undefined || rule.scope === options.scope),
+        };
+        const json = serializeRuleStore(combined);
+        if (options.out === undefined) {
+            out(json.trimEnd());
+            return;
+        }
+        writeFileSync(options.out, json, 'utf8');
+        out(`Exported ${combined.rules.length} rule(s) to ${options.out}`);
+    });
+    program
+        .command('import')
+        .argument('<file>', 'JSON file previously produced by "pai export"')
+        .description('Merge rules from a file into this machine (never overwrites)')
+        .option('--dry-run', 'show what would change without writing')
+        .action(async (file, options) => {
+        let incoming;
+        try {
+            incoming = parseRuleStore(await readFile(file, 'utf8'));
+        }
+        catch (error) {
+            out(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+            return;
+        }
+        const targets = [
+            { scope: 'global', path: globalStorePath() },
+            { scope: 'project', path: projectStorePath(process.cwd()) },
+        ];
+        for (const target of targets) {
+            const rules = incoming.rules.filter((rule) => rule.scope === target.scope);
+            if (rules.length === 0)
+                continue;
+            const result = mergeStores(readStore(target.path), { ...emptyStore(), rules });
+            if (!options.dryRun)
+                writeStore(target.path, result.store);
+            out(`${target.scope}: ${result.added} added, ${result.merged} updated with new evidence, ${result.store.rules.length} total → ${target.path}`);
+        }
+        if (incoming.rules.length === 0)
+            out('Nothing to import — the file contains no rules.');
+        if (options.dryRun)
+            out('(dry run — nothing was written)');
+    });
+    const experiment = program
+        .command('experiment')
+        .description('Experimental features — may change or disappear');
+    experiment
+        .command('correction')
+        .description('EXPERIMENT: analyze one correction candidate with a local Ollama model')
+        .option('--model <name>', 'Ollama model to use', 'qwen2.5:14b')
+        .option('--correction <n>', 'correction candidate number (1-based, default: last)')
+        .action(async (options) => {
+        const chosen = await chooseSession(out);
+        if (!chosen) {
+            process.exitCode = 1;
+            return;
+        }
+        const transcript = await readFile(chosen.path, 'utf8');
+        const events = parseEvents(transcript);
+        const candidates = events
+            .map((event, index) => ({ event, index }))
+            .filter(({ event }) => event.kind === 'user' &&
+            detectPossibleCorrections([{ text: event.text }]).length > 0);
+        if (candidates.length === 0) {
+            out('No correction candidates found in this session.');
+            process.exitCode = 1;
+            return;
+        }
+        out(`Correction candidates in session ${chosen.id.slice(0, 8)}:`);
+        candidates.forEach(({ event }, i) => {
+            const text = event.kind === 'user' ? event.text : '';
+            out(`  ${i + 1}. "${text.replace(/\s+/g, ' ').slice(0, 70)}"`);
+        });
+        out('');
+        let pick = candidates.length - 1;
+        if (options.correction !== undefined) {
+            const index = parseSelection(options.correction, candidates.length);
+            if (index === undefined) {
+                out('Invalid --correction number.');
+                process.exitCode = 1;
+                return;
+            }
+            pick = index;
+        }
+        else if (process.stdin.isTTY) {
+            const answer = await ask(`Select candidate [1-${candidates.length}, Enter = ${candidates.length}]: `);
+            const index = answer.trim() === '' ? candidates.length - 1 : parseSelection(answer, candidates.length);
+            if (index === undefined) {
+                out('Invalid selection.');
+                process.exitCode = 1;
+                return;
+            }
+            pick = index;
+        }
+        const candidate = candidates[pick];
+        if (!candidate)
+            return;
+        const context = buildCorrectionContext(events, candidate.index);
+        const prompt = buildPrompt(context);
+        out('=== 1. Deterministic detector ===');
+        out(`Flagged as possible correction (keyword match).`);
+        out('');
+        out('=== 2. Context sent to Ollama ===');
+        out(prompt);
+        out('');
+        out(`Context size: ${prompt.length} chars (~${Math.round(prompt.length / 4)} tokens)`);
+        out('');
+        out(`=== 3. Ollama result (${options.model}) ===`);
+        try {
+            const result = await analyzeWithOllama(prompt, options.model);
+            out(`Raw response: ${result.raw.trim()}`);
+            out('');
+            if (result.parsed) {
+                out(`Parsed: isCorrection=${result.parsed.isCorrection}  category=${result.parsed.category}  confidence=${result.parsed.confidence}`);
+                out(`Reason: ${result.parsed.reason}`);
+            }
+            else {
+                out('Could not parse a structured result from the response.');
+            }
+            out('');
+            out('=== 4. Latency ===');
+            out(`Wall clock: ${(result.latencyMs / 1000).toFixed(1)}s`);
+            if (result.modelDurationMs !== undefined) {
+                out(`Ollama total_duration: ${(result.modelDurationMs / 1000).toFixed(1)}s`);
+            }
+        }
+        catch (error) {
+            out(`Ollama call failed: ${error instanceof Error ? error.message : String(error)}`);
+            out('Is Ollama running? (ollama serve, then ollama pull <model>)');
+            process.exitCode = 1;
+        }
+    });
+    experiment
+        .command('distill')
+        .description('EXPERIMENT: distill candidate rules from recent user messages via Ollama')
+        .option('--model <name>', 'Ollama model to use', 'qwen2.5:14b')
+        .option('--limit <n>', 'how many recent user messages to analyze', '10')
+        .action(async (options) => {
+        const chosen = await chooseSession(out);
+        if (!chosen) {
+            process.exitCode = 1;
+            return;
+        }
+        const transcript = await readFile(chosen.path, 'utf8');
+        const messages = parseEvents(transcript).filter((e) => e.kind === 'user');
+        const limit = Math.max(1, Number(options.limit) || 10);
+        const sample = messages.slice(-limit);
+        out(`Distilling from the last ${sample.length} user messages (session ${chosen.id.slice(0, 8)}, model ${options.model})`);
+        out('');
+        let totalMs = 0;
+        let ruleCount = 0;
+        for (const [i, message] of sample.entries()) {
+            const text = message.kind === 'user' ? message.text : '';
+            out(`--- Message ${i + 1}/${sample.length} ---`);
+            out(`  "${text.replace(/\s+/g, ' ').slice(0, 120)}${text.length > 120 ? '...' : ''}"`);
+            try {
+                const generation = await ollamaGenerate(buildDistillPrompt(text), options.model);
+                totalMs += generation.latencyMs;
+                const rules = parseDistillResponse(generation.raw);
+                if (rules.length === 0) {
+                    out('  → no lasting guidance found');
+                }
+                for (const rule of rules) {
+                    ruleCount += 1;
+                    out(`  → [${rule.category}] ${rule.rule}  (confidence ${rule.confidence})`);
+                }
+            }
+            catch (error) {
+                out(`  Ollama call failed: ${error instanceof Error ? error.message : String(error)}`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        out('');
+        out(`Layers: L0 ✓ 1 session · L1 ✓ ${sample.length} messages · L2 ✓ ${options.model}`);
+        out(`Candidates: ${ruleCount} rules · total LLM time ${(totalMs / 1000).toFixed(1)}s`);
+    });
+    return program;
+}

package/dist/cli/render.js

@@ -0,0 +1,113 @@
+export function renderGuidelines(groups) {
+    const lines = ['PAI — Guidelines'];
+    for (const group of groups) {
+        lines.push('');
+        lines.push(`${group.scope === 'global' ? 'Global' : 'Project'} (${group.path})`);
+        if (group.guidelines.length === 0) {
+            lines.push('  (no guidelines found)');
+            continue;
+        }
+        let category;
+        for (const guideline of group.guidelines) {
+            if (guideline.category !== category) {
+                category = guideline.category;
+                lines.push('');
+                lines.push(`  ${category}`);
+            }
+            lines.push(`    • ${guideline.text}`);
+        }
+    }
+    if (groups.length === 0) {
+        lines.push('');
+        lines.push('No CLAUDE.md files found (global or project).');
+    }
+    return lines;
+}
+function formatDuration(ms) {
+    const totalMinutes = Math.floor(ms / 60_000);
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    if (totalMinutes > 0)
+        return `${minutes}m`;
+    return `${Math.floor(ms / 1000)}s`;
+}
+function formatClock(date) {
+    return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+}
+function stat(label, value) {
+    return `  ${label.padEnd(16)}${String(value).padStart(5)}`;
+}
+function quote(text) {
+    const singleLine = text.replace(/\s+/g, ' ').trim();
+    return singleLine.length > 60 ? `"${singleLine.slice(0, 57)}..."` : `"${singleLine}"`;
+}
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+function formatDay(date) {
+    return `${date.getDate()} ${MONTHS[date.getMonth()]} ${formatClock(date)}`;
+}
+function formatFullDate(date) {
+    return `${date.getDate()} ${MONTHS[date.getMonth()]} ${date.getFullYear()}, ${formatClock(date)}`;
+}
+function snippet(text, max = 40) {
+    const singleLine = text.replace(/\s+/g, ' ').trim();
+    return singleLine.length > max ? `${singleLine.slice(0, max - 3)}...` : singleLine;
+}
+export function renderSessionList(sessions) {
+    const lines = ['Sessions for this project:'];
+    sessions.forEach((session, index) => {
+        const started = session.startedAt ? `started ${formatDay(session.startedAt)}` : 'started ?';
+        const lastActive = `last active ${formatDay(session.lastActiveAt)}`;
+        const prompt = session.firstPrompt ? `  "${snippet(session.firstPrompt)}"` : '';
+        lines.push(`  ${String(index + 1).padStart(2)}. ${session.id.slice(0, 8)}  ${started}  ${lastActive}${prompt}`);
+    });
+    return lines;
+}
+// Empty input selects the first (most recent) session; otherwise a 1-based index.
+export function parseSelection(input, count) {
+    const trimmed = input.trim();
+    if (trimmed === '')
+        return 0;
+    if (!/^\d+$/.test(trimmed))
+        return undefined;
+    const n = Number(trimmed);
+    return n >= 1 && n <= count ? n - 1 : undefined;
+}
+export function renderReview(review) {
+    const lines = [];
+    lines.push('PAI — Session Review');
+    lines.push(`Session: ${review.sessionId}`);
+    if (review.title)
+        lines.push(`Title: ${review.title}`);
+    lines.push(`Model: ${review.model ?? 'unknown'}`);
+    if (review.startedAt)
+        lines.push(`Started: ${formatFullDate(review.startedAt)}`);
+    if (review.endedAt)
+        lines.push(`Last active: ${formatFullDate(review.endedAt)}`);
+    if (review.durationMs !== undefined)
+        lines.push(`Duration: ${formatDuration(review.durationMs)}`);
+    lines.push('');
+    lines.push('Conversation');
+    lines.push(stat('User messages', review.userMessageCount));
+    lines.push(stat('Claude messages', review.assistantMessageCount));
+    lines.push(stat('Tool calls', review.toolCallCount));
+    lines.push(stat('Tool failures', review.toolFailureCount));
+    lines.push('');
+    lines.push('Activity');
+    lines.push(stat('Files read', review.filesRead));
+    lines.push(stat('Files modified', review.filesModified));
+    lines.push(stat('Commands', review.commandCount));
+    lines.push('');
+    lines.push(`Possible corrections  ${review.possibleCorrections.length}`);
+    const recent = review.possibleCorrections.slice(-5);
+    if (recent.length > 0) {
+        lines.push('');
+        lines.push('Recent user corrections:');
+        for (const correction of recent) {
+            const time = correction.timestamp ? `${formatClock(new Date(correction.timestamp))}  ` : '';
+            lines.push(`  ${time}${quote(correction.text)}`);
+        }
+    }
+    return lines;
+}

package/dist/core/corrections.js

@@ -0,0 +1,20 @@
+// Deliberately simple first pass. These phrases MAY indicate the user is
+// correcting or redirecting the agent — they are not classified as mistakes.
+// "no" and "stop" are anchored to the message start to reduce noise.
+const CORRECTION_PATTERNS = [
+    /^no\b/i,
+    /^stop\b/i,
+    /\bdon'?t\b/i,
+    /\bthat'?s not what i asked\b/i,
+    /\bwe already\b/i,
+    /\bwe agreed\b/i,
+    /\bwhy did you\b/i,
+    /\byou forgot\b/i,
+    /\bread\b.{0,60}\bfirst\b/i,
+    /\bthat'?s wrong\b/i,
+];
+export function detectPossibleCorrections(messages) {
+    return messages
+        .filter((m) => CORRECTION_PATTERNS.some((p) => p.test(m.text)))
+        .map((m) => ({ timestamp: m.timestamp, text: m.text }));
+}

package/dist/core/guidelines.js

@@ -0,0 +1,16 @@
+export function filterGuidelineGroups(groups, filters) {
+    const query = filters.search?.trim();
+    // Word-start match: "ask" hits "Ask"/"asking" but not "tasks".
+    const matcher = query === undefined || query === ''
+        ? undefined
+        : new RegExp(`\\b${query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'i');
+    return groups
+        .filter((group) => filters.scope === undefined || group.scope === filters.scope)
+        .map((group) => matcher === undefined
+        ? group
+        : {
+            ...group,
+            guidelines: group.guidelines.filter((g) => matcher.test(g.text) || matcher.test(g.category)),
+        })
+        .filter((group) => group.guidelines.length > 0 || matcher === undefined);
+}

package/dist/core/review.js

@@ -0,0 +1,27 @@
+import { detectPossibleCorrections } from './corrections.js';
+function distinctTargets(session, kind) {
+    const targets = session.toolCalls
+        .filter((c) => c.kind === kind && c.target !== undefined)
+        .map((c) => c.target);
+    return new Set(targets).size;
+}
+export function buildReview(session) {
+    return {
+        sessionId: session.id,
+        title: session.title,
+        model: session.model,
+        startedAt: session.startedAt,
+        endedAt: session.endedAt,
+        durationMs: session.startedAt && session.endedAt
+            ? session.endedAt.getTime() - session.startedAt.getTime()
+            : undefined,
+        userMessageCount: session.userMessages.length,
+        assistantMessageCount: session.assistantMessageCount,
+        toolCallCount: session.toolCalls.length,
+        toolFailureCount: session.toolCalls.filter((c) => c.failed).length,
+        filesRead: distinctTargets(session, 'file-read'),
+        filesModified: distinctTargets(session, 'file-write'),
+        commandCount: session.toolCalls.filter((c) => c.kind === 'command').length,
+        possibleCorrections: detectPossibleCorrections(session.userMessages),
+    };
+}

package/dist/core/session.js

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

package/dist/core/status.js

@@ -0,0 +1,6 @@
+export function getStatus() {
+    return { status: 'ready', mode: 'local' };
+}
+export function renderStatus(status) {
+    return ['PAI', `Status: ${status.status}`, `Mode: ${status.mode}`];
+}

package/dist/experiments/correction-analysis.js

@@ -0,0 +1,84 @@
+import { ollamaGenerate } from './ollama.js';
+const CATEGORIES = [
+    'scope_drift',
+    'repeated_failure',
+    'ignored_guidance',
+    'misunderstanding',
+    'regression',
+    'other',
+    'not_correction',
+];
+const MAX_PRECEDING_EVENTS = 5;
+const MAX_EVENT_CHARS = 300;
+const MAX_GOAL_CHARS = 500;
+function clip(text, max) {
+    const singleLine = text.replace(/\s+/g, ' ').trim();
+    return singleLine.length > max ? `${singleLine.slice(0, max - 3)}...` : singleLine;
+}
+export function buildCorrectionContext(events, correctionIndex) {
+    const correction = events[correctionIndex];
+    if (!correction || correction.kind !== 'user') {
+        throw new Error('correctionIndex must point at a user event');
+    }
+    const firstUser = events.find((e, i) => e.kind === 'user' && i < correctionIndex);
+    return {
+        goal: firstUser?.kind === 'user' ? firstUser.text : undefined,
+        // The goal message is sent separately — don't duplicate it in the window.
+        events: events
+            .slice(Math.max(0, correctionIndex - MAX_PRECEDING_EVENTS), correctionIndex)
+            .filter((e) => e !== firstUser),
+        correction: correction.text,
+    };
+}
+function describeEvent(event) {
+    switch (event.kind) {
+        case 'user':
+            return `[user] ${clip(event.text, MAX_EVENT_CHARS)}`;
+        case 'assistant':
+            return `[assistant] ${clip(event.text, MAX_EVENT_CHARS)}`;
+        case 'tool':
+            return `[tool] ${event.name}${event.target ? ` ${clip(event.target, 120)}` : ''}${event.failed ? ' (FAILED)' : ''}`;
+    }
+}
+export function buildPrompt(context) {
+    const parts = [
+        'You are analyzing one moment in a coding-agent session.',
+        'Decide whether the user message below is the user CORRECTING or REDIRECTING the AI assistant (as opposed to a normal new request, answer, or approval).',
+        '',
+    ];
+    if (context.goal) {
+        parts.push('User request earlier in the session:', `"${clip(context.goal, MAX_GOAL_CHARS)}"`, '');
+    }
+    if (context.events.length > 0) {
+        parts.push('Events immediately before the message:');
+        context.events.forEach((event, i) => parts.push(`${i + 1}. ${describeEvent(event)}`));
+        parts.push('');
+    }
+    parts.push('User message to analyze:', `"${clip(context.correction, MAX_GOAL_CHARS)}"`, '', 'Respond with ONLY this JSON, nothing else:', `{"isCorrection": true or false, "category": "${CATEGORIES.join('" | "')}", "confidence": 0.0 to 1.0, "reason": "short explanation"}`);
+    return parts.join('\n');
+}
+export function parseModelResponse(text) {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end <= start)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed['isCorrection'] !== 'boolean')
+        return undefined;
+    return {
+        isCorrection: parsed['isCorrection'],
+        category: typeof parsed['category'] === 'string' ? parsed['category'] : 'other',
+        confidence: typeof parsed['confidence'] === 'number' ? parsed['confidence'] : 0,
+        reason: typeof parsed['reason'] === 'string' ? parsed['reason'] : '',
+    };
+}
+export async function analyzeWithOllama(prompt, model, baseUrl = 'http://localhost:11434') {
+    const generation = await ollamaGenerate(prompt, model, baseUrl);
+    return { ...generation, parsed: parseModelResponse(generation.raw) };
+}

package/dist/experiments/ollama.js

@@ -0,0 +1,24 @@
+// Shared minimal Ollama HTTP client for experiments. Direct fetch, no SDK.
+export async function ollamaGenerate(prompt, model, baseUrl = 'http://localhost:11434') {
+    const startedAt = performance.now();
+    const response = await fetch(`${baseUrl}/api/generate`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            model,
+            prompt,
+            stream: false,
+            format: 'json',
+            options: { temperature: 0 },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama responded ${response.status}: ${await response.text()}`);
+    }
+    const body = (await response.json());
+    return {
+        raw: body.response ?? '',
+        latencyMs: performance.now() - startedAt,
+        modelDurationMs: typeof body.total_duration === 'number' ? body.total_duration / 1_000_000 : undefined,
+    };
+}

package/dist/experiments/rule-distillation.js

@@ -0,0 +1,46 @@
+// EXPERIMENT — Task 3 checkpoint. Distills candidate personal-guidance rules
+// from real user messages with a local Ollama model, so distillation quality
+// can be judged before building the approve/store flow.
+const MAX_MESSAGE_CHARS = 3_000;
+export function buildDistillPrompt(message) {
+    const clipped = message.length > MAX_MESSAGE_CHARS ? `${message.slice(0, MAX_MESSAGE_CHARS)}...` : message;
+    return [
+        'You extract personal working-preference rules that a user teaches an AI coding assistant.',
+        'From the user message below, extract 0 to 3 rules the user wants the assistant to follow IN GENERAL across future work.',
+        'A rule is a lasting preference, constraint, or way of working (e.g. "ask before making decisions", "keep answers short").',
+        'One-off task instructions ("add a button", "fix this bug", "rename X") are NOT rules — return them nowhere.',
+        'If the message contains no lasting guidance, return an empty rules array.',
+        '',
+        'User message:',
+        `"${clipped}"`,
+        '',
+        'Respond with ONLY this JSON, nothing else:',
+        '{"rules": [{"rule": "short imperative rule", "category": "one or two words", "confidence": 0.0 to 1.0}]}',
+    ].join('\n');
+}
+export function parseDistillResponse(text) {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end <= start)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed['rules']))
+        return [];
+    const rules = [];
+    for (const entry of parsed['rules']) {
+        if (typeof entry?.['rule'] !== 'string' || entry['rule'].trim() === '')
+            continue;
+        rules.push({
+            rule: entry['rule'].trim(),
+            category: typeof entry['category'] === 'string' ? entry['category'] : 'General',
+            confidence: typeof entry['confidence'] === 'number' ? entry['confidence'] : 0,
+        });
+    }
+    return rules;
+}

package/dist/persistence/rule-store-files.js

@@ -0,0 +1,25 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { emptyStore, parseRuleStore, serializeRuleStore } from '../core/rule-store.js';
+// PAI writes only to its own agent-neutral `.pai/` directories.
+export function globalStorePath(home = homedir()) {
+    return join(home, '.pai', 'rules.json');
+}
+export function projectStorePath(cwd) {
+    return join(cwd, '.pai', 'rules.json');
+}
+export function readStore(path) {
+    let contents;
+    try {
+        contents = readFileSync(path, 'utf8');
+    }
+    catch {
+        return emptyStore();
+    }
+    return parseRuleStore(contents);
+}
+export function writeStore(path, store) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, serializeRuleStore(store), 'utf8');
+}

package/docs/principles.md

@@ -0,0 +1,39 @@
+# PAI — Principles & Validation Layers
+
+## Principles
+
+1. **Read-only toward agents' data.** PAI never modifies coding-agent files
+   (transcripts, configs, CLAUDE.md). PAI writes only to its own store
+   (`.pai/` in a project) — and to agent guidance files only as an explicit,
+   user-approved sync feature (future).
+2. **Approval gates knowledge.** Nothing becomes a stored rule without the
+   user approving it. Every stored or reported item carries evidence: the
+   user's actual words, session id, timestamp.
+3. **Candidates, not verdicts.** Detection output is labeled as possible /
+   candidate with confidence. PAI informs; it never blocks or controls.
+4. **Local-only.** Transcripts and derived data never leave the machine.
+   LLM analysis runs on a local model (Ollama). No cloud calls. Portability is
+   the user's move, not PAI's: `pai export` / `pai import` produce a portable,
+   versioned JSON store the user carries between machines. Imports merge
+   non-destructively; they never overwrite existing knowledge. A hosted
+   backend is a later swap, only if PAI ever becomes a multi-user service.
+5. **Degrade, never block.** A failed or unavailable layer reduces the
+   result and says so. Commands do not crash or guess when data is missing.
+6. **Outside the agent's context.** Anything that can be observed and
+   processed outside the coding agent's context stays outside it.
+
+## Validation layers
+
+Each layer is independent, optional, and ordered cheap → expensive.
+Command output states which layers ran (footer), so the user always knows
+how much to trust a result.
+
+| Layer | Validates | Cost | On failure / absence |
+|---|---|---|---|
+| L0 Data | transcripts exist, parseable, known format | free | report what was skipped; show partial results |
+| L1 Deterministic | keyword corrections, tool failures | free | always available — the floor |
+| L2 Semantic | local LLM: confirm corrections, distill rules, match rules | seconds, local | deliver L1 results labeled "unfiltered"; note skip |
+| L3 Compliance | sessions vs stored rules → violations | uses L2 | no stored rules → report "nothing to audit" |
+| L4 Trends (future) | violations over time; before/after a rule; model/config comparison | aggregation | needs accumulated history |
+
+Adding a future validation = adding a row here and one module — not a framework.

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@lastboy/pai",
+  "version": "0.1.0",
+  "description": "PAI — Personal AI Supervisor: a local-first CLI that observes how you work with AI coding agents and turns it into knowledge you own",
+  "keywords": [
+    "cli",
+    "claude-code",
+    "ai",
+    "coding-agent",
+    "developer-tools",
+    "local-first",
+    "productivity"
+  ],
+  "homepage": "https://github.com/lastboy/pai#readme",
+  "bugs": {
+    "url": "https://github.com/lastboy/pai/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lastboy/pai.git"
+  },
+  "license": "MIT",
+  "author": "Arik Lewin",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "pai": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/cli/index.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "commander": "^15.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  }
+}