@haystackeditor/cli 0.15.29 → 0.15.31

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

@@ -0,0 +1,79 @@
+const outcomes = ['healthy', 'degraded', 'invalid', 'failed', 'unknown'];
+export function isDesignVerifierHistoryReport(value, expected) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const report = value;
+    if (report.version !== 'dv-cli-history-v1' || report.owner !== expected.owner ||
+        report.repo !== expected.repo || report.limit !== expected.limit ||
+        !Number.isSafeInteger(report.retentionDays) || report.retentionDays <= 0 ||
+        !Array.isArray(report.runs) || report.runs.length > report.limit || !report.summary)
+        return false;
+    const seen = new Set();
+    const counts = { healthy: 0, degraded: 0, invalid: 0, failed: 0, unknown: 0 };
+    const blockers = new Map();
+    for (const run of report.runs) {
+        if (!run || !Number.isSafeInteger(run.pr) || run.pr < 1 || typeof run.runId !== 'string')
+            return false;
+        const prefix = `${expected.owner}--${expected.repo}--${run.pr}--`;
+        if (!run.runId.startsWith(prefix) ||
+            !/^[0-9a-f]{12}(?:--attempt-[1-9]\d*)?$/.test(run.runId.slice(prefix.length)) ||
+            seen.has(run.runId) || !outcomes.includes(run.outcome) ||
+            !['succeeded', 'failed', 'failed-stale'].includes(run.status) ||
+            (run.outcome === 'failed') !== (run.status !== 'succeeded') ||
+            typeof run.createdAt !== 'string' || !Number.isFinite(Date.parse(run.createdAt)) ||
+            (run.finishedAt !== null && (typeof run.finishedAt !== 'string' || !Number.isFinite(Date.parse(run.finishedAt)))) ||
+            (run.baseSha !== null && typeof run.baseSha !== 'string') ||
+            (run.headSha !== null && typeof run.headSha !== 'string') ||
+            (run.admitted !== null && (!Number.isSafeInteger(run.admitted) || run.admitted < 0)) ||
+            !Array.isArray(run.losses) || run.losses.some(loss => !loss || typeof loss.code !== 'string' || !loss.code || typeof loss.owner !== 'string' ||
+            !loss.owner || !['degraded', 'invalid'].includes(loss.impact) ||
+            !Number.isSafeInteger(loss.count) || loss.count < 1))
+            return false;
+        if (['healthy', 'degraded'].includes(run.outcome) && (run.admitted === null || run.admitted === 0))
+            return false;
+        seen.add(run.runId);
+        counts[run.outcome]++;
+        for (const code of new Set(run.losses.map(loss => loss.code))) {
+            blockers.set(code, (blockers.get(code) || 0) + 1);
+        }
+    }
+    const summary = report.summary;
+    const usableRate = report.runs.length ? (counts.healthy + counts.degraded) / report.runs.length : null;
+    if (summary.total !== report.runs.length || summary.usableRate !== usableRate ||
+        outcomes.some(outcome => summary[outcome] !== counts[outcome]) ||
+        !Array.isArray(summary.topBlockers) || summary.topBlockers.length !== blockers.size)
+        return false;
+    const seenBlockers = new Set();
+    return summary.topBlockers.every(blocker => {
+        if (!blocker || seenBlockers.has(blocker.code) || blockers.get(blocker.code) !== blocker.affectedRuns)
+            return false;
+        seenBlockers.add(blocker.code);
+        return true;
+    });
+}
+function terminalSafe(value) {
+    return Array.from(value).filter(character => {
+        const point = character.codePointAt(0);
+        return point >= 32 && !(point >= 127 && point <= 159);
+    }).join('');
+}
+export function formatDesignVerifierHistory(report) {
+    const { summary } = report;
+    const lines = [`Execution history for ${terminalSafe(report.owner)}/${terminalSafe(report.repo)}`,
+        `Latest ${summary.total} recorded terminal attempts within ${report.retentionDays} days (limit ${report.limit}).`];
+    if (summary.total === 0) {
+        lines.push('No recorded attempts in this window. History starts when recording is deployed.');
+        return lines.join('\n');
+    }
+    lines.push(`Usable evidence: ${Math.round(summary.usableRate * 100)}% of attempts (${summary.healthy + summary.degraded}/${summary.total}).`, `Fully healthy: ${summary.healthy}; partially degraded: ${summary.degraded}; invalid: ${summary.invalid}; failed: ${summary.failed}; unknown: ${summary.unknown}.`, 'Usable includes partial evidence from degraded attempts. This measures execution reliability, not bug-detection accuracy.', '');
+    for (const run of report.runs) {
+        lines.push(`${run.finishedAt || run.createdAt}  PR #${run.pr}  ${run.outcome}  ${run.admitted ?? '?'} admitted cases`, `  ${run.runId}`);
+    }
+    if (summary.topBlockers.length) {
+        lines.push('', 'Most frequent blockers (attempts affected):');
+        for (const blocker of summary.topBlockers.slice(0, 5)) {
+            lines.push(`  ${terminalSafe(blocker.code)}: ${blocker.affectedRuns}`);
+        }
+    }
+    return lines.join('\n');
+}

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

