@haystackeditor/cli 0.15.26 → 0.15.28

package/dist/commands/install-session-hooks.js

@@ -1,12 +1,12 @@
 /**
- * install-session-hooks — Wire up session-start hooks for coding CLIs.
+ * install-session-hooks — Wire up session-start and Stop hooks for coding CLIs.
  *
  * When a CLI session starts, `haystack triage --hook` runs automatically
  * and shows the user whether their last submitted PR is "Good to merge" or
  * "Needs input", with the Haystack rating and auto-fixer status.
  *
  * Supported CLIs:
- *   - Claude Code: Native SessionStart hook in .claude/settings.json
+ *   - Claude Code: Native SessionStart and Stop hooks in .claude/settings.json
  *   - Codex CLI:   AGENTS.md instructions (no native hook support)
  *   - Gemini CLI:  GEMINI.md instructions (no native hook support)
  */
@@ -43,6 +43,7 @@ function detectInstalledCLIs() {
 // Claude Code: Native SessionStart hook
 // ============================================================================
 const HAYSTACK_HOOK_COMMAND = 'haystack triage --hook';
+const HAYSTACK_PRECOMPUTE_HOOK_COMMAND = 'haystack verify precompute --hook';
 function installClaudeHook(gitRoot) {
     const settingsDir = join(gitRoot, '.claude');
     const settingsPath = join(settingsDir, 'settings.json');
@@ -65,6 +66,8 @@ function installClaudeHook(gitRoot) {
         // Check if haystack hook already installed (current or legacy)
         const isHaystackHook = (h) => h.command?.includes('haystack triage') || h.command?.includes('haystack check-pending');
         const existingIndex = sessionStart.findIndex(entry => entry.hooks?.some(h => isHaystackHook(h)));
+        let changed = false;
+        let migrated = false;
         if (existingIndex !== -1) {
             const entry = sessionStart[existingIndex];
             const isLegacy = entry.hooks?.some(h => h.command?.includes('haystack check-pending'));
@@ -73,27 +76,51 @@ function installClaudeHook(gitRoot) {
                 for (const h of entry.hooks || []) {
                     if (h.command?.includes('haystack check-pending')) {
                         h.command = HAYSTACK_HOOK_COMMAND;
+                        changed = true;
+                        migrated = true;
                     }
                 }
-                writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-                console.log(chalk.green('  Claude Code hook migrated from check-pending to triage.'));
             }
-            else {
-                console.log(chalk.dim('  Claude Code hook already installed.'));
+        }
+        else {
+            // Add the session-start hook (fresh install).
+            sessionStart.push({
+                matcher: '',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: HAYSTACK_HOOK_COMMAND,
+                    },
+                ],
+            });
+            changed = true;
+        }
+        // Stop precompute is independent of SessionStart. Preserve every unrelated
+        // entry and add the exact command only when no matching command exists.
+        const stop = (hooks.Stop || []);
+        hooks.Stop = stop;
+        const hasPrecomputeHook = stop.some(entry => entry.hooks?.some(h => h.command?.includes(HAYSTACK_PRECOMPUTE_HOOK_COMMAND)));
+        if (!hasPrecomputeHook) {
+            stop.push({
+                matcher: '',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: HAYSTACK_PRECOMPUTE_HOOK_COMMAND,
+                    },
+                ],
+            });
+            changed = true;
+        }
+        if (changed) {
+            writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+            if (migrated) {
+                console.log(chalk.green('  Claude Code hook migrated from check-pending to triage.'));
             }
-            return true;
         }
-        // Add the hook (fresh install)
-        sessionStart.push({
-            matcher: '',
-            hooks: [
-                {
-                    type: 'command',
-                    command: HAYSTACK_HOOK_COMMAND,
-                },
-            ],
-        });
-        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        else {
+            console.log(chalk.dim('  Claude Code session and Stop hooks already installed.'));
+        }
         return true;
     }
     catch (err) {
@@ -101,6 +128,19 @@ function installClaudeHook(gitRoot) {
         return false;
     }
 }
