runbrief 0.1.0 → 0.1.1

package/README.md

@@ -13,13 +13,13 @@ name used in the install command.
 Claude Code:
 
 ```sh
-claude mcp add --transport stdio --scope user brief -- npx -y runbrief@0.1.0
+claude mcp add --transport stdio --scope user brief -- npx -y runbrief@0.1.1
 ```
 
 Codex:
 
 ```sh
-codex mcp add brief -- npx -y runbrief@0.1.0
+codex mcp add brief -- npx -y runbrief@0.1.1
 ```
 
 Generic MCP configuration:
@@ -29,7 +29,7 @@ Generic MCP configuration:
   "mcpServers": {
     "brief": {
       "command": "npx",
-      "args": ["-y", "runbrief@0.1.0"]
+      "args": ["-y", "runbrief@0.1.1"]
     }
   }
 }

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) => ({
@@ -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;
@@ -12993,20 +13090,37 @@ function compactProtectedMapMetadata(metadata) {
     "symbolKind",
     "symbolName",
     "role",
-    "entityConfidence"
+    "entityConfidence",
+    "parserBackedEntityCount"
   ]) {
     const value = metadata[key];
     if (value !== void 0)
       compact[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))
@@ -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,
@@ -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.1";
     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,6 +28159,7 @@ var init_agentBeforeYouCode = __esm({
     init_productOperatingContext();
     init_pathIntent();
     init_testRecommendations();
+    init_localReferenceImplementations();
     init_utils();
   }
 });
@@ -28759,7 +29020,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 = {
@@ -29767,6 +30037,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)
@@ -34644,7 +34958,7 @@ var init_installStatus = __esm({
   "../mcp/src/installStatus.ts"() {
     "use strict";
     init_serverInstructions();
-    briefConnectorVersion = "0.1.0";
+    briefConnectorVersion = "0.1.1";
   }
 });
 
@@ -34675,6 +34989,11 @@ function buildCompactStartEnvelope(input) {
       path: item.path,
       action: compactLine(item.action, 160)
     })),
+    reuseDecision: compactLine(beforeYouCode.reuseFirst.decision, 240),
+    sharedContext: summarizeBeforeYouCodeSharedContext(
+      beforeYouCode.teamGuidance
+    ),
+    referenceFirst: summarizeBeforeYouCodeReferences(beforeYouCode),
     validation: beforeYouCode.likelyTests.slice(0, 3),
     result: input.result,
     stopSignals: beforeYouCode.stopSignals.slice(0, 2),
@@ -34700,6 +35019,9 @@ function formatCompactStartText(envelope) {
     ),
     "Reuse:",
     ...listLines(envelope.reuse.map((item) => `${item.path} - ${item.action}`)),
+    `Reuse decision: ${envelope.reuseDecision}`,
+    `Shared context: ${envelope.sharedContext.status === "applied" ? envelope.sharedContext.applied.map((item) => item.label).join(", ") : envelope.sharedContext.status}`,
+    `Saved reference: ${envelope.referenceFirst.status === "matched" ? envelope.referenceFirst.references.map((reference) => reference.title).join(", ") : envelope.referenceFirst.status}`,
     "Validate:",
     ...listLines(envelope.validation),
     `Result: ${envelope.result.summary}`,
@@ -35142,7 +35464,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.1 wiki init --repo "$GITHUB_WORKSPACE" --update --no-agent-files',
     "      - name: Open refresh PR",
     "        uses: peter-evans/create-pull-request@22a9089034f40e5a961c8808d113e2c98fb63676 # v7.0.11",
     "        with:",
@@ -35420,6 +35742,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 +36068,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 +36504,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 +36669,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.1"
       },
       {
         instructions: briefMcpInstructions
@@ -37115,6 +37478,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 +37490,17 @@ var init_server = __esm({
             status: beforeYouCode.productOperatingContext.status,
             taskClasses: beforeYouCode.productOperatingContext.taskClasses
           },
+          autoEngage: {
+            status: "active",
+            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 +37508,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 +37974,7 @@ var init_server = __esm({
         const cloudSync = await syncScanSummary(scan, repoRoot);
         return jsonText({
           ...summarizeScan(scan),
+          scanFreshness: scanFreshnessFor(repoRoot, scan),
           rootResolution,
           repoTarget,
           cloudSync
@@ -39036,6 +39417,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 +39621,7 @@ async function runCli(commandName, commandArgs) {
       repoTarget,
       scannedAt: scan.scannedAt,
       stats: scan.stats,
+      scanFreshness: scanFreshnessFor(repoRoot, scan),
       cloudSync,
       webAppStatus: webAppStatusForScan(cloudSync),
       next: nextScanStep(cloudSync)
@@ -39325,6 +39708,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 +39720,15 @@ 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: autoEngage.finalRecapPolicy
+        },
+        referenceFirst: summarizeBeforeYouCodeReferences(beforeYouCode),
         ...learnedWorkflow ? {
           learnedWorkflow: {
             name: learnedWorkflow.name,
@@ -39343,7 +39736,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 +40201,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 +40701,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);
@@ -40961,7 +41363,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 +42088,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 +42133,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 +42181,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runbrief",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "description": "Brief Connector: the local MCP companion for repo context, reuse guidance, review gates, and handoff proof.",
   "type": "module",