praxis-agent 0.46.1 → 0.46.4

package/dist/tools/local-tools.js

@@ -1,4 +1,5 @@
 import { constants } from 'node:fs';
+import { randomBytes, randomInt } from 'node:crypto';
 import { mkdir, mkdtemp, open, realpath, stat, writeFile, } from 'node:fs/promises';
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
@@ -247,6 +248,20 @@ function stringInput(input, name, allowEmpty = false) {
     }
     return value;
 }
+function stripShellControlTrace(content, token) {
+    if (!content.includes(token))
+        return content;
+    return content
+        .split('\n')
+        .filter((line) => !line.includes(token))
+        .join('\n');
+}
+function commandShellSyntaxArguments(command) {
+    const args = [...commandShellArguments(command)];
+    const commandIndex = args.indexOf('-c');
+    args.splice(commandIndex, 0, '-n');
+    return args;
+}
 function optionalString(input, name) {
     const value = input[name];
     if (value === undefined)
@@ -480,6 +495,14 @@ function formatKilobytes(bytes) {
     const value = bytes / 1024;
     return `${value < 10 ? value.toFixed(1) : Math.round(value)}KB`.replace('.0KB', 'KB');
 }
+function newlineStyle(content) {
+    return content.match(/\r\n|\n|\r/u)?.[0];
+}
+function normalizeNewlines(content, style) {
+    if (style === undefined)
+        return content;
+    return content.replace(/\r\n|\n|\r/gu, style);
+}
 function parsePdfPages(value) {
     const match = /^(\d+)(?:-(\d+))?$/u.exec(value);
     if (!match)
@@ -506,6 +529,7 @@ export class LocalToolRegistry {
     maxOutputBytes;
     maxFileBytes;
     maxShellTimeoutMs;
+    maxSearchTimeoutMs;
     processRunner;
     enableReportFindings;
     environment;
@@ -513,7 +537,9 @@ export class LocalToolRegistry {
     sandbox;
     homeDirectory;
     configRoot;
+    sessionCwds = new Map();
     protectedWriteReason;
+    mutationTargetExisted = new WeakMap();
     constructor(options) {
         this.cwd = resolve(options.cwd);
         this.cwdProvider = options.cwdProvider;
@@ -524,7 +550,8 @@ export class LocalToolRegistry {
         this.additionalReadDirectories = (options.additionalReadDirectories ?? []).map((directory) => resolve(directory));
         this.maxOutputBytes = options.maxOutputBytes ?? 128 * 1024;
         this.maxFileBytes = options.maxFileBytes ?? 10 * 1024 * 1024;
-        this.maxShellTimeoutMs = options.maxShellTimeoutMs ?? 120_000;
+        this.maxShellTimeoutMs = options.maxShellTimeoutMs ?? 600_000;
+        this.maxSearchTimeoutMs = options.maxShellTimeoutMs ?? 120_000;
         this.enableReportFindings = options.enableReportFindings ?? false;
         this.environment = options.environment;
         this.sessionEnvironment = options.sessionEnvironment;
@@ -551,7 +578,7 @@ export class LocalToolRegistry {
         }
     }
     assertProtectedBashCommand(command, context) {
-        const cwd = this.currentCwd(context);
+        const cwd = this.currentBashCwd(context);
         const protectedWrite = context?.preToolUseAllowed
             ? (filePath) => {
                 const reason = this.protectedWriteReason(filePath);
@@ -576,6 +603,18 @@ export class LocalToolRegistry {
     currentCwd(context) {
         return resolve(context?.cwd || this.cwdProvider?.() || this.cwd);
     }
+    currentBashCwd(context) {
+        const hostCwd = this.currentCwd(context);
+        if (context?.sessionId) {
+            const sessionCwd = this.sessionCwds.get(context.sessionId);
+            if (sessionCwd) {
+                if (sessionCwd.hostCwd === hostCwd)
+                    return sessionCwd.cwd;
+                this.sessionCwds.delete(context.sessionId);
+            }
+        }
+        return hostCwd;
+    }
     definitions() {
         const definitions = this.enableReportFindings
             ? [...TOOL_DEFINITIONS, REPORT_FINDINGS_DEFINITION]
@@ -646,28 +685,48 @@ export class LocalToolRegistry {
                     },
                 };
             }
-            case 'Write':
-                return {
+            case 'Write': {
+                const filePath = await this.filePath(stringInput(call.input, 'file_path'), true, false, context);
+                this.assertProtectedWritePath(filePath);
+                const targetExisted = await this.pathExists(filePath);
+                if (targetExisted &&
+                    !(await this.wasSuccessfullyRead(filePath, context.messages ?? [], context))) {
+                    throw new Error('<tool_use_error>File has not been read yet. Read it first before writing to it.</tool_use_error>');
+                }
+                const prepared = {
                     ...call,
                     input: {
-                        file_path: await this.filePath(stringInput(call.input, 'file_path'), true, false, context),
+                        file_path: filePath,
                         content: stringInput(call.input, 'content', true),
                     },
                 };
+                this.mutationTargetExisted.set(prepared, targetExisted);
+                return prepared;
+            }
             case 'Edit': {
                 const replaceAll = call.input.replace_all;
                 if (replaceAll !== undefined && typeof replaceAll !== 'boolean') {
                     throw new Error('replace_all must be a boolean');
                 }
-                return {
+                const oldString = stringInput(call.input, 'old_string', true);
+                const filePath = await this.filePath(stringInput(call.input, 'file_path'), oldString === '', false, context);
+                this.assertProtectedWritePath(filePath);
+                const targetExisted = await this.pathExists(filePath);
+                if (targetExisted &&
+                    !(await this.wasSuccessfullyRead(filePath, context.messages ?? [], context))) {
+                    throw new Error('<tool_use_error>File has not been read yet. Read it first before writing to it.</tool_use_error>');
+                }
+                const prepared = {
                     ...call,
                     input: {
-                        file_path: await this.filePath(stringInput(call.input, 'file_path'), false, false, context),
-                        old_string: stringInput(call.input, 'old_string'),
+                        file_path: filePath,
+                        old_string: oldString,
                         new_string: stringInput(call.input, 'new_string', true),
                         replace_all: replaceAll ?? false,
                     },
                 };
+                this.mutationTargetExisted.set(prepared, targetExisted);
+                return prepared;
             }
             case 'NotebookEdit': {
                 const requestedPath = stringInput(call.input, 'notebook_path');
@@ -759,17 +818,24 @@ export class LocalToolRegistry {
     async execute(call, context) {
         if (context.signal?.aborted)
             throw abortError();
+        const approvedTargetExisted = this.mutationTargetExisted.get(call);
         const prepared = await this.prepare(call, context);
         if (JSON.stringify(prepared.input) !== JSON.stringify(call.input)) {
             throw new Error('Tool input changed after permission approval');
         }
+        const executionTargetExisted = this.mutationTargetExisted.get(prepared);
+        if (approvedTargetExisted !== undefined &&
+            executionTargetExisted !== approvedTargetExisted) {
+            throw new Error('Tool input changed after permission approval');
+        }
+        const targetExisted = approvedTargetExisted ?? executionTargetExisted;
         switch (prepared.name) {
             case 'Read':
                 return this.read(prepared, context);
             case 'Write':
-                return this.write(prepared);
+                return this.write(prepared, context, targetExisted);
             case 'Edit':
-                return this.edit(prepared);
+                return this.edit(prepared, targetExisted);
             case 'NotebookEdit':
                 return this.notebookEdit(prepared);
             case 'Glob':
@@ -864,11 +930,28 @@ export class LocalToolRegistry {
             return join(parent, basename(candidate));
         }
     }
+    async pathExists(filePath) {
+        try {
+            await stat(filePath);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
     async assertStablePath(filePath) {
         if ((await realpath(filePath)) !== filePath) {
             throw new Error('Tool input changed after permission approval');
         }
     }
+    async assertStableCreationParent(filePath) {
+        const parent = dirname(filePath);
+        if ((await realpath(parent)) !== parent) {
+            throw new Error('Tool input changed after permission approval');
+        }
+    }
     async globRoot(requestedPath, context) {
         const displayedPath = isAbsolute(requestedPath)
             ? resolve(requestedPath)
@@ -1053,21 +1136,19 @@ export class LocalToolRegistry {
         await mkdir(parent, { recursive: true });
         return mkdtemp(join(parent, 'pdf-'));
     }
-    async write(call) {
+    async write(call, context, preparedTargetExisted) {
         const filePath = stringInput(call.input, 'file_path');
         this.assertProtectedWritePath(filePath);
-        const content = stringInput(call.input, 'content', true);
-        if (Buffer.byteLength(content) > this.maxFileBytes) {
-            throw new Error(`Content exceeds ${this.maxFileBytes} byte write limit`);
-        }
+        const requestedContent = stringInput(call.input, 'content', true);
         let handle;
         let newFile = false;
-        try {
-            handle = await open(filePath, constants.O_RDWR | constants.O_NOFOLLOW);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
+        const hasRead = await this.wasSuccessfullyRead(filePath, context.messages ?? [], context);
+        const targetExisted = preparedTargetExisted ?? (await this.pathExists(filePath));
+        if (!targetExisted) {
+            if (Buffer.byteLength(requestedContent) > this.maxFileBytes) {
+                throw new Error(`Content exceeds ${this.maxFileBytes} byte write limit`);
+            }
+            await this.assertStableCreationParent(filePath);
             try {
                 handle = await open(filePath, constants.O_RDWR |
                     constants.O_CREAT |
@@ -1076,19 +1157,40 @@ export class LocalToolRegistry {
                 newFile = true;
             }
             catch (createError) {
-                if (createError.code !== 'EEXIST') {
-                    throw createError;
+                if (createError.code === 'EEXIST') {
+                    throw new Error('<tool_use_error>File has not been read yet. Read it first before writing to it.</tool_use_error>');
                 }
+                throw createError;
+            }
+        }
+        else {
+            if (!hasRead) {
+                throw new Error('<tool_use_error>File has not been read yet. Read it first before writing to it.</tool_use_error>');
+            }
+            try {
                 handle = await open(filePath, constants.O_RDWR | constants.O_NOFOLLOW);
             }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    throw new Error('Tool input changed after permission approval');
+                }
+                throw error;
+            }
         }
         try {
             await this.assertStablePath(filePath);
             const metadata = await handle.stat();
             if (!metadata.isFile())
                 throw new Error(`Not a file: ${filePath}`);
+            if (!newFile && metadata.size > this.maxFileBytes) {
+                throw new Error(`File exceeds ${this.maxFileBytes} byte write limit`);
+            }
             const preContent = newFile ? '' : await handle.readFile('utf8');
+            const content = normalizeNewlines(requestedContent, newlineStyle(preContent));
             const encoded = Buffer.from(content);
+            if (encoded.length > this.maxFileBytes) {
+                throw new Error(`Content exceeds ${this.maxFileBytes} byte write limit`);
+            }
             const { linesAdded, linesRemoved } = countLineChanges(preContent, content, preContent === '' ? { newFile: true } : undefined);
             await handle.write(encoded, 0, encoded.length, 0);
             await handle.truncate(encoded.length);
@@ -1098,28 +1200,84 @@ export class LocalToolRegistry {
                 isError: false,
                 linesAdded,
                 linesRemoved,
+                nativeToolUseResult: { filePath, content },
             };
         }
         finally {
             await handle.close();
         }
     }
-    async edit(call) {
+    async edit(call, preparedTargetExisted) {
         const filePath = stringInput(call.input, 'file_path');
         this.assertProtectedWritePath(filePath);
-        const oldString = stringInput(call.input, 'old_string');
+        const oldString = stringInput(call.input, 'old_string', true);
         const newString = stringInput(call.input, 'new_string', true);
-        const handle = await open(filePath, constants.O_RDWR | constants.O_NOFOLLOW);
+        if (oldString === '' && Buffer.byteLength(newString) > this.maxFileBytes) {
+            throw new Error(`Content exceeds ${this.maxFileBytes} byte write limit`);
+        }
+        let handle;
+        let newFile = false;
+        if (oldString === '') {
+            const targetExisted = preparedTargetExisted ?? (await this.pathExists(filePath));
+            if (targetExisted) {
+                handle = await open(filePath, constants.O_RDWR | constants.O_NOFOLLOW);
+            }
+            else {
+                await this.assertStableCreationParent(filePath);
+                try {
+                    handle = await open(filePath, constants.O_RDWR |
+                        constants.O_CREAT |
+                        constants.O_EXCL |
+                        constants.O_NOFOLLOW, 0o666);
+                    newFile = true;
+                }
+                catch (error) {
+                    if (error.code === 'EEXIST') {
+                        throw new Error('Tool input changed after permission approval');
+                    }
+                    throw error;
+                }
+            }
+        }
+        else {
+            handle = await open(filePath, constants.O_RDWR | constants.O_NOFOLLOW);
+        }
         try {
             await this.assertStablePath(filePath);
             const metadata = await handle.stat();
             if (!metadata.isFile())
                 throw new Error(`Not a file: ${filePath}`);
+            if (newFile) {
+                const content = newString;
+                const encoded = Buffer.from(content);
+                if (encoded.length > this.maxFileBytes) {
+                    throw new Error(`Content exceeds ${this.maxFileBytes} byte write limit`);
+                }
+                const { linesAdded, linesRemoved } = countLineChanges('', content, {
+                    newFile: true,
+                });
+                await handle.write(encoded, 0, encoded.length, 0);
+                await handle.truncate(encoded.length);
+                await handle.sync();
+                return {
+                    content: `Replaced 1 occurrence(s)`,
+                    isError: false,
+                    linesAdded,
+                    linesRemoved,
+                    nativeToolUseResult: { filePath, content },
+                };
+            }
+            if (oldString === '') {
+                throw new Error('Edit with an empty old_string is only valid for creating a missing file');
+            }
             if (metadata.size > this.maxFileBytes) {
                 throw new Error(`File exceeds ${this.maxFileBytes} byte edit limit`);
             }
             const source = await handle.readFile('utf8');
-            const occurrences = source.split(oldString).length - 1;
+            const style = newlineStyle(source);
+            const normalizedOldString = normalizeNewlines(oldString, style);
+            const normalizedNewString = normalizeNewlines(newString, style);
+            const occurrences = source.split(normalizedOldString).length - 1;
             if (occurrences === 0)
                 throw new Error('old_string was not found');
             if (call.input.replace_all !== true && occurrences !== 1) {
@@ -1128,13 +1286,14 @@ export class LocalToolRegistry {
             const replacementCount = call.input.replace_all === true ? occurrences : 1;
             const outputBytes = Buffer.byteLength(source) +
                 replacementCount *
-                    (Buffer.byteLength(newString) - Buffer.byteLength(oldString));
+                    (Buffer.byteLength(normalizedNewString) -
+                        Buffer.byteLength(normalizedOldString));
             if (outputBytes > this.maxFileBytes) {
                 throw new Error(`Edited content exceeds ${this.maxFileBytes} bytes`);
             }
             const output = call.input.replace_all === true
-                ? source.replaceAll(oldString, newString)
-                : source.replace(oldString, newString);
+                ? source.replaceAll(normalizedOldString, normalizedNewString)
+                : source.replace(normalizedOldString, normalizedNewString);
             const { linesAdded, linesRemoved } = countLineChanges(source, output);
             const encoded = Buffer.from(output);
             await handle.write(encoded, 0, encoded.length, 0);
@@ -1145,6 +1304,7 @@ export class LocalToolRegistry {
                 isError: false,
                 linesAdded,
                 linesRemoved,
+                nativeToolUseResult: { filePath, content: output },
             };
         }
         finally {
@@ -1191,7 +1351,7 @@ export class LocalToolRegistry {
     async glob(call, context) {
         const requestedPath = call.input.path === undefined ? '.' : stringInput(call.input, 'path');
         const root = await this.globRoot(requestedPath, context);
-        const timeoutSignal = AbortSignal.timeout(this.maxShellTimeoutMs);
+        const timeoutSignal = AbortSignal.timeout(this.maxSearchTimeoutMs);
         const searchSignal = context.signal
             ? AbortSignal.any([context.signal, timeoutSignal])
             : timeoutSignal;
@@ -1215,7 +1375,7 @@ export class LocalToolRegistry {
                 throw abortError();
             if (timeoutSignal.aborted) {
                 return {
-                    content: `Search timed out after ${this.maxShellTimeoutMs}ms`,
+                    content: `Search timed out after ${this.maxSearchTimeoutMs}ms`,
                     isError: true,
                 };
             }
@@ -1240,14 +1400,14 @@ export class LocalToolRegistry {
         const result = await this.processRunner.run({
             command: 'rg',
             args,
-            timeoutMs: this.maxShellTimeoutMs,
+            timeoutMs: this.maxSearchTimeoutMs,
             cwd: this.currentCwd(context),
             ...(this.environment ? { env: this.environment } : {}),
             ...(context.signal ? { signal: context.signal } : {}),
         });
         if (result.timedOut) {
             return {
-                content: `Search timed out after ${this.maxShellTimeoutMs}ms`,
+                content: `Search timed out after ${this.maxSearchTimeoutMs}ms`,
                 isError: true,
             };
         }
@@ -1274,39 +1434,131 @@ export class LocalToolRegistry {
         };
         const sandboxed = this.sandbox?.shouldUseSandbox(sandboxPolicyInput) ?? false;
         const shell = commandShell();
+        let cwdToken;
+        let sandboxCommandAttempted = false;
         let result;
         try {
             const sessionEnvironment = context.sessionId
                 ? await this.sessionEnvironment?.(context.sessionId)
                 : undefined;
-            const command = sandboxed
-                ? await this.sandbox?.wrapCommand(sandboxPolicyInput, {
-                    shell,
+            const processEnvironment = this.environment || sessionEnvironment
+                ? { env: { ...this.environment, ...sessionEnvironment } }
+                : {};
+            let executionTimeout = timeout;
+            let syntaxTimeoutResult;
+            if (context.sessionId) {
+                const syntaxStartedAt = Date.now();
+                const syntaxResult = await this.processRunner.run({
+                    command: shell,
+                    args: commandShellSyntaxArguments(rawCommand),
+                    timeoutMs: timeout,
+                    cwd: this.currentBashCwd(context),
+                    ...processEnvironment,
                     ...(context.signal ? { signal: context.signal } : {}),
-                    commandId: call.id,
-                })
+                });
+                executionTimeout = Math.max(1, timeout - (Date.now() - syntaxStartedAt));
+                if (syntaxResult.timedOut) {
+                    syntaxTimeoutResult = syntaxResult;
+                }
+                else if (syntaxResult.code === 0) {
+                    cwdToken = randomBytes(16).toString('hex');
+                }
+            }
+            const controlOutputFd = cwdToken ? randomInt(5, 10) : undefined;
+            const statusVariable = cwdToken
+                ? `_praxis_exit_status_${cwdToken}`
+                : undefined;
+            const trapStatusVariable = cwdToken
+                ? `_praxis_trap_status_${cwdToken}`
+                : undefined;
+            const cwdReportCommand = cwdToken && controlOutputFd
+                ? `{ printf "%s%s\\0" "${cwdToken}" "$(pwd -P 2>/dev/null)" >&${controlOutputFd}; } 2>/dev/null`
+                : undefined;
+            const executionCommand = cwdToken && trapStatusVariable && cwdReportCommand
+                ? `if [ -n "\${ZSH_VERSION-}" ]; then 0=${JSON.stringify(shell)}; fi
+trap '${trapStatusVariable}=$?; ${cwdReportCommand}; exit "$${trapStatusVariable}"' EXIT
+${rawCommand}
+${statusVariable}=$?
+${cwdReportCommand}
+exit "$${statusVariable}"`
                 : rawCommand;
-            result = await this.processRunner.run({
-                command: shell,
-                args: commandShellArguments(command ?? rawCommand),
-                timeoutMs: timeout,
-                cwd: this.currentCwd(context),
-                ...(this.environment || sessionEnvironment
-                    ? { env: { ...this.environment, ...sessionEnvironment } }
-                    : {}),
-                ...(context.signal ? { signal: context.signal } : {}),
-            });
+            const scriptLoaderCommand = 'eval "$(cat <&4)"';
+            if (syntaxTimeoutResult) {
+                result = syntaxTimeoutResult;
+            }
+            else {
+                let command;
+                if (sandboxed) {
+                    sandboxCommandAttempted = true;
+                    command = await this.sandbox?.wrapCommand(cwdToken
+                        ? { ...sandboxPolicyInput, executionCommand: scriptLoaderCommand }
+                        : sandboxPolicyInput, {
+                        shell,
+                        ...(context.signal ? { signal: context.signal } : {}),
+                        commandId: call.id,
+                    });
+                }
+                else {
+                    command = cwdToken ? scriptLoaderCommand : rawCommand;
+                }
+                result = await this.processRunner.run({
+                    command: shell,
+                    args: commandShellArguments(command ?? rawCommand),
+                    timeoutMs: executionTimeout,
+                    cwd: this.currentBashCwd(context),
+                    ...processEnvironment,
+                    ...(context.signal ? { signal: context.signal } : {}),
+                    ...(cwdToken && controlOutputFd
+                        ? {
+                            controlOutputBytes: 8192,
+                            controlOutputFd,
+                            scriptInput: executionCommand,
+                        }
+                        : {}),
+                });
+            }
         }
         finally {
-            if (sandboxed)
+            if (sandboxCommandAttempted)
                 this.sandbox?.cleanupAfterCommand();
         }
-        if (sandboxed && this.sandbox) {
+        if (cwdToken) {
+            result = {
+                ...result,
+                stdout: stripShellControlTrace(result.stdout, cwdToken),
+                stderr: stripShellControlTrace(result.stderr, cwdToken),
+                output: stripShellControlTrace(result.output, cwdToken),
+            };
+        }
+        if (sandboxCommandAttempted && this.sandbox) {
             result = {
                 ...result,
                 stderr: this.sandbox.annotateStderr(call.id, result.stderr),
             };
         }
+        if (cwdToken && !result.timedOut && result.controlOutput) {
+            const controlRecord = result.controlOutput.startsWith(cwdToken)
+                ? result.controlOutput.slice(cwdToken.length)
+                : undefined;
+            const terminator = controlRecord?.indexOf('\0') ?? -1;
+            const record = controlRecord && terminator > 0
+                ? controlRecord.slice(0, terminator)
+                : undefined;
+            if (record) {
+                try {
+                    const canonicalCwd = await realpath(record);
+                    if ((await stat(canonicalCwd)).isDirectory() && context.sessionId) {
+                        this.sessionCwds.set(context.sessionId, {
+                            cwd: canonicalCwd,
+                            hostCwd: resolve(context.cwd || this.cwdProvider?.() || this.cwd),
+                        });
+                    }
+                }
+                catch {
+                    // A command may remove or replace its final directory. Keep prior state.
+                }
+            }
+        }
         if (result.timedOut) {
             return {
                 content: `Command timed out after ${timeout}ms`,

package/dist/tools/team-lead-tools.js

@@ -304,11 +304,12 @@ function validate(input, name) {
         for (const member of input.roster) {
             if (!member || typeof member !== 'object' || Array.isArray(member))
                 throw new Error('Invalid Team member');
-            objectInput(member, [
-                'name',
-                'agentType',
-                'access',
-            ]);
+            const value = member;
+            objectInput(value, ['name', 'agentType', 'access']);
+            stringValue(value, 'name');
+            stringValue(value, 'agentType');
+            if (value.access !== 'read-only' && value.access !== 'write')
+                throw new Error('Invalid Team member access');
         }
         for (const task of input.tasks) {
             if (!task || typeof task !== 'object' || Array.isArray(task))
@@ -321,6 +322,12 @@ function validate(input, name) {
                 'blockedBy',
                 'claims',
             ]);
+            stringValue(value, 'id');
+            stringValue(value, 'description');
+            stringValue(value, 'assignee');
+            if (!Array.isArray(value.blockedBy) ||
+                value.blockedBy.some((entry) => typeof entry !== 'string' || entry.trim() === ''))
+                throw new Error('Invalid Team blockedBy');
             if (!value.claims ||
                 typeof value.claims !== 'object' ||
                 Array.isArray(value.claims))
@@ -332,6 +339,18 @@ function validate(input, name) {
                 'migrations',
                 'mergeTargets',
             ]);
+            for (const key of [
+                'files',
+                'publicContracts',
+                'generatedArtifacts',
+                'migrations',
+                'mergeTargets',
+            ]) {
+                const entries = value.claims[key];
+                if (!Array.isArray(entries) ||
+                    entries.some((entry) => typeof entry !== 'string' || entry.trim() === ''))
+                    throw new Error(`Invalid Team claim list: ${key}`);
+            }
         }
         return input;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.46.1",
+  "version": "0.46.4",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",
@@ -29,7 +29,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "check": "npm run format:check && npm run lint && npm run test:docs && npm run verify:release-automation && npm run verify:ci-coverage && npm run check:boundaries && npm run typecheck && npm run build:native && npm run build && npm test",
+    "check": "npm run format:check && npm run lint && npm run test:docs && npm run verify:release-automation && npm run verify:ci-coverage && npm run verify:fixture-contracts && npm run check:boundaries && npm run typecheck && npm run build:native && npm run build && npm test",
     "check:boundaries": "node scripts/check-boundaries.mjs",
     "dev": "tsx src/cli.ts",
     "format": "prettier --write .",
@@ -44,11 +44,11 @@
     "release:artifacts": "node scripts/build-release-artifacts.mjs",
     "release:verify": "node scripts/verify-release-ref.mjs",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage && node scripts/verify-nonzero-runtime-coverage.mjs",
     "test:docs": "node scripts/verify-docs.mjs",
     "test:tui:pty": "npm run build && node scripts/verify-fullscreen-rendering.mjs && node scripts/verify-interactive-ansi.mjs",
     "test:self-update": "npm run build && node scripts/verify-self-update-contract.mjs",
-    "test:core-completion": "npm run build && node scripts/verify-core-completion-audit.mjs",
+    "test:core-completion": "npm run test:fixtures",
     "test:performance": "npm run build && node scripts/verify-projection-scaling.mjs && node scripts/verify-projection-regression.mjs && node scripts/verify-quiet-frame-performance.mjs",
     "test:performance:projection": "npm run build && node scripts/verify-projection-scaling.mjs",
     "test:performance:projection-regression": "npm run build && node scripts/verify-projection-regression.mjs",
@@ -56,9 +56,12 @@
     "test:prompt-suggestions": "npm run build && node scripts/verify-prompt-suggestions.mjs",
     "test:mcp-oauth-serve": "npm run build && node scripts/verify-mcp-oauth-serve.mjs",
     "test:package": "npm run build && node scripts/verify-native-release-package.mjs",
+    "test:security": "npm audit --omit=dev",
     "typecheck": "tsc --noEmit",
     "verify:release-automation": "node scripts/verify-release-automation.mjs",
-    "verify:ci-coverage": "node scripts/verify-ci-coverage.mjs"
+    "verify:ci-coverage": "node scripts/verify-ci-coverage.mjs",
+    "verify:fixture-contracts": "node scripts/verify-fixture-contracts.mjs",
+    "test:fixtures": "node scripts/run-fixture-contracts.mjs"
   },
   "engines": {
     "node": ">=24"