praxis-agent 0.20.21 → 0.21.0

package/dist/compatibility/claude/sidechain.js

@@ -1,14 +1,27 @@
 import { resolve } from 'node:path';
 import { isClaudeSessionId } from './paths.js';
 const AGENT_ID_PATTERN = /^a[0-9a-f]{16}$/u;
-export function resolveClaudeSidechainPaths(projectRoot, sessionId, agentId) {
+export function resolveClaudeSidechainPaths(projectRoot, sessionId, agentId, options = {}) {
     if (!isClaudeSessionId(sessionId)) {
         throw new Error(`Invalid Claude session ID: ${sessionId}`);
     }
     if (!AGENT_ID_PATTERN.test(agentId)) {
         throw new Error(`Invalid Claude agent ID: ${agentId}`);
     }
-    const directory = resolve(projectRoot, sessionId, 'subagents');
+    const subdirectory = options.subdirectory;
+    if (subdirectory !== undefined &&
+        (subdirectory.length === 0 ||
+            subdirectory.startsWith('/') ||
+            subdirectory.includes('\\') ||
+            subdirectory.includes('\0') ||
+            subdirectory
+                .split('/')
+                .some((segment) => segment === '.' || segment === '..'))) {
+        throw new Error(`Invalid Claude sidechain subdirectory: ${subdirectory}`);
+    }
+    const directory = subdirectory === undefined
+        ? resolve(projectRoot, sessionId, 'subagents')
+        : resolve(projectRoot, sessionId, 'subagents', subdirectory);
     return {
         sessionId,
         agentId,

package/dist/core/context-budget.d.ts

@@ -1,8 +1,21 @@
-import type { ModelMessage, ModelToolDefinition } from './runtime.js';
+import type { ModelMessage, ModelToolDefinition, ModelUsage } from './runtime.js';
 export interface ContextBudgetOptions {
     contextWindowTokens: number;
     reserveTokens?: number;
+    /** Declares whether the configured window came from a provider capability so
+     *  reports can distinguish provider-derived decisions from estimates. */
+    windowSource?: 'capability' | 'estimate';
 }
+export interface ContextBudgetEvaluateOptions {
+    /** Most recent provider usage observation; a positive `contextWindow` is
+     *  authoritative for the effective window. */
+    lastUsage?: ModelUsage;
+    /** Provider-reported output tokens to reserve in the overflow accounting. */
+    outputTokens?: number;
+    /** Force `shouldCompact` when the provider rejected the prompt as too long. */
+    promptTooLong?: boolean;
+}
+export type ContextBudgetSource = 'provider' | 'capability' | 'estimate';
 export interface ContextBudgetReport {
     estimatedTokens: number;
     contextWindowTokens: number;
@@ -10,6 +23,7 @@ export interface ContextBudgetReport {
     availableTokens: number;
     overflowTokens: number;
     shouldCompact: boolean;
+    source: ContextBudgetSource;
 }
 export declare class ContextOverflowError extends Error {
     readonly report: ContextBudgetReport;
@@ -21,8 +35,45 @@ export declare function estimateModelRequestTokens(messages: readonly ModelMessa
 export declare class ContextBudget {
     readonly contextWindowTokens: number;
     readonly reserveTokens: number;
+    readonly windowSource: 'capability' | 'estimate';
+    private observedUsage;
     constructor(options: ContextBudgetOptions);
-    evaluate(messages: readonly ModelMessage[], tools?: readonly ModelToolDefinition[]): ContextBudgetReport;
+    observeUsage(usage: ModelUsage): void;
+    effectiveContextWindow(usage?: ModelUsage): number;
+    evaluate(messages: readonly ModelMessage[], tools?: readonly ModelToolDefinition[], options?: ContextBudgetEvaluateOptions): ContextBudgetReport;
     assertFits(report: ContextBudgetReport): void;
+    /** Returns the positive provider-reported context window, if any. */
+    private providerContextWindow;
+}
+export type ContextRecoveryStage = 'preflight' | 'microcompact' | 'auto-compact' | 'reactive-retry' | 'blocked';
+export interface ContextRecoveryPlannerOptions {
+    /** Number of reactive retries allowed before the planner reports `blocked`. */
+    maxReactiveRetries?: number;
+    /** Consecutive failures that trip the circuit breaker to `blocked`. */
+    consecutiveFailureThreshold?: number;
+}
+export declare class ContextRecoveryPlanner {
+    private readonly maxReactiveRetries;
+    private readonly consecutiveFailureThreshold;
+    private currentStage;
+    private reactiveRetriesUsed;
+    private consecutiveFailures;
+    constructor(options?: ContextRecoveryPlannerOptions);
+    get stage(): ContextRecoveryStage;
+    get reactiveRetriesRemaining(): number;
+    /** Advance one escalation stage; bounded so the planner never leaves
+     *  `blocked`. Side-effect free apart from the internal stage. */
+    advance(): ContextRecoveryStage;
+    /** Consume one reactive retry decision; reports `blocked` once the maximum
+     *  reactive retries have been consumed. */
+    consumeReactiveRetry(): ContextRecoveryStage;
+    /** Record a failed recovery attempt; trips the circuit breaker to `blocked`
+     *  after `consecutiveFailureThreshold` consecutive failures. */
+    recordFailure(): ContextRecoveryStage;
+    /** Record a successful recovery/model attempt; resets the planner. */
+    recordSuccess(): ContextRecoveryStage;
 }
+/** True when a provider error signals that the request exceeded the model's
+ *  context window and a reactive compaction retry is the relevant recovery. */
+export declare function isPromptTooLongError(error: unknown): boolean;
 //# sourceMappingURL=context-budget.d.ts.map

package/dist/core/context-budget.js

@@ -1,3 +1,4 @@
+import { ModelProviderError } from './runtime.js';
 export class ContextOverflowError extends Error {
     report;
     name = 'ContextOverflowError';
@@ -76,6 +77,8 @@ export function estimateModelRequestTokens(messages, tools = []) {
 export class ContextBudget {
     contextWindowTokens;
     reserveTokens;
+    windowSource;
+    observedUsage;
     constructor(options) {
         requirePositiveInteger(options.contextWindowTokens, 'Context window tokens');
         const defaultReserve = Math.min(8192, Math.max(1, Math.floor(options.contextWindowTokens / 10)));
@@ -86,23 +89,132 @@ export class ContextBudget {
         }
         this.contextWindowTokens = options.contextWindowTokens;
         this.reserveTokens = reserveTokens;
+        this.windowSource = options.windowSource ?? 'estimate';
     }
-    evaluate(messages, tools = []) {
+    observeUsage(usage) {
+        this.observedUsage = usage;
+    }
+    effectiveContextWindow(usage) {
+        return this.providerContextWindow(usage) ?? this.contextWindowTokens;
+    }
+    evaluate(messages, tools = [], options = {}) {
         const estimatedTokens = estimateModelRequestTokens(messages, tools);
-        const availableTokens = this.contextWindowTokens - this.reserveTokens;
-        const overflowTokens = Math.max(0, estimatedTokens - availableTokens);
+        const providerWindow = this.providerContextWindow(options.lastUsage);
+        const contextWindowTokens = providerWindow ?? this.contextWindowTokens;
+        const outputTokens = options.outputTokens !== undefined &&
+            Number.isSafeInteger(options.outputTokens) &&
+            options.outputTokens >= 0
+            ? options.outputTokens
+            : 0;
+        const availableTokens = Math.max(0, contextWindowTokens - this.reserveTokens);
+        const overflowTokens = Math.max(0, estimatedTokens + outputTokens - availableTokens);
+        const shouldCompact = options.promptTooLong === true || overflowTokens > 0;
         return {
             estimatedTokens,
-            contextWindowTokens: this.contextWindowTokens,
+            contextWindowTokens,
             reserveTokens: this.reserveTokens,
             availableTokens,
             overflowTokens,
-            shouldCompact: overflowTokens > 0,
+            shouldCompact,
+            source: providerWindow === undefined ? this.windowSource : 'provider',
         };
     }
     assertFits(report) {
         if (report.shouldCompact)
             throw new ContextOverflowError(report);
     }
+    /** Returns the positive provider-reported context window, if any. */
+    providerContextWindow(usage) {
+        const candidate = usage?.contextWindow ?? this.observedUsage?.contextWindow;
+        if (candidate !== undefined &&
+            Number.isSafeInteger(candidate) &&
+            candidate > 0) {
+            return candidate;
+        }
+        return undefined;
+    }
+}
+const DEFAULT_MAX_REACTIVE_RETRIES = 1;
+const DEFAULT_CONSECUTIVE_FAILURE_THRESHOLD = 3;
+export class ContextRecoveryPlanner {
+    maxReactiveRetries;
+    consecutiveFailureThreshold;
+    currentStage = 'preflight';
+    reactiveRetriesUsed = 0;
+    consecutiveFailures = 0;
+    constructor(options = {}) {
+        const maxReactiveRetries = options.maxReactiveRetries ?? DEFAULT_MAX_REACTIVE_RETRIES;
+        const consecutiveFailureThreshold = options.consecutiveFailureThreshold ??
+            DEFAULT_CONSECUTIVE_FAILURE_THRESHOLD;
+        if (!Number.isInteger(maxReactiveRetries) || maxReactiveRetries < 0) {
+            throw new Error('maxReactiveRetries must be a nonnegative integer');
+        }
+        if (!Number.isInteger(consecutiveFailureThreshold) ||
+            consecutiveFailureThreshold < 1) {
+            throw new Error('consecutiveFailureThreshold must be a positive integer');
+        }
+        this.maxReactiveRetries = maxReactiveRetries;
+        this.consecutiveFailureThreshold = consecutiveFailureThreshold;
+    }
+    get stage() {
+        return this.currentStage;
+    }
+    get reactiveRetriesRemaining() {
+        return Math.max(0, this.maxReactiveRetries - this.reactiveRetriesUsed);
+    }
+    /** Advance one escalation stage; bounded so the planner never leaves
+     *  `blocked`. Side-effect free apart from the internal stage. */
+    advance() {
+        switch (this.currentStage) {
+            case 'preflight':
+                this.currentStage = 'microcompact';
+                break;
+            case 'microcompact':
+                this.currentStage = 'auto-compact';
+                break;
+            case 'auto-compact':
+                this.currentStage = 'reactive-retry';
+                break;
+            case 'reactive-retry':
+                this.currentStage = 'blocked';
+                break;
+            case 'blocked':
+                break;
+        }
+        return this.currentStage;
+    }
+    /** Consume one reactive retry decision; reports `blocked` once the maximum
+     *  reactive retries have been consumed. */
+    consumeReactiveRetry() {
+        this.reactiveRetriesUsed += 1;
+        this.currentStage =
+            this.reactiveRetriesUsed <= this.maxReactiveRetries
+                ? 'reactive-retry'
+                : 'blocked';
+        return this.currentStage;
+    }
+    /** Record a failed recovery attempt; trips the circuit breaker to `blocked`
+     *  after `consecutiveFailureThreshold` consecutive failures. */
+    recordFailure() {
+        this.consecutiveFailures += 1;
+        if (this.consecutiveFailures >= this.consecutiveFailureThreshold) {
+            this.currentStage = 'blocked';
+        }
+        return this.currentStage;
+    }
+    /** Record a successful recovery/model attempt; resets the planner. */
+    recordSuccess() {
+        this.consecutiveFailures = 0;
+        this.reactiveRetriesUsed = 0;
+        this.currentStage = 'preflight';
+        return this.currentStage;
+    }
+}
+const PROMPT_TOO_LONG_PATTERN = /context(?:[_\s-]?length|[_\s-]?window)|prompt(?:[_\s-]?is)?[_\s-]?too[_\s-]?long|too[_\s-]?many[_\s-]?tokens|maximum[_\s-]?context/iu;
+/** True when a provider error signals that the request exceeded the model's
+ *  context window and a reactive compaction retry is the relevant recovery. */
+export function isPromptTooLongError(error) {
+    return (error instanceof ModelProviderError &&
+        PROMPT_TOO_LONG_PATTERN.test(error.message));
 }
 //# sourceMappingURL=context-budget.js.map

package/dist/tools/claude-capabilities.d.ts

@@ -0,0 +1,79 @@
+import type { ModelToolDefinition } from '../core/runtime.js';
+import type { ModelToolCall, ToolExecutionContext, ToolExecutionResult, ToolRegistry } from '../core/runtime.js';
+/**
+ * Capability-driven Claude tool exposure.
+ *
+ * The advertised/allowed set of capability-gated tools is derived from the
+ * runtime role and explicit gates rather than from a Claude version or a fixed
+ * global list. Base tools (Bash, Read, Edit, ...) are never part of this
+ * resolver; callers keep them and apply the resolved set only to the
+ * capability-gated tools they actually expose.
+ */
+export type ClaudeToolRole = 'main' | 'worker' | 'coordinator';
+/**
+ * Immutable capability input. `interactive`/`simpleMode` describe the runtime
+ * mode; the gate booleans are explicit when present and otherwise fall back to
+ * the documented environment overrides, then to the default rules. Explicit
+ * booleans always override the environment.
+ */
+export interface ClaudeToolCapabilityInput {
+    readonly role: ClaudeToolRole;
+    readonly interactive: boolean;
+    readonly simpleMode: boolean;
+    readonly tasks?: boolean;
+    readonly workflowScripts?: boolean;
+    readonly agentTriggers?: boolean;
+    readonly backgroundAgents?: boolean;
+    readonly subagents?: boolean;
+    /** Explicit allow-list for capability-gated tools; never enables a gate. */
+    readonly tools?: readonly string[];
+    /** Always wins over the allow-list and the default rules. */
+    readonly disallowedTools?: readonly string[];
+    readonly env?: Readonly<Record<string, string | undefined>>;
+}
+/** Stable environment names. Explicit input booleans override these. */
+export declare const CLAUDE_CODE_ENABLE_TASKS = "CLAUDE_CODE_ENABLE_TASKS";
+export declare const CLAUDE_CODE_DISABLE_CRON = "CLAUDE_CODE_DISABLE_CRON";
+export declare const PRAXIS_ENABLE_WORKFLOW_SCRIPTS = "PRAXIS_ENABLE_WORKFLOW_SCRIPTS";
+/** task-v2 task-board tools, gated by the `tasks` capability. */
+export declare const CLAUDE_TASK_V2_TOOLS: readonly ["TaskCreate", "TaskGet", "TaskList", "TaskUpdate"];
+/** Workflow tool, gated by the `workflowScripts` capability. */
+export declare const CLAUDE_WORKFLOW_TOOLS: readonly ["Workflow"];
+/** Cron and wakeup tools, gated by the `agentTriggers` capability. */
+export declare const CLAUDE_AGENT_TRIGGER_TOOLS: readonly ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"];
+/** Agent tool, gated by the `subagents` capability. */
+export declare const CLAUDE_AGENT_TOOLS: readonly ["Agent"];
+/** Background task lifecycle tools, gated by the `backgroundAgents` capability. */
+export declare const CLAUDE_BACKGROUND_TOOLS: readonly ["TaskOutput", "TaskStop"];
+/** Coordination tools advertised by a coordinator only when explicitly enabled. */
+export declare const CLAUDE_COORDINATION_TOOLS: readonly ["AskUserQuestion", "SendMessage", "SendUserMessage", "Monitor", "PushNotification"];
+/** Recursively suppressed for worker agents regardless of any allow-list. */
+export declare const CLAUDE_WORKER_RECURSIVE_TOOLS: readonly ["Agent", "TaskOutput", "TaskStop"];
+export declare const CLAUDE_CAPABILITY_GATED_TOOLS: ReadonlySet<string>;
+/**
+ * Resolve the deterministic set of capability-gated tool names enabled for the
+ * given role, gates, allow-list, and disallow-list. Tools outside this set that
+ * are not capability-gated are unaffected by the resolver.
+ */
+export declare function resolveClaudeToolCapabilities(input: ClaudeToolCapabilityInput): ReadonlySet<string>;
+/** Whether a single tool name is enabled under the given capability input. */
+export declare function isClaudeToolEnabled(input: ClaudeToolCapabilityInput, name: string): boolean;
+/** Whether the tool name participates in capability gating. */
+export declare function isClaudeCapabilityGated(name: string): boolean;
+/** Keep only capability-gated definitions the resolved capabilities include. */
+export declare function filterClaudeToolDefinitions(definitions: readonly ModelToolDefinition[], capabilities: ReadonlySet<string>): readonly ModelToolDefinition[];
+/**
+ * Applies the capability set at both advertisement and invocation boundaries.
+ * This keeps a caller from executing a capability-gated tool that was omitted
+ * from the model-facing tool list.
+ */
+export declare class ClaudeCapabilityToolRegistry implements ToolRegistry {
+    private readonly base;
+    private readonly capabilities;
+    constructor(base: ToolRegistry, capabilities: ReadonlySet<string>);
+    definitions(): readonly ModelToolDefinition[];
+    prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
+    execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
+    private assertEnabled;
+}
+//# sourceMappingURL=claude-capabilities.d.ts.map

package/dist/tools/claude-capabilities.js

@@ -0,0 +1,187 @@
+/** Stable environment names. Explicit input booleans override these. */
+export const CLAUDE_CODE_ENABLE_TASKS = 'CLAUDE_CODE_ENABLE_TASKS';
+export const CLAUDE_CODE_DISABLE_CRON = 'CLAUDE_CODE_DISABLE_CRON';
+export const PRAXIS_ENABLE_WORKFLOW_SCRIPTS = 'PRAXIS_ENABLE_WORKFLOW_SCRIPTS';
+/** task-v2 task-board tools, gated by the `tasks` capability. */
+export const CLAUDE_TASK_V2_TOOLS = [
+    'TaskCreate',
+    'TaskGet',
+    'TaskList',
+    'TaskUpdate',
+];
+/** Workflow tool, gated by the `workflowScripts` capability. */
+export const CLAUDE_WORKFLOW_TOOLS = ['Workflow'];
+/** Cron and wakeup tools, gated by the `agentTriggers` capability. */
+export const CLAUDE_AGENT_TRIGGER_TOOLS = [
+    'CronCreate',
+    'CronDelete',
+    'CronList',
+    'ScheduleWakeup',
+];
+/** Agent tool, gated by the `subagents` capability. */
+export const CLAUDE_AGENT_TOOLS = ['Agent'];
+/** Background task lifecycle tools, gated by the `backgroundAgents` capability. */
+export const CLAUDE_BACKGROUND_TOOLS = ['TaskOutput', 'TaskStop'];
+/** Coordination tools advertised by a coordinator only when explicitly enabled. */
+export const CLAUDE_COORDINATION_TOOLS = [
+    'AskUserQuestion',
+    'SendMessage',
+    'SendUserMessage',
+    'Monitor',
+    'PushNotification',
+];
+/** Recursively suppressed for worker agents regardless of any allow-list. */
+export const CLAUDE_WORKER_RECURSIVE_TOOLS = [
+    'Agent',
+    'TaskOutput',
+    'TaskStop',
+];
+export const CLAUDE_CAPABILITY_GATED_TOOLS = new Set([
+    ...CLAUDE_TASK_V2_TOOLS,
+    ...CLAUDE_WORKFLOW_TOOLS,
+    ...CLAUDE_AGENT_TRIGGER_TOOLS,
+    ...CLAUDE_AGENT_TOOLS,
+    ...CLAUDE_BACKGROUND_TOOLS,
+    ...CLAUDE_COORDINATION_TOOLS,
+]);
+const EMPTY_ENV = {};
+const ENV_TRUE = /^(?:1|true|yes|on)$/iu;
+const ENV_FALSE = /^(?:0|false|no|off|)$/iu;
+function envBoolean(env, name) {
+    const value = env[name];
+    if (value === undefined)
+        return undefined;
+    if (ENV_TRUE.test(value))
+        return true;
+    if (ENV_FALSE.test(value))
+        return false;
+    return undefined;
+}
+function validateNames(names, flag) {
+    for (const name of names) {
+        if (!CLAUDE_CAPABILITY_GATED_TOOLS.has(name)) {
+            throw new Error(`Unknown capability tool in ${flag}: ${name}`);
+        }
+    }
+}
+/**
+ * Resolve the deterministic set of capability-gated tool names enabled for the
+ * given role, gates, allow-list, and disallow-list. Tools outside this set that
+ * are not capability-gated are unaffected by the resolver.
+ */
+export function resolveClaudeToolCapabilities(input) {
+    const env = input.env ?? EMPTY_ENV;
+    const tasks = input.tasks ??
+        envBoolean(env, CLAUDE_CODE_ENABLE_TASKS) ??
+        (input.interactive && !input.simpleMode);
+    const workflowScripts = input.workflowScripts ??
+        envBoolean(env, PRAXIS_ENABLE_WORKFLOW_SCRIPTS) ??
+        false;
+    let agentTriggers = input.agentTriggers;
+    if (agentTriggers === undefined) {
+        const disableCron = envBoolean(env, CLAUDE_CODE_DISABLE_CRON);
+        agentTriggers = disableCron === undefined ? false : !disableCron;
+    }
+    // The local kill switch takes priority over the internal agentTriggers
+    // capability input: a truthy CLAUDE_CODE_DISABLE_CRON suppresses the cron
+    // tools even when selected scheduled names would otherwise enable them.
+    if (envBoolean(env, CLAUDE_CODE_DISABLE_CRON) === true) {
+        agentTriggers = false;
+    }
+    const backgroundAgents = input.backgroundAgents ?? false;
+    const subagents = input.subagents ?? false;
+    if (input.tools)
+        validateNames(input.tools, '--tools');
+    if (input.disallowedTools)
+        validateNames(input.disallowedTools, '--disallowedTools');
+    // Simple mode is an absolute suppressor for every capability-gated tool,
+    // regardless of role, explicit gates, environment overrides, or allow-list.
+    if (input.simpleMode) {
+        return new Set();
+    }
+    const enabled = new Set(CLAUDE_COORDINATION_TOOLS);
+    if (tasks) {
+        for (const name of CLAUDE_TASK_V2_TOOLS)
+            enabled.add(name);
+    }
+    if (workflowScripts) {
+        for (const name of CLAUDE_WORKFLOW_TOOLS)
+            enabled.add(name);
+    }
+    if (agentTriggers) {
+        for (const name of CLAUDE_AGENT_TRIGGER_TOOLS)
+            enabled.add(name);
+    }
+    if (subagents) {
+        for (const name of CLAUDE_AGENT_TOOLS)
+            enabled.add(name);
+    }
+    if (backgroundAgents) {
+        for (const name of CLAUDE_BACKGROUND_TOOLS)
+            enabled.add(name);
+    }
+    if (input.role === 'worker') {
+        for (const name of CLAUDE_WORKER_RECURSIVE_TOOLS)
+            enabled.delete(name);
+    }
+    else if (input.role === 'coordinator') {
+        const explicit = new Set(input.tools ?? []);
+        for (const name of CLAUDE_COORDINATION_TOOLS) {
+            if (!explicit.has(name))
+                enabled.delete(name);
+        }
+    }
+    if (input.tools) {
+        const allowList = new Set(input.tools);
+        for (const name of [...enabled]) {
+            if (!allowList.has(name))
+                enabled.delete(name);
+        }
+    }
+    for (const name of input.disallowedTools ?? [])
+        enabled.delete(name);
+    return enabled;
+}
+/** Whether a single tool name is enabled under the given capability input. */
+export function isClaudeToolEnabled(input, name) {
+    return resolveClaudeToolCapabilities(input).has(name);
+}
+/** Whether the tool name participates in capability gating. */
+export function isClaudeCapabilityGated(name) {
+    return CLAUDE_CAPABILITY_GATED_TOOLS.has(name);
+}
+/** Keep only capability-gated definitions the resolved capabilities include. */
+export function filterClaudeToolDefinitions(definitions, capabilities) {
+    return definitions.filter((definition) => !CLAUDE_CAPABILITY_GATED_TOOLS.has(definition.name) ||
+        capabilities.has(definition.name));
+}
+/**
+ * Applies the capability set at both advertisement and invocation boundaries.
+ * This keeps a caller from executing a capability-gated tool that was omitted
+ * from the model-facing tool list.
+ */
+export class ClaudeCapabilityToolRegistry {
+    base;
+    capabilities;
+    constructor(base, capabilities) {
+        this.base = base;
+        this.capabilities = capabilities;
+    }
+    definitions() {
+        return filterClaudeToolDefinitions(this.base.definitions(), this.capabilities);
+    }
+    async prepare(call, context) {
+        this.assertEnabled(call.name);
+        return this.base.prepare(call, context);
+    }
+    async execute(call, context) {
+        this.assertEnabled(call.name);
+        return this.base.execute(call, context);
+    }
+    assertEnabled(name) {
+        if (isClaudeCapabilityGated(name) && !this.capabilities.has(name)) {
+            throw new Error(`Tool ${name} is unavailable in this runtime`);
+        }
+    }
+}
+//# sourceMappingURL=claude-capabilities.js.map

package/package.json

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