snipara-companion 3.1.0 → 3.1.1

package/README.md

@@ -94,8 +94,10 @@ sample from `sample_unreviewed` to `sample_reviewed` or `sample_rejected`.
 For conversational human review, run `workflow producer-triage` to create a
 batched Decision Request V0 artifact, `workflow decisions --json` to give the
 LLM client the exact question/evidence/options to ask, and `workflow decide`
-only after the human answers. Decision requests never resolve by timeout or
-default, and only `workflow decide` applies the existing `producer-review` path.
+only after the human answers. Batched requests include readable evidence items
+with artifact summaries, statuses, file hints, and metadata instead of only
+opaque refs. Decision requests never resolve by timeout or default, and only
+`workflow decide` applies the existing `producer-review` path.
 Other producers such as `outcome-capture preview --emit-decisions`,
 `workflow decision-producer memory`, and `workflow decision-producer context-risk`
 emit requests with their existing apply paths declared; they do not write

package/dist/index.d.ts

@@ -2814,7 +2814,9 @@ interface ProducerLoopArtifactReportSummary {
     producerKind: ProducerLoopProducerKind;
     workflowId?: string;
     phaseId?: string;
+    phaseTitle?: string;
     outcome?: TaskCommitOutcome;
+    summary?: string;
     path: string;
     relativePath: string;
     artifactHash: string;

package/dist/index.js

@@ -12533,6 +12533,7 @@ function buildDecisionRequest(input) {
     evidence: {
       summary: input.evidence.summary,
       refs: uniqueStrings8(input.evidence.refs),
+      ...input.evidence.items ? { items: normalizeEvidenceItems(input.evidence.items) } : {},
       reasonCodes: uniqueStrings8(input.evidence.reasonCodes),
       ...input.evidence.files ? { files: uniqueStrings8(input.evidence.files) } : {},
       ...input.evidence.applyPath ? { applyPath: input.evidence.applyPath } : {},
@@ -12595,6 +12596,30 @@ function uniqueStrings8(values) {
   }
   return result;
 }
+function normalizeEvidenceItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const item of items) {
+    const ref = item.ref.trim();
+    if (!ref || seen.has(ref)) continue;
+    seen.add(ref);
+    normalized.push({
+      ref,
+      ...normalizeOptionalString(item.title) ? { title: normalizeOptionalString(item.title) } : {},
+      ...normalizeOptionalString(item.summary) ? { summary: normalizeOptionalString(item.summary) } : {},
+      ...normalizeOptionalString(item.kind) ? { kind: normalizeOptionalString(item.kind) } : {},
+      ...normalizeOptionalString(item.status) ? { status: normalizeOptionalString(item.status) } : {},
+      ...item.files ? { files: uniqueStrings8(item.files) } : {},
+      ...item.metadata ? { metadata: normalizeMetadata(item.metadata) } : {}
+    });
+  }
+  return normalized;
+}
+function normalizeMetadata(metadata) {
+  return Object.fromEntries(
+    Object.entries(metadata).filter(([, value]) => value !== void 0).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
 function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -16025,6 +16050,7 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
       );
     }
     const producer = isRecord8(parsed.producer) ? parsed.producer : void 0;
+    const source2 = isRecord8(parsed.source) ? parsed.source : void 0;
     const ledger = isRecord8(parsed.ledger) ? parsed.ledger : void 0;
     const calibration = isRecord8(parsed.calibration) ? parsed.calibration : void 0;
     const review = isRecord8(parsed.review) ? parsed.review : void 0;
@@ -16051,7 +16077,9 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
         producerKind,
         workflowId: stringValue5(producer.workflowId),
         phaseId: stringValue5(producer.phaseId),
+        phaseTitle: stringValue5(producer.phaseTitle),
         outcome: isTaskCommitOutcome(outcome) ? outcome : void 0,
+        summary: stringValue5(source2?.summary),
         path: filePath,
         relativePath: relativePath2,
         artifactHash: `sha256:${hashContent(content)}`,
@@ -16422,6 +16450,23 @@ function printDecisionRequests(entries) {
       console.log(`  recommendation: ${request.recommendation}`);
     }
     console.log(`  evidence: ${request.evidence.summary}`);
+    if (request.evidence.items?.length) {
+      console.log("  items:");
+      for (const item of request.evidence.items) {
+        console.log(`    - ${item.ref}${item.title ? `: ${item.title}` : ""}`);
+        if (item.status || item.kind) {
+          console.log(`      ${[item.kind, item.status].filter(Boolean).join(" | ")}`);
+        }
+        if (item.summary) {
+          console.log(`      ${item.summary}`);
+        }
+        if (item.files?.length) {
+          console.log(
+            `      files: ${item.files.slice(0, 5).join(", ")}${item.files.length > 5 ? ` (+${item.files.length - 5})` : ""}`
+          );
+        }
+      }
+    }
     if (request.evidence.applyCommand) {
       console.log(`  apply: ${request.evidence.applyCommand}`);
     }
@@ -16531,6 +16576,23 @@ function buildProducerTriageRequest(report) {
     return null;
   }
   const refs = candidates.map((artifact) => artifact.artifactId);
+  const items = candidates.map((artifact) => ({
+    ref: artifact.artifactId,
+    title: producerLoopTriageItemTitle(artifact),
+    summary: artifact.summary ?? `${artifact.producerKind} sample for review.`,
+    kind: artifact.producerKind,
+    status: artifact.reviewStatus,
+    files: artifact.files.slice(0, 12),
+    metadata: {
+      generatedAt: artifact.generatedAt,
+      workflowId: artifact.workflowId ?? null,
+      phaseId: artifact.phaseId ?? null,
+      outcome: artifact.outcome ?? null,
+      artifactHash: artifact.artifactHash,
+      ledgerHash: artifact.ledgerHash ?? null,
+      relativePath: artifact.relativePath
+    }
+  }));
   return buildDecisionRequest({
     producer: {
       kind: "producer_loop_triage",
@@ -16542,6 +16604,7 @@ function buildProducerTriageRequest(report) {
     evidence: {
       summary: `${candidates.length} unreviewed Producer Loop samples; ${report.invalidArtifacts.length} invalid artifacts; hardGateReady remains false.`,
       refs,
+      items,
       reasonCodes: uniqueStrings10([
         "triage_rules_v0",
         "producer_loop_report_valid",
@@ -16561,6 +16624,11 @@ function buildProducerTriageRequest(report) {
     ]
   });
 }
+function producerLoopTriageItemTitle(artifact) {
+  const workflow2 = artifact.workflowId ?? "producer-loop";
+  const phase = artifact.phaseTitle ?? artifact.phaseId;
+  return phase ? `${workflow2} / ${phase}` : workflow2;
+}
 async function workflowProducerTriageCommand(options) {
   const report = buildProducerLoopReport({ minReviewSampleSize: options.minReviewSamples });
   const request = buildProducerTriageRequest(report);

package/docs/FULL_REFERENCE.md

@@ -222,7 +222,8 @@ snipara-companion workflow resume --include-session-context
   It never marks samples reviewed by itself.
 - `workflow decisions` lists pending decision requests in a compact shape an LLM
   client can render as a human question, including evidence, options,
-  recommendation, and declared apply path.
+  recommendation, declared apply path, and readable evidence items for batched
+  decisions.
 - `workflow decide <request-id> --choose <option> --reviewer <name>` writes a
   Decision Response V0 receipt under `.snipara/decisions/resolved/`. For
   Producer Loop triage accept/reject choices, it applies the existing

package/package.json

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