praxis-agent 0.46.4 → 0.47.0

package/dist/evals/project-eval.js

@@ -0,0 +1,214 @@
+import { join, relative, resolve } from 'node:path';
+import { writeFileAtomically } from '../platform/atomic-write.js';
+import { runProjectEvalCase, } from './project-eval-runner.js';
+import { discoverProjectEvalCases } from './project-eval-schema.js';
+export const PROJECT_EVAL_HELP = `Usage: praxis eval [options] <target>
+
+Run deterministic project outcome evaluations in isolated workspaces.
+
+Options:
+  --case <glob>          Filter case names
+  --tag <tag[,tag]>      Filter tags; repeatable
+  --runs <1..50>         Override run count
+  --model <model>        Override model
+  --allow-tools <rules>  Grant gated tools; comma-separated and repeatable
+  --run-verification     Enable verifier subprocesses
+  --output-dir <dir>     Write artifacts to this directory
+  --keep-temp            Preserve temporary workspaces
+  --json                 Print exactly one aggregate JSON value
+  --verbose              Print run progress to stderr
+  -h, --help             Display help`;
+function takeValue(argv, index, option) {
+    const value = argv[index + 1];
+    if (!value || value.startsWith('-'))
+        throw new Error(`${option} requires a value`);
+    return value;
+}
+function listValues(value, option) {
+    const values = value.split(',').map((item) => item.trim());
+    if (values.some((item) => item.length === 0))
+        throw new Error(`${option} contains an empty value`);
+    return values;
+}
+export function parseProjectEvalOptions(argv) {
+    const options = {
+        tags: [],
+        allowTools: [],
+        runVerification: false,
+        keepTemp: false,
+        json: false,
+        verbose: false,
+    };
+    const operands = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (!value)
+            continue;
+        if (value === '-h' || value === '--help')
+            return { ...options, help: true };
+        if (value === '--run-verification')
+            options.runVerification = true;
+        else if (value === '--keep-temp')
+            options.keepTemp = true;
+        else if (value === '--json')
+            options.json = true;
+        else if (value === '--verbose')
+            options.verbose = true;
+        else if (value === '--case' ||
+            value === '--model' ||
+            value === '--output-dir' ||
+            value === '--runs' ||
+            value === '--tag' ||
+            value === '--allow-tools') {
+            const selected = takeValue(argv, index, value);
+            index += 1;
+            if (value === '--case')
+                options.caseGlob = selected;
+            else if (value === '--model')
+                options.model = selected;
+            else if (value === '--output-dir')
+                options.outputDir = selected;
+            else if (value === '--runs') {
+                const runs = Number(selected);
+                if (!Number.isInteger(runs) || runs < 1 || runs > 50)
+                    throw new Error('--runs must be an integer from 1 to 50');
+                options.runs = runs;
+            }
+            else if (value === '--tag')
+                options.tags.push(...listValues(selected, value));
+            else
+                options.allowTools.push(...listValues(selected, value));
+        }
+        else if (value.startsWith('-'))
+            throw new Error(`Unknown eval option: ${value}`);
+        else
+            operands.push(value);
+    }
+    if (operands.length !== 1)
+        throw new Error('eval requires one target');
+    const target = operands[0];
+    if (!target)
+        throw new Error('eval requires one target');
+    options.target = target;
+    return options;
+}
+function aggregateUsage(results) {
+    const totals = {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        web_search_requests: 0,
+    };
+    for (const result of results) {
+        if (!result.usage)
+            continue;
+        totals.input_tokens += result.usage.inputTokens;
+        totals.output_tokens += result.usage.outputTokens;
+        totals.cache_read_input_tokens += result.usage.cacheReadInputTokens ?? 0;
+        totals.cache_creation_input_tokens +=
+            result.usage.cacheCreationInputTokens ?? 0;
+        totals.web_search_requests += result.usage.webSearchRequests ?? 0;
+    }
+    return totals;
+}
+function runSummary(result, outputDirectory) {
+    return {
+        case: result.case,
+        run: result.run,
+        model: result.model,
+        passed: result.passed,
+        score: result.score,
+        turns: result.turns,
+        usage: result.usage,
+        cost_usd: result.cost_usd,
+        cost_known: result.cost_known,
+        duration_ms: result.duration_ms,
+        termination: result.termination,
+        error: result.error,
+        artifact_dir: relative(outputDirectory, join(outputDirectory, result.case, `run-${result.run}`)).replaceAll('\\', '/'),
+    };
+}
+export async function executeProjectEvalCommand(argv, io, dependencies, callerCwd = process.cwd(), signal) {
+    const options = parseProjectEvalOptions(argv);
+    if (options.help) {
+        io.stdout(PROJECT_EVAL_HELP);
+        return 0;
+    }
+    if (!options.target)
+        throw new Error('eval requires one target');
+    const target = resolve(callerCwd, options.target);
+    const cases = await discoverProjectEvalCases(target, options.caseGlob, options.tags);
+    const outputDirectory = options.outputDir
+        ? resolve(callerCwd, options.outputDir)
+        : join(dependencies.configRoot, 'evals', 'results', new Date().toISOString().replaceAll(':', '-'));
+    const plannedRunCount = cases.reduce((total, definition) => total + (options.runs ?? definition.runs), 0);
+    const results = [];
+    const started = Date.now();
+    let interrupted = signal?.aborted ?? false;
+    runs: for (const definition of cases) {
+        for (let runIndex = 1; runIndex <= (options.runs ?? definition.runs); runIndex += 1) {
+            if (signal?.aborted) {
+                interrupted = true;
+                break runs;
+            }
+            const result = await runProjectEvalCase({
+                case: definition,
+                factory: dependencies.runtimeFactory,
+                run: runIndex,
+                allowTools: options.allowTools,
+                ...(options.model === undefined ? {} : { model: options.model }),
+                keepTemp: options.keepTemp,
+                runVerification: options.runVerification,
+                outputDir: outputDirectory,
+                version: dependencies.version ?? 'unknown',
+                ...(signal === undefined ? {} : { signal }),
+            });
+            results.push(result);
+            if (options.verbose)
+                io.stderr(`${definition.name} run ${runIndex}: ${result.passed ? 'passed' : 'failed'}\n`);
+            if (signal?.aborted || result.termination === 'interrupted') {
+                interrupted = true;
+                break runs;
+            }
+        }
+    }
+    const passed = results.filter((result) => result.passed).length;
+    const knownCostResults = results.filter((result) => result.cost_known);
+    const aggregate = {
+        schema_version: '1.0',
+        version: dependencies.version ?? 'unknown',
+        start: new Date(started).toISOString(),
+        duration_ms: Date.now() - started,
+        target,
+        output_dir: outputDirectory,
+        model: options.model ?? null,
+        case_count: cases.length,
+        planned_run_count: plannedRunCount,
+        completed_run_count: results.length,
+        run_count: results.length,
+        passed,
+        failed: results.length - passed,
+        pass_rate: results.length === 0 ? 0 : passed / results.length,
+        total_turns: results.reduce((total, result) => total + result.turns, 0),
+        usage_totals: aggregateUsage(results),
+        usage_known_runs: results.filter((result) => result.usage !== null).length,
+        usage_unknown_runs: results.filter((result) => result.usage === null)
+            .length,
+        known_cost_total_usd: knownCostResults.length === 0
+            ? null
+            : knownCostResults.reduce((total, result) => total + (result.cost_usd ?? 0), 0),
+        known_cost_runs: knownCostResults.length,
+        unknown_cost_runs: results.length - knownCostResults.length,
+        partial: interrupted || results.length < plannedRunCount,
+        interrupted,
+        runs: results.map((result) => runSummary(result, outputDirectory)),
+    };
+    await writeFileAtomically(join(outputDirectory, 'aggregate-result.json'), JSON.stringify(aggregate, null, 2));
+    if (options.json)
+        io.stdout(`${JSON.stringify(aggregate)}\n`);
+    else
+        io.stdout(`${passed}/${results.length} passed\n`);
+    return interrupted ? 130 : passed === results.length ? 0 : 1;
+}
+//# sourceMappingURL=project-eval.js.map

