@mjasnikovs/pi-task 0.18.14 → 0.18.16

package/dist/task/write-guard.js

@@ -0,0 +1,112 @@
+/**
+ * write-guard — deterministic tree-change accounting for WRITE-CAPABLE gate
+ * children (mx5 run 11).
+ *
+ * The failure class: the final-gate autofix child (read,edit,bash) was added after
+ * the run-8 guard generation and inherited NONE of the guards the other
+ * write-capable passes carry — no diff capture, no frozen-path deny, no probe
+ * scans, free `rm`. Run 11 it deleted `src/client/pages/admin.tsx` (TASK_0008's
+ * verified deliverable) to satisfy a recorded debt claim, and the deletion was
+ * invisible: nothing even logged what the pass changed.
+ *
+ * This module is the pure half of the guard stack: parse `git status --porcelain`
+ * into a change summary (the diff-capture log line every write-capable child now
+ * gets at the gate-deps seam), and classify tracked-file DELETIONS. A fix pass
+ * exists to repair the assembled repository, not to shrink it: every tracked file
+ * is a committed task's deliverable, so deleting one is rejected outright — with
+ * one allowance, a RELOCATION (the same file name reappears as an added file
+ * elsewhere, e.g. moving a test the runner was never meant to pick up out of its
+ * glob — the legitimate fix shape from run 7). Pure text/path analysis; no git
+ * execution, no stack assumptions.
+ */
+/** Porcelain v1 line: `XY <path>` or `XY <orig> -> <new>` (rename/copy). */
+function splitEntry(raw) {
+    if (raw.length < 4)
+        return null;
+    const x = raw[0];
+    const y = raw[1];
+    const file = raw.slice(3).trim();
+    if (file.length === 0)
+        return null;
+    let from = file;
+    let to = file;
+    const arrow = file.indexOf(' -> ');
+    if (arrow !== -1) {
+        from = file.slice(0, arrow).trim();
+        to = file.slice(arrow + 4).trim();
+    }
+    const unquote = (s) => s.startsWith('"') && s.endsWith('"') && s.length >= 2 ? s.slice(1, -1) : s;
+    return { x, y, from: unquote(from), to: unquote(to) };
+}
+/**
+ * Parse `git status --porcelain` output into the change summary. A rename entry
+ * contributes its source to `deleted` and its target to `added` (unstaged child
+ * edits show the same reality as separate ` D old` + `?? new` lines, so both
+ * shapes classify identically). Deterministic and pure so it is unit-tested
+ * without a repo.
+ */
+export function parseTreeChanges(porcelain) {
+    const modified = new Set();
+    const deleted = new Set();
+    const added = new Set();
+    for (const raw of porcelain.split('\n')) {
+        const e = splitEntry(raw);
+        if (!e)
+            continue;
+        const status = `${e.x}${e.y}`;
+        if (status === '??') {
+            added.add(e.to);
+            continue;
+        }
+        if (e.x === 'R' || e.y === 'R' || e.x === 'C') {
+            deleted.add(e.from);
+            added.add(e.to);
+            continue;
+        }
+        if (e.x === 'D' || e.y === 'D') {
+            deleted.add(e.from);
+            continue;
+        }
+        if (e.x === 'A') {
+            added.add(e.to);
+            continue;
+        }
+        modified.add(e.to);
+    }
+    return { modified: [...modified], deleted: [...deleted], added: [...added] };
+}
+const basename = (p) => {
+    const i = p.lastIndexOf('/');
+    return i === -1 ? p : p.slice(i + 1);
+};
+/**
+ * The deletions a fix pass may NOT make: every deleted tracked file whose name does
+ * not reappear among the added files (a relocation keeps the file, under the same
+ * name, somewhere in the tree). Anything returned here rejects the whole fix
+ * attempt — run 11's `rm src/client/pages/admin.tsx` had no corresponding add and
+ * destroyed a sibling task's verified deliverable.
+ */
+export function findForbiddenDeletions(changes) {
+    if (changes.deleted.length === 0)
+        return [];
+    const addedNames = new Set(changes.added.map(basename));
+    return changes.deleted.filter(p => !addedNames.has(basename(p)));
+}
+/**
+ * One-line summary for the gate debug log — the diff capture every write-capable
+ * child gets so "what did this pass change" is answerable from artifacts (the
+ * run-11 `rm` left no trace outside the bash stream).
+ */
+export function formatTreeChanges(changes) {
+    if (changes.modified.length === 0
+        && changes.deleted.length === 0
+        && changes.added.length === 0) {
+        return '(no tree changes)';
+    }
+    const part = (label, list) => list.length > 0 ? [`${label} [${list.join(', ')}]`] : [];
+    return [
+        ...part('MODIFIED', changes.modified),
+        ...part('NEW', changes.added),
+        ...part('DELETED', changes.deleted)
+    ].join(' ');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.14",
+    "version": "0.18.16",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",

package/dist/task/_ab.d.ts

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

package/dist/task/_ab.js

@@ -1,68 +0,0 @@
-/* Live A/B: orientation OFF vs ON, real pi + local model, real mx5 repo. */
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { runWorker } from '../workers/pi-worker-core.js';
-import { getFileInventory } from './file-inventory.js';
-import { buildOrientation } from './orientation.js';
-import { appendNoThink, RESEARCH_FILES_PROMPT, RESEARCH_CONTEXT_PROMPT, RESEARCH_APIS_PROMPT, RESEARCH_TOOLING_PROMPT } from './prompts.js';
-import { scopedToolingGoal } from './phases.js';
-const DOCS_EXT = new URL('../workers/docs-extension.js', import.meta.url).pathname;
-const SINGLE_READ_EXT = new URL('../workers/single-read-extension.js', import.meta.url).pathname;
-const CWD = '/home/edgars/hub/mx5';
-process.env.PI_BIN ??= '/home/edgars/.local/share/mise/installs/node/26.2.0/bin/pi';
-const refined = await readFile('/tmp/refined.txt', 'utf8');
-const inventoryRaw = await getFileInventory(CWD);
-const invPaths = inventoryRaw.split('\n').filter(l => l.trim());
-const inventoryHeader = `PROJECT FILE INVENTORY\n${inventoryRaw}\n\n`;
-const orientation = await buildOrientation(invPaths, async (p) => {
-    try {
-        return await readFile(resolve(CWD, p), 'utf8');
-    }
-    catch {
-        return null;
-    }
-});
-console.error(`orientation: ${orientation.supplied.size} files, ${(orientation.block.length / 1024).toFixed(1)}KB`);
-const suppliedRel = new Set([...orientation.supplied].map(p => resolve(CWD, p)));
-const workers = {
-    FILES: { build: RESEARCH_FILES_PROMPT, tools: undefined, ext: [] },
-    APIS: {
-        build: RESEARCH_APIS_PROMPT,
-        tools: 'read,grep,find,ls,pi-worker-docs',
-        ext: [DOCS_EXT]
-    },
-    CONTEXT: { build: RESEARCH_CONTEXT_PROMPT, tools: 'read,grep', ext: [] },
-    TOOLING: {
-        build: (r) => RESEARCH_TOOLING_PROMPT(scopedToolingGoal(r)),
-        tools: undefined,
-        ext: [SINGLE_READ_EXT]
-    }
-};
-async function run(worker, on) {
-    const header = (on ? orientation.block : '') + inventoryHeader;
-    const prompt = appendNoThink(header + workers[worker].build(refined));
-    const reads = [];
-    const r = await runWorker({
-        prompt,
-        cwd: CWD,
-        ...(workers[worker].tools ? { tools: workers[worker].tools } : {}),
-        ...(workers[worker].ext.length ? { extensions: workers[worker].ext } : {}),
-        onLine: line => {
-            const m = /read: (\S+)/.exec(line);
-            if (m)
-                reads.push(resolve(CWD, m[1]));
-        }
-    });
-    const reReadSupplied = reads.filter(p => suppliedRel.has(p)).length;
-    const label = `${worker} ${on ? 'ON ' : 'OFF'}`;
-    console.log(`${label}  exit=${r.exitCode} loop=${r.loopHit ? 'Y' : 'n'} time=${r.loopHit || r.timedOut ? '(runaway)' : ''}` +
-        ` workMs=${r.workMs} reads=${reads.length} reads_of_core=${reReadSupplied} answerChars=${r.text.trim().length}`);
-    return { reads: reads.length, reReadSupplied, workMs: r.workMs, exit: r.exitCode };
-}
-for (const w of ['FILES', 'APIS', 'CONTEXT', 'TOOLING']) {
-    const off = await run(w, false);
-    const on = await run(w, true);
-    const saved = off.reads - on.reads;
-    console.log(`  -> ${w}: reads ${off.reads}->${on.reads} (${saved >= 0 ? '-' : '+'}${Math.abs(saved)}), ` +
-        `workMs ${off.workMs}->${on.workMs}, core re-read while ON: ${on.reReadSupplied}\n`);
-}

package/dist/task/task-file.d.ts

@@ -1,14 +0,0 @@
-/**
- * Task file — barrel re-export for backward compatibility.
- *
- * All existing import sites continue to work unchanged.
- *
- * @deprecated Import from the specific modules:
- *   - Types & constants: task-types.ts
- *   - Parsing & formatting: task-parsers.ts
- *   - File I/O: task-io.ts
- */
-export type { TaskState, PhaseName, TaskFrontMatter } from './task-types.js';
-export { PHASE_ORDER, PHASE_INDEX, TASKS_DIR_NAME, RESUMABLE_STATES } from './task-types.js';
-export { emitFrontMatter, parseFrontMatter, sectionRegex, extractSection, normaliseTaskId } from './task-parsers.js';
-export { tasksDir, taskFilePath, ensureTasksDir, allocateTaskId, readTaskFile, writeTaskFile, updateTaskFrontMatter, readSection, setTaskSection } from './task-io.js';

package/dist/task/task-file.js

@@ -1,15 +0,0 @@
-/**
- * Task file — barrel re-export for backward compatibility.
- *
- * All existing import sites continue to work unchanged.
- *
- * @deprecated Import from the specific modules:
- *   - Types & constants: task-types.ts
- *   - Parsing & formatting: task-parsers.ts
- *   - File I/O: task-io.ts
- */
-export { PHASE_ORDER, PHASE_INDEX, TASKS_DIR_NAME, RESUMABLE_STATES } from './task-types.js';
-// Parsing & formatting
-export { emitFrontMatter, parseFrontMatter, sectionRegex, extractSection, normaliseTaskId } from './task-parsers.js';
-// File I/O
-export { tasksDir, taskFilePath, ensureTasksDir, allocateTaskId, readTaskFile, writeTaskFile, updateTaskFrontMatter, readSection, setTaskSection } from './task-io.js';

package/dist/think-test/cli.d.ts

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

package/dist/think-test/cli.js

@@ -1,98 +0,0 @@
-// src/think-test/cli.ts
-import { readFileSync } from 'node:fs';
-import { parseTranscript, decisionPoints } from './transcript.js';
-import { applyMode } from './transform.js';
-import { toOpenAiMessages } from './serialize.js';
-import { createHttpClient } from './client.js';
-import { buildCompressionMap } from './compressor.js';
-import { scoreSamples, aggregate } from './score.js';
-const ENDPOINT = process.env.PI_THINKTEST_ENDPOINT ?? 'http://localhost:8080/v1/chat/completions';
-const MODES = ['full', 'none', 'compressed'];
-function flag(name, def) {
-    const hit = process.argv.find(a => a.startsWith(`--${name}=`));
-    if (!hit)
-        return def;
-    const value = Number(hit.split('=')[1]);
-    if (!Number.isFinite(value))
-        throw new Error(`--${name} must be a number`);
-    return value;
-}
-function readFixtureTools() {
-    const url = new URL('./__fixtures__/tools.json', import.meta.url);
-    let raw;
-    try {
-        raw = readFileSync(url, 'utf8');
-    }
-    catch {
-        throw new Error('missing src/think-test/__fixtures__/tools.json — capture it first (see plan Task 6). '
-            + 'Without the tools schema the model cannot emit tool_calls and the test is meaningless.');
-    }
-    const tools = JSON.parse(raw);
-    if (!Array.isArray(tools) || tools.length === 0) {
-        throw new Error('tools.json must be a non-empty JSON array of tool schemas');
-    }
-    return tools;
-}
-async function main() {
-    const sessionPath = process.argv[2];
-    if (!sessionPath) {
-        console.error('usage: bun run think-test <session.jsonl> [--n=5] [--limit=0]');
-        process.exit(1);
-    }
-    const n = flag('n', 5);
-    const limit = flag('limit', 0); // 0 = all turns
-    const tools = readFixtureTools();
-    let transcript;
-    try {
-        transcript = readFileSync(sessionPath, 'utf8');
-    }
-    catch {
-        throw new Error(`cannot read session file: ${sessionPath}`);
-    }
-    const messages = parseTranscript(transcript);
-    let points = decisionPoints(messages).filter(p => p.prior.length > 0);
-    if (points.length === 0) {
-        throw new Error('no decision points with prior context found in transcript');
-    }
-    if (limit > 0)
-        points = points.slice(0, limit);
-    const sampler = createHttpClient(fetch, ENDPOINT, tools);
-    const textClient = createHttpClient(fetch, ENDPOINT, []); // compression + judging: no tools, want text
-    // Only compress thinking the selected points reference (deduped inside
-    // buildCompressionMap). With --limit this avoids compressing the whole
-    // transcript; a full run covers every turn anyway.
-    const referenced = points.flatMap(p => p.prior);
-    console.error(`compressing prior thinking referenced by ${points.length} points…`);
-    const compressed = await buildCompressionMap(referenced, textClient);
-    // Dump the compressions for manual inspection (guards against a weak prompt).
-    console.error('--- compression samples (first 3) ---');
-    let shown = 0;
-    for (const [orig, comp] of compressed) {
-        if (shown++ >= 3)
-            break;
-        console.error(`[${orig.length}→${comp.length}] ${comp.slice(0, 200)}`);
-    }
-    const perTurn = { full: [], none: [], compressed: [] };
-    for (const [i, pt] of points.entries()) {
-        for (const mode of MODES) {
-            const body = toOpenAiMessages(applyMode(pt.prior, mode, compressed));
-            const samples = [];
-            for (let s = 0; s < n; s++) {
-                samples.push(await sampler.complete(body, { temperature: 1 }));
-            }
-            const rate = await scoreSamples(pt.recordedTool, pt.recordedArgs, samples, textClient);
-            perTurn[mode].push(rate);
-        }
-        console.error(`turn ${i + 1}/${points.length} (${pt.recordedTool}) `
-            + MODES.map(m => `${m}=${perTurn[m][i].toFixed(2)}`).join(' '));
-    }
-    console.log('\n=== aggregate agreement vs recorded action ===');
-    for (const mode of MODES) {
-        console.log(`${mode.padEnd(11)} ${aggregate(perTurn[mode]).toFixed(3)}`);
-    }
-    console.log('\nread: full=ceiling, none=floor, compressed=verdict');
-}
-main().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-});

