@haystackeditor/cli 0.15.27 → 0.15.28

package/dist/commands/verify-precompute.js

@@ -0,0 +1,328 @@
+import { spawn, execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { createGzip } from 'node:zlib';
+import { isAbsolute, join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import chalk from 'chalk';
+import { NotLoggedInError, resolveAuthContext } from '../utils/auth.js';
+import { findGitRoot, parseRemoteUrl, resolveDiffBaseRef, } from '../utils/git.js';
+import { HaystackApiError, haystackJson } from '../utils/haystack-api.js';
+import { trackPrecomputeEvent } from '../utils/telemetry.js';
+const TOTAL_WALL_MS = 5_000;
+const REMOTE_COMMAND_MS = 750;
+const COMMIT_SHA = /^[0-9a-f]{40}$/;
+const REPOSITORY_COMPONENT = /^[A-Za-z0-9_.-]{1,100}$/;
+const RUN_ID = /^cv_[0-9a-f]{48}$/;
+const FIXED_COMMIT_ENV = {
+    GIT_AUTHOR_NAME: 'haystack-stop-hook',
+    GIT_AUTHOR_EMAIL: 'stop-hook@haystack.invalid',
+    GIT_AUTHOR_DATE: '2000-01-01T00:00:00Z',
+    GIT_COMMITTER_NAME: 'haystack-stop-hook',
+    GIT_COMMITTER_EMAIL: 'stop-hook@haystack.invalid',
+    GIT_COMMITTER_DATE: '2000-01-01T00:00:00Z',
+};
+class PrecomputeFailure extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PrecomputeFailure';
+    }
+}
+function remainingMs(deadline) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+        throw new PrecomputeFailure('Precompute timed out.');
+    }
+    return remaining;
+}
+function gitOutput(args, gitRoot, deadline, options = {}) {
+    const timeout = Math.max(1, Math.min(remainingMs(deadline), options.timeoutCapMs ?? TOTAL_WALL_MS));
+    try {
+        return execFileSync('git', args, {
+            cwd: gitRoot,
+            encoding: 'utf8',
+            env: options.env ?? process.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout,
+        }).trim();
+    }
+    catch {
+        throw new PrecomputeFailure('Could not derive the repository snapshot.');
+    }
+}
+function resolveOriginRepository(gitRoot) {
+    try {
+        const remote = parseRemoteUrl('origin');
+        if (!REPOSITORY_COMPONENT.test(remote.owner)
+            || !REPOSITORY_COMPONENT.test(remote.repo)) {
+            throw new Error('invalid repository identity');
+        }
+        return { owner: remote.owner, repository: remote.repo };
+    }
+    catch {
+        // Keep remote URLs and local paths out of errors.
+        throw new PrecomputeFailure('No supported origin repository was found.');
+    }
+}
+function resolveOriginDefaultBranch(gitRoot, deadline) {
+    try {
+        const remoteHead = gitOutput(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], gitRoot, deadline);
+        if (remoteHead.startsWith('origin/') && remoteHead.length > 'origin/'.length) {
+            return remoteHead.slice('origin/'.length);
+        }
+    }
+    catch {
+        // A clone does not have to carry origin/HEAD; ask the remote below.
+    }
+    const remoteSummary = gitOutput(['remote', 'show', 'origin'], gitRoot, deadline, {
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        timeoutCapMs: REMOTE_COMMAND_MS,
+    });
+    const match = remoteSummary.match(/^\s*HEAD branch:\s*(\S+)\s*$/m);
+    if (!match) {
+        throw new PrecomputeFailure('Could not resolve the origin default branch.');
+    }
+    return match[1];
+}
+function deriveBaseSha(gitRoot, deadline) {
+    const defaultBranch = resolveOriginDefaultBranch(gitRoot, deadline);
+    const baseRef = resolveDiffBaseRef(defaultBranch, {
+        cwd: gitRoot,
+        timeoutMs: Math.max(1, Math.min(remainingMs(deadline), REMOTE_COMMAND_MS)),
+    });
+    const baseSha = gitOutput(['merge-base', 'HEAD', baseRef], gitRoot, deadline);
+    if (!COMMIT_SHA.test(baseSha)) {
+        throw new PrecomputeFailure('Could not derive the base commit.');
+    }
+    return baseSha;
+}
+function deriveWorktreeTreeSha(gitRoot, deadline) {
+    const scratchDirectory = mkdtempSync(join(tmpdir(), 'haystack-precompute-index-'));
+    const temporaryIndex = join(scratchDirectory, 'index');
+    try {
+        const gitIndexPath = gitOutput(['rev-parse', '--git-path', 'index'], gitRoot, deadline);
+        const sourceIndex = isAbsolute(gitIndexPath)
+            ? gitIndexPath
+            : resolve(gitRoot, gitIndexPath);
+        const indexEnv = { ...process.env, GIT_INDEX_FILE: temporaryIndex };
+        if (existsSync(sourceIndex)) {
+            // blast_cache_worktree_tree_sha uses `cp -p`: preserving timestamps keeps
+            // git's racy-clean handling byte-identical to the bash implementation.
+            cpSync(sourceIndex, temporaryIndex, { preserveTimestamps: true });
+        }
+        else {
+            gitOutput(['read-tree', 'HEAD'], gitRoot, deadline, { env: indexEnv });
+        }
+        gitOutput(['add', '-A'], gitRoot, deadline, { env: indexEnv });
+        const treeSha = gitOutput(['write-tree'], gitRoot, deadline, { env: indexEnv });
+        if (!COMMIT_SHA.test(treeSha)) {
+            throw new PrecomputeFailure('Could not derive the working-tree snapshot.');
+        }
+        return treeSha;
+    }
+    finally {
+        rmSync(scratchDirectory, { recursive: true, force: true });
+    }
+}
+function deriveWorkCommit(gitRoot, baseSha, treeSha, deadline) {
+    const headSha = gitOutput(['rev-parse', 'HEAD'], gitRoot, deadline);
+    const headTreeSha = gitOutput(['rev-parse', 'HEAD^{tree}'], gitRoot, deadline);
+    if (!COMMIT_SHA.test(headSha) || !COMMIT_SHA.test(headTreeSha)) {
+        throw new PrecomputeFailure('Could not resolve the current commit.');
+    }
+    // A clean checkout of the base already has the exact required identity.
+    if (baseSha === headSha && treeSha === headTreeSha)
+        return headSha;
+    const workCommit = gitOutput(['commit-tree', treeSha, '-p', baseSha, '-m', 'front-half-snapshot'], gitRoot, deadline, { env: { ...process.env, ...FIXED_COMMIT_ENV } });
+    if (!COMMIT_SHA.test(workCommit)) {
+        throw new PrecomputeFailure('Could not derive the working commit.');
+    }
+    return workCommit;
+}
+function slimInputHash() {
+    // Mirrors printf '%s\0%s\0%s\0%s\0' slim codex-harness none none.
+    return createHash('sha256')
+        .update(Buffer.from('slim\0codex-harness\0none\0none\0'))
+        .digest('hex');
+}
+async function buildCompressedPatch(gitRoot, baseSha, workCommit, deadline) {
+    return new Promise((resolvePatch, rejectPatch) => {
+        const child = spawn('git', ['diff', '--binary', baseSha, workCommit], {
+            cwd: gitRoot,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const gzip = createGzip();
+        const chunks = [];
+        let compressedBytes = 0;
+        let childClosed = false;
+        let gzipEnded = false;
+        let childSucceeded = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            fail(new PrecomputeFailure('Precompute timed out.'));
+        }, remainingMs(deadline));
+        const clear = () => clearTimeout(timer);
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clear();
+            child.kill('SIGKILL');
+            gzip.destroy();
+            rejectPatch(error);
+        };
+        const finish = () => {
+            if (settled || !childClosed || !gzipEnded)
+                return;
+            if (!childSucceeded) {
+                fail(new PrecomputeFailure('Could not build the working-tree patch.'));
+                return;
+            }
+            settled = true;
+            clear();
+            resolvePatch(Buffer.concat(chunks, compressedBytes));
+        };
+        child.stderr.resume();
+        child.once('error', () => fail(new PrecomputeFailure('Could not build the working-tree patch.')));
+        child.once('close', code => {
+            childClosed = true;
+            childSucceeded = code === 0;
+            finish();
+        });
+        gzip.on('data', (chunk) => {
+            compressedBytes += chunk.length;
+            chunks.push(chunk);
+        });
+        gzip.once('error', () => fail(new PrecomputeFailure('Could not compress the working-tree patch.')));
+        gzip.once('end', () => {
+            gzipEnded = true;
+            finish();
+        });
+        child.stdout.pipe(gzip);
+    });
+}
+export async function derivePrecomputeRequest(gitRoot, owner, repository, deadline = Date.now() + TOTAL_WALL_MS) {
+    const baseSha = deriveBaseSha(gitRoot, deadline);
+    const treeSha = deriveWorktreeTreeSha(gitRoot, deadline);
+    const workCommit = deriveWorkCommit(gitRoot, baseSha, treeSha, deadline);
+    const patchGzip = await buildCompressedPatch(gitRoot, baseSha, workCommit, deadline);
+    const cacheKey = [
+        baseSha.slice(0, 12),
+        workCommit.slice(0, 12),
+        treeSha.slice(0, 16),
+        'slim',
+        slimInputHash(),
+    ].join('-');
+    return {
+        treeSha,
+        request: {
+            owner,
+            repository,
+            baseCommit: baseSha,
+            workCommit,
+            cacheKey,
+            patchGzBase64: patchGzip.toString('base64'),
+            patchSha256: createHash('sha256').update(patchGzip).digest('hex'),
+        },
+    };
+}
+function precomputeResult(response) {
+    if (!response || typeof response !== 'object' || Array.isArray(response)) {
+        throw new PrecomputeFailure('The precompute service returned an invalid response.');
+    }
+    const { status, runId } = response;
+    if (status === 'queued' && typeof runId === 'string' && RUN_ID.test(runId)) {
+        return { outcome: 'enqueued', runId };
+    }
+    if (status === 'cached')
+        return { outcome: 'cached' };
+    if (status === 'existing')
+        return { outcome: 'existing' };
+    throw new PrecomputeFailure('The precompute service returned an invalid response.');
+}
+function normalModeFailure(error) {
+    if (error instanceof PrecomputeFailure)
+        return error;
+    if (error instanceof NotLoggedInError) {
+        return new PrecomputeFailure('Authentication is required. Run `haystack login` first.');
+    }
+    if (error instanceof HaystackApiError) {
+        if (error.status === 401 || error.status === 403) {
+            return new PrecomputeFailure('Authentication was rejected. Run `haystack login` and try again.');
+        }
+        if (error.status === 429) {
+            return new PrecomputeFailure('Precompute requests are temporarily rate limited. Try again later.');
+        }
+        return new PrecomputeFailure(`The precompute request failed (HTTP ${error.status}).`);
+    }
+    return new PrecomputeFailure('The precompute request failed.');
+}
+function printResult(outcome, runId) {
+    if (outcome === 'enqueued') {
+        console.log(chalk.green(`Precompute request queued${runId ? ` (${runId})` : ''}.`));
+    }
+    else if (outcome === 'cached') {
+        console.log(chalk.green('Precompute result is already cached.'));
+    }
+    else if (outcome === 'existing') {
+        console.log(chalk.green('A matching precompute request already exists.'));
+    }
+}
+export async function verifyPrecomputeCommand(options) {
+    const startedAt = Date.now();
+    const deadline = startedAt + TOTAL_WALL_MS;
+    let outcome = 'error';
+    try {
+        const gitRoot = findGitRoot();
+        if (!gitRoot) {
+            throw new PrecomputeFailure('Run this command from a git repository.');
+        }
+        const repository = resolveOriginRepository(gitRoot);
+        const derivation = await derivePrecomputeRequest(gitRoot, repository.owner, repository.repository, deadline);
+        let token;
+        try {
+            const auth = await resolveAuthContext({
+                owner: repository.owner,
+                repo: repository.repository,
+            });
+            token = auth.token;
+        }
+        catch (error) {
+            if (error instanceof NotLoggedInError) {
+                outcome = 'skipped_no_auth';
+                if (options.hook)
+                    return;
+            }
+            throw error;
+        }
+        const controller = new AbortController();
+        const fetchTimer = setTimeout(() => controller.abort(), remainingMs(deadline));
+        let response;
+        try {
+            response = await haystackJson('/api/agent/cloud-verifier/front-half', token, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(derivation.request),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(fetchTimer);
+        }
+        const result = precomputeResult(response);
+        outcome = result.outcome;
+        if (!options.hook)
+            printResult(outcome, result.runId);
+    }
+    catch (error) {
+        if (!options.hook)
+            throw normalModeFailure(error);
+    }
+    finally {
+        const wallMs = Date.now() - startedAt;
+        trackPrecomputeEvent(outcome, wallMs, Math.max(1, TOTAL_WALL_MS - wallMs));
+        if (options.hook)
+            process.exitCode = 0;
+    }
+}

package/dist/index.js

@@ -36,7 +36,7 @@ import { cloudVerifierDataStoreDriftCommand } from './commands/cloud-verifier-da
 import { cloudVerifierBehaviorsValidateCommand } from './commands/cloud-verifier-behaviors.js';
 import { prepareUniverseReviewCommand } from './commands/prepare-universe-review.js';
 import { scaffoldProvisionalUniverseCommand } from './commands/scaffold-provisional-universe.js';
-import { hooksInstall, hooksStatus, hooksUpdate } from './commands/hooks.js';
+import { hooksInstall, hooksStatus } from './commands/hooks.js';
 import { submitCommand } from './commands/submit.js';
 import { installSessionHooks, sessionHooksStatus } from './commands/install-session-hooks.js';
 import { listPolicies, addPolicy, removePolicy, initPolicies, addInstruction } from './commands/policy.js';
@@ -49,7 +49,6 @@ import { prStatusCommand } from './commands/pr-status.js';
 import { prReadCommand } from './commands/pr.js';
 import { inboxListCommand } from './commands/inbox.js';
 import { askHaystackCommand } from './commands/ask.js';
-import { tracesGetCommand, tracesListCommand } from './commands/traces.js';
 import { telemetryInstrumentCommand } from './commands/telemetry.js';
 import { setupCommand } from './commands/setup.js';
 import { schemaCommand, listSchemas } from './commands/schema-cmd.js';
@@ -134,7 +133,6 @@ program
     // Defining --no-auto-merge also accepts --auto-merge; default is "ask" unless
     // one is explicitly passed (detected via getOptionValueSource below).
     .option('--no-auto-merge', 'Set auto-merge in the written config (--auto-merge / --no-auto-merge; omit to be asked)')
-    .option('--skip-entire', 'Skip the Entire CLI / git-hooks (session tracking) step')
     .option('--answers <file>', 'JSON file of {questionId: value} pre-supplied answers')
     .addHelpText('after', `
 Steps: verify GitHub App → select repos → scan (rules/policies/instructions) →
@@ -143,7 +141,7 @@ review → write .haystack/pr-rules.yml + review-policy.md + .haystack.json.
 Three ways to run:
   • Interactive (default): prompts in your terminal.
   • Autonomous/CI: supply every decision via flags, e.g.
-      haystack setup --repo owner/name --yes --no-auto-merge --skip-entire
+      haystack setup --repo owner/name --yes --no-auto-merge
   • Coding agent: --json speaks NDJSON on stdout and reads answers on stdin, so an
     agent can auto-answer or relay questions to the user. Pre-supplied answers
     (flags / --answers) skip the matching question.
@@ -165,7 +163,6 @@ Examples:
         repos: options.repo,
         yes: options.yes,
         autoMerge: autoMergeExplicit ? options.autoMerge : undefined,
-        skipEntire: options.skipEntire,
         answersFile: options.answers,
     });
 });
@@ -213,6 +210,18 @@ Examples:
 `)
     .action((specimen, options) => runPublicCommand(() => verifyCommand(specimen, options), options.json));
 const verifyRunArg = 'Run id, chapter id (newest run of that chapter), or "latest" (default)';
+verify
+    .command('precompute')
+    .description('Precompute reusable verification inputs for the current working tree')
+    .option('--hook', 'Run silently as a best-effort repository hook')
+    .action(async (options) => {
+    await runPublicCommand(async () => {
+        const { verifyPrecomputeCommand } = await import('./commands/verify-precompute.js');
+        await verifyPrecomputeCommand(options);
+    });
+    if (options.hook)
+        process.exitCode = 0;
+});
 const hostedVerify = verify
     .command('hosted')
     .description('Run the production Cloud Verifier against exact GitHub commits');
@@ -655,7 +664,7 @@ program
     .addHelpText('after', `
 This command is designed for AI coding agents to submit PRs.
 
-  1. Runs pre-PR triage (code review, rules, instruction drift) via sub-agents
+  1. Runs pre-PR triage (code review and rules) via sub-agents
   2. Pushes the current branch to origin
   3. Creates a pull request on GitHub
   4. Waits for Haystack analysis results (triggered via GitHub App webhook)
@@ -664,15 +673,14 @@ Pre-PR Triage:
   Before creating the PR, haystack spawns parallel sub-agents to check for:
   • Code review bugs (logic errors, null crashes, security issues)
   • Rule violations (from .haystack/pr-rules.yml)
-  • Instruction drift (AI agent deviations from user instructions)
 
   Use --force to skip triage entirely.
   Use --no-wait to skip waiting for analysis results.
 
   Triage budgets:
   • --max-turns <n>         Raise/lower the per-checker tool-use turn cap.
-                            Defaults: code-review 8, rules-validator 10,
-                            intent-drift 10. Applies the same N to all three.
+                            Defaults: code-review 8, rules-validator 10.
+                            Applies the same N to both.
   • --triage-timeout <sec>  Raise/lower the per-checker wall-clock timeout
                             (default: 180s).
 
@@ -790,7 +798,7 @@ inbox
 const prProgram = program.command('pr').description('Inspect one pull request');
 prProgram
     .command('get <ref>')
-    .description('Get triage, merge blockers, and trace availability')
+    .description('Get triage and merge blockers')
     .option('--json', 'Output as JSON')
     .action((ref, options) => runPublicCommand(() => prReadCommand(ref, options), options.json));
 program
@@ -799,19 +807,6 @@ program
     .option('--json', 'Output the answer and every consulted customer-facing source as JSON')
     .option('--session <id>', 'Continue a previous Ask Haystack session')
     .action((ref, question, options) => runPublicCommand(() => askHaystackCommand(ref, question, options), options.json));
-const traces = program.command('traces').description('Inspect customer-owned Entire traces');
-traces
-    .command('list <ref>')
-    .description('List retained checkpoints for a pull request')
-    .option('--json', 'Output as JSON')
-    .action((ref, options) => runPublicCommand(() => tracesListCommand(ref, options), options.json));
-traces
-    .command('get <ref> <checkpoint>')
-    .description('Get retained transcript chunks for one checkpoint')
-    .option('--cursor <cursor>', 'Zero-based chunk cursor')
-    .option('--limit <count>', 'Chunks per page', '20')
-    .option('--json', 'Output as JSON')
-    .action((ref, checkpoint, options) => runPublicCommand(() => tracesGetCommand(ref, checkpoint, options), options.json));
 const telemetry = program.command('telemetry').description('Add privacy-safe production telemetry without an application SDK');
 telemetry
     .command('instrument <dist>')
@@ -870,15 +865,27 @@ program
     .option('--run <run-id>', 'Resume and wait for an existing exact run id')
     .option('--poll-interval <seconds>', 'Status polling interval', '3')
     .option('--timeout <seconds>', 'Maximum time to wait; the server run continues after timeout', '7200')
+    .option('--case <case-id>', 'Select one exact generated case for universe exploration')
+    .option('--universe <role>', 'Select control-before, before, or after')
+    .option('--replay', 'Replay the registered case command in the selected universe')
+    .option('--exec-json <argv>', 'Run a JSON argv array in the selected universe')
+    .option('--cwd <path>', 'Repository-relative working directory for --exec-json')
+    .option('--command-timeout <seconds>', 'Maximum selected-universe command runtime')
+    .option('--action <action-id>', 'Resume one exact universe action')
     .addHelpText('after', `
 Executes the change instead of reading 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 reports a mechanical
-verdict of unexpected behavior changes.
+alone, designs pre-registered behavioral test cases, runs control-before,
+before, and after in isolated sandboxes, and reports anomaly candidates
+outside the registered intent.
 
 The command waits for a behavioral verdict by default. Use --no-wait to
 return the run id immediately, or --run <run-id> to resume waiting.
 
+After a completed run, inspect or replay one retained case universe without
+receiving provider credentials:
+  haystack design-verify owner/repo#123 --run RUN --case case-00001 --universe before --replay
+  haystack design-verify owner/repo#123 --run RUN --case case-00001 --universe after --exec-json '["rg","TODO"]'
+
 PR identifier formats:
   123                                     PR number (uses current repo)
   owner/repo#123                          Fully qualified
@@ -1188,42 +1195,34 @@ const hooks = program
     .description('Manage git hooks for AI agent quality checks');
 hooks
     .command('install')
-    .description('Install Haystack git hooks and Entire CLI')
-    .option('--version <version>', 'Entire CLI version (default: pinned)')
+    .description('Install Haystack git hooks')
     .option('-f, --force', 'Overwrite existing hooks')
-    .option('--skip-entire', 'Skip Entire binary download')
     .addHelpText('after', `
 This installs:
   • Git hooks for AI agent quality checks (pre-commit, commit-msg, etc.)
   • Agent context detector (identifies AI agent sessions)
   • Truncation checker (prevents code truncation by LLMs)
-  • Entire CLI binary for session tracking (powered by https://entire.dev)
 
 Hooks are installed to <repo>/hooks/ and git is configured to use them.
 
 Examples:
-  haystack hooks install              # Install with pinned Entire version
   haystack hooks install --force      # Overwrite existing hooks
-  haystack hooks install --skip-entire # Only install Haystack hooks
 `)
     .action(hooksInstall);
 hooks
     .command('status')
     .description('Check hooks installation status')
     .action(hooksStatus);
-hooks
-    .command('update')
-    .description('Update Entire CLI to the latest version')
-    .action(hooksUpdate);
 hooks
     .command('install-session')
-    .description('Install session-start hooks for coding CLIs')
+    .description('Install session-start and Stop hooks for coding CLIs')
     .option('--cli <name>', 'Target CLI: claude, codex, gemini, or all')
     .addHelpText('after', `
 Configures your coding CLI to run \`haystack triage --hook\` on session start.
 This shows pending PR analysis results when you open a new terminal session.
+Claude Code also runs \`haystack verify precompute --hook\` when a session stops.
 
-  Claude Code:  Native SessionStart hook (.claude/settings.json)
+  Claude Code:  Native SessionStart and Stop hooks (.claude/settings.json)
   Codex CLI:    AGENTS.md instructions
   Gemini CLI:   GEMINI.md instructions
 

package/dist/schema.d.ts

@@ -12,11 +12,10 @@
 export declare const SCHEMA_VERSIONS: {
     readonly triage: "2.0.0";
     readonly setup: "1.0.0";
-    readonly pr: "2.0.0";
+    readonly pr: "3.0.0";
     readonly 'pr-status': "1.0.0";
     readonly inbox: "1.0.0";
     readonly ask: "1.0.0";
-    readonly traces: "1.0.0";
     readonly submit: "1.0.0";
     readonly action: "1.0.0";
     readonly 'cloud-verifier': "1.0.0";

package/dist/schema.js

@@ -12,11 +12,10 @@
 export const SCHEMA_VERSIONS = {
     triage: '2.0.0',
     setup: '1.0.0',
-    pr: '2.0.0',
+    pr: '3.0.0',
     'pr-status': '1.0.0',
     inbox: '1.0.0',
     ask: '1.0.0',
-    traces: '1.0.0',
     submit: '1.0.0',
     action: '1.0.0',
     'cloud-verifier': '1.0.0',

package/dist/triage/prompts.d.ts

@@ -22,10 +22,3 @@ export declare function buildRulesValidatorPrompt(baseBranch: string, rulesYaml:
     filename: string;
     content: string;
 }[], precomputedDiff?: string | null): string | null;
-/**
- * Build the intent drift prompt.
- * Only runs if relevant trace files exist.
- *
- * @returns The prompt string, or null if no trace files provided.
- */
-export declare function buildIntentDriftPrompt(baseBranch: string, traceFiles: string[], outputPath: string, maxTurns: number, timeoutMs: number, precomputedDiff?: string | null): string | null;