@haystackeditor/cli 0.15.26 → 0.15.28

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

@@ -0,0 +1,345 @@
+import { isDeepStrictEqual } from 'node:util';
+function findingExplanation(kind) {
+    if (kind === 'declared-change-not-observed') {
+        return 'The registered intended behavior change was not observed; investigate the captured outputs before concluding why.';
+    }
+    if (kind === 'unexpected-change') {
+        return 'The proposed revision produced a difference outside this case’s registered intent; this is an anomaly candidate for investigation.';
+    }
+    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);
+}
+function executionSummaries(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((execution) => !!execution && typeof execution === 'object' &&
+        ['base1', 'base2', 'head'].includes(execution.side) &&
+        ['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) {
+        return {
+            ok: false,
+            status: 'failed',
+            verdict: 'inconclusive',
+            headline: 'VERIFICATION INCONCLUSIVE',
+            explanation: run.error || 'The verifier did not produce a terminal behavioral verdict.',
+            runId: run.runId,
+            repository,
+            pullRequest: run.pr,
+            revisions: { base: run.baseSha, head: run.headSha },
+            durationMs: run.durationMs,
+            timings: null,
+            changedFiles: [],
+            cases: [],
+            inspectCommand: `haystack design-verify ${repository}#${run.pr} --run ${run.runId}`,
+            replay: null,
+            error: run.error,
+            exitCode: 2,
+        };
+    }
+    const verdict = run.result.verdict || {};
+    const summary = verdict.summary || {};
+    const findings = Array.isArray(verdict.findings) ? verdict.findings : [];
+    const confirmations = Array.isArray(verdict.confirmations) ? verdict.confirmations : [];
+    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 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) => ({
+            path: String(item.display || (Array.isArray(item.path) ? item.path.join('.') : 'observation')),
+            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: caseFindings.length
+                ? 'finding'
+                : confirmedIds.has(id)
+                    ? 'confirmed'
+                    : scenario?.status === 'clean'
+                        ? 'clean'
+                        : 'inconclusive',
+            findingKind: finding?.kind || 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'
+                ? {
+                    verified: scenario.infrastructureReceipt.status === 'passed',
+                    recipeId: typeof scenario.infrastructureReceipt.recipeId === 'string'
+                        ? scenario.infrastructureReceipt.recipeId
+                        : null,
+                    freshInstances: Array.isArray(scenario.infrastructureReceipt.environmentInstanceIds)
+                        ? scenario.infrastructureReceipt.environmentInstanceIds.length
+                        : 0,
+                    baseRepeat: typeof scenario.infrastructureReceipt.baseRepeat === 'string'
+                        ? scenario.infrastructureReceipt.baseRepeat
+                        : null,
+                    errors: Array.isArray(scenario.infrastructureReceipt.errors)
+                        ? scenario.infrastructureReceipt.errors.filter((item) => typeof item === 'string')
+                        : [],
+                }
+                : null,
+        };
+    });
+    let agentVerdict;
+    let headline;
+    let explanation;
+    let exitCode;
+    if (findings.length > 0) {
+        agentVerdict = 'anomaly_candidate';
+        headline = 'ANOMALY CANDIDATE';
+        explanation = findingExplanation(String(findings[0]?.kind || ''));
+        exitCode = 1;
+    }
+    else if (summary.caseDesignOutcome === 'no-supported-cases' || Number(summary.scenarios || 0) === 0) {
+        agentVerdict = 'inconclusive';
+        headline = 'VERIFICATION INCONCLUSIVE';
+        explanation = 'The verifier could not design and execute a supported behavioral case.';
+        exitCode = 2;
+    }
+    else if (confirmations.length > 0) {
+        agentVerdict = 'fix_confirmed';
+        headline = 'FIX CONFIRMED';
+        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 = 'The executed cases found no observed difference outside their registered expectations.';
+        exitCode = 0;
+    }
+    return {
+        ok: exitCode === 0,
+        status: 'complete',
+        verdict: agentVerdict,
+        headline,
+        explanation,
+        runId: run.runId,
+        repository,
+        pullRequest: run.pr,
+        revisions: { base: run.baseSha, head: run.headSha },
+        durationMs: run.durationMs,
+        timings: run.result.timings || null,
+        changedFiles: run.result.changedFiles,
+        cases,
+        inspectCommand: `haystack design-verify ${repository}#${run.pr} --run ${run.runId}`,
+        replay: run.result.replay,
+        error: null,
+        exitCode,
+    };
+}
+function displayValue(value) {
+    const encoded = JSON.stringify(value);
+    return encoded === undefined ? String(value) : encoded;
+}
+function durationLabel(durationMs) {
+    if (durationMs === null)
+        return '';
+    const totalSeconds = Math.round(durationMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return minutes ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+function preciseDurationLabel(durationMs) {
+    if (durationMs === null)
+        return 'not recorded';
+    if (durationMs < 1000)
+        return `${Number(durationMs.toFixed(3))}ms`;
+    const minutes = Math.floor(durationMs / 60_000);
+    const seconds = Number(((durationMs % 60_000) / 1000).toFixed(3));
+    return minutes ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+function timingStageLabel(stage) {
+    if (stage === 'blast-radius')
+        return 'blast radius';
+    if (stage === 'case-design')
+        return 'case design';
+    return stage;
+}
+function commandLabel(command) {
+    if (!command)
+        return null;
+    return command.argv.map((arg) => (/^[A-Za-z0-9_./:=+-]+$/.test(arg) ? arg : JSON.stringify(arg))).join(' ');
+}
+function executionSideLabel(side) {
+    if (side === 'base1')
+        return 'before';
+    if (side === 'base2')
+        return 'control-before';
+    return 'after';
+}
+function executionNeedsAttention(execution) {
+    return execution.status !== 'completed' || execution.diagnostics.length > 0;
+}
+export function formatDesignVerifierAgentReport(report) {
+    const timing = durationLabel(report.durationMs);
+    const lines = [
+        `${report.exitCode === 0 ? '✓' : report.exitCode === 1 ? '✗' : '?'} ${report.headline}${timing ? `  ${timing}` : ''}`,
+        '',
+        report.explanation,
+    ];
+    if (report.revisions.base || report.revisions.head) {
+        lines.push('', `Revisions: before ${report.revisions.base || 'unknown'} (control + comparison)`, `           after  ${report.revisions.head || 'unknown'} (comparison)`);
+    }
+    if (report.timings) {
+        lines.push('', 'Timing breakdown:');
+        if (report.timings.admissionMs !== null) {
+            lines.push(`  admission: ${preciseDurationLabel(report.timings.admissionMs)}`);
+        }
+        for (const stage of report.timings.stages) {
+            lines.push(`  ${timingStageLabel(stage.stage)}: ${preciseDurationLabel(stage.durationMs)} (${stage.status})`);
+        }
+        lines.push(`  pipeline total: ${preciseDurationLabel(report.timings.pipelineDurationMs)}`);
+        if (report.timings.unattributedMs !== null) {
+            lines.push(`  orchestration/finalization not recorded in a phase: ${preciseDurationLabel(report.timings.unattributedMs)}`);
+        }
+    }
+    for (const testCase of report.cases) {
+        lines.push('', `Test: ${testCase.title}`);
+        if (testCase.story)
+            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(`      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(`  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
+                ? `  Infrastructure: verified; same recipe, ${testCase.infrastructure.freshInstances} fresh instances`
+                : `  Infrastructure: unverified; ${testCase.infrastructure.errors.join('; ') || 'receipt missing'}`);
+        }
+        const executionsWithDiagnostics = testCase.executions.filter(executionNeedsAttention);
+        if (executionsWithDiagnostics.length) {
+            lines.push('  Execution diagnostics:');
+            for (const execution of executionsWithDiagnostics) {
+                const exit = execution.commandExitCode === null ? 'exit unknown' : `exit ${execution.commandExitCode}`;
+                const elapsed = execution.durationMs === null ? '' : `, ${durationLabel(execution.durationMs)}`;
+                lines.push(`    ${executionSideLabel(execution.side)} (${exit}${elapsed}):`);
+                if (execution.scenarioError)
+                    lines.push(`      Scenario error: ${execution.scenarioError}`);
+                for (const diagnostic of execution.diagnostics) {
+                    const identity = [diagnostic.type, diagnostic.code].filter(Boolean).join(', ');
+                    lines.push(`      ${diagnostic.kind}${identity ? ` (${identity})` : ''}: ${diagnostic.message}`);
+                }
+                if (execution.diagnosticsOmitted > 0) {
+                    lines.push(`      ... ${execution.diagnosticsOmitted} additional diagnostics omitted`);
+                }
+                if (execution.outputExcerpt.length) {
+                    lines.push('      Relevant command output:');
+                    for (const output of execution.outputExcerpt) {
+                        lines.push(`        ${output.stream}: ${output.text}`);
+                    }
+                    if (execution.outputLinesOmitted > 0) {
+                        lines.push(`        ... ${execution.outputLinesOmitted} output lines omitted`);
+                    }
+                }
+                lines.push(`      Full output artifact: ${execution.outputArtifact}`);
+                lines.push(`      Structured trace artifact: ${execution.traceArtifact}`);
+            }
+        }
+        if (testCase.generatedFiles.length)
+            lines.push(`  Generated probe artifact: ${testCase.generatedFiles.join(', ')}`);
+        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}`));
+    }
+    lines.push('', `Inspect this exact result again: ${report.inspectCommand}`, `Run: ${report.runId}`);
+    return lines.join('\n');
+}
+export function designVerifierStageLabel(stage) {
+    if (!stage)
+        return 'Waiting for the run to start';
+    if (stage === 'prepare' || stage === 'bake')
+        return 'Preparing the repository';
+    if (stage === 'blast-radius')
+        return 'Mapping affected behavior';
+    if (stage === 'prefetch')
+        return 'Retrieving relevant failure patterns';
+    if (stage === 'stage1')
+        return 'Designing behavioral test cases';
+    if (stage.startsWith('build:'))
+        return 'Building an executable probe';
+    if (stage.startsWith('execute:'))
+        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/haystack-api.d.ts

@@ -1,3 +1,5 @@
+export declare function haystackApiBase(): string;
+export declare function haystackApiUrl(path: string): string;
 export interface UserInstallation {
     id: number;
     account?: {

package/dist/utils/haystack-api.js

@@ -1,4 +1,11 @@
-const HAYSTACK_API_BASE = process.env.HAYSTACK_API_BASE ?? 'https://haystackeditor.com';
+export function haystackApiBase() {
+    return process.env.HAYSTACK_API_BASE ?? 'https://haystackeditor.com';
+}
+export function haystackApiUrl(path) {
+    if (!path.startsWith('/'))
+        throw new Error('Haystack API path must be absolute');
+    return `${haystackApiBase()}${path}`;
+}
 /**
  * Typed error for non-OK Haystack API responses. Callers classify by
  * `status` (never by message substring) and the message always carries a
@@ -70,7 +77,7 @@ export async function classifyHttpError(response, context) {
     return new HaystackApiError(response.status, `${context}: unexpected response (HTTP ${response.status})${suffix}.`);
 }
 export async function haystackJson(path, token, init = {}, acceptedStatuses = []) {
-    const response = await fetch(`${HAYSTACK_API_BASE}${path}`, {
+    const response = await fetch(haystackApiUrl(path), {
         ...init,
         headers: headers(token, init.headers),
     });
@@ -91,7 +98,7 @@ export async function fetchGitHubJson(path, token, init = {}) {
 }
 export async function fetchAnalysisArtifact(owner, repo, prNumber, file, token) {
     const ref = encodeURIComponent(`${owner}/${repo}#${prNumber}`);
-    const response = await fetch(`${HAYSTACK_API_BASE}/api/analysis/${ref}/${file}`, {
+    const response = await fetch(haystackApiUrl(`/api/analysis/${ref}/${file}`), {
         headers: headers(token, { 'Cache-Control': 'no-cache' }),
     });
     if (response.status === 404)

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>;