package/dist/think-test/client.d.ts

@@ -1,26 +0,0 @@
-import type { Action } from './types.js';
-import type { OpenAiMessage } from './serialize.js';
-export interface CompletionOpts {
-    temperature: number;
-}
-export interface ModelClient {
-    complete(messages: OpenAiMessage[], opts: CompletionOpts): Promise<Action>;
-}
-export interface RawChoice {
-    message: {
-        content?: string | null;
-        tool_calls?: {
-            function: {
-                name: string;
-                arguments: string;
-            };
-        }[];
-    };
-}
-/** Normalize one completion choice into an Action: a tool call (with parsed
- *  args, `{}` on malformed JSON) or, absent any tool call, the text. */
-export declare function parseChoice(choice: RawChoice): Action;
-/** HTTP client for the local llama-server. `tools` is the captured schema array
- *  — without it the model cannot emit tool_calls and the test is meaningless.
- *  `fetchFn`/`endpoint` are injectable for tests. */
-export declare function createHttpClient(fetchFn: typeof fetch, endpoint: string, tools: unknown[]): ModelClient;

package/dist/think-test/client.js

@@ -1,37 +0,0 @@
-/** Normalize one completion choice into an Action: a tool call (with parsed
- *  args, `{}` on malformed JSON) or, absent any tool call, the text. */
-export function parseChoice(choice) {
-    const tc = choice.message.tool_calls?.[0];
-    if (tc) {
-        let args;
-        try {
-            args = JSON.parse(tc.function.arguments);
-        }
-        catch {
-            args = {};
-        }
-        return { tool: tc.function.name, args };
-    }
-    return { text: choice.message.content ?? '' };
-}
-/** HTTP client for the local llama-server. `tools` is the captured schema array
- *  — without it the model cannot emit tool_calls and the test is meaningless.
- *  `fetchFn`/`endpoint` are injectable for tests. */
-export function createHttpClient(fetchFn, endpoint, tools) {
-    return {
-        async complete(messages, opts) {
-            const res = await fetchFn(endpoint, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ messages, tools, temperature: opts.temperature })
-            });
-            if (!res.ok)
-                throw new Error(`model HTTP ${res.status}`);
-            const json = (await res.json());
-            const choice = json.choices?.[0];
-            if (!choice)
-                throw new Error('model returned no choices');
-            return parseChoice(choice);
-        }
-    };
-}