+function checkClaudePrecomputeHook(gitRoot) {
+    const settingsPath = join(gitRoot, '.claude', 'settings.json');
+    if (!existsSync(settingsPath))
+        return false;
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        const stop = settings?.hooks?.Stop || [];
+        return stop.some((entry) => entry.hooks?.some(h => h.command?.includes(HAYSTACK_PRECOMPUTE_HOOK_COMMAND)));
+    }
+    catch {
+        return false;
+    }
+}
 function checkClaudeHook(gitRoot) {
     const settingsPath = join(gitRoot, '.claude', 'settings.json');
     if (!existsSync(settingsPath))
@@ -220,6 +260,7 @@ const CLI_HOOKS = {
         hasNativeHook: true,
         install: installClaudeHook,
         check: checkClaudeHook,
+        checkStop: checkClaudePrecomputeHook,
     },
     codex: {
         name: 'codex',
@@ -286,6 +327,9 @@ export async function installSessionHooks(options) {
         }
     }
     console.log(chalk.green('\n✓ Session hooks installed!\n'));
+    if (targets.includes('claude')) {
+        console.log(chalk.dim('Claude Code will also precompute verification inputs when a session stops.'));
+    }
     console.log(chalk.dim('When you start a new session, you\'ll see:'));
     console.log(chalk.green('  [Haystack] ✓ PR #42 "Fix auth": Good to merge'));
     console.log(chalk.yellow('  [Haystack] ⚠ PR #37 "Refactor API": Needs your input (2 bugs)'));
@@ -306,11 +350,17 @@ export async function sessionHooksStatus() {
         const cliIcon = isInstalled ? chalk.green('✓') : chalk.dim('-');
         const hookIcon = hookConfigured ? chalk.green('✓') : chalk.red('✗');
         console.log(`  ${cliIcon} ${config.displayName} ${isInstalled ? '(installed)' : '(not found)'}`);
-        if (isInstalled) {
-            console.log(`    ${hookIcon} Session hook ${hookConfigured ? 'configured' : 'not configured'}`);
+        console.log(`    ${hookIcon} Session hook ${hookConfigured ? 'configured' : 'not configured'}`);
+        if (config.checkStop) {
+            const stopConfigured = config.checkStop(gitRoot);
+            const stopIcon = stopConfigured ? chalk.green('✓') : chalk.red('✗');
+            console.log(`    ${stopIcon} Stop precompute hook ${stopConfigured ? 'configured' : 'not configured'}`);
         }
     }
-    const anyMissing = installed.some(cli => !CLI_HOOKS[cli].check(gitRoot));
+    const anyMissing = installed.some(cli => {
+        const config = CLI_HOOKS[cli];
+        return !config.check(gitRoot) || (config.checkStop ? !config.checkStop(gitRoot) : false);
+    });
     if (anyMissing) {
         console.log(chalk.dim('\nRun: haystack hooks install-session'));
     }

package/dist/commands/mcp.js

@@ -9,7 +9,6 @@ import { fetchPrStatePayload } from './pr.js';
 import { fetchPrStatusPayload } from './pr-status.js';
 import { fetchTriagePayload, fetchTriageHeadSha } from './triage.js';
 import { fetchAskPayload } from './ask.js';
-import { fetchTracesGetPayload, fetchTracesListPayload } from './traces.js';
 import { performOverride, performUndismiss } from './dismiss.js';
 import { performRequestReview } from './request-review.js';
 import { loadToken } from '../utils/auth.js';
@@ -29,7 +28,7 @@ const TOOLS = [
     },
     {
         name: 'pr_get',
-        description: 'Get useful state for one PR: triage, minimal merge blockers, trace availability, and conditional fixer outcome.',
+        description: 'Get useful state for one PR: triage, minimal merge blockers, and conditional fixer outcome.',
         inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
     },
     {
@@ -50,25 +49,6 @@ const TOOLS = [
             required: ['ref', 'question'],
         },
     },
-    {
-        name: 'traces_list',
-        description: 'List retained customer-owned Entire checkpoints for one PR.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'traces_get',
-        description: 'Get a page of retained customer-owned transcript chunks for one checkpoint.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ref: refInput,
-                checkpoint_id: { type: 'string' },
-                cursor: { type: 'string' },
-                limit: { type: 'integer', minimum: 1, maximum: 100 },
-            },
-            required: ['ref', 'checkpoint_id'],
-        },
-    },
     {
         name: 'pr_status',
         description: 'Get which Haystack feed bucket a PR is in (analyzing, good_to_merge, issues, needs_assignment, ...) and why.',
@@ -153,19 +133,6 @@ export async function runMcpServer() {
                     session: typeof input.session_id === 'string' ? input.session_id : undefined,
                 }));
             }
