@haystackeditor/cli 0.15.27 → 0.15.28

package/dist/assets/telemetry/runtime.cjs

@@ -51,6 +51,7 @@ const safeBufferByteLength = Buffer.byteLength;
 const safeObjectKeys = Object.keys;
 const safeObjectEntries = Object.entries;
 const safeObjectCreate = Object.create;
+const safeObjectFreeze = Object.freeze;
 const safeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 const safeGetPrototypeOf = Object.getPrototypeOf;
 const safeHasOwn = Function.call.bind(Object.prototype.hasOwnProperty);
@@ -95,7 +96,7 @@ const safeResponseStatus = typeof Response === 'function'
   : null;
 const safeClearInterval = clearInterval;
 const SafeError = Error;
-const nativeErrorPrototypes = Object.freeze({
+const nativeErrorPrototypes = safeObjectFreeze({
   type: TypeError.prototype,
   range: RangeError.prototype,
   syntax: SyntaxError.prototype,
@@ -173,10 +174,12 @@ function responseStatus(response) {
 }
 
 const RUNTIME_VERSION = 1;
-const SAMPLER_VERSION = 3;
+const SAMPLER_VERSION = 4;
 const DEFAULT_FLUSH_INTERVAL_MS = 60_000;
 const DEFAULT_SITE_OBSERVATIONS = 8;
 const MAX_SITE_OBSERVATIONS = 4_096;
+const DEFAULT_PROCESS_PROBE_OBSERVATIONS = 4_096;
+const MAX_PROCESS_PROBE_OBSERVATIONS = 65_536;
 const MAX_SAFE_COUNT = Number.MAX_SAFE_INTEGER;
 const MAX_COUNTER_KEYS = 50_000;
 const MAX_EXECUTION_FAMILIES = 64;
@@ -195,7 +198,7 @@ const MAX_CONSECUTIVE_FAILURES = 3;
 const CONTROL_GLOBAL = '__haystackTelemetryControlV1';
 const CONTROL_CHANNEL = '__HAYSTACK_TELEMETRY_CONTROL_CHANNEL__';
 const RUNTIME_INTEGRITY = '__HAYSTACK_TELEMETRY_RUNTIME_INTEGRITY__';
-const SUPPRESSED_ACTION = Object.freeze({ suppressed: true });
+const SUPPRESSED_ACTION = safeObjectFreeze({ suppressed: true });
 
 let installed = false;
 let activeControl = null;
@@ -401,7 +404,7 @@ function loadInstrumentation() {
     const manifest = safeJsonParse(readFileSync(join(__dirname, 'instrumentation.json'), 'utf8'));
     if (manifest.schema_version !== 'haystack-node-telemetry-instrumentation-v3' ||
         !safeArrayIsArray(manifest.sites)) return { sites: new SafeMap(), entrySourcePath: null };
-    const siteEntries = safeArrayMap(manifest.sites, site => [site.probe_key, Object.freeze({
+    const siteEntries = safeArrayMap(manifest.sites, site => [site.probe_key, safeObjectFreeze({
       probeKey: site.probe_key,
       siteId: site.site_id,
       sourcePath: site.source_path,
@@ -461,7 +464,6 @@ function installRuntime(options = {}) {
       metadata,
       calls: 0,
       saturated: false,
-      omitted: 0,
     });
   }
   if (safeMapSize(sitesByProbe) === 0) return { enabled: false, reason: 'missing-instrumentation-manifest' };
@@ -481,6 +483,15 @@ function installRuntime(options = {}) {
     requestedSiteObservations >= 1 && requestedSiteObservations <= MAX_SITE_OBSERVATIONS
     ? requestedSiteObservations
     : DEFAULT_SITE_OBSERVATIONS;
+  const requestedProcessProbeObservations = safeNumberParseInt(
+    process.env.HAYSTACK_TELEMETRY_PROCESS_PROBE_OBSERVATIONS ?? '',
+    10,
+  );
+  const processProbeObservationLimit = safeNumberIsSafeInteger(requestedProcessProbeObservations) &&
+    requestedProcessProbeObservations >= 1 &&
+    requestedProcessProbeObservations <= MAX_PROCESS_PROBE_OBSERVATIONS
+    ? requestedProcessProbeObservations
+    : DEFAULT_PROCESS_PROBE_OBSERVATIONS;
   const requestedProcessSampleRate = safeNumberParseInt(
     process.env.HAYSTACK_TELEMETRY_PROCESS_SAMPLE_RATE ?? '',
     10,
@@ -499,6 +510,8 @@ function installRuntime(options = {}) {
     : DEFAULT_ACTION_SAMPLE_RATE;
 
   let enabled = true;
+  let collecting = true;
+  let processProbeObservations = 0;
   let sequence = 0;
   let consecutiveFailures = 0;
   let currentShape = new SafeMap();
@@ -509,7 +522,6 @@ function installRuntime(options = {}) {
   let sampledActions = 0;
   let unsampledActions = 0;
   let currentOmissions = new SafeMap();
-  let saturatedProbeOmissions = 0;
   let pending = null;
   let pendingQueue = [];
   let flushInFlight = null;
@@ -743,11 +755,15 @@ function installRuntime(options = {}) {
   }
 
   function sampleWeight(state) {
-    if (state.saturated) {
-      if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
-      if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
+    if (processProbeObservations >= processProbeObservationLimit) {
+      // Attribute the one observation that exhausted the process-wide budget.
+      // Later probes are deliberately not inspected or counted: the sampler
+      // version declares that this is a bounded, lossy collection mode.
+      recordOmission(state.metadata.probeKey, 'probeObservations');
+      collecting = false;
       return -2;
     }
+    processProbeObservations++;
     const calls = ++state.calls;
     if (calls > siteObservationLimit) {
       state.saturated = true;
@@ -766,7 +782,11 @@ function installRuntime(options = {}) {
   }
 
   function observeState(state, value, fields) {
-    if (!enabled) return value;
+    // Saturation is deliberately lossy: the first over-limit observation
+    // records an explicit saturation marker, then this probe becomes a
+    // constant-time pass-through. Counting every later omission caused severe
+    // amplification in customer hot loops while adding no new shape evidence.
+    if (!enabled || !collecting || state.saturated) return value;
     try {
       const site = state.metadata.probeKey;
       const action = actionForProbe();
@@ -877,7 +897,7 @@ function installRuntime(options = {}) {
   }
 
   function branchState(state, value) {
-    if (!enabled) return value;
+    if (!enabled || !collecting || state.saturated) return value;
     try {
       const site = state.metadata.probeKey;
       const action = actionForProbe();
@@ -909,7 +929,7 @@ function installRuntime(options = {}) {
   }
 
   function thrownState(state, value) {
-    if (!enabled) return value;
+    if (!enabled || !collecting || state.saturated) return value;
     try {
       const site = state.metadata.probeKey;
       const action = actionForProbe();
@@ -939,7 +959,7 @@ function installRuntime(options = {}) {
     if (pending || pendingQueue.length > 0 || (safeMapSize(currentShape) === 0 &&
       safeMapSize(currentBranch) === 0 && safeMapSize(currentExecutions) === 0 &&
       omittedExecutionFamilyObservations === 0 && sampledActions === 0 && unsampledActions === 0 &&
-      safeMapSize(currentOmissions) === 0 && saturatedProbeOmissions === 0)) return;
+      safeMapSize(currentOmissions) === 0)) return;
     const shape = objectFromMap(currentShape);
     const branchCounters = objectFromMap(currentBranch);
     currentShape = new SafeMap();
@@ -958,25 +978,6 @@ function installRuntime(options = {}) {
     sampledActions = 0;
     unsampledActions = 0;
     omittedExecutionFamilyObservations = 0;
-    if (saturatedProbeOmissions > 0) {
-      const countEntries = mapEntriesArray(probeStates);
-      for (let index = 0; index < countEntries.length; index++) {
-        const site = countEntries[index][0];
-        const state = countEntries[index][1];
-        if (!state || state.omitted <= 0) continue;
-        const current = safeMapGet(currentOmissions, site) || {
-          counterObservations: 0,
-          probeObservations: 0,
-        };
-        current.probeObservations = safeMathMin(
-          MAX_SAFE_COUNT,
-          current.probeObservations + state.omitted,
-        );
-        safeMapSet(currentOmissions, site, current);
-        state.omitted = 0;
-      }
-      saturatedProbeOmissions = 0;
-    }
     const omittedEntries = safeArraySort(
       mapEntriesArray(currentOmissions),
       (leftEntry, rightEntry) => compareStrings(leftEntry[0], rightEntry[0]),
@@ -1389,7 +1390,7 @@ function installRuntime(options = {}) {
     void flush('before-exit');
   });
 
-  const control = Object.freeze({
+  const control = safeObjectFreeze({
     enabled: true,
     runtimeVersion: RUNTIME_VERSION,
     buildId,
@@ -1409,55 +1410,48 @@ function installRuntime(options = {}) {
       if (name === '__hstValue') {
         const fields = state.metadata.allowedFields;
         return (value) => {
-          if (!enabled) return value;
-          if (state.saturated) {
-            const action = actionForProbe();
-            if (action?.suppressed) return value;
-            const executionValue = state.metadata.probeKind === 'parameter' ||
-              state.metadata.probeKind === 'return';
-            if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
-            if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
-            if (executionValue) {
-              const skippedEvents = value !== null && typeof value === 'object' && !safeArrayIsArray(value)
-                ? 1 + safeMathMin(fields.length, 48)
-                : 1;
-              omitExecutionEvents(action, skippedEvents);
-            }
-            return value;
-          }
+          if (!enabled || !collecting || state.saturated) return value;
           return observeState(state, value, fields);
         };
       }
       if (name === '__hstBranch') return (value) => {
-        if (!enabled) return value;
-        if (state.saturated) {
-          const action = actionForProbe();
-          if (action?.suppressed) return value;
-          if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
-          if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
-          omitExecutionEvents(action);
-          return value;
-        }
+        if (!enabled || !collecting || state.saturated) return value;
         return branchState(state, value);
       };
       if (name === '__hstThrow') return (value) => {
-        if (!enabled) return value;
-        if (state.saturated) {
-          const action = actionForProbe();
-          if (action?.suppressed) return value;
-          if (state.omitted < MAX_SAFE_COUNT) state.omitted++;
-          if (saturatedProbeOmissions < MAX_SAFE_COUNT) saturatedProbeOmissions++;
-          omitExecutionEvents(action);
-          return value;
-        }
+        if (!enabled || !collecting || state.saturated) return value;
         return thrownState(state, value);
       };
       return null;
     },
+    snapshotCurrentAction() {
+      try {
+        const action = currentAction();
+        if (!action || action.actionKind !== 'http-server') return null;
+        return safeObjectFreeze({
+          actionKind: action.actionKind,
+          truncated: action.truncated,
+          omittedEvents: action.omittedEvents,
+          events: safeObjectFreeze(safeArrayMap(action.events, event => safeObjectFreeze({
+            siteId: event.siteId,
+            kind: event.kind,
+            scope: event.scope,
+            outcome: event.outcome,
+            observations: event.observations,
+          }))),
+        });
+      } catch (error) {
+        debug('current action snapshot failed open', error);
+        return null;
+      }
+    },
     status() {
       return {
         enabled,
+        collecting,
         sequence,
+        processProbeObservations,
+        processProbeObservationLimit,
         pending: pending !== null || pendingQueue.length > 0,
         shapeKeys: safeMapSize(currentShape),
         branchKeys: safeMapSize(currentBranch),
@@ -1496,7 +1490,7 @@ function install(options = {}) {
   }
 }
 
-const publicRuntime = Object.freeze({ install, selectProbe, safeSelectProbe, safeSelectSiteProbe });
+const publicRuntime = safeObjectFreeze({ install, selectProbe, safeSelectProbe, safeSelectSiteProbe });
 // Keep the exported capability immutable. The generated CommonJS entry locks
 // its cache slot after genuine evaluation; the ESM wrapper evaluates this
 // source outside CommonJS's public cache.

package/dist/commands/design-verify.d.ts

@@ -6,18 +6,26 @@
  *
  * Unlike `haystack review` (finding-oriented analysis of the diff), design
  * verification executes the change: it infers intent from the diff alone,
- * designs pre-registered behavioral test cases, runs them against both sides
- * of the PR in isolated sandboxes, and produces a mechanical verdict of
- * unexpected behavior changes.
+ * designs pre-registered behavioral test cases, runs control-before, before,
+ * and after in isolated sandboxes, and reports evidence-backed anomaly
+ * candidates outside the registered intent.
  *
  * The command waits by default and returns an agent-facing behavioral result.
  * --no-wait preserves the asynchronous trigger-only path.
  */
+import { type DesignVerifierUniverseRole } from '../utils/design-verifier-api.js';
 export interface DesignVerifyOptions {
     json?: boolean;
     wait?: boolean;
     run?: string;
     pollInterval?: string;
     timeout?: string;
+    case?: string;
+    universe?: DesignVerifierUniverseRole;
+    replay?: boolean;
+    execJson?: string;
+    cwd?: string;
+    commandTimeout?: string;
+    action?: string;
 }
 export declare function designVerifyCommand(identifier: string, options: DesignVerifyOptions): Promise<void>;

package/dist/commands/design-verify.js

@@ -6,9 +6,9 @@
  *
  * Unlike `haystack review` (finding-oriented analysis of the diff), design
  * verification executes the change: it infers intent from the diff alone,
- * designs pre-registered behavioral test cases, runs them against both sides
- * of the PR in isolated sandboxes, and produces a mechanical verdict of
- * unexpected behavior changes.
+ * designs pre-registered behavioral test cases, runs control-before, before,
+ * and after in isolated sandboxes, and reports evidence-backed anomaly
+ * candidates outside the registered intent.
  *
  * The command waits by default and returns an agent-facing behavioral result.
  * --no-wait preserves the asynchronous trigger-only path.
@@ -16,7 +16,7 @@
 import chalk from 'chalk';
 import { loadToken } from '../utils/auth.js';
 import { parsePrRef } from '../utils/pr-ref.js';
-import { triggerDesignVerifier, waitForDesignVerifier } from '../utils/design-verifier-api.js';
+import { getDesignVerifierUniverseAction, startDesignVerifierUniverseAction, triggerDesignVerifier, waitForDesignVerifier, waitForDesignVerifierUniverseAction, } from '../utils/design-verifier-api.js';
 import { buildDesignVerifierAgentReport, designVerifierStageLabel, formatDesignVerifierAgentReport, } from '../utils/design-verifier-result.js';
 function emit(json, payload, human) {
     if (json) {
@@ -26,6 +26,138 @@ function emit(json, payload, human) {
         human();
     }
 }
+function parseExecArgv(source) {
+    let value;
+    try {
+        value = JSON.parse(source);
+    }
+    catch (error) {
+        throw new Error(`--exec-json is not valid JSON: ${error.message}`);
+    }
+    if (!Array.isArray(value) || value.length === 0 ||
+        value.some(argument => typeof argument !== 'string')) {
+        throw new Error('--exec-json must be a non-empty JSON array of string arguments');
+    }
+    return value;
+}
+function terminalSafe(value) {
+    // Preserve ordinary whitespace while removing C0/C1 controls, including
+    // ESC/OSC introducers. JSON output retains the server-returned strings.
+    let safe = '';
+    for (const character of value) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        const ordinaryWhitespace = codePoint === 9 || codePoint === 10 || codePoint === 13;
+        if ((codePoint < 32 && !ordinaryWhitespace) ||
+            (codePoint >= 127 && codePoint <= 159))
+            continue;
+        safe += character;
+    }
+    return safe;
+}
+function printUniverseAction(action) {
+    const result = action.result;
+    if (action.status === 'queued' || action.status === 'running') {
+        console.log(chalk.dim(`${action.caseId}/${action.universe} ${action.action} is ${action.status}; action ${action.actionId}`));
+        return;
+    }
+    if (action.status === 'failed') {
+        console.error(chalk.red(`Universe ${action.action} failed: ${action.error || 'unknown error'}`));
+        return;
+    }
+    if (!result) {
+        console.error(chalk.red(`Universe ${action.action} completed without a result.`));
+        return;
+    }
+    console.log(chalk.dim(`${action.caseId}/${action.universe} ${action.action} (${result.durationMs}ms, exit ${result.exitCode ?? 'unknown'})`));
+    if (result.stdout) {
+        const stdout = terminalSafe(result.stdout);
+        process.stdout.write(stdout.endsWith('\n') ? stdout : `${stdout}\n`);
+    }
+    if (result.stderr) {
+        const stderr = terminalSafe(result.stderr);
+        process.stderr.write(stderr.endsWith('\n') ? stderr : `${stderr}\n`);
+    }
+    if (result.stdoutOmittedBytes || result.stderrOmittedBytes) {
+        console.error(chalk.dim(`Output truncated: ${result.stdoutOmittedBytes} stdout bytes, ${result.stderrOmittedBytes} stderr bytes omitted.`));
+    }
+}
+async function runUniverseOperation(pr, prLabel, options, token, pollIntervalSeconds, timeoutSeconds) {
+    const requested = Boolean(options.action || options.case || options.universe ||
+        options.replay || options.execJson || options.cwd || options.commandTimeout);
+    if (!requested)
+        return false;
+    if (!options.run)
+        throw new Error('universe exploration requires --run <run-id>');
+    let actionId = options.action;
+    if (actionId) {
+        if (options.case || options.universe || options.replay || options.execJson ||
+            options.cwd || options.commandTimeout) {
+            throw new Error('--action cannot be combined with a new universe command');
+        }
+        if (options.wait === false) {
+            const loaded = await getDesignVerifierUniverseAction(pr.owner, pr.repo, pr.prNumber, options.run, actionId, token);
+            if (loaded.status !== 'ok')
+                throw new Error(loaded.message);
+            emit(options.json, { ok: true, pr: prLabel, ...loaded.action }, () => printUniverseAction(loaded.action));
+            return true;
+        }
+    }
+    else {
+        if (!options.case || !/^case-\d{5}$/.test(options.case)) {
+            throw new Error('a canonical --case case-00000 is required');
+        }
+        if (!options.universe || !['control-before', 'before', 'after'].includes(options.universe)) {
+            throw new Error('--universe must be control-before, before, or after');
+        }
+        if (Boolean(options.replay) === Boolean(options.execJson)) {
+            throw new Error('choose exactly one of --replay or --exec-json');
+        }
+        if (options.replay && (options.cwd || options.commandTimeout)) {
+            throw new Error('--cwd and --command-timeout apply only to --exec-json');
+        }
+        const commandTimeoutMs = options.commandTimeout === undefined
+            ? undefined
+            : Number(options.commandTimeout) * 1000;
+        if (commandTimeoutMs !== undefined &&
+            !(Number.isInteger(commandTimeoutMs) && commandTimeoutMs >= 1_000 && commandTimeoutMs <= 300_000)) {
+            throw new Error('--command-timeout must be between 1 and 300 seconds');
+        }
+        const started = await startDesignVerifierUniverseAction(pr.owner, pr.repo, pr.prNumber, options.run, token, {
+            caseId: options.case,
+            universe: options.universe,
+            action: options.replay ? 'replay' : 'exec',
+            ...(options.execJson ? { argv: parseExecArgv(options.execJson) } : {}),
+            ...(options.cwd ? { cwd: options.cwd } : {}),
+            ...(commandTimeoutMs === undefined ? {} : { timeoutMs: commandTimeoutMs }),
+        });
+        if (started.status !== 'ok')
+            throw new Error(started.message);
+        actionId = started.action.actionId;
+        if (options.wait === false) {
+            emit(options.json, { ok: true, pr: prLabel, ...started.action }, () => {
+                console.log(chalk.green('✓ Universe action queued'));
+                console.log(chalk.dim(`  Action: ${actionId}`));
+                console.log(chalk.dim(`  Resume: haystack design-verify ${prLabel} --run ${options.run} --action ${actionId}`));
+            });
+            return true;
+        }
+    }
+    const waited = await waitForDesignVerifierUniverseAction(pr.owner, pr.repo, pr.prNumber, options.run, actionId, token, { intervalMs: pollIntervalSeconds * 1000, timeoutMs: timeoutSeconds * 1000 });
+    if (waited.status === 'timeout') {
+        throw new Error(`Timed out waiting; resume with: haystack design-verify ${prLabel} --run ${options.run} --action ${actionId}`);
+    }
+    if (waited.status === 'error')
+        throw new Error(waited.message);
+    emit(options.json, {
+        ok: waited.action.status === 'completed' && waited.action.result?.exitCode === 0,
+        pr: prLabel,
+        ...waited.action,
+    }, () => printUniverseAction(waited.action));
+    process.exitCode = waited.action.status === 'failed'
+        ? 2
+        : waited.action.result?.exitCode === 0 ? 0 : 1;
+    return true;
+}
 export async function designVerifyCommand(identifier, options) {
     let pr;
     try {
@@ -73,6 +205,17 @@ export async function designVerifyCommand(identifier, options) {
         process.exitCode = 2;
         return;
     }
+    try {
+        if (await runUniverseOperation(pr, prLabel, options, token, pollIntervalSeconds, timeoutSeconds))
+            return;
+    }
+    catch (error) {
+        emit(options.json, { ok: false, pr: prLabel, error: error.message }, () => {
+            console.error(chalk.red(error.message));
+        });
+        process.exitCode = 2;
+        return;
+    }
     if (!options.json) {
         console.log(chalk.dim(options.run
             ? `\nResuming design verification ${options.run}...`

package/dist/commands/hooks.d.ts

@@ -2,16 +2,12 @@
  * haystack hooks - Install and manage git hooks for AI agent quality checks
  *
  * Installs:
- *   - Entire CLI binary (session tracking, powered by https://entire.dev)
  *   - Pre-commit hook (agent detection, truncation checking, LLM rules review)
- *   - Git hooks for session logging (commit-msg, post-commit, pre-push, prepare-commit-msg)
+ *   - Git hooks for Haystack quality checks and workflow guidance
  */
 interface HooksInstallOptions {
-    version?: string;
     force?: boolean;
-    skipEntire?: boolean;
 }
 export declare function hooksInstall(options: HooksInstallOptions): Promise<void>;
 export declare function hooksStatus(): Promise<void>;
-export declare function hooksUpdate(): Promise<void>;
 export {};