snipara-companion 3.2.27 → 3.2.29

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 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,
+  Cursor, VS Code/Continue, and generic HTTP MCP references through
+  `SNIPARA_SESSION_ID` / `X-Snipara-Session-Id`.
+- Prints the active correlation session during `init` and documents the
+  explicit `correlation_context.session_id` fallback for MCP clients that
+  cannot inject environment-backed headers.
+- Keeps the correlation identifier telemetry-only and project-scoped; it does
+  not alter authentication or authorization.
+
 ## New In 3.2.27
 
 - Scopes `context-control drift` dirty Git detection to the ProjectContext

package/README.md

@@ -49,6 +49,18 @@ Use this after `create-snipara` activation. `create-snipara` remains the
 canonical engine for first workspace setup; Companion owns the repeatable local
 continuity loop after that.
 
+## Retrieval And Outcome Correlation
+
+`snipara-companion init` creates and prints a bounded workspace session ID.
+Export it as `SNIPARA_SESSION_ID` before starting Codex, Claude, Cursor, VS Code,
+Continue, or another HTTP MCP client. Generated configs forward it as
+`X-Snipara-Session-Id`, while canonical execution events use the same Companion
+session automatically. Clients without environment-backed headers can pass the
+same value as `correlation_context.session_id` on retrieval tools.
+
+The identifier is opaque, project-scoped telemetry. It does not grant access or
+change authorization, and explicit per-call correlation remains authoritative.
+
 Example output excerpt:
 
 ```text
@@ -245,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

@@ -5641,6 +5641,7 @@ Claude Code should apply this workflow automatically for project-specific work;
 
 - Bound Snipara project: \`${projectSlug}\`
 - Hosted MCP endpoint: \`${buildHostedMcpEndpoint(projectSlug)}\`
+- Keep \`SNIPARA_SESSION_ID\` equal to the active Companion session. Generated MCP configs send it as \`X-Snipara-Session-Id\`; when a client cannot send that header, pass the same value as \`correlation_context.session_id\` on retrieval tools.
 - At the start of substantial work, validate the hosted MCP surface with a tool-oriented call, then use \`snipara_recall\` and a targeted \`snipara_context_query\` before falling back to local search.
 - Do not treat empty MCP resources/templates as an outage. If the tool surface looks incomplete, call \`snipara_help(list_all=true)\` and compare exact tool names.
 - Use \`snipara_context_query\` for docs, business context, architecture notes, runbooks, and source truth. Use \`snipara_get_chunk\` for exact cited sections when references are returned.
@@ -5660,6 +5661,7 @@ function buildSharedWorkflowInstructionBlock(projectSlug, client) {
 This workspace is bound to Snipara project \`${projectSlug}\` for ${formatClientName(client)}. Agents should use Snipara automatically for project-specific context, decisions, and workflow state.
 
 - Hosted MCP endpoint: \`${buildHostedMcpEndpoint(projectSlug)}\`
+- Keep \`SNIPARA_SESSION_ID\` equal to the active Companion session. Generated MCP configs send it as \`X-Snipara-Session-Id\`; when a client cannot send that header, pass the same value as \`correlation_context.session_id\` on retrieval tools.
 - At the start of substantial work, validate the hosted MCP surface with a tool-oriented call, then use \`snipara_recall\` and a targeted \`snipara_context_query\` before falling back to local search.
 - Do not treat empty MCP resources/templates as an outage. If the tool surface looks incomplete, call \`snipara_help(list_all=true)\` and compare exact tool names.
 - Use \`snipara_context_query\` for docs, business context, architecture notes, runbooks, and source truth. Use \`snipara_get_chunk\` for exact cited sections when references are returned.
@@ -5911,6 +5913,7 @@ function generateCodexConfigString(projectSlug) {
 type = "streamable_http"
 url = "https://api.snipara.com/mcp/${projectSlug}"
 bearer_token_env_var = "SNIPARA_API_KEY"
+env_http_headers = { "X-Snipara-Session-Id" = "SNIPARA_SESSION_ID" }
 `;
 }
 function generateGenericMcpReferenceString(client, projectSlug) {
@@ -5920,7 +5923,8 @@ function generateGenericMcpReferenceString(client, projectSlug) {
         name: "snipara",
         url: `https://api.snipara.com/mcp/${projectSlug}`,
         headers: {
-          "X-API-Key": "${SNIPARA_API_KEY}"
+          "X-API-Key": "${SNIPARA_API_KEY}",
+          "X-Snipara-Session-Id": "${SNIPARA_SESSION_ID}"
         }
       },
       null,
@@ -5935,7 +5939,8 @@ function generateGenericMcpReferenceString(client, projectSlug) {
           type: "http",
           url: `https://api.snipara.com/mcp/${projectSlug}`,
           headers: {
-            "X-API-Key": "${SNIPARA_API_KEY}"
+            "X-API-Key": "${SNIPARA_API_KEY}",
+            "X-Snipara-Session-Id": "${SNIPARA_SESSION_ID}"
           }
         }
       }
@@ -5995,6 +6000,7 @@ async function callSniparaTool(name: string, args: Record<string, unknown>): Pro
     headers: {
       "Content-Type": "application/json",
       "X-API-Key": SNIPARA_API_KEY,
+      "X-Snipara-Session-Id": process.env.SNIPARA_SESSION_ID || "",
     },
     body: JSON.stringify({
       jsonrpc: "2.0",
@@ -6561,12 +6567,13 @@ async function initCommand(options) {
     existingProjectId: existingConfig.projectId,
     selectedProject
   });
+  const sessionId = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
   saveConfig(
     {
       apiKey,
       apiUrl: existingConfig.apiUrl,
       projectId: projectIdentifier,
-      sessionId: `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      sessionId,
       client: selectedClient
     },
     { cwd: projectDir, scope: "workspace" }
@@ -6688,6 +6695,10 @@ async function initCommand(options) {
   console.log(`Companion config: ${configPaths.companion}`);
   console.log(`Selected project: ${formatProjectChoice(selectedProject)}`);
   console.log(`Selected client:  ${formatClientName(selectedClient)}`);
+  console.log(`Correlation session: ${sessionId}`);
+  console.log(
+    "Export SNIPARA_SESSION_ID with this value before starting the MCP client so served context and execution outcomes share one bounded session."
+  );
   if (options.withHooks) {
     console.log("\nNext steps:");
     if (hookClient === "cursor") {
@@ -21538,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(
@@ -21578,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 {
@@ -21605,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,
@@ -21804,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"));
@@ -33396,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));
 }
@@ -33523,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",
@@ -33547,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
@@ -821,6 +825,15 @@ Mistral generates MCP-first files (`MISTRAL.md`, Vibe config, Le Chat connector
 reference, and LangChain `ChatMistralAI.bindTools` snippets); Mistral request
 hooks are model request hooks, not local agent lifecycle hooks.
 
+All generated HTTP/SSE references include a bounded correlation header sourced
+from `SNIPARA_SESSION_ID`. Set it to the session printed by `init` before
+starting Codex, Claude, Cursor, VS Code/Continue, GLM, or another generic MCP
+host. The hosted server uses the header only for project-scoped retrieval
+telemetry and ignores invalid values. If the host cannot inject environment
+headers, pass the same value as `correlation_context.session_id` on
+`snipara_context_query`, `snipara_recall`, `snipara_search`, `snipara_ask`, and
+`snipara_get_chunk`.
+
 OpenClaw hooks remain separate:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snipara-companion",
-  "version": "3.2.27",
+  "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": {