@haystackeditor/cli 0.22.2 → 0.23.1

package/dist/commands/verify-precompute.js

@@ -8,7 +8,7 @@ import chalk from 'chalk';
 import { NotLoggedInError, resolveAuthContext } from '../utils/auth.js';
 import { findGitRoot, parseRemoteUrl, } from '../utils/git.js';
 import { resolveVerifyBaseSha } from '../utils/verify-base.js';
-import { HaystackApiError, haystackJson, REPO_NOT_ENTITLED_CODE, SUBSCRIPTION_REQUIRED_CODE, } from '../utils/haystack-api.js';
+import { HaystackApiError, haystackFetch, haystackJson, REPO_NOT_ENTITLED_CODE, SUBSCRIPTION_REQUIRED_CODE, } from '../utils/haystack-api.js';
 import { trackPrecomputeEvent } from '../utils/telemetry.js';
 import { findSecretsInPatch, isSecretBearingPath } from '../utils/secret-paths.js';
 import { startPrecomputeDelivery } from './precompute-delivery.js';
@@ -196,11 +196,11 @@ function deriveChangeTitle(gitRoot, baseSha, treeSha, commits, deadline) {
 }
 function slimInputHash() {
     // Mirrors front_half_cache_derive in blast-cache.sh for a slim bundle:
-    // printf '%s\0%s\0%s\0%s\0%s\0' slim agent-deferred none none crawl-blast-v1.
+    // printf '%s\0%s\0%s\0%s\0%s\0' slim agent-deferred none none crawl-blast-groups-v2.
     // The fifth field (CRAWL-V1 rule 4) keeps bundles written before
     // crawl-blast.json existed from being restored for a crawl.
     return createHash('sha256')
-        .update(Buffer.from('slim\0agent-deferred\0none\0none\0crawl-blast-v1\0'))
+        .update(Buffer.from('slim\0agent-deferred\0none\0none\0crawl-blast-groups-v2\0'))
         .digest('hex');
 }
 async function buildCompressedPatch(gitRoot, baseSha, workCommit, deadline) {
@@ -313,13 +313,45 @@ function precomputeResult(response) {
         return { outcome: 'existing', ...reported };
     throw new PrecomputeFailure('The precompute service returned an invalid response.');
 }
+/** The captured change as the service takes it (CRAWL-V1 amendment 14): uploaded once, content-addressed by its sha256 in
+ * the repository's scope (a HEAD finds an earlier upload; a PUT only when it is missing), and named in the front-half
+ * request by digest and size instead of carried inline. Nothing on the way holds a size limit of its own: tldraw's 13.8 MB
+ * capture was refused at the 8 MiB inline bound (2026-10-02). `force` uploads even when the HEAD found it (a 409 says the
+ * service no longer has it). */
+async function uploadSourcePatch(request, token, signal, force = false) {
+    const gzipped = Buffer.from(request.patchGzBase64, 'base64');
+    const path = `/api/agent/cloud-verifier/source-patches/${request.patchSha256}`
+        + `?owner=${encodeURIComponent(request.owner)}&repository=${encodeURIComponent(request.repository)}`;
+    const found = force ? null : await haystackFetch(path, token, { method: 'HEAD', signal }, [404]);
+    if (found === null || found.status === 404) {
+        await haystackFetch(path, token, { method: 'PUT', headers: { 'Content-Type': 'application/gzip' }, body: gzipped, signal });
+    }
+    return gzipped.byteLength;
+}
+/** One front-half submission of a captured request: the change uploaded (uploadSourcePatch), then the request naming it. A
+ * 409 (the service has no such upload: it expired between the HEAD and the POST) uploads it again and submits once more. */
+async function submitCapture(request, token, signal) {
+    const { patchGzBase64: _inline, ...named } = request;
+    const submit = async (force) => {
+        const patchBytes = await uploadSourcePatch(request, token, signal, force);
+        return haystackJson('/api/agent/cloud-verifier/front-half', token, { method: 'POST',
+            headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ...named, patchBytes }), signal });
+    };
+    try {
+        return await submit(false);
+    }
+    catch (error) {
+        if (!(error instanceof HaystackApiError && error.status === 409))
+            throw error;
+        return submit(true);
+    }
+}
 /** One authenticated submission of the already captured request. No source reads or retries. */
 export const deliverPrecomputeRequest = async (request, signal) => {
     signal.throwIfAborted();
     const auth = await resolveAuthContext({ owner: request.owner, repo: request.repository });
     signal.throwIfAborted();
-    return precomputeResult(await haystackJson('/api/agent/cloud-verifier/front-half', auth.token, { method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(request), signal }));
+    return precomputeResult(await submitCapture(request, auth.token, signal));
 };
 function readWalkerStatus(value) {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
@@ -506,12 +538,7 @@ export async function postPrecomputeCapture(capture, token, deadline) {
     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(capture.derivation.request),
-            signal: controller.signal,
-        });
+        response = await submitCapture(capture.derivation.request, token, controller.signal);
     }
     finally {
         clearTimeout(fetchTimer);

package/dist/commands/verify.js

@@ -160,6 +160,19 @@ function checkSpot(value) {
         || (reached.page !== null && typeof reached.page !== 'string')))
         invalid('how a changed spot was reached');
 }
