snipara-companion 3.0.13 → 3.0.14

package/README.md

@@ -47,6 +47,7 @@ These commands are useful without hosted Snipara:
 | `code callers` / `imports` / `neighbors` / `shortest-path`   | Structural repo questions from local files                   |
 | `workflow start` / `phase-start` / `phase-commit` / `resume` | Agent continuity that survives compaction                    |
 | `workflow producer-report`                                   | Local Producer Loop adoption and calibration report          |
+| `workflow producer-review`                                   | Mark local Producer Loop samples reviewed or rejected        |
 | `context-pack`                                               | Reversible local packs for long logs, diffs, and tool output |
 | `judgment-card`, `verify`, `lead-plan`, `agent-readiness`    | Local review artifacts and delegation contracts              |
 | `intelligence ledger-export`                                 | Structured redacted ledger JSON for replay and review        |
@@ -64,6 +65,7 @@ npx -y snipara-companion lead-plan --from-plan ./project-health-lead-plan.json -
 npx -y snipara-companion lead-plan --from-plan ./project-health-lead-plan.json --json | jq '.engineeringLeadPlan.executionReceipts'
 npx -y snipara-companion workflow phase-commit audit --summary "mapped auth impact"
 npx -y snipara-companion workflow producer-report
+npx -y snipara-companion workflow producer-review --latest --outcome useful --reviewer alice
 npx -y snipara-companion handoff --summary "auth impact mapped" --next "run auth tests"
 ```
 
@@ -76,10 +78,14 @@ under `.snipara/producer-loop/`. These are local review evidence backed by the
 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, invalid artifacts, and calibration caveats before any future hard gate.
+size, reviewed/rejected/unreviewed counts, invalid artifacts, and calibration
+caveats before any future hard gate.
 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.
+Use `workflow producer-review --artifact <path|file|artifactId>` or
+`workflow producer-review --latest` after auditing embedded evidence to move a
+sample from `sample_unreviewed` to `sample_reviewed` or `sample_rejected`.
 
 ## Local First, Hosted When Useful
 

package/dist/index.d.ts

@@ -2795,6 +2795,7 @@ declare const PRODUCER_LOOP_ARTIFACT_VERSION: "snipara.producer_loop_artifact.v0
 declare const PRODUCER_LOOP_REPORT_VERSION: "snipara.producer_loop_report.v0";
 declare const PRODUCER_LOOP_RELATIVE_DIR: string;
 type ProducerLoopProducerKind = "workflow_phase_commit" | "workflow_final_commit" | "pr_answer_pack_decision_capture";
+type ProducerLoopSampleReviewStatus = "sample_unreviewed" | "sample_reviewed" | "sample_rejected";
 interface ProducerLoopArtifactWriteResult {
     status: "written" | "error";
     schemaVersion: typeof PRODUCER_LOOP_ARTIFACT_VERSION;
@@ -2820,6 +2821,10 @@ interface ProducerLoopArtifactReportSummary {
     reasonCodes: string[];
     files: string[];
     calibrationStatus?: string;
+    reviewStatus: ProducerLoopSampleReviewStatus;
+    reviewOutcome?: string;
+    reviewedAt?: string;
+    reviewer?: string;
 }
 interface ProducerLoopReport {
     version: typeof PRODUCER_LOOP_REPORT_VERSION;
@@ -2847,7 +2852,11 @@ interface ProducerLoopReport {
     calibration: {
         status: "no_samples" | "insufficient_samples" | "reviewable_sample_set";
         sampleSize: number;
+        reviewedSampleSize: number;
+        rejectedSampleSize: number;
+        unreviewedSampleSize: number;
         minReviewSampleSize: number;
+        reviewOutcomes: Record<string, number>;
         hardGateReady: false;
         notes: string[];
     };

package/dist/index.js

@@ -14605,6 +14605,16 @@ function countStringOccurrences(values) {
 function isProducerLoopProducerKind(value) {
   return value === "workflow_phase_commit" || value === "workflow_final_commit" || value === "pr_answer_pack_decision_capture";
 }
+function isProducerLoopSampleReviewStatus(value) {
+  return value === "sample_unreviewed" || value === "sample_reviewed" || value === "sample_rejected";
+}
+function normalizeProducerLoopSampleReviewStatus(value) {
+  const status = stringValue5(value);
+  return isProducerLoopSampleReviewStatus(status) ? status : "sample_unreviewed";
+}
+function isProducerLoopReviewOutcome(value) {
+  return value === "useful" || value === "false_positive" || value === "missing_context" || value === "unsafe" || value === "duplicate" || value === "other";
+}
 function isTaskCommitOutcome(value) {
   return ["completed", "partial", "blocked", "abandoned"].includes(value ?? "");
 }
@@ -14630,6 +14640,7 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
     const producer = isRecord7(parsed.producer) ? parsed.producer : void 0;
     const ledger = isRecord7(parsed.ledger) ? parsed.ledger : void 0;
     const calibration = isRecord7(parsed.calibration) ? parsed.calibration : void 0;
+    const review = isRecord7(parsed.review) ? parsed.review : void 0;
     if (!producer) {
       throw new Error("artifact is missing producer metadata");
     }
@@ -14643,6 +14654,9 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
       throw new Error("artifact is missing artifactId or generatedAt");
     }
     const outcome = stringValue5(producer.outcome);
+    const reviewStatus = normalizeProducerLoopSampleReviewStatus(
+      stringValue5(review?.status) ?? stringValue5(calibration?.status)
+    );
     return {
       artifact: {
         artifactId,
@@ -14657,7 +14671,11 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
         ledgerHash: stringValue5(parsed.ledgerHash),
         reasonCodes: uniqueStrings8(stringArrayValue(ledger?.reasonCodes)),
         files: uniqueStrings8(stringArrayValue(producer.files)),
-        calibrationStatus: stringValue5(calibration?.status)
+        calibrationStatus: stringValue5(calibration?.status),
+        reviewStatus,
+        reviewOutcome: stringValue5(review?.outcome),
+        reviewedAt: stringValue5(review?.reviewedAt),
+        reviewer: stringValue5(review?.reviewer)
       }
     };
   } catch (error) {
@@ -14677,11 +14695,11 @@ function listProducerLoopArtifactFiles(cwd) {
   }
   return fs19.readdirSync(dir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => path18.join(dir, fileName)).sort();
 }
-function producerLoopCalibrationStatus(sampleSize, minReviewSampleSize) {
+function producerLoopCalibrationStatus(sampleSize, reviewedSampleSize, minReviewSampleSize) {
   if (sampleSize === 0) {
     return "no_samples";
   }
-  if (sampleSize < minReviewSampleSize) {
+  if (reviewedSampleSize < minReviewSampleSize) {
     return "insufficient_samples";
   }
   return "reviewable_sample_set";
@@ -14709,10 +14727,28 @@ function buildProducerLoopReport(options = {}) {
     artifacts.flatMap((artifact) => artifact.reasonCodes)
   );
   const latestArtifact = artifacts[artifacts.length - 1];
-  const calibrationStatus = producerLoopCalibrationStatus(artifacts.length, minReviewSampleSize);
+  const reviewedSampleSize = artifacts.filter(
+    (artifact) => artifact.reviewStatus === "sample_reviewed"
+  ).length;
+  const rejectedSampleSize = artifacts.filter(
+    (artifact) => artifact.reviewStatus === "sample_rejected"
+  ).length;
+  const unreviewedSampleSize = artifacts.filter(
+    (artifact) => artifact.reviewStatus === "sample_unreviewed"
+  ).length;
+  const reviewOutcomes = countStringOccurrences(
+    artifacts.map((artifact) => artifact.reviewOutcome).filter((outcome) => Boolean(outcome))
+  );
+  const calibrationStatus = producerLoopCalibrationStatus(
+    artifacts.length,
+    reviewedSampleSize,
+    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 && artifacts.length < minReviewSampleSize ? `Collect and review at least ${minReviewSampleSize} local workflow samples before considering any hard gate.` : 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,
     "Review false positives, missing outcomes, and reason-code drift before any future enforcement."
   ].filter((item) => Boolean(item));
@@ -14738,11 +14774,16 @@ function buildProducerLoopReport(options = {}) {
     calibration: {
       status: calibrationStatus,
       sampleSize: artifacts.length,
+      reviewedSampleSize,
+      rejectedSampleSize,
+      unreviewedSampleSize,
       minReviewSampleSize,
+      reviewOutcomes,
       hardGateReady: false,
       notes: [
         "Producer Loop V0 reports local or exported producer samples only.",
-        "Samples are unreviewed unless an operator separately audits them.",
+        "Only samples marked sample_reviewed count toward calibration review size.",
+        "sample_rejected records operator review but does not count as positive calibration evidence.",
         "hardGateReady remains false in V0 even when enough samples exist."
       ]
     },
@@ -14754,11 +14795,171 @@ function buildProducerLoopReport(options = {}) {
     ]
   };
 }
+function resolveProducerLoopReviewTarget(cwd, selector, latest) {
+  const files = listProducerLoopArtifactFiles(cwd);
+  if (files.length === 0) {
+    throw new Error(`No Producer Loop artifacts found under ${PRODUCER_LOOP_RELATIVE_DIR}.`);
+  }
+  const normalizedSelector = selector?.trim();
+  if (!normalizedSelector) {
+    if (!latest) {
+      throw new Error("Pass --artifact <path|file|artifactId> or --latest.");
+    }
+    const summaries = files.map((filePath) => summarizeProducerLoopArtifactFile(filePath, cwd).artifact).filter((entry) => Boolean(entry)).sort(
+      (left, right) => left.generatedAt === right.generatedAt ? left.relativePath.localeCompare(right.relativePath) : left.generatedAt.localeCompare(right.generatedAt)
+    );
+    const latestArtifact = summaries[summaries.length - 1];
+    if (!latestArtifact) {
+      throw new Error("No valid Producer Loop artifacts found to review.");
+    }
+    return latestArtifact.path;
+  }
+  const directCandidates = [
+    path18.resolve(cwd, normalizedSelector),
+    path18.resolve(cwd, PRODUCER_LOOP_RELATIVE_DIR, normalizedSelector)
+  ];
+  const directMatch = directCandidates.find((candidate) => fs19.existsSync(candidate));
+  if (directMatch) {
+    return directMatch;
+  }
+  const normalizedPathSelector = normalizedSelector.replace(/\\/g, "/").replace(/^\.\//, "");
+  const matches = files.filter((filePath) => {
+    const relativePath2 = toProjectRelativePath(filePath, cwd).replace(/\\/g, "/");
+    const basename7 = path18.basename(filePath);
+    if (basename7 === normalizedSelector || relativePath2 === normalizedPathSelector || relativePath2.replace(/^\.\//, "") === normalizedPathSelector) {
+      return true;
+    }
+    try {
+      const parsed = JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+      return isRecord7(parsed) && stringValue5(parsed.artifactId) === normalizedSelector;
+    } catch {
+      return false;
+    }
+  });
+  if (matches.length === 0) {
+    throw new Error(`No Producer Loop artifact matched '${normalizedSelector}'.`);
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Producer Loop artifact selector '${normalizedSelector}' matched multiple files: ${matches.map((filePath) => toProjectRelativePath(filePath, cwd)).join(", ")}`
+    );
+  }
+  return matches[0];
+}
+function readProducerLoopArtifactForReview(filePath) {
+  const parsed = JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+  if (!isRecord7(parsed)) {
+    throw new Error("artifact must be a JSON object");
+  }
+  if (parsed.schemaVersion !== PRODUCER_LOOP_ARTIFACT_VERSION) {
+    throw new Error(
+      `unsupported schemaVersion '${stringValue5(parsed.schemaVersion) ?? "unknown"}'`
+    );
+  }
+  const artifactId = stringValue5(parsed.artifactId);
+  const generatedAt = stringValue5(parsed.generatedAt);
+  if (!artifactId || !generatedAt) {
+    throw new Error("artifact is missing artifactId or generatedAt");
+  }
+  if (!isRecord7(parsed.producer)) {
+    throw new Error("artifact is missing producer metadata");
+  }
+  const producerKind = stringValue5(parsed.producer.kind);
+  if (!isProducerLoopProducerKind(producerKind)) {
+    throw new Error(`unsupported producer kind '${producerKind ?? "unknown"}'`);
+  }
+  return parsed;
+}
+function applyProducerLoopArtifactReview(artifact, options) {
+  const reviewNotes = uniqueStrings8(options.notes ?? []);
+  const reviewNote = options.status === "sample_rejected" ? "Sample rejected by local operator review." : "Sample reviewed by local operator.";
+  const existingCalibration = artifact.calibration ?? {
+    status: "sample_unreviewed",
+    sampleSize: 1,
+    hardGateReady: false,
+    notes: []
+  };
+  return {
+    ...artifact,
+    calibration: {
+      ...existingCalibration,
+      status: options.status,
+      sampleSize: 1,
+      hardGateReady: false,
+      notes: uniqueStrings8([
+        ...stringArrayValue(existingCalibration.notes),
+        reviewNote,
+        ...reviewNotes.map((note) => `Review note: ${note}`)
+      ])
+    },
+    review: {
+      status: options.status,
+      reviewedAt: options.reviewedAt,
+      ...options.reviewer ? { reviewer: options.reviewer } : {},
+      ...options.outcome ? { outcome: options.outcome } : {},
+      notes: reviewNotes
+    }
+  };
+}
+function reviewProducerLoopArtifact(options) {
+  const cwd = path18.resolve(options.cwd ?? process.cwd());
+  const targetPath = resolveProducerLoopReviewTarget(cwd, options.artifact, options.latest);
+  const artifact = readProducerLoopArtifactForReview(targetPath);
+  const rawOutcome = stringValue5(options.outcome);
+  if (rawOutcome && !isProducerLoopReviewOutcome(rawOutcome)) {
+    throw new Error(
+      `Unsupported producer review outcome '${rawOutcome}'. Use useful, false_positive, missing_context, unsafe, duplicate, or other.`
+    );
+  }
+  const outcome = rawOutcome;
+  const status = options.reject ? "sample_rejected" : "sample_reviewed";
+  const reviewer = stringValue5(options.reviewer);
+  const reviewedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const reviewed = applyProducerLoopArtifactReview(artifact, {
+    status,
+    reviewedAt,
+    ...reviewer ? { reviewer } : {},
+    ...outcome ? { outcome } : {},
+    notes: options.notes ?? []
+  });
+  fs19.writeFileSync(targetPath, stableJsonStringify(reviewed), "utf-8");
+  const content = fs19.readFileSync(targetPath, "utf-8");
+  return {
+    status: "reviewed",
+    schemaVersion: PRODUCER_LOOP_ARTIFACT_VERSION,
+    artifactId: reviewed.artifactId,
+    path: targetPath,
+    relativePath: toProjectRelativePath(targetPath, cwd),
+    artifactHash: `sha256:${hashContent(content)}`,
+    ledgerHash: reviewed.ledgerHash,
+    review: reviewed.review,
+    calibration: {
+      status: reviewed.calibration.status,
+      hardGateReady: false
+    },
+    caveats: [
+      "Local operator review only; this is not server-side attestation.",
+      "Producer Loop V0 keeps hardGateReady=false after review."
+    ]
+  };
+}
+function printProducerLoopReviewResult(result) {
+  console.log(import_chalk6.default.bold("Producer Loop Review"));
+  printKeyValue2("Artifact:", result.relativePath);
+  printKeyValue2("Status:", result.review.status);
+  if (result.review.outcome) {
+    printKeyValue2("Outcome:", result.review.outcome);
+  }
+  printKeyValue2("Hard gate ready:", result.calibration.hardGateReady ? "yes" : "no");
+}
 function printProducerLoopReport(report) {
   console.log(import_chalk6.default.bold("Producer Loop Report"));
   printKeyValue2("Status:", report.adoption.status);
   printKeyValue2("Artifacts:", report.adoption.artifactCount);
   printKeyValue2("Calibration:", report.calibration.status);
+  printKeyValue2("Reviewed:", report.calibration.reviewedSampleSize);
+  printKeyValue2("Rejected:", report.calibration.rejectedSampleSize);
+  printKeyValue2("Unreviewed:", report.calibration.unreviewedSampleSize);
   printKeyValue2("Hard gate ready:", report.calibration.hardGateReady ? "yes" : "no");
   if (report.adoption.producerKinds.length > 0) {
     printKeyValue2("Producers:", report.adoption.producerKinds.join(", "));
@@ -14787,6 +14988,21 @@ async function workflowProducerReportCommand(options) {
   }
   printProducerLoopReport(report);
 }
+async function workflowProducerReviewCommand(options) {
+  const result = reviewProducerLoopArtifact({
+    artifact: options.artifact,
+    latest: Boolean(options.latest),
+    reject: Boolean(options.reject),
+    outcome: options.outcome,
+    reviewer: options.reviewer,
+    notes: options.note ?? []
+  });
+  if (options.json) {
+    printJson2(result);
+    return;
+  }
+  printProducerLoopReviewResult(result);
+}
 async function workflowScaffoldCommand(options) {
   const preset = parseWorkflowPlanPreset(options.preset);
   const scaffold = buildWorkflowPlanScaffold(preset, {
@@ -29291,6 +29507,20 @@ workflow.command("producer-report").description("Summarize local Producer Loop a
     json: options.json
   });
 });
+workflow.command("producer-review").description("Mark a local Producer Loop artifact as reviewed or rejected").option("--artifact <artifact>", "Artifact path, file name, or artifact id to review").option("--latest", "Review the latest valid Producer Loop artifact").option("--reject", "Mark the sample as rejected instead of reviewed").option(
+  "--outcome <outcome>",
+  "Review outcome: useful, false_positive, missing_context, unsafe, duplicate, or other"
+).option("--reviewer <reviewer>", "Reviewer name or handle").option("--note <note>", "Review note; repeatable", collectOption, []).option("--json", "Print raw JSON").action(async (options) => {
+  await workflowProducerReviewCommand({
+    artifact: options.artifact,
+    latest: options.latest,
+    reject: options.reject,
+    outcome: options.outcome,
+    reviewer: options.reviewer,
+    note: options.note,
+    json: options.json
+  });
+});
 workflow.command("resume").description(
   "Restore managed workflow state plus hosted memory after compaction or resume, including guided Sandbox reattach or rehydrate steps when a runtime checkpoint exists"
 ).option("--max-critical-tokens <number>", "Durable memory token budget").option("--max-context-tokens <number>", "Short-lived session context token budget").option("--include-session-context", "Include short-lived session carryover").option("--json", "Print raw JSON").action(async (options) => {

package/docs/FULL_REFERENCE.md

@@ -179,6 +179,7 @@ snipara-companion timeline
 snipara-companion workflow phase-commit build --summary "tests green"
 snipara-companion workflow impact-gate
 snipara-companion workflow producer-report
+snipara-companion workflow producer-review --latest --outcome useful --reviewer alice
 snipara-companion workflow run --adaptive-routing-dry-run --route-local-workers "document a scoped change"
 snipara-companion lead-plan --task "ship auth hardening" --changed-files src/auth.ts --proof "pnpm test auth" --acceptance "auth tests pass"
 snipara-companion verify --changed-files src/auth.ts --diff-summary "auth hardening"
@@ -216,8 +217,12 @@ snipara-companion workflow resume --include-session-context
 - `workflow producer-report` scans local Producer Loop artifacts emitted by
   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, and calibration caveats with
-  `hardGateReady=false`.
+  counts, invalid artifacts, sample size, reviewed/rejected/unreviewed counts,
+  and calibration caveats with `hardGateReady=false`.
+- `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
+  newest valid local artifact.
 - `workflow run --adaptive-routing-dry-run` prints an Adaptive Work Routing
   card. Add `--route-local-workers` when a strong planner should keep deep
   reasoning while a local worker handles scoped execution.
@@ -243,7 +248,7 @@ The mental model is intentionally close to Git:
 | `git show`            | `snipara-companion brief`                    |
 | `git commit`          | `snipara-companion workflow phase-commit`    |
 | `git diff @{u}..HEAD` | `snipara-companion workflow impact-gate`     |
-| review local samples  | `snipara-companion workflow producer-report` |
+| review local samples  | `snipara-companion workflow producer-review` |
 | `git log`             | `snipara-companion timeline`                 |
 | `git format-patch`    | `snipara-companion handoff`                  |
 | `git checkout`        | `snipara-companion workflow resume`          |
@@ -784,6 +789,7 @@ snipara-companion workflow run --mode full --no-runtime-hint --query "implement
 snipara-companion workflow run --mode orchestrate --query "map production rollout risks"
 snipara-companion workflow final-commit --summary "Shipped auth hardening and tests" --files src/auth.ts tests/auth.test.ts
 snipara-companion workflow producer-report
+snipara-companion workflow producer-review --artifact producer-abc123 --outcome useful --reviewer alice
 snipara-companion final-commit --summary "Shipped auth hardening and tests" --files src/auth.ts tests/auth.test.ts
 snipara-companion doctor
 snipara-companion doctor --json
@@ -1072,7 +1078,8 @@ Semantics:
 - `snipara-companion workflow runtime-checkpoint` = captures a resume-ready Snipara Sandbox checkpoint for one phase using local workflow state plus a hosted automation event when configured
 - `snipara-companion workflow phase-commit` = calls hosted `snipara_end_of_task_commit` for that phase, updates local state, and advances the next phase; if the hosted commit times out or hits a transient network failure, local workflow state still advances with an explicit local fallback record
 - `snipara-companion workflow phase-commit` and `workflow final-commit` also emit local Producer Loop V0 artifacts under `.snipara/producer-loop/`, backed by the redacted Coding Intelligence Ledger. PR Answer Pack decision capture uses the same schema with producer kind `pr_answer_pack_decision_capture` when the artifact is exported or embedded by the hosted PR pack producer. These artifacts are review evidence only: they do not launch workers, approve durable memory, claim calibrated confidence, or provide server-side attestation.
-- `snipara-companion workflow producer-report` = scans local Producer Loop artifacts and reports adoption, producer kinds, workflow ids, latest artifact, reason-code counts, invalid artifacts, sample size, and calibration caveats with `hardGateReady=false`
+- `snipara-companion workflow producer-report` = scans local Producer Loop artifacts and reports adoption, producer kinds, workflow ids, latest artifact, reason-code counts, invalid artifacts, sample size, reviewed/rejected/unreviewed counts, and calibration caveats with `hardGateReady=false`
+- `snipara-companion workflow producer-review` = marks one local Producer Loop artifact as reviewed or rejected with optional outcome, reviewer, and notes; it does not make `hardGateReady` true
 - `snipara-companion workflow phase-commit` and `workflow final-commit` complete matching local Team Sync active work when the workflow is completed. Matching is conservative: exact workflow goal/summary text wins, and file overlap plus meaningful token overlap handles slug-like workflow goals without closing unrelated active work.
 - `snipara-companion workflow impact-gate` = local pre-push gate for completed workflow phases in `upstream..HEAD`; it keeps dirty files out of the committed impact analysis and reports phase/file coverage before hosted reindex catches up
 - `snipara-companion workflow resume` = reloads local workflow state plus hosted durable memory after compaction or resume, optionally includes short-lived session context with `--include-session-context`, then appends the latest hosted Team Sync handoff/checkpoint context when available; runtime-bound phases also print a Snipara Sandbox reattach or rehydrate plan; rerun `workflow phase-start` before editing again

package/package.json

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