snipara-companion 3.2.28 → 3.2.30

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 Release notes for `snipara-companion`, newest first.
 
+## New In 3.2.30
+
+- Persists an explicit `--ack-review-only` as a 15-minute, one-use
+  acknowledgement bound to the exact guard profile, action, and finding
+  fingerprint, so the immediately following Git hook can consume it safely.
+- Invalidates that acknowledgement when findings change and never applies it
+  to required acknowledgements, active conflicts, or hard blocks.
+- Resolves collaboration state from `SNIPARA_WORKSPACE_DIR` or the Git
+  top-level directory, preventing filtered package commands from writing a
+  nested `packages/cli/.snipara/` session.
+
+## 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

@@ -2831,6 +2831,7 @@ declare function buildCodingIntelligenceLedger(options?: CodingLedgerBuildOption
 declare function codingLedgerExportCommand(options: CodingLedgerExportCommandOptions): Promise<void>;
 
 declare const COLLABORATION_STATE_RELATIVE_PATH: string;
+type CollaborationGuardProfile = "edit" | "pre-commit" | "pre-push" | "pre-deploy" | "migration" | "schema" | "release-package";
 type CollaborationGuardActionKind = "safe_to_ack" | "needs_handoff" | "needs_test" | "needs_package_review" | "blocking_conflict" | "guard_unavailable";
 interface CollaborationGuardActionCard {
     kind: CollaborationGuardActionKind;
@@ -2910,6 +2911,13 @@ interface CollaborationLocalLeaseRecord {
     expiresAt?: string | null;
     workSessionId?: string;
 }
+interface CollaborationReviewOnlyAcknowledgement {
+    profile: CollaborationGuardProfile;
+    action: string;
+    findingFingerprint: string;
+    acknowledgedAt: string;
+    expiresAt: string;
+}
 interface CollaborationLocalState {
     schemaVersion: "snipara.collaboration.v1";
     updatedAt: string;
@@ -2926,6 +2934,7 @@ interface CollaborationLocalState {
     files: string[];
     resources: CollaborationResource[];
     leases: CollaborationLocalLeaseRecord[];
+    reviewOnlyAcknowledgements: CollaborationReviewOnlyAcknowledgement[];
     lastGuard?: {
         decision: CollaborationGuardDecision;
         severity: string;
@@ -3543,6 +3552,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 +3608,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

@@ -15400,6 +15400,7 @@ var DEFAULT_LOCAL_CODE_MAX_FILES = 2e3;
 var HOSTED_GUARD_MAX_FILES = 450;
 var HOSTED_GUARD_MAX_RESOURCES = 850;
 var HOSTED_GUARD_MAX_SYMBOL_RESOURCES = 160;
+var REVIEW_ONLY_ACK_TTL_MS = 15 * 60 * 1e3;
 var HOOK_BLOCK_PREFIX2 = "snipara:collaboration-guard";
 var CHECKOUT_GIT_WRITE_RESOURCE = {
   kind: "SURFACE",
@@ -15460,7 +15461,8 @@ function createEmptyCollaborationState(now = /* @__PURE__ */ new Date()) {
     updatedAt: now.toISOString(),
     files: [],
     resources: [],
-    leases: []
+    leases: [],
+    reviewOnlyAcknowledgements: []
   };
 }
 function getCollaborationStatePath(rootDir = process.cwd()) {
@@ -15493,13 +15495,18 @@ function loadCollaborationState(rootDir = process.cwd()) {
     files: normalizeFiles(parsed.files),
     resources: normalizeResources(parsed.resources),
     leases: normalizeLocalLeases(parsed.leases),
+    reviewOnlyAcknowledgements: normalizeReviewOnlyAcknowledgements(
+      parsed.reviewOnlyAcknowledgements
+    ),
     lastGuard: normalizeLastGuard(parsed.lastGuard)
   };
   expireLocalLeases(state);
+  expireReviewOnlyAcknowledgements(state);
   return state;
 }
 function saveCollaborationState(state, rootDir = process.cwd()) {
   expireLocalLeases(state);
+  expireReviewOnlyAcknowledgements(state);
   const statePath = getCollaborationStatePath(rootDir);
   fs20.mkdirSync(path19.dirname(statePath), { recursive: true });
   const tempPath = `${statePath}.${process.pid}.${Date.now()}.tmp`;
@@ -15814,13 +15821,14 @@ async function collaborationGuardCommand(options) {
   const context = resolveCollaborationContext(options);
   const state = loadCollaborationState(context.rootDir);
   const profile = normalizeGuardProfile(options.profile) ?? "edit";
+  const action = normalizeOptionalString3(options.action) ?? profile;
   const files = resolveGuardFiles(context, options, profile);
   const resources = resolveCommandResources(context, files, options, profile);
   ensureFilesOrResources(files, resources, "guard");
   const hostedPayload = buildHostedGuardPayload(files, resources);
   const hosted = await maybeEvaluateHostedGuard(context, {
     workSessionId: options.workSessionId ?? state.workSessionId,
-    action: normalizeOptionalString3(options.action) ?? profile,
+    action,
     files: hostedPayload.files,
     resources: hostedPayload.resources,
     persist: options.persist !== false
@@ -15832,26 +15840,39 @@ async function collaborationGuardCommand(options) {
       decision: evaluation.decision,
       severity: evaluation.severity,
       checkedAt: evaluation.evaluatedAt,
-      action: normalizeOptionalString3(options.action) ?? profile,
+      action,
       resources: evaluation.resources,
       conflictCount: evaluation.conflicts.length
     };
     state.files = mergeStrings(state.files, files);
     state.resources = mergeResources(state.resources, evaluation.resources);
+  }
+  const explicitReviewOnlyAck = Boolean(options.enforce) && Boolean(options.ackReviewOnly) && isReviewOnlyGuardEvaluation(evaluation);
+  const findingFingerprint = evaluation && isReviewOnlyGuardEvaluation(evaluation) ? fingerprintReviewOnlyGuardEvaluation(evaluation) : void 0;
+  const persistedReviewOnlyAck = Boolean(options.enforce) && !options.ackReviewOnly && Boolean(
+    findingFingerprint && consumeReviewOnlyAcknowledgement(state, profile, action, findingFingerprint)
+  );
+  if (explicitReviewOnlyAck && findingFingerprint) {
+    persistReviewOnlyAcknowledgement(state, profile, action, findingFingerprint);
+  } else if (evaluation && !persistedReviewOnlyAck) {
+    invalidateReviewOnlyAcknowledgements(state, profile, action);
+  }
+  const reviewOnlyAcknowledged = explicitReviewOnlyAck || persistedReviewOnlyAck;
+  const ackSource = explicitReviewOnlyAck ? "explicit" : persistedReviewOnlyAck ? "persisted" : "none";
+  if (evaluation) {
     saveCollaborationState(state, context.rootDir);
   }
-  const reviewOnlyAcknowledged = Boolean(options.enforce) && Boolean(options.ackReviewOnly) && isReviewOnlyGuardEvaluation(evaluation);
   const actionCards = buildCollaborationGuardActionCards(evaluation, {
     profile,
     enforced: Boolean(options.enforce),
-    ackReviewOnly: Boolean(options.ackReviewOnly),
+    ackReviewOnly: reviewOnlyAcknowledged,
     reviewOnlyAcknowledged
   });
   const guardFailed = shouldFailCollaborationGuard({
     hostedStatus: hosted.status,
     evaluation,
     enforce: Boolean(options.enforce),
-    ackReviewOnly: Boolean(options.ackReviewOnly)
+    ackReviewOnly: reviewOnlyAcknowledged
   });
   if (guardFailed) {
     process.exitCode = 2;
@@ -15867,6 +15888,7 @@ async function collaborationGuardCommand(options) {
         enforced: Boolean(options.enforce),
         ackReviewOnly: Boolean(options.ackReviewOnly),
         reviewOnlyAcknowledged,
+        ackSource,
         failed: guardFailed
       }
     },
@@ -16036,7 +16058,8 @@ async function collaborationIdeStatusCommand(options) {
   console.log(`Active leases: ${payload.hosted.activeLeases.length}`);
 }
 function resolveCollaborationContext(options) {
-  const rootDir = path19.resolve(options.dir ?? process.cwd());
+  const requestedDir = normalizeOptionalString3(options.dir) ?? normalizeOptionalString3(process.env.SNIPARA_WORKSPACE_DIR) ?? process.cwd();
+  const rootDir = resolveRepoRoot3(requestedDir);
   const config = loadConfig({ cwd: rootDir });
   const actor = buildCollaborationActor(options, config);
   return {
@@ -17138,6 +17161,68 @@ function normalizeLocalLeases(value) {
     return lease;
   }).filter((item) => Boolean(item));
 }
+function normalizeReviewOnlyAcknowledgements(value, now = /* @__PURE__ */ new Date()) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const nowMs = now.getTime();
+  return value.map((item) => {
+    const parsed = item;
+    const profile = normalizeGuardProfile(parsed.profile);
+    const action = normalizeOptionalString3(parsed.action);
+    const findingFingerprint = normalizeOptionalString3(parsed.findingFingerprint);
+    const acknowledgedAt = normalizeOptionalString3(parsed.acknowledgedAt);
+    const expiresAt = normalizeOptionalString3(parsed.expiresAt);
+    if (!profile || !action || !findingFingerprint || !acknowledgedAt || !expiresAt || !Number.isFinite(Date.parse(expiresAt)) || Date.parse(expiresAt) <= nowMs) {
+      return null;
+    }
+    return { profile, action, findingFingerprint, acknowledgedAt, expiresAt };
+  }).filter((item) => Boolean(item));
+}
+function expireReviewOnlyAcknowledgements(state, now = /* @__PURE__ */ new Date()) {
+  state.reviewOnlyAcknowledgements = normalizeReviewOnlyAcknowledgements(
+    state.reviewOnlyAcknowledgements,
+    now
+  );
+}
+function fingerprintReviewOnlyGuardEvaluation(evaluation) {
+  const findings = evaluation.conflicts.map((conflict) => ({
+    code: conflict.code,
+    decision: conflict.decision,
+    severity: conflict.severity,
+    resource: `${conflict.resource.kind}:${conflict.resource.id}`,
+    actor: conflict.conflictingActor ? `${conflict.conflictingActor.actorType}:${conflict.conflictingActor.actorId}` : null,
+    workSessionId: conflict.workSessionId ?? null,
+    reason: conflict.reason
+  })).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+  return (0, import_node_crypto6.createHash)("sha256").update(JSON.stringify(findings)).digest("hex");
+}
+function persistReviewOnlyAcknowledgement(state, profile, action, findingFingerprint, now = /* @__PURE__ */ new Date()) {
+  invalidateReviewOnlyAcknowledgements(state, profile, action);
+  state.reviewOnlyAcknowledgements.push({
+    profile,
+    action,
+    findingFingerprint,
+    acknowledgedAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + REVIEW_ONLY_ACK_TTL_MS).toISOString()
+  });
+}
+function consumeReviewOnlyAcknowledgement(state, profile, action, findingFingerprint) {
+  expireReviewOnlyAcknowledgements(state);
+  const index = state.reviewOnlyAcknowledgements.findIndex(
+    (ack) => ack.profile === profile && ack.action === action && ack.findingFingerprint === findingFingerprint
+  );
+  if (index < 0) {
+    return false;
+  }
+  state.reviewOnlyAcknowledgements.splice(index, 1);
+  return true;
+}
+function invalidateReviewOnlyAcknowledgements(state, profile, action) {
+  state.reviewOnlyAcknowledgements = state.reviewOnlyAcknowledgements.filter(
+    (ack) => ack.profile !== profile || ack.action !== action
+  );
+}
 function normalizeLastGuard(value) {
   const parsed = value;
   if (!parsed || !parsed.decision || !parsed.checkedAt) {
@@ -21549,6 +21634,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 +21822,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 +21853,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 +22059,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 +33664,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 +33791,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 +33815,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)
   );
@@ -37325,7 +37582,7 @@ collaboration.command("guard").description("Check files or resources against act
   "edit"
 ).option("-a, --action <action>", "Guarded action label", "edit").option("--actor <actor>", "Developer or agent display name").option("--actor-id <actorId>", "Stable developer or agent id").option("--actor-type <actorType>", "HUMAN|AGENT|SYSTEM", "AGENT").option("--session-id <sessionId>", "Automation/session id").option("--work-session-id <workSessionId>", "Existing hosted work session id").option("--client <client>", "Client label", "snipara-companion").option("--repository <repository>", "Repository id").option("-b, --branch <branch>", "Current branch name").option("--worktree <worktree>", "Worktree path").option("--max-files <number>", "Maximum files for local code resource expansion", "2000").option("--no-persist", "Evaluate without storing a guard event").option("--enforce", "Exit non-zero for REVIEW_REQUIRED or REQUIRES_ACK, not only BLOCKED").option(
   "--ack-review-only",
-  "Under --enforce, acknowledge review-only stale-state and decision-consistency warnings"
+  "Under --enforce, persist one exact review-only acknowledgement for the next hook rerun"
 ).option("-d, --dir <directory>", "Repository directory (default: current)").option("--json", "Print raw JSON").option("--verbose", "Print the full guard report even when the guard passes").action(async (options) => {
   await collaborationGuardCommand({
     files: options.files,

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.30",
   "description": "Local-first CLI that asks your repo what breaks before an AI coding agent edits it.",
   "main": "dist/index.js",
   "bin": {