package/dist/think-test/compressor.d.ts

@@ -1,5 +0,0 @@
-import type { SessionMsg } from './types.js';
-import type { ModelClient } from './client.js';
-/** Compress every distinct thinking block once (compress-once semantics, even
- *  here in the test) and return a map from original text → compressed text. */
-export declare function buildCompressionMap(messages: SessionMsg[], client: ModelClient): Promise<Map<string, string>>;

package/dist/think-test/compressor.js

@@ -1,25 +0,0 @@
-const COMPRESS_PROMPT = (thinking) => `Compress the following reasoning trace. Keep every decision, conclusion, `
-    + `constraint, and fact the author will rely on later. Drop restated questions, `
-    + `false starts, self-talk, and verbosity. Output only the compressed reasoning, `
-    + `no preamble.\n\n---\n${thinking}\n---\n\n/no_think`;
-/** Compress every distinct thinking block once (compress-once semantics, even
- *  here in the test) and return a map from original text → compressed text. */
-export async function buildCompressionMap(messages, client) {
-    const unique = new Set();
-    for (const m of messages) {
-        if (m.role !== 'assistant')
-            continue;
-        for (const c of m.content) {
-            if (c.type === 'thinking')
-                unique.add(c.thinking);
-        }
-    }
-    const map = new Map();
-    for (const original of unique) {
-        const action = await client.complete([{ role: 'user', content: COMPRESS_PROMPT(original) }], {
-            temperature: 0
-        });
-        map.set(original, (action.text ?? '').trim());
-    }
-    return map;
-}

