snipara-companion 3.2.28 → 3.2.29

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 Release notes for `snipara-companion`, newest first.
 
+## New In 3.2.29
+
+- Extends `workflow producer-report` with attributed gated-execution samples
+  joined to their persisted supervisor reviews.
+- Adds per-`workerId`/`workCategory` `workerTrust` breakdowns with execution,
+  review, accepted, blocked, incomplete receipt-family, and workflow fingerprint
+  counts.
+- Keeps the read model deliberately supervised: every pair remains
+  `probation_supervised`, `hardGateReady=false`, and lists the evidence still
+  required before the separate Trust Promotion gates can be implemented.
+
 ## New In 3.2.28
 
 - Adds bounded Outcome Loop retrieval correlation to generated Codex, Claude,

package/README.md

@@ -257,7 +257,11 @@ redacted Coding Intelligence Ledger, not automatic durable memory, worker
 execution, calibrated confidence, or server-side attestation. Use
 `workflow producer-report` to inspect local adoption, reason-code counts, sample
 size, reviewed/rejected/unreviewed counts, invalid artifacts, and calibration
-caveats before any future hard gate.
+caveats before any future hard gate. The report also joins attributed gated
+receipts from `.snipara/orchestrator/executions/` with persisted supervisor
+reviews, then emits `workerReceipts` and a per-`workerId`/`workCategory`
+`workerTrust` breakdown. This is observability only: every pair remains
+`probation_supervised` and `hardGateReady=false`.
 The report also recognizes exported PR Answer Pack decision-capture artifacts
 with producer kind `pr_answer_pack_decision_capture`, so calibration can track
 more than the workflow producer once those artifacts are present locally.

package/dist/index.d.ts

@@ -3543,6 +3543,39 @@ interface ProducerLoopArtifactReportSummary {
     reviewedAt?: string;
     reviewer?: string;
 }
