@event4u/agent-config 9.7.0 → 9.9.0

package/src/scripts/memory_signal.ts

@@ -29,6 +29,7 @@
 
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -211,6 +212,49 @@ export interface SignalRecord {
     body: string;
 }
 
+/**
+ * Provenance gate at the write edge — invariant 2 of ADR-130 (`subject`
+ * axis). A record whose `origin` resolves into the user-global store, or
+ * that carries `subject: user`, is REFUSED entry into the tracked project
+ * intake (plain path/field check, no model call). `subject: project` is
+ * the additive default. Thrown message names the partition rule.
+ */
+export class ProvenanceRefusedError extends Error {}
+
+// lint-store-boundary: ignore — the provenance gate must RECOGNISE the global root to refuse it
+const _GLOBAL_STORE_MARKER = `.event4u${path.sep}agent-config`;
+
+export function _origin_is_global(origin: string): boolean {
+    if (!origin.includes('/') && !origin.includes(path.sep) && !origin.startsWith('~')) {
+        return false; // symbolic origins ('agent', 'claude', 'cursor', …) are not paths
+    }
+    const expanded = origin.startsWith('~')
+        ? path.join(os.homedir(), origin.slice(1)) // lint-store-boundary: ignore — the gate itself must recognise the global root
+        : origin;
+    let resolved: string;
+    try {
+        resolved = path.resolve(expanded);
+    } catch {
+        return false;
+    }
+    return resolved.includes(_GLOBAL_STORE_MARKER) || /(^|[\\/])\.event4u([\\/]|$)/.test(origin);
+}
+
+export function _assert_project_writable(record: { origin: string; subject?: unknown }): void {
+    if (record.subject === 'user') {
+        throw new ProvenanceRefusedError(
+            'provenance gate: subject: user records live global-only and may ' +
+                'never be written into a tracked project artifact (ADR-130).',
+        );
+    }
+    if (_origin_is_global(record.origin)) {
+        throw new ProvenanceRefusedError(
+            `provenance gate: origin resolves into the user-global store ` +
+                `(${record.origin}) — refused entry into tracked project intake (ADR-130).`,
+        );
+    }
+}
+
 /**
  * Append a signal entry. Returns the written record, or null when skipped.
  */
@@ -252,6 +296,10 @@ export function emit(
             }
         }
     }
+    if (!('subject' in record)) {
+        record.subject = 'project'; // additive default (ADR-130)
+    }
+    _assert_project_writable(record as { origin: string; subject?: unknown });
     fs.mkdirSync(INTAKE_ROOT, { recursive: true });
     const target = _monthly_file();
     fs.appendFileSync(target, `${_jsonDumpsUnicode(record)}\n`, 'utf-8');

package/src/scripts/memory_status.ts