package/dist/think-test/judge.d.ts

@@ -1,4 +0,0 @@
-import type { ModelClient } from './client.js';
-/** Ask the model whether two arg objects are equivalent in intent. Deterministic
- *  (temperature 0). Only meaningful when the tool name already matched. */
-export declare function judgeArgs(tool: string, a: Record<string, unknown>, b: Record<string, unknown>, client: ModelClient): Promise<boolean>;

package/dist/think-test/judge.js

@@ -1,11 +0,0 @@
-const JUDGE_PROMPT = (tool, a, b) => `Two calls to the tool "${tool}" were made. Are their arguments equivalent `
-    + `in intent (same target/effect), ignoring cosmetic differences? Answer with `
-    + `YES or NO only.\n\nA: ${JSON.stringify(a)}\nB: ${JSON.stringify(b)}\n\n/no_think`;
-/** Ask the model whether two arg objects are equivalent in intent. Deterministic
- *  (temperature 0). Only meaningful when the tool name already matched. */
-export async function judgeArgs(tool, a, b, client) {
-    const action = await client.complete([{ role: 'user', content: JUDGE_PROMPT(tool, a, b) }], {
-        temperature: 0
-    });
-    return /\byes\b/i.test(action.text ?? '');
-}

package/dist/think-test/score.d.ts