-            if (name === 'traces_list') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                return ok(await fetchTracesListPayload(input.ref));
-            }
-            if (name === 'traces_get') {
-                if (typeof input.ref !== 'string' || typeof input.checkpoint_id !== 'string')
-                    return fail('ref and checkpoint_id required');
-                return ok(await fetchTracesGetPayload(input.ref, input.checkpoint_id, {
-                    cursor: typeof input.cursor === 'string' ? input.cursor : undefined,
-                    limit: typeof input.limit === 'number' ? String(input.limit) : undefined,
-                }));
-            }
             if (name === 'pr_status') {
                 if (typeof input.ref !== 'string')
                     return fail('ref required');

package/dist/commands/pr.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { loadToken } from '../utils/auth.js';
 import { fetchAutoFixManifest, fetchRatingSynthesis } from '../utils/analysis-api.js';
-import { fetchAnalysisArtifact, fetchGitHubJson, haystackJson, HaystackApiError } from '../utils/haystack-api.js';
+import { fetchGitHubJson, haystackJson, HaystackApiError } from '../utils/haystack-api.js';
 import { parsePrRef } from '../utils/pr-ref.js';
 import { toPublicVerdict } from '../states.js';
 import { withSchema } from '../schema.js';
@@ -59,10 +59,9 @@ export async function fetchPrStatePayload(ref) {
     if (!token)
         throw new Error('Not authenticated. Run `haystack login` first.');
     const meta = await fetchGitHubJson(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, token);
-    const [synthesis, manifest, traces, merge] = await Promise.all([
+    const [synthesis, manifest, merge] = await Promise.all([
         fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
         fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
-        fetchAnalysisArtifact(pr.owner, pr.repo, pr.prNumber, 'entire_traces.json', token),
         fetchMergePublicState(meta, pr.prNumber, pr.owner, pr.repo, token),
     ]);
     const payload = {
@@ -77,10 +76,6 @@ export async function fetchPrStatePayload(ref) {
             }
             : { status: 'pending', verdict: null, findings_count: 0 },
         merge,
-        traces: {
-            available: traces?.hasTraces === true,
-            count: traces?.traces?.length ?? 0,
-        },
     };
     if (manifest) {
         const fixed = manifest.fixedItems.length;

package/dist/commands/prepare-universe-review.d.ts

@@ -0,0 +1,115 @@
+export interface ReviewExclusion {
+    path: string;
+    rule_id: string;
+}
+export interface ReviewSymlinkIssue {
+    path: string;
+    target: string;
+    reason: 'absolute-target' | 'target-escapes-repository' | 'target-is-excluded' | 'target-is-not-retained-file' | 'target-cycle' | 'ambiguous-target' | 'unreadable-link';
+}
+export interface InlineTestCandidate {
+    path: string;
+}
+export interface SnapshotLimitBlocker {
+    kind: 'entry-count' | 'total-output-bytes';
+    path: string;
+    limit: number;
+    attempted: number;
+    reason: string;
+}
+export interface PrepareUniverseReviewResult {
+    status: 'ready-for-confinement' | 'blocked';
+    path: string;
+    process_confinement_required: true;
+    counts: {
+        tracked: number;
+        retained: number;
+        copied: number;
+        excluded: number;
+        submodules_omitted: number;
+        approved_inactive_submodules_omitted: number;
+        symlinks_materialized: number;
+        symlink_issues: number;
+        symlinks_omitted_target_not_retained: number;
+        omitted_unscannable: number;
+        missing_or_changed_type: number;
+        inline_test_candidates: number;
+        inline_scan_skipped: number;
+        binary_inline_scan_skipped: number;
+        oversized_text_inline_scan_blockers: number;
+        snapshot_limit_blockers: number;
+        copied_bytes: number;
+    };
+    exclusions: ReviewExclusion[];
+    submodules_omitted: string[];
+    approved_inactive_submodule_omissions: {
+        rule: {
+            id: string;
+            description: string;
+        };
+        paths: string[];
+    };
+    rules: Array<{
+        id: string;
+        description: string;
+    }>;
+    activated_conditional_rule_ids: string[];
+    inline_marker_rules: Array<{
+        id: string;
+        description: string;
+    }>;
+    symlink_issues: ReviewSymlinkIssue[];
+    omitted_symlinks: ReviewSymlinkIssue[];
+    omitted_unscannable: {
+        path: string;
+        reason: string;
+    }[];
+    missing_or_changed_type: Array<{
+        path: string;
+        reason: string;
+    }>;
+    inline_test_candidates: InlineTestCandidate[];
+    inline_scan_skipped: Array<{
+        path: string;
+        reason: string;
+    }>;
+    snapshot_limit_blockers: SnapshotLimitBlocker[];
+    receipt: {
+        detail: 'compact' | 'full';
+        sample_limit: number;
+        complete_blocking_details: true;
+        collections: {
+            exclusions: ReceiptCollectionSummary;
+            approved_inactive_submodule_omissions: ReceiptCollectionSummary;
+            binary_inline_scan_skips: ReceiptCollectionSummary;
+        };
+    };
+    manifest: {
+        path: string;
+        sha256: string;
+        entries: number;
+    };
+}
+export interface PrepareUniverseReviewOptions {
+    excludeInactiveSubmodules?: string[];
+    /** Omit files whose test content cannot be ruled out instead of blocking. */
+    omitUnscannableFiles?: boolean;
+    fullReceipt?: boolean;
+    limits?: {
+        maxSnapshotEntries?: number;
+        maxSnapshotOutputBytes?: number;
+    };
+}
+interface ReceiptCollectionSummary {
+    total: number;
+    returned: number;
+    truncated: number;
+}
+export declare function prepareUniverseReview(root: string, options?: PrepareUniverseReviewOptions): PrepareUniverseReviewResult;
+export declare function prepareUniverseReviewCommand(options: {
+    json?: boolean;
+    excludeInactiveSubmodule?: string[];
+    omitUnscannableFiles?: boolean;
+    fullReceipt?: boolean;
+}): Promise<void>;
+export {};