The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix: close release review gaps and expose failing CI suites
haelyra14e731c6d5f3
diff --git a/docs/releases/2.2.1/patch-execution.md b/docs/releases/2.2.1/patch-execution.mdindex f0faf4332..b8fdfbe5e 100644--- a/docs/releases/2.2.1/patch-execution.md+++ b/docs/releases/2.2.1/patch-execution.md@@ -106,3 +106,29 @@ after the guided-setup integration repair. Signing remains unavailable locally.Pending final hosted validation, signed tag, publication, registryintegrity readback, and clean lifecycle canaries. This document does not claimthat 2.2.1 has shipped.++## Resumed verification, September 7++The secure GitHub gateway authenticated as an authorized repository maintainer.+All GitHub API requests in this continuation use that gateway. No local+credential inspection or signing-key discovery is part of this continuation.+The v2.2.1 tag and release are absent; npm returns E404 for 2.2.1 and still+reports latest 2.2.0.++The ba3a64a2 hosted run passed coverage, lint, CodeQL, and Linux tests, but nine+Windows test jobs failed. Gateway downloads for both job logs and test artifacts+returned HTTP 401 from redirected storage. Check metadata confirms failures+occur during tests after successful dependency installation. Failed-suite+annotations now expose bounded diagnostic context through the checks API.+The runner also counts subprocess failure when a suite prints `Failed: 0`.+Seven isolated runner regressions pass.++Follow-up review reproduced additional release defects. Ordered JSON merges+to one Kimi destination were collapsed by destination-only preview indexing;+operation-specific previews preserve the supported merge sequence (24 focused+tests pass). Array-form Claude commands now receive the same plugin-root+materialization as strings, including rejection of unresolved reads (seven new+and 36 existing settings tests pass). Static PowerShell alias and stdin values+are resolved conservatively, with independent review covering mixed named and+positional alias arguments. Hosted verification on the final patch remains+required before merge or release.diff --git a/docs/releases/2.2.1/release-notes.md b/docs/releases/2.2.1/release-notes.mdindex 5bd695d1c..4d05b3c3d 100644--- a/docs/releases/2.2.1/release-notes.md+++ b/docs/releases/2.2.1/release-notes.md@@ -93,8 +93,9 @@ and signing evidence are tracked separately in the release checklist.## Upgrade-Install or update the published package, then run the same ECC command path you-already use:+After the release workflow publishes 2.2.1 and verifies registry integrity,+install or update the package, then run the same ECC command path you already+use. Until publication completes, the exact-version command below returns E404.```bashnpm install -g [email protected]diff --git a/scripts/lib/install/claude-settings.js b/scripts/lib/install/claude-settings.jsindex 3c18668a6..7075c5bd9 100644--- a/scripts/lib/install/claude-settings.js+++ b/scripts/lib/install/claude-settings.js@@ -255,6 +255,10 @@ function resolveManagedHookCommands(managedHooks, targetRoot) {const encodedRoot = Buffer.from(targetRoot, 'utf8').toString('base64');const rootExpression = `Buffer.from('${encodedRoot}','base64').toString('utf8')`;const resolveCommand = command => {+ // Leave invalid entries intact so managed-hook validation reports them.+ if (typeof command !== 'string') {+ return command;+ }const resolved = command.split(PLUGIN_ROOT_ENV_PROLOGUE).join(`var e=${rootExpression};`);@@ -273,9 +277,11 @@ function resolveManagedHookCommands(managedHooks, targetRoot) {...entry,hooks: entry.hooks.map(hook => ({...hook,- ...(typeof hook.command === 'string'+ ...(typeof hook.command === 'string' || Array.isArray(hook.command)? {- command: resolveCommand(hook.command),+ command: Array.isArray(hook.command)+ ? hook.command.map(resolveCommand)+ : resolveCommand(hook.command),}: {}),})),diff --git a/scripts/lib/multi-harness-setup.js b/scripts/lib/multi-harness-setup.jsindex 3b9b9eee0..141eb4206 100644--- a/scripts/lib/multi-harness-setup.js+++ b/scripts/lib/multi-harness-setup.js@@ -373,9 +373,12 @@ async function applyPreflightedManagedPlan(entry) {: preflightManagedPlan(entry.preview.plan);const ownedDestinations = new Set(preview.ownershipSnapshot.destinations);let expectedStateFingerprint = preview.ownershipSnapshot.stateFingerprint;- const expectedOperations = new Map(preview.operations.map(operation => [- canonicalPath(operation.destinationPath), operation,+ // Several ordered JSON merges may share one destination. Preserve each+ // operation's preview instead of collapsing that sequence to one path entry.+ const expectedOperations = new Map(preview.plan.operations.map((operation, index) => [+ operation, preview.operations[index],]));+ const writtenDestinations = new Set();const assertStateUnchanged = () => (assertInstallStateUnchanged(preview.plan, expectedStateFingerprint));@@ -385,12 +388,17 @@ async function applyPreflightedManagedPlan(entry) {};const assertOperationUnchanged = operation => {const destination = canonicalPath(operation.destinationPath);- const expected = expectedOperations.get(destination);+ const expected = expectedOperations.get(operation);const currentClassification = classifyManagedOperation(operation, ownedDestinations);+ const expectedClassification = operation.kind === 'merge-json'+ && writtenDestinations.has(destination)+ ? 'managed-json-update'+ : expected && expected.classification;if (!expected|| expected.kind !== operation.kind- || expected.classification !== currentClassification+ || canonicalPath(expected.destinationPath) !== destination+ || expectedClassification !== currentClassification) {throw new Error(`Refusing to write ${operation.destinationPath}: destination changed after Kimi preflight.`@@ -412,6 +420,7 @@ async function applyPreflightedManagedPlan(entry) {assertStateUnchanged();const destination = assertOperationUnchanged(operation);ownedDestinations.add(destination);+ writtenDestinations.add(destination);},beforeInstallStateWrite: prepareInstallStateWrite,});diff --git a/scripts/lib/powershell-destructive-command.js b/scripts/lib/powershell-destructive-command.jsindex 77f3ac095..6ec294453 100644--- a/scripts/lib/powershell-destructive-command.js+++ b/scripts/lib/powershell-destructive-command.js@@ -58,6 +58,21 @@ const START_PROCESS_SWITCH_PARAMETERS = new Set(['usenewenvironment','wait',]);+const ALIAS_VALUE_PARAMETERS = new Set([+ 'name', 'value', 'description', 'option', 'scope',+ 'erroraction', 'warningaction', 'informationaction', 'progressaction',+ 'errorvariable', 'warningvariable', 'informationvariable',+ 'outvariable', 'outbuffer', 'pipelinevariable',+]);+const ALIAS_SWITCH_PARAMETERS = new Set([+ 'force', 'passthru', 'whatif', 'confirm', 'verbose', 'debug',+]);+const ALIAS_PARAMETER_ABBREVIATIONS = Object.freeze({+ ea: 'erroraction', wa: 'warningaction', infa: 'informationaction', proga: 'progressaction',+ ev: 'errorvariable', wv: 'warningvariable', iv: 'informationvariable',+ ov: 'outvariable', ob: 'outbuffer', pv: 'pipelinevariable',+ wi: 'whatif', cf: 'confirm', vb: 'verbose', db: 'debug',+});const MAX_SCAN_DEPTH = 4;const MAX_CONTEXT_LENGTH = 4096;const DYNAMIC_EXECUTION_MARKER = '__ecc_dynamic_execution__';@@ -1225,16 +1240,22 @@ function addNestedScan(payload, depth, findings, analysis, options = {}, scanStascanPowerShell(payload, depth + 1, findings, analysis, options, scanState);}-function staticPipelineInput(tokens) {+function staticTokenValue(tokens, index, state, findings, inline = false) {+ const value = inline ? parameterValue(tokens[index]) : tokens[index];+ const quoteKind = inline ? tokens.inlineValueQuoteKinds?.[index] : tokens.quoteKinds?.[index];+ if (quoteKind === "'") return value;+ const source = inline+ ? parameterValue(tokens.tokenSources?.[index] || tokens[index])+ : tokens.tokenSources?.[index] ?? value;+ return expandStaticDoubleQuotedString(source, state, findings);+}++function staticPipelineInput(tokens, state, findings) {if (!tokens || tokens.length === 0) return null;- if (tokens.length === 1) {- const value = String(tokens[0] || '');- return value || null;- }+ if (tokens.length === 1) return staticTokenValue(tokens, 0, state, findings);const command = commandBasename(tokens[0]);if ((command === 'write-output' || command === 'echo') && tokens.length === 2) {- const value = String(tokens[1] || '');- return tokens.quotedTokens?.[1] === true || /\s/.test(value) ? value : null;+ return staticTokenValue(tokens, 1, state, findings);}return null;}@@ -1272,7 +1293,7 @@ function scanNestedPowerShell(tokens, depth, findings, analysis, scanState, upstlet payload = inlinePayload? [inlinePayload, ...tokens.slice(index + 1)].join(' '): tokens.slice(index + 1).join(' ');- const pipelinePayload = payload === '-' ? staticPipelineInput(upstreamTokens) : null;+ const pipelinePayload = payload === '-' ? staticPipelineInput(upstreamTokens, scanState, findings) : null;const payloadIndex = index + 1;const inlineQuoteKind = tokens.inlineValueQuoteKinds?.[index];if (inlinePayload && inlineQuoteKind !== "'") {@@ -1754,26 +1775,70 @@ function scanScriptBlockConsumer(tokens, quotedTokens, findings, state) {}}-function staticAliasDefinition(tokens, quotedTokens = []) {- let name = null;- let value = null;+function aliasParameterName(token) {+ const name = String(token).replace(/^-+/, '').split(':')[0].toLowerCase();+ if (Object.hasOwn(ALIAS_PARAMETER_ABBREVIATIONS, name)) return ALIAS_PARAMETER_ABBREVIATIONS[name];+ const parameters = [...ALIAS_VALUE_PARAMETERS, ...ALIAS_SWITCH_PARAMETERS];+ if (parameters.includes(name)) return name;+ const matches = parameters.filter(parameter => name && parameter.startsWith(name));+ return matches.length === 1 ? matches[0] : null;+}++function aliasArguments(tokens, quotedTokens) {+ const named = new Map();const positional = [];+ let ambiguous = false;for (let index = 1; index < tokens.length; index += 1) {- const token = tokens[index];- if (!quotedTokens[index] && isParameterPrefix(token, 'name')) {- name = parameterValue(token) || tokens[++index] || null;- } else if (!quotedTokens[index] && isParameterPrefix(token, 'value')) {- value = parameterValue(token) || tokens[++index] || null;- } else if (!String(token).startsWith('-')) {- positional.push(token);+ const token = String(tokens[index]);+ if (quotedTokens[index] || !token.startsWith('-')) {+ positional.push({ index, inline: false });+ if (!quotedTokens[index] && token.startsWith('@')) ambiguous = true;+ continue;+ }+ const parameter = aliasParameterName(token);+ if (!parameter) {+ ambiguous = true;+ continue;+ }+ if (named.has(parameter)) ambiguous = true;+ const inline = token.includes(':');+ const argument = { index: ALIAS_VALUE_PARAMETERS.has(parameter) && !inline ? ++index : index, inline };+ if (ALIAS_VALUE_PARAMETERS.has(parameter) && tokens[argument.index] === undefined) ambiguous = true;+ named.set(parameter, argument);+ // Option accepts a comma-separated array; its continuation belongs to the+ // named parameter rather than the remaining positional name/value slots.+ if (parameter === 'option') {+ while (index + 1 < tokens.length && !quotedTokens[index] &&+ (String(tokens[index]).endsWith(',') || String(tokens[index + 1]).startsWith(','))) index += 1;}}- name ||= positional[0] || null;- value ||= positional[1] || null;- if (!/^[A-Za-z_][\w-]*$/.test(name || '') || !/^[A-Za-z_][\w./\\-]*$/.test(value || '')) {- return null;- }- return { name: name.toLowerCase(), value };+ return { named, positional, ambiguous };+}++function staticAliasDefinitions(tokens, quotedTokens, state) {+ const args = aliasArguments(tokens, quotedTokens);+ // Definitions stay inert. Uncertain binding is gated only when a candidate+ // alias is invoked, without allowing auxiliary values to hide its target.+ const unresolved = new Set();+ const resolve = argument => argument+ ? staticTokenValue(tokens, argument.index, state, unresolved, argument.inline)+ : null;+ let positionalIndex = 0;+ const nameArgument = args.named.get('name') || args.positional[positionalIndex++];+ const valueArgument = args.named.get('value') || args.positional[positionalIndex++];+ const name = resolve(nameArgument);+ const value = resolve(valueArgument);+ const ambiguous = args.ambiguous || positionalIndex < args.positional.length;+ const possibleNames = args.named.has('value') ? args.positional : args.positional.slice(0, -1);+ const names = ambiguous && !args.named.has('name')+ ? [name, ...possibleNames.map(resolve)]+ : [name];+ const target = ambiguous || value === null || /^@/.test(value)+ ? DYNAMIC_EXECUTION_MARKER+ : value;+ if (!/^[A-Za-z_][\w./\\-]*$/.test(target || '')) return [];+ return [...new Set(names.filter(candidate => /^[A-Za-z_][\w-]*$/.test(candidate || '')))]+ .map(candidate => ({ name: candidate.toLowerCase(), value: target }));}function scanInvokeScriptCalls(source, unquoted, depth, findings, analysis, state) {@@ -1862,9 +1927,10 @@ function scanPowerShell(command, depth, findings, analysis = null, options = {},state);}- if (commandName === 'set-alias' || commandName === 'new-alias') {- const definition = staticAliasDefinition(tokens, executable.quotedTokens);- if (definition) state.aliases.set(definition.name, definition.value);+ if (['set-alias', 'new-alias', 'sal', 'nal'].includes(commandName)) {+ for (const definition of staticAliasDefinitions(tokens, executable.quotedTokens, state)) {+ state.aliases.set(definition.name, definition.value);+ }}const classInvocation = commandName.match(/^\[([a-z_][\w-]*)\]::/i);if (classInvocation) recordInvocation(state, `__class__:${classInvocation[1].toLowerCase()}`);diff --git a/tests/ci/run-all.test.js b/tests/ci/run-all.test.jsnew file mode 100644index 000000000..21c760c86--- /dev/null+++ b/tests/ci/run-all.test.js@@ -0,0 +1,112 @@+'use strict';++const assert = require('assert');+const fs = require('fs');+const path = require('path');+const vm = require('vm');++const source = fs.readFileSync(path.join(__dirname, '..', 'run-all.js'), 'utf8');++function run(result, filename = 'sample.test.js', actions = true) {+ const logs = [];+ const exit = {};+ let status;+ let spawns = 0;+ const fakeProcess = {+ env: actions ? { GITHUB_ACTIONS: 'true' } : {},+ exit(code) { status = code; throw exit; },+ };+ const fakeFs = {+ readdirSync: () => [{+ name: filename,+ isDirectory: () => false,+ isFile: () => true,+ }],+ existsSync: () => true,+ };+ try {+ vm.runInNewContext(source, {+ __dirname: path.resolve('/virtual/tests'),+ process: fakeProcess,+ console: { log: (...args) => logs.push(args.join(' ')) },+ require(name) {+ if (name === 'fs') return fakeFs;+ if (name === 'path') return path;+ if (name === 'child_process') return {+ spawnSync() { spawns += 1; return result; },+ };+ throw new Error(`Unexpected dependency: ${name}`);+ },+ });+ } catch (error) {+ if (error !== exit) throw error;+ }+ assert.strictEqual(spawns, 1);+ return { status, logs, annotations: logs.filter(line => line.startsWith('::error ')) };+}++const tests = [+ ['nonzero exit overrides a zero-failure summary', () => {+ const result = run({ status: 1, stdout: 'Passed: 2, Failed: 0', stderr: 'Error: late crash' });+ assert.strictEqual(result.status, 1);+ assert.strictEqual(result.annotations.length, 1);+ assert.match(result.annotations[0], /file=tests\/sample.test.js/);+ assert.match(result.annotations[0], /status 1.*Error: late crash/);+ assert.ok(result.logs.includes('Error: late crash'));+ }],+ ['startup errors always count as failures and annotate their cause', () => {+ const result = run({ status: null, stdout: 'Failed: 0', error: new Error('spawn node ENOENT') });+ assert.strictEqual(result.status, 1);+ assert.strictEqual(result.annotations.length, 1);+ assert.match(result.annotations[0], /failed to start.*spawn node ENOENT/);+ }],+ ['annotation properties and messages escape workflow command characters', () => {+ const result = run({ status: null, error: new Error('100% broken\r\nnext line') }, 'sample%,:.test.js');+ assert.strictEqual(result.annotations.length, 1);+ assert.ok(result.annotations[0].includes('file=tests/sample%25%2C%3A.test.js'));+ assert.ok(result.annotations[0].includes('100%25 broken%0D%0Anext line'));+ assert.ok(!result.annotations[0].includes('\n'));+ assert.ok(!result.annotations[0].includes('\r'));+ }],+ ['failure summaries annotate concise context even with a successful exit', () => {+ const output = `${'routine log\n'.repeat(100)}FAIL regression example\nPassed: 2, Failed: 1`;+ const result = run({ status: 0, stdout: output });+ assert.strictEqual(result.status, 1);+ assert.strictEqual(result.annotations.length, 1);+ assert.match(result.annotations[0], /FAIL regression example/);+ assert.ok(result.annotations[0].length < 1500);+ assert.ok(!result.annotations[0].includes('routine log'));+ assert.ok(result.logs.includes(output));+ assert.ok(result.logs.some(line => /Failed:\s+1\s/.test(line)));+ }],+ ['signals fail even when no summary was printed', () => {+ const result = run({ status: null, signal: 'SIGTERM' });+ assert.strictEqual(result.status, 1);+ assert.match(result.annotations[0], /SIGTERM/);+ }],+ ['healthy suites preserve successful totals and emit no annotation', () => {+ const result = run({ status: 0, stdout: 'Passed: 3, Failed: 0' });+ assert.strictEqual(result.status, 0);+ assert.deepStrictEqual(result.annotations, []);+ assert.ok(result.logs.some(line => /Passed:\s+3\s/.test(line)));+ }],+ ['local failures retain console diagnostics without workflow annotations', () => {+ const result = run({ status: 1, stderr: 'Error: local failure' }, 'sample.test.js', false);+ assert.strictEqual(result.status, 1);+ assert.deepStrictEqual(result.annotations, []);+ assert.ok(result.logs.includes('Error: local failure'));+ }],+];++let failed = 0;+for (const [name, test] of tests) {+ try {+ test();+ console.log(`PASS ${name}`);+ } catch (error) {+ failed += 1;+ console.error(`FAIL ${name}\n${error.stack || error.message}`);+ }+}+console.log(`Passed: ${tests.length - failed}, Failed: ${failed}`);+process.exitCode = failed ? 1 : 0;diff --git a/tests/hooks/gateguard-fact-force.test.js b/tests/hooks/gateguard-fact-force.test.jsindex abf328201..495928691 100644--- a/tests/hooks/gateguard-fact-force.test.js+++ b/tests/hooks/gateguard-fact-force.test.js@@ -3020,6 +3020,20 @@ function runTests() {"$payload='Remove-Item -Force C:/tmp/demo'; pwsh -Command \"$payload\"","$payload='Remove-Item -Force C:/tmp/demo'; pwsh -Command \"Write-Output ready; $payload\"","$payload='Remove-Item'; pwsh -Command $payload -Force C:/tmp/demo",+ "$cmd='Remove-Item'; Set-Alias zap $cmd; zap -Force C:/tmp/demo",+ "$cmd='Remove-Item'; Set-Alias -Name zap $cmd; zap -Force C:/tmp/demo",+ "$cmd='Remove-Item'; Set-Alias -Scope Global -Name zap $cmd; zap -Force C:/tmp/demo",+ "$cmd='Remove-Item'; New-Alias -Description demo -Name zap $cmd; zap -Force C:/tmp/demo",+ "$cmd='Remove-Item'; sal -Option AllScope -Name zap $cmd; zap -Force C:/tmp/demo",+ 'Set-Alias -Unknown demo -Name zap Write-Output; zap ok',++ 'Set-Alias -Name zap Remove-Item; zap -Force C:/tmp/demo',+ 'Set-Alias -Name zap $cmd; zap -Force C:/tmp/demo',+ "$cmd='Remove-Item'; Set-Alias -Value $cmd zap; zap -Force C:/tmp/demo",+ "$payload='Remove-Item -Force C:/tmp/demo'; $payload | pwsh -Command -",+ "$payload='Remove-Item -Force C:/tmp/demo'; Write-Output $payload | pwsh -Command -",+ "Set-Alias zap $cmd; zap -Force C:/tmp/demo; $cmd='Write-Output'",+ "$payload | pwsh -Command -; $payload='Write-Output ok'",'pwsh -Command "Write-Output ready; $runtimePayload"','pwsh -Command $runtimePayload -Force C:/tmp/demo','Write-Output "$(Remove-Item -Force C:/tmp/demo)"',diff --git a/tests/hooks/governance-capture.test.js b/tests/hooks/governance-capture.test.jsindex c7cc46c52..7d40ebe78 100644--- a/tests/hooks/governance-capture.test.js+++ b/tests/hooks/governance-capture.test.js@@ -247,6 +247,50 @@ async function runTests() {command: "$payload='Remove-Item -Force C:/private/expanded-command-sentinel'; pwsh -Command \"Write-Output ready; $payload\"",expectedRules: ['powershell.remove-item.force'],},+ {+ command: "$cmd='Remove-Item'; Set-Alias zap $cmd; zap -Force C:/private/alias-command-sentinel",+ expectedRules: ['powershell.remove-item.force'],+ },+ {+ command: "$cmd='Remove-Item'; Set-Alias -Name zap $cmd; zap -Force C:/private/alias-command-sentinel",+ expectedRules: ['powershell.remove-item.force'],+ },+ {+ command: 'Set-Alias -Name zap Remove-Item; zap -Force C:/private/alias-command-sentinel',+ expectedRules: ['powershell.remove-item.force'],+ },+ {+ command: 'Set-Alias -Name zap $cmd; zap -Force C:/private/alias-command-sentinel',+ expectedRules: ['powershell.dynamic-execution'],+ },+ {+ command: "$cmd='Remove-Item'; Set-Alias -Scope Global -Name zap $cmd; zap -Force C:/private/alias-command-sentinel",+ expectedRules: ['powershell.remove-item.force'],+ },+ {+ command: "$cmd='Remove-Item'; New-Alias -Description demo -Name zap $cmd; zap -Force C:/private/alias-command-sentinel",+ expectedRules: ['powershell.remove-item.force'],+ },+ {+ command: "$cmd='Remove-Item'; sal -Option AllScope -Name zap $cmd; zap -Force C:/private/alias-command-sentinel",+ expectedRules: ['powershell.remove-item.force'],+ },+ {+ command: 'Set-Alias -Unknown demo -Name zap Write-Output; zap ok',+ expectedRules: ['powershell.dynamic-execution'],+ },+ {+ command: "$payload='Remove-Item -Force C:/private/stdin-command-sentinel'; $payload | pwsh -Command -",+ expectedRules: ['powershell.remove-item.force'],+ },+ {+ command: "Set-Alias zap $cmd; zap -Force C:/private/alias-command-sentinel; $cmd='Write-Output'",+ expectedRules: ['powershell.dynamic-execution'],+ },+ {+ command: "$payload | pwsh -Command -; $payload='Write-Output ok'",+ expectedRules: ['powershell.dynamic-execution'],+ },{command: 'pwsh -Command "Write-Output ready; $runtimePayload"',expectedRules: ['powershell.dynamic-execution'],diff --git a/tests/lib/claude-settings-array.test.js b/tests/lib/claude-settings-array.test.jsnew file mode 100644index 000000000..bc1a9e093--- /dev/null+++ b/tests/lib/claude-settings-array.test.js@@ -0,0 +1,88 @@+'use strict';++const assert = require('assert');+const { spawnSync } = require('child_process');+const { materializeManagedHooks } = require('../../scripts/lib/install/claude-settings');++function config(command) {+ return {+ hooks: {+ Stop: [{ id: 'ecc:array', hooks: [{ type: 'command', command }] }],+ },+ };+}++function materialize(command, root = '/opt/ecc') {+ return materializeManagedHooks(config(command), root).Stop[0].hooks[0].command;+}++const tests = [+ ['materializes every array command without changing the source', () => {+ const source = config([+ 'node -e "var e=process.env.CLAUDE_PLUGIN_ROOT;console.log(e)"',+ 'node -e "var e=process.env.CLAUDE_PLUGIN_ROOT;console.log(e)"',+ '${CLAUDE_PLUGIN_ROOT}/scripts/start.js',+ '--unchanged',+ ]);+ const before = JSON.parse(JSON.stringify(source));+ const command = materializeManagedHooks(source, '/opt/ecc').Stop[0].hooks[0].command;+ assert.deepStrictEqual(source, before);+ assert.notStrictEqual(command, source.hooks.Stop[0].hooks[0].command);+ assert.ok(command.slice(0, 2).every(value => !value.includes('process.env.CLAUDE_PLUGIN_ROOT')));+ assert.deepStrictEqual(command.slice(2), ['/opt/ecc/scripts/start.js', '--unchanged']);+ }],+ ['array argv commands execute with the exact root in a clean process', () => {+ const root = '/tmp/ECC space/\'"$`\\路径';+ const command = materialize([+ process.execPath,+ '-e',+ 'var e=process.env.CLAUDE_PLUGIN_ROOT;process.stdout.write(e);',+ ], root);+ const result = spawnSync(command[0], command.slice(1), {+ env: {},+ encoding: 'utf8',+ timeout: 5000,+ });+ assert.ifError(result.error);+ assert.strictEqual(result.status, 0, result.stderr);+ assert.strictEqual(result.stdout, root);+ }],+ ...[0, 1].map(index => [+ `rejects an unresolved root read in array element ${index}`,+ () => {+ const command = ['echo first', 'echo second'];+ command[index] = 'node -e "const root=process.env.CLAUDE_PLUGIN_ROOT"';+ assert.throws(() => materialize(command), /Unable to resolve CLAUDE_PLUGIN_ROOT/);+ },+ ]),+ ['rejects a remaining root read after resolving an array prologue', () => {+ assert.throws(() => materialize([+ 'var e=process.env.CLAUDE_PLUGIN_ROOT;console.log(process.env.CLAUDE_PLUGIN_ROOT);',+ ]), /Unable to resolve CLAUDE_PLUGIN_ROOT/);+ }],+ ['retains supported root assignments in array commands', () => {+ const command = materialize([+ 'var e=process.env.CLAUDE_PLUGIN_ROOT;process.env.CLAUDE_PLUGIN_ROOT=e;',+ ]);+ assert.ok(!command[0].includes('var e=process.env.CLAUDE_PLUGIN_ROOT;'));+ assert.ok(command[0].includes('process.env.CLAUDE_PLUGIN_ROOT=e;'));+ }],+ ['invalid arrays still fail command validation', () => {+ for (const command of [[], ['node', null], ['node', 3], ['node', ' ']]) {+ assert.throws(() => materialize(command), /invalid command/);+ }+ }],+];++let failed = 0;+for (const [name, run] of tests) {+ try {+ run();+ console.log(` PASS ${name}`);+ } catch (error) {+ failed += 1;+ console.error(` FAIL ${name}\n ${error.stack || error.message}`);+ }+}+console.log(`\nResults: Passed: ${tests.length - failed}, Failed: ${failed}`);+process.exitCode = failed > 0 ? 1 : 0;diff --git a/tests/lib/multi-harness-setup.test.js b/tests/lib/multi-harness-setup.test.jsindex 2858a7ab4..24b5a5f45 100644--- a/tests/lib/multi-harness-setup.test.js+++ b/tests/lib/multi-harness-setup.test.js@@ -601,6 +601,44 @@ function writeManagedState(plan, overrides = {}) {}});+ for (const existing of [false, true]) {+ await test(`applies ordered JSON merges to the same ${existing ? 'existing' : 'new'} destination`, async () => {+ const root = tempDir('ecc-guided-repeated-json-');+ const projection = require('../../scripts/lib/install-state-store-sync');+ const originalProjection = projection.projectCanonicalInstallState;+ projection.projectCanonicalInstallState = async () => ({ status: 'projected' });+ try {+ const destination = path.join(root, '.kimi-code', 'mcp.json');+ if (existing) writeFile(destination, JSON.stringify({ userSetting: true }));+ const plan = managedPlan(root, [+ stateOperation(destination, {+ kind: 'merge-json',+ mergePayload: { servers: { first: { command: 'first' } }, sequence: 'first' },+ strategy: 'merge-json',+ }),+ stateOperation(destination, {+ kind: 'merge-json',+ mergePayload: { servers: { second: { command: 'second' } }, sequence: 'second' },+ strategy: 'merge-json',+ }),+ ]);+ const result = await applyMultiHarnessPlan({+ harnesses: [{ id: 'kimi', preview: preflightManagedPlan(plan) }],+ request: { harnesses: ['kimi'] },+ });+ assert.strictEqual(result.status, 'complete', JSON.stringify(result.failure));+ assert.deepStrictEqual(JSON.parse(fs.readFileSync(destination, 'utf8')), {+ ...(existing ? { userSetting: true } : {}),+ servers: { first: { command: 'first' }, second: { command: 'second' } },+ sequence: 'second',+ });+ } finally {+ projection.projectCanonicalInstallState = originalProjection;+ fs.rmSync(root, { recursive: true, force: true });+ }+ });+ }+await test('refuses conflicting JSON created after preview but before apply', async () => {const root = tempDir('ecc-guided-late-json-collision-');try {diff --git a/tests/lib/powershell-destructive-command.test.js b/tests/lib/powershell-destructive-command.test.jsindex 7a4ae31cf..43f01994a 100644--- a/tests/lib/powershell-destructive-command.test.js+++ b/tests/lib/powershell-destructive-command.test.js@@ -206,6 +206,109 @@ test('does not resolve earlier invocations from later scalar assignments', () =>expectSafe('$payload = "Write-Output ok"; pwsh -Command "$payload"');});+test('resolves scalar values supplied to aliases and shell stdin', () => {+ for (const command of [+ "$cmd='Remove-Item'; Set-Alias zap $cmd; zap -Force C:/tmp/demo",+ "$cmd='Remove-Item'; New-Alias -Name zap -Value $cmd; zap -Force C:/tmp/demo",+ "$cmd='Remove-Item'; Set-Alias -Name zap -Value:$cmd; zap -Force C:/tmp/demo",+ '$cmd=\'Remove-Item\'; Set-Alias zap "$cmd"; zap -Force C:/tmp/demo',+ "$payload='Remove-Item -Force C:/tmp/demo'; $payload | pwsh -Command -",+ "$payload='Remove-Item -Force C:/tmp/demo'; Write-Output $payload | pwsh -Command -",+ '$payload=\'Remove-Item -Force C:/tmp/demo\'; "$payload" | pwsh -Command -',+ '$payload=\'Remove-Item -Force C:/tmp/demo\'; Write-Output "$payload" | pwsh -Command -',+ ]) {+ expectRules(command, [RULES.REMOVE_FORCE]);+ }+ expectSafe('Set-Alias zap $runtimeCommand');+ expectSafe("$cmd='Write-Output'; Set-Alias zap $cmd; zap ok");+ expectSafe("$payload='Write-Output ok'; $payload | pwsh -Command -");+ expectSafe("$payload='Remove-Item -Force C:/tmp/demo'; '$payload' | pwsh -Command -");+ expectSafe("$cmd='Remove-Item'; Set-Alias zap '$cmd'; zap -Force C:/tmp/demo");+});++test('binds remaining alias positional arguments after named parameters', () => {+ for (const definition of [+ 'Set-Alias -Name zap $cmd',+ 'New-Alias -Name:zap $cmd',+ 'Set-Alias -Value $cmd zap',+ 'New-Alias zap -Value:$cmd',+ ]) {+ expectRules(`$cmd='Remove-Item'; ${definition}; zap -Force C:/tmp/demo`, [+ RULES.REMOVE_FORCE,+ ]);+ expectRules(`${definition}; zap -Force C:/tmp/demo`, [RULES.DYNAMIC_EXECUTION]);+ expectRules(`${definition}; zap -Force C:/tmp/demo; $cmd='Write-Output'`, [+ RULES.DYNAMIC_EXECUTION,+ ]);+ expectSafe(`$cmd='Write-Output'; ${definition}; zap ok`);+ expectSafe(definition);+ }+ expectRules('Set-Alias -Name zap Remove-Item; zap -Force C:/tmp/demo', [RULES.REMOVE_FORCE]);+ expectRules('Set-Alias -Value Remove-Item zap; zap -Force C:/tmp/demo', [RULES.REMOVE_FORCE]);+ expectSafe("$cmd='Remove-Item'; Set-Alias -Name zap '$cmd'; zap -Force C:/tmp/demo");+});++test('binds alias auxiliary parameters independently of their layout', () => {+ const parameters = [+ '-Scope Global', '-Sc:Global', '-Description demo', '-Desc:demo',+ '-Option AllScope', '-Opt:AllScope', '-Option ReadOnly, Private',+ '-Force', '-Fo:$false', '-PassThru', '-Pass:$false',+ '-Verbose', '-vb:$false', '-Debug', '-db:$false',+ '-Confirm:$false', '-cf:$false', '-WhatIf:$false', '-wi:$false',+ '-ErrorAction Stop', '-ea:Stop', '-WarningAction Continue', '-wa:Continue',+ '-InformationAction Continue', '-infa:Continue', '-ProgressAction Continue',+ '-proga:Continue', '-ErrorVariable errors', '-ev:errors',+ '-WarningVariable warnings', '-wv:warnings', '-InformationVariable info', '-iv:info',+ '-OutVariable output', '-ov:output', '-OutBuffer 1', '-ob:1',+ '-PipelineVariable item', '-pv:item',+ ];+ for (const command of ['Set-Alias', 'New-Alias', 'sal', 'nal']) {+ for (const parameter of parameters) {+ for (const args of [+ `${parameter} -Name zap $cmd`,+ `-Name zap ${parameter} $cmd`,+ `-Name zap $cmd ${parameter}`,+ `${parameter} zap -Value $cmd`,+ `${parameter} zap $cmd`,+ ]) {+ const definition = `${command} ${args}`;+ expectRules(`$cmd='Remove-Item'; ${definition}; zap -Force C:/tmp/demo`, [RULES.REMOVE_FORCE]);+ expectRules(`${definition}; zap -Force C:/tmp/demo`, [RULES.DYNAMIC_EXECUTION]);+ expectSafe(`$cmd='Write-Output'; ${definition}; zap ok`);+ expectSafe(definition);+ }+ }+ }+ expectRules('Set-Alias -Scope Global -Name zap Remove-Item; zap -Force C:/tmp/demo', [RULES.REMOVE_FORCE]);+});++test('gates invoked aliases with unsupported or ambiguous parameter binding', () => {+ for (const definition of [+ 'Set-Alias -Unknown demo -Name zap Write-Output',+ 'Set-Alias -Unknown demo zap Write-Output',+ 'Set-Alias -Name zap -V Write-Output',+ 'Set-Alias -Name zap -Option AllScope extra Write-Output',+ 'Set-Alias -Name zap @parameters',+ ]) {+ expectRules(`${definition}; zap ok`, [RULES.DYNAMIC_EXECUTION]);+ expectSafe(`${definition}; Write-Output ok`);+ }+});++test('gates unresolved aliases and stdin without using later or reassigned scalars', () => {+ for (const command of [+ 'Set-Alias zap $cmd; zap -Force C:/tmp/demo',+ "Set-Alias zap $cmd; zap -Force C:/tmp/demo; $cmd='Write-Output'",+ "$cmd='Remove-Item'; Set-Alias zap $cmd; $cmd='Write-Output'; zap -Force C:/tmp/demo",+ '$payload | pwsh -Command -',+ 'Write-Output $payload | pwsh -Command -',+ "$payload | pwsh -Command -; $payload='Write-Output ok'",+ "$payload='Remove-Item -Force C:/tmp/demo'; $payload | pwsh -Command -; $payload='Write-Output ok'",+ ]) {+ expectRules(command, [RULES.DYNAMIC_EXECUTION]);+ }+});+test('classifies powershell and pwsh command payloads recursively', () => {expectRules('powershell -Command "Remove-Item -Recurse C:/tmp/demo"',diff --git a/tests/run-all.js b/tests/run-all.jsindex fd79cb4af..09bc0ccef 100644--- a/tests/run-all.js+++ b/tests/run-all.js@@ -43,6 +43,21 @@ function discoverTestFiles() {.sort();}+function escapeAnnotation(value, property = false) {+ const escaped = value.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');+ return property ? escaped.replace(/:/g, '%3A').replace(/,/g, '%2C') : escaped;+}++function annotateFailure(displayPath, reason, output) {+ if (process.env.GITHUB_ACTIONS !== 'true') return;+ const context = output.split(/\r?\n/)+ .filter(line => /\b(?:FAIL|[A-Za-z]*Error)\b|[✗❌]/i.test(line))+ .slice(0, 3)+ .join('\n');+ const message = [reason, context].filter(Boolean).join(': ').slice(0, 1000);+ console.log(`::error file=${escapeAnnotation(`tests/${displayPath}`, true)}::${escapeAnnotation(message)}`);+}+const testFiles = discoverTestFiles();const BOX_W = 58; // inner width between ║ delimiters@@ -96,22 +111,29 @@ for (const testFile of testFiles) {if (stderr) console.log(stderr);// Parse results from combined output- const combined = stdout + stderr;+ const combined = `${stdout}\n${stderr}`;const passedMatch = combined.match(/Passed:\s*(\d+)/);const failedMatch = combined.match(/Failed:\s*(\d+)/);if (passedMatch) totalPassed += parseInt(passedMatch[1], 10);- if (failedMatch) totalFailed += parseInt(failedMatch[1], 10);+ const reportedFailures = failedMatch ? parseInt(failedMatch[1], 10) : 0;+ const processFailed = Boolean(result.error) || result.status !== 0;+ totalFailed += processFailed ? Math.max(reportedFailures, 1) : reportedFailures;+ let failureReason;if (result.error) {- console.log(`✗ ${displayPath} failed to start: ${result.error.message}`);- totalFailed += failedMatch ? 0 : 1;- continue;+ failureReason = `failed to start: ${result.error.message}`;+ } else if (result.status !== 0) {+ failureReason = result.signal+ ? `terminated by signal ${result.signal}`+ : `exited with status ${result.status}`;+ } else if (reportedFailures > 0) {+ failureReason = `reported ${reportedFailures} failed tests`;}- if (result.status !== 0) {- console.log(`✗ ${displayPath} exited with status ${result.status}`);- totalFailed += failedMatch ? 0 : 1;+ if (failureReason) {+ console.log(`✗ ${displayPath} ${failureReason}`);+ annotateFailure(displayPath, failureReason, combined);}}