snipara-companion 3.2.9 → 3.2.10

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { ProjectIntentDetectionResult, ProjectRealityCheckResult, ProjectIntelligenceEngineeringLeadPlanSummary } from '@snipara/project-intelligence-contracts';
+import { ProjectIntentDetectionResult, ProjectPolicyDecision, ProjectRealityCheckResult, ProjectIntelligenceEngineeringLeadPlanSummary, ProjectPolicyRule } from '@snipara/project-intelligence-contracts';
 
 declare function resolveQueryFromToolInput(toolInput?: string, tool?: string): string | null;
 
@@ -2030,6 +2030,7 @@ interface ProjectIntelligenceBrief {
     codeImpact?: Record<string, unknown>;
     codeImpactSourceSelection?: CodeGraphSourceSelection;
     localSessionSnapshot?: SessionSnapshot;
+    projectPolicyDecision?: ProjectPolicyDecision;
     verificationPlan?: VerificationPlan;
     judgmentCard?: ProjectIntelligenceJudgmentCard;
     errors: Array<{
@@ -2375,7 +2376,7 @@ declare function formatCompanionEngineeringLeadPlanReport(report: CompanionEngin
 declare function leadPlanCommand(options: LeadPlanCommandOptions): Promise<void>;
 
 type ProjectPolicyGateSeverity = "advisory" | "required_action" | "block";
-type ProjectPolicyGateSurface = "release" | "schema" | "auth" | "billing" | "deploy" | "package_surface";
+type ProjectPolicyGateSurface = "release" | "schema" | "auth" | "billing" | "deploy" | "package_surface" | "project_policy";
 type ProjectPolicyGateSampleMode = "not_applicable" | "structural" | "explicit_contract" | "sample_gated";
 interface ProjectPolicyGateSampleGate {
     mode: ProjectPolicyGateSampleMode;
@@ -2417,6 +2418,7 @@ interface ProjectPolicyGatesResult {
     release: boolean;
     summary: ProjectPolicyGatesSummary;
     gates: ProjectPolicyGateDecision[];
+    projectPolicyDecision?: ProjectPolicyDecision;
     suggestedCommands: string[];
 }
 interface EvaluateProjectPolicyGatesInput {
@@ -2438,6 +2440,10 @@ interface EvaluateProjectPolicyGatesInput {
         command?: string;
     };
     judgmentCard?: ProjectIntelligenceJudgmentCard;
+    projectPolicy?: {
+        rules?: ProjectPolicyRule[];
+        decision?: ProjectPolicyDecision;
+    };
 }
 declare function evaluateProjectPolicyGates(input: EvaluateProjectPolicyGatesInput): ProjectPolicyGatesResult;
 declare function formatPolicyGateDecision(gateDecision: ProjectPolicyGateDecision): string[];

package/dist/index.js

@@ -10634,6 +10634,151 @@ function buildIntentDetectionFromTimeline(events) {
   };
 }
 
+// ../project-intelligence-contracts/src/project-policy.ts
+var PROJECT_POLICY_DECISION_VERSION = "snipara.project_policy.decision.v0";
+var PROJECT_POLICY_RECEIPT_VERSION = "snipara.project_policy.receipt.v0";
+var VERDICT_RANK = {
+  allow: 0,
+  warn: 1,
+  require_review: 2,
+  block: 3
+};
+function evaluateProjectPolicyDecision(input) {
+  const generatedAt = isoTimestamp2(input.now);
+  const actionText = normalizeText2(
+    [
+      input.action.summary,
+      input.action.surface,
+      ...input.action.changedFiles ?? [],
+      ...input.action.commands ?? [],
+      metadataToText(input.action.metadata)
+    ].filter((item) => Boolean(item))
+  );
+  const matchedRules = normalizeRules(input.rules).filter(
+    (rule) => ruleMatchesAction(rule, actionText, input.action)
+  );
+  const verdict = matchedRules.reduce(
+    (current, rule) => strongerVerdict(current, verdictForRule(rule, actionText)),
+    "allow"
+  );
+  const confidence = matchedRules.length === 0 ? 1 : Math.max(...matchedRules.map((rule) => normalizeConfidence(rule.confidence)));
+  const reasonCodes = buildReasonCodes(matchedRules, verdict);
+  const requiredActions = uniqueStrings7(
+    matchedRules.flatMap((rule) => rule.requiredActions ?? [rule.requirement])
+  );
+  const warnings = matchedRules.filter((rule) => verdictForRule(rule, actionText) === "warn").map((rule) => rule.requirement);
+  const actionFingerprint = hashDecisionJsonValue(input.action);
+  const receipt = {
+    version: PROJECT_POLICY_RECEIPT_VERSION,
+    receiptId: buildReceiptId(actionFingerprint, matchedRules),
+    generatedAt,
+    verdict,
+    actionFingerprint,
+    ruleRefs: matchedRules.map((rule) => rule.source.ref),
+    confidence,
+    reasonCodes,
+    overrideAllowed: verdict !== "block",
+    overrideRequiresReason: verdict !== "allow"
+  };
+  return {
+    version: PROJECT_POLICY_DECISION_VERSION,
+    generatedAt,
+    verdict,
+    confidence,
+    matchedRules,
+    reasonCodes,
+    requiredActions,
+    warnings,
+    receipt
+  };
+}
+function projectPolicyVerdictToGateSeverity(verdict) {
+  if (verdict === "block") return "block";
+  if (verdict === "require_review") return "required_action";
+  return "advisory";
+}
+function normalizeRules(rules) {
+  return rules.filter(
+    (rule) => rule.id.trim() && rule.title.trim() && rule.requirement.trim() && rule.source.reviewStatus !== "rejected" && normalizeConfidence(rule.confidence) >= 0.5
+  );
+}
+function ruleMatchesAction(rule, actionText, action) {
+  if (action.surface && rule.scope !== "custom" && action.surface !== rule.scope) {
+    return false;
+  }
+  const anchors = uniqueStrings7([
+    rule.scope,
+    ...rule.anchors,
+    ...rule.forbiddenActions ?? [],
+    ...rule.requiredActions ?? []
+  ]);
+  return anchors.some((anchor) => actionText.includes(normalizeText2(anchor)));
+}
+function verdictForRule(rule, actionText) {
+  const forbidden = (rule.forbiddenActions ?? []).some(
+    (item) => actionText.includes(normalizeText2(item))
+  );
+  if (rule.strength === "blocking" && forbidden && normalizeConfidence(rule.confidence) >= 0.8) {
+    return "block";
+  }
+  if (rule.strength === "blocking" || rule.strength === "review_required") {
+    return "require_review";
+  }
+  return "warn";
+}
+function strongerVerdict(left, right) {
+  return VERDICT_RANK[right] > VERDICT_RANK[left] ? right : left;
+}
+function buildReasonCodes(rules, verdict) {
+  if (rules.length === 0) {
+    return ["project_policy_no_match"];
+  }
+  return uniqueStrings7([
+    `project_policy_${verdict}`,
+    ...rules.map((rule) => `project_policy_${rule.scope}`),
+    ...rules.map((rule) => `project_policy_${rule.strength}`)
+  ]);
+}
+function buildReceiptId(actionFingerprint, rules) {
+  const hash = hashDecisionJsonValue({
+    actionFingerprint,
+    rules: rules.map((rule) => [rule.id, rule.source.ref])
+  }).replace(/^sha256:/, "");
+  return `project-policy-${hash.slice(0, 16)}`;
+}
+function isoTimestamp2(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" && value.trim()) return new Date(value).toISOString();
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeConfidence(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function normalizeText2(value) {
+  const text = Array.isArray(value) ? value.filter(Boolean).join("\n") : value ?? "";
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function uniqueStrings7(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const normalized = value.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+function metadataToText(metadata) {
+  if (!metadata) return "";
+  try {
+    return JSON.stringify(metadata).slice(0, 12e3);
+  } catch {
+    return "";
+  }
+}
+
 // src/commands/decision-requests.ts
 var fs12 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
@@ -10964,7 +11109,7 @@ function memoryEvidenceItem(value, options) {
     summary: options.summary,
     kind: options.kind,
     status: options.status,
-    files: uniqueStrings7(evidenceRefs),
+    files: uniqueStrings8(evidenceRefs),
     metadata: compactObject({
       source: options.source,
       bucket: options.bucket,
@@ -11005,7 +11150,7 @@ function reviewQueueItems(result) {
         action: "review_queue_item",
         options: ["accept", "reject", "archive", "invalidate", "keep_pending"],
         recommendation: reviewStatus === "approved" || status === "active" ? "keep_pending" : "accept",
-        reasonCodes: uniqueStrings7(["memory_review_queue", reason ?? "", status ?? ""]),
+        reasonCodes: uniqueStrings8(["memory_review_queue", reason ?? "", status ?? ""]),
         evidenceItem: memoryEvidenceItem(item, {
           ref: `memory:${memoryId}`,
           title: `Review memory ${memoryId}`,
@@ -11044,7 +11189,7 @@ function cleanCandidateItems(result) {
         action: `${bucket}_candidate`,
         options,
         recommendation,
-        reasonCodes: uniqueStrings7(["memory_clean_candidates", bucket, reason]),
+        reasonCodes: uniqueStrings8(["memory_clean_candidates", bucket, reason]),
         evidenceItem: memoryEvidenceItem(candidate, {
           ref: `memory:${memoryId}`,
           title: `${bucket.replace(/_/g, " ")} memory candidate ${memoryId}`,
@@ -11081,7 +11226,7 @@ function duplicateCandidateItems(result) {
           action: "duplicate_candidate",
           options: ["merge", "supersede", "keep", "inspect"],
           recommendation: keepMemoryId ? "supersede" : "inspect",
-          reasonCodes: uniqueStrings7(["memory_duplicate_candidates", `group_${index + 1}`]),
+          reasonCodes: uniqueStrings8(["memory_duplicate_candidates", `group_${index + 1}`]),
           evidenceItem: memoryEvidenceItem(candidate, {
             ref: `memory:${memoryId}`,
             title: `Duplicate memory candidate ${memoryId}`,
@@ -11311,10 +11456,10 @@ function buildMemoryAuditSummary(audit) {
     cleanupCandidateCounts,
     ...typeof compactDryRun.mutated === "boolean" ? { compactDryRunMutated: compactDryRun.mutated } : {},
     ...compactDryRunPlannedActions !== void 0 ? { compactDryRunPlannedActions } : {},
-    recommendedActions: uniqueStrings7(recommendedActions)
+    recommendedActions: uniqueStrings8(recommendedActions)
   };
 }
-function uniqueStrings7(values) {
+function uniqueStrings8(values) {
   return Array.from(new Set(values));
 }
 function printMemoryAuditSummary(summary) {
@@ -11529,7 +11674,7 @@ async function memoryAuditCommand(options) {
 var fs13 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
-function uniqueStrings8(values) {
+function uniqueStrings9(values) {
   return Array.from(new Set((values ?? []).map((value) => value.trim()).filter(Boolean)));
 }
 function slugify(value, fallback) {
@@ -11537,7 +11682,7 @@ function slugify(value, fallback) {
   return slug2 || fallback;
 }
 function keywordHints(value) {
-  return uniqueStrings8(
+  return uniqueStrings9(
     value.split(/[^A-Za-z0-9_.:/-]+/).map((part) => part.trim()).filter((part) => part.length >= 4).slice(0, 8)
   );
 }
@@ -11583,17 +11728,17 @@ function expectedItems(section, values, files) {
 }
 function buildEvalCaseArtifact(options = {}) {
   const rootDir = path12.resolve(options.dir ?? process.cwd());
-  const files = uniqueStrings8(options.files);
-  const commandsRun = uniqueStrings8(options.commandRun);
+  const files = uniqueStrings9(options.files);
+  const commandsRun = uniqueStrings9(options.commandRun);
   const summary = options.summary?.trim() || "Snipara companion local workflow evaluation";
   const id = options.id?.trim() || slugify(summary, "snipara-companion-eval");
   const expected = {};
   const sectionInputs = {
-    context: uniqueStrings8(options.context),
-    decisions: uniqueStrings8(options.decision),
-    impact: uniqueStrings8(options.impact),
-    verification: uniqueStrings8(options.verification),
-    continuity: uniqueStrings8(options.continuity)
+    context: uniqueStrings9(options.context),
+    decisions: uniqueStrings9(options.decision),
+    impact: uniqueStrings9(options.impact),
+    verification: uniqueStrings9(options.verification),
+    continuity: uniqueStrings9(options.continuity)
   };
   for (const [section, values] of Object.entries(sectionInputs)) {
     if (values.length > 0) {
@@ -13055,7 +13200,7 @@ var SESSION_SNAPSHOT_VERSION = "snipara.session_snapshot.v0";
 var ACTIVITY_RELATIVE_DIR = path16.join(".snipara", "activity");
 var ACTIVITY_TIMELINE_RELATIVE_PATH = path16.join(ACTIVITY_RELATIVE_DIR, "timeline.jsonl");
 var SESSION_SNAPSHOT_RELATIVE_PATH = path16.join(ACTIVITY_RELATIVE_DIR, "session.json");
-function uniqueStrings9(values) {
+function uniqueStrings10(values) {
   return Array.from(new Set(values.map((value) => value?.trim()).filter(Boolean)));
 }
 function stableJson(value) {
@@ -13128,8 +13273,8 @@ function appendActivityEvent(input) {
     ...input.phaseId ? { phaseId: input.phaseId } : {},
     ...input.actor ? { actor: input.actor } : {},
     ...input.outcome ? { outcome: input.outcome } : {},
-    files: uniqueStrings9(input.files ?? []),
-    refs: uniqueStrings9(input.refs ?? []),
+    files: uniqueStrings10(input.files ?? []),
+    refs: uniqueStrings10(input.refs ?? []),
     metadata: input.metadata ?? {}
   };
   const timelinePath = getActivityTimelinePath(cwd);
@@ -13224,7 +13369,7 @@ function deriveSessionSnapshotSummary(args) {
   if (args.workflow?.status === "blocked") {
     riskReasons.push("workflow is blocked");
   }
-  const touchedFiles = uniqueStrings9(args.latestEvents.flatMap((event) => event.files)).slice(
+  const touchedFiles = uniqueStrings10(args.latestEvents.flatMap((event) => event.files)).slice(
     0,
     20
   );
@@ -13324,7 +13469,7 @@ function readSessionSnapshot(cwd = process.cwd()) {
 }
 
 // src/commands/journal.ts
-function uniqueStrings10(values) {
+function uniqueStrings11(values) {
   if (!values) {
     return [];
   }
@@ -13352,7 +13497,7 @@ function buildJournalCheckpointEntry(payload) {
     payload.actor ? `Actor: ${payload.actor}` : null,
     payload.attention ? `Attention: ${payload.attention}` : null,
     payload.next ? `Next: ${payload.next}` : null,
-    uniqueStrings10(payload.files).length > 0 ? `Files: ${uniqueStrings10(payload.files).join(", ")}` : null
+    uniqueStrings11(payload.files).length > 0 ? `Files: ${uniqueStrings11(payload.files).join(", ")}` : null
   ].filter((line) => Boolean(line));
   return {
     text: lines.join("\n"),
@@ -13448,7 +13593,7 @@ function createRedactor(rootDir) {
       patterns.add(item.name);
       item.pattern.lastIndex = 0;
     }
-    const uniqueMatchedPatterns = uniqueStrings11(matchedPatterns);
+    const uniqueMatchedPatterns = uniqueStrings12(matchedPatterns);
     if (uniqueMatchedPatterns.length > 0) {
       redactedValueCount += 1;
     }
@@ -13563,14 +13708,14 @@ function buildRepoState(input, options, rootDir, redactor) {
   const inputRepo = inputRecord(input, "repoState", "repo_state", "repo");
   const detected = detectGitState(rootDir);
   const statusCounts = countGitStatus(detected.statusLines);
-  const changedFiles = uniqueStrings11([
+  const changedFiles = uniqueStrings12([
     ...normalizeUnknownStringList(inputRepo.changedFiles),
     ...normalizeUnknownStringList(inputRepo.changed_files),
     ...normalizeUnknownStringList(input.changedFiles),
     ...normalizeUnknownStringList(input.changed_files),
     ...options.changedFiles ?? []
   ]).map((item) => redactor.redact(item).value);
-  const recentFiles = uniqueStrings11([
+  const recentFiles = uniqueStrings12([
     ...normalizeUnknownStringList(inputRepo.recentFiles),
     ...normalizeUnknownStringList(inputRepo.recent_files),
     ...normalizeUnknownStringList(input.recentFiles),
@@ -13638,18 +13783,18 @@ function normalizeEvidenceItem(value, section, index, redactor) {
     "command",
     "check"
   ]) ?? fallbackSummary(value, section, index);
-  const reasonCodes = uniqueStrings11([
+  const reasonCodes = uniqueStrings12([
     `section_${section}`,
     ...normalizeUnknownStringList(value.reasonCodes),
     ...normalizeUnknownStringList(value.reason_codes)
   ]).map((item) => redactor.redact(item).value);
-  const files = uniqueStrings11([
+  const files = uniqueStrings12([
     ...normalizeUnknownStringList(value.files),
     ...normalizeUnknownStringList(value.changedFiles),
     ...normalizeUnknownStringList(value.changed_files),
     ...normalizeUnknownStringList(value.file)
   ]).slice(0, MAX_LIST_ITEMS).map((item) => redactor.redact(item).value);
-  const commands = uniqueStrings11([
+  const commands = uniqueStrings12([
     ...normalizeUnknownStringList(value.commands),
     ...normalizeUnknownStringList(value.command),
     ...normalizeUnknownStringList(value.checks),
@@ -13673,7 +13818,7 @@ function normalizeEvidenceItem(value, section, index, redactor) {
   });
 }
 function collectReasonCodes(input, cliValues, items, redactor) {
-  return uniqueStrings11([
+  return uniqueStrings12([
     "coding_intelligence_ledger_v0",
     ...normalizeUnknownStringList(input.reasonCodes),
     ...normalizeUnknownStringList(input.reason_codes),
@@ -13704,13 +13849,13 @@ function buildCalibrationMetadata(input, cliValues, redactor) {
     "calibration",
     "calibration_metadata"
   );
-  const notes = uniqueStrings11([
+  const notes = uniqueStrings12([
     ...normalizeUnknownStringList(calibration.notes),
     ...normalizeUnknownStringList(calibration.note),
     ...normalizeUnknownStringList(input.calibrationNotes),
     ...cliValues ?? []
   ]).slice(0, MAX_LIST_ITEMS).map((item) => redactor.redact(item).value);
-  const caveats = uniqueStrings11([
+  const caveats = uniqueStrings12([
     ...normalizeUnknownStringList(calibration.caveats),
     ...normalizeUnknownStringList(calibration.caveat),
     ...normalizeUnknownStringList(input.calibrationCaveats)
@@ -13907,7 +14052,7 @@ function validIso(value) {
   const date = new Date(value);
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
-function uniqueStrings11(values) {
+function uniqueStrings12(values) {
   return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
 }
 function compactWhitespace(value) {
@@ -16209,16 +16354,16 @@ function upsertLocalAdaptiveRoutingPolicy(workerRole) {
     mode: stringValue6(existing.mode) ?? "catalog",
     plannerRetainsReasoning: existing.plannerRetainsReasoning !== false,
     preferLocalWorkers: true,
-    allowedEndpointTypes: uniqueStrings12([
+    allowedEndpointTypes: uniqueStrings13([
       ...normalizeStringList3(existing.allowedEndpointTypes),
       "local",
       "cloud"
     ]),
-    preferredEndpointTypes: uniqueStrings12([
+    preferredEndpointTypes: uniqueStrings13([
       "local",
       ...normalizeStringList3(existing.preferredEndpointTypes)
     ]),
-    allowedWorkerClasses: uniqueStrings12([
+    allowedWorkerClasses: uniqueStrings13([
       ...normalizeStringList3(existing.allowedWorkerClasses),
       workerRole,
       "documentation",
@@ -16458,7 +16603,7 @@ function normalizeWorkerProfileLanguages(value) {
   return value.length > 0 ? value : ["typescript"];
 }
 function normalizeWorkerCapabilities(values) {
-  return values.length > 0 ? uniqueStrings12(values.map((value) => String(value).trim()).filter(Boolean)) : ["code", "repo_scan", "refactor"];
+  return values.length > 0 ? uniqueStrings13(values.map((value) => String(value).trim()).filter(Boolean)) : ["code", "repo_scan", "refactor"];
 }
 function defaultCapabilitiesForWorker(workerRole) {
   if (workerRole === "documentation") {
@@ -16474,9 +16619,9 @@ function defaultCapabilitiesForWorker(workerRole) {
 }
 function normalizeStringList3(value) {
   const values = Array.isArray(value) ? value : value === void 0 ? [] : [value];
-  return uniqueStrings12(values.map(stringValue6).filter((item) => Boolean(item)));
+  return uniqueStrings13(values.map(stringValue6).filter((item) => Boolean(item)));
 }
-function uniqueStrings12(values) {
+function uniqueStrings13(values) {
   return Array.from(new Set(values));
 }
 function stringValue6(value) {
@@ -16634,7 +16779,7 @@ function numberValue4(value) {
   const parsed = Number(text);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
-function uniqueStrings13(values) {
+function uniqueStrings14(values) {
   return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
 }
 function normalizeEnum(value) {
@@ -17950,7 +18095,7 @@ function buildProducerLoopArtifact(options) {
     workflowId ?? "unmanaged",
     options.phase?.id ? `phase:${options.phase.id}` : "final"
   ].join(":");
-  const reasonCodes = uniqueStrings13([
+  const reasonCodes = uniqueStrings14([
     "producer_loop_v0",
     options.kind,
     `outcome_${options.outcome}`,
@@ -18142,8 +18287,8 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
         relativePath: relativePath2,
         artifactHash: `sha256:${hashContent(content)}`,
         ledgerHash: stringValue7(parsed.ledgerHash),
-        reasonCodes: uniqueStrings13(stringArrayValue(ledger?.reasonCodes)),
-        files: uniqueStrings13(stringArrayValue(producer.files)),
+        reasonCodes: uniqueStrings14(stringArrayValue(ledger?.reasonCodes)),
+        files: uniqueStrings14(stringArrayValue(producer.files)),
         calibrationStatus: stringValue7(calibration?.status),
         reviewStatus,
         reviewOutcome: stringValue7(review?.outcome),
@@ -18190,10 +18335,10 @@ function buildProducerLoopReport(options = {}) {
     (left, right) => left.generatedAt === right.generatedAt ? left.relativePath.localeCompare(right.relativePath) : left.generatedAt.localeCompare(right.generatedAt)
   );
   const invalidArtifacts = summaries.map((entry) => entry.invalid).filter((entry) => Boolean(entry));
-  const producerKinds = uniqueStrings13(artifacts.map((artifact) => artifact.producerKind)).filter(
+  const producerKinds = uniqueStrings14(artifacts.map((artifact) => artifact.producerKind)).filter(
     (kind) => isProducerLoopProducerKind(kind)
   );
-  const workflowIds = uniqueStrings13(
+  const workflowIds = uniqueStrings14(
     artifacts.map((artifact) => artifact.workflowId).filter((id) => Boolean(id))
   );
   const reasonCodeCounts = countStringOccurrences(
@@ -18344,7 +18489,7 @@ function readProducerLoopArtifactForReview(filePath) {
   return parsed;
 }
 function applyProducerLoopArtifactReview(artifact, options) {
-  const reviewNotes = uniqueStrings13(options.notes ?? []);
+  const reviewNotes = uniqueStrings14(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",
@@ -18359,7 +18504,7 @@ function applyProducerLoopArtifactReview(artifact, options) {
       status: options.status,
       sampleSize: 1,
       hardGateReady: false,
-      notes: uniqueStrings13([
+      notes: uniqueStrings14([
         ...stringArrayValue(existingCalibration.notes),
         reviewNote,
         ...reviewNotes.map((note) => `Review note: ${note}`)
@@ -18574,7 +18719,7 @@ function applyDecisionRequestLocally(options) {
       reject: isRejectChoice(options.choice),
       outcome: isRejectChoice(options.choice) ? "false_positive" : "useful",
       reviewer: options.reviewer,
-      notes: uniqueStrings13([
+      notes: uniqueStrings14([
         `decision_request:${request.requestId}`,
         ...options.note ? [options.note] : []
       ])
@@ -18597,7 +18742,7 @@ function recurringPolicySuggestionTargetCategory(request) {
     const metadata = isRecord9(item.metadata) ? item.metadata : void 0;
     return stringValue7(metadata?.category) ?? stringValue7(metadata?.type) ?? item.kind;
   }).filter((value) => Boolean(value)) ?? [];
-  return uniqueStrings13(evidenceCategories).sort().join("|") || request.evidence.applyPath || request.decision;
+  return uniqueStrings14(evidenceCategories).sort().join("|") || request.evidence.applyPath || request.decision;
 }
 function buildRecurringDecisionPolicySuggestionRequest(resolvedRecords) {
   const grouped = /* @__PURE__ */ new Map();
@@ -18635,12 +18780,12 @@ function buildRecurringDecisionPolicySuggestionRequest(resolvedRecords) {
         status: record.response.choice,
         files: record.request.evidence.files?.slice(0, 12)
       })),
-      reasonCodes: uniqueStrings13([
+      reasonCodes: uniqueStrings14([
         "recurring_decision_receipts",
         "never_ask_twice_candidate",
         ...latest.request.evidence.reasonCodes
       ]),
-      files: uniqueStrings13(repeated.flatMap((record) => record.request.evidence.files ?? [])),
+      files: uniqueStrings14(repeated.flatMap((record) => record.request.evidence.files ?? [])),
       applyPath: "manual_context_review",
       applyCommand: "Review the suggested rule and add it to the appropriate project policy or AGENTS.md section manually."
     },
@@ -18782,12 +18927,12 @@ function buildProducerTriageRequest(report) {
       summary: `${candidates.length} unreviewed Producer Loop samples; ${report.invalidArtifacts.length} invalid artifacts; hardGateReady remains false.`,
       refs,
       items,
-      reasonCodes: uniqueStrings13([
+      reasonCodes: uniqueStrings14([
         "triage_rules_v0",
         "producer_loop_report_valid",
         ...report.invalidArtifacts.length === 0 ? ["no_invalid_artifacts"] : ["invalid_artifacts_present"]
       ]),
-      files: uniqueStrings13(candidates.flatMap((artifact) => artifact.files)),
+      files: uniqueStrings14(candidates.flatMap((artifact) => artifact.files)),
       applyPath: "workflow producer-review",
       applyCommand: "snipara-companion workflow decide <request-id> --choose accept_all --reviewer <name>"
     },
@@ -20563,8 +20708,8 @@ async function enrichAdaptiveRoutingWithHostedCatalog(client, routing) {
       runtimeCatalog: catalog,
       routingCard: {
         ...routing.routingCard,
-        reasons: uniqueStrings13(reasons),
-        warnings: uniqueStrings13([...routing.routingCard.warnings, ...gatewayWarnings])
+        reasons: uniqueStrings14(reasons),
+        warnings: uniqueStrings14([...routing.routingCard.warnings, ...gatewayWarnings])
       }
     };
   } catch (error) {
@@ -20581,7 +20726,7 @@ async function enrichAdaptiveRoutingWithHostedCatalog(client, routing) {
       },
       routingCard: {
         ...routing.routingCard,
-        warnings: uniqueStrings13([...routing.routingCard.warnings, warning])
+        warnings: uniqueStrings14([...routing.routingCard.warnings, warning])
       }
     };
   }
@@ -20772,7 +20917,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
     const approvalRequired = booleanValue4(
       isRecord9(resolution?.policyDecision) ? resolution.policyDecision.approvalRequired : void 0
     );
-    const gatewayWarnings = uniqueStrings13([
+    const gatewayWarnings = uniqueStrings14([
       ...resolutionWarnings,
       ...selectedCandidate ? [] : ["Local orchestrator did not select a worker candidate and will fail closed."]
     ]);
@@ -20794,7 +20939,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
         ...selectedCandidate?.workerClass ? { recommendedWorkerClass: selectedCandidate.workerClass } : {},
         ...resolutionRejectedReasons ? { rejectedReasons: resolutionRejectedReasons } : {},
         ...approvalRequired !== void 0 ? { humanApprovalRequired: approvalRequired } : {},
-        reasons: uniqueStrings13([
+        reasons: uniqueStrings14([
           ...routing.routingCard.reasons,
           ...resolutionReasons,
           ...selectedCandidate ? [
@@ -20803,7 +20948,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
             ...stringValue7(selectedEndpoint?.model) ? [`selected local model ${String(selectedEndpoint?.model)}`] : []
           ] : ["local orchestrator could not resolve a concrete worker candidate"]
         ]),
-        warnings: uniqueStrings13([...routing.routingCard.warnings, ...gatewayWarnings])
+        warnings: uniqueStrings14([...routing.routingCard.warnings, ...gatewayWarnings])
       }
     };
   } catch (error) {
@@ -20820,7 +20965,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
       },
       routingCard: {
         ...routing.routingCard,
-        warnings: uniqueStrings13([...routing.routingCard.warnings, warning])
+        warnings: uniqueStrings14([...routing.routingCard.warnings, warning])
       }
     };
   }
@@ -22689,8 +22834,8 @@ function buildWorkflowAdaptiveRouting(options, policy = null, intentWarnings = [
     ...routing,
     routingCard: {
       ...routing.routingCard,
-      reasons: uniqueStrings13([...routing.routingCard.reasons, ...policyReasons]),
-      warnings: uniqueStrings13([...routing.routingCard.warnings, ...policyWarnings])
+      reasons: uniqueStrings14([...routing.routingCard.reasons, ...policyReasons]),
+      warnings: uniqueStrings14([...routing.routingCard.warnings, ...policyWarnings])
     }
   };
 }
@@ -22706,7 +22851,7 @@ function normalizeAdaptiveRoutingMode(value) {
   return normalized === "off" || normalized === "recommend" || normalized === "catalog" ? normalized : null;
 }
 function normalizeAdaptiveWorkerClasses(values) {
-  return uniqueStrings13((values ?? []).map(canonicalAdaptiveWorkerClass)).filter(
+  return uniqueStrings14((values ?? []).map(canonicalAdaptiveWorkerClass)).filter(
     (value) => ["documentation", "tests", "review", "coding"].includes(value)
   );
 }
@@ -26933,7 +27078,7 @@ function normalizeCaptureEvent(event, now, index) {
   const reasons = normalizeStringList4(event.reason).map(redactText);
   const evidence = normalizeStringList4(event.evidence).map(redactText);
   const commands = normalizeStringList4(event.commands).map(redactText);
-  const redactionPatterns = uniqueStrings14([
+  const redactionPatterns = uniqueStrings15([
     ...summary.patterns,
     ...outcome.patterns,
     ...status.patterns,
@@ -26966,7 +27111,7 @@ function normalizeEventKind(value) {
   return "feedback";
 }
 function reasonCodesForEvent(event, kind, status) {
-  return uniqueStrings14([
+  return uniqueStrings15([
     "why_outcome_capture_v1",
     "review_pending_authority",
     `source_${event.kind}`,
@@ -27031,7 +27176,7 @@ function readEventsFromFile(filePath) {
 function stableHash2(parts) {
   return (0, import_node_crypto8.createHash)("sha256").update(parts.join("\0")).digest("hex");
 }
-function uniqueStrings14(values) {
+function uniqueStrings15(values) {
   return Array.from(new Set(values.filter(Boolean)));
 }
 function compactWhitespace3(value) {
@@ -28282,6 +28427,108 @@ function actionList(value) {
     return reason ? `${priority}${preview3(title, 80)} - ${preview3(reason, 140)}` : `${priority}${preview3(title, 160)}`;
   }).filter(Boolean);
 }
+function extractProjectPolicyRulesFromResumeContext(resumeContext) {
+  if (!resumeContext) {
+    return [];
+  }
+  return collectRecords(resumeContext).map(recordToProjectPolicyRule).filter((rule) => Boolean(rule));
+}
+function collectRecords(value, depth = 0) {
+  if (depth > 5) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => collectRecords(item, depth + 1));
+  }
+  if (!isRecord15(value)) {
+    return [];
+  }
+  return [
+    value,
+    ...Object.values(value).flatMap(
+      (item) => typeof item === "object" && item !== null ? collectRecords(item, depth + 1) : []
+    )
+  ];
+}
+function recordToProjectPolicyRule(record) {
+  const type = preview3(record.type ?? record.memory_type ?? record.category, 80).toLowerCase();
+  const content = preview3(record.content ?? record.text ?? record.summary ?? record.decision, 4e3);
+  if (!content || !/(decision|policy|workflow-policy|roadmap)/i.test(type)) {
+    return void 0;
+  }
+  const status = preview3(record.status ?? record.lifecycleStatus ?? "active", 40).toLowerCase();
+  const reviewStatus = preview3(record.reviewStatus ?? record.review_status ?? "approved", 40).toLowerCase().replace("canonical", "approved");
+  if (status && status !== "active") {
+    return void 0;
+  }
+  if (reviewStatus && reviewStatus !== "approved") {
+    return void 0;
+  }
+  const anchors = extractPolicyAnchors(content);
+  if (anchors.length === 0) {
+    return void 0;
+  }
+  const id = preview3(record.memory_id ?? record.id ?? record.source_id ?? anchors[0], 80);
+  const confidence = numberValue8(record.confidence) ?? numberValue8(record.score) ?? 0.8;
+  return {
+    id,
+    title: preview3(record.title ?? content, 120),
+    scope: inferProjectPolicyScope(content, anchors),
+    strength: inferProjectPolicyStrength(content),
+    confidence,
+    source: {
+      kind: "decision_memory",
+      ref: id.startsWith("memory:") ? id : `memory:${id}`,
+      reviewStatus: "approved"
+    },
+    anchors,
+    requirement: content.slice(0, 240),
+    forbiddenActions: extractForbiddenActions(content)
+  };
+}
+function extractPolicyAnchors(text) {
+  const normalized = text.toLowerCase();
+  return [
+    ...Array.from(normalized.matchAll(/`([^`]{3,120})`/g), (match) => match[1]),
+    ...Array.from(
+      normalized.matchAll(/\b(?:apps|packages|deploy|docs|scripts|oss)\/[a-z0-9_[\]./-]+/g),
+      (match) => match[0]
+    ),
+    ...["auth", "billing", "schema", "migration", "deploy", "package", "memory", "routing"].filter(
+      (term) => normalized.includes(term)
+    )
+  ].filter((value, index, values) => value && values.indexOf(value) === index);
+}
+function inferProjectPolicyScope(text, anchors) {
+  const haystack = `${text}
+${anchors.join("\n")}`.toLowerCase();
+  if (/\b(auth|oauth|session|permission|token|secret)\b/.test(haystack)) return "auth";
+  if (/\b(billing|stripe|subscription|checkout|entitlement|quota)\b/.test(haystack)) {
+    return "billing";
+  }
+  if (/\b(schema|migration|prisma|database)\b/.test(haystack)) return "schema";
+  if (/\b(deploy|production|pre-deploy|zero-downtime)\b/.test(haystack)) return "deploy";
+  if (/\b(package|npm|pypi|npx|publish|pack smoke)\b/.test(haystack)) return "package_surface";
+  if (/\b(memory|reviewed memory|decision memory)\b/.test(haystack)) return "memory";
+  if (/\b(routing|orchestrator|worker)\b/.test(haystack)) return "routing";
+  return "custom";
+}
+function inferProjectPolicyStrength(text) {
+  const normalized = text.toLowerCase();
+  if (/\b(never|must not|do not|forbid|forbidden|disallow|block)\b/.test(normalized)) {
+    return "blocking";
+  }
+  if (/\b(require review|requires review|approval|required|must)\b/.test(normalized)) {
+    return "review_required";
+  }
+  return "advisory";
+}
+function extractForbiddenActions(text) {
+  const normalized = text.toLowerCase();
+  return ["bypass", "skip", "remove", "delete", "disable", "drop", "force"].filter(
+    (term) => normalized.includes(term)
+  );
+}
 function buildSuggestedCommands2(args) {
   const commands = [
     "snipara-companion team-sync what-changed",
@@ -28374,6 +28621,16 @@ async function buildProjectIntelligenceBrief(options) {
       });
     }
   }
+  const projectPolicyRules = extractProjectPolicyRulesFromResumeContext(brief.resumeContext);
+  if (projectPolicyRules.length > 0) {
+    brief.projectPolicyDecision = evaluateProjectPolicyDecision({
+      action: {
+        summary: options.diffSummary ?? options.task ?? "Project Intelligence brief",
+        changedFiles
+      },
+      rules: projectPolicyRules
+    });
+  }
   brief.verificationPlan = buildVerificationPlan({
     task: options.task,
     changedFiles,
@@ -28539,6 +28796,19 @@ async function projectIntelligenceBriefCommand(options) {
   console.log(import_chalk9.default.bold("Memory Authority And Health"));
   printMemoryHealth2(brief.memoryHealth);
   console.log("");
+  if (brief.projectPolicyDecision) {
+    console.log(import_chalk9.default.bold("Project Policy"));
+    console.log(
+      `Verdict: ${brief.projectPolicyDecision.verdict} (${Math.round(
+        brief.projectPolicyDecision.confidence * 100
+      )}%)`
+    );
+    if (brief.projectPolicyDecision.requiredActions.length > 0) {
+      console.log(`Required: ${brief.projectPolicyDecision.requiredActions[0]}`);
+    }
+    console.log(`Receipt: ${brief.projectPolicyDecision.receipt.receiptId}`);
+    console.log("");
+  }
   console.log(import_chalk9.default.bold("Code Impact"));
   if (brief.codeImpactSourceSelection) {
     console.log(
@@ -29246,9 +29516,46 @@ function gateSummary(gates) {
 function packageReviewCommand2(input) {
   return input.packageReview?.command ?? "npm view snipara-companion version bin dist-tags --json";
 }
+function gateSurfaceFromPolicyScope(scope) {
+  if (scope === "release" || scope === "schema" || scope === "auth" || scope === "billing" || scope === "deploy" || scope === "package_surface") {
+    return scope;
+  }
+  return "project_policy";
+}
 function evaluateProjectPolicyGates(input) {
   const changedFiles = normalizeChangedFiles(input.changedFiles);
   const gates = [];
+  const projectPolicyDecision = input.projectPolicy?.decision ?? (input.projectPolicy?.rules?.length ? evaluateProjectPolicyDecision({
+    action: {
+      summary: [input.task, input.diffSummary].filter(Boolean).join("\n"),
+      changedFiles
+    },
+    rules: input.projectPolicy.rules
+  }) : void 0);
+  if (projectPolicyDecision && projectPolicyDecision.verdict !== "allow") {
+    const strongestRule = projectPolicyDecision.matchedRules[0];
+    gates.push(
+      gate({
+        id: "policy:project:decision-consistency",
+        surface: strongestRule ? gateSurfaceFromPolicyScope(strongestRule.scope) : "project_policy",
+        severity: projectPolicyVerdictToGateSeverity(projectPolicyDecision.verdict),
+        title: "Project Policy decision consistency",
+        rationale: "Approved project policy and decision memories can require review or block when the proposed action contradicts high-confidence constraints.",
+        evidence: [
+          `verdict ${projectPolicyDecision.verdict}`,
+          `receipt ${projectPolicyDecision.receipt.receiptId}`,
+          ...projectPolicyDecision.matchedRules.map((rule) => `${rule.source.ref}: ${rule.title}`)
+        ],
+        requiredActions: projectPolicyDecision.requiredActions.length > 0 ? projectPolicyDecision.requiredActions : ["Review the matching project policy decision before proceeding."],
+        suggestedCommands: projectPolicyDecision.verdict === "block" ? ["snipara-companion decisions request --help"] : ["snipara-companion memory reviews --emit-decisions"],
+        sampleGate: explicitContractSampleGate(
+          "Project Policy gates are driven by reviewed decisions and explicit receipts, not statistical outcome thresholds."
+        ),
+        source: "project_policy_decision",
+        reasonCodes: projectPolicyDecision.reasonCodes
+      })
+    );
+  }
   if (input.release) {
     gates.push(
       gate({
@@ -29507,6 +29814,7 @@ function evaluateProjectPolicyGates(input) {
     release: Boolean(input.release),
     summary,
     gates,
+    ...projectPolicyDecision ? { projectPolicyDecision } : {},
     suggestedCommands: suggestedCommands3
   };
 }
@@ -30011,7 +30319,10 @@ async function buildProjectIntelligenceRun(options) {
     skipPackageReview: options.skipPackageReview,
     guard,
     packageReview,
-    judgmentCard
+    judgmentCard,
+    projectPolicy: brief.projectPolicyDecision ? {
+      decision: brief.projectPolicyDecision
+    } : void 0
   });
   const verificationEvidence = verificationEvidenceFromRun({
     guard,

package/docs/FULL_REFERENCE.md

@@ -1037,6 +1037,12 @@ checkouts use hosted graph impact. It prints continuity signals, memory health,
 risk and verification hints, degraded surfaces, and the Judgment Card's
 weighted readiness, evidence, and required actions.
 
+When hosted resume context includes approved decision memories that match the
+task or changed files, the brief also emits a Project Policy decision receipt
+with an `allow`, `warn`, `require_review`, or `block` verdict. This is
+conservative by design: blocks require high-confidence reviewed policy plus a
+matching forbidden action, and no new default MCP tool is exposed.
+
 Use `reality-check` or `intelligence reality-check` when a local hook, agent, or
 CI adapter needs the contradiction-to-reality gate without a full hosted brief:
 
@@ -1146,7 +1152,7 @@ Semantics:
 - `snipara-companion workflow timeline` = append-only activity timeline from `.snipara/activity/timeline.jsonl`, including workflow, Producer Loop, Decision Request, and Team Sync events emitted by Companion commands; add `--export md` for a redacted Markdown artifact
 - `snipara-companion workflow session` = writes and prints Session Snapshot V0 at `.snipara/activity/session.json` with latest activity, risk, touched files, next action, advisory Intent Detection V0 intent/confidence/signals/suggested mode, workflow/session counts, Producer Loop calibration, decision counts, Team Sync counts, and `hardRoutingAllowed=false`
 - `snipara-companion handoff` = top-level agent-ready Markdown/JSON handoff artifact plus the same local/hosted Team Sync handoff persistence
-- `snipara-companion intelligence brief` = one local Project Intelligence brief that combines local Session Snapshot, hosted resume context, memory health, and code impact for a task
+- `snipara-companion intelligence brief` = one local Project Intelligence brief that combines local Session Snapshot, hosted resume context, memory health, Project Policy decision receipts, and code impact for a task
 - `snipara-companion intelligence reality-check` = Project Intelligence namespace alias for the same local Reality Check gate
 - `snipara-companion intelligence ledger-export` = structured redacted Coding Intelligence Ledger JSON for replay, review, and commercial proof assets without dumping raw transcripts
 - `snipara-companion run` = production Project Intelligence flow that combines the brief, guard action cards, package review, verification hints, and a final weighted Judgment Card
@@ -1172,7 +1178,7 @@ Semantics:
 - `snipara-companion team-sync resume` = reloads local carryover plus the hosted latest handoff and checkpoint-aware resume guidance when available
 - `snipara-companion final-commit` / `workflow final-commit` = final hosted commit for the managed workflow
 - `snipara-companion code callers/imports/neighbors/shortest-path/impact` = primary code graph surface for agents with shell access. These commands use `--source auto` by default; clean configured checkouts use hosted MCP, dirty/ahead worktrees use the local overlay, and every response reports `sourceSelection` plus agent guidance.
-- `snipara-companion code symbol-card` = direct paid Context `snipara_code_symbol_card` for an important symbol before editing, with an agent guidance summary before raw JSON
+- `snipara-companion code symbol-card` = direct `snipara_code_symbol_card` for an important symbol before editing, with an agent guidance summary before raw JSON
 - `snipara-companion code impact --source hosted|local` = optional source override for debugging; normal agent instructions should leave `--source auto` in place. Hosted `snipara_code_impact` is the fallback when companion is unavailable or the canonical graph check after push/reindex.
 - `snipara-companion code local impact` = explicit repository-local file-level import impact from the local code overlay; keep this for power-user/debug workflows, and use `workflow impact-gate` when the file set should come from unpushed workflow commits
 - `snipara-companion doctor` = local readiness check for companion version skew, Snipara auth, deterministic hosted tool catalog access, Snipara Sandbox, Snipara Sandbox MCP wiring, provider keys, and Docker

package/package.json

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