+interface WorkerExecutionReceiptReportSummary {
+    receiptId: string;
+    schemaVersion: string;
+    recordedAt?: string;
+    workerId: string;
+    workCategory: string;
+    routingCardRef?: string;
+    workflowFingerprint?: string;
+    executionActor: string;
+    status?: string;
+    reviewStatus: "review_pending" | "accepted" | "blocked";
+    executed: boolean;
+    receiptFamilyComplete: boolean;
+    missingReceiptFamilies: string[];
+    path: string;
+    relativePath: string;
+    reviewPath?: string;
+    reviewRelativePath?: string;
+}
+interface WorkerTrustReportRow {
+    workerId: string;
+    workCategory: string;
+    state: "probation_supervised";
+    sampleSize: number;
+    executedSampleSize: number;
+    reviewedSampleSize: number;
+    verifiedSampleSize: number;
+    blockedSampleSize: number;
+    incompleteReceiptSampleSize: number;
+    workflowFingerprints: string[];
+    hardGateReady: false;
+    nextRequired: string[];
+}
 interface ProducerLoopReport {
     version: typeof PRODUCER_LOOP_REPORT_VERSION;
     generatedAt: string;
@@ -3566,6 +3599,17 @@ interface ProducerLoopReport {
     reasonCodes: {
         counts: Record<string, number>;
     };
+    workerReceipts: {
+        sourceDirectories: string[];
+        sampleSize: number;
+        samples: WorkerExecutionReceiptReportSummary[];
+        invalidArtifacts: Array<{
+            path: string;
+            relativePath: string;
+            error: string;
+        }>;
+    };
+    workerTrust: WorkerTrustReportRow[];
     calibration: {
         status: "no_samples" | "insufficient_samples" | "reviewable_sample_set";
         sampleSize: number;

package/dist/index.js

@@ -21549,6 +21549,154 @@ function producerLoopCalibrationStatus(sampleSize, reviewedSampleSize, minReview
   }
   return "reviewable_sample_set";
 }
+var WORKER_RECEIPT_RELATIVE_DIR = path22.join(".snipara", "orchestrator", "executions");
+var WORKER_REVIEW_RELATIVE_DIR = path22.join(".snipara", "orchestrator", "reviews");
+var REQUIRED_WORKER_RECEIPT_FAMILIES = [
+  "handoffReceiptId",
+  "claimId",
+  "proofReceiptIds",
+  "outcomeReceiptId",
+  "brainUpdateReceiptId"
+];
+function listJsonFiles(relativeDir, cwd) {
+  const directory = path22.join(cwd, relativeDir);
+  if (!fs23.existsSync(directory)) {
+    return [];
+  }
+  return fs23.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path22.join(directory, entry.name)).sort();
+}
+function readWorkerReviewFiles(cwd) {
+  const reviews = /* @__PURE__ */ new Map();
+  const invalid = [];
+  for (const filePath of listJsonFiles(WORKER_REVIEW_RELATIVE_DIR, cwd)) {
+    try {
+      const parsed = JSON.parse(fs23.readFileSync(filePath, "utf-8"));
+      if (!isRecord10(parsed)) {
+        throw new Error("review must be a JSON object");
+      }
+      const receiptId = stringValue7(parsed.receiptId);
+      if (!receiptId) {
+        throw new Error("review is missing receiptId");
+      }
+      reviews.set(receiptId, { value: parsed, path: filePath });
+    } catch (error) {
+      invalid.push({
+        path: filePath,
+        relativePath: toProjectRelativePath3(filePath, cwd),
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { reviews, invalid };
+}
+function missingWorkerReceiptFamilies(receipt) {
+  const refs = isRecord10(receipt.receiptRefs) ? receipt.receiptRefs : isRecord10(receipt.receipt) ? receipt.receipt : {};
+  return REQUIRED_WORKER_RECEIPT_FAMILIES.filter((family) => {
+    const value = refs[family];
+    return family === "proofReceiptIds" ? !Array.isArray(value) || value.filter((item) => Boolean(stringValue7(item))).length === 0 : !stringValue7(value);
+  });
+}
+function summarizeWorkerExecutionReceipts(cwd) {
+  const reviewFiles = readWorkerReviewFiles(cwd);
+  const invalid = [...reviewFiles.invalid];
+  const samples = [];
+  for (const filePath of listJsonFiles(WORKER_RECEIPT_RELATIVE_DIR, cwd)) {
+    try {
+      const parsed = JSON.parse(fs23.readFileSync(filePath, "utf-8"));
+      if (!isRecord10(parsed)) {
+        throw new Error("receipt must be a JSON object");
+      }
+      const receiptId = stringValue7(parsed.receiptId);
+      const schemaVersion = stringValue7(parsed.schemaVersion);
+      if (!receiptId || !schemaVersion) {
+        throw new Error("receipt is missing receiptId or schemaVersion");
+      }
+      const attribution = isRecord10(parsed.workerAttribution) ? parsed.workerAttribution : {};
+      const gate2 = isRecord10(parsed.gate) ? parsed.gate : {};
+      const review = reviewFiles.reviews.get(receiptId);
+      const reviewStatusValue = stringValue7(review?.value.reviewStatus);
+      const reviewStatus = reviewStatusValue === "accepted" ? "accepted" : reviewStatusValue === "blocked" ? "blocked" : "review_pending";
+      const workerId = stringValue7(parsed.workerId) ?? stringValue7(attribution.workerId) ?? stringValue7(parsed.selectedWorkerCandidateId) ?? stringValue7(gate2.selectedWorkerCandidateId) ?? "main_agent";
+      const workCategory = stringValue7(parsed.workCategory) ?? stringValue7(attribution.workCategory) ?? "unknown";
+      const executionActor = stringValue7(parsed.executionActor) ?? stringValue7(attribution.executionActor) ?? (Number(parsed.workersSpawned ?? 0) > 0 ? "worker" : "main_agent");
+      const missingReceiptFamilies = missingWorkerReceiptFamilies(parsed);
+      samples.push({
+        receiptId,
+        schemaVersion,
+        recordedAt: stringValue7(parsed.recordedAt),
+        workerId,
+        workCategory,
+        routingCardRef: stringValue7(parsed.routingCardRef) ?? stringValue7(attribution.routingCardRef),
+        workflowFingerprint: stringValue7(parsed.workflowFingerprint) ?? stringValue7(attribution.workflowFingerprint),
+        executionActor,
+        status: stringValue7(parsed.status),
+        reviewStatus,
+        executed: executionActor === "worker" || Number(parsed.workersSpawned ?? 0) > 0,
+        receiptFamilyComplete: missingReceiptFamilies.length === 0,
+        missingReceiptFamilies,
+        path: filePath,
+        relativePath: toProjectRelativePath3(filePath, cwd),
+        ...review ? {
+          reviewPath: review.path,
+          reviewRelativePath: toProjectRelativePath3(review.path, cwd)
+        } : {}
+      });
+    } catch (error) {
+      invalid.push({
+        path: filePath,
+        relativePath: toProjectRelativePath3(filePath, cwd),
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  samples.sort(
+    (left, right) => (left.recordedAt ?? left.receiptId).localeCompare(right.recordedAt ?? right.receiptId)
+  );
+  return { samples, invalid };
+}
+function buildWorkerTrustRows(samples, minReviewSampleSize) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const sample of samples) {
+    const key = `${sample.workerId}\0${sample.workCategory}`;
+    grouped.set(key, [...grouped.get(key) ?? [], sample]);
+  }
+  return [...grouped.values()].map((group) => {
+    const reviewedSampleSize = group.filter(
+      (sample) => sample.reviewStatus !== "review_pending"
+    ).length;
+    const verifiedSampleSize = group.filter(
+      (sample) => sample.reviewStatus === "accepted"
+    ).length;
+    const incompleteReceiptSampleSize = group.filter(
+      (sample) => !sample.receiptFamilyComplete
+    ).length;
+    const nextRequired = [
+      reviewedSampleSize < minReviewSampleSize ? `${minReviewSampleSize - reviewedSampleSize} more supervised review sample(s)` : void 0,
+      verifiedSampleSize < 3 ? `${3 - verifiedSampleSize} more accepted verified sample(s)` : void 0,
+      incompleteReceiptSampleSize > 0 ? `${incompleteReceiptSampleSize} sample(s) need complete receipt families` : void 0,
+      group[0].workCategory === "unknown" ? "classify legacy samples by work category" : void 0,
+      "Trust Promotion gate implementation remains required"
+    ].filter((item) => Boolean(item));
+    return {
+      workerId: group[0].workerId,
+      workCategory: group[0].workCategory,
+      state: "probation_supervised",
+      sampleSize: group.length,
+      executedSampleSize: group.filter((sample) => sample.executed).length,
+      reviewedSampleSize,
+      verifiedSampleSize,
+      blockedSampleSize: group.filter((sample) => sample.reviewStatus === "blocked").length,
+      incompleteReceiptSampleSize,
+      workflowFingerprints: uniqueStrings18(
+        group.map((sample) => sample.workflowFingerprint).filter((value) => Boolean(value))
+      ),
+      hardGateReady: false,
+      nextRequired
+    };
+  }).sort(
+    (left, right) => left.workerId === right.workerId ? left.workCategory.localeCompare(right.workCategory) : left.workerId.localeCompare(right.workerId)
+  );
+}
 function buildProducerLoopReport(options = {}) {
   const cwd = path22.resolve(options.cwd ?? process.cwd());
   const minReviewSampleSize = Math.max(
@@ -21589,12 +21737,16 @@ function buildProducerLoopReport(options = {}) {
     reviewedSampleSize,
     minReviewSampleSize
   );
+  const workerReceiptReport = summarizeWorkerExecutionReceipts(cwd);
+  const workerTrust = buildWorkerTrustRows(workerReceiptReport.samples, minReviewSampleSize);
   const recommendedActions = [
     artifacts.length === 0 ? "Run a current Producer Loop producer, such as workflow phase-commit/final-commit or PR Answer Pack decision capture, to create samples." : void 0,
     artifacts.length > 0 && reviewedSampleSize < minReviewSampleSize ? `Review at least ${minReviewSampleSize} local Producer Loop samples before considering any calibration signal.` : void 0,
     unreviewedSampleSize > 0 ? "Mark local samples with workflow producer-review after checking the embedded evidence." : void 0,
     rejectedSampleSize > 0 ? "Inspect rejected Producer Loop samples for false positives, missing context, or reason-code drift." : void 0,
     invalidArtifacts.length > 0 ? "Inspect invalid Producer Loop artifacts before trusting adoption counts." : void 0,
+    workerReceiptReport.samples.length === 0 ? "Run agents execute-gated and persist agents review-gated results to create worker-attributed receipt samples." : void 0,
+    workerReceiptReport.invalid.length > 0 ? "Inspect invalid worker execution receipts or reviews before trusting per-worker counts." : void 0,
     "Review false positives, missing outcomes, and reason-code drift before any future enforcement."
   ].filter((item) => Boolean(item));
   return {
@@ -21616,6 +21768,13 @@ function buildProducerLoopReport(options = {}) {
     reasonCodes: {
       counts: reasonCodeCounts
     },
+    workerReceipts: {
+      sourceDirectories: [WORKER_RECEIPT_RELATIVE_DIR, WORKER_REVIEW_RELATIVE_DIR],
+      sampleSize: workerReceiptReport.samples.length,
+      samples: workerReceiptReport.samples,
+      invalidArtifacts: workerReceiptReport.invalid
+    },
+    workerTrust,
     calibration: {
       status: calibrationStatus,
       sampleSize: artifacts.length,
@@ -21815,6 +21974,19 @@ function printProducerLoopReport(report) {
   if (report.invalidArtifacts.length > 0) {
     printKeyValue2("Invalid artifacts:", report.invalidArtifacts.length);
   }
+  printKeyValue2("Worker receipts:", report.workerReceipts.sampleSize);
+  if (report.workerReceipts.invalidArtifacts.length > 0) {
+    printKeyValue2("Invalid worker evidence:", report.workerReceipts.invalidArtifacts.length);
+  }
+  if (report.workerTrust.length > 0) {
+    console.log("");
+    console.log(import_chalk6.default.bold("Worker Trust (supervised probation)"));
+    for (const row of report.workerTrust) {
+      console.log(
+        `- ${row.workerId} / ${row.workCategory}: ${row.verifiedSampleSize} accepted, ${row.blockedSampleSize} blocked, ${row.reviewedSampleSize}/${row.sampleSize} reviewed`
+      );
+    }
+  }
   if (report.recommendedActions.length > 0) {
     console.log("");
     console.log(import_chalk6.default.bold("Recommended Actions"));
@@ -33407,7 +33579,7 @@ function applyLocalContextMutationPlan(options) {
     writtenFiles
   };
 }
-function listJsonFiles(dir) {
+function listJsonFiles2(dir) {
   if (!fs30.existsSync(dir)) return [];
   return fs30.readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => path30.join(dir, name)).sort((left, right) => left.localeCompare(right));
 }
@@ -33534,7 +33706,7 @@ function collectWorkflowDriftSignals(cwd) {
 }
 function collectDecisionDriftSignals(cwd) {
   const pendingDir = path30.join(cwd, ".snipara", "decisions", "pending");
-  const pending = listJsonFiles(pendingDir).map((file) => toProjectRelativePath4(file, cwd));
+  const pending = listJsonFiles2(pendingDir).map((file) => toProjectRelativePath4(file, cwd));
   return [
     pending.length > 0 ? {
       id: "decision-requests-pending",
@@ -33558,8 +33730,8 @@ function collectDecisionDriftSignals(cwd) {
   ];
 }
 function collectContextControlDriftSignals(cwd) {
-  const planFiles = listJsonFiles(path30.join(cwd, CONTEXT_CONTROL_PLANS_RELATIVE_DIR));
-  const receiptFiles = listJsonFiles(path30.join(cwd, CONTEXT_CONTROL_APPLIED_RELATIVE_DIR));
+  const planFiles = listJsonFiles2(path30.join(cwd, CONTEXT_CONTROL_PLANS_RELATIVE_DIR));
+  const receiptFiles = listJsonFiles2(path30.join(cwd, CONTEXT_CONTROL_APPLIED_RELATIVE_DIR));
   const receiptPlanHashes = new Set(
     receiptFiles.map((file) => readJsonFileSafe(file).value).filter(isContextMutationApplyReceipt).map((receipt) => receipt.planHash)
   );

package/docs/FULL_REFERENCE.md

@@ -324,7 +324,11 @@ snipara-companion workflow resume --include-session-context
   workflow phase/final commits or exported PR Answer Pack decision-capture
   producers, then reports adoption, producer kinds, workflow ids, reason-code
   counts, invalid artifacts, sample size, reviewed/rejected/unreviewed counts,
-  and calibration caveats with `hardGateReady=false`.
+  and calibration caveats with `hardGateReady=false`. It also scans attributed
+  gated receipts and persisted reviews under `.snipara/orchestrator/`, reports
+  receipt-family completeness, and groups supervised evidence by
+  `(workerId, workCategory)` in `workerTrust`. It never promotes a worker or
+  changes an execution gate.
 - `workflow producer-review` marks one local Producer Loop artifact as
   `sample_reviewed` or `sample_rejected` after operator review. Use
   `--artifact <path|file|artifactId>` for an exact sample or `--latest` for the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snipara-companion",
-  "version": "3.2.28",
+  "version": "3.2.29",
   "description": "Local-first CLI that asks your repo what breaks before an AI coding agent edits it.",
   "main": "dist/index.js",
   "bin": {