praxis-agent 0.20.3 → 0.20.4

package/dist/application/session-cost-tracker.d.ts

@@ -1,5 +1,5 @@
 import type { ModelUsage } from '../core/runtime.js';
-import type { ClaudeSessionCostState } from '../persistence/claude-cost-state-store.js';
+import type { ClaudeSessionCostState, ClaudeStoredModelCostUsage } from '../persistence/claude-cost-state-store.js';
 export interface ClaudeSessionCostTrackerOptions {
     readonly sessionId: string;
     readonly restored?: ClaudeSessionCostState | null;
@@ -25,7 +25,16 @@ export interface ClaudeSessionDurationsInput {
     readonly apiDurationWithoutRetriesMs?: number;
     readonly toolDurationMs?: number;
 }
-export interface ClaudeSessionCostSnapshot extends ClaudeSessionCostState {
+export interface ClaudeSessionCostSnapshot {
+    readonly sessionId: string;
+    readonly totalCostUsd: number;
+    readonly apiDurationMs: number;
+    readonly apiDurationWithoutRetriesMs: number;
+    readonly toolDurationMs: number;
+    readonly wallDurationMs: number;
+    readonly linesAdded: number;
+    readonly linesRemoved: number;
+    readonly modelUsage: Readonly<Record<string, ClaudeStoredModelCostUsage>>;
     readonly hasUnknownModelCost: boolean;
 }
 export declare class ClaudeSessionCostTracker {

package/dist/application/session-cost-tracker.js

@@ -71,6 +71,7 @@ export class ClaudeSessionCostTracker {
         this.toolDurationMs = restored.toolDurationMs;
         this.linesAdded = restored.linesAdded;
         this.linesRemoved = restored.linesRemoved;
+        this.hasUnknownModelCost = restored.hasUnknownModelCost === true;
         for (const [model, usage] of Object.entries(restored.modelUsage)) {
             this.modelUsage.set(model, {
                 inputTokens: usage.inputTokens,

package/dist/cli.js

@@ -776,6 +776,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     const costStateStore = new ClaudeCostStateStore({
         statePath: claudeStatePath,
         projectIdentity: await resolveClaudeProjectIdentity({ cwd }),
+        sidecarPath: join(configRoot, 'praxis', 'unknown-cost-sidecar.json'),
     });
     const options = {
         configRoot,

package/dist/persistence/claude-cost-state-store.d.ts

@@ -16,11 +16,14 @@ export interface ClaudeSessionCostState {
     readonly linesAdded: number;
     readonly linesRemoved: number;
     readonly modelUsage: Readonly<Record<string, ClaudeStoredModelCostUsage>>;
+    readonly hasUnknownModelCost?: boolean;
 }
 export interface ClaudeCostStateStoreOptions {
     statePath: string;
     projectIdentity: string;
     lockFile?: string;
+    sidecarPath?: string;
+    sidecarLockFile?: string;
 }
 export interface ClaudeCostStateSaveHooks {
     readonly afterValidation?: () => Promise<void>;
@@ -30,6 +33,7 @@ export declare class ClaudeCostStateStore {
     readonly projectIdentity: string;
     readonly lockFile: string;
     private readonly lease;
+    private readonly sidecar;
     constructor(options: ClaudeCostStateStoreOptions);
     load(sessionId: string): Promise<ClaudeSessionCostState | null>;
     save(state: ClaudeSessionCostState, hooks?: ClaudeCostStateSaveHooks): Promise<void>;

package/dist/persistence/claude-cost-state-store.js

@@ -5,6 +5,7 @@ import { dirname, join } from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { writeFileAtomically } from '../platform/atomic-write.js';
 import { ExclusiveFileLease } from '../platform/exclusive-file-lease.js';
+import { UnknownCostSidecar } from './unknown-cost-sidecar.js';
 function isErrnoException(err) {
     return (typeof err === 'object' &&
         err !== null &&
@@ -64,6 +65,7 @@ export class ClaudeCostStateStore {
     projectIdentity;
     lockFile;
     lease;
+    sidecar;
     constructor(options) {
         assertNonBlank(options.statePath, 'statePath');
         assertNonBlank(options.projectIdentity, 'projectIdentity');
@@ -73,6 +75,15 @@ export class ClaudeCostStateStore {
             options.lockFile ??
                 join(dirname(options.statePath), '.praxis-claude-state.lock');
         this.lease = new ExclusiveFileLease(this.lockFile);
+        this.sidecar =
+            options.sidecarPath === undefined
+                ? null
+                : new UnknownCostSidecar({
+                    sidecarPath: options.sidecarPath,
+                    ...(options.sidecarLockFile === undefined
+                        ? {}
+                        : { lockFile: options.sidecarLockFile }),
+                });
     }
     async load(sessionId) {
         assertNonBlank(sessionId, 'sessionId');
@@ -80,7 +91,14 @@ export class ClaudeCostStateStore {
         if (content === null) {
             return null;
         }
-        return this.restoreMatchingSession(content, sessionId);
+        const native = this.restoreMatchingSession(content, sessionId);
+        if (native === null) {
+            return null;
+        }
+        const hasUnknownModelCost = this.sidecar
+            ? await this.sidecar.readFlag(sessionId)
+            : false;
+        return { ...native, hasUnknownModelCost };
     }
     async save(state, hooks = {}) {
         this.validateState(state);
@@ -92,6 +110,7 @@ export class ClaudeCostStateStore {
         finally {
             await handle.release();
         }
+        await this.sidecar?.writeFlag(state.sessionId, state.hasUnknownModelCost ?? false);
     }
     async readStateFile() {
         let handle;
@@ -161,6 +180,10 @@ export class ClaudeCostStateStore {
         requireMetric(state.wallDurationMs, 'wallDurationMs');
         requireCounter(state.linesAdded, 'linesAdded');
         requireCounter(state.linesRemoved, 'linesRemoved');
+        if (state.hasUnknownModelCost !== undefined &&
+            typeof state.hasUnknownModelCost !== 'boolean') {
+            throw new TypeError('hasUnknownModelCost must be a boolean');
+        }
         const rawUsage = requireObject(state.modelUsage, 'modelUsage');
         for (const [modelKey, rawValue] of Object.entries(rawUsage)) {
             assertNonBlank(modelKey, `modelUsage.${modelKey}`);

package/dist/persistence/unknown-cost-sidecar.d.ts

@@ -0,0 +1,23 @@
+export interface UnknownCostSidecarOptions {
+    sidecarPath: string;
+    lockFile?: string;
+}
+/**
+ * Praxis-private sidecar for the `/cost` unknown-model flag. The native
+ * `.claude.json` project record must stay Claude-compatible, so this flag lives
+ * in a disposable JSON document keyed by session ID. Reads fail closed to
+ * `false` when the sidecar is missing or malformed.
+ */
+export declare class UnknownCostSidecar {
+    private readonly sidecarPath;
+    private readonly lockFile;
+    private readonly lease;
+    constructor(options: UnknownCostSidecarOptions);
+    readFlag(sessionId: string): Promise<boolean>;
+    writeFlag(sessionId: string, flag: boolean): Promise<void>;
+    private readDocument;
+    private readContent;
+    private parseDocument;
+    private acquireLease;
+}
+//# sourceMappingURL=unknown-cost-sidecar.d.ts.map

package/dist/persistence/unknown-cost-sidecar.js

@@ -0,0 +1,125 @@
+import { constants } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { writeFileAtomically } from '../platform/atomic-write.js';
+import { ExclusiveFileLease } from '../platform/exclusive-file-lease.js';
+const SIDECAR_VERSION = 1;
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertNonBlank(value, field) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new TypeError(`${field} must not be blank`);
+    }
+}
+function emptyDocument() {
+    return { version: SIDECAR_VERSION, sessions: {} };
+}
+/**
+ * Praxis-private sidecar for the `/cost` unknown-model flag. The native
+ * `.claude.json` project record must stay Claude-compatible, so this flag lives
+ * in a disposable JSON document keyed by session ID. Reads fail closed to
+ * `false` when the sidecar is missing or malformed.
+ */
+export class UnknownCostSidecar {
+    sidecarPath;
+    lockFile;
+    lease;
+    constructor(options) {
+        assertNonBlank(options.sidecarPath, 'sidecarPath');
+        this.sidecarPath = options.sidecarPath;
+        this.lockFile =
+            options.lockFile ??
+                join(dirname(options.sidecarPath), 'locks', 'unknown-cost-sidecar.lock');
+        this.lease = new ExclusiveFileLease(this.lockFile);
+    }
+    async readFlag(sessionId) {
+        assertNonBlank(sessionId, 'sessionId');
+        const document = await this.readDocument();
+        if (document === null)
+            return false;
+        return document.sessions[sessionId]?.hasUnknownModelCost === true;
+    }
+    async writeFlag(sessionId, flag) {
+        assertNonBlank(sessionId, 'sessionId');
+        if (typeof flag !== 'boolean') {
+            throw new TypeError('flag must be a boolean');
+        }
+        const handle = await this.acquireLease();
+        try {
+            const document = (await this.readDocument()) ?? emptyDocument();
+            const sessions = {
+                ...document.sessions,
+                [sessionId]: { hasUnknownModelCost: flag },
+            };
+            const content = `${JSON.stringify({ version: SIDECAR_VERSION, sessions }, null, 2)}\n`;
+            await writeFileAtomically(this.sidecarPath, content, { mode: 0o600 });
+        }
+        finally {
+            await handle.release();
+        }
+    }
+    async readDocument() {
+        const content = await this.readContent();
+        if (content === null)
+            return null;
+        return this.parseDocument(content);
+    }
+    async readContent() {
+        let handle;
+        try {
+            handle = await open(this.sidecarPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        }
+        catch {
+            return null;
+        }
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile())
+                return null;
+            return await handle.readFile('utf8');
+        }
+        catch {
+            return null;
+        }
+        finally {
+            await handle.close().catch(() => undefined);
+        }
+    }
+    parseDocument(content) {
+        let root;
+        try {
+            root = JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+        if (!isObject(root) || root.version !== SIDECAR_VERSION)
+            return null;
+        const rawSessions = root.sessions;
+        if (!isObject(rawSessions))
+            return null;
+        const sessions = {};
+        for (const [sessionId, value] of Object.entries(rawSessions)) {
+            if (sessionId.trim() === '')
+                return null;
+            if (!isObject(value))
+                return null;
+            if (typeof value.hasUnknownModelCost !== 'boolean')
+                return null;
+            sessions[sessionId] = { hasUnknownModelCost: value.hasUnknownModelCost };
+        }
+        return { version: SIDECAR_VERSION, sessions };
+    }
+    async acquireLease() {
+        for (let attempt = 0; attempt < 400; attempt += 1) {
+            const handle = await this.lease.tryAcquire();
+            if (handle)
+                return handle;
+            await sleep(5);
+        }
+        throw new Error(`Timed out acquiring unknown-cost sidecar lock for ${this.sidecarPath}`);
+    }
+}
+//# sourceMappingURL=unknown-cost-sidecar.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.20.3",
+  "version": "0.20.4",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",