runbrief 0.1.0 → 0.1.2

package/dist/cli.js

@@ -636,6 +636,13 @@ var init_dist = __esm({
       sources: z.array(z.string()),
       tokenEstimate: z.number().int().nonnegative(),
       omitted: z.array(z.string()),
+      valueSignals: z.object({
+        relevantSourceCount: z.number().int().nonnegative(),
+        reusablePrimitiveCount: z.number().int().nonnegative(),
+        parserBackedEntityCount: z.number().int().nonnegative(),
+        appliedTeamGuidanceCount: z.number().int().nonnegative(),
+        suggestedTestCount: z.number().int().nonnegative()
+      }).optional(),
       teamGuidance: teamGuidanceDeliverySchema.optional()
     });
     contextReceiptRequestSchema = z.object({
@@ -2732,6 +2739,7 @@ function saveLocalContextReceiptUnlocked(repoRoot, packet, input) {
     mapNodeCount: packet.map.length,
     memoryCount: packet.memories.length,
     suggestedTests: packet.suggestedTests,
+    ...packet.valueSignals ? { valueSignals: packet.valueSignals } : {},
     ...packet.teamGuidance ? { teamGuidance: packet.teamGuidance } : {},
     git
   };
@@ -2830,6 +2838,18 @@ function buildLocalValueReport(repoRoot, repoName = path3.basename(repoRoot)) {
   const receiptCount = receipts.length + handoffs.length;
   const proofLedger = buildProofLedger(receipts, handoffs, proofLoop);
   const impact = impactReportFor(receipts);
+  const valueSignals = receipts.reduce((summary, receipt) => {
+    summary.reusablePrimitiveCount += receipt.valueSignals?.reusablePrimitiveCount ?? 0;
+    summary.parserBackedEntityCount += receipt.valueSignals?.parserBackedEntityCount ?? 0;
+    summary.appliedTeamGuidanceCount += receipt.valueSignals?.appliedTeamGuidanceCount ?? 0;
+    summary.suggestedTestTargetCount += receipt.valueSignals?.suggestedTestCount ?? 0;
+    return summary;
+  }, {
+    reusablePrimitiveCount: 0,
+    parserBackedEntityCount: 0,
+    appliedTeamGuidanceCount: 0,
+    suggestedTestTargetCount: 0
+  });
   const report = {
     repoName,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2839,6 +2859,7 @@ function buildLocalValueReport(repoRoot, repoName = path3.basename(repoRoot)) {
     reviewCheckCount: receipts.filter((receipt) => receipt.kind === "review").length,
     handoffCount: handoffs.length,
     estimatedTokensSaved,
+    ...valueSignals,
     averagePacketTokens,
     topSources,
     recentTasks: receipts.slice(0, 8).map((receipt) => ({
@@ -7470,15 +7491,15 @@ function criticalPathBoost(filePath) {
   return 0;
 }
 function compactMetadata(metadata) {
-  const compact = {};
+  const compact2 = {};
   for (const [key, value] of Object.entries(metadata)) {
     if (Array.isArray(value) && value.length === 0)
       continue;
     if (value === "" || value === null)
       continue;
-    compact[key] = value;
+    compact2[key] = value;
   }
-  return Object.keys(compact).length > 0 ? compact : void 0;
+  return Object.keys(compact2).length > 0 ? compact2 : void 0;
 }
 function isCodeFilePath(filePath) {
   return /\.(?:[tj]sx?|py|go|rb|sql|graphql|gql)$/.test(filePath.replaceAll("\\", "/"));
@@ -11948,14 +11969,14 @@ function contextForTask(scan, request) {
   const scoped = files.length > 0;
   const rankedRules = rankRules(scan.rules, task, files);
   const initialRules = rankedRules.slice(0, scoped ? 8 : 12);
+  const initialSkills = selectSkills(scan.skills, task, files, scoped).map(compactSkillForContext);
   const mapCandidates = mapCandidatesForTask(scan, task, files);
   const rankedMap = rankMap(mapCandidates, task, files);
-  const initialGroundingRules = rulesStronglyRelevantForGrounding(initialRules, task);
-  const selectedMap = takeRuleGroundedMapNodes(mapCandidates, initialGroundingRules, rankedMap, scoped ? 14 : 18).map(compactMapNodeForContext);
+  const selectedMap = takeGuidanceGroundedMapNodes(mapCandidates, scan.sources, rulesStronglyRelevantForGrounding(initialRules, task), initialSkills, rankedMap, files, scoped ? 14 : 18).map(compactMapNodeForContext);
   const suggestedTests = selectValidationForContext(scan.map, scan.sources, task, files, selectedMap, request.repoRoot);
   const initialSelection = {
     rules: initialRules,
-    skills: selectSkills(scan.skills, task, files, scoped).map(compactSkillForContext),
+    skills: initialSkills,
     map: selectedMap,
     wikiPages: selectWikiPages(buildContextWiki(scan).pages, task, files, scoped, suggestedTests).map(compactWikiPageForContext),
     memories: rankMemories(scan.memories, task, files).slice(0, scoped ? 4 : 8).map(compactMemoryForContext),
@@ -11968,7 +11989,7 @@ function contextForTask(scan, request) {
     files
   });
   const { rules: selectedRules, skills: selectedSkills, map: budgetedMap, wikiPages: selectedWikiPages, memories: selectedMemories } = selection;
-  const finalMap = takeRuleGroundedMapNodes(mapCandidates, rulesStronglyRelevantForGrounding(selectedRules, task), budgetedMap, Math.max(budgetedMap.length, scoped ? 2 : 4)).map(compactMapNodeForContext);
+  const finalMap = takeGuidanceGroundedMapNodes(mapCandidates, scan.sources, rulesStronglyRelevantForGrounding(selectedRules, task), selectedSkills, budgetedMap, files, Math.max(budgetedMap.length, scoped ? 2 : 4)).map(compactMapNodeForContext);
   const finalSuggestedTests = selectValidationForContext(scan.map, scan.sources, task, files, finalMap, request.repoRoot);
   const owners = selectOwners(scan.map, files);
   const sources = unique([
@@ -11978,6 +11999,7 @@ function contextForTask(scan, request) {
     ...selectedWikiPages.flatMap((page2) => page2.sourcePaths),
     ...selectedMemories.flatMap((memory) => memory.sourcePaths)
   ]);
+  const teamGuidance = scan.teamGuidanceCatalog ? teamGuidanceDeliveryFor(scan, selectedRules, selectedSkills, selectedMemories) : void 0;
   const packet = {
     packetId: packetId(),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11993,19 +12015,49 @@ function contextForTask(scan, request) {
     sources,
     tokenEstimate,
     omitted,
-    ...scan.teamGuidanceCatalog ? {
-      teamGuidance: teamGuidanceDeliveryFor(scan, selectedRules, selectedSkills, selectedMemories)
-    } : {}
+    valueSignals: contextValueSignals(finalMap, finalSuggestedTests, sources.length, teamGuidance?.applied.length ?? 0),
+    ...teamGuidance ? { teamGuidance } : {}
   };
   return enforceContextPacketBudget(packet, maxTokens, files);
 }
+function contextValueSignals(map, suggestedTests, relevantSourceCount, appliedTeamGuidanceCount) {
+  const reusablePrimitiveCount = map.filter((node) => {
+    if (!["component", "route", "source", "risk"].includes(node.type)) {
+      return false;
+    }
+    const metadata = node.metadata ?? {};
+    return [
+      "exports",
+      "astFunctions",
+      "astClasses",
+      "astComponents",
+      "hooks",
+      "services",
+      "models",
+      "commands",
+      "domainEntities"
+    ].some((key) => Array.isArray(metadata[key]) && metadata[key].length > 0);
+  }).length;
+  const parserBackedEntityCount = map.reduce((total, node) => {
+    const value = node.metadata?.parserBackedEntityCount;
+    return total + (typeof value === "number" && value > 0 ? value : 0);
+  }, 0);
+  return {
+    relevantSourceCount,
+    reusablePrimitiveCount,
+    parserBackedEntityCount,
+    appliedTeamGuidanceCount,
+    suggestedTestCount: suggestedTests.length
+  };
+}
 function codebaseMapForTask(scan, request, limit = 80) {
   const files = request.files ?? [];
   const hasSpecificScope = files.length > 0 || wordsFor3(request.task).length > 1;
   const mapCandidates = mapCandidatesForTask(scan, request.task, files);
   const rankedMap = rankMap(mapCandidates, request.task, files);
-  const groundedRules = rankRules(scan.rules, request.task, files).filter((rule) => ruleIsStronglyRelevantForGrounding(rule, request.task)).slice(0, 3);
-  const ruleGroundedMap = takeRuleGroundedMapNodes(mapCandidates, groundedRules, [], Math.min(8, limit));
+  const selectedRules = rankRules(scan.rules, request.task, files).filter((rule) => ruleIsStronglyRelevantForGrounding(rule, request.task)).slice(0, files.length > 0 ? 8 : 12);
+  const selectedSkills = selectSkills(scan.skills, request.task, files, files.length > 0);
+  const ruleGroundedMap = takeGuidanceGroundedMapNodes(mapCandidates, scan.sources, selectedRules, selectedSkills, [], files, Math.min(8, limit));
   const selected = hasSpecificScope ? diversifyMap(uniqueMapNodes([...ruleGroundedMap, ...rankedMap]), limit) : broadCodebaseOverview(scan.map, limit);
   return withMapCoverageNotice(selected, scan, request, limit);
 }
@@ -12100,58 +12152,100 @@ function sourceFallbackMapNode(sourcePath) {
     }
   };
 }
-function takeRuleGroundedMapNodes(scanMap, rules, rankedMap, limit) {
-  const groundedPaths = unique(rules.flatMap(explicitRuleGroundedPaths));
-  const groundedNodes = groundedPaths.flatMap((sourcePath) => {
-    const mappedNode = scanMap.find((node) => mapNodeSourcePath(node) === sourcePath);
-    return [
-      mappedNode ? markRuleGroundedMapNode(mappedNode) : ruleSourceFallbackMapNode(sourcePath)
-    ];
+function takeGuidanceGroundedMapNodes(scanMap, sources, rules, skills, rankedMap, files, limit) {
+  const groundedPaths = guidanceReferencedSourcePaths(sources, rules, skills);
+  const nodeBySourcePath = /* @__PURE__ */ new Map();
+  for (const node of scanMap) {
+    const sourcePath = mapNodeSourcePath(node);
+    if (!nodeBySourcePath.has(sourcePath))
+      nodeBySourcePath.set(sourcePath, node);
+  }
+  const explicitNodes = rankedMap.filter((node) => files.includes(mapNodeSourcePath(node)));
+  const groundedNodes = groundedPaths.map((sourcePath) => {
+    const mappedNode = nodeBySourcePath.get(sourcePath);
+    return mappedNode ? markGuidanceGroundedMapNode(mappedNode) : guidanceSourceFallbackMapNode(sourcePath);
   });
-  const groundedLimit = Math.min(limit, 8, Math.max(3, Math.ceil(limit / 2)));
   return uniqueMapNodes([
-    ...groundedNodes.slice(0, groundedLimit),
+    ...explicitNodes,
+    ...groundedNodes,
     ...rankedMap
   ]).slice(0, limit);
 }
-function explicitRuleGroundedPaths(rule) {
-  const codePaths = rule.sourcePaths.filter((sourcePath) => isCodeOrTestPath(sourcePath));
-  const normalizedBody = rule.body.toLowerCase().replaceAll("\\", "/");
-  const explicitPaths = codePaths.filter((sourcePath) => {
-    const normalizedPath = sourcePath.toLowerCase().replaceAll("\\", "/");
-    const basename = pathBasename(sourcePath);
-    const stem = basename.replace(/\.[^.]+$/, "");
-    return normalizedBody.includes(normalizedPath) || normalizedBody.includes(pathBasename(normalizedPath)) || /[A-Z_$]/.test(stem) && normalizedBody.includes(stem.toLowerCase());
-  });
-  return explicitPaths;
+function guidanceReferencedSourcePaths(sources, rules, skills) {
+  const sourcePaths = new Map(sources.filter((source) => isCodeOrTestPath(source.path)).map((source) => [source.path.toLowerCase(), source.path]));
+  const pathsByStem = /* @__PURE__ */ new Map();
+  for (const sourcePath of sourcePaths.values()) {
+    const rawStem = pathBasename(sourcePath).replace(/\.[^.]+$/, "");
+    if (rawStem.length < 6 || !/[A-Z_$]/.test(rawStem))
+      continue;
+    const stem = rawStem.toLowerCase();
+    pathsByStem.set(stem, [...pathsByStem.get(stem) ?? [], sourcePath]);
+  }
+  const guidanceText = [
+    ...rules.map((rule) => `${rule.title}
+${rule.body}`),
+    ...skills.map((skill) => [
+      skill.name,
+      skill.description,
+      skill.body,
+      skill.triggers.join(" "),
+      skill.teamShare?.rationale ?? "",
+      skill.teamShare?.guardrails.join(" ") ?? ""
+    ].join("\n"))
+  ].join("\n");
+  const selected = [];
+  for (const rule of rules) {
+    const body = rule.body.toLowerCase().replaceAll("\\", "/");
+    for (const sourcePath of rule.sourcePaths) {
+      if (!isCodeOrTestPath(sourcePath))
+        continue;
+      const normalizedPath = sourcePath.toLowerCase().replaceAll("\\", "/");
+      const rawStem = pathBasename(sourcePath).replace(/\.[^.]+$/, "");
+      if (body.includes(normalizedPath) || body.includes(pathBasename(normalizedPath)) || rawStem.length >= 6 && /[A-Z_$]/.test(rawStem) && body.includes(rawStem.toLowerCase())) {
+        selected.push(sourcePath);
+      }
+    }
+  }
+  for (const match of guidanceText.matchAll(/[A-Za-z0-9_.@/-]+\.(?:[cm]?[tj]sx?|py|go|rb|sql|graphql|gql)\b/g)) {
+    const referencedPath = match[0]?.replace(/^\.\//, "").toLowerCase();
+    const canonicalPath = referencedPath ? sourcePaths.get(referencedPath) : void 0;
+    if (canonicalPath)
+      selected.push(canonicalPath);
+  }
+  for (const match of guidanceText.matchAll(/\b[A-Za-z_$][A-Za-z0-9_$-]{5,}\b/g)) {
+    const matches = pathsByStem.get(match[0]?.toLowerCase() ?? "") ?? [];
+    if (matches.length === 1)
+      selected.push(matches[0]);
+  }
+  return unique(selected);
 }
 function pathBasename(sourcePath) {
   return sourcePath.split("/").at(-1) ?? sourcePath;
 }
-function markRuleGroundedMapNode(node) {
+function markGuidanceGroundedMapNode(node) {
   return {
     ...node,
     metadata: {
       ...node.metadata ?? {},
       evidenceKinds: unique([
         ...metadataStringsForScore(node.metadata, "evidenceKinds"),
-        "rule_reference"
+        "guidance_reference"
       ])
     }
   };
 }
-function ruleSourceFallbackMapNode(sourcePath) {
+function guidanceSourceFallbackMapNode(sourcePath) {
   return {
-    id: idFor("map", `rule-source:${sourcePath}`),
+    id: idFor("map", `guidance-source:${sourcePath}`),
     type: isLikelyTestPath(sourcePath) ? "test" : "source",
     name: titleFromPath(sourcePath),
     path: sourcePath,
-    summary: "Source file cited by a selected repo rule; included even when the broad map cap omits it.",
-    tags: unique(["source", ...fallbackTagsForPath(sourcePath)]),
+    summary: "Source file cited by selected repo or team guidance; included even when the broad map cap omits it.",
+    tags: unique(["source", "guidance", ...fallbackTagsForPath(sourcePath)]),
     metadata: {
       sourcePath,
-      evidenceKinds: ["rule_reference"],
-      entityConfidence: 72
+      evidenceKinds: ["guidance_reference"],
+      entityConfidence: 82
     }
   };
 }
@@ -12190,6 +12284,9 @@ function uniqueMapNodes(nodes) {
 function mapNodeSourcePath(node) {
   return typeof node.metadata?.sourcePath === "string" ? node.metadata.sourcePath : node.path;
 }
+function mapNodeHasGuidanceEvidence(node) {
+  return metadataStringsForScore(node.metadata, "evidenceKinds").some((kind) => ["guidance_reference", "rule_reference"].includes(kind));
+}
 function isCodeOrTestPath(sourcePath) {
   return /\.(?:[cm]?[tj]sx?|py|go|rb|sql|graphql|gql)$/.test(sourcePath);
 }
@@ -12793,17 +12890,17 @@ function ruleIsStronglyRelevantForGrounding(rule, task) {
 function fitSelectionToBudget(initialSelection, options2) {
   const selection = cloneSelection(initialSelection);
   const omitted = [];
-  const protectedMapPaths = new Set(selection.map.filter((node) => mapNodeRelatesToExplicitFile(node, options2.files)).map(mapNodeSourcePath));
+  const protectedMapPaths = new Set(selection.map.filter((node) => mapNodeRelatesToExplicitFile(node, options2.files) || mapNodeHasGuidanceEvidence(node)).map(mapNodeSourcePath));
   const minimums = {
     rules: options2.scoped ? Math.min(selection.rules.length, 3) : 5,
-    skills: 0,
+    skills: selection.skills.some(isApprovedSharedSkill) ? 1 : 0,
     map: options2.scoped ? Math.min(selection.map.length, 8) : 10,
     wikiPages: options2.scoped ? Math.min(selection.wikiPages.length, 1) : 2,
     memories: 0
   };
   const hardMinimums = {
     rules: Math.min(selection.rules.length, options2.scoped ? 1 : 2),
-    skills: 0,
+    skills: selection.skills.some(isApprovedSharedSkill) ? 1 : 0,
     map: Math.max(Math.min(selection.map.length, options2.scoped ? 2 : 4), protectedMapPaths.size),
     wikiPages: 0,
     memories: 0
@@ -12867,7 +12964,7 @@ function enforceContextPacketBudget(packet, maxTokens, explicitFiles) {
   let trimmed = packet.omitted.length > 0;
   if (trimmed)
     packet.omitted = [omittedReason];
-  const protectedMapPaths = new Set(packet.map.filter((node) => mapNodeRelatesToExplicitFile(node, explicitFiles)).map(mapNodeSourcePath));
+  const protectedMapPaths = new Set(packet.map.filter((node) => mapNodeRelatesToExplicitFile(node, explicitFiles) || mapNodeHasGuidanceEvidence(node)).map(mapNodeSourcePath));
   let tokenEstimate = estimateContextPacketTokens(packet);
   const maxTrimSteps = removableContextItemCount(packet) + 1;
   let trimSteps = 0;
@@ -12987,32 +13084,49 @@ function compactProtectedMapNodes(map, protectedMapPaths) {
 function compactProtectedMapMetadata(metadata) {
   if (!metadata)
     return void 0;
-  const compact = {};
+  const compact2 = {};
   for (const key of [
     "sourcePath",
     "symbolKind",
     "symbolName",
     "role",
-    "entityConfidence"
+    "entityConfidence",
+    "parserBackedEntityCount"
   ]) {
     const value = metadata[key];
     if (value !== void 0)
-      compact[key] = value;
+      compact2[key] = value;
   }
   for (const key of [
+    "evidenceKinds",
     "exports",
     "imports",
     "importedBy",
     "relatedTests",
     "owners",
     "validationCommands",
-    "changeRisk"
+    "changeRisk",
+    "astClasses",
+    "astCommands",
+    "astComponents",
+    "astFunctions",
+    "astHooks",
+    "astJobs",
+    "astModels",
+    "astServices",
+    "commands",
+    "domainEntities",
+    "hooks",
+    "jobs",
+    "models",
+    "procedures",
+    "services"
   ]) {
     const value = metadata[key];
     if (Array.isArray(value))
-      compact[key] = value.slice(0, 2);
+      compact2[key] = value.slice(0, 2);
   }
-  return compact;
+  return compact2;
 }
 function refreshContextPacketDerivedFields(packet) {
   packet.summary = summarizeContext(packet.task, packet.rules, packet.suggestedTests, packet.map);
@@ -13025,6 +13139,7 @@ function refreshContextPacketDerivedFields(packet) {
     suggestedTests: packet.suggestedTests
   });
   refreshTeamGuidanceDelivery(packet);
+  packet.valueSignals = contextValueSignals(packet.map, packet.suggestedTests, packet.sources.length, packet.teamGuidance?.applied.length ?? 0);
 }
 function teamGuidanceDeliveryFor(scan, rules, skills, memories) {
   const catalog = scan.teamGuidanceCatalog;
@@ -13127,6 +13242,9 @@ function lastDroppableRuleIndex(rules) {
   }
   return -1;
 }
+function isApprovedSharedSkill(skill) {
+  return skill.status === "approved";
+}
 function compactSkillForContext(skill) {
   return {
     ...skill,
@@ -13184,17 +13302,17 @@ function compactWikiPageForContext(page2) {
 function compactMetadata2(metadata) {
   if (!metadata)
     return void 0;
-  const compact = {};
+  const compact2 = {};
   for (const [key, value] of Object.entries(metadata)) {
     if (!contextMetadataKeys.has(key))
       continue;
     if (Array.isArray(value)) {
-      compact[key] = value.slice(0, metadataArrayLimit(key));
+      compact2[key] = value.slice(0, metadataArrayLimit(key));
     } else {
-      compact[key] = value;
+      compact2[key] = value;
     }
   }
-  return compact;
+  return compact2;
 }
 function metadataArrayLimit(key) {
   if (["imports", "importedBy"].includes(key))
@@ -13248,11 +13366,27 @@ var init_context = __esm({
     ]);
     contextMetadataKeys = /* @__PURE__ */ new Set([
       "accessControls",
+      "agentTools",
+      "astClasses",
+      "astCommands",
+      "astComponents",
+      "astFunctions",
+      "astHooks",
+      "astJobs",
+      "astModels",
+      "astServices",
       "changeRisk",
+      "commands",
+      "domainEntities",
       "entityConfidence",
       "envVars",
       "evidenceKinds",
       "exports",
+      "hooks",
+      "jobs",
+      "models",
+      "parserBackedEntityCount",
+      "procedures",
       "importedBy",
       "imports",
       "loopHints",
@@ -13260,6 +13394,7 @@ var init_context = __esm({
       "relatedTests",
       "role",
       "routes",
+      "services",
       "sourcePath",
       "symbolKind",
       "symbolName",
@@ -26085,7 +26220,7 @@ var init_agentSetup = __esm({
       "ide",
       "generic"
     ];
-    briefPublishedPackageSpec = "runbrief@0.1.0";
+    briefPublishedPackageSpec = "runbrief@0.1.2";
     TARGET_LABELS = {
       terminal: "Terminal agent",
       vscode: "VS Code",
@@ -27136,6 +27271,41 @@ var init_agentStart = __esm({
 });
 
 // ../core/dist/agentBeforeYouCode.js
+function summarizeBeforeYouCodeSharedContext(delivery) {
+  if (!delivery) {
+    return {
+      status: "not_available",
+      applied: [],
+      availableCount: 0,
+      omittedCount: 0,
+      next: "Shared guidance is not available in this session; keep new learning personal until the workspace connection is ready."
+    };
+  }
+  const next = delivery.status === "applied" ? "Use the applied shared guidance, then save a focused learning or reference when the pass proves a reusable pattern." : delivery.status === "available_not_applied" ? "Shared guidance exists but did not match this task; inspect the relevant team item before creating a new pattern." : "No approved shared guidance exists yet; keep this pass personal and publish only after the pattern is proven.";
+  return {
+    status: delivery.status,
+    workspaceId: delivery.workspaceId,
+    revision: delivery.revision,
+    availableCount: delivery.availableCount,
+    applied: delivery.applied.slice(0, 4),
+    omittedCount: delivery.omittedCount,
+    next
+  };
+}
+function summarizeBeforeYouCodeReferences(beforeYouCode) {
+  return {
+    status: beforeYouCode.referenceFirst.status,
+    availableCount: beforeYouCode.referenceFirst.availableCount,
+    decision: beforeYouCode.referenceFirst.decision,
+    references: beforeYouCode.referenceFirst.references.slice(0, 2).map((reference) => ({
+      title: reference.title,
+      kind: reference.kind,
+      sourcePaths: reference.sourcePaths.slice(0, 4),
+      useWhen: reference.useWhen.slice(0, 2),
+      doNotCopy: reference.doNotCopy.slice(0, 2)
+    }))
+  };
+}
 function missionScopeFilesFromBeforeYouCode(beforeYouCode, requestedFiles = []) {
   const explicitFiles = unique(requestedFiles);
   if (explicitFiles.length > 0)
@@ -27170,6 +27340,7 @@ function buildBeforeYouCodeMap(scan, input) {
     files,
     maxTokens: 2500
   });
+  const referenceFirst = referenceFirstFor(loadLocalReferenceImplementations(input.repoRoot), input.task);
   const taskAwareSources = scan.sources.map((source, index) => ({
     source,
     index,
@@ -27192,7 +27363,7 @@ function buildBeforeYouCodeMap(scan, input) {
     ...context.map.map((node) => ({
       ...node,
       evidenceKinds: Array.isArray(node.metadata?.evidenceKinds) ? node.metadata.evidenceKinds.filter((kind) => typeof kind === "string") : [],
-      priority: Array.isArray(node.metadata?.evidenceKinds) && node.metadata.evidenceKinds.includes("rule_reference") ? 3 : 0
+      priority: Array.isArray(node.metadata?.evidenceKinds) && node.metadata.evidenceKinds.some((kind) => ["rule_reference", "guidance_reference"].includes(kind)) ? 3 : 0
     })),
     ...taskAwareSources.map((node) => ({ ...node, priority: 0 })),
     ...taskAwareMap.map((node) => ({ ...node, priority: 0 })),
@@ -27203,26 +27374,26 @@ function buildBeforeYouCodeMap(scan, input) {
       priority: 0
     }))
   ], input.task);
-  const mappedReuseCandidates = insights.agentPacket.reuseGuard.candidates.map((candidate, index) => ({
+  const mappedReuseCandidateScores = insights.agentPacket.reuseGuard.candidates.map((candidate, index) => ({
     candidate,
     index,
-    intentScore: beforeYouCodePathIntentScore(candidate.path, input.task)
-  })).filter(({ intentScore }) => intentScore > -100).sort((a, b) => b.intentScore - a.intentScore || a.index - b.index).map(({ candidate }) => reuseCandidateFor(candidate));
-  const inspectReuseCandidates = inspectFirst.filter((item) => (beforeYouCodePathIntentScore(item.path, input.task) >= 40 || item.evidenceKinds.includes("rule_reference")) && !/\.(test|spec)\.[cm]?[tj]sx?$/i.test(item.path)).map((item) => ({
+    intentScore: beforeYouCodeReuseScore(candidate, input.task)
+  })).filter(({ candidate, intentScore }) => intentScore > 0 || intentScore >= 0 && candidate.evidenceKinds.some((kind) => ["ast", "parser"].includes(kind)) && candidate.symbols.length > 0).sort((a, b) => b.intentScore - a.intentScore || a.index - b.index).map(({ candidate }) => reuseCandidateFor(candidate));
+  const inspectReuseCandidates = inspectFirst.filter((item) => (beforeYouCodePathIntentScore(item.path, input.task) >= 40 || item.evidenceKinds.some((kind) => ["rule_reference", "guidance_reference"].includes(kind))) && !/\.(test|spec)\.[cm]?[tj]sx?$/i.test(item.path)).map((item) => ({
     path: item.path,
     action: "Extend this existing implementation or rule it out.",
     why: item.why,
     evidenceKinds: item.evidenceKinds
   }));
   const reuseCandidates = uniqueReuseCandidates([
-    ...mappedReuseCandidates,
+    ...mappedReuseCandidateScores,
     ...inspectReuseCandidates
   ]).sort((a, b) => {
     const inspectRank = (candidate) => {
       const index = inspectFirst.findIndex((item) => item.path === candidate.path);
       return index < 0 ? 0 : Math.max(0, 6 - index) * 60;
     };
-    return beforeYouCodePathIntentScore(b.path, input.task) + inspectRank(b) - (beforeYouCodePathIntentScore(a.path, input.task) + inspectRank(a));
+    return beforeYouCodeReuseScore(b, input.task) + inspectRank(b) - (beforeYouCodeReuseScore(a, input.task) + inspectRank(a));
   }).slice(0, 5);
   const taskDerivedTestFiles = inspectFirstTestTargets(inspectFirst, prefersPrimaryWorkspaceTask(input.task));
   const testScopeFiles = files.length > 0 ? files : taskDerivedTestFiles.length > 0 ? taskDerivedTestFiles : target.changedFiles;
@@ -27245,7 +27416,7 @@ function buildBeforeYouCodeMap(scan, input) {
   const validationChecklist = validationChecklistFor({
     task: input.task,
     likelyTests,
-    reuseStatus: insights.agentPacket.reuseGuard.status
+    reuseStatus: reuseStatusFor(reuseCandidates)
   });
   const productOperatingContext = buildProductOperatingContext(scan, {
     task: input.task,
@@ -27261,6 +27432,7 @@ function buildBeforeYouCodeMap(scan, input) {
     ...target.dirty && files.length === 0 ? ["Dirty worktree is broad; classify baseline before editing."] : []
   ]).slice(0, 5);
   const status = inspectFirst.length === 0 && reuseCandidates.length === 0 ? "needs_narrower_scope" : "ready";
+  const reuseSummary = reuseCandidates.length > 0 ? `${reuseCandidates.length} focused reuse candidate${reuseCandidates.length === 1 ? "" : "s"} matched this task; extend or explicitly rule them out before creating new code.` : "No task-relevant reuse candidate is grounded yet; narrow the task or search once more before creating new code.";
   const headline = status === "ready" ? `${scan.repoName}: inspect ${inspectFirst.length} file${inspectFirst.length === 1 ? "" : "s"} and rule out ${reuseCandidates.length} reuse candidate${reuseCandidates.length === 1 ? "" : "s"} before coding.` : `${scan.repoName}: no focused code map yet; narrow by folder, feature, or proposed files before coding.`;
   const taskSize = taskSizeFor({
     task: input.task,
@@ -27276,6 +27448,8 @@ function buildBeforeYouCodeMap(scan, input) {
     reuseCandidates,
     likelyTests,
     productOperatingContext,
+    ...context.teamGuidance ? { teamGuidance: context.teamGuidance } : {},
+    referenceFirst,
     validationChecklist,
     stopSignals: stopSignals2
   });
@@ -27288,6 +27462,8 @@ function buildBeforeYouCodeMap(scan, input) {
     productOperatingContext,
     validationChecklist,
     stopSignals: stopSignals2,
+    ...context.teamGuidance ? { teamGuidance: context.teamGuidance } : {},
+    referenceFirst,
     maxLines: input.maxLines ?? 30
   });
   return {
@@ -27298,10 +27474,13 @@ function buildBeforeYouCodeMap(scan, input) {
     cockpit,
     inspectFirst,
     reuseFirst: {
-      status: insights.agentPacket.reuseGuard.status === "missing" && reuseCandidates.length > 0 ? "partial" : insights.agentPacket.reuseGuard.status,
-      summary: insights.agentPacket.reuseGuard.summary,
-      candidates: reuseCandidates
+      status: reuseStatusFor(reuseCandidates),
+      summary: reuseSummary,
+      candidates: reuseCandidates,
+      decision: reuseCandidates.length > 0 ? "For each candidate, choose reuse, adapt, or rule out and record the decision before creating a new primitive." : "No reuse candidate is grounded yet; run one focused search before creating a new primitive."
     },
+    ...context.teamGuidance ? { teamGuidance: context.teamGuidance } : {},
+    referenceFirst,
     likelyTests,
     exactTests,
     productOperatingContext,
@@ -27312,6 +27491,71 @@ function buildBeforeYouCodeMap(scan, input) {
     next: status === "ready" ? "Inspect these files and reuse candidates before editing; cite the reuse decision in the final handoff." : "Run brief.codebase_map or brief.context_for_task with a narrower task, folder, or file list before editing."
   };
 }
+function reuseStatusFor(candidates) {
+  if (candidates.length === 0)
+    return "missing";
+  return candidates.length >= 3 || candidates.some((candidate) => candidate.evidenceKinds.includes("ast")) ? "strong" : "partial";
+}
+function beforeYouCodeReuseScore(candidate, task) {
+  const candidateText2 = "symbols" in candidate ? [
+    candidate.path,
+    candidate.name,
+    ...candidate.symbols,
+    ...candidate.relatedEntities
+  ].join(" ") : [candidate.path, candidate.action, candidate.why].join(" ");
+  const taskTerms = new Set(reuseTerms(task));
+  const candidateTerms = new Set(reuseTerms(candidateText2));
+  const symbolMatches = [...taskTerms].filter((term) => candidateTerms.has(term)).length;
+  return beforeYouCodePathIntentScore(candidate.path, task) + Math.min(48, symbolMatches * 12);
+}
+function reuseTerms(input) {
+  return referenceQueryTerms(input.replace(/([a-z0-9])([A-Z])/g, "$1 $2"));
+}
+function referenceFirstFor(references, task) {
+  const active = references.filter((reference) => reference.status !== "archived");
+  const terms = referenceQueryTerms(task);
+  const scored = active.map((reference, index) => ({
+    reference,
+    index,
+    score: terms.reduce((score, term) => {
+      const haystack = [
+        reference.title,
+        reference.summary,
+        reference.kind,
+        ...reference.tags,
+        ...reference.appliesTo,
+        ...reference.useWhen,
+        ...reference.sourcePaths
+      ].join(" ").toLowerCase();
+      return score + (haystack.includes(term) ? 1 : 0);
+    }, 0)
+  })).sort((a, b) => b.score - a.score || b.reference.updatedAt.localeCompare(a.reference.updatedAt) || a.index - b.index);
+  const matched = scored.filter((item) => item.score > 0).map((item) => item.reference);
+  const selected = (matched.length > 0 ? matched : []).slice(0, 4);
+  const status = selected.length > 0 ? "matched" : active.length > 0 ? "available_unmatched" : "none";
+  return {
+    status,
+    availableCount: active.length,
+    references: selected,
+    decision: status === "matched" ? "Inspect the cited source paths and reuse or adapt the reference; honor its do-not-copy guardrails." : status === "available_unmatched" ? "Saved references exist, but none match this task; search the reference library before creating a new pattern." : "No saved reference matches this task; prove the new pattern before saving it for reuse."
+  };
+}
+function referenceQueryTerms(input) {
+  const ignored = /* @__PURE__ */ new Set([
+    "after",
+    "before",
+    "create",
+    "existing",
+    "make",
+    "new",
+    "reuse",
+    "task",
+    "the",
+    "this",
+    "with"
+  ]);
+  return unique(input.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length >= 4 && !ignored.has(term)));
+}
 function testRecommendationMatchesWorkspace(recommendation, targetFiles) {
   const scopes = unique(targetFiles.map(workspaceScopeForFile).filter(Boolean));
   if (scopes.length === 0)
@@ -27344,7 +27588,13 @@ function cockpitFor(input) {
     ...input.inspectFirst[0] ? [`Inspect ${input.inspectFirst[0].path}.`] : ["Narrow the task until Brief can name an inspect-first file."],
     ...input.reuseCandidates[0] ? [`Reuse or rule out ${input.reuseCandidates[0].path}.`] : ["Search once more before creating a new primitive."]
   ]).slice(0, 4);
-  const productMemory = input.productOperatingContext.status === "not_applicable" ? [] : input.productOperatingContext.productMemoryCandidates.slice(0, 3);
+  const sharedMemory = input.teamGuidance?.applied.slice(0, 2).map((item) => `Shared ${item.kind}: ${item.label}`) ?? [];
+  const productMemory = unique([
+    ...sharedMemory,
+    ...input.referenceFirst.status === "matched" ? input.referenceFirst.references.slice(0, 1).map((reference) => `Saved reference: ${reference.title}`) : input.referenceFirst.status === "available_unmatched" ? ["Saved references exist, but none match this task yet."] : [],
+    ...input.teamGuidance?.status === "available_not_applied" ? ["Shared guidance is available, but none matched this task yet."] : [],
+    ...input.productOperatingContext.status === "not_applicable" ? [] : input.productOperatingContext.productMemoryCandidates
+  ]).slice(0, 3);
   const reuseDecision = input.reuseCandidates.slice(0, 3).map((candidate) => `${candidate.path} - ${candidate.action}`);
   const validation = unique([
     ...input.likelyTests.slice(0, mode === "mission" ? 3 : 2),
@@ -27484,7 +27734,7 @@ function inspectFilesFor(nodes, contextMap, task) {
   })).filter(({ intentScore }) => intentScore > -100);
   const seen = /* @__PURE__ */ new Set();
   const candidates = [...fromNodes, ...fromContext];
-  const focusedCandidates = candidates.filter((item) => item.intentScore > 0);
+  const focusedCandidates = candidates.filter((item) => item.intentScore > 0 || item.evidenceKinds.some((kind) => ["rule_reference", "guidance_reference"].includes(kind)));
   const ranked = (focusedCandidates.length >= 3 ? focusedCandidates : candidates).sort((a, b) => b.intentScore - a.intentScore || b.originPriority - a.originPriority || a.index - b.index).filter((item) => {
     const sourcePath = item.path.split("#", 1)[0] ?? item.path;
     if (seen.has(sourcePath))
@@ -27609,7 +27859,7 @@ function beforeYouCodePathIntentScore(path20, task) {
   const wantsBilling = /\b(bill(?:ing)?|checkout|paid|payment|price|pricing|stripe|subscription)\b/.test(lowerTask);
   const wantsWorkspaceBootstrap = /\b(onboarding|workspace creation|workspace bootstrap)\b/.test(lowerTask);
   const wantsConnector = /\b(agent action|connector|first useful|mcp|setup)\b/.test(lowerTask);
-  const wantsTeam = /\b(invite|member|team)\b/.test(lowerTask);
+  const wantsTeam = /\b(invite|member|team (?:member|access|setup|management)|workspace team)\b/.test(lowerTask);
   const wantsAutoEngagement = /\b(auto[- ]?engage|automatically|by default|default engagement|reminder)\b/.test(lowerTask);
   const wantsRecommendations = /\b(context|recommendations?|reuse|tests?|test guidance|test recommendations?)\b/.test(lowerTask);
   if (wantsInterface && wantsLanding && /(landinginteractive|landing-page|src\/app\/page\.[cm]?[tj]sx?$)/.test(lowerPath)) {
@@ -27868,10 +28118,20 @@ function compactTextFor2(input) {
     `Target: ${input.target.repoName} | ${input.target.branch ?? "branch unknown"} | ${input.target.repoRoot}`,
     `Worktree: ${input.target.dirty ? "dirty" : "clean"}${input.target.changedFiles.length ? `; changed ${input.target.changedFiles.slice(0, 4).join(", ")}` : ""}${input.target.untrackedFiles.length ? `; untracked ${input.target.untrackedFiles.slice(0, 3).join(", ")}` : ""}`,
     ...input.target.requestedFiles.length ? [`Scope files: ${input.target.requestedFiles.slice(0, 5).join(", ")}`] : [],
+    ...input.teamGuidance ? [
+      `Shared guidance: ${input.teamGuidance.applied.length > 0 ? input.teamGuidance.applied.slice(0, 2).map((item) => item.label).join(", ") : input.teamGuidance.status === "available_not_applied" ? "available, but none matched this task" : "none approved yet"}`
+    ] : [],
+    ...input.referenceFirst.status === "matched" ? [
+      `Saved reference: ${input.referenceFirst.references.slice(0, 2).map((reference) => reference.title).join(", ")}`
+    ] : input.referenceFirst.status === "available_unmatched" ? [
+      "Saved references exist, but none match this task; search before creating."
+    ] : [],
     "Inspect first:",
     ...itemLines2(input.inspectFirst, (item) => `${item.path} - ${item.why}`, "No focused files yet; narrow the request.", 5),
     "Reuse before create:",
     ...itemLines2(input.reuseCandidates, (item) => `${item.path} - ${item.action}`, "No reuse candidates yet; run a narrower codebase_map query.", 4),
+    "Reuse decision: reuse, adapt, or rule out each candidate before creating a new primitive.",
+    `Reference decision: ${input.referenceFirst.decision}`,
     ...input.productOperatingContext.status === "not_applicable" ? [] : [
       "Product guardrails:",
       ...itemLines2(input.productOperatingContext.productRules, (item) => item.rule, "No product rules found; capture acceptance criteria before editing.", 3),
@@ -27899,10 +28159,107 @@ var init_agentBeforeYouCode = __esm({
     init_productOperatingContext();
     init_pathIntent();
     init_testRecommendations();
+    init_localReferenceImplementations();
     init_utils();
   }
 });
 
+// ../core/dist/agentWorkPacket.js
+function buildAgentWorkPacket(input) {
+  const before = input.beforeYouCode;
+  const rules = [
+    ...(before.teamGuidance?.applied ?? []).map((item) => ({
+      rule: item.label,
+      source: `team:${item.kind}`
+    })),
+    ...before.productOperatingContext.productRules.map((item) => ({
+      rule: item.rule,
+      source: item.source
+    }))
+  ].slice(0, 3);
+  const tests = before.exactTests.length > 0 ? before.exactTests.slice(0, 3).map((test) => ({
+    command: compact(test.command, 180),
+    reason: compact(test.reason, 180),
+    confidence: test.confidence
+  })) : before.likelyTests.slice(0, 3).map((command2) => ({
+    command: compact(command2, 180),
+    reason: "Nearest validation signal Brief found for this task.",
+    confidence: "medium"
+  }));
+  const acceptance = unique2([
+    ...before.productOperatingContext.acceptanceCriteria,
+    ...before.validationChecklist
+  ]).slice(0, 3);
+  const stopConditions = unique2([
+    ...before.stopSignals,
+    ...before.productOperatingContext.stopSignals
+  ]).slice(0, 3);
+  const nextAction = input.nextAction ?? before.next ?? "Inspect the listed files and make the reuse decision before editing.";
+  const packet = {
+    schemaVersion: 1,
+    objective: compact(input.task, 240),
+    interpretation: compact(input.interpretation ?? before.productOperatingContext.summary ?? before.headline, 160),
+    target: {
+      repoRoot: before.target.repoRoot,
+      repoName: before.target.repoName,
+      ...before.target.branch ? { branch: before.target.branch } : {},
+      ...before.target.baseRef ? { baseRef: before.target.baseRef } : {},
+      dirty: before.target.dirty,
+      changedFiles: before.target.changedFiles.slice(0, 4)
+    },
+    inspectFirst: before.inspectFirst.slice(0, 3).map((item) => ({
+      path: item.path,
+      why: compact(item.why, 160)
+    })),
+    reuse: {
+      status: before.reuseFirst.status,
+      decision: compact(before.reuseFirst.decision, 220),
+      candidates: before.reuseFirst.candidates.slice(0, 2).map((item) => ({
+        path: item.path,
+        action: compact(item.action, 140),
+        why: compact(item.why, 140)
+      }))
+    },
+    rules,
+    tests,
+    acceptance,
+    stopConditions,
+    nextAction: compact(nextAction, 200)
+  };
+  const compactText = formatAgentWorkPacket(packet);
+  return { ...packet, compactText, lineCount: compactText.split("\n").length };
+}
+function formatAgentWorkPacket(packet) {
+  const lines = [
+    `Objective: ${packet.objective}`,
+    `Target: ${packet.target.repoName}${packet.target.branch ? ` @ ${packet.target.branch}` : ""} (${packet.target.dirty ? "dirty" : "clean"})`,
+    `Interpretation: ${packet.interpretation}`,
+    `Inspect first: ${inlineList(packet.inspectFirst.map((item) => `${item.path} - ${item.why}`))}`,
+    `Reuse (${packet.reuse.status}): ${packet.reuse.decision}; ${inlineList(packet.reuse.candidates.map((item) => `${item.path} - ${item.action}`))}`,
+    `Rules: ${inlineList(packet.rules.map((item) => `${item.rule} [${item.source}]`))}`,
+    `Focused tests: ${inlineList(packet.tests.map((item) => `${item.command} - ${item.reason}`))}`,
+    `Acceptance: ${inlineList(packet.acceptance)}`,
+    `Stop if: ${inlineList(packet.stopConditions)}`,
+    `Next: ${packet.nextAction}`
+  ];
+  return lines.join("\n");
+}
+function inlineList(items) {
+  return items.length > 0 ? items.join("; ") : "none found";
+}
+function compact(value, maxLength) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}
+function unique2(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+var init_agentWorkPacket = __esm({
+  "../core/dist/agentWorkPacket.js"() {
+    "use strict";
+  }
+});
+
 // ../core/dist/ticketMissionRuntime.js
 var init_ticketMissionRuntime = __esm({
   "../core/dist/ticketMissionRuntime.js"() {
@@ -28542,7 +28899,7 @@ function codeMapBetaReadiness(input) {
     score: Math.min(100, Math.round((betaScore + input.qualityScore) / 2)),
     summary: status === "beta_plus" ? "Beta+ ready: agents have source-grounded code surfaces, parser facts, ownership, validation, operational context, and focused map proof." : status === "beta" ? "Beta: source-grounded enough to use, with remaining proof gaps that should be explicit in missions." : status === "alpha" ? "Alpha: useful orientation, but agents need narrower source, proof, or operational context before autonomous edits." : "Blocked: this map is not safe to use as architecture proof yet.",
     checks,
-    blockingGaps: unique2(blockingGaps),
+    blockingGaps: unique3(blockingGaps),
     nextActions: status === "beta_plus" ? [
       "Use this map as the pre-edit context gate for agent missions.",
       "Preserve mapQuality.betaReadiness in review_diff and save_handoff proof."
@@ -28615,7 +28972,7 @@ function metadataList(node, key) {
     return [];
   return value.filter((item) => typeof item === "string");
 }
-function unique2(items) {
+function unique3(items) {
   return [...new Set(items)];
 }
 var CODE_SURFACE_TYPES2, SOURCE_AWARE_TYPES, OBSERVABILITY_SYSTEMS, TICKET_SYSTEMS, DATA_SYSTEMS;
@@ -28759,7 +29116,16 @@ function collectFindings(input) {
     findings.push(...bugBarFindings(input.diff, input.changedFiles));
   }
   if (input.policy.enabledGates.includes("tests")) {
-    findings.push(...missingTestFindings(input.changedFiles, input.context.suggestedTests, input.validationEvidence));
+    const behaviorChangeInput = {
+      changedFiles: input.changedFiles,
+      diff: input.diff,
+      suggestedTests: input.context.suggestedTests
+    };
+    if (input.validationEvidence) {
+      behaviorChangeInput.validationEvidence = input.validationEvidence;
+    }
+    const behaviorFindings = behaviorChangeFindings(behaviorChangeInput);
+    findings.push(...behaviorFindings.length > 0 ? [] : missingTestFindings(input.changedFiles, input.context.suggestedTests, input.validationEvidence), ...behaviorFindings);
   }
   if (input.policy.enabledGates.includes("runtime_evidence")) {
     const runtimeEvidenceInput = {
@@ -29637,12 +30003,12 @@ function humanQuestionsFor(advisory, omittedFindingCount) {
   return unique(questions.map((question) => compactReviewQuestion(question))).slice(0, 8);
 }
 function compactReviewQuestion(value, maxLength = 800) {
-  const compact = value.replace(/\s+/g, " ").trim();
-  if (compact.length <= maxLength)
-    return compact;
+  const compact2 = value.replace(/\s+/g, " ").trim();
+  if (compact2.length <= maxLength)
+    return compact2;
   if (maxLength <= 3)
-    return compact.slice(0, maxLength);
-  return `${compact.slice(0, maxLength - 3).trimEnd()}...`;
+    return compact2.slice(0, maxLength);
+  return `${compact2.slice(0, maxLength - 3).trimEnd()}...`;
 }
 function reviewReadinessScore(counts, proofStatus, review) {
   const penalty = counts.blocker * 35 + counts.high * 28 + counts.medium * 12 + counts.low * 5 + counts.info * 1 + review.omittedFindingCount * 2;
@@ -29767,6 +30133,50 @@ function missingTestFindings(changedFiles, suggestedTests, validationEvidence) {
     }
   ];
 }
+function behaviorChangeFindings(input) {
+  const changedTestFiles = input.changedFiles.filter(isTestLikePath);
+  if (changedTestFiles.length > 0)
+    return [];
+  const hits = addedLinesMatching(input.diff, /(?:\b(?:router\.(?:get|post|put|patch|delete|use)|app\.(?:get|post|put|patch|delete|use)|registerTool|publicProcedure|protectedProcedure|zaniaInternalProcedure|fetch|sendEmail|enqueue|publish|writeFile(?:Sync)?|requireAuth|authorize|permission|featureFlag|process\.env\.[A-Z0-9_]+)\b|\b(?:insert|update|delete|upsert)\s*\()/i).filter((hit) => !isTestLikePath(hit.file));
+  if (hits.length === 0)
+    return [];
+  const proofTargets = input.suggestedTests.slice(0, 8);
+  if (validationEvidenceCoversSuggestedTests(input.validationEvidence, proofTargets)) {
+    return [];
+  }
+  const behaviorKinds = unique(hits.flatMap((hit) => behaviorKindForLine(hit.line))).slice(0, 5);
+  const files = unique(hits.map((hit) => hit.file));
+  return [
+    {
+      id: idFor("finding", `behavior-change:${locationsKey(hits)}:${behaviorKinds.join(",")}`),
+      gateId: "tests",
+      severity: "medium",
+      title: `Behavior change: ${behaviorKinds.join(", ")} needs focused proof`,
+      body: [
+        `Brief found added ${behaviorKinds.join(", ")} signals in ${files.join(", ")}. This is more than a structural edit: it can change a user path, data write, access boundary, external side effect, or agent contract.`,
+        proofTargets.length > 0 ? `Run the nearest mapped proof first: ${proofTargets.join(", ")}.` : "Add the nearest page, route, persistence, auth, or integration proof before handoff.",
+        "A broad typecheck alone does not prove this behavior stayed correct."
+      ].join(" "),
+      files,
+      ruleIds: [],
+      suggestedTests: proofTargets
+    }
+  ];
+}
+function behaviorKindForLine(line) {
+  const kinds = [];
+  if (/\b(?:router\.|app\.|registerTool|publicProcedure|protectedProcedure|zaniaInternalProcedure)\b/i.test(line))
+    kinds.push("route or agent contract");
+  if (/\b(?:insert|update|delete|upsert)\s*\(/i.test(line))
+    kinds.push("persistence");
+  if (/\b(?:requireAuth|authorize|permission|process\.env\.)\b/i.test(line))
+    kinds.push("access or configuration");
+  if (/\b(?:fetch|sendEmail|enqueue|publish|writeFile)\b/i.test(line))
+    kinds.push("external side effect");
+  if (/\bfeatureFlag\b/i.test(line))
+    kinds.push("feature flag");
+  return kinds.length > 0 ? kinds : ["runtime behavior"];
+}
 function validationEvidenceCoversSuggestedTests(validationEvidence, suggestedTests) {
   const passedCommands = (validationEvidence ?? []).filter((item) => item.status === "passed").map((item) => item.command.toLowerCase());
   if (passedCommands.length === 0)
@@ -32664,6 +33074,7 @@ var init_dist2 = __esm({
     init_missionPlan();
     init_agentStart();
     init_agentBeforeYouCode();
+    init_agentWorkPacket();
     init_productOperatingContext();
     init_ticketMissionRuntime();
     init_governance();
@@ -34507,9 +34918,9 @@ var init_serverInstructions = __esm({
   "../mcp/src/serverInstructions.ts"() {
     "use strict";
     briefMcpInstructions = [
-      "Brief is the default repo-context, reuse, review, and handoff companion for non-trivial coding work. Do not wait for the user to repeat 'use Brief'.",
+      "Brief is the default repo-context, reuse, review, and handoff companion for non-trivial coding work. This is the normal path, not an optional reminder. Do not wait for the user to repeat 'use Brief'.",
       "At the first Brief-relevant task in a session, call brief.install_status once and confirm the repo target and connector freshness.",
-      "Before non-trivial edits, call brief.next with the user's actual request and follow its compact recommendation. Keep micro changes lightweight.",
+      "When the user asks for non-trivial work, call brief.next with the user's actual request before inspecting or editing files, then follow its compact workPacket and recommendation. Keep micro changes lightweight.",
       "Before creating a helper, component, route, workflow, command, or skill, use the returned reuse candidates or call brief.reference_implementations and brief.codebase_map.",
       "Refresh Brief context when the task, files, risk, or validation plan changes.",
       "Before a meaningful handoff, call brief.review_diff. Save and verify a handoff only for multi-step, high-risk, or durable work.",
@@ -34547,7 +34958,7 @@ function compactBlockedInstallStatus(input) {
       fresh: input.serverFreshness.status === "current",
       summary: input.connectorReadiness.summary
     },
-    next: unique3(input.repoTarget.next).slice(0, 2),
+    next: unique4(input.repoTarget.next).slice(0, 2),
     detailHint: "Open a Git repository or pass its path, then run install-status again."
   };
 }
@@ -34559,10 +34970,10 @@ function compactInstallStatus(input) {
   const mcpContractActive = input.serverInstructionsActive && input.connectorReadiness.safeToUseBrief;
   const totalMapCandidates = stats.mapTotalCandidateCount ?? stats.mapNodeCount + (stats.mapOmittedCount ?? 0);
   const mapCoveragePercent = totalMapCandidates ? Math.round(stats.mapNodeCount / totalMapCandidates * 100) : 100;
-  const repoGuidanceSignals = unique3(
+  const repoGuidanceSignals = unique4(
     input.workflowWiring.surfaces.filter((surface) => surface.kind === "always_on_guidance").flatMap((surface) => surface.signals)
   );
-  const next = unique3([
+  const next = unique4([
     ...blocked ? [input.connectorReadiness.firstAction] : [],
     ...cloudIssue ? [cloudIssue] : [],
     ...input.readiness.nextBestActions,
@@ -34609,7 +35020,7 @@ function compactInstallStatus(input) {
       score: input.readiness.score,
       verdict: input.readiness.verdict,
       summary: input.readiness.summary,
-      gaps: unique3([
+      gaps: unique4([
         ...input.readiness.quickWins,
         ...input.readiness.nextBestActions
       ]).slice(0, 3)
@@ -34636,7 +35047,7 @@ function compactInstallStatus(input) {
     detailHint: 'Use detail: "expanded" in MCP or --full in the CLI only when diagnosing setup, workflow wiring, or receipt history.'
   };
 }
-function unique3(values) {
+function unique4(values) {
   return [...new Set(values.filter((value) => value.trim()))];
 }
 var briefConnectorVersion;
@@ -34644,7 +35055,7 @@ var init_installStatus = __esm({
   "../mcp/src/installStatus.ts"() {
     "use strict";
     init_serverInstructions();
-    briefConnectorVersion = "0.1.0";
+    briefConnectorVersion = "0.1.2";
   }
 });
 
@@ -34667,19 +35078,26 @@ function buildCompactStartEnvelope(input) {
       ...start.intent.autonomy ? { autonomy: start.intent.autonomy } : {},
       ...start.intent.reviewBar ? { reviewBar: start.intent.reviewBar } : {}
     },
+    workPacket: (() => {
+      const packet = buildAgentWorkPacket({
+        task: start.normalizedInput.task,
+        beforeYouCode,
+        interpretation: start.summary,
+        nextAction: input.next
+      });
+      return {
+        schemaVersion: packet.schemaVersion,
+        compactText: packet.compactText
+      };
+    })(),
     inspectFirst: beforeYouCode.inspectFirst.slice(0, 3).map((item) => ({
       path: item.path,
       why: compactLine(item.why, 160)
     })),
-    reuse: beforeYouCode.reuseFirst.candidates.slice(0, 2).map((item) => ({
-      path: item.path,
-      action: compactLine(item.action, 160)
-    })),
     validation: beforeYouCode.likelyTests.slice(0, 3),
     result: input.result,
-    stopSignals: beforeYouCode.stopSignals.slice(0, 2),
-    next: compactLine(input.next, 320),
-    detailHint: 'Request expanded detail only when needed: CLI --json/--full or MCP detail: "expanded".'
+    next: compactLine(input.next, 240),
+    detailHint: 'Expand with MCP detail: "expanded" or CLI --full.'
   };
 }
 function formatCompactStartText(envelope) {
@@ -34694,23 +35112,13 @@ function formatCompactStartText(envelope) {
     `Target: ${target} | ${envelope.target.dirty ? "dirty" : "clean"}`,
     `Job: ${envelope.job}`,
     `Route: ${route}`,
-    "Inspect first:",
-    ...listLines(
-      envelope.inspectFirst.map((item) => `${item.path} - ${item.why}`)
-    ),
-    "Reuse:",
-    ...listLines(envelope.reuse.map((item) => `${item.path} - ${item.action}`)),
-    "Validate:",
-    ...listLines(envelope.validation),
+    envelope.workPacket.compactText,
     `Result: ${envelope.result.summary}`,
     `Next: ${envelope.next}`,
     `Details: ${envelope.detailHint}`
   ];
   return lines.join("\n");
 }
-function listLines(items) {
-  return items.length > 0 ? items.map((item) => `- ${item}`) : ["- none"];
-}
 function compactLine(value, maxLength) {
   const normalized = value.replace(/\s+/g, " ").trim();
   if (normalized.length <= maxLength) return normalized;
@@ -35142,7 +35550,7 @@ function renderWikiRefreshWorkflow(options2 = {}) {
     "        with:",
     "          node-version: 22",
     "      - name: Refresh wiki",
-    '        run: npx -y runbrief@0.1.0 wiki init --repo "$GITHUB_WORKSPACE" --update --no-agent-files',
+    '        run: npx -y runbrief@0.1.2 wiki init --repo "$GITHUB_WORKSPACE" --update --no-agent-files',
     "      - name: Open refresh PR",
     "        uses: peter-evans/create-pull-request@22a9089034f40e5a961c8808d113e2c98fb63676 # v7.0.11",
     "        with:",
@@ -35242,7 +35650,7 @@ function resolveHandoffAutofill(repoRoot, input) {
     sources,
     missionReceiptId,
     reviewReceiptId,
-    autoFilled: unique4(autoFilled)
+    autoFilled: unique5(autoFilled)
   });
 }
 function bestMatchingReceipt(receipts, kind, input) {
@@ -35322,10 +35730,10 @@ function compactResult(result) {
 }
 function cleanValues(values, limit = 300) {
   if (!values) return void 0;
-  const cleaned = unique4(values.map((value) => value.trim()).filter(Boolean)).sort().slice(0, limit);
+  const cleaned = unique5(values.map((value) => value.trim()).filter(Boolean)).sort().slice(0, limit);
   return cleaned.length > 0 ? cleaned : void 0;
 }
-function unique4(values) {
+function unique5(values) {
   return [...new Set(values)];
 }
 function normalizeText(value) {
@@ -35382,35 +35790,35 @@ function compactCodebaseMapResponse(input) {
   };
 }
 function formatCompactCodebaseMap(input) {
-  const compact = compactCodebaseMapResponse(input);
+  const compact2 = compactCodebaseMapResponse(input);
   const lines = [
-    `Codebase map: ${compact.summary}`,
-    `Target: ${compact.target.repoName} | ${compact.target.repoRoot}${compact.target.mapPartial ? " | partial map" : ""}`,
+    `Codebase map: ${compact2.summary}`,
+    `Target: ${compact2.target.repoName} | ${compact2.target.repoRoot}${compact2.target.mapPartial ? " | partial map" : ""}`,
     "Inspect first:",
-    ...listLines2(
-      compact.inspectFirst,
+    ...listLines(
+      compact2.inspectFirst,
       (item) => `${item.path} - ${item.reason}`,
       "No focused source matched; narrow the query before editing."
     ),
     "Reuse before creating:",
-    ...listLines2(
-      compact.reuse.candidates,
+    ...listLines(
+      compact2.reuse.candidates,
       (item) => `${item.path}${item.symbols.length > 0 ? ` - ${item.symbols.join(", ")}` : ""}`,
       "No reusable primitive is proven yet; run a narrower map query."
     ),
     "Validate:",
-    ...listLines2(
-      compact.validate,
+    ...listLines(
+      compact2.validate,
       (item) => item,
       "No focused validation command was found."
     ),
-    ...compact.warnings.length > 0 ? ["Warnings:", ...listLines2(compact.warnings, (item) => item, "")] : [],
+    ...compact2.warnings.length > 0 ? ["Warnings:", ...listLines(compact2.warnings, (item) => item, "")] : [],
     "Next:",
-    ...listLines2(compact.next, (item) => item, "Inspect the first source.")
+    ...listLines(compact2.next, (item) => item, "Inspect the first source.")
   ];
   return lines.slice(0, 30).join("\n");
 }
-function listLines2(items, render, empty) {
+function listLines(items, render, empty) {
   if (items.length === 0) return empty ? [`- ${empty}`] : [];
   return items.map((item) => `- ${render(item)}`);
 }
@@ -35420,6 +35828,40 @@ var init_mapResponse = __esm({
   }
 });
 
+// ../mcp/src/scanFreshness.ts
+function scanFreshnessFor(repoRoot, scan) {
+  const gitRoot = runGit(repoRoot, ["rev-parse", "--show-toplevel"]);
+  const gitAvailable = Boolean(gitRoot);
+  const branch = runGit(repoRoot, ["branch", "--show-current"]) || null;
+  const commit = runGit(repoRoot, ["rev-parse", "HEAD"]) || null;
+  const statusLines = (gitAvailable ? runGit(repoRoot, ["status", "--short"]) : "").split("\n").map((line) => line.trim()).filter(Boolean);
+  return {
+    status: !gitAvailable ? "git_unavailable" : scan.stats.mapPartial ? "partial_coverage" : statusLines.length > 0 ? "working_tree_changed" : "current_at_scan",
+    git: {
+      available: gitAvailable,
+      detachedHead: gitAvailable && !branch
+    },
+    scannedAt: scan.scannedAt,
+    branch,
+    commit,
+    changedPathCount: statusLines.length,
+    changedPaths: statusLines.map((line) => line.replace(/^[ MADRCU?!]{1,3}\s+/, "")).slice(0, 24),
+    mapCoverage: {
+      nodes: scan.stats.mapNodeCount,
+      candidates: scan.stats.mapTotalCandidateCount ?? scan.stats.mapNodeCount,
+      omitted: scan.stats.mapOmittedCount ?? 0,
+      partial: Boolean(scan.stats.mapPartial)
+    },
+    next: !gitAvailable ? "Git metadata is unavailable; verify the repo target before trusting map freshness." : statusLines.length > 0 ? "Rescan after the current edits settle; changed paths may invalidate reuse and wiki evidence." : scan.stats.mapPartial ? "Narrow the scan by area or raise maxFiles before treating the map as complete." : !branch ? "The map was generated from a detached commit and clean working tree; verify the intended branch before editing." : "The map was generated from the current commit and clean working tree."
+  };
+}
+var init_scanFreshness = __esm({
+  "../mcp/src/scanFreshness.ts"() {
+    "use strict";
+    init_dist2();
+  }
+});
+
 // ../mcp/src/workflowWiringResponse.ts
 function selectWorkflowWiringResponse(report, detail) {
   return detail === "expanded" ? report : summarizeAgentWorkflowWiring(report);
@@ -35712,6 +36154,7 @@ function summarizePacket(packet) {
     memories: packet.memories,
     sources: packet.sources,
     omitted: packet.omitted,
+    ...packet.valueSignals ? { valueSignals: packet.valueSignals } : {},
     ...packet.teamGuidance ? { teamGuidance: packet.teamGuidance } : {}
   };
 }
@@ -36147,8 +36590,13 @@ function summarizeBeforeYouCodeForStart(beforeYouCode) {
     reuseFirst: {
       status: beforeYouCode.reuseFirst.status,
       summary: beforeYouCode.reuseFirst.summary,
+      decision: beforeYouCode.reuseFirst.decision,
       candidates: beforeYouCode.reuseFirst.candidates.slice(0, 2)
     },
+    sharedContext: summarizeBeforeYouCodeSharedContext(
+      beforeYouCode.teamGuidance
+    ),
+    referenceFirst: summarizeBeforeYouCodeReferences(beforeYouCode),
     likelyTests: beforeYouCode.likelyTests.slice(0, 3),
     productOperatingContext: {
       status: beforeYouCode.productOperatingContext.status,
@@ -36307,10 +36755,11 @@ var init_server = __esm({
     init_wikiInit();
     init_workspace();
     init_handoffAutofill();
+    init_scanFreshness();
     server = new McpServer(
       {
         name: "brief",
-        version: "0.1.0"
+        version: "0.1.2"
       },
       {
         instructions: briefMcpInstructions
@@ -37076,6 +37525,12 @@ var init_server = __esm({
         }) : void 0;
         const autoEngage = buildAgentAutoEngagementPlan(scan, skillLearning);
         const workflowWiring = evaluateAgentWorkflowWiring(scan);
+        const workPacket = buildAgentWorkPacket({
+          task,
+          beforeYouCode,
+          interpretation: recommendation.reason,
+          nextAction: `Call ${recommendation.mcpTool} next. ${recommendation.stopUntil}`
+        });
         const fullResponse = {
           status: "brief_next",
           repoRoot,
@@ -37084,6 +37539,7 @@ var init_server = __esm({
           stage: resolvedStage,
           recommendation,
           cockpit: beforeYouCode.cockpit,
+          workPacket,
           beforeYouCode: summarizeBeforeYouCodeForStart(beforeYouCode),
           ...start && recommendation.mcpTool !== "brief.before_you_code" ? { start: summarizeStartForStart(start) } : {},
           ...readinessPreview ? { readinessPreview } : {},
@@ -37107,6 +37563,7 @@ var init_server = __esm({
           },
           stage: resolvedStage,
           recommendation,
+          workPacket,
           cockpit: {
             taskSize: beforeYouCode.cockpit.taskSize,
             mode: beforeYouCode.cockpit.mode,
@@ -37115,6 +37572,7 @@ var init_server = __esm({
           },
           reuse: {
             status: beforeYouCode.reuseFirst.status,
+            decision: beforeYouCode.reuseFirst.decision,
             candidates: beforeYouCode.reuseFirst.candidates.slice(0, 3).map(({ path: candidatePath, action, why }) => ({
               path: candidatePath,
               action,
@@ -37126,6 +37584,18 @@ var init_server = __esm({
             status: beforeYouCode.productOperatingContext.status,
             taskClasses: beforeYouCode.productOperatingContext.taskClasses
           },
+          autoEngage: {
+            status: autoEngage.status,
+            workflowWiring: workflowWiring.status,
+            firstCall: "brief.next",
+            beforeEditing: "brief.before_you_code or brief.start",
+            beforeHandoff: "brief.review_diff",
+            finalRecap: "one or two truthful lines; no receipt dump"
+          },
+          sharedContext: summarizeBeforeYouCodeSharedContext(
+            beforeYouCode.teamGuidance
+          ),
+          referenceFirst: summarizeBeforeYouCodeReferences(beforeYouCode),
           ...learnedWorkflow ? {
             learnedWorkflow: {
               name: learnedWorkflow.name,
@@ -37133,7 +37603,12 @@ var init_server = __esm({
               preservedGates: learnedWorkflow.preservedGates
             }
           } : {},
-          teamContext: { status: teamContext.status },
+          teamContext: {
+            status: teamContext.status,
+            sharedContext: summarizeBeforeYouCodeSharedContext(
+              beforeYouCode.teamGuidance
+            )
+          },
           detailHint: 'Call brief.next again with detail: "expanded" only for expanded proof and workflow diagnostics.',
           next: fullResponse.next
         });
@@ -37594,6 +38069,7 @@ var init_server = __esm({
         const cloudSync = await syncScanSummary(scan, repoRoot);
         return jsonText({
           ...summarizeScan(scan),
+          scanFreshness: scanFreshnessFor(repoRoot, scan),
           rootResolution,
           repoTarget,
           cloudSync
@@ -39036,6 +39512,7 @@ init_startSummary();
 init_wikiInit();
 init_handoffAutofill();
 init_mapResponse();
+init_scanFreshness();
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "node:fs";
 import path19 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -39239,6 +39716,7 @@ async function runCli(commandName, commandArgs) {
       repoTarget,
       scannedAt: scan.scannedAt,
       stats: scan.stats,
+      scanFreshness: scanFreshnessFor(repoRoot, scan),
       cloudSync,
       webAppStatus: webAppStatusForScan(cloudSync),
       next: nextScanStep(cloudSync)
@@ -39287,6 +39765,12 @@ async function runCli(commandName, commandArgs) {
       beforeYouCode,
       baseRef
     });
+    const workPacket = buildAgentWorkPacket({
+      task,
+      beforeYouCode,
+      interpretation: recommendation.reason,
+      nextAction: recommendation.stopUntil
+    });
     const fullResponse = {
       status: "brief_next",
       repoRoot,
@@ -39295,6 +39779,7 @@ async function runCli(commandName, commandArgs) {
       stage,
       recommendation,
       cockpit: beforeYouCode.cockpit,
+      workPacket,
       beforeYouCode: summarizeBeforeYouCodeForCli(beforeYouCode),
       ...start && recommendation.mcpTool !== "brief.before_you_code" ? { start: summarizeStartForCli(start) } : {},
       workflowWiring: summarizeWorkflowWiringForCli(workflowWiring),
@@ -39317,6 +39802,11 @@ async function runCli(commandName, commandArgs) {
         },
         stage,
         recommendation,
+        workPacket: {
+          schemaVersion: workPacket.schemaVersion,
+          compactText: workPacket.compactText,
+          lineCount: workPacket.lineCount
+        },
         cockpit: {
           taskSize: beforeYouCode.cockpit.taskSize,
           mode: beforeYouCode.cockpit.mode,
@@ -39325,6 +39815,7 @@ async function runCli(commandName, commandArgs) {
         },
         reuse: {
           status: beforeYouCode.reuseFirst.status,
+          decision: beforeYouCode.reuseFirst.decision,
           candidates: beforeYouCode.reuseFirst.candidates.slice(0, 3).map(({ path: candidatePath, action, why }) => ({
             path: candidatePath,
             action,
@@ -39336,6 +39827,19 @@ async function runCli(commandName, commandArgs) {
           status: beforeYouCode.productOperatingContext.status,
           taskClasses: beforeYouCode.productOperatingContext.taskClasses
         },
+        sharedContext: summarizeBeforeYouCodeSharedContext(
+          beforeYouCode.teamGuidance
+        ),
+        autoEngage: {
+          status: autoEngage.status,
+          chatFeedback: autoEngage.chatFeedback.slice(0, 1),
+          finalRecapPolicy: {
+            maxLines: autoEngage.finalRecapPolicy.maxLines,
+            defaultTemplate: autoEngage.finalRecapPolicy.defaultTemplate,
+            fallbackWhenNotHelpful: autoEngage.finalRecapPolicy.fallbackWhenNotHelpful
+          }
+        },
+        referenceFirst: summarizeBeforeYouCodeReferences(beforeYouCode),
         ...learnedWorkflow ? {
           learnedWorkflow: {
             name: learnedWorkflow.name,
@@ -39343,7 +39847,12 @@ async function runCli(commandName, commandArgs) {
             preservedGates: learnedWorkflow.preservedGates
           }
         } : {},
-        teamContext: { status: teamContext.status },
+        teamContext: {
+          status: teamContext.status,
+          sharedContext: summarizeBeforeYouCodeSharedContext(
+            beforeYouCode.teamGuidance
+          )
+        },
         detailHint: "Run the same command with --full for expanded proof and workflow diagnostics.",
         next: fullResponse.next
       }
@@ -39803,6 +40312,10 @@ async function runCli(commandName, commandArgs) {
       repoTarget,
       cockpit: beforeYouCode.cockpit,
       beforeYouCode: summarizeBeforeYouCodeForCli(beforeYouCode),
+      sharedContext: summarizeBeforeYouCodeSharedContext(
+        beforeYouCode.teamGuidance
+      ),
+      referenceFirst: summarizeBeforeYouCodeReferences(beforeYouCode),
       teamContext: summarizeTeamContext(teamContext),
       next: "Read cockpit.compactText first. For micro/small passes, stay lightweight unless scope grows; for medium/large passes, call brief.start or mission_plan before editing."
     });
@@ -40299,7 +40812,7 @@ async function runCli(commandName, commandArgs) {
     });
     return;
   }
-  if (isCommand(commandName, "review-diff", "review_diff")) {
+  if (isCommand(commandName, "review-diff", "review", "review_diff")) {
     const baseRef = option2(commandArgs, "base");
     const task = option2(commandArgs, "task");
     const files = filesOption2(commandArgs);
@@ -40479,14 +40992,14 @@ async function runCli(commandName, commandArgs) {
   if (isCommand(commandName, "workflow-wiring", "workflow_wiring")) {
     const scan = scanRepo(repoRoot, { maxFiles: 400 });
     const workflowWiring = evaluateAgentWorkflowWiring(scan);
-    const compact = hasFlag(commandArgs, "compact") && !hasFlag(commandArgs, "full");
+    const compact2 = hasFlag(commandArgs, "compact") && !hasFlag(commandArgs, "full");
     const explicitlyExpanded = hasFlag(commandArgs, "full");
     printJson({
       status: "workflow_wiring",
       repoRoot,
       repoName: scan.repoName,
-      workflowWiring: compact ? summarizeAgentWorkflowWiring(workflowWiring) : workflowWiring,
-      ...compact ? {
+      workflowWiring: compact2 ? summarizeAgentWorkflowWiring(workflowWiring) : workflowWiring,
+      ...compact2 ? {
         detailHint: "Use --full only when diagnosing wiring evidence, contracts, or copyable prompts."
       } : explicitlyExpanded ? { detail: "expanded" } : {
         compatibility: "Expanded detail was returned for backward compatibility. Use --compact for the agent-safe response."
@@ -40961,7 +41474,7 @@ function cliCommandHelp() {
     },
     {
       command: "review-diff",
-      aliases: ["review_diff"],
+      aliases: ["review", "review_diff"],
       purpose: "Review the current diff for bugs, missing tests, reuse gaps, trust boundaries, design adherence, and proof.",
       repoBound: true,
       usage: 'brief review-diff --repo /path/to/repo --base main --task "Prepare PR" --json',
@@ -41686,6 +42199,7 @@ function printContextSummary(packet, localReceipt, teamContext) {
     `Sources: ${packet.sources.length}`,
     teamContextLine(teamContext),
     teamGuidanceLine(packet),
+    valueSignalLine(packet),
     "",
     "Rules:",
     ...packet.rules.length > 0 ? packet.rules.slice(0, 8).map((rule) => `- [${rule.enforcement}] ${rule.title}`) : ["- none"],
@@ -41730,6 +42244,11 @@ function teamGuidanceLine(packet) {
   if (!delivery) return "Team guidance applied: not connected";
   return `Team guidance applied: ${delivery.applied.length}/${delivery.availableCount} approved items (${delivery.revision})`;
 }
+function valueSignalLine(packet) {
+  const signals = packet.valueSignals;
+  if (!signals) return "Value signals: not available";
+  return `Value signals: ${signals.relevantSourceCount} relevant sources, ${signals.reusablePrimitiveCount} reusable primitives, ${signals.parserBackedEntityCount} parser-backed entities, ${signals.appliedTeamGuidanceCount} team guidance items, ${signals.suggestedTestCount} test targets`;
+}
 function writeHookFiles2(repoRoot, files) {
   const written = [];
   for (const file of files) {
@@ -41773,8 +42292,13 @@ function summarizeBeforeYouCodeForCli(beforeYouCode) {
     reuseFirst: {
       status: beforeYouCode.reuseFirst.status,
       summary: beforeYouCode.reuseFirst.summary,
+      decision: beforeYouCode.reuseFirst.decision,
       candidates: beforeYouCode.reuseFirst.candidates.slice(0, 2)
     },
+    sharedContext: summarizeBeforeYouCodeSharedContext(
+      beforeYouCode.teamGuidance
+    ),
+    referenceFirst: summarizeBeforeYouCodeReferences(beforeYouCode),
     likelyTests: beforeYouCode.likelyTests.slice(0, 3),
     productOperatingContext: {
       status: beforeYouCode.productOperatingContext.status,