@@ -1,8 +0,0 @@
-import type { Action } from './types.js';
-import type { ModelClient } from './client.js';
-/** Agreement rate for one decision point's samples against the recorded action:
- *  fraction of samples whose tool name matches AND whose args the judge deems
- *  equivalent. The judge is only consulted on a tool-name match. */
-export declare function scoreSamples(recordedTool: string, recordedArgs: Record<string, unknown>, samples: Action[], judge: ModelClient): Promise<number>;
-/** Mean of per-turn agreement rates; 0 for an empty list. */
-export declare function aggregate(perTurnRates: number[]): number;

package/dist/think-test/score.js

@@ -1,22 +0,0 @@
-import { judgeArgs } from './judge.js';
-/** Agreement rate for one decision point's samples against the recorded action:
- *  fraction of samples whose tool name matches AND whose args the judge deems
- *  equivalent. The judge is only consulted on a tool-name match. */
-export async function scoreSamples(recordedTool, recordedArgs, samples, judge) {
-    if (samples.length === 0)
-        return 0;
-    let hits = 0;
-    for (const s of samples) {
-        if (s.tool !== recordedTool)
-            continue;
-        if (await judgeArgs(recordedTool, recordedArgs, s.args ?? {}, judge))
-            hits++;
-    }
-    return hits / samples.length;
-}
-/** Mean of per-turn agreement rates; 0 for an empty list. */
-export function aggregate(perTurnRates) {
-    if (perTurnRates.length === 0)
-        return 0;
-    return perTurnRates.reduce((a, b) => a + b, 0) / perTurnRates.length;
-}

