@haystackeditor/cli 0.15.27 → 0.15.29

package/dist/utils/design-verifier-api.d.ts

@@ -52,6 +52,48 @@ export interface DesignVerifierExecutionSummary {
     traceArtifact: string;
     outputArtifact: string;
 }
+export type DesignVerifierUniverseRole = 'control-before' | 'before' | 'after';
+export interface DesignVerifierUniverseSummary {
+    version: 'dv-case-universe-summary-v1';
+    universeId: string;
+    caseRunId: string;
+    caseId: string;
+    role: DesignVerifierUniverseRole;
+    revision: string;
+    capabilities: Array<'inspect' | 'query' | 'replay' | 'exec'>;
+    lease: {
+        state: 'leased' | 'released';
+        expiresAt: string | null;
+        available: boolean;
+    };
+}
+export interface DesignVerifierUniverseAction {
+    version: 'dv-universe-action-v1';
+    actionId: string;
+    runId: string;
+    caseId: string;
+    universe: DesignVerifierUniverseRole;
+    universeId: string;
+    action: 'replay' | 'exec';
+    command: {
+        cwd: string;
+        argv: string[];
+        timeoutMs: number;
+    };
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    result: {
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        stdoutOmittedBytes: number;
+        stderrOmittedBytes: number;
+        durationMs: number;
+    } | null;
+    error: string | null;
+}
 export interface DesignVerifierStageTiming {
     stage: 'prepare' | 'bake' | 'blast-radius' | 'prefetch' | 'case-design' | 'verdict';
     status: string;
@@ -88,6 +130,7 @@ export interface DesignVerifierStatusResult {
         cases: Array<Record<string, any>>;
         scenarios: Array<Record<string, any> & {
             executions?: DesignVerifierExecutionSummary[];
+            universes?: DesignVerifierUniverseSummary[];
         }>;
         changedFiles: string[];
         timings?: DesignVerifierTimingSummary;
@@ -111,6 +154,34 @@ export type DesignVerifierStatusFetchResult = {
     status: 'not_found' | 'denied' | 'unavailable' | 'error';
     message: string;
 };
+export type DesignVerifierUniverseActionFetchResult = {
+    status: 'ok';
+    action: DesignVerifierUniverseAction;
+} | {
+    status: 'not_found' | 'denied' | 'unavailable' | 'error';
+    message: string;
+};
+export declare function startDesignVerifierUniverseAction(owner: string, repo: string, prNumber: number, runId: string, token: string, request: {
+    caseId: string;
+    universe: DesignVerifierUniverseRole;
+    action: 'replay' | 'exec';
+    argv?: string[];
+    cwd?: string;
+    timeoutMs?: number;
+}): Promise<DesignVerifierUniverseActionFetchResult>;
+export declare function getDesignVerifierUniverseAction(owner: string, repo: string, prNumber: number, runId: string, actionId: string, token: string): Promise<DesignVerifierUniverseActionFetchResult>;
+export declare function waitForDesignVerifierUniverseAction(owner: string, repo: string, prNumber: number, runId: string, actionId: string, token: string, options?: {
+    intervalMs?: number;
+    timeoutMs?: number;
+}): Promise<{
+    status: 'terminal';
+    action: DesignVerifierUniverseAction;
+} | {
+    status: 'timeout';
+} | {
+    status: 'error';
+    message: string;
+}>;
 export declare function triggerDesignVerifier(owner: string, repo: string, prNumber: number, token: string): Promise<DesignVerifierTriggerResult>;
 export declare function getDesignVerifierStatus(owner: string, repo: string, prNumber: number, runId: string, token: string): Promise<DesignVerifierStatusFetchResult>;
 export declare function waitForDesignVerifier(owner: string, repo: string, prNumber: number, runId: string, token: string, options?: {

package/dist/utils/design-verifier-api.js

@@ -54,6 +54,102 @@ function apiHeaders(token) {
         Authorization: `Bearer ${token}`,
     };
 }
+function isUniverseAction(value, expected) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const action = value;
+    return action.version === 'dv-universe-action-v1' && action.runId === expected.runId &&
+        (expected.actionId === undefined || action.actionId === expected.actionId) &&
+        (expected.caseId === undefined || action.caseId === expected.caseId) &&
+        (expected.universe === undefined || action.universe === expected.universe) &&
+        /^action-[0-9a-f-]{36}$/.test(action.actionId || '') &&
+        /^universe-[0-9a-f]{24}$/.test(action.universeId || '') &&
+        ['control-before', 'before', 'after'].includes(action.universe) &&
+        ['replay', 'exec'].includes(action.action) &&
+        ['queued', 'running', 'completed', 'failed'].includes(action.status) &&
+        action.command && Array.isArray(action.command.argv) && typeof action.command.cwd === 'string';
+}
+function universeActionPath(owner, repo, prNumber, runId) {
+    return `/api/design-verifier/universe/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${prNumber}/${encodeURIComponent(runId)}`;
+}
+async function parseUniverseActionResponse(response, expected) {
+    let data = {};
+    try {
+        data = await response.json();
+    }
+    catch {
+        return { status: 'error', message: `Universe endpoint returned invalid JSON (HTTP ${response.status})` };
+    }
+    if (response.ok) {
+        if (!isUniverseAction(data, expected)) {
+            return { status: 'error', message: `Universe endpoint returned an invalid or mismatched result (HTTP ${response.status})` };
+        }
+        return { status: 'ok', action: data };
+    }
+    const message = data.message || data.error || `HTTP ${response.status}`;
+    if (response.status === 401 || response.status === 403)
+        return { status: 'denied', message };
+    if (response.status === 404 || response.status === 410)
+        return { status: 'not_found', message };
+    if (response.status === 502 || response.status === 503)
+        return { status: 'unavailable', message };
+    return { status: 'error', message };
+}
+export async function startDesignVerifierUniverseAction(owner, repo, prNumber, runId, token, request) {
+    let response;
+    try {
+        response = await fetch(haystackApiUrl(universeActionPath(owner, repo, prNumber, runId)), {
+            method: 'POST',
+            headers: { ...apiHeaders(token), 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+        });
+    }
+    catch (err) {
+        return { status: 'error', message: err.message };
+    }
+    return parseUniverseActionResponse(response, {
+        runId,
+        caseId: request.caseId,
+        universe: request.universe,
+    });
+}
+export async function getDesignVerifierUniverseAction(owner, repo, prNumber, runId, actionId, token) {
+    const path = universeActionPath(owner, repo, prNumber, runId);
+    let response;
+    try {
+        response = await fetch(haystackApiUrl(`${path}?actionId=${encodeURIComponent(actionId)}`), {
+            method: 'GET',
+            headers: apiHeaders(token),
+        });
+    }
+    catch (err) {
+        return { status: 'error', message: err.message };
+    }
+    return parseUniverseActionResponse(response, { runId, actionId });
+}
+export async function waitForDesignVerifierUniverseAction(owner, repo, prNumber, runId, actionId, token, options = {}) {
+    const intervalMs = options.intervalMs ?? 1_000;
+    const deadline = Date.now() + (options.timeoutMs ?? 10 * 60_000);
+    let consecutiveErrors = 0;
+    for (;;) {
+        const loaded = await getDesignVerifierUniverseAction(owner, repo, prNumber, runId, actionId, token);
+        if (loaded.status === 'ok') {
+            consecutiveErrors = 0;
+            if (['completed', 'failed'].includes(loaded.action.status)) {
+                return { status: 'terminal', action: loaded.action };
+            }
+        }
+        else {
+            consecutiveErrors += 1;
+            if (loaded.status === 'denied' || loaded.status === 'not_found' || consecutiveErrors >= 3) {
+                return { status: 'error', message: loaded.message };
+            }
+        }
+        if (Date.now() >= deadline)
+            return { status: 'timeout' };
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
 export async function triggerDesignVerifier(owner, repo, prNumber, token) {
     const url = haystackApiUrl(`/api/design-verifier/trigger/${owner}/${repo}/${prNumber}`);
     let response;

package/dist/utils/design-verifier-result.d.ts

@@ -1,5 +1,5 @@
-import type { DesignVerifierCommandSpec, DesignVerifierExecutionSummary, DesignVerifierStatusResult, DesignVerifierTimingSummary } from './design-verifier-api.js';
-export type DesignVerifierAgentVerdict = 'fix_confirmed' | 'fix_needed' | 'no_unexpected_change' | 'inconclusive';
+import type { DesignVerifierCommandSpec, DesignVerifierExecutionSummary, DesignVerifierStatusResult, DesignVerifierTimingSummary, DesignVerifierUniverseSummary } from './design-verifier-api.js';
+export type DesignVerifierAgentVerdict = 'fix_confirmed' | 'anomaly_candidate' | 'no_unexpected_change' | 'inconclusive';
 export interface DesignVerifierAgentCase {
     id: string;
     title: string;
@@ -7,16 +7,21 @@ export interface DesignVerifierAgentCase {
     expectedHead: string;
     verdict: 'confirmed' | 'finding' | 'clean' | 'inconclusive';
     findingKind: string | null;
+    findingKinds: string[];
     baseStable: boolean | null;
     observations: Array<{
         path: string;
         base: unknown;
         baseRepeat: unknown;
         head: unknown;
+        controlObservedAtSamePath: boolean;
+        controlObservedAtAncestorPath: boolean;
+        controlObservedAtDescendantPath: boolean;
     }>;
     generatedFiles: string[];
     executedCommand: DesignVerifierCommandSpec | null;
     executions: DesignVerifierExecutionSummary[];
+    universes: DesignVerifierUniverseSummary[];
     infrastructure: {
         verified: boolean;
         recipeId: string | null;

package/dist/utils/design-verifier-result.js

@@ -1,12 +1,15 @@
 import { isDeepStrictEqual } from 'node:util';
 function findingExplanation(kind) {
     if (kind === 'declared-change-not-observed') {
-        return 'The intended behavior change was not observed on the proposed revision.';
+        return 'The registered intended behavior change was not observed; investigate the captured outputs before concluding why.';
     }
     if (kind === 'unexpected-change') {
-        return 'The proposed revision changed behavior that was registered to remain stable.';
+        return 'The proposed revision produced a difference outside this case’s registered intent; this is an anomaly candidate for investigation.';
     }
-    return 'Executed behavior contradicted the registered expectation.';
+    if (kind === 'intended-change-control-confounded') {
+        return 'The intended difference was observed, but control-before also varied on an intersecting output path; inspect it before claiming causality.';
+    }
+    return 'Executed behavior produced a suspicious difference against the registered expectation.';
 }
 function sameRecordedValue(left, right) {
     return isDeepStrictEqual(left, right);
@@ -19,6 +22,14 @@ function executionSummaries(value) {
         ['completed', 'failed', 'missing'].includes(execution.status) &&
         Array.isArray(execution.diagnostics) && Array.isArray(execution.outputExcerpt));
 }
+function universeSummaries(value, caseId) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((universe) => universe?.version === 'dv-case-universe-summary-v1' && universe.caseId === caseId &&
+        /^universe-[0-9a-f]{24}$/.test(universe.universeId || '') &&
+        ['control-before', 'before', 'after'].includes(universe.role) &&
+        universe.lease && typeof universe.lease.available === 'boolean');
+}
 export function buildDesignVerifierAgentReport(run) {
     const repository = `${run.owner}/${run.repo}`;
     if (run.status !== 'succeeded' || !run.result) {
@@ -46,13 +57,19 @@ export function buildDesignVerifierAgentReport(run) {
     const summary = verdict.summary || {};
     const findings = Array.isArray(verdict.findings) ? verdict.findings : [];
     const confirmations = Array.isArray(verdict.confirmations) ? verdict.confirmations : [];
-    const findingByCase = new Map(findings.map((finding) => [finding.caseId, finding]));
+    const findingsByCase = new Map();
+    for (const finding of findings) {
+        const caseFindings = findingsByCase.get(String(finding?.caseId || '')) || [];
+        caseFindings.push(finding);
+        findingsByCase.set(String(finding?.caseId || ''), caseFindings);
+    }
     const confirmedIds = new Set(confirmations.map((confirmation) => confirmation.caseId));
     const scenarioByCase = new Map(run.result.scenarios.map((scenario) => [scenario.caseId, scenario]));
     const probeByCase = new Map(run.result.probes.map((probe) => [probe.caseId, probe]));
     const cases = run.result.cases.map((testCase) => {
         const id = String(testCase.id || '');
-        const finding = findingByCase.get(id);
+        const caseFindings = findingsByCase.get(id) || [];
+        const finding = caseFindings[0];
         const scenario = scenarioByCase.get(id);
         const probe = probeByCase.get(id);
         const observations = (Array.isArray(scenario?.divergences) ? scenario.divergences : []).map((item) => ({
@@ -60,13 +77,18 @@ export function buildDesignVerifierAgentReport(run) {
             base: item.base,
             baseRepeat: item.base2,
             head: item.head,
+            controlObservedAtSamePath: item.controlObservedAtSamePath === true,
+            controlObservedAtAncestorPath: item.controlObservedAtAncestorPath === true,
+            controlObservedAtDescendantPath: item.controlObservedAtDescendantPath === true,
         }));
+        const hasControlEvidence = typeof scenario?.noisePathCount === 'number' ||
+            scenario?.controlScenarioErrorVariation != null;
         return {
             id,
             title: String(testCase.title || scenario?.scenario || id),
             story: String(testCase.story || ''),
             expectedHead: String(testCase.expected_head_observation || ''),
-            verdict: finding
+            verdict: caseFindings.length
                 ? 'finding'
                 : confirmedIds.has(id)
                     ? 'confirmed'
@@ -74,13 +96,19 @@ export function buildDesignVerifierAgentReport(run) {
                         ? 'clean'
                         : 'inconclusive',
             findingKind: finding?.kind || null,
-            baseStable: observations.length
-                ? observations.every((item) => sameRecordedValue(item.base, item.baseRepeat))
-                : scenario?.status === 'clean' ? true : null,
+            findingKinds: caseFindings
+                .map((item) => String(item?.kind || ''))
+                .filter(Boolean),
+            baseStable: hasControlEvidence
+                ? scenario.noisePathCount === 0 && scenario.controlScenarioErrorVariation == null
+                : observations.length
+                    ? observations.every((item) => sameRecordedValue(item.base, item.baseRepeat))
+                    : scenario?.status === 'clean' ? true : null,
             observations,
             generatedFiles: probe?.files || [],
             executedCommand: probe?.run || null,
             executions: executionSummaries(scenario?.executions),
+            universes: universeSummaries(scenario?.universes, id),
             infrastructure: scenario?.infrastructureReceipt &&
                 typeof scenario.infrastructureReceipt === 'object'
                 ? {
@@ -106,8 +134,8 @@ export function buildDesignVerifierAgentReport(run) {
     let explanation;
     let exitCode;
     if (findings.length > 0) {
-        agentVerdict = 'fix_needed';
-        headline = 'FIX NEEDED';
+        agentVerdict = 'anomaly_candidate';
+        headline = 'ANOMALY CANDIDATE';
         explanation = findingExplanation(String(findings[0]?.kind || ''));
         exitCode = 1;
     }
@@ -120,13 +148,13 @@ export function buildDesignVerifierAgentReport(run) {
     else if (confirmations.length > 0) {
         agentVerdict = 'fix_confirmed';
         headline = 'FIX CONFIRMED';
-        explanation = 'The intended behavior change was observed on head and reproduced across two stable base runs.';
+        explanation = 'The intended behavior change was observed on output paths that did not vary between control-before and before.';
         exitCode = 0;
     }
     else {
         agentVerdict = 'no_unexpected_change';
         headline = 'NO UNEXPECTED CHANGE';
-        explanation = 'Executed cases found no behavior change outside the registered expectations.';
+        explanation = 'The executed cases found no observed difference outside their registered expectations.';
         exitCode = 0;
     }
     return {
@@ -184,10 +212,10 @@ function commandLabel(command) {
 }
 function executionSideLabel(side) {
     if (side === 'base1')
-        return 'base';
+        return 'before';
     if (side === 'base2')
-        return 'base repeat';
-    return 'head';
+        return 'control-before';
+    return 'after';
 }
 function executionNeedsAttention(execution) {
     return execution.status !== 'completed' || execution.diagnostics.length > 0;
@@ -200,7 +228,7 @@ export function formatDesignVerifierAgentReport(report) {
         report.explanation,
     ];
     if (report.revisions.base || report.revisions.head) {
-        lines.push('', `Revisions: base ${report.revisions.base || 'unknown'} (executed twice)`, `           head ${report.revisions.head || 'unknown'} (executed once)`);
+        lines.push('', `Revisions: before ${report.revisions.base || 'unknown'} (control + comparison)`, `           after  ${report.revisions.head || 'unknown'} (comparison)`);
     }
     if (report.timings) {
         lines.push('', 'Timing breakdown:');
@@ -221,16 +249,30 @@ export function formatDesignVerifierAgentReport(report) {
             lines.push(`  Behavior: ${testCase.story}`);
         if (testCase.expectedHead)
             lines.push(`  Expected on head: ${testCase.expectedHead}`);
+        if (testCase.findingKinds.length > 0) {
+            lines.push(`  Candidate reasons: ${testCase.findingKinds.join(', ')}`);
+        }
         if (testCase.observations.length) {
             lines.push('  Observed:');
             for (const observation of testCase.observations) {
                 lines.push(`    ${observation.path}`);
-                lines.push(`      base: ${displayValue(observation.base)} (repeat: ${displayValue(observation.baseRepeat)})`);
-                lines.push(`      head: ${displayValue(observation.head)}`);
+                lines.push(`      control-before: ${displayValue(observation.baseRepeat)}`);
+                lines.push(`      before: ${displayValue(observation.base)}`);
+                lines.push(`      after: ${displayValue(observation.head)}`);
+                if (observation.controlObservedAtSamePath || observation.controlObservedAtAncestorPath ||
+                    observation.controlObservedAtDescendantPath) {
+                    lines.push(`      control evidence: ${observation.controlObservedAtSamePath
+                        ? 'variation observed at this same path'
+                        : observation.controlObservedAtAncestorPath
+                            ? 'variation observed at an ancestor path'
+                            : 'variation observed at a descendant path'}`);
+                }
             }
         }
         if (testCase.baseStable !== null) {
-            lines.push(`  Base stability: ${testCase.baseStable ? 'passed; both runs agreed' : 'failed; base runs disagreed'}`);
+            lines.push(`  Control evidence: ${testCase.baseStable
+                ? 'control-before and before agreed'
+                : 'control-before and before varied; inspect alongside the difference'}`);
         }
         if (testCase.infrastructure) {
             lines.push(testCase.infrastructure.verified
@@ -271,6 +313,10 @@ export function formatDesignVerifierAgentReport(report) {
         const command = commandLabel(testCase.executedCommand);
         if (command)
             lines.push(`  Executed in the sandbox: ${command}`);
+        for (const universe of testCase.universes.filter(item => item.lease.available)) {
+            lines.push(`  Replay ${universe.role}: haystack design-verify ${report.repository}#${report.pullRequest}` +
+                ` --run ${report.runId} --case ${testCase.id} --universe ${universe.role} --replay`);
+        }
     }
     if (report.changedFiles.length) {
         lines.push('', 'Changed files to inspect:', ...report.changedFiles.map((file) => `  ${file}`));
@@ -292,7 +338,7 @@ export function designVerifierStageLabel(stage) {
     if (stage.startsWith('build:'))
         return 'Building an executable probe';
     if (stage.startsWith('execute:'))
-        return 'Running base/base/head comparisons';
+        return 'Running control-before/before/after comparisons';
     if (stage === 'verdict')
         return 'Comparing observations';
     return stage;

package/dist/utils/git.d.ts

@@ -93,6 +93,10 @@ export declare function getLastCommitSha(): string;
  * Returns the combined log, or empty string if no commits or on error.
  */
 export declare function getCommitMessagesSinceBase(baseBranch: string): string;
+interface ResolveDiffBaseRefOptions {
+    cwd?: string;
+    timeoutMs?: number;
+}
 /**
  * Resolve the git ref to diff a PR branch against for review.
  *
@@ -124,7 +128,7 @@ export declare function getCommitMessagesSinceBase(baseBranch: string): string;
  *   4. Fall back to whatever single qualified ref resolves, then the bare
  *      <base> name (preserves prior behavior rather than breaking triage).
  */
-export declare function resolveDiffBaseRef(baseBranch: string): string;
+export declare function resolveDiffBaseRef(baseBranch: string, options?: ResolveDiffBaseRefOptions): string;
 /**
  * Get the number of commits ahead of base branch
  */

package/dist/utils/git.js

@@ -376,11 +376,18 @@ export function getCommitMessagesSinceBase(baseBranch) {
         }
     }
 }
+function gitCommandOptions(options) {
+    return {
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        ...(options.timeoutMs ? { timeout: options.timeoutMs } : {}),
+        stdio: ['pipe', 'pipe', 'pipe'],
+    };
+}
 /** True if `ref` resolves to a commit in the current repo. */
-function gitRefResolves(ref) {
+function gitRefResolves(ref, options = {}) {
     try {
         execFileSync('git', ['rev-parse', '--verify', '--quiet', '--', `${ref}^{commit}`], {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            ...gitCommandOptions(options),
         });
         return true;
     }
@@ -389,11 +396,11 @@ function gitRefResolves(ref) {
     }
 }
 /** True if `ancestor` is an ancestor of (or equal to) `descendant`. */
-function gitIsAncestor(ancestor, descendant) {
+function gitIsAncestor(ancestor, descendant, options = {}) {
     try {
         // exit 0 => ancestor; exit 1 => not; both non-throwing for us via stdio pipe
         execFileSync('git', ['merge-base', '--is-ancestor', '--', ancestor, descendant], {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            ...gitCommandOptions(options),
         });
         return true;
     }
@@ -432,7 +439,7 @@ function gitIsAncestor(ancestor, descendant) {
  *   4. Fall back to whatever single qualified ref resolves, then the bare
  *      <base> name (preserves prior behavior rather than breaking triage).
  */
-export function resolveDiffBaseRef(baseBranch) {
+export function resolveDiffBaseRef(baseBranch, options = {}) {
     const remoteRef = `refs/remotes/origin/${baseBranch}`;
     const localRef = `refs/heads/${baseBranch}`;
     // Freshen the remote base so the merge-base reflects the true fork point.
@@ -451,7 +458,10 @@ export function resolveDiffBaseRef(baseBranch) {
     let fetched = false;
     try {
         execFileSync('git', ['fetch', 'origin', `+refs/heads/${baseBranch}:${remoteRef}`], {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            ...gitCommandOptions(options),
+            env: options.timeoutMs
+                ? { ...process.env, GIT_TERMINAL_PROMPT: '0' }
+                : process.env,
         });
         fetched = true;
     }
@@ -459,17 +469,17 @@ export function resolveDiffBaseRef(baseBranch) {
         // Offline / no creds / base not on remote — fall through to degraded
         // selection below using whatever refs already exist locally.
     }
-    const remoteResolves = gitRefResolves(remoteRef);
+    const remoteResolves = gitRefResolves(remoteRef, options);
     // Happy path: we just refreshed the remote base, so it's authoritative.
     if (fetched && remoteResolves)
         return remoteRef;
     // Degraded path: fetch failed (or didn't produce the ref). Prefer the more
     // up-to-date of the cached remote ref and the local branch; only a base that
     // lags HEAD's fork point balloons the diff, so pick the one that's ahead.
-    const localResolves = gitRefResolves(localRef);
+    const localResolves = gitRefResolves(localRef, options);
     if (remoteResolves && localResolves) {
         // If the remote ref is an ancestor of the local ref, local is ahead → use it.
-        return gitIsAncestor(remoteRef, localRef) ? localRef : remoteRef;
+        return gitIsAncestor(remoteRef, localRef, options) ? localRef : remoteRef;
     }
     if (remoteResolves)
         return remoteRef;

package/dist/utils/github-api.js

@@ -86,10 +86,7 @@ async function githubApiRequest(method, path, token, body) {
     const proxied = await fetch(`${GITHUB_PROXY_BASE}${path}`, init);
     return proxied.status === 403 ? direct : proxied;
 }
-/**
- * Handle API errors consistently
- */
-async function handleApiError(response, context) {
+async function handleApiError(response, context, operation) {
     if (response.status === 401) {
         throw new Error('GitHub token expired or invalid. Run `haystack login` again.');
     }
@@ -100,7 +97,7 @@ async function handleApiError(response, context) {
             // whether the CLI needs its own token bucket. Routes to PostHog (and on to
             // Slack via the ops-alert pipeline). Fire-and-forget; never blocks.
             trackError('cli_github_rate_limited', {
-                context,
+                operation,
                 status: 403,
                 rate_limit_limit: response.headers.get('x-ratelimit-limit'),
                 rate_limit_reset: response.headers.get('x-ratelimit-reset'),
@@ -149,7 +146,7 @@ export async function createPullRequest(options) {
                     `Push to a new branch name and try again.`);
             }
         }
-        await handleApiError(response, `creating PR in ${options.owner}/${options.repo}`);
+        await handleApiError(response, `creating PR in ${options.owner}/${options.repo}`, 'create_pull_request');
     }
     return response.json();
 }
@@ -190,7 +187,7 @@ export async function findExistingPR(owner, repo, head, token) {
     if (!response.ok) {
         if (response.status === 404)
             return null;
-        await handleApiError(response, `checking for existing PR`);
+        await handleApiError(response, 'checking for existing PR', 'find_existing_pull_request');
     }
     const prs = await response.json();
     return prs.length > 0 ? prs[0] : null;
@@ -205,7 +202,7 @@ export async function addLabelsToIssue(owner, repo, issueNumber, labels, token)
     const authToken = await resolveToken(token, { owner, repo });
     const response = await githubApiRequest('POST', `/repos/${owner}/${repo}/issues/${issueNumber}/labels`, authToken, { labels });
     if (!response.ok) {
-        await handleApiError(response, `adding labels to PR #${issueNumber}`);
+        await handleApiError(response, `adding labels to PR #${issueNumber}`, 'add_labels');
     }
 }
 /**
@@ -215,7 +212,7 @@ export async function getLabelsFromIssue(owner, repo, issueNumber, token) {
     const authToken = await resolveToken(token, { owner, repo });
     const response = await githubApiRequest('GET', `/repos/${owner}/${repo}/issues/${issueNumber}/labels`, authToken);
     if (!response.ok) {
-        await handleApiError(response, `getting labels from PR #${issueNumber}`);
+        await handleApiError(response, `getting labels from PR #${issueNumber}`, 'get_labels');
     }
     const labels = await response.json();
     return labels.map((l) => l.name);
@@ -228,7 +225,7 @@ export async function removeLabelFromIssue(owner, repo, issueNumber, labelName,
     const response = await githubApiRequest('DELETE', `/repos/${owner}/${repo}/issues/${issueNumber}/labels/${encodeURIComponent(labelName)}`, authToken);
     // 404 is fine - label wasn't on the issue
     if (!response.ok && response.status !== 404) {
-        await handleApiError(response, `removing label '${labelName}' from PR #${issueNumber}`);
+        await handleApiError(response, `removing label '${labelName}' from PR #${issueNumber}`, 'remove_label');
     }
 }
 /**
@@ -251,7 +248,7 @@ export async function createLabel(owner, repo, label, token) {
     });
     if (!response.ok && response.status !== 422) {
         // 422 means label already exists, which is fine
-        await handleApiError(response, `creating label '${label.name}'`);
+        await handleApiError(response, `creating label '${label.name}'`, 'create_label');
     }
 }
 /**
@@ -278,7 +275,7 @@ export async function requestReviewers(owner, repo, prNumber, reviewers, token)
     const authToken = await resolveToken(token, { owner, repo });
     const response = await githubApiRequest('POST', `/repos/${owner}/${repo}/pulls/${prNumber}/requested_reviewers`, authToken, { reviewers });
     if (!response.ok) {
-        await handleApiError(response, `requesting reviewers on PR #${prNumber}`);
+        await handleApiError(response, `requesting reviewers on PR #${prNumber}`, 'request_reviewers');
     }
 }
 // ============================================================================
@@ -291,7 +288,7 @@ export async function getCurrentUser(token) {
     const authToken = await resolveToken(token);
     const response = await githubApiRequest('GET', '/user', authToken);
     if (!response.ok) {
-        await handleApiError(response, 'getting current user');
+        await handleApiError(response, 'getting current user', 'get_current_user');
     }
     return response.json();
 }
@@ -299,7 +296,7 @@ export async function getRepositoryAccess(owner, repo, token) {
     const authToken = await resolveToken(token, { owner, repo });
     const response = await githubApiRequest('GET', `/repos/${owner}/${repo}`, authToken);
     if (!response.ok) {
-        await handleApiError(response, `getting repository access for ${owner}/${repo}`);
+        await handleApiError(response, `getting repository access for ${owner}/${repo}`, 'get_repository_access');
     }
     return response.json();
 }

package/dist/utils/hooks.d.ts

@@ -1,17 +1,7 @@
 /**
- * Utilities for haystack hooks install/status/update commands.
- *
- * Handles Entire CLI binary download, hook file copying, and git configuration.
+ * Utilities for haystack hooks install/status commands.
  */
-export declare const ENTIRE_DEFAULT_VERSION = "0.4.8";
-export declare const ENTIRE_GITHUB_REPO = "entireio/cli";
-export declare const HAYSTACK_BIN_DIR: string;
-export declare const ENTIRE_BIN_PATH: string;
-export declare function getPlatformAssetName(): string;
 export declare function findGitRoot(): string | null;
-export declare function getInstalledEntireVersion(): Promise<string | null>;
-export declare function getLatestEntireVersion(): Promise<string>;
-export declare function downloadEntireBinary(version: string): Promise<void>;
 /** Resolves the path to dist/assets/hooks/ (or src/assets/hooks/ in dev) */
 export declare function getAssetsDir(): string;
 /** Copy hook scripts and TypeScript modules into the target hooks directory */
@@ -20,7 +10,3 @@ export declare function copyHookFiles(hooksDir: string): Promise<void>;
 export declare function installHookDeps(hooksDir: string): Promise<void>;
 /** Copy LLM rules template if none exists */
 export declare function copyLlmRulesTemplate(repoRoot: string): Promise<boolean>;
-/** Create .entire/settings.json and .entire/.gitignore */
-export declare function createEntireConfig(repoRoot: string): Promise<void>;
-/** Add .entire/metadata/ to repo .gitignore if not already present */
-export declare function updateGitignore(repoRoot: string): Promise<boolean>;