@@ -30,6 +30,22 @@ export interface DesignVerifierAgentCase {
         errors: string[];
     } | null;
 }
+export interface DesignVerifierRunHealthLoss {
+    code: string;
+    owner: 'harness' | 'case';
+    impact: 'degraded' | 'invalid';
+    count: number;
+    caseIds: string[];
+    obligationIds: string[];
+    slotIds: string[];
+    sides: string[];
+}
+export interface DesignVerifierRunHealth {
+    version: 'dv-run-health-v1';
+    status: 'healthy' | 'degraded' | 'invalid';
+    admitted: number;
+    losses: DesignVerifierRunHealthLoss[];
+}
 export interface DesignVerifierAgentReport {
     ok: boolean;
     status: 'complete' | 'failed';
@@ -47,6 +63,7 @@ export interface DesignVerifierAgentReport {
     timings: DesignVerifierTimingSummary | null;
     changedFiles: string[];
     cases: DesignVerifierAgentCase[];
+    runHealth: DesignVerifierRunHealth | null;
     inspectCommand: string;
     replay: Record<string, unknown> | null;
     error: string | null;

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

@@ -30,6 +30,54 @@ function universeSummaries(value, caseId) {
         ['control-before', 'before', 'after'].includes(universe.role) &&
         universe.lease && typeof universe.lease.available === 'boolean');
 }
+function runHealthOf(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const health = value;
+    if (health.version !== 'dv-run-health-v1' ||
+        !['healthy', 'degraded', 'invalid'].includes(health.status) ||
+        !Number.isInteger(health.admitted) || health.admitted < 0 ||
+        !Array.isArray(health.losses))
+        return null;
+    const losses = health.losses.filter((loss) => loss && typeof loss === 'object' &&
+        typeof loss.code === 'string' && loss.code.length > 0 &&
+        ['harness', 'case'].includes(loss.owner) &&
+        ['degraded', 'invalid'].includes(loss.impact) &&
+        Number.isInteger(loss.count) && loss.count > 0 &&
+        [loss.caseIds, loss.obligationIds, loss.slotIds, loss.sides]
+            .every(items => Array.isArray(items) && items.every(item => typeof item === 'string')));
+    if (losses.length !== health.losses.length)
+        return null;
+    const invalidHarnessLoss = losses.some(loss => loss.owner === 'harness' && loss.impact === 'invalid');
+    const expectedStatus = health.admitted === 0 || invalidHarnessLoss
+        ? 'invalid'
+        : losses.length > 0 ? 'degraded' : 'healthy';
+    if (health.status !== expectedStatus)
+        return null;
+    return {
+        version: health.version,
+        status: health.status,
+        admitted: health.admitted,
+        losses,
+    };
+}
+function missingRunHealth() {
+    return {
+        version: 'dv-run-health-v1',
+        status: 'invalid',
+        admitted: 0,
+        losses: [{
+                code: 'run-health-missing',
+                owner: 'harness',
+                impact: 'invalid',
+                count: 1,
+                caseIds: [],
+                obligationIds: [],
+                slotIds: [],
+                sides: [],
+            }],
+    };
+}
 export function buildDesignVerifierAgentReport(run) {
     const repository = `${run.owner}/${run.repo}`;
     if (run.status !== 'succeeded' || !run.result) {
@@ -47,6 +95,7 @@ export function buildDesignVerifierAgentReport(run) {
             timings: null,
             changedFiles: [],
             cases: [],
+            runHealth: null,
             inspectCommand: `haystack design-verify ${repository}#${run.pr} --run ${run.runId}`,
             replay: null,
             error: run.error,
@@ -55,6 +104,7 @@ export function buildDesignVerifierAgentReport(run) {
     }
     const verdict = run.result.verdict || {};
     const summary = verdict.summary || {};
+    const runHealth = runHealthOf(verdict.runHealth) || missingRunHealth();
     const findings = Array.isArray(verdict.findings) ? verdict.findings : [];
     const confirmations = Array.isArray(verdict.confirmations) ? verdict.confirmations : [];
     const findingsByCase = new Map();
@@ -133,7 +183,19 @@ export function buildDesignVerifierAgentReport(run) {
     let headline;
     let explanation;
     let exitCode;
-    if (findings.length > 0) {
+    if (runHealth.status === 'invalid') {
+        agentVerdict = 'inconclusive';
+        headline = 'VERIFICATION INCONCLUSIVE';
+        explanation = 'No admissible evidence — this is not a pass.';
+        exitCode = 2;
+    }
+    else if (runHealth.status === 'degraded') {
+        agentVerdict = 'inconclusive';
+        headline = 'VERIFICATION INCONCLUSIVE';
+        explanation = 'Evidence losses degraded this run; inspect the loss table before drawing a conclusion.';
+        exitCode = 2;
+    }
+    else if (findings.length > 0) {
         agentVerdict = 'anomaly_candidate';
         headline = 'ANOMALY CANDIDATE';
         explanation = findingExplanation(String(findings[0]?.kind || ''));
@@ -171,6 +233,7 @@ export function buildDesignVerifierAgentReport(run) {
         timings: run.result.timings || null,
         changedFiles: run.result.changedFiles,
         cases,
+        runHealth,
         inspectCommand: `haystack design-verify ${repository}#${run.pr} --run ${run.runId}`,
         replay: run.result.replay,
         error: null,
@@ -243,6 +306,22 @@ export function formatDesignVerifierAgentReport(report) {
             lines.push(`  orchestration/finalization not recorded in a phase: ${preciseDurationLabel(report.timings.unattributedMs)}`);
         }
     }
+    if (report.runHealth && report.runHealth.status !== 'healthy') {
+        lines.push('', `Run health: ${report.runHealth.status}; admitted evidence: ${report.runHealth.admitted}`);
+        if (report.runHealth.losses.length > 0) {
+            lines.push('Evidence loss table:', '  owner   impact    count  loss / stable identifiers');
+            for (const loss of report.runHealth.losses) {
+                const identifiers = [
+                    ...loss.caseIds,
+                    ...loss.obligationIds,
+                    ...loss.slotIds,
+                    ...loss.sides,
+                ];
+                lines.push(`  ${loss.owner.padEnd(7)} ${loss.impact.padEnd(9)} ${String(loss.count).padStart(5)}  ` +
+                    `${loss.code}${identifiers.length ? `: ${identifiers.join(', ')}` : ''}`);
+            }
+        }
+    }
     for (const testCase of report.cases) {
         lines.push('', `Test: ${testCase.title}`);
         if (testCase.story)

package/dist/utils/git.js

@@ -386,7 +386,11 @@ function gitCommandOptions(options) {
 /** True if `ref` resolves to a commit in the current repo. */
 function gitRefResolves(ref, options = {}) {
     try {
-        execFileSync('git', ['rev-parse', '--verify', '--quiet', '--', `${ref}^{commit}`], {
+        // `--end-of-options`, not `--`: rev-parse treats everything after `--` as
+        // a pathspec, so `-- refs/remotes/origin/main^{commit}` exits 1 for every
+        // ref and the caller fell back to a bare local `main` (which a fresh clone
+        // does not have). Verified on git 2.39: `--` rc=1, `--end-of-options` rc=0.
+        execFileSync('git', ['rev-parse', '--verify', '--quiet', '--end-of-options', `${ref}^{commit}`], {
             ...gitCommandOptions(options),
         });
         return true;

package/dist/utils/telemetry.js

@@ -103,7 +103,10 @@ export function trackError(errorType, metadata) {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(event),
-        }).catch(() => { });
+        }).catch(() => {
+            // Documented fire-and-forget product telemetry: delivery cannot affect
+            // the CLI command being measured.
+        });
     }
     catch {
         // Telemetry must never crash the CLI
@@ -135,7 +138,10 @@ export function trackSetupEvent(step, metadata) {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(event),
-        }).catch(() => { });
+        }).catch(() => {
+            // Documented fire-and-forget product telemetry: delivery cannot affect
+            // the CLI command being measured.
+        });
     }
     catch {
         // Telemetry must never crash the CLI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haystackeditor/cli",
-  "version": "0.15.29",
+  "version": "0.15.31",
   "description": "Set up Haystack for your project — automated PR review, triage, and merge queue",
   "type": "module",
   "bin": {

package/schemas/cloud-verifier.v1.json

@@ -69,57 +69,99 @@
       "type": "string"
     },
     "result": {
+      "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "verdict",
+            "summary",
+            "casesTotal",
+            "casesFailed",
+            "regressions",
+            "outputLocation",
+            "wallSeconds"
+          ],
+          "properties": {
+            "verdict": {
+              "type": "string"
+            },
+            "summary": {
+              "type": "string"
+            },
+            "casesTotal": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "casesFailed": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "regressions": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": [
+                  "caseId",
+                  "title"
+                ],
+                "properties": {
+                  "caseId": {
+                    "type": "string"
+                  },
+                  "title": {
+                    "type": "string"
+                  }
+                }
+              }
+            },
+            "outputLocation": {
+              "type": "string"
+            },
+            "wallSeconds": {
+              "type": "number",
+              "minimum": 0
+            }
+          }
+        },
+        {
+          "type": "object",
+          "description": "Opaque VerifyResultV1 document, validated by the hosted service against the canonical P0 contract.",
+          "required": [
+            "version",
+            "provider"
+          ],
+          "properties": {
+            "version": {
+              "const": "dv-verify-result-v1"
+            },
+            "provider": {
+              "const": "haystack"
+            }
+          }
+        }
+      ]
+    },
+    "provider": {
+      "const": "haystack"
+    },
+    "version": {
+      "const": "dv-cloud-verifier-fleet-runner-projection-v1"
+    },
+    "progress": {
       "type": "object",
-      "additionalProperties": false,
+      "description": "Opaque VerifyProgressV1 document, validated by the hosted service against the canonical P0 contract.",
       "required": [
-        "verdict",
-        "summary",
-        "casesTotal",
-        "casesFailed",
-        "regressions",
-        "outputLocation",
-        "wallSeconds"
+        "version",
+        "publicRunId"
       ],
       "properties": {
-        "verdict": {
-          "type": "string"
+        "version": {
+          "const": "dv-verify-progress-v1"
         },
-        "summary": {
+        "publicRunId": {
           "type": "string"
-        },
-        "casesTotal": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "casesFailed": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "regressions": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": [
-              "caseId",
-              "title"
-            ],
-            "properties": {
-              "caseId": {
-                "type": "string"
-              },
-              "title": {
-                "type": "string"
-              }
-            }
-          }
-        },
-        "outputLocation": {
-          "type": "string"
-        },
-        "wallSeconds": {
-          "type": "number",
-          "minimum": 0
         }
       }
     }
@@ -157,6 +199,27 @@
           }
         ]
       }
+    },
+    {
+      "if": {
+        "properties": {
+          "provider": {
+            "const": "haystack"
+          }
+        },
+        "required": [
+          "provider"
+        ]
+      },
+      "then": {
+        "required": [
+          "version",
+          "repository",
+          "base_commit",
+          "head_commit",
+          "created_at"
+        ]
+      }
     }
   ]
 }