package/dist/think-test/serialize.d.ts

@@ -1,19 +0,0 @@
-import type { SessionMsg } from './types.js';
-export interface OpenAiMessage {
-    role: 'user' | 'assistant' | 'tool';
-    content: string;
-    reasoning_content?: string;
-    tool_call_id?: string;
-    tool_calls?: {
-        id: string;
-        type: 'function';
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }[];
-}
-/** Convert session messages to the OpenAI chat-completions wire format used by
- *  llama-server, replicating pi's `reasoning_content` carry-back so prior
- *  thinking is preserved exactly as in a real request. */
-export declare function toOpenAiMessages(messages: SessionMsg[]): OpenAiMessage[];

package/dist/think-test/serialize.js

@@ -1,41 +0,0 @@
-function joinText(blocks) {
-    return blocks
-        .filter((b) => b.type === 'text')
-        .map(b => b.text)
-        .join('');
-}
-/** Convert session messages to the OpenAI chat-completions wire format used by
- *  llama-server, replicating pi's `reasoning_content` carry-back so prior
- *  thinking is preserved exactly as in a real request. */
-export function toOpenAiMessages(messages) {
-    const out = [];
-    for (const m of messages) {
-        if (m.role === 'user') {
-            const content = typeof m.content === 'string' ? m.content : joinText(m.content);
-            out.push({ role: 'user', content });
-        }
-        else if (m.role === 'assistant') {
-            const content = joinText(m.content);
-            const thinking = m.content
-                .filter((c) => c.type === 'thinking')
-                .map(c => c.thinking)
-                .join('\n');
-            const toolCalls = m.content.filter((c) => c.type === 'toolCall');
-            const msg = { role: 'assistant', content };
-            if (thinking.length > 0)
-                msg.reasoning_content = thinking;
-            if (toolCalls.length > 0) {
-                msg.tool_calls = toolCalls.map(tc => ({
-                    id: tc.id,
-                    type: 'function',
-                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
-                }));
-            }
-            out.push(msg);
-        }
-        else {
-            out.push({ role: 'tool', tool_call_id: m.toolCallId, content: joinText(m.content) });
-        }
-    }
-    return out;
-}

