praxis-agent 0.26.0 → 0.28.0

package/dist/tools/claude-interactive-tools.js

@@ -1,5 +1,6 @@
 import { mkdir, readFile, realpath } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 const ASK_USER_QUESTION = {
     name: 'AskUserQuestion',
     description: "Use this tool only when you are blocked on a decision that is genuinely the user's to make: one you cannot resolve from the request, the code, or sensible defaults. Users can always provide custom text. Use multiSelect for non-exclusive choices. In plan mode, use this tool to clarify requirements before ExitPlanMode; do not use it to request plan approval.",
@@ -197,6 +198,12 @@ class ClaudeInteractiveToolRegistry {
             ...INTERACTIVE_DEFINITIONS.filter(({ name }) => this.manager.enabledNames.has(name)),
         ];
     }
+    schedulingPolicy(call) {
+        if (this.manager.enabledNames.has(call.name)) {
+            return { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.base, call);
+    }
     async prepare(call, context) {
         return this.manager.enabledNames.has(call.name)
             ? call

package/dist/tools/claude-lsp-tool.js

@@ -4,6 +4,7 @@ import { homedir } from 'node:os';
 import { extname, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { promisify } from 'node:util';
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { redactSensitiveText, sanitizeChildEnvironment, sensitiveEnvironmentValues, } from '../platform/sensitive-data.js';
 import { formatClaudeLspResult } from './claude-lsp-formatters.js';
 const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
@@ -730,6 +731,12 @@ class ClaudeLspToolRegistry {
     definitions() {
         return [...this.base.definitions(), LSP_DEFINITION];
     }
+    schedulingPolicy(call) {
+        if (call.name === 'LSP') {
+            return { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.base, call);
+    }
     prepare(call, context) {
         return call.name === 'LSP'
             ? Promise.resolve(call)

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

@@ -16,6 +16,7 @@ export declare class ClaudeScheduledToolRegistry implements ToolRegistry {
     private readonly now;
     constructor(options: ClaudeScheduledToolRegistryOptions);
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }

package/dist/tools/claude-scheduled-tools.js

@@ -1,3 +1,4 @@
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 const SCHEMA = 'https://json-schema.org/draft/2020-12/schema';
 const CRON_CREATE_DESCRIPTION = `Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders.
 
@@ -191,6 +192,12 @@ export class ClaudeScheduledToolRegistry {
             ...scheduledDefinitions.filter(({ name }) => (this.enabled?.has(name) ?? true) && !existing.has(name)),
         ];
     }
+    schedulingPolicy(call) {
+        if (DEFINITION_NAMES.has(call.name)) {
+            return { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.options.base, call);
+    }
     async prepare(call, context) {
         if (!DEFINITION_NAMES.has(call.name)) {
             return this.options.base.prepare(call, context);

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

@@ -22,6 +22,7 @@ export declare class ClaudeTaskToolRegistry implements ToolRegistry {
     stopBackgroundTask(taskId: string): Promise<BackgroundBashToolResult>;
     isEnabled(name: string): boolean;
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     notifications(waitForRunning: boolean): Promise<string[]>;

package/dist/tools/claude-task-tools.js

@@ -1,4 +1,5 @@
 import { resolve } from 'node:path';
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { BackgroundBashManager, } from '../application/background-bash-manager.js';
 import { isBackgroundBashTaskId } from '../application/background-task-id.js';
 import { ClaudeTaskStore, } from '../persistence/claude-task-store.js';
@@ -260,6 +261,16 @@ export class ClaudeTaskToolRegistry {
             ...TASK_DEFINITIONS.filter(({ name }) => this.isEnabled(name) && !existing.has(name)),
         ];
     }
+    schedulingPolicy(call) {
+        if (call.name !== 'Bash' &&
+            !TASK_DEFINITIONS.some(({ name }) => name === call.name)) {
+            return resolveToolSchedulingPolicy(this.options.base, call);
+        }
+        if (call.name === 'Bash' && call.input.run_in_background !== true) {
+            return resolveToolSchedulingPolicy(this.options.base, call);
+        }
+        return { concurrency: 'exclusive', cancelOnInterrupt: true };
+    }
     async prepare(call, context) {
         if (call.name === 'Bash') {
             return this.prepareBash(call, context);

package/dist/tools/claude-user-message.d.ts

@@ -10,6 +10,7 @@ export declare class ClaudeUserMessageToolRegistry implements ToolRegistry {
     private readonly onMessage;
     constructor(base: ToolRegistry, onMessage: (message: UserMessage) => void);
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }

package/dist/tools/claude-user-message.js

@@ -1,5 +1,6 @@
 import { stat } from 'node:fs/promises';
 import { extname, resolve } from 'node:path';
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 export const CLAUDE_USER_MESSAGE_PROMPT = 'When brief mode is enabled, SendUserMessage is the primary user-visible reply channel. Use it for the answer, progress checkpoints, and blockers. Set status to normal for a direct reply and proactive for an unsolicited update.';
 const DEFINITION = {
     name: 'SendUserMessage',
@@ -42,6 +43,12 @@ export class ClaudeUserMessageToolRegistry {
     definitions() {
         return [...this.base.definitions(), DEFINITION];
     }
+    schedulingPolicy(call) {
+        if (call.name === DEFINITION.name) {
+            return { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.base, call);
+    }
     prepare(call, context) {
         if (call.name !== DEFINITION.name)
             return this.base.prepare(call, context);

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

@@ -21,6 +21,7 @@ export declare class ClaudeWorkflowToolRegistry implements ToolRegistry {
     private readonly prepared;
     constructor(options: ClaudeWorkflowToolRegistryOptions);
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     private resolveSource;

package/dist/tools/claude-workflow-tools.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { parseWorkflowScript, } from '../application/workflow-manager.js';
 const MAX_SCRIPT_BYTES = 524_288;
 function workflowDefinition(dataPlane) {
@@ -91,6 +92,12 @@ export class ClaudeWorkflowToolRegistry {
         }
         return [...base, workflowDefinition(this.options.dataPlane ?? 'claude')];
     }
+    schedulingPolicy(call) {
+        if (['Workflow', 'TaskOutput', 'TaskStop'].includes(call.name)) {
+            return { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.options.base, call);
+    }
     async prepare(call, context) {
         if (call.name === 'TaskOutput' || call.name === 'TaskStop') {
             const taskId = call.input.task_id ?? call.input.shell_id;

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

@@ -12,6 +12,7 @@ export declare class ClaudeWorktreeToolRegistry implements ToolRegistry {
         dataPlane?: DataPlane;
     });
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }

package/dist/tools/claude-worktree-tools.js

@@ -1,3 +1,4 @@
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 const ENTER_DEFINITION = {
     name: 'EnterWorktree',
     description: 'Create or enter an isolated Git worktree and switch the current session into it.',
@@ -96,6 +97,12 @@ export class ClaudeWorktreeToolRegistry {
             ...definitions.filter((definition) => this.enabled.has(definition.name) && !existing.has(definition.name)),
         ];
     }
+    schedulingPolicy(call) {
+        if (['EnterWorktree', 'ExitWorktree'].includes(call.name)) {
+            return { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.options.base, call);
+    }
     async prepare(call, context) {
         if (call.name === 'EnterWorktree' && this.enabled.has(call.name)) {
             const input = objectInput(call);

package/dist/tools/filtered-tool-registry.d.ts

@@ -9,6 +9,7 @@ export declare class FilteredToolRegistry implements ToolRegistry {
     private readonly enabledNames;
     constructor(base: ToolRegistry, options?: FilteredToolRegistryOptions);
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     private assertEnabled;

package/dist/tools/filtered-tool-registry.js

@@ -1,3 +1,4 @@
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 function exactToolNames(rules) {
     return new Set(rules.flatMap((rule) => {
         const match = /^([A-Za-z][\w-]*)$/.exec(rule);
@@ -34,6 +35,10 @@ export class FilteredToolRegistry {
             return definition;
         });
     }
+    schedulingPolicy(call) {
+        this.assertEnabled(call.name);
+        return resolveToolSchedulingPolicy(this.base, call);
+    }
     async prepare(call, context) {
         this.assertEnabled(call.name);
         return this.base.prepare(call, context);

package/dist/tools/local-tools.d.ts

@@ -53,6 +53,23 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private assertProtectedBashCommand;
     private currentCwd;
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): {
+        concurrency: "concurrent";
+        cancelOnInterrupt: boolean;
+        abortGroupOnError?: never;
+    } | {
+        concurrency: "concurrent";
+        cancelOnInterrupt: boolean;
+        abortGroupOnError: boolean;
+    } | {
+        abortGroupOnError?: boolean;
+        concurrency: "exclusive";
+        cancelOnInterrupt: boolean;
+    } | {
+        concurrency: "exclusive";
+        cancelOnInterrupt?: never;
+        abortGroupOnError?: never;
+    };
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     private workspacePath;

package/dist/tools/local-tools.js

@@ -11,7 +11,7 @@ import { editNotebook, formatNotebookForRead } from './notebook.js';
 import { openPdf } from './pdf.js';
 import { validateBashPathSafety } from '../permissions/bash-path-safety.js';
 import { protectedWritePathReason } from '../permissions/bypass-immune-paths.js';
-import { effectiveAdditionalDirectories } from '../permissions/permission-updates.js';
+import { effectiveAdditionalDirectories, shellInputIsReadOnly, } from '../permissions/permission-updates.js';
 const REPORT_FINDINGS_DEFINITION = {
     name: 'ReportFindings',
     description: "Report code-review findings as a typed list so the host UI can render them. Use this only when the active code-review instructions tell you to report findings with this tool; otherwise follow whatever output format those instructions specify. When reporting a review's results, call it once with the verified findings ranked most-severe first (empty array if nothing survived verification) and do not also print the findings as text. When re-reporting after applying fixes (only if the apply instructions ask for it), set outcome on each finding to what actually happened.",
@@ -277,6 +277,64 @@ function optionalNonNegativeInteger(input, name) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function hasOnlyInputKeys(input, allowed) {
+    const names = new Set(allowed);
+    return Object.keys(input).every((name) => names.has(name));
+}
+function localSchedulingInputIsValid(call) {
+    try {
+        if (call.name === 'Read') {
+            stringInput(call.input, 'file_path');
+            optionalNonNegativeInteger(call.input, 'offset');
+            optionalPositiveInteger(call.input, 'limit');
+            optionalString(call.input, 'pages');
+            return hasOnlyInputKeys(call.input, [
+                'file_path',
+                'offset',
+                'limit',
+                'pages',
+            ]);
+        }
+        if (call.name === 'Glob') {
+            stringInput(call.input, 'pattern', true);
+            optionalString(call.input, 'path');
+            return hasOnlyInputKeys(call.input, ['pattern', 'path']);
+        }
+        if (call.name === 'Grep') {
+            stringInput(call.input, 'pattern');
+            optionalString(call.input, 'path');
+            optionalString(call.input, 'glob');
+            return hasOnlyInputKeys(call.input, ['pattern', 'path', 'glob']);
+        }
+        if (call.name === 'Bash') {
+            stringInput(call.input, 'command');
+            optionalPositiveInteger(call.input, 'timeout');
+            const description = call.input.description;
+            const background = call.input.run_in_background;
+            const disableSandbox = call.input.dangerouslyDisableSandbox;
+            if (description !== undefined && typeof description !== 'string') {
+                return false;
+            }
+            if (background !== undefined && typeof background !== 'boolean') {
+                return false;
+            }
+            if (disableSandbox !== undefined && typeof disableSandbox !== 'boolean') {
+                return false;
+            }
+            return hasOnlyInputKeys(call.input, [
+                'command',
+                'timeout',
+                'description',
+                'run_in_background',
+                'dangerouslyDisableSandbox',
+            ]);
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 const REPORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
 const REPORT_VERDICTS = ['CONFIRMED', 'PLAUSIBLE'];
 const REPORT_OUTCOMES = ['fixed', 'skipped', 'no_change_needed'];
@@ -535,6 +593,33 @@ export class LocalToolRegistry {
             }
             : definition);
     }
+    schedulingPolicy(call) {
+        if (['Read', 'Glob', 'Grep'].includes(call.name) &&
+            localSchedulingInputIsValid(call)) {
+            return { concurrency: 'concurrent', cancelOnInterrupt: true };
+        }
+        if (call.name === 'Bash' &&
+            localSchedulingInputIsValid(call) &&
+            call.input.run_in_background !== true &&
+            typeof call.input.command === 'string' &&
+            shellInputIsReadOnly(call.input.command)) {
+            return {
+                concurrency: 'concurrent',
+                cancelOnInterrupt: true,
+                abortGroupOnError: true,
+            };
+        }
+        if (TOOL_DEFINITIONS.some(({ name }) => name === call.name)) {
+            return {
+                concurrency: 'exclusive',
+                cancelOnInterrupt: true,
+                ...(call.name === 'Bash' ? { abortGroupOnError: true } : {}),
+            };
+        }
+        return {
+            concurrency: 'exclusive',
+        };
+    }
     async prepare(call, context) {
         if (context.signal?.aborted)
             throw abortError();

package/dist/tools/web.d.ts

@@ -36,6 +36,7 @@ export declare class WebToolRegistry implements ToolRegistry {
     private cacheBytes;
     constructor(options: WebToolRegistryOptions);
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     private webFetch;

package/dist/tools/web.js

@@ -6,6 +6,7 @@ import { isIP } from 'node:net';
 import { join } from 'node:path';
 import ipaddr from 'ipaddr.js';
 import TurndownService from 'turndown';
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 const MAX_URL_LENGTH = 2_000;
 const MAX_MARKDOWN_LENGTH = 100_000;
 const DEFAULT_MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
@@ -273,6 +274,24 @@ function parseWebSearchInput(input) {
         ...(blockedDomains ? { blockedDomains } : {}),
     };
 }
+function webSchedulingInputIsValid(call) {
+    try {
+        if (call.name === 'WebFetch') {
+            parseWebFetchInput(call.input);
+            return Object.keys(call.input).every((name) => name === 'url' || name === 'prompt');
+        }
+        if (call.name === 'WebSearch') {
+            parseWebSearchInput(call.input);
+            return Object.keys(call.input).every((name) => name === 'query' ||
+                name === 'allowed_domains' ||
+                name === 'blocked_domains');
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 function normalizedAddress(value) {
     const parsed = ipaddr.parse(value);
     return parsed instanceof ipaddr.IPv6 && parsed.isIPv4MappedAddress()
@@ -475,6 +494,14 @@ export class WebToolRegistry {
                 : []),
         ];
     }
+    schedulingPolicy(call) {
+        if (call.name === 'WebFetch' || call.name === 'WebSearch') {
+            return webSchedulingInputIsValid(call)
+                ? { concurrency: 'concurrent', cancelOnInterrupt: true }
+                : { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.options.base, call);
+    }
     async prepare(call, context) {
         if (context.signal?.aborted)
             throw abortError();

package/package.json

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