The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix: stability batch — hook stdin truncation, Codex exa TOML, Stop hook JSON, GateGuard repetition (#2227)
Affaan Mustafa6319c7d309df
diff --git a/scripts/codex/check-codex-global-state.sh b/scripts/codex/check-codex-global-state.shindex eb9801995..c9dac74b1 100755--- a/scripts/codex/check-codex-global-state.sh+++ b/scripts/codex/check-codex-global-state.sh@@ -107,11 +107,11 @@ if [[ -f "$CONFIG_FILE" ]]; thencheck_config_pattern '^\[profiles\.strict\]' "profiles.strict exists"check_config_pattern '^\[profiles\.yolo\]' "profiles.yolo exists"+ # Current default connector set (docs/MCP-CONNECTOR-POLICY.md): exactly+ # one connector. Former defaults (github, memory, sequential-thinking,+ # context7, exa, ...) are opt-in user choices, so they are not required.for section in \- 'mcp_servers.github' \- 'mcp_servers.memory' \- 'mcp_servers.sequential-thinking' \- 'mcp_servers.context7'+ 'mcp_servers.chrome-devtools'doif search_file "^\[$section\]" "$CONFIG_FILE"; thenok "MCP section [$section] exists"@@ -120,25 +120,17 @@ if [[ -f "$CONFIG_FILE" ]]; thenfidone- has_context7_legacy=0- has_context7_current=0-- if search_file '^\[mcp_servers\.context7\]' "$CONFIG_FILE"; then- has_context7_legacy=1- fi-- if search_file '^\[mcp_servers\.context7-mcp\]' "$CONFIG_FILE"; then- has_context7_current=1- fi-- if [[ "$has_context7_legacy" -eq 1 || "$has_context7_current" -eq 1 ]]; then- ok "MCP section [mcp_servers.context7] or [mcp_servers.context7-mcp] exists"- else- fail "MCP section [mcp_servers.context7] or [mcp_servers.context7-mcp] missing"- fi-- if [[ "$has_context7_legacy" -eq 1 && "$has_context7_current" -eq 1 ]]; then- warn "Both [mcp_servers.context7] and [mcp_servers.context7-mcp] exist; prefer one name"+ # ECC <= 2.0.0 emitted a url-only exa entry that Codex's stdio-only+ # schema rejects, breaking the whole config (#2224). Flag it so users+ # re-run the sync (which repairs it) or remove it manually.+ if search_file '^\[mcp_servers\.exa\]' "$CONFIG_FILE"; then+ exa_block="$(awk '/^\[mcp_servers\.exa\]/{flag=1;next}/^\[/{flag=0}flag' "$CONFIG_FILE")"+ if printf '%s\n' "$exa_block" | grep -Eq '^[[:space:]]*url[[:space:]]*=' \+ && ! printf '%s\n' "$exa_block" | grep -Eq '^[[:space:]]*command[[:space:]]*='; then+ fail "MCP section [mcp_servers.exa] uses a url key, which Codex rejects for stdio servers — re-run ecc-sync-codex to repair (#2224)"+ else+ ok "MCP section [mcp_servers.exa] uses the stdio form"+ fififidiff --git a/scripts/codex/merge-mcp-config.js b/scripts/codex/merge-mcp-config.jsindex 0acb00853..721e3c29f 100644--- a/scripts/codex/merge-mcp-config.js+++ b/scripts/codex/merge-mcp-config.js@@ -65,14 +65,14 @@ const PM_EXEC_PARTS = PM_EXEC.split(/\s+/); // ["pnpm", "dlx"] or ["npx"] or ["b// ECC-recommended MCP servers// ----------------------------------------------------------------------------// GitHub bootstrap uses bash for token forwarding — this is intentionally-// shell-based regardless of package manager, since Codex runs on macOS/Linux.-const GH_BOOTSTRAP = `token=$(gh auth token 2>/dev/null || true); if [ -n "$token" ]; then export GITHUB_PERSONAL_ACCESS_TOKEN="$token"; fi; exec ${PM_EXEC} @modelcontextprotocol/server-github`;-/*** Build a server spec with the detected package manager.* Returns { fields, toml } where fields is for drift detection and* toml is the raw text appended to the file.+ *+ * Codex's [mcp_servers.*] TOML schema is stdio-only (command/args) —+ * never emit a `url` key here. The http/url form is valid only for+ * Claude Code's .mcp.json (#2224).*/function dlxServer(name, pkg, extraFields, extraToml) {const args = [...PM_EXEC_PARTS.slice(1), pkg];@@ -87,31 +87,29 @@ function dlxServer(name, pkg, extraFields, extraToml) {const DEFAULT_MCP_STARTUP_TIMEOUT_SEC = 30;const DEFAULT_MCP_STARTUP_TIMEOUT_TOML = `startup_timeout_sec = ${DEFAULT_MCP_STARTUP_TIMEOUT_SEC}`;+// Current default connector set (docs/MCP-CONNECTOR-POLICY.md): exactly one+// connector. The former defaults (supabase, playwright, context7, exa,+// github, memory, sequential-thinking) were retired in the June 2026 audit+// and must not be re-emitted; they remain opt-in via+// mcp-configs/mcp-servers.json. Existing user-managed entries are never+// touched by the merge (add-only), except the known-invalid repair below.const ECC_SERVERS = {- supabase: dlxServer('supabase', '@supabase/mcp-server-supabase@latest', { startup_timeout_sec: 20.0, tool_timeout_sec: 120.0 }, 'startup_timeout_sec = 20.0\ntool_timeout_sec = 120.0'),- playwright: dlxServer('playwright', '@playwright/mcp@latest', { startup_timeout_sec: DEFAULT_MCP_STARTUP_TIMEOUT_SEC }, DEFAULT_MCP_STARTUP_TIMEOUT_TOML),- context7: dlxServer('context7', '@upstash/context7-mcp@latest', { startup_timeout_sec: DEFAULT_MCP_STARTUP_TIMEOUT_SEC }, DEFAULT_MCP_STARTUP_TIMEOUT_TOML),- exa: {- fields: { url: 'https://mcp.exa.ai/mcp' },- toml: `[mcp_servers.exa]\nurl = "https://mcp.exa.ai/mcp"`- },- github: {- fields: { command: 'bash', args: ['-lc', GH_BOOTSTRAP], startup_timeout_sec: DEFAULT_MCP_STARTUP_TIMEOUT_SEC },- toml: `[mcp_servers.github]\ncommand = "bash"\nargs = ["-lc", ${JSON.stringify(GH_BOOTSTRAP)}]\n${DEFAULT_MCP_STARTUP_TIMEOUT_TOML}`- },- memory: dlxServer('memory', '@modelcontextprotocol/server-memory', { startup_timeout_sec: DEFAULT_MCP_STARTUP_TIMEOUT_SEC }, DEFAULT_MCP_STARTUP_TIMEOUT_TOML),- 'sequential-thinking': dlxServer('sequential-thinking', '@modelcontextprotocol/server-sequential-thinking', { startup_timeout_sec: DEFAULT_MCP_STARTUP_TIMEOUT_SEC }, DEFAULT_MCP_STARTUP_TIMEOUT_TOML)+ 'chrome-devtools': dlxServer('chrome-devtools', 'chrome-devtools-mcp@latest', { startup_timeout_sec: DEFAULT_MCP_STARTUP_TIMEOUT_SEC }, DEFAULT_MCP_STARTUP_TIMEOUT_TOML)};-// Append --features arg for supabase after dlxServer builds the base-ECC_SERVERS.supabase.fields.args.push('--features=account,docs,database,debugging,development,functions,storage,branching');-ECC_SERVERS.supabase.toml = ECC_SERVERS.supabase.toml.replace(/^(args = \[.*)\]$/m, '$1, "--features=account,docs,database,debugging,development,functions,storage,branching"]');+// ECC <= 2.0.0 emitted [mcp_servers.exa] with a `url` key. Codex rejects+// `url` for stdio servers, which makes the *entire* config.toml fail to+// load (#2224). Repair exactly that ECC-emitted form on every merge so+// re-running the installer fixes broken configs instead of preserving+// them. A user-managed stdio exa entry (command/args) is left untouched.+const RETIRED_INVALID_URL_SERVERS = {+ exa: 'https://mcp.exa.ai/mcp'+};// Legacy section names that should be treated as an existing ECC server.-// e.g. older configs shipped [mcp_servers.context7-mcp] instead of [mcp_servers.context7].-const LEGACY_ALIASES = {- context7: ['context7-mcp']-};+// e.g. older configs shipped [mcp_servers.context7-mcp] instead of+// [mcp_servers.context7]. Empty since the June 2026 default-set reduction.+const LEGACY_ALIASES = {};// ---------------------------------------------------------------------------// Helpers@@ -241,6 +239,21 @@ function main() {const toAppend = [];const toRemoveLog = [];+ // Repair schema-invalid entries emitted by earlier ECC versions (#2224).+ for (const [name, invalidUrl] of Object.entries(RETIRED_INVALID_URL_SERVERS)) {+ const entry = existing[name];+ const isBrokenEccForm =+ entry &&+ typeof entry.url === 'string' &&+ entry.url === invalidUrl &&+ typeof entry.command !== 'string';+ if (isBrokenEccForm) {+ toRemoveLog.push(`mcp_servers.${name} (invalid url entry from earlier ECC versions)`);+ raw = removeServerFromText(raw, name, existing);+ log(` [repair] mcp_servers.${name} — url is not valid for Codex stdio servers, removing`);+ }+ }+for (const [name, spec] of Object.entries(ECC_SERVERS)) {const entry = existing[name];const aliases = LEGACY_ALIASES[name] || [];@@ -249,7 +262,9 @@ function main() {// Prefer canonical entry over legacy aliasconst hasCanonical = entry && typeof entry.command === 'string';const resolvedEntry = hasCanonical ? entry : legacyName ? existing[legacyName] : null;- // For URL-based servers (exa), check for url field instead of command+ // Recognize url-form entries as existing so they are never duplicated.+ // (Codex itself rejects url-form stdio servers; ECC only ever emits+ // command/args, but a user-managed entry must still count as present.)const urlEntry = !resolvedEntry && entry && typeof entry.url === 'string' ? entry : null;const finalEntry = resolvedEntry || urlEntry;const resolvedLabel = hasCanonical ? name : legacyName || name;@@ -306,11 +321,13 @@ function main() {if (dryRun) {if (toRemoveLog.length > 0) {- log('Dry run — would remove and re-add:');+ log('Dry run — would remove:');for (const label of toRemoveLog) log(` [remove] ${label}`);}- log('Dry run — would append:');- console.log(appendText);+ if (toAppend.length > 0) {+ log('Dry run — would append:');+ console.log(appendText);+ }return;}@@ -325,7 +342,7 @@ function main() {}if (hasRemovals && toAppend.length === 0) {- log(`Done. Removed ${toRemoveLog.length} disabled server(s).`);+ log(`Done. Removed ${toRemoveLog.length} server section(s).`);return;}diff --git a/scripts/hooks/check-console-log.js b/scripts/hooks/check-console-log.jsindex f55a5ed1d..94e60a152 100755--- a/scripts/hooks/check-console-log.js+++ b/scripts/hooks/check-console-log.js@@ -28,20 +28,40 @@ const EXCLUDED_PATTERNS = [const MAX_STDIN = 1024 * 1024; // 1MB limitlet data = '';+let truncated = false;process.stdin.setEncoding('utf8');process.stdin.on('data', chunk => {if (data.length < MAX_STDIN) {const remaining = MAX_STDIN - data.length;data += chunk.substring(0, remaining);+ if (chunk.length > remaining) truncated = true;+ } else {+ truncated = true;}});+/**+ * Echo stdin back (ECC pass-through convention), then exit once the pipe has+ * flushed. Truncated stdin is never echoed: a JSON document cut mid-stream is+ * reported by the harness as a Stop hook JSON validation failure (#2090).+ */+function passThroughAndExit() {+ if (truncated) {+ log('[Hook] check-console-log: stdin exceeded 1MB; suppressing pass-through (fail-open)');+ process.exit(0);+ }+ if (!data) {+ process.exit(0);+ }+ process.stdout.write(data, () => process.exit(0));+}+process.stdin.on('end', () => {try {if (!isGitRepo()) {- process.stdout.write(data);- process.exit(0);+ passThroughAndExit();+ return;}const files = getGitModifiedFiles(['\\.tsx?$', '\\.jsx?$'])@@ -65,7 +85,6 @@ process.stdin.on('end', () => {log(`[Hook] check-console-log error: ${err.message}`);}- // Always output the original data- process.stdout.write(data);- process.exit(0);+ // Always output the original data (unless truncated)+ passThroughAndExit();});diff --git a/scripts/hooks/cost-tracker.js b/scripts/hooks/cost-tracker.jsindex 039375787..8eb605274 100755--- a/scripts/hooks/cost-tracker.js+++ b/scripts/hooks/cost-tracker.js@@ -128,12 +128,22 @@ function sumUsageFromTranscript(transcriptPath) {return { inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, model };}-const MAX_STDIN = 64 * 1024;+// 1MB, matching the other Stop hooks. The Stop payload carries+// last_assistant_message, which routinely exceeded the old 64KB cap and+// made this hook echo a JSON document cut mid-stream (#2090).+const MAX_STDIN = 1024 * 1024;let raw = '';+let truncated = false;process.stdin.setEncoding('utf8');process.stdin.on('data', chunk => {- if (raw.length < MAX_STDIN) raw += chunk.substring(0, MAX_STDIN - raw.length);+ if (raw.length < MAX_STDIN) {+ const remaining = MAX_STDIN - raw.length;+ raw += chunk.substring(0, remaining);+ if (chunk.length > remaining) truncated = true;+ } else {+ truncated = true;+ }});process.stdin.on('end', () => {@@ -201,6 +211,11 @@ process.stdin.on('end', () => {// Non-blocking — never fail the Stop hook.}- // Pass stdin through (required by ECC hook convention).+ // Pass stdin through (ECC hook convention) — but never echo truncated+ // stdin: invalid JSON on stdout is reported as a Stop hook failure (#2090).+ if (truncated) {+ process.stderr.write('[Hook] cost-tracker: stdin exceeded 1MB; suppressing pass-through (fail-open)\n');+ return;+ }process.stdout.write(raw);});diff --git a/scripts/hooks/desktop-notify.js b/scripts/hooks/desktop-notify.jsindex 469648c75..a9458711f 100644--- a/scripts/hooks/desktop-notify.js+++ b/scripts/hooks/desktop-notify.js@@ -236,15 +236,26 @@ module.exports = { run };if (require.main === module) {const MAX_STDIN = 1024 * 1024;let data = '';+ let truncated = false;process.stdin.setEncoding('utf8');process.stdin.on('data', chunk => {if (data.length < MAX_STDIN) {- data += chunk.substring(0, MAX_STDIN - data.length);+ const remaining = MAX_STDIN - data.length;+ data += chunk.substring(0, remaining);+ if (chunk.length > remaining) truncated = true;+ } else {+ truncated = true;}});process.stdin.on('end', () => {const output = run(data);+ // Never echo truncated stdin — invalid JSON on stdout is reported as a+ // Stop hook failure (#2090).+ if (truncated) {+ log('[DesktopNotify] stdin exceeded 1MB; suppressing pass-through (fail-open)');+ return;+ }if (output) process.stdout.write(output);});}diff --git a/scripts/hooks/gateguard-fact-force.js b/scripts/hooks/gateguard-fact-force.jsindex 33a4ac0b4..d28d818c5 100644--- a/scripts/hooks/gateguard-fact-force.js+++ b/scripts/hooks/gateguard-fact-force.js@@ -592,6 +592,7 @@ function saveState(state) {let mergedChecked = Array.isArray(state.checked) ? state.checked : [];let mergedLastActive = typeof state.last_active === 'number' ? state.last_active : 0;+ let mergedDenials = getDenialCount(state);try {if (fs.existsSync(stateFile)) {@@ -602,6 +603,7 @@ function saveState(state) {if (typeof diskState.last_active === 'number') {mergedLastActive = Math.max(mergedLastActive, diskState.last_active);}+ mergedDenials = Math.max(mergedDenials, getDenialCount(diskState));}} catch (_) {/* ignore malformed or transient disk state */@@ -609,7 +611,8 @@ function saveState(state) {const finalState = {checked: pruneCheckedEntries(mergedChecked),- last_active: Math.max(mergedLastActive, Date.now())+ last_active: Math.max(mergedLastActive, Date.now()),+ fact_force_denials: mergedDenials};// Atomic write: temp file + rename prevents partial reads@@ -652,6 +655,48 @@ function markChecked(key) {return true;}+// --- Fact-force denial dampening (#2142) ---+//+// In long sessions the near-identical four-fact deny blocks accumulate in+// the context window and measurably raise the odds of the model dropping+// into a degenerate repetition loop. Emit the full four-fact block only for+// the first GATEGUARD_FACT_FORCE_FULL_DENIALS denials per session (default+// 3); afterwards emit a condensed single-line denial that carries the+// denial ordinal, so consecutive denials are structurally different and+// never textually identical. True retries of an already-gated target are+// unaffected (they were always allowed). Destructive-Bash and routine-Bash+// gates are unchanged.++const DEFAULT_FULL_DENIALS = 3;++function getFullDenialBudget() {+ const raw = Number.parseInt(process.env.GATEGUARD_FACT_FORCE_FULL_DENIALS || '', 10);+ if (Number.isInteger(raw) && raw >= 0) {+ return raw;+ }+ return DEFAULT_FULL_DENIALS;+}++function getDenialCount(state) {+ const n = Number(state && state.fact_force_denials);+ return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0;+}++/**+ * Record a first-touch target AND count the fact-force denial in the same+ * state write. Returns the new denial ordinal (1-based) plus whether the+ * write persisted.+ */+function markCheckedAndCountDenial(key) {+ const state = loadState();+ if (!state.checked.includes(key)) {+ state.checked.push(key);+ }+ const denials = getDenialCount(state) + 1;+ state.fact_force_denials = denials;+ return { ok: saveState(state), denials };+}+function isChecked(key) {const state = loadState();const found = state.checked.includes(key);@@ -792,6 +837,20 @@ function writeGateMsg(filePath) {].join('\n');}+/**+ * Condensed single-line denial used after the full-block budget is spent+ * (#2142). Carries the denial ordinal so consecutive denials differ+ * textually, and a one-line recovery hint instead of the multi-line block.+ */+function condensedGateMsg(action, filePath, ordinal) {+ const safe = sanitizePath(filePath);+ return (+ `[Fact-Forcing Gate] (denial #${ordinal} this session) First ${action} of ${safe}: ` ++ "briefly state importers/callers, affected API, data schemas if any, and the user's verbatim instruction, then retry. " ++ '(ECC_GATEGUARD=off disables this gate.)'+ );+}+function destructiveBashMsg() {return ['[Fact-Forcing Gate]',@@ -902,9 +961,14 @@ function run(rawInput) {}if (!isChecked(filePath)) {- if (!markChecked(filePath)) {+ const { ok, denials } = markCheckedAndCountDenial(filePath);+ if (!ok) {return allowWithStateWarning();}+ if (denials > getFullDenialBudget()) {+ const action = toolName === 'Edit' ? 'edit' : 'creation';+ return denyResult(condensedGateMsg(action, filePath, denials), { includeRecoveryHint: false });+ }return denyResult(toolName === 'Edit' ? editGateMsg(filePath) : writeGateMsg(filePath));}@@ -920,9 +984,13 @@ function run(rawInput) {for (const edit of edits) {const filePath = edit.file_path || '';if (filePath && !isClaudeSettingsPath(filePath) && !isChecked(filePath)) {- if (!markChecked(filePath)) {+ const { ok, denials } = markCheckedAndCountDenial(filePath);+ if (!ok) {return allowWithStateWarning();}+ if (denials > getFullDenialBudget()) {+ return denyResult(condensedGateMsg('edit', filePath, denials), { includeRecoveryHint: false });+ }return denyResult(editGateMsg(filePath));}}diff --git a/scripts/hooks/run-with-flags.js b/scripts/hooks/run-with-flags.jsindex a0b43fbaf..c1c3b9046 100755--- a/scripts/hooks/run-with-flags.js+++ b/scripts/hooks/run-with-flags.js@@ -45,40 +45,52 @@ function writeStderr(stderr) {process.stderr.write(stderr.endsWith('\n') ? stderr : `${stderr}\n`);}-function emitHookResult(raw, output) {+/**+ * Write stdout fully, then exit. `process.exit()` immediately after+ * `process.stdout.write()` drops anything beyond the ~64KB pipe buffer,+ * which cut large pass-through payloads mid-JSON and made the harness+ * treat the hook as failed (#2222). The write callback fires only after+ * the chunk is flushed to the pipe.+ */+function exitWithStdout(text, exitCode) {+ if (typeof text !== 'string' || text.length === 0) {+ process.exit(exitCode);+ }+ process.stdout.write(text, () => process.exit(exitCode));+}++function resolveHookResult(raw, output) {if (typeof output === 'string' || Buffer.isBuffer(output)) {- process.stdout.write(String(output));- return 0;+ return { stdout: String(output), exitCode: 0 };}if (output && typeof output === 'object') {writeStderr(output.stderr);+ const exitCode = Number.isInteger(output.exitCode) ? output.exitCode : 0;if (Object.prototype.hasOwnProperty.call(output, 'additionalContext')) {- process.stdout.write(buildPreToolUseAdditionalContext(output.additionalContext));- } else if (Object.prototype.hasOwnProperty.call(output, 'stdout')) {- process.stdout.write(String(output.stdout ?? ''));- } else if (!Number.isInteger(output.exitCode) || output.exitCode === 0) {- process.stdout.write(raw);+ return { stdout: buildPreToolUseAdditionalContext(output.additionalContext), exitCode };}-- return Number.isInteger(output.exitCode) ? output.exitCode : 0;+ if (Object.prototype.hasOwnProperty.call(output, 'stdout')) {+ return { stdout: String(output.stdout ?? ''), exitCode };+ }+ return { stdout: exitCode === 0 ? raw : '', exitCode };}- process.stdout.write(raw);- return 0;+ return { stdout: raw, exitCode: 0 };}-function writeLegacySpawnOutput(raw, result) {+function resolveLegacySpawnStdout(raw, result) {const stdout = typeof result.stdout === 'string' ? result.stdout : '';if (stdout) {- process.stdout.write(stdout);- return;+ return stdout;}if (Number.isInteger(result.status) && result.status === 0) {- process.stdout.write(raw);+ return raw;}++ return '';}function getPluginRoot() {@@ -92,14 +104,25 @@ async function main() {const [, , hookId, relScriptPath, profilesCsv] = process.argv;const { raw, truncated } = await readStdinRaw();+ // Oversized payloads: never echo the truncated string — a JSON document+ // cut mid-stream is treated by the harness as a hook failure, blocking the+ // tool call (#2222). Empty stdout + exit 0 means "no opinion", so+ // pass-through paths fail open. The hook itself still runs and receives+ // the truncated flag (run() context / ECC_HOOK_INPUT_TRUNCATED), so+ // security hooks like config-protection can still choose to block.+ const sanitizeEcho = text => (truncated && text === raw ? '' : text);+ if (truncated) {+ process.stderr.write(`[Hook] stdin exceeded ${MAX_STDIN} bytes for ${hookId || 'unknown'}; suppressing pass-through (fail-open unless the hook blocks)\n`);+ }+if (!hookId || !relScriptPath) {- process.stdout.write(raw);- process.exit(0);+ exitWithStdout(sanitizeEcho(raw), 0);+ return;}if (!isHookEnabled(hookId, { profiles: profilesCsv })) {- process.stdout.write(raw);- process.exit(0);+ exitWithStdout(sanitizeEcho(raw), 0);+ return;}const pluginRoot = getPluginRoot();@@ -109,14 +132,14 @@ async function main() {// Prevent path traversal outside the plugin rootif (!scriptPath.startsWith(resolvedRoot + path.sep)) {process.stderr.write(`[Hook] Path traversal rejected for ${hookId}: ${scriptPath}\n`);- process.stdout.write(raw);- process.exit(0);+ exitWithStdout(sanitizeEcho(raw), 0);+ return;}if (!fs.existsSync(scriptPath)) {process.stderr.write(`[Hook] Script not found for ${hookId}: ${scriptPath}\n`);- process.stdout.write(raw);- process.exit(0);+ exitWithStdout(sanitizeEcho(raw), 0);+ return;}// Prefer direct require() when the hook exports a run(rawInput) function.@@ -147,12 +170,13 @@ async function main() {truncated,maxStdin: MAX_STDIN});- process.exit(emitHookResult(raw, output));+ const result = resolveHookResult(raw, output);+ exitWithStdout(sanitizeEcho(result.stdout), result.exitCode);} catch (runErr) {process.stderr.write(`[Hook] run() error for ${hookId}: ${runErr.message}\n`);- process.stdout.write(raw);+ exitWithStdout(sanitizeEcho(raw), 0);}- process.exit(0);+ return;}// Legacy path: spawn a child Node process for hooks without run() export@@ -171,20 +195,17 @@ async function main() {timeout: 30000});- writeLegacySpawnOutput(raw, result);+ const legacyStdout = sanitizeEcho(resolveLegacySpawnStdout(raw, result));if (result.stderr) process.stderr.write(result.stderr);if (result.error || result.signal || result.status === null) {- const failureDetail = result.error- ? result.error.message- : result.signal- ? `terminated by signal ${result.signal}`- : 'missing exit status';+ const failureDetail = result.error ? result.error.message : result.signal ? `terminated by signal ${result.signal}` : 'missing exit status';writeStderr(`[Hook] legacy hook execution failed for ${hookId}: ${failureDetail}`);- process.exit(1);+ exitWithStdout(legacyStdout, 1);+ return;}- process.exit(Number.isInteger(result.status) ? result.status : 0);+ exitWithStdout(legacyStdout, Number.isInteger(result.status) ? result.status : 0);}main().catch(err => {diff --git a/scripts/hooks/stop-format-typecheck.js b/scripts/hooks/stop-format-typecheck.jsindex 50c5d2c68..a7bc0b784 100644--- a/scripts/hooks/stop-format-typecheck.js+++ b/scripts/hooks/stop-format-typecheck.js@@ -196,13 +196,30 @@ function run(rawInput) {if (require.main === module) {let stdinData = '';+ let truncated = false;process.stdin.setEncoding('utf8');process.stdin.on('data', chunk => {- if (stdinData.length < MAX_STDIN) stdinData += chunk.substring(0, MAX_STDIN - stdinData.length);+ if (stdinData.length < MAX_STDIN) {+ const remaining = MAX_STDIN - stdinData.length;+ stdinData += chunk.substring(0, remaining);+ if (chunk.length > remaining) truncated = true;+ } else {+ truncated = true;+ }});process.stdin.on('end', () => {- process.stdout.write(run(stdinData));- process.exit(0);+ const output = run(stdinData);+ // Never echo truncated stdin (invalid JSON would be reported as a Stop+ // hook failure, #2090); flush stdout before exiting so large payloads+ // are not cut at the pipe buffer.+ if (truncated) {+ process.stderr.write('[Hook] stop-format-typecheck: stdin exceeded 1MB; suppressing pass-through (fail-open)\n');+ process.exit(0);+ }+ if (!output) {+ process.exit(0);+ }+ process.stdout.write(output, () => process.exit(0));});}diff --git a/skills/gateguard/SKILL.md b/skills/gateguard/SKILL.mdindex 6b1125993..ab31ffcbc 100644--- a/skills/gateguard/SKILL.md+++ b/skills/gateguard/SKILL.md@@ -98,6 +98,13 @@ If GateGuard blocks setup or repair work, start the session with`ECC_GATEGUARD=off`. For hook-level control, keep using`ECC_DISABLED_HOOKS` with the GateGuard hook ID.+In long sessions, only the first `GATEGUARD_FACT_FORCE_FULL_DENIALS`+fact-force denials (default 3) emit the full four-fact block; later+denials are condensed to a single line carrying the denial ordinal, so+near-identical blocks cannot accumulate in the context window and+amplify model repetition loops (#2142). Retrying the same file or+command after presenting facts never re-triggers the gate.+### Option B: Full package with config```bashdiff --git a/tests/hooks/gateguard-fact-force.test.js b/tests/hooks/gateguard-fact-force.test.jsindex 458476a78..f6b317396 100644--- a/tests/hooks/gateguard-fact-force.test.js+++ b/tests/hooks/gateguard-fact-force.test.js@@ -1637,6 +1637,114 @@ function runTests() {}})) passed++; else failed++;+ // --- Fact-force denial dampening (#2142) ---++ console.log('\n Fact-force denial dampening (#2142):');++ clearState();+ if (test('first denials use the full four-fact block and count toward the budget', () => {+ const result = runHook({ tool_name: 'Edit', tool_input: { file_path: '/src/damp-one.js' } });+ const output = parseOutput(result.stdout);+ assert.strictEqual(output.hookSpecificOutput.permissionDecision, 'deny');+ assert.ok(output.hookSpecificOutput.permissionDecisionReason.includes('present these facts'),+ 'first denial should use the full block');+ const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));+ assert.strictEqual(state.fact_force_denials, 1, 'denial counter should persist in session state');+ })) passed++; else failed++;++ clearState();+ if (test('emits a condensed single-line denial once the full-block budget is spent', () => {+ writeState({ checked: [], last_active: Date.now(), fact_force_denials: 3 });+ const result = runHook({ tool_name: 'Edit', tool_input: { file_path: '/src/damp-two.js' } });+ const output = parseOutput(result.stdout);+ assert.strictEqual(result.code, 0);+ assert.strictEqual(output.hookSpecificOutput.permissionDecision, 'deny', 'still denies first touch');+ const reason = output.hookSpecificOutput.permissionDecisionReason;+ assert.ok(reason.includes('[Fact-Forcing Gate]'), 'condensed message keeps the gate marker');+ assert.ok(reason.includes('denial #4'), 'condensed message carries the denial ordinal');+ assert.ok(reason.includes('/src/damp-two.js'), 'condensed message names the target');+ assert.ok(!reason.includes('present these facts'), 'no repeated four-fact block');+ assert.ok(!reason.includes('\n'), 'condensed message is a single line');+ assert.ok(reason.includes('ECC_GATEGUARD=off'), 'condensed message keeps a recovery hint');+ })) passed++; else failed++;++ clearState();+ if (test('consecutive condensed denials are textually different (ordinal advances)', () => {+ writeState({ checked: [], last_active: Date.now(), fact_force_denials: 5 });+ const first = parseOutput(runHook({ tool_name: 'Write', tool_input: { file_path: '/src/damp-a.js', content: 'x' } }).stdout);+ const second = parseOutput(runHook({ tool_name: 'Write', tool_input: { file_path: '/src/damp-b.js', content: 'x' } }).stdout);+ const firstReason = first.hookSpecificOutput.permissionDecisionReason;+ const secondReason = second.hookSpecificOutput.permissionDecisionReason;+ assert.ok(firstReason.includes('denial #6'), `expected ordinal 6, got: ${firstReason}`);+ assert.ok(secondReason.includes('denial #7'), `expected ordinal 7, got: ${secondReason}`);+ assert.notStrictEqual(firstReason, secondReason, 'successive denials must differ so they cannot compound verbatim');+ })) passed++; else failed++;++ clearState();+ if (test('retry of the same target is still allowed after a condensed denial', () => {+ writeState({ checked: [], last_active: Date.now(), fact_force_denials: 9 });+ const input = { tool_name: 'Edit', tool_input: { file_path: '/src/damp-retry.js' } };+ const denied = parseOutput(runHook(input).stdout);+ assert.strictEqual(denied.hookSpecificOutput.permissionDecision, 'deny');+ const retryOutput = parseOutput(runHook(input).stdout);+ assert.ok(!retryOutput || !retryOutput.hookSpecificOutput, 'retry passes through (no second deny, no re-prompt)');+ })) passed++; else failed++;++ clearState();+ if (test('GATEGUARD_FACT_FORCE_FULL_DENIALS tunes the full-block budget', () => {+ // Budget 0: condensed from the very first denial.+ const zero = parseOutput(runHook(+ { tool_name: 'Edit', tool_input: { file_path: '/src/damp-zero.js' } },+ { GATEGUARD_FACT_FORCE_FULL_DENIALS: '0' }+ ).stdout);+ assert.ok(zero.hookSpecificOutput.permissionDecisionReason.includes('denial #1'));+ assert.ok(!zero.hookSpecificOutput.permissionDecisionReason.includes('present these facts'));++ // Large budget: full block well past the default threshold.+ clearState();+ writeState({ checked: [], last_active: Date.now(), fact_force_denials: 7 });+ const big = parseOutput(runHook(+ { tool_name: 'Edit', tool_input: { file_path: '/src/damp-big.js' } },+ { GATEGUARD_FACT_FORCE_FULL_DENIALS: '20' }+ ).stdout);+ assert.ok(big.hookSpecificOutput.permissionDecisionReason.includes('present these facts'),+ 'budget of 20 keeps the full block at denial 8');+ })) passed++; else failed++;++ clearState();+ if (test('malformed denial counter in state is treated as zero (full block, no crash)', () => {+ writeState({ checked: [], last_active: Date.now(), fact_force_denials: 'garbage' });+ const result = runHook({ tool_name: 'Edit', tool_input: { file_path: '/src/damp-malformed.js' } });+ assert.strictEqual(result.code, 0);+ const output = parseOutput(result.stdout);+ assert.strictEqual(output.hookSpecificOutput.permissionDecision, 'deny');+ assert.ok(output.hookSpecificOutput.permissionDecisionReason.includes('present these facts'),+ 'malformed counter resets to the full block');+ })) passed++; else failed++;++ clearState();+ if (test('MultiEdit denials are dampened past the budget', () => {+ writeState({ checked: [], last_active: Date.now(), fact_force_denials: 4 });+ const result = runHook({+ tool_name: 'MultiEdit',+ tool_input: { edits: [{ file_path: '/src/damp-multi.js', old_string: 'a', new_string: 'b' }] }+ });+ const output = parseOutput(result.stdout);+ assert.strictEqual(output.hookSpecificOutput.permissionDecision, 'deny');+ assert.ok(output.hookSpecificOutput.permissionDecisionReason.includes('denial #5'));+ assert.ok(!output.hookSpecificOutput.permissionDecisionReason.includes('present these facts'));+ })) passed++; else failed++;++ clearState();+ if (test('destructive Bash gate keeps the full message regardless of denial count', () => {+ writeState({ checked: ['__bash_session__'], last_active: Date.now(), fact_force_denials: 50 });+ const result = runBashHook({ tool_name: 'Bash', tool_input: { command: 'rm -rf /tmp/damp-target' } });+ const output = parseOutput(result.stdout);+ assert.strictEqual(output.hookSpecificOutput.permissionDecision, 'deny');+ assert.ok(output.hookSpecificOutput.permissionDecisionReason.includes('rollback'),+ 'destructive gate is exempt from dampening');+ })) passed++; else failed++;+// Cleanup only the temp directory created by this test file.try {if (fs.existsSync(stateDir)) {diff --git a/tests/hooks/hooks.test.js b/tests/hooks/hooks.test.jsindex af0d0d246..146023544 100644--- a/tests/hooks/hooks.test.js+++ b/tests/hooks/hooks.test.js@@ -5285,17 +5285,15 @@ async function runTests() {console.log('\nRound 59: check-console-log.js (stdin exceeding 1MB — truncation):');if (- await asyncTest('truncates stdin at 1MB limit and still passes through data', async () => {- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit+ await asyncTest('suppresses pass-through for oversized stdin (fail-open, #2090)', async () => {+ // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit. Echoing the+ // truncated string would emit a JSON document cut mid-stream, which the+ // harness reports as a Stop hook JSON validation failure.const payload = 'x'.repeat(1024 * 1024 + 200000);const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), payload);assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');- // Output should be truncated — significantly less than input- assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);- // Output should be approximately 1MB (last accepted chunk may push slightly over)- assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');+ assert.strictEqual(result.stdout, '', 'Truncated stdin must not be echoed (empty stdout = no opinion)');}))passed++;diff --git a/tests/hooks/run-with-flags-truncation.test.js b/tests/hooks/run-with-flags-truncation.test.jsnew file mode 100644index 000000000..36cdf06ed--- /dev/null+++ b/tests/hooks/run-with-flags-truncation.test.js@@ -0,0 +1,154 @@+/**+ * Regression tests for #2222: run-with-flags.js must fail open on >1MB stdin.+ *+ * Before the fix, every fallthrough path echoed the truncated payload to+ * stdout. The harness parses hook stdout as JSON, got a document cut+ * mid-stream, and treated the hook as failed — blocking every Edit/Write+ * whose hook payload exceeded the 1MB cap.+ */++'use strict';++const assert = require('assert');+const path = require('path');+const { spawnSync } = require('child_process');++const repoRoot = path.join(__dirname, '..', '..');+const runner = path.join(repoRoot, 'scripts', 'hooks', 'run-with-flags.js');++const MAX_STDIN = 1024 * 1024;++function test(name, fn) {+ try {+ fn();+ console.log(` ✓ ${name}`);+ return true;+ } catch (error) {+ console.log(` ✗ ${name}`);+ console.log(` Error: ${error.message}`);+ return false;+ }+}++function runRunner(args, input, env = {}) {+ return spawnSync('node', [runner, ...args], {+ input,+ encoding: 'utf8',+ cwd: repoRoot,+ env: { ...process.env, ...env },+ timeout: 30000,+ maxBuffer: 16 * 1024 * 1024,+ stdio: ['pipe', 'pipe', 'pipe']+ });+}++function oversizedPayload() {+ // JSON document that exceeds MAX_STDIN so the runner's stdin cap trips.+ return JSON.stringify({+ tool_name: 'Write',+ tool_input: { file_path: '/tmp/big.md', content: 'x'.repeat(MAX_STDIN + 64 * 1024) }+ });+}++console.log('\nrun-with-flags truncation (fail-open) tests:');++let passed = 0;+let failed = 0;++if (+ test('oversized payload exits 0 with empty stdout for an enabled hook', () => {+ const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], oversizedPayload());+ assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}: ${result.stderr}`);+ assert.strictEqual(result.stdout, '', `stdout must be empty, got: ${result.stdout.slice(0, 120)}...`);+ assert.match(result.stderr, /stdin exceeded \d+ bytes for pre:write:doc-file-warning/);+ assert.match(result.stderr, /fail-open/);+ })+)+ passed++;+else failed++;++if (+ test('oversized payload never echoes truncated stdin when hook args are missing', () => {+ const result = runRunner([], oversizedPayload());+ assert.strictEqual(result.status, 0);+ assert.strictEqual(result.stdout, '', 'missing-args path must not echo truncated stdin');+ })+)+ passed++;+else failed++;++if (+ test('oversized payload never echoes truncated stdin for a disabled hook', () => {+ const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], oversizedPayload(), { ECC_DISABLED_HOOKS: 'pre:write:doc-file-warning' });+ assert.strictEqual(result.status, 0);+ assert.strictEqual(result.stdout, '', 'disabled-hook path must not echo truncated stdin');+ })+)+ passed++;+else failed++;++if (+ test('normal-sized payload still passes through unchanged', () => {+ const payload = JSON.stringify({+ tool_name: 'Write',+ tool_input: { file_path: '/tmp/small.js', content: 'const x = 1;\n' }+ });+ const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], payload);+ assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}: ${result.stderr}`);+ assert.ok(result.stdout.length > 0, 'normal payloads keep the pass-through behavior');+ JSON.parse(result.stdout); // stdout must remain valid JSON+ })+)+ passed++;+else failed++;++if (+ test('a security hook can still block on an oversized payload (no blanket skip)', () => {+ // config-protection refuses to fail open on truncated payloads. The+ // runner must still execute the hook and forward its verdict — only the+ // runner's own raw-echo is suppressed.+ const payload = JSON.stringify({+ tool_name: 'Write',+ tool_input: { file_path: '.eslintrc.js', content: 'x'.repeat(MAX_STDIN + 2048) }+ });+ const result = runRunner(['pre:config-protection', 'scripts/hooks/config-protection.js', 'standard,strict'], payload);+ assert.strictEqual(result.status, 2, `expected block exit 2, got ${result.status}: ${result.stderr}`);+ assert.strictEqual(result.stdout, '', 'blocked truncated payload must not echo raw input');+ })+)+ passed++;+else failed++;++if (+ test('payload just under the cap echoes through completely (no 64KB pipe cut)', () => {+ // process.exit() right after stdout.write() used to drop everything past+ // the ~64KB pipe buffer, cutting the echoed JSON mid-stream.+ const content = 'y'.repeat(MAX_STDIN - 1024);+ const payload = JSON.stringify({ tool_name: 'Write', tool_input: { file_path: '/tmp/edge.md', content } });+ assert.ok(payload.length < MAX_STDIN, 'fixture must stay under the stdin cap');+ const result = runRunner([], payload);+ assert.strictEqual(result.status, 0);+ assert.strictEqual(result.stdout.length, payload.length, 'echo must not be cut at the pipe buffer');+ assert.strictEqual(result.stdout, payload, 'sub-cap payloads still echo through fallthrough paths');+ })+)+ passed++;+else failed++;++if (+ test('disabled-hook passthrough of a >64KB payload stays valid JSON', () => {+ const payload = JSON.stringify({+ tool_name: 'Write',+ tool_input: { file_path: '/tmp/medium.md', content: 'z'.repeat(256 * 1024) }+ });+ const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], payload, { ECC_DISABLED_HOOKS: 'pre:write:doc-file-warning' });+ assert.strictEqual(result.status, 0);+ assert.strictEqual(result.stdout, payload);+ JSON.parse(result.stdout);+ })+)+ passed++;+else failed++;++console.log(`\n ${passed} passed, ${failed} failed\n`);+process.exit(failed > 0 ? 1 : 0);diff --git a/tests/hooks/stop-hooks-stdout.test.js b/tests/hooks/stop-hooks-stdout.test.jsnew file mode 100644index 000000000..08b79e66b--- /dev/null+++ b/tests/hooks/stop-hooks-stdout.test.js@@ -0,0 +1,203 @@+/**+ * Regression tests for #2090: "Stop hook error: JSON validation failed".+ *+ * Stop hooks follow the ECC pass-through convention (echo stdin on stdout).+ * The Stop payload carries `last_assistant_message`, which can be large; any+ * hook that caps stdin and echoes the capped string emits a JSON document cut+ * mid-stream, which the harness reports as a Stop hook JSON validation+ * failure. Worst offender: cost-tracker capped stdin at 64KB, so any Stop+ * payload with a >64KB final assistant message broke the whole Stop chain.+ *+ * Contract under test: for every Stop hook, stdout is either empty or valid+ * JSON, and the exit code is 0 — for realistic large payloads and for+ * oversized (>1MB) payloads, via the production runner and via direct+ * invocation.+ */++'use strict';++const assert = require('assert');+const fs = require('fs');+const os = require('os');+const path = require('path');+const { spawnSync } = require('child_process');++const repoRoot = path.join(__dirname, '..', '..');+const runner = path.join(repoRoot, 'scripts', 'hooks', 'run-with-flags.js');++const MAX_STDIN = 1024 * 1024;++const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-stop-stdout-')); // non-git cwd+const dataHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-stop-data-'));++function test(name, fn) {+ try {+ fn();+ console.log(` ✓ ${name}`);+ return true;+ } catch (error) {+ console.log(` ✗ ${name}`);+ console.log(` Error: ${error.message}`);+ return false;+ }+}++function stopPayload(messageBytes) {+ return JSON.stringify({+ session_id: `stop-stdout-test-${process.pid}`,+ transcript_path: path.join(workDir, 'missing-transcript.jsonl'),+ cwd: workDir,+ hook_event_name: 'Stop',+ stop_hook_active: false,+ last_assistant_message: 'm'.repeat(messageBytes)+ });+}++function hookEnv() {+ const env = {+ ...process.env,+ ECC_HOOK_PROFILE: 'standard',+ ECC_AGENT_DATA_HOME: dataHome,+ CLAUDE_SESSION_ID: `stop-stdout-test-${process.pid}`+ };+ delete env.ECC_GATEGUARD;+ delete env.ECC_DISABLED_HOOKS;+ return env;+}++function runViaRunner(hookId, script, input) {+ return spawnSync('node', [runner, hookId, script, 'minimal,standard,strict'], {+ input,+ encoding: 'utf8',+ cwd: workDir,+ env: hookEnv(),+ timeout: 60000,+ maxBuffer: 16 * 1024 * 1024,+ stdio: ['pipe', 'pipe', 'pipe']+ });+}++function runDirect(script, input) {+ return spawnSync('node', [path.join(repoRoot, script)], {+ input,+ encoding: 'utf8',+ cwd: workDir,+ env: hookEnv(),+ timeout: 60000,+ maxBuffer: 16 * 1024 * 1024,+ stdio: ['pipe', 'pipe', 'pipe']+ });+}++function assertStdoutContract(result, label) {+ assert.strictEqual(result.status, 0, `${label}: expected exit 0, got ${result.status}: ${result.stderr}`);+ if (result.stdout.length > 0) {+ try {+ JSON.parse(result.stdout);+ } catch (err) {+ assert.fail(`${label}: stdout is non-empty but not valid JSON (${err.message}); first 120 chars: ${result.stdout.slice(0, 120)}`);+ }+ }+}++// All registered Stop hooks (hooks/hooks.json).+const STOP_HOOKS = [+ ['stop:format-typecheck', 'scripts/hooks/stop-format-typecheck.js'],+ ['stop:check-console-log', 'scripts/hooks/check-console-log.js'],+ ['stop:session-end', 'scripts/hooks/session-end.js'],+ ['stop:evaluate-session', 'scripts/hooks/evaluate-session.js'],+ ['stop:cost-tracker', 'scripts/hooks/cost-tracker.js']+ // stop:desktop-notify is excluded from the valid-payload run because a+ // successful run() fires a real OS notification; its truncation path is+ // covered separately below (run() bails on JSON.parse before notifying).+];++// Direct-invocation legacy paths that echo stdin.+const ECHOING_STOP_HOOKS = [+ 'scripts/hooks/stop-format-typecheck.js',+ 'scripts/hooks/check-console-log.js',+ 'scripts/hooks/cost-tracker.js',+ 'scripts/hooks/desktop-notify.js'+];++console.log('\nStop hook stdout contract tests (#2090):');++let passed = 0;+let failed = 0;++// A 100KB last_assistant_message is a realistic long-session Stop payload.+// Before the fix, cost-tracker echoed it cut at 64KB through the production+// runner path, making the harness report "JSON validation failed".+const realisticPayload = stopPayload(100 * 1024);++for (const [hookId, script] of STOP_HOOKS) {+ if (+ test(`${hookId} via runner keeps stdout valid for a 100KB Stop payload`, () => {+ const result = runViaRunner(hookId, script, realisticPayload);+ assertStdoutContract(result, hookId);+ if (result.stdout.length > 0) {+ assert.strictEqual(result.stdout, realisticPayload, `${hookId}: pass-through must echo the payload uncut`);+ }+ })+ )+ passed++;+ else failed++;+}++const oversizedPayload = stopPayload(MAX_STDIN + 64 * 1024);++for (const [hookId, script] of [...STOP_HOOKS, ['stop:desktop-notify', 'scripts/hooks/desktop-notify.js']]) {+ if (+ test(`${hookId} via runner fails open on a >1MB Stop payload`, () => {+ const result = runViaRunner(hookId, script, oversizedPayload);+ assert.strictEqual(result.status, 0, `${hookId}: expected exit 0, got ${result.status}: ${result.stderr}`);+ assert.strictEqual(result.stdout, '', `${hookId}: oversized payloads must not be echoed`);+ })+ )+ passed++;+ else failed++;+}++for (const script of ECHOING_STOP_HOOKS) {+ if (+ test(`${path.basename(script)} invoked directly never echoes truncated stdin`, () => {+ const result = runDirect(script, oversizedPayload);+ assert.strictEqual(result.status, 0, `${script}: expected exit 0, got ${result.status}: ${result.stderr}`);+ assert.strictEqual(result.stdout, '', `${script}: truncated stdin must not be echoed`);+ })+ )+ passed++;+ else failed++;+}++if (+ test('check-console-log invoked directly echoes a sub-cap >64KB payload uncut', () => {+ const result = runDirect('scripts/hooks/check-console-log.js', realisticPayload);+ assert.strictEqual(result.status, 0);+ assert.strictEqual(result.stdout, realisticPayload, 'pass-through must not be cut at the pipe buffer');+ JSON.parse(result.stdout);+ })+)+ passed++;+else failed++;++if (+ test('cost-tracker invoked directly echoes a sub-cap >64KB payload uncut', () => {+ const result = runDirect('scripts/hooks/cost-tracker.js', realisticPayload);+ assert.strictEqual(result.status, 0);+ assert.strictEqual(result.stdout, realisticPayload, 'the old 64KB cap must not cut realistic Stop payloads');+ JSON.parse(result.stdout);+ })+)+ passed++;+else failed++;++try {+ fs.rmSync(workDir, { recursive: true, force: true });+ fs.rmSync(dataHome, { recursive: true, force: true });+} catch {+ /* best-effort cleanup */+}++console.log(`\n ${passed} passed, ${failed} failed\n`);+process.exit(failed > 0 ? 1 : 0);diff --git a/tests/scripts/codex-hooks.test.js b/tests/scripts/codex-hooks.test.jsindex 59b82b5ed..d482bb325 100644--- a/tests/scripts/codex-hooks.test.js+++ b/tests/scripts/codex-hooks.test.js@@ -261,7 +261,7 @@ if (else failed++;if (- test('merge-mcp-config dry-run appends all recommended servers without mutating target', () => {+ test('merge-mcp-config dry-run appends the current default set without mutating target', () => {const tempDir = createTempDir('mcp-merge-dry-run-');const configPath = path.join(tempDir, 'config.toml');const original = '';@@ -272,9 +272,12 @@ if (assert.strictEqual(result.status, 0, `${result.stdout}\n${result.stderr}`);assert.match(result.stdout, /Package manager: npm \(exec: npx\)/);- assert.match(result.stdout, /\[add\] mcp_servers\.supabase/);- assert.match(result.stdout, /\[mcp_servers\.github\]/);+ assert.match(result.stdout, /\[add\] mcp_servers\.chrome-devtools/);+ assert.match(result.stdout, /\[mcp_servers\.chrome-devtools\]/);assert.match(result.stdout, /Dry run/);+ // Retired defaults (June 2026 connector policy) must not be emitted.+ assert.doesNotMatch(result.stdout, /mcp_servers\.(supabase|playwright|context7|exa|github|memory|sequential-thinking)\b/);+ assert.doesNotMatch(result.stdout, /url = /);assert.strictEqual(fs.readFileSync(configPath, 'utf8'), original);} finally {cleanup(tempDir);@@ -296,14 +299,17 @@ if (const merged = fs.readFileSync(configPath, 'utf8');const parsed = TOML.parse(merged);- assert.strictEqual(parsed.mcp_servers.exa.url, 'https://mcp.exa.ai/mcp');- assert.strictEqual(parsed.mcp_servers.github.command, 'bash');- assert.deepStrictEqual(parsed.mcp_servers.memory.args, ['@modelcontextprotocol/server-memory']);- assert.strictEqual(parsed.mcp_servers.supabase.tool_timeout_sec, 120);+ assert.strictEqual(parsed.mcp_servers['chrome-devtools'].command, 'npx');+ assert.deepStrictEqual(parsed.mcp_servers['chrome-devtools'].args, ['chrome-devtools-mcp@latest']);+ assert.strictEqual(parsed.mcp_servers['chrome-devtools'].startup_timeout_sec, 30);+ // No retired server may be (re-)emitted — exa's url form broke Codex (#2224).+ assert.strictEqual(parsed.mcp_servers.exa, undefined);+ assert.strictEqual(parsed.mcp_servers.github, undefined);+ assert.strictEqual(parsed.mcp_servers.supabase, undefined);const second = runNode(mergeMcpConfigScript, [configPath], deterministicPackageEnv);assert.strictEqual(second.status, 0, `${second.stdout}\n${second.stderr}`);- assert.match(second.stdout, /\[ok\] mcp_servers\.github/);+ assert.match(second.stdout, /\[ok\] mcp_servers\.chrome-devtools/);assert.match(second.stdout, /All ECC MCP servers already present/);assert.strictEqual(fs.readFileSync(configPath, 'utf8'), merged);} finally {@@ -315,24 +321,88 @@ if (else failed++;if (- test('merge-mcp-config update dry-run reports canonical and legacy section refreshes', () => {- const tempDir = createTempDir('mcp-merge-update-dry-run-');+ test('merge-mcp-config repairs the invalid exa url entry from earlier ECC versions (#2224)', () => {+ const tempDir = createTempDir('mcp-merge-exa-repair-');const configPath = path.join(tempDir, 'config.toml');const original = [- '[mcp_servers.context7]',- 'command = "custom"',- 'args = ["old"]',+ '[mcp_servers.github]',+ 'command = "npx"',+ 'args = ["-y", "@modelcontextprotocol/server-github"]','',- '[mcp_servers.context7-mcp]',+ '[mcp_servers.exa]',+ 'url = "https://mcp.exa.ai/mcp"',+ '',+ ].join('\n');++ try {+ fs.writeFileSync(configPath, original);+ const result = runNode(mergeMcpConfigScript, [configPath], deterministicPackageEnv);++ assert.strictEqual(result.status, 0, `${result.stdout}\n${result.stderr}`);+ assert.match(result.stdout, /\[repair\] mcp_servers\.exa/);++ const updated = fs.readFileSync(configPath, 'utf8');+ const parsed = TOML.parse(updated);+ assert.strictEqual(parsed.mcp_servers.exa, undefined, 'invalid exa url entry must be removed');+ assert.doesNotMatch(updated, /url = "https:\/\/mcp\.exa\.ai\/mcp"/);+ // User-managed servers are untouched; current default is added.+ assert.strictEqual(parsed.mcp_servers.github.command, 'npx');+ assert.strictEqual(parsed.mcp_servers['chrome-devtools'].command, 'npx');++ // Re-running must not re-introduce the invalid entry.+ const second = runNode(mergeMcpConfigScript, [configPath], deterministicPackageEnv);+ assert.strictEqual(second.status, 0, `${second.stdout}\n${second.stderr}`);+ assert.doesNotMatch(fs.readFileSync(configPath, 'utf8'), /mcp_servers\.exa/);+ } finally {+ cleanup(tempDir);+ }+ })+)+ passed++;+else failed++;++if (+ test('merge-mcp-config leaves a user-managed stdio exa entry untouched', () => {+ const tempDir = createTempDir('mcp-merge-exa-stdio-');+ const configPath = path.join(tempDir, 'config.toml');+ const original = [+ '[mcp_servers.exa]','command = "npx"',- 'args = ["legacy"]',+ 'args = ["-y", "mcp-remote", "https://mcp.exa.ai/mcp"]',+ 'startup_timeout_sec = 30','',- '[mcp_servers.supabase]',+ ].join('\n');++ try {+ fs.writeFileSync(configPath, original);+ const result = runNode(mergeMcpConfigScript, [configPath], deterministicPackageEnv);++ assert.strictEqual(result.status, 0, `${result.stdout}\n${result.stderr}`);+ assert.doesNotMatch(result.stdout, /\[repair\]/);++ const parsed = TOML.parse(fs.readFileSync(configPath, 'utf8'));+ assert.strictEqual(parsed.mcp_servers.exa.command, 'npx');+ assert.deepStrictEqual(parsed.mcp_servers.exa.args, ['-y', 'mcp-remote', 'https://mcp.exa.ai/mcp']);+ } finally {+ cleanup(tempDir);+ }+ })+)+ passed++;+else failed++;++if (+ test('merge-mcp-config update dry-run refreshes managed sections and leaves user servers alone', () => {+ const tempDir = createTempDir('mcp-merge-update-dry-run-');+ const configPath = path.join(tempDir, 'config.toml');+ const original = [+ '[mcp_servers.chrome-devtools]','command = "custom"','args = ["old"]','',- '[mcp_servers.supabase.env]',- 'SUPABASE_ACCESS_TOKEN = "token"',+ '[mcp_servers.context7]',+ 'command = "npx"',+ 'args = ["-y", "@upstash/context7-mcp@latest"]','',].join('\n');@@ -341,11 +411,10 @@ if (const result = runNode(mergeMcpConfigScript, [configPath, '--update-mcp', '--dry-run'], deterministicPackageEnv);assert.strictEqual(result.status, 0, `${result.stdout}\n${result.stderr}`);- assert.match(result.stdout, /\[remove\] mcp_servers\.context7/);- assert.match(result.stdout, /\[remove\] mcp_servers\.context7-mcp/);- assert.match(result.stdout, /\[remove\] mcp_servers\.supabase/);- assert.match(result.stdout, /\[mcp_servers\.supabase\]/);- assert.match(result.stdout, /\[mcp_servers\.context7\]/);+ assert.match(result.stdout, /\[remove\] mcp_servers\.chrome-devtools/);+ assert.match(result.stdout, /\[mcp_servers\.chrome-devtools\]/);+ // Retired servers are no longer ECC-managed: never removed or re-added.+ assert.doesNotMatch(result.stdout, /\[remove\] mcp_servers\.context7/);assert.strictEqual(fs.readFileSync(configPath, 'utf8'), original);} finally {cleanup(tempDir);@@ -356,38 +425,31 @@ if (else failed++;if (- test('merge-mcp-config removes disabled legacy servers without appending replacements', () => {+ test('merge-mcp-config removes disabled servers without appending replacements', () => {const tempDir = createTempDir('mcp-merge-disabled-');const configPath = path.join(tempDir, 'config.toml');const original = [- '[mcp_servers.context7-mcp]',+ '[mcp_servers.chrome-devtools]','command = "npx"',- 'args = ["legacy"]',- '',- '[mcp_servers.exa]',- 'url = "https://mcp.exa.ai/mcp"',+ 'args = ["chrome-devtools-mcp@latest"]','',].join('\n');- const allServersDisabled = 'supabase,playwright,context7,exa,github,memory,sequential-thinking';try {fs.writeFileSync(configPath, original);const result = runNode(mergeMcpConfigScript, [configPath], {...deterministicPackageEnv,- ECC_DISABLED_MCPS: allServersDisabled,+ ECC_DISABLED_MCPS: 'chrome-devtools',});assert.strictEqual(result.status, 0, `${result.stdout}\n${result.stderr}`);assert.match(result.stdout, /Disabled via ECC_DISABLED_MCPS/);- assert.match(result.stdout, /\[skip\] mcp_servers\.context7 \(disabled\)/);- assert.match(result.stdout, /\[skip\] mcp_servers\.exa \(disabled\)/);- assert.match(result.stdout, /\[update\] mcp_servers\.context7-mcp \(disabled\)/);- assert.match(result.stdout, /\[update\] mcp_servers\.exa \(disabled\)/);- assert.match(result.stdout, /Done\. Removed 2 disabled server\(s\)\./);+ assert.match(result.stdout, /\[skip\] mcp_servers\.chrome-devtools \(disabled\)/);+ assert.match(result.stdout, /\[update\] mcp_servers\.chrome-devtools \(disabled\)/);+ assert.match(result.stdout, /Done\. Removed 1 server section\(s\)\./);const updated = fs.readFileSync(configPath, 'utf8');- assert.doesNotMatch(updated, /context7-mcp/);- assert.doesNotMatch(updated, /mcp_servers\.exa/);+ assert.doesNotMatch(updated, /chrome-devtools/);} finally {cleanup(tempDir);}@@ -454,7 +516,10 @@ if (assert.strictEqual(parsedConfig.agents.explorer.config_file, 'agents/explorer.toml');assert.strictEqual(parsedConfig.agents.reviewer.config_file, 'agents/reviewer.toml');assert.strictEqual(parsedConfig.agents.docs_researcher.config_file, 'agents/docs-researcher.toml');- assert.ok(parsedConfig.mcp_servers.exa);+ // Current default connector is added; retired servers are not emitted,+ // and pre-existing user-managed entries are preserved untouched.+ assert.ok(parsedConfig.mcp_servers['chrome-devtools']);+ assert.strictEqual(parsedConfig.mcp_servers.exa, undefined);assert.ok(parsedConfig.mcp_servers.github);assert.ok(parsedConfig.mcp_servers.memory);assert.ok(parsedConfig.mcp_servers['sequential-thinking']);