package/dist/think-test/transcript.d.ts

@@ -1,7 +0,0 @@
-import type { SessionMsg, DecisionPoint } from './types.js';
-/** Parse a pi session `.jsonl` into the ordered message list, dropping
- *  non-message rows (session header, model_change, blanks, malformed lines). */
-export declare function parseTranscript(jsonl: string): SessionMsg[];
-/** Every assistant turn whose content includes a toolCall becomes a scoring
- *  unit: the prior context plus the recorded tool name + args. */
-export declare function decisionPoints(messages: SessionMsg[]): DecisionPoint[];

package/dist/think-test/transcript.js

@@ -1,41 +0,0 @@
-/** Parse a pi session `.jsonl` into the ordered message list, dropping
- *  non-message rows (session header, model_change, blanks, malformed lines). */
-export function parseTranscript(jsonl) {
-    const out = [];
-    for (const line of jsonl.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let obj;
-        try {
-            obj = JSON.parse(trimmed);
-        }
-        catch {
-            continue;
-        }
-        const rec = obj;
-        if (rec.type !== 'message' || !rec.message)
-            continue;
-        out.push(rec.message);
-    }
-    return out;
-}
-/** Every assistant turn whose content includes a toolCall becomes a scoring
- *  unit: the prior context plus the recorded tool name + args. */
-export function decisionPoints(messages) {
-    const points = [];
-    messages.forEach((m, index) => {
-        if (m.role !== 'assistant')
-            return;
-        const tc = m.content.find((c) => c.type === 'toolCall');
-        if (!tc)
-            return;
-        points.push({
-            index,
-            prior: messages.slice(0, index),
-            recordedTool: tc.name,
-            recordedArgs: tc.arguments
-        });
-    });
-    return points;
-}

package/dist/think-test/transform.d.ts

@@ -1,6 +0,0 @@
-import type { SessionMsg, ThinkMode } from './types.js';
-/** Produce the message list to send for a given arm. `full` is identity;
- *  `none` removes thinking; `compressed` swaps each thinking block's text for
- *  its precomputed summary (keyed by the original text), leaving it verbatim on
- *  a cache miss. */
-export declare function applyMode(messages: SessionMsg[], mode: ThinkMode, compressed: Map<string, string>): SessionMsg[];

package/dist/think-test/transform.js

@@ -1,24 +0,0 @@
-function stripThinking(messages) {
-    return messages.map(m => m.role === 'assistant' ? { ...m, content: m.content.filter(c => c.type !== 'thinking') } : m);
-}
-function compressThinking(messages, compressed) {
-    return messages.map(m => m.role === 'assistant' ?
-        {
-            ...m,
-            content: m.content.map(c => c.type === 'thinking' ?
-                { ...c, thinking: compressed.get(c.thinking) ?? c.thinking }
-                : c)
-        }
-        : m);
-}
-/** Produce the message list to send for a given arm. `full` is identity;
- *  `none` removes thinking; `compressed` swaps each thinking block's text for
- *  its precomputed summary (keyed by the original text), leaving it verbatim on
- *  a cache miss. */
-export function applyMode(messages, mode, compressed) {
-    if (mode === 'full')
-        return messages;
-    if (mode === 'none')
-        return stripThinking(messages);
-    return compressThinking(messages, compressed);
-}