+function checkPlanningCoverage(value) {
+    if (!isRecord(value) || !['groups', 'selectedIncidentPairs', 'unplannedIncidentPairs', 'proposedSituations', 'selectedSituations',
+        'deferredSituations', 'unrealizedSituations', 'completedSituations', 'blockedSituations'].every(key => isCount(value[key]))
+        || typeof value.sourceGraphTruncated !== 'boolean' || !Array.isArray(value.unresolvedChanges))
+        invalid('its planning coverage');
+    const changes = new Set();
+    for (const item of value.unresolvedChanges) {
+        if (!isRecord(item) || typeof item.changeKey !== 'string' || !item.changeKey || typeof item.reason !== 'string' || !item.reason
+            || changes.has(item.changeKey))
+            invalid('its unresolved changes');
+        changes.add(item.changeKey);
+    }
+}
 /** The published results' shape, shared by the sealed manifest and (amendment 9) an answer; `what` names which. */
 function checkResults(value, view, what) {
     if (!isRecord(value) || value.schemaVersion !== 1)
@@ -196,6 +209,8 @@ function checkResults(value, view, what) {
         || standIns.coverage.length > CRAWL_MAX_STAND_IN_ROWS || !standIns.coverage.every(isStandInRow)
         || !isCount(standIns.omittedRows) || !isStrings(standIns.gaps, CRAWL_MAX_STAND_IN_ROWS)))
         invalid('its outside-service coverage');
+    if (Object.hasOwn(reach, 'planning'))
+        checkPlanningCoverage(reach.planning);
     if (value.error !== null)
         checkError(value.error, 'its error');
 }
@@ -439,6 +454,17 @@ export function formatCrawl(view) {
     const blast = published.reach.blast;
     if (blast !== null)
         lines.push(`  ${blast.ran} of ${plural(blast.functions, 'affected function')} ran.`);
+    const planning = published.reach.planning;
+    if (planning !== undefined) {
+        lines.push('', chalk.bold('Situations considered'), `  Considered ${plural(planning.groups, 'group')} of related behavior, with ${plural(planning.selectedIncidentPairs, 'possible failure pattern')} selected across them.`, `  ${planning.selectedSituations} of ${plural(planning.proposedSituations, 'proposed situation')} selected; ${planning.deferredSituations} deferred.`, `  Actions completed for ${plural(planning.completedSituations, 'situation')}; ${planning.blockedSituations} blocked during execution.`, `  Could not plan checks for ${plural(planning.unplannedIncidentPairs, 'selected failure pattern')}; ${plural(planning.unrealizedSituations, 'selected situation')} had no executable route.`, '  Completed actions do not establish that a situation is free of bugs.');
+        if (planning.sourceGraphTruncated)
+            lines.push('  The recorded code relationships were incomplete.');
+        if (planning.unresolvedChanges.length) {
+            lines.push('  Changes that could not be included in a behavior group:');
+            for (const change of planning.unresolvedChanges)
+                lines.push(`    ${safe(change.changeKey)}: ${safe(change.reason)}`);
+        }
+    }
     // Amendment 13: calls to outside services the stand-ins could not serve: the copy's missing coverage, never a finding.
     const gaps = published.standIns?.gaps ?? [];
     if (gaps.length > 0) {

package/dist/utils/haystack-api.js

@@ -183,6 +183,11 @@ 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 haystackFetch(path, token, init, acceptedStatuses);
+    return response.json();
+}
+/** An authenticated request whose response is not JSON (a HEAD, an upload): the response itself, or the classified error. */
+export async function haystackFetch(path, token, init = {}, acceptedStatuses = []) {
     const response = await fetch(haystackApiUrl(path), {
         ...init,
         headers: headers(token, init.headers),
@@ -190,7 +195,7 @@ export async function haystackJson(path, token, init = {}, acceptedStatuses = []
     if (!response.ok && !acceptedStatuses.includes(response.status)) {
         throw await classifyHttpError(response, `Haystack API ${path}`);
     }
-    return response.json();
+    return response;
 }
 export async function fetchCliIdentity(token) {
     return haystackJson('/api/cli/me', token);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haystackeditor/cli",
-  "version": "0.22.2",
+  "version": "0.23.1",
   "description": "haystack verify: run your app with and without a change, and see what the change broke",
   "type": "module",
   "bin": {