package/dist/platform/bounded-process-runner.d.ts

@@ -19,6 +19,8 @@ export interface RunProcessOptions {
     signal?: AbortSignal;
     onOutput?: (output: string) => void | Promise<void>;
     env?: Readonly<Record<string, string>>;
+    inheritEnvironment?: boolean;
+    redactExplicitEnvironment?: boolean;
     controlOutputBytes?: number;
     controlOutputFd?: number;
     scriptInput?: string;

package/dist/platform/bounded-process-runner.js

@@ -84,7 +84,7 @@ export class BoundedProcessRunner {
         if (options.signal?.aborted)
             return Promise.reject(abortError());
         return new Promise((resolve, reject) => {
-            const sensitiveValues = sensitiveEnvironmentValues(process.env);
+            const sensitiveValues = sensitiveEnvironmentValues(process.env, ...(options.redactExplicitEnvironment ? [options.env ?? {}] : []));
             const longestSensitiveValueBytes = sensitiveValues.reduce((longest, value) => Math.max(longest, Buffer.byteLength(value)), 0);
             const rawOutputLimit = this.options.maxOutputBytes + Math.max(3, longestSensitiveValueBytes);
             const controlOutputFd = options.controlOutputBytes === undefined
@@ -108,7 +108,9 @@ export class BoundedProcessRunner {
             const child = spawn(options.command, options.args, {
                 cwd: options.cwd ?? this.options.cwd,
                 detached: process.platform !== 'win32',
-                env: { ...sanitizeChildEnvironment(), ...options.env },
+                env: options.inheritEnvironment === false
+                    ? sanitizeChildEnvironment(options.env ?? {}, {})
+                    : sanitizeChildEnvironment(options.env ?? {}),
                 stdio,
             });
             const chunks = { stdout: [], stderr: [] };

package/dist/plugins/claude-plugin-eval-graders.d.ts

@@ -1,37 +1,6 @@
 import type { ClaudePluginEvalCase } from './claude-plugin-eval-schema.js';
-export interface EvalTraceEvent {
-    type: string;
-    tool?: string;
-    input?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export interface EvalRunArtifacts {
-    lastMessage: string;
-    trace: readonly EvalTraceEvent[];
-    cwd: string;
-}
-export interface EvalGraderResult {
-    name: string;
-    passed: boolean;
-    weight: number;
-    explanation: string;
-    judge_votes?: readonly boolean[];
-    evidence?: string;
-    with_only?: boolean;
-}
-export interface EvalJudge {
-    vote(request: {
-        criteria: string;
-        focus: string;
-        baseline?: string;
-        model: string;
-        signal?: AbortSignal;
-    }): Promise<{
-        passed: boolean;
-        explanation?: string;
-        costUsd: number;
-    }>;
-}
+export type { EvalTraceEvent, EvalRunArtifacts, EvalGraderResult, EvalJudge, } from '../evals/eval-contract.js';
+import type { EvalRunArtifacts, EvalGraderResult, EvalJudge } from '../evals/eval-contract.js';
 export declare function gradeClaudePluginEvalRun(options: {
     case: ClaudePluginEvalCase;
     artifacts: EvalRunArtifacts;

package/dist/plugins/claude-plugin-eval-graders.js

@@ -1,20 +1,6 @@
 import { readFile } from 'node:fs/promises';
-import { minimatch } from 'minimatch';
 import { resolveContainedPath } from './claude-plugin-eval-schema.js';
-function subset(actual, expected) {
-    if (expected && typeof expected === 'object' && !Array.isArray(expected)) {
-        if (!actual || typeof actual !== 'object' || Array.isArray(actual))
-            return false;
-        return Object.entries(expected).every(([key, value]) => subset(actual[key], value));
-    }
-    return Object.is(actual, expected);
-}
-function matches(event, match) {
-    const selected = typeof match === 'string' ? { tool: match } : match;
-    return (event.type === 'tool-call' &&
-        event.tool === selected.tool &&
-        (!selected.input_match || subset(event.input, selected.input_match)));
-}
+import { gradeDeterministicEvalRun } from '../evals/eval-graders.js';
 async function focusText(focus, artifacts) {
     if (focus === 'last_message')
         return artifacts.lastMessage;
@@ -32,56 +18,6 @@ async function focusText(focus, artifacts) {
     }
     return readFile(await resolveContainedPath(artifacts.cwd, focus.path, 'Grader focus'), 'utf8');
 }
-async function freeGrade(grader, artifacts) {
-    let passed = false;
-    let evidence = '';
-    if (grader.type === 'regex') {
-        const target = await focusText(grader.target, artifacts);
-        const expression = new RegExp(grader.pattern, grader.flags.includes('g') ? grader.flags : `${grader.flags}g`);
-        const count = [...target.matchAll(expression)].length;
-        passed =
-            grader.match === 'contains'
-                ? count > 0
-                : grader.match === 'not_contains'
-                    ? count === 0
-                    : count === Number(grader.match.slice(6));
-        evidence = `matches=${count}`;
-    }
-    else if (grader.type === 'tool_used') {
-        const count = artifacts.trace.filter((event) => matches(event, {
-            tool: grader.tool,
-            ...(grader.input_match ? { input_match: grader.input_match } : {}),
-        })).length;
-        passed = count >= grader.min && count <= grader.max;
-        evidence = `uses=${count}`;
-    }
-    else if (grader.type === 'tool_order') {
-        const before = artifacts.trace.findIndex((event) => matches(event, grader.before));
-        const after = artifacts.trace.findIndex((event, index) => index > before && matches(event, grader.after));
-        passed = before >= 0 && after > before;
-        evidence = `before=${before},after=${after}`;
-    }
-    else {
-        const { glob } = await import('node:fs/promises');
-        let count = 0;
-        for await (const path of glob('**/*', { cwd: artifacts.cwd })) {
-            if (!minimatch(path, grader.path))
-                continue;
-            await resolveContainedPath(artifacts.cwd, path, 'file_exists match');
-            count += 1;
-        }
-        passed = grader.exists ? count > 0 : count === 0;
-        evidence = `files=${count}`;
-    }
-    return {
-        name: grader.name,
-        passed,
-        weight: grader.weight,
-        explanation: passed ? 'passed' : 'failed',
-        evidence,
-        ...(grader.arm === 'with-only' ? { with_only: true } : {}),
-    };
-}
 export async function gradeClaudePluginEvalRun(options) {
     const results = [];
     let skippedPaidGraders = false;
@@ -90,7 +26,12 @@ export async function gradeClaudePluginEvalRun(options) {
         if (options.arm === 'without' && item.arm === 'with-only')
             continue;
         if (item.type !== 'llm' && item.type !== 'baseline') {
-            results.push(await freeGrade(item, options.artifacts));
+            const [result] = await gradeDeterministicEvalRun({
+                graders: [item],
+                artifacts: options.artifacts,
+            });
+            if (result)
+                results.push(result);
             continue;
         }
         if (options.skipPaid) {

package/dist/plugins/claude-plugin-eval-runner.d.ts

@@ -1,33 +1,9 @@
-import type { RuntimeEvent } from '../core/runtime.js';
 import type { DataPlane } from '../persistence/data-plane.js';
 import type { ClaudePluginEvalCase } from './claude-plugin-eval-schema.js';
-import type { EvalRunArtifacts } from './claude-plugin-eval-graders.js';
-export declare const DEFAULT_EVAL_ALLOWED_TOOLS: readonly ["Read", "Glob", "Grep", "Skill"];
-export interface PluginEvalRuntime {
-    run(prompt: string, signal: AbortSignal): Promise<{
-        text: string;
-        turns: number;
-        costUsd?: number;
-    }>;
-    close?(): Promise<void>;
-}
-export interface PluginEvalRuntimeFactory {
-    create(options: {
-        dataPlane: DataPlane;
-        cwd: string;
-        configRoot: string;
-        home: string;
-        model?: string;
-        maxTurns: number;
-        pluginDirectories: readonly string[];
-        allowedTools: readonly string[];
-        appendSystemPrompt?: string;
-        historyFile?: string;
-        addDirs: readonly string[];
-        env: Readonly<Record<string, string>>;
-        eventSink(event: RuntimeEvent): void;
-    }): Promise<PluginEvalRuntime>;
-}
+import type { EvalRunArtifacts, EvalRuntime, EvalRuntimeFactory } from '../evals/eval-contract.js';
+export { DEFAULT_EVAL_ALLOWED_TOOLS, resolveEvalAllowedTools, } from '../evals/eval-contract.js';
+export type PluginEvalRuntime = EvalRuntime;
+export type PluginEvalRuntimeFactory = EvalRuntimeFactory;
 export interface EvalSingleRunResult {
     text: string;
     turns: number;
@@ -39,7 +15,6 @@ export interface EvalSingleRunResult {
     termination: 'timeout' | 'interrupted' | null;
     tempRoot?: string;
 }
-export declare function resolveEvalAllowedTools(requested: readonly string[], grants: readonly string[]): string[];
 export declare function runClaudePluginEvalOnce(options: {
     case: ClaudePluginEvalCase;
     factory: PluginEvalRuntimeFactory;

package/dist/plugins/claude-plugin-eval-runner.js

@@ -3,50 +3,11 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { BoundedProcessRunner, joinedProcessOutput, } from '../platform/bounded-process-runner.js';
 import { resolveContainedPath } from './claude-plugin-eval-schema.js';
-export const DEFAULT_EVAL_ALLOWED_TOOLS = [
-    'Read',
-    'Glob',
-    'Grep',
-    'Skill',
-];
+import { normalizeEvalTraceEvent, resolveEvalAllowedTools, } from '../evals/eval-contract.js';
+export { DEFAULT_EVAL_ALLOWED_TOOLS, resolveEvalAllowedTools, } from '../evals/eval-contract.js';
 function abortError() {
     return new DOMException('Eval run timed out', 'AbortError');
 }
-function toolName(rule) {
-    const separator = rule.indexOf('(');
-    return separator < 0 ? rule : rule.slice(0, separator);
-}
-function gatedTool(rule) {
-    const name = toolName(rule);
-    return (['Bash', 'Write', 'Edit', 'NotebookEdit', 'WebFetch', 'WebSearch'].includes(name) || name.startsWith('mcp__'));
-}
-function operatorGrants(requested, grants) {
-    const name = toolName(requested);
-    const wildcardMatch = (pattern) => {
-        const parts = pattern.split('*');
-        if (parts.length === 1)
-            return false;
-        if (!requested.startsWith(parts[0] ?? ''))
-            return false;
-        let cursor = parts[0]?.length ?? 0;
-        for (const part of parts.slice(1, -1)) {
-            const index = requested.indexOf(part, cursor);
-            if (index < 0)
-                return false;
-            cursor = index + part.length;
-        }
-        const last = parts.at(-1) ?? '';
-        return last.length === 0 || requested.slice(cursor).endsWith(last);
-    };
-    return grants.some((grant) => grant === requested || grant === name || wildcardMatch(grant));
-}
-export function resolveEvalAllowedTools(requested, grants) {
-    const selected = requested.length ? requested : DEFAULT_EVAL_ALLOWED_TOOLS;
-    for (const rule of selected)
-        if (gatedTool(rule) && !operatorGrants(rule, grants))
-            throw new Error(`Eval case requests gated tool ${rule}; grant it with --allow-tools`);
-    return [...new Set(selected)];
-}
 async function scaffold(caseDef, cwd, home, signal) {
     if (!caseDef.context.scaffoldScript)
         return;
@@ -70,23 +31,7 @@ async function scaffold(caseDef, cwd, home, signal) {
     if (result.code !== 0)
         throw new Error(`Scaffold failed (${result.code}): ${joinedProcessOutput(result)}`);
 }
-function traceEvent(event) {
-    if (event.type === 'tool-call')
-        return {
-            type: 'tool-call',
-            tool: event.call.name,
-            input: event.call.input,
-            id: event.call.id,
-        };
-    if (event.type === 'tool-result')
-        return {
-            type: 'tool-result',
-            callId: event.callId,
-            content: event.content,
-            isError: event.isError,
-        };
-    return event;
-}
+const traceEvent = normalizeEvalTraceEvent;
 export async function runClaudePluginEvalOnce(options) {
     const tempRoot = await mkdtemp(join(tmpdir(), 'praxis-eval-'));
     const cwd = join(tempRoot, 'cwd');

package/dist/plugins/claude-plugin-eval-schema.d.ts

@@ -1,3 +1,4 @@
+import type { EvalArm as SharedEvalArm, EvalDeterministicGrader, EvalFocus as SharedEvalFocus, EvalToolMatch as SharedEvalToolMatch } from '../evals/eval-contract.js';
 export declare const EVAL_SCHEMA_VERSION = "1.0";
 export declare const MAX_EVAL_FILE_BYTES: number;
 export declare const MAX_EVAL_GRADERS = 256;
@@ -5,48 +6,23 @@ export declare const MAX_EVAL_ARRAY_ITEMS = 256;
 export declare const MAX_EVAL_STRING_LENGTH: number;
 export declare const MAX_EVAL_OBJECT_DEPTH = 16;
 export declare const MAX_EVAL_OBJECT_NODES = 4096;
-export type EvalFocus = 'last_message' | 'trace' | 'files' | {
-    source: 'file';
-    path: string;
-};
-export type EvalArm = 'with-only' | 'both';
-interface EvalGraderBase {
+export type EvalFocus = SharedEvalFocus;
+export type EvalArm = SharedEvalArm;
+export type EvalToolMatch = SharedEvalToolMatch;
+export type ClaudePluginEvalGrader = EvalDeterministicGrader | {
     name: string;
     weight: number;
     arm?: EvalArm;
-}
-export type ClaudePluginEvalGrader = (EvalGraderBase & {
-    type: 'regex';
-    target: EvalFocus;
-    pattern: string;
-    flags: string;
-    match: 'contains' | 'not_contains' | `count:${number}`;
-}) | (EvalGraderBase & {
-    type: 'tool_order';
-    before: EvalToolMatch;
-    after: EvalToolMatch;
-}) | (EvalGraderBase & {
-    type: 'tool_used';
-    tool: string;
-    input_match?: Record<string, unknown>;
-    min: number;
-    max: number;
-}) | (EvalGraderBase & {
-    type: 'file_exists';
-    path: string;
-    exists: boolean;
-}) | (EvalGraderBase & {
     type: 'llm';
     criteria: string;
     focus: EvalFocus;
-}) | (EvalGraderBase & {
+} | {
+    name: string;
+    weight: number;
+    arm?: EvalArm;
     type: 'baseline';
     baseline_file: string;
     criteria: string;
-});
-export type EvalToolMatch = string | {
-    tool: string;
-    input_match?: Record<string, unknown>;
 };
 export interface ClaudePluginEvalCase {
     schemaVersion: string;
@@ -76,5 +52,4 @@ export interface ClaudePluginEvalCase {
 }
 export declare function loadClaudePluginEvalCase(caseDir: string): Promise<ClaudePluginEvalCase>;
 export declare function resolveContainedPath(root: string, candidate: string, label: string): Promise<string>;
-export {};
 //# sourceMappingURL=claude-plugin-eval-schema.d.ts.map

package/dist/tools/local-tools.js

@@ -4,6 +4,7 @@ import { mkdir, mkdtemp, open, realpath, stat, writeFile, } from 'node:fs/promis
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import sharp from 'sharp';
+import { countTokens } from '@anthropic-ai/tokenizer';
 import { commandShell, commandShellArguments, } from '../platform/command-shell.js';
 import { BoundedProcessRunner, joinedProcessOutput, } from '../platform/bounded-process-runner.js';
 import { globFiles } from './glob.js';
@@ -462,6 +463,8 @@ function truncateOutput(content, maxBytes) {
         ? `${retained.content}\n[output truncated]`
         : retained.content;
 }
+const TEXT_READ_MAX_BYTES = 256 * 1024;
+const TEXT_READ_MAX_TOKENS = 25_000;
 function abortError() {
     return new DOMException('Tool execution aborted', 'AbortError');
 }
@@ -1037,8 +1040,20 @@ export class LocalToolRegistry {
                 : selected
                     .map((line, index) => `${(offset === 0 ? 0 : offset) + index}\t${line}`)
                     .join('\n');
+            if (!notebook) {
+                const contentBytes = Buffer.byteLength(content);
+                if (contentBytes > TEXT_READ_MAX_BYTES) {
+                    throw new Error(`Read result is ${contentBytes} bytes, which exceeds the ${formatKilobytes(TEXT_READ_MAX_BYTES)} limit. Use offset and limit to read specific portions.`);
+                }
+                const contentTokens = countTokens(content);
+                if (contentTokens > TEXT_READ_MAX_TOKENS) {
+                    throw new Error(`Read result is ${contentTokens} tokens, which exceeds the ${TEXT_READ_MAX_TOKENS} token limit. Use offset and limit to read specific portions.`);
+                }
+            }
             return {
-                content: truncateOutput(content, this.maxOutputBytes),
+                content: notebook
+                    ? truncateOutput(content, this.maxOutputBytes)
+                    : content,
                 isError: false,
                 accessedPaths: [filePath],
                 ...(notebook

package/package.json

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