@@ -176,7 +176,13 @@ export function main(): number {
     return 0;
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/minimal_safe_diff_hook.ts

@@ -36,6 +36,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { atomic_write_json } from "./hooks/state_io.js";
+import { readHookStdin } from "./hooks/hook_stdin.js";
 
 // NOTE: the Python docstring says `agents/runtime/state/`, but the code
 // constant is `agents/state/`. Replicated verbatim — latent docstring/code
@@ -335,11 +336,7 @@ function parse_args(argv: string[]): ParsedArgs {
 }
 
 function _readStdin(): string {
-  try {
-    return fs.readFileSync(0, "utf-8");
-  } catch {
-    return "";
-  }
+  return readHookStdin();
 }
 
 export function main(argv?: string[]): number {
@@ -347,7 +344,13 @@ export function main(argv?: string[]): number {
   return run(_readStdin(), { consumer_root: process.cwd(), verbose: args.verbose });
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/onboarding_gate_hook.ts

@@ -36,6 +36,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 // `agents/runtime/state/.dispatcher.lock` discipline (hook-architecture-v1.md
 // § Concurrency, Phase 7.4).
 import { atomic_write_json } from "./hooks/state_io.js";
+import { readHookStdin } from "./hooks/hook_stdin.js";
 
 export const SETTINGS_FILE = ".agent-settings.yml";
 // NOTE: the Python docstring says `agents/runtime/state/`, but the code
@@ -201,11 +202,7 @@ function parse_args(argv: string[]): ParsedArgs {
 }
 
 function _readStdin(): void {
-  try {
-    fs.readFileSync(0, "utf-8");
-  } catch {
-    /* ignore */
-  }
+  readHookStdin();
 }
 
 export function main(argv?: string[]): number {
@@ -216,7 +213,13 @@ export function main(argv?: string[]): number {
   return run({ consumer_root: process.cwd(), verbose: args.verbose });
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/orchestration_record.ts

@@ -12,6 +12,10 @@
  *     --tier-chosen lite --tier-source inferred --task-class read-only-fanout \
  *     [--tiers sonnet,opus] [--agent-combo implementer,judge] [--wall-clock-ms 18500] [--dispatch-outcome DONE] \
  *     [--first-pass-success true|false] [--escalated true|false] \
+ *     [--init-tokens 1200] [--payload-hash <hex8-64>] [--lookup-class definition|references|string-existence|report-run] \
+ *     [--route-taken primitive|subagent] [--budget-hit true|false] [--correctness-match true|false] \
+ *     [--cache-hit true|false] [--origin lean-init-2026] \
+ *     [--rules-carried 32] [--rules-used 5] \
  *     [--dir <audit-dir>] [--dry-run]
  *
  * Read by `src/scripts/orchestration_savings_report.ts`.
@@ -22,6 +26,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
+import type { LookupClass } from './_lib/auto_dispatch.js';
 import {
     buildOrchestrationLine,
     type Provenance,
@@ -33,6 +38,7 @@ import {
     type LinePhase,
     type LineOutcome,
     type RecordInput,
+    type RouteTaken,
 } from './_lib/orchestration_record.js';
 
 const DEFAULT_DIR = 'agents/runtime/state/audit';
@@ -122,6 +128,16 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         verify_mode: str(flags, 'verify-mode') as VerifyMode | undefined,
         first_pass_success: bool(flags, 'first-pass-success'),
         escalated: bool(flags, 'escalated'),
+        init_tokens: int(flags, 'init-tokens'),
+        payload_hash: str(flags, 'payload-hash'),
+        lookup_class: str(flags, 'lookup-class') as LookupClass | undefined,
+        route_taken: str(flags, 'route-taken') as RouteTaken | undefined,
+        budget_hit: bool(flags, 'budget-hit'),
+        correctness_match: bool(flags, 'correctness-match'),
+        cache_hit: bool(flags, 'cache-hit'),
+        origin: str(flags, 'origin'),
+        rules_carried: int(flags, 'rules-carried'),
+        rules_used: int(flags, 'rules-used'),
         phase: str(flags, 'phase') as LinePhase | undefined,
         outcome: str(flags, 'outcome') as LineOutcome | undefined,
         confidence_band: str(flags, 'confidence-band') as Band | undefined,

package/src/scripts/pr_url_reminder_hook.ts

@@ -28,6 +28,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { readHookStdin } from "./hooks/hook_stdin.js";
 
 const EXIT_ALLOW = 0;
 const EXIT_WARN = 2;
@@ -150,10 +151,16 @@ export function main(): number {
 }
 
 function _readStdin(): string {
-  return fs.readFileSync(0, "utf-8");
+  return readHookStdin();
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+  if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+    return false;
+  }
   if (process.argv[1] === undefined) {
     return false;
   }

package/src/scripts/prepack-check.mjs

@@ -159,6 +159,23 @@ process.stderr.write(
     `prepack-check: import-completeness OK (${scanRoots.length} shipped src tree(s) scanned)\n`,
 );
 
+// ---------------------------------------------------------------------------
+// Lifecycle-target guard (gate 3): every consumer-side lifecycle script
+// (preinstall/install/postinstall/prepare) must reference only targets that
+// exist and ship. Structural fix for the 9.8.0 dead-postinstall class.
+// ---------------------------------------------------------------------------
+import { existsSync } from 'node:fs';
+import { checkLifecycleTargets } from './prepack_lifecycle_check.mjs';
+
+const lifecycleErrors = checkLifecycleTargets(pkg, (p) => existsSync(resolve(p)));
+if (lifecycleErrors.length > 0) {
+    for (const e of lifecycleErrors) {
+        process.stderr.write(`prepack-check: ${e}\n`);
+    }
+    die(`${lifecycleErrors.length} lifecycle script target(s) missing or unshipped.`);
+}
+process.stderr.write('prepack-check: lifecycle script targets OK\n');
+
 // Optional: invoked with --verbose dumps the size for tarball-budget bookkeeping.
 if (argv.includes('--verbose')) {
     process.stderr.write(`prepack-check: size=${st.size} bytes\n`);

package/src/scripts/prepack_lifecycle_check.d.mts

@@ -0,0 +1,8 @@
+/** Type declarations for prepack_lifecycle_check.mjs (plain-JS prepack gate). */
+export declare const CONSUMER_LIFECYCLE_SCRIPTS: string[];
+export declare function extractScriptTargets(command: string): string[];
+export declare function isShippedPath(relPath: string, files: string[]): boolean;
+export declare function checkLifecycleTargets(
+    pkg: { scripts?: Record<string, string>; files?: string[] },
+    existsFn: (relPath: string) => boolean,
+): string[];

package/src/scripts/prepack_lifecycle_check.mjs

@@ -0,0 +1,82 @@
+/**
+ * prepack_lifecycle_check.mjs — gate 3 of the prepack guard.
+ *
+ * Every `package.json` lifecycle script that runs on the CONSUMER side
+ * (preinstall / install / postinstall / prepare) must only reference file
+ * targets that exist AND are covered by the `files` pack whitelist. This is
+ * the structural fix for the 9.8.0 dead-postinstall class: a hook pointing at
+ * `dist/scripts/postinstall_gui.js` that nothing built failed silently on
+ * every install for months because the check was one-time, not standing.
+ *
+ * Pure module (no top-level side effects) so the red/green test can exercise
+ * it with a fabricated package.json — prepack-check.mjs is the CLI caller.
+ */
+
+/** Lifecycle scripts npm executes in a CONSUMER install of the tarball. */
+export const CONSUMER_LIFECYCLE_SCRIPTS = ['preinstall', 'install', 'postinstall', 'prepare'];
+
+/**
+ * Extract file-path targets from a shell command line: arguments following
+ * `node` / `bash` / `sh` interpreters. Flags and shell operators are skipped.
+ */
+export function extractScriptTargets(command) {
+    const targets = [];
+    // Split on shell connectors so each simple command is scanned on its own.
+    for (const segment of command.split(/&&|\|\||;|\|/)) {
+        const tokens = segment.trim().split(/\s+/);
+        for (let i = 0; i < tokens.length - 1; i += 1) {
+            if (!/^(node|bash|sh)$/.test(tokens[i])) continue;
+            for (let j = i + 1; j < tokens.length; j += 1) {
+                const tok = tokens[j];
+                if (tok.startsWith('-')) continue; // interpreter flag
+                // Shell noise (redirections, subshell tokens) ends the scan.
+                if (/[<>()[\]]/.test(tok)) break;
+                targets.push(tok);
+                break;
+            }
+        }
+    }
+    return targets;
+}
+
+/** Whitelist membership — same semantics as prepack-check's isShipped(). */
+export function isShippedPath(relPath, files) {
+    const posix = relPath.split('\\').join('/');
+    const prefixes = files.filter((f) => f.endsWith('/')).map((f) => f.replace(/\/+$/, '') + '/');
+    const exact = new Set(files.filter((f) => !f.endsWith('/')));
+    if (exact.has(posix)) return true;
+    return prefixes.some((p) => posix.startsWith(p));
+}
+
+/**
+ * Check every consumer-side lifecycle script of `pkg`.
+ *
+ * @param pkg parsed package.json ({ scripts, files })
+ * @param existsFn (relPath: string) => boolean — injectable for tests
+ * @returns string[] — human-readable errors; empty = green
+ */
+export function checkLifecycleTargets(pkg, existsFn) {
+    const errors = [];
+    const scripts = pkg.scripts ?? {};
+    const files = pkg.files ?? [];
+    for (const name of CONSUMER_LIFECYCLE_SCRIPTS) {
+        const command = scripts[name];
+        if (typeof command !== 'string' || command.length === 0) continue;
+        for (const target of extractScriptTargets(command)) {
+            if (!existsFn(target)) {
+                errors.push(
+                    `scripts.${name} references '${target}', which does not exist ` +
+                        '(dead lifecycle script — fails silently on every consumer install)',
+                );
+                continue;
+            }
+            if (!isShippedPath(target, files)) {
+                errors.push(
+                    `scripts.${name} references '${target}', which is not covered by the ` +
+                        'package.json `files` whitelist (missing from the published tarball)',
+                );
+            }
+        }
+    }
+    return errors;
+}

package/src/scripts/profile_staleness_hook.ts

@@ -36,6 +36,7 @@ import {
   LOCAL_PROJECT_FILE,
   LOCAL_PROJECT_SUBDIR,
 } from "./_lib/agent_settings.js";
+import { readHookStdin } from "./hooks/hook_stdin.js";
 
 // --- inlined session_profiles.stale_notice slice (unported dep) ----------
 
@@ -118,13 +119,7 @@ function _project_root(): string {
 }
 
 function _readStdinIfNotTty(): void {
-  try {
-    if (!process.stdin.isTTY) {
-      fs.readFileSync(0, "utf-8");
-    }
-  } catch {
-    /* ignore */
-  }
+  readHookStdin();
 }
 
 function _parseRoot(argv: string[]): string | null {
@@ -161,7 +156,13 @@ export function main(argv?: string[]): number {
   return 0;
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }