@pasko70/pibo 2.3.0 → 2.4.1

package/dist/compute/pool/store.js

@@ -0,0 +1,239 @@
+import { mkdirSync } from "node:fs";
+import { chmodSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function slotFromRow(row) {
+    return {
+        id: row.id,
+        ordinal: row.ordinal,
+        webPort: row.web_port,
+        gatewayPort: row.gateway_port,
+        publicUrl: row.public_url ?? undefined,
+        state: row.state,
+        activeLeaseId: row.active_lease_id ?? undefined,
+        dirtyReason: row.dirty_reason ?? undefined,
+        updatedAt: row.updated_at,
+    };
+}
+function leaseFromRow(row) {
+    return {
+        id: row.id,
+        slotId: row.slot_id,
+        holder: row.holder,
+        seedMode: row.seed_mode,
+        artifactSha256: row.artifact_sha256,
+        artifactRuntimePath: row.artifact_runtime_path,
+        packageVersion: row.package_version ?? undefined,
+        commit: row.commit_sha ?? undefined,
+        containerName: row.container_name,
+        publicUrl: row.public_url ?? undefined,
+        status: row.status,
+        createdAt: row.created_at,
+        expiresAt: row.expires_at,
+        renewedAt: row.renewed_at ?? undefined,
+        releasedAt: row.released_at ?? undefined,
+        failedAt: row.failed_at ?? undefined,
+        failureSnapshotPath: row.failure_snapshot_path ?? undefined,
+        lastError: row.last_error ?? undefined,
+    };
+}
+export class DeploymentPoolStore {
+    path;
+    db;
+    constructor(path, slots) {
+        this.path = path === ":memory:" ? path : resolve(path);
+        if (this.path !== ":memory:")
+            mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+        this.db = new DatabaseSync(this.path);
+        this.db.exec("PRAGMA busy_timeout = 10000");
+        if (this.path !== ":memory:")
+            this.db.exec("PRAGMA journal_mode = WAL");
+        this.applySchema();
+        this.ensureSlots(slots);
+        if (this.path !== ":memory:")
+            chmodSync(this.path, 0o600);
+    }
+    applySchema() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS deployment_pool_slots (
+				id TEXT PRIMARY KEY,
+				ordinal INTEGER NOT NULL UNIQUE,
+				web_port INTEGER NOT NULL UNIQUE,
+				gateway_port INTEGER NOT NULL UNIQUE,
+				public_url TEXT,
+				state TEXT NOT NULL,
+				active_lease_id TEXT,
+				dirty_reason TEXT,
+				updated_at TEXT NOT NULL
+			);
+			CREATE TABLE IF NOT EXISTS deployment_pool_leases (
+				id TEXT PRIMARY KEY,
+				slot_id TEXT NOT NULL,
+				holder TEXT NOT NULL,
+				seed_mode TEXT NOT NULL,
+				artifact_sha256 TEXT NOT NULL,
+				artifact_runtime_path TEXT NOT NULL,
+				package_version TEXT,
+				commit_sha TEXT,
+				container_name TEXT NOT NULL,
+				public_url TEXT,
+				status TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				expires_at TEXT NOT NULL,
+				renewed_at TEXT,
+				released_at TEXT,
+				failed_at TEXT,
+				failure_snapshot_path TEXT,
+				last_error TEXT
+			);
+			CREATE INDEX IF NOT EXISTS deployment_pool_leases_status_idx
+				ON deployment_pool_leases (status, expires_at);
+			CREATE INDEX IF NOT EXISTS deployment_pool_leases_slot_idx
+				ON deployment_pool_leases (slot_id, created_at DESC);
+		`);
+    }
+    ensureSlots(slots) {
+        const now = new Date().toISOString();
+        const insert = this.db.prepare(`
+			INSERT INTO deployment_pool_slots (id, ordinal, web_port, gateway_port, public_url, state, updated_at)
+			VALUES (?, ?, ?, ?, ?, 'free', ?)
+			ON CONFLICT(id) DO UPDATE SET
+				ordinal=excluded.ordinal,
+				web_port=excluded.web_port,
+				gateway_port=excluded.gateway_port,
+				public_url=excluded.public_url
+		`);
+        for (const slot of slots)
+            insert.run(slot.id, slot.ordinal, slot.webPort, slot.gatewayPort, slot.publicUrl ?? null, now);
+    }
+    listSlots() {
+        return this.db.prepare("SELECT * FROM deployment_pool_slots ORDER BY ordinal").all().map(slotFromRow);
+    }
+    getSlot(id) {
+        const row = this.db.prepare("SELECT * FROM deployment_pool_slots WHERE id = ?").get(id);
+        return row ? slotFromRow(row) : undefined;
+    }
+    listLeases(options = {}) {
+        const where = options.includeInactive ? "" : "WHERE status IN ('provisioning', 'ready', 'releasing')";
+        return this.db.prepare(`SELECT * FROM deployment_pool_leases ${where} ORDER BY created_at DESC`).all().map(leaseFromRow);
+    }
+    getLease(id) {
+        const row = this.db.prepare("SELECT * FROM deployment_pool_leases WHERE id = ?").get(id);
+        return row ? leaseFromRow(row) : undefined;
+    }
+    reserveLease(input) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const active = this.db.prepare("SELECT COUNT(*) AS count FROM deployment_pool_slots WHERE state IN ('provisioning', 'ready', 'releasing')").get();
+            if (Number(active.count) >= input.maxActive) {
+                const nearest = this.db.prepare(`
+					SELECT MIN(l.expires_at) AS nearest_expiry
+					FROM deployment_pool_slots s
+					JOIN deployment_pool_leases l ON l.id = s.active_lease_id
+					WHERE s.state IN ('provisioning', 'ready', 'releasing')
+				`).get();
+                throw new Error(`Deployment pool capacity reached (${input.maxActive} active)${nearest.nearest_expiry ? `; nearest expiry ${nearest.nearest_expiry}` : ""}`);
+            }
+            const row = this.db.prepare("SELECT * FROM deployment_pool_slots WHERE state = 'free' ORDER BY ordinal LIMIT 1").get();
+            if (!row)
+                throw new Error("No free deployment pool slot is available");
+            const slot = slotFromRow(row);
+            const containerName = `pibo-pool-${slot.id}`;
+            this.db.prepare(`
+				INSERT INTO deployment_pool_leases (
+					id, slot_id, holder, seed_mode, artifact_sha256, artifact_runtime_path,
+					package_version, commit_sha, container_name, public_url, status, created_at, expires_at
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'provisioning', ?, ?)
+			`).run(input.id, slot.id, input.holder, input.seedMode, input.artifactSha256, input.artifactRuntimePath, input.packageVersion ?? null, input.commit ?? null, containerName, slot.publicUrl ?? null, input.createdAt, input.expiresAt);
+            this.db.prepare("UPDATE deployment_pool_slots SET state='provisioning', active_lease_id=?, dirty_reason=NULL, updated_at=? WHERE id=?")
+                .run(input.id, input.createdAt, slot.id);
+            this.db.exec("COMMIT");
+            return { slot: this.getSlot(slot.id), lease: this.getLease(input.id) };
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    markReady(leaseId, now = new Date().toISOString()) {
+        const lease = this.requireLease(leaseId);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db.prepare("UPDATE deployment_pool_leases SET status='ready', last_error=NULL WHERE id=?").run(leaseId);
+            this.db.prepare("UPDATE deployment_pool_slots SET state='ready', dirty_reason=NULL, updated_at=? WHERE id=? AND active_lease_id=?")
+                .run(now, lease.slotId, leaseId);
+            this.db.exec("COMMIT");
+            return this.requireLease(leaseId);
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    markReleasing(leaseId, now = new Date().toISOString()) {
+        const lease = this.requireLease(leaseId);
+        this.db.prepare("UPDATE deployment_pool_leases SET status='releasing' WHERE id=? AND status IN ('provisioning','ready','releasing')").run(leaseId);
+        this.db.prepare("UPDATE deployment_pool_slots SET state='releasing', updated_at=? WHERE id=? AND active_lease_id=?").run(now, lease.slotId, leaseId);
+        return this.requireLease(leaseId);
+    }
+    markReleased(leaseId, status, now = new Date().toISOString()) {
+        const lease = this.requireLease(leaseId);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db.prepare("UPDATE deployment_pool_leases SET status=?, released_at=?, last_error=NULL WHERE id=?").run(status, now, leaseId);
+            this.db.prepare("UPDATE deployment_pool_slots SET state='free', active_lease_id=NULL, dirty_reason=NULL, updated_at=? WHERE id=? AND active_lease_id=?")
+                .run(now, lease.slotId, leaseId);
+            this.db.exec("COMMIT");
+            return this.requireLease(leaseId);
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    markFailed(leaseId, error, snapshotPath, options = { slotClean: false }) {
+        const lease = this.requireLease(leaseId);
+        const now = options.now ?? new Date().toISOString();
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db.prepare("UPDATE deployment_pool_leases SET status='failed', failed_at=?, failure_snapshot_path=?, last_error=? WHERE id=?")
+                .run(now, snapshotPath ?? null, error, leaseId);
+            if (options.slotClean) {
+                this.db.prepare("UPDATE deployment_pool_slots SET state='free', active_lease_id=NULL, dirty_reason=NULL, updated_at=? WHERE id=? AND active_lease_id=?")
+                    .run(now, lease.slotId, leaseId);
+            }
+            else {
+                this.db.prepare("UPDATE deployment_pool_slots SET state='dirty', dirty_reason=?, updated_at=? WHERE id=? AND active_lease_id=?")
+                    .run(error, now, lease.slotId, leaseId);
+            }
+            this.db.exec("COMMIT");
+            return this.requireLease(leaseId);
+        }
+        catch (caught) {
+            this.db.exec("ROLLBACK");
+            throw caught;
+        }
+    }
+    renewLease(leaseId, holder, expiresAt, now = new Date().toISOString()) {
+        const result = this.db.prepare(`
+			UPDATE deployment_pool_leases SET expires_at=?, renewed_at=?
+			WHERE id=? AND holder=? AND status='ready'
+		`).run(expiresAt, now, leaseId, holder);
+        if (Number(result.changes ?? 0) !== 1)
+            throw new Error(`Active deployment lease "${leaseId}" for holder "${holder}" was not found`);
+        return this.requireLease(leaseId);
+    }
+    freeDirtySlot(slotId, now = new Date().toISOString()) {
+        this.db.prepare("UPDATE deployment_pool_slots SET state='free', active_lease_id=NULL, dirty_reason=NULL, updated_at=? WHERE id=?")
+            .run(now, slotId);
+    }
+    requireLease(id) {
+        const lease = this.getLease(id);
+        if (!lease)
+            throw new Error(`Deployment lease "${id}" was not found`);
+        return lease;
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/compute/pool/types.js

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

package/dist/gateway/web.js

@@ -1,3 +1,4 @@
+import { CHAT_WEB_APP_NAME } from "../apps/chat/web-app.js";
 import { createDefaultPiboPlugins } from "../plugins/builtin.js";
 import { createPiboBetterAuthPlugin } from "../plugins/better-auth.js";
 import { createPiboChatCustomAgentProfilesPlugin } from "../plugins/chat-custom-agents.js";
@@ -144,7 +145,13 @@ export function createWebPiboPluginRegistry(options = {}) {
         plugins: [
             ...createDefaultPiboPlugins(),
             useDevAuth ? createPiboDevAuthPlugin() : createPiboBetterAuthPlugin(resolvedOptions.auth),
-            createPiboWebHostPlugin({ announce: false, canonicalBaseURL: useDevAuth ? undefined : authBaseURL(resolvedOptions), gatewayMode: webGatewayMode(resolvedOptions, useDevAuth), ...resolvedOptions.web }),
+            createPiboWebHostPlugin({
+                announce: false,
+                canonicalBaseURL: useDevAuth ? undefined : authBaseURL(resolvedOptions),
+                gatewayMode: webGatewayMode(resolvedOptions, useDevAuth),
+                ...resolvedOptions.web,
+                landingAppName: CHAT_WEB_APP_NAME,
+            }),
             createPiboCronPlugin({ cronStorePath: resolvedOptions.chat?.cronStorePath, dataStorePath: resolvedOptions.chat?.dataStorePath, dataPayloadRootDir: resolvedOptions.chat?.dataPayloadRootDir }),
             createPiboChatUserSkillsPlugin({
                 globalRoot: resolvedOptions.chat?.userSkillGlobalRoot,

package/dist/loops/accounting.js

@@ -1,3 +1,30 @@
+export const LOOP_TOKEN_ACCOUNTING_VERSION = 1;
+function normalizedTokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+export function normalizeLoopTokenAccounting(value, fallback = 'total') {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const candidate = value;
+        if (candidate.version === LOOP_TOKEN_ACCOUNTING_VERSION && (candidate.basis === 'total' || candidate.basis === 'uncached')) {
+            return { version: LOOP_TOKEN_ACCOUNTING_VERSION, basis: candidate.basis };
+        }
+    }
+    return { version: LOOP_TOKEN_ACCOUNTING_VERSION, basis: fallback };
+}
+export function newGoalTokenAccounting() {
+    return { version: LOOP_TOKEN_ACCOUNTING_VERSION, basis: 'uncached' };
+}
+export function goalTokenAccounting(job) {
+    return normalizeLoopTokenAccounting(job.state.tokenAccounting);
+}
+export function goalBudgetTokens(usage, basis) {
+    const totalTokens = normalizedTokenCount(usage.totalTokens);
+    if (basis === 'total')
+        return totalTokens;
+    const cacheReadTokens = normalizedTokenCount(usage.cacheReadTokens);
+    const cacheWriteTokens = normalizedTokenCount(usage.cacheWriteTokens);
+    return Math.max(0, totalTokens - cacheReadTokens - cacheWriteTokens);
+}
 export function goalActiveTimeSeconds(job) {
     return Math.max(0, Math.floor(job.state.activeTimeSeconds ?? job.state.timeUsedSeconds ?? 0));
 }

package/dist/loops/cli.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { Command } from 'commander';
-import { goalActiveTimeSeconds, goalElapsedWallClockSeconds } from './accounting.js';
+import { goalActiveTimeSeconds, goalElapsedWallClockSeconds, goalTokenAccounting } from './accounting.js';
 import { createDefaultPiboLoopStore } from './store.js';
 import { createBuiltInLoopStopConditions } from './stopping.js';
 import { DEFAULT_PIBO_PROFILE_NAME } from '../plugins/builtin.js';
@@ -116,12 +116,13 @@ export function formatLoopResourceSummary(resources) {
 }
 function formatLoopJobLine(job) {
     const goal = job.mode === 'goal' ? job.state.goalStatus ?? (job.enabled ? 'active' : 'paused') : '-';
-    const budget = job.mode === 'goal' ? job.tokenBudget === undefined ? 'unbounded' : `soft:${job.state.tokensUsed ?? 0}/${job.tokenBudget};reserve=${job.tokenReserve ?? 0}` : '-';
+    const tokenBasis = job.mode === 'goal' ? goalTokenAccounting(job).basis : undefined;
+    const budget = job.mode === 'goal' ? job.tokenBudget === undefined ? `unbounded:${tokenBasis}` : `soft:${tokenBasis}:${job.state.tokensUsed ?? 0}/${job.tokenBudget};reserve=${job.tokenReserve ?? 0}` : '-';
     const time = job.mode === 'goal' ? `activeAgent=${goalActiveTimeSeconds(job)}s;elapsedWall=${goalElapsedWallClockSeconds(job)}s;paused=included` : '-';
     return `${job.id}\t${job.mode}\t${job.enabled ? 'running' : 'stopped'}\t${job.state.runningAt ? 'active' : '-'}\tgoal=${goal}\tbudget=${budget}\ttime=${time}\tresources=${formatLoopResourceSummary(job.resources)}\t${job.name}`;
 }
 function formatLoopRunLine(run) {
-    const accounting = run.accounting ? `tokens=${run.accounting.tokensUsed ?? 0};remainingBefore=${run.accounting.remainingTokensBefore ?? 'unbounded'};overshoot=${run.accounting.overshootTokens ?? 0};activeAgent=${run.accounting.activeTimeSeconds ?? 0}s` : '-';
+    const accounting = run.accounting ? `basis=${run.accounting.tokenAccounting?.basis ?? 'total'};tokens=${run.accounting.tokensUsed ?? 0};remainingBefore=${run.accounting.remainingTokensBefore ?? 'unbounded'};overshoot=${run.accounting.overshootTokens ?? 0};activeAgent=${run.accounting.activeTimeSeconds ?? 0}s` : '-';
     return `${run.id}\t${run.jobId}\t${run.status}\t${run.piboSessionId ?? '-'}\t${run.completedAt ?? '-'}\taccounting=${accounting}\tresources=${formatLoopResourceSummary(run.resources)}`;
 }
 export async function runLoopCli(argv = process.argv, defaults = {}) {
@@ -139,13 +140,13 @@ export async function runLoopCli(argv = process.argv, defaults = {}) {
     else
         for (const job of jobs)
             console.log(formatLoopJobLine(job)); store.close(); });
-    program.command('add').description(defaults.mode === 'ralph' ? 'Create a Ralph job' : 'Create a Loop job').option('--template <id>', 'Built-in job template id').option('--mode <mode>', 'Loop mode: goal or ralph').option('--prompt <text>', 'Task prompt').option('--name <name>', 'Job name').option('--description <text>', 'Job description').option('--profile <profile>', 'Agent profile', DEFAULT_PIBO_PROFILE_NAME).option('--room <room-id>', 'Target room id').option('--default-chat', 'Target the shared default chat').option('--max-iterations <n>', 'Stop after n completed run attempts').option('--token-budget <n>', 'Set a soft Goal token budget; the final turn can overshoot').option('--token-reserve <n>', 'Require more than n tokens to remain before starting another Goal turn').option('--model <provider/model>', 'Runtime model override, for example openai/gpt-5').option('--thinking <level>', 'Runtime thinking level override: off, minimal, low, medium, high, xhigh, max').option('--fast', 'Enable runtime fast mode').option('--no-fast', 'Disable runtime fast mode')
+    program.command('add').description(defaults.mode === 'ralph' ? 'Create a Ralph job' : 'Create a Loop job').option('--template <id>', 'Built-in job template id').option('--mode <mode>', 'Loop mode: goal or ralph').option('--prompt <text>', 'Task prompt').option('--name <name>', 'Job name').option('--description <text>', 'Job description').option('--profile <profile>', 'Agent profile', DEFAULT_PIBO_PROFILE_NAME).option('--room <room-id>', 'Target room id').option('--default-chat', 'Target the shared default chat').option('--max-iterations <n>', 'Stop after n completed run attempts').option('--token-budget <n>', 'Set a soft Goal token budget; new Goals use uncached accounting and the final turn can overshoot').option('--token-reserve <n>', 'Require more than n tokens under the Goal accounting basis before starting another turn').option('--model <provider/model>', 'Runtime model override, for example openai/gpt-5').option('--thinking <level>', 'Runtime thinking level override: off, minimal, low, medium, high, xhigh, max').option('--fast', 'Enable runtime fast mode').option('--no-fast', 'Disable runtime fast mode')
         .option('--start', 'Start immediately').option('--json', 'Print JSON').action((options) => { const base = templatePatch(options.template); const prompt = options.prompt ?? base.prompt; if (typeof prompt !== 'string' || !prompt.trim())
         throw new Error('Choose --template <id> or provide --prompt <text>'); const input = { mode: loopMode(options.mode) ?? base.mode ?? defaults.mode ?? 'goal', name: options.name ?? base.name, description: options.description ?? base.description, enabled: options.start === true, target: targetFromOptions(options), profile: options.profile, prompt, maxIterations: options.maxIterations !== undefined ? maxIterations(options.maxIterations) : typeof base.maxIterations === 'number' ? base.maxIterations : undefined, tokenBudget: tokenBudget(options.tokenBudget), tokenReserve: tokenReserve(options.tokenReserve), stopPolicy: base.stopPolicy ?? undefined }; applyRuntimeCreateOptions(input, options); const store = createDefaultPiboLoopStore({ path: program.opts().store }); const job = store.createJob(input); if (options.json)
         printJson(job);
     else
         console.log(`${job.id}\t${job.enabled ? 'running' : 'stopped'}\t${job.name}`); store.close(); });
-    program.command('edit').argument('<id>', defaults.mode === 'ralph' ? 'Ralph job id' : 'Loop job id').description(defaults.mode === 'ralph' ? 'Update a Ralph job' : 'Update a Loop job').option('--template <id>', 'Apply a built-in job template before explicit overrides').option('--mode <mode>', 'Set loop mode: goal or ralph').option('--prompt <text>', 'Task prompt').option('--name <name>', 'Job name').option('--description <text>', 'Job description').option('--profile <profile>', 'Agent profile').option('--room <room-id>', 'Target room id').option('--default-chat', 'Target the shared default chat').option('--max-iterations <n>', 'Stop after n completed run attempts').option('--token-budget <n>', 'Set soft Goal token budget').option('--clear-token-budget', 'Clear Goal token budget').option('--token-reserve <n>', 'Set pre-turn minimum remaining tokens').option('--clear-token-reserve', 'Clear Goal token reserve').option('--model <provider/model>', 'Set runtime model override, for example openai/gpt-5').option('--clear-model', 'Clear runtime model override').option('--thinking <level>', 'Set runtime thinking level override: off, minimal, low, medium, high, xhigh, max').option('--clear-thinking', 'Clear runtime thinking level override').option('--fast', 'Enable runtime fast mode').option('--no-fast', 'Disable runtime fast mode').option('--clear-fast', 'Clear runtime fast mode override').option('--json', 'Print JSON').action((id, options) => { const store = createDefaultPiboLoopStore({ path: program.opts().store }); const patch = { ...templatePatch(options.template) }; if (options.mode !== undefined)
+    program.command('edit').argument('<id>', defaults.mode === 'ralph' ? 'Ralph job id' : 'Loop job id').description(defaults.mode === 'ralph' ? 'Update a Ralph job' : 'Update a Loop job').option('--template <id>', 'Apply a built-in job template before explicit overrides').option('--mode <mode>', 'Set loop mode: goal or ralph').option('--prompt <text>', 'Task prompt').option('--name <name>', 'Job name').option('--description <text>', 'Job description').option('--profile <profile>', 'Agent profile').option('--room <room-id>', 'Target room id').option('--default-chat', 'Target the shared default chat').option('--max-iterations <n>', 'Stop after n completed run attempts').option('--token-budget <n>', "Set the soft Goal token budget under the job's persisted accounting basis").option('--clear-token-budget', 'Clear Goal token budget').option('--token-reserve <n>', "Set the pre-turn minimum remaining tokens under the job's persisted accounting basis").option('--clear-token-reserve', 'Clear Goal token reserve').option('--model <provider/model>', 'Set runtime model override, for example openai/gpt-5').option('--clear-model', 'Clear runtime model override').option('--thinking <level>', 'Set runtime thinking level override: off, minimal, low, medium, high, xhigh, max').option('--clear-thinking', 'Clear runtime thinking level override').option('--fast', 'Enable runtime fast mode').option('--no-fast', 'Disable runtime fast mode').option('--clear-fast', 'Clear runtime fast mode override').option('--json', 'Print JSON').action((id, options) => { const store = createDefaultPiboLoopStore({ path: program.opts().store }); const patch = { ...templatePatch(options.template) }; if (options.mode !== undefined)
         patch.mode = loopMode(options.mode); if (options.name !== undefined)
         patch.name = options.name; if (options.description !== undefined)
         patch.description = options.description; if (options.profile !== undefined)

package/dist/loops/prompts.js

@@ -1,3 +1,4 @@
+import { goalTokenAccounting } from './accounting.js';
 const completionMarkerInstruction = 'When and only when the full objective is proven complete, end with the XML completion marker on its own line. Compose it from the opening tag <promise>, the word COMPLETE, and the closing tag </promise>. Do not quote, negate, explain, or mention the literal marker before completion.';
 export function buildLoopTurnPrompt(job, continuation, goalToolsAvailable = true) {
     if (job.mode === 'ralph')
@@ -22,6 +23,11 @@ function buildGoalTurnPrompt(job, continuation, goalToolsAvailable) {
     const tokenBudget = job.tokenBudget;
     const remainingTokens = tokenBudget === undefined ? 'unbounded' : String(Math.max(0, tokenBudget - tokensUsed));
     const tokenReserve = job.tokenReserve ?? 0;
+    const tokenAccounting = goalTokenAccounting(job);
+    const tokenBasis = tokenAccounting.basis === 'uncached' ? 'uncached' : 'total';
+    const accountingPolicy = tokenAccounting.basis === 'uncached'
+        ? '- Cache-read and cache-write tokens do not consume the budget.'
+        : '- Legacy compatibility: cache-read and cache-write tokens remain included because prior persisted counters cannot be reconstructed safely.';
     return [
         continuation ? 'Continue working toward the active Pibo loop goal.' : 'Start working toward the active Pibo loop goal.',
         '',
@@ -37,11 +43,13 @@ function buildGoalTurnPrompt(job, continuation, goalToolsAvailable) {
         '- Temporary rough edges are acceptable while work moves toward the requested end state. Completion still requires the requested end state to be true and verified.',
         '',
         'Budget:',
-        '- Budget enforcement: soft; model usage is reported after a response and the current turn can overshoot the limit.',
-        `- Reported tokens used before this turn: ${tokensUsed}`,
-        `- Soft token budget: ${tokenBudget ?? 'none'}`,
-        `- Pre-turn token reserve: ${tokenReserve}`,
-        `- Reported tokens remaining before this turn: ${remainingTokens}`,
+        `- Accounting basis: ${tokenBasis} tokens (version ${tokenAccounting.version}).`,
+        `- Budget enforcement: soft; ${tokenBasis} model usage is reported after a response and the current turn can overshoot the limit.`,
+        accountingPolicy,
+        `- Reported ${tokenBasis} tokens used before this turn: ${tokensUsed}`,
+        `- Soft ${tokenBasis} token budget: ${tokenBudget ?? 'none'}`,
+        `- Pre-turn ${tokenBasis} token reserve: ${tokenReserve}`,
+        `- Reported ${tokenBasis} tokens remaining before this turn: ${remainingTokens}`,
         '',
         'Work from evidence:',
         'Use the current workspace, repository, runtime, and external state as authoritative. Previous conversation context can help locate relevant work, but inspect current state before relying on it. Improve, replace, or remove existing work as needed to satisfy the actual objective.',

package/dist/loops/service.js

@@ -6,6 +6,7 @@ import { PiboDataStore } from '../data/pibo-store.js';
 import { ChatRoomService } from '../apps/chat/data/room-service.js';
 import { isPiboRoomArchived } from '../apps/chat/types/rooms.js';
 import { acquireBrowserPoolLease, browserPoolPaths, releaseBrowserPoolLease, restartRecordedBrowserPoolChrome } from '../tools/browser-pool.js';
+import { goalBudgetTokens, goalTokenAccounting } from './accounting.js';
 import { createDefaultPiboLoopStore } from './store.js';
 import { createBuiltInLoopStopConditions, evaluateLoopStopPolicy } from './stopping.js';
 import { buildLoopTurnPrompt } from './prompts.js';
@@ -536,7 +537,8 @@ export class PiboLoopService {
         const job = this.store.getJob(run.jobId);
         if (!job || job.mode !== 'goal')
             return;
-        this.store.recordGoalTurnUsage(job.id, run.id, event.totalTokens);
+        const basis = run.accounting?.tokenAccounting?.basis ?? goalTokenAccounting(job).basis;
+        this.store.recordGoalTurnUsage(job.id, run.id, goalBudgetTokens(event, basis));
     }
     handleProductEvent(event) {
         if (event.type !== 'pibo.loop.fact' && event.type !== 'loop.fact' && event.type !== 'pibo.ralph.fact' && event.type !== 'ralph.fact')

package/dist/loops/store.js

@@ -4,6 +4,7 @@ import { dirname, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { piboHomePath } from '../core/pibo-home.js';
 import { isPiboThinkingLevel } from '../core/thinking.js';
+import { newGoalTokenAccounting, normalizeLoopTokenAccounting } from './accounting.js';
 function nowIso(now = new Date()) { return now.toISOString(); }
 function parseJson(json) { return JSON.parse(json); }
 function defaultName(prompt) { const normalized = prompt.replace(/\s+/g, ' ').trim(); return normalized ? normalized.slice(0, 80) : 'Loop job'; }
@@ -80,7 +81,9 @@ function parseRunAccounting(json) {
         return undefined;
     try {
         const value = JSON.parse(json);
-        return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? { ...value, tokenAccounting: normalizeLoopTokenAccounting(value.tokenAccounting) }
+            : undefined;
     }
     catch {
         return undefined;
@@ -104,7 +107,7 @@ function normalizeJobState(state, mode, enabled, createdAt) {
         return state;
     const activeTimeSeconds = Math.max(0, Math.floor(state.activeTimeSeconds ?? state.timeUsedSeconds ?? 0));
     const goalStartedAt = state.goalStartedAt ?? (enabled || (state.completedIterations ?? 0) > 0 || (state.tokensUsed ?? 0) > 0 || (state.goalStatus !== undefined && state.goalStatus !== 'paused') ? createdAt : undefined);
-    const normalized = { ...state, activeTimeSeconds, ...(goalStartedAt ? { goalStartedAt } : {}) };
+    const normalized = { ...state, tokenAccounting: normalizeLoopTokenAccounting(state.tokenAccounting), activeTimeSeconds, ...(goalStartedAt ? { goalStartedAt } : {}) };
     delete normalized.timeUsedSeconds;
     return normalized;
 }
@@ -296,7 +299,7 @@ export class PiboLoopStore {
         const enabled = input.enabled === true;
         const state = {
             completedIterations: 0,
-            ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: timestamp } : {}) } : {}),
+            ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokenAccounting: newGoalTokenAccounting(), tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: timestamp } : {}) } : {}),
             ...(input.initialPiboSessionId?.trim() ? { lastPiboSessionId: input.initialPiboSessionId.trim() } : {}),
         };
         const job = { id: mode === 'ralph' ? `ralph_${randomUUID()}` : `loop_${randomUUID()}`, mode, name: (input.name ?? defaultName(input.prompt)).trim(), description: input.description?.trim() || undefined, enabled, target, profile: input.profile, prompt: input.prompt, maxIterations: normalizeMaxIterations(input.maxIterations), tokenBudget: normalizeTokenBudget(input.tokenBudget), tokenReserve: normalizeTokenReserve(input.tokenReserve), stopPolicy: normalizeLoopStopPolicy(input.stopPolicy), ...runtimeOptions, ...(resources ? { resources } : {}), state, createdAt: timestamp, updatedAt: timestamp };
@@ -422,7 +425,7 @@ export class PiboLoopStore {
             if (job?.mode === 'goal') {
                 const row = this.db.prepare('SELECT * FROM pibo_ralph_runs WHERE id = ? AND job_id = ?').get(runId, id);
                 if (row) {
-                    const accounting = parseRunAccounting(row.accounting_json) ?? {};
+                    const accounting = parseRunAccounting(row.accounting_json) ?? { tokenAccounting: normalizeLoopTokenAccounting(job.state.tokenAccounting) };
                     const turnTokens = (accounting.tokensUsed ?? 0) + Math.max(0, Math.floor(tokens));
                     const budget = accounting.tokenBudget;
                     const before = accounting.tokensUsedBefore ?? 0;
@@ -446,7 +449,7 @@ export class PiboLoopStore {
             if (job?.mode === 'goal') {
                 const row = this.db.prepare('SELECT * FROM pibo_ralph_runs WHERE id = ? AND job_id = ?').get(runId, id);
                 if (row) {
-                    const accounting = { ...(parseRunAccounting(row.accounting_json) ?? {}), activeTimeSeconds: seconds };
+                    const accounting = { ...(parseRunAccounting(row.accounting_json) ?? { tokenAccounting: normalizeLoopTokenAccounting(job.state.tokenAccounting) }), activeTimeSeconds: seconds };
                     this.db.prepare('UPDATE pibo_ralph_runs SET accounting_json = ?, updated_at = ? WHERE id = ?').run(runAccountingJson(accounting), nowIso(now), runId);
                 }
             }
@@ -481,7 +484,7 @@ export class PiboLoopStore {
         const enabled = patch.enabled ?? existing.enabled;
         let state = mode === existing.mode
             ? { ...existing.state }
-            : { completedIterations: existing.state.completedIterations ?? 0, ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: nowIso(now) } : {}) } : {}) };
+            : { completedIterations: existing.state.completedIterations ?? 0, ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokenAccounting: newGoalTokenAccounting(), tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: nowIso(now) } : {}) } : {}) };
         if (mode === 'goal' && patch.enabled !== undefined) {
             const currentGoalStatus = goalStatus({ mode, enabled: existing.enabled, state: existing.state }) ?? 'paused';
             if (patch.enabled) {
@@ -807,6 +810,7 @@ export class PiboLoopStore {
     createRunLocked(job, timestamp) {
         const tokensUsedBefore = job.state.tokensUsed ?? 0;
         const accounting = job.mode === 'goal' ? {
+            tokenAccounting: normalizeLoopTokenAccounting(job.state.tokenAccounting),
             ...(job.tokenBudget !== undefined ? { tokenBudget: job.tokenBudget, remainingTokensBefore: Math.max(0, job.tokenBudget - tokensUsedBefore) } : {}),
             ...(job.tokenReserve !== undefined ? { tokenReserve: job.tokenReserve } : {}),
             tokensUsedBefore,

package/dist/loops/tools.js

@@ -1,7 +1,7 @@
 import { Type } from "typebox";
 import { piboStringEnum } from "../tools/schema.js";
 import { definePiboTool } from "../tools/contract.js";
-import { goalActiveTimeSeconds, goalCanStartNextTurn, goalElapsedWallClockSeconds, goalRemainingTokens } from './accounting.js';
+import { goalActiveTimeSeconds, goalCanStartNextTurn, goalElapsedWallClockSeconds, goalRemainingTokens, goalTokenAccounting } from './accounting.js';
 import { createDefaultPiboLoopStore } from './store.js';
 export const PIBO_GOAL_TOOL_NAMES = ['get_goal', 'create_goal', 'update_goal'];
 let configuredStorePath;
@@ -68,11 +68,13 @@ function nonNegativeInteger(value, field) {
 }
 function goalPayload(job) {
     const tokenBudget = job.tokenBudget;
+    const tokenAccounting = goalTokenAccounting(job);
     return {
         goalId: job.id,
         objective: job.prompt,
         status: effectiveGoalStatus(job),
         budgetType: tokenBudget === undefined ? 'unbounded' : 'soft',
+        tokenAccounting,
         tokenBudget: tokenBudget ?? null,
         tokenReserve: job.tokenReserve ?? 0,
         tokensUsed: job.state.tokensUsed ?? 0,
@@ -130,8 +132,8 @@ function createCreateGoalTool(context, options) {
         promptSnippet: 'Call create_goal only when the user or system explicitly requests a persistent goal. Do not infer a goal from an ordinary task.',
         inputSchema: Type.Object({
             objective: Type.String({ description: 'Concrete objective to pursue across automatic continuations.' }),
-            token_budget: Type.Optional(Type.Number({ description: 'Optional soft token budget. Usage arrives after each model response, so the final turn can overshoot.' })),
-            token_reserve: Type.Optional(Type.Number({ description: 'Optional non-negative minimum remaining tokens required before Pibo starts another turn.' })),
+            token_budget: Type.Optional(Type.Number({ description: 'Optional soft uncached-token budget. Cache reads and writes are excluded. Usage arrives after each model response, so the final turn can overshoot.' })),
+            token_reserve: Type.Optional(Type.Number({ description: 'Optional non-negative minimum remaining uncached tokens required before Pibo starts another turn.' })),
         }),
         async execute(_toolCallId, params) {
             try {
@@ -182,11 +184,12 @@ function createUpdateGoalTool(context, options) {
                     const job = store.updateGoalStatus(existing.id, status);
                     if (!job)
                         throw new Error('goal no longer exists');
+                    const tokenBasis = goalTokenAccounting(job).basis;
                     return toolResult({
                         ok: true,
                         goal: goalPayload(job),
                         ...(status === 'complete' && job.tokenBudget !== undefined
-                            ? { completionBudgetReport: `${job.state.tokensUsed ?? 0}/${job.tokenBudget} reported tokens consumed against a soft budget before the current model turn finishes` }
+                            ? { completionBudgetReport: `${job.state.tokensUsed ?? 0}/${job.tokenBudget} reported ${tokenBasis} tokens consumed against a soft budget before the current model turn finishes` }
                             : {}),
                     });
                 });

package/dist/mcp/config-command.js

@@ -36,8 +36,9 @@ MCP config lookup order:
   1. -c/--config <path>
   2. MCP_CONFIG_PATH
   3. ./mcp_servers.json
-  4. ~/.mcp_servers.json
-  5. ~/.config/mcp/mcp_servers.json
+  4. ~/mcp_servers.json
+  5. ~/.mcp_servers.json
+  6. ~/.config/mcp/mcp_servers.json
 `);
 }
 export function printConfigSchema() {

package/dist/mcp/config.js

@@ -5,7 +5,7 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { ErrorCode, configInvalidJsonError, configMissingFieldError, configNotFoundError, configSearchError, formatCliError, serverNotFoundError, } from './errors.js';
 export const DEFAULT_MCP_CONFIG_FILE = 'mcp_servers.json';
 // ============================================================================
@@ -306,9 +306,15 @@ export function getDefaultConfigPaths() {
     const home = homedir();
     // Current directory
     paths.push(resolve(DEFAULT_MCP_CONFIG_FILE));
-    // Home directory variants
-    paths.push(join(home, '.mcp_servers.json'));
-    paths.push(join(home, '.config', 'mcp', 'mcp_servers.json'));
+    // Home directory variants. Include the non-dot filename because `pibo mcp
+    // config` creates it when invoked from the home directory, and services can
+    // later run with a different working directory. Ignore empty or relative
+    // platform home values instead of treating them as paths below the cwd.
+    if (home && isAbsolute(home)) {
+        paths.push(join(home, DEFAULT_MCP_CONFIG_FILE));
+        paths.push(join(home, '.mcp_servers.json'));
+        paths.push(join(home, '.config', 'mcp', 'mcp_servers.json'));
+    }
     return paths;
 }
 export function getConfigSearchPaths(explicitPath) {

package/dist/mcp/errors.js

@@ -24,7 +24,7 @@ export function configSearchError() {
         code: ErrorCode.CLIENT_ERROR,
         type: 'CONFIG_NOT_FOUND',
         message: 'No mcp_servers.json found in search paths',
-        details: 'Searched: ./mcp_servers.json, ~/.mcp_servers.json, ~/.config/mcp/mcp_servers.json',
+        details: 'Searched: ./mcp_servers.json, ~/mcp_servers.json, ~/.mcp_servers.json, ~/.config/mcp/mcp_servers.json',
         suggestion: 'Create mcp_servers.json in current directory or use -c/--config to specify path',
     };
 }