@moretea-labs/forge 1.8.0 → 1.8.2

package/adapters/mcp/runtime-gateway/context-adapter.ts

@@ -1,42 +1,59 @@
 import { createHash } from "crypto";
-import { existsSync } from "fs";
-import { join } from "path";
 import { defaultSemanticProviderRegistry, type SemanticNavigationKind, type SemanticNavigationRequest } from "../../../src/runtime/context/semantic-navigation";
+import { isIncidentalSemanticDependencyProbe } from "../../../src/runtime/context/semantic-navigation-contract";
 import { buildContextClosureReceipt } from "../../../src/runtime/context/context-closure";
-import { codegraphRepositoryCacheRoot } from "../../../src/runtime/context/codegraph-cache-boundary";
+import { readWorkHandle } from "../../../src/runtime/control-plane/execution/work-handle-store";
 import type { MultiRepositoryMcpToolContext } from "../multi-repository";
 import { result } from "./result-adapter";
+import { boundedRuntimeResult } from "./bounded-result-runtime";
 import { selected } from "./shared-adapter";
 import { resolveMcpPath } from "../paths";
 import { freshGitIdentity } from "../../../src/cli/repository/inspector";
-import { repositoryCheckoutLifecycle, repositorySummary, resolveRepositorySelection } from "../../../src/cli/repositories/registry";
+import { repositorySummary, resolveRepositorySelection } from "../../../src/cli/repositories/registry";
 import { getExecutionJob, listExecutionJobs } from "../../../src/runtime/execution/jobs/store";
 import { isManagedProcessActive, listProcessRecords, listRecoverableProcessRecords, processRuntimeResourceDiagnostics } from "../../../src/runtime/execution/process-runtime";
-import { buildControllerContextPackAsync, CONTROLLER_CONTEXT_IMPACT_DOMAINS, type ControllerContextImpactDomain } from "../../../src/cli/controller/context-pack";
+import { CONTROLLER_CONTEXT_IMPACT_DOMAINS, type ControllerContextImpactDomain } from "../../../src/cli/controller/context/types";
+import { buildControllerContextPackInSidecar } from "../../../src/runtime/context/context-pack-process";
+import { isCodeShapedTerm } from "../../../src/cli/controller/context/query-planning";
 import { listControllerChecks } from "../../../src/cli/controller/check-runner";
-import { controllerPluginRepository, getAssistantPluginManifest, listAssistantPluginManifests } from "../../../src/runtime/plugins/store";
-import { allowedFacadeOperations, buildFacadeResult, listCapabilityDescriptors, getCapabilityDescriptor, getPluginActionCapabilitySchema, searchCapabilityDescriptors, summarizeCapabilityGroups, listHandoffItems, normalizeCheckIds, summarizeHandoffItem, buildWorkContinuationSnapshot } from "../../../src/runtime/control-plane/facade";
-import { getWorkContract, readActiveWorkCandidates, type InvalidActiveWorkCandidate } from "../../../packages/kernel/work/api/index";
+import { getAssistantPluginManifest, getControllerPluginManifest, listAssistantPluginManifests, listControllerPluginManifests } from "../../../src/runtime/plugins/store";
+import { allowedFacadeOperations, buildFacadeResult, listCapabilityDescriptors, getCapabilityDescriptor, getCoreCapabilityExecutionSchema, getPluginActionCapabilitySchema, searchCapabilityDescriptors, summarizeCapabilityGroups, listHandoffAttentionItems, listHandoffItems, normalizeCheckIds, summarizeHandoffItem, buildWorkContinuationSnapshot, getPlanContract, planSemanticView, FACADE_TOOLS } from "../../../src/runtime/control-plane/facade";
+import { currentTaskLineageWorkIds, currentTaskSemanticProjectionForWork, getWorkContract, readActiveWorkCandidates, readWorkContractStore, workSemanticView, type InvalidActiveWorkCandidate, type WorkContract } from "../../../packages/kernel/work/api/index";
+import { readRequirement, requirementSemanticView } from '../../../src/runtime/control-plane/persistence/requirement-store';
+import { readForgeInstanceIdentity, type ScopeRef } from "../../../packages/kernel/identity/api/index";
+import { memoryAddressKey } from "../../../packages/kernel/cognition/api/index";
 import { currentControllerInstanceId } from "../../../src/runtime/control-plane/execution/session-store";
 import { getControllerSession } from "../../../packages/kernel/controller/api/index";
+import { resolveProjectForRepositoryPlacement } from "../../../src/runtime/control-plane/workspace/workspace-store";
+import { cognitiveScopesForWork } from "../../../src/runtime/control-plane/persistence/experience-store";
+import { activateCognitiveMemory, auditCognitiveMemory } from "../../../src/runtime/control-plane/persistence/cognition-store";
+import { cognitiveUsageFeedbackForContext, resolveCognitiveAttention } from "../../../src/runtime/context/cognitive-attention";
 import { invalidFacadeOperation, repositoryExecutionReadiness, summarizeInvalidActiveWorkCandidate, summarizeWorkListItem } from './status-inbox-adapter';
 import type { CallToolResult } from '../../../packages/protocols/mcp/tool-contract';
 
-const RH_CONTEXT_CURRENT_WINDOW_MS = 24 * 60 * 60 * 1_000;
+const RH_CONTEXT_RECENT_ACTIVITY_WINDOW_MS = 24 * 60 * 60 * 1_000;
+const RH_CONTEXT_AUTOMATIC_RECALL_LIMIT = 4;
 
-function timestampIsCurrent(value: string | undefined, cutoffMs: number): boolean {
+function timestampIsRecent(value: string | undefined, cutoffMs: number): boolean {
   if (!value) return false;
   const timestamp = Date.parse(value);
   return Number.isFinite(timestamp) && timestamp >= cutoffMs;
 }
 
-function isCurrentRhContextWork(
-  contract: { status: string; updatedAt?: string },
+const RESUME_CONTEXT_HUMAN_REQUEST_REASONS = new Set([
+  'policy_approval_required',
+  'missing_authorization',
+  'invalid_objective',
+  'destructive_action_requires_confirmation',
+]);
+
+function isRecentRhContextWork(
+  contract: Pick<WorkContract, 'semanticState' | 'dispatchState' | 'updatedAt'>,
   cutoffMs: number,
 ): boolean {
-  if (contract.status === 'running') return true;
-  if (contract.status !== 'ready' && contract.status !== 'open' && contract.status !== 'blocked') return false;
-  return timestampIsCurrent(contract.updatedAt, cutoffMs);
+  if (contract.semanticState !== 'open') return false;
+  if (contract.dispatchState === 'running' || contract.dispatchState === 'launching' || contract.dispatchState === 'claimed') return true;
+  return timestampIsRecent(contract.updatedAt, cutoffMs);
 }
 
 function rhContextReadSessionId(ctx: MultiRepositoryMcpToolContext): string | undefined {
@@ -49,6 +66,173 @@ function rhContextReadSessionId(ctx: MultiRepositoryMcpToolContext): string | un
   return transportSession ? `transport:${transportSession}` : undefined;
 }
 
+function rhContextKnowledgeAuditRequested(args: Record<string, unknown>): boolean {
+  return [
+    'knowledge_query', 'knowledge_memory_id', 'knowledge_scope_kind', 'knowledge_scope_id',
+    'knowledge_concept', 'knowledge_facet', 'knowledge_source_kind', 'knowledge_source_work_id',
+  ].some(key => typeof args[key] === 'string' && String(args[key]).trim().length > 0)
+    || typeof args.knowledge_limit === 'number';
+}
+
+function rhContextKnowledgeScopes(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  workId: string | undefined,
+): { scopes: ScopeRef[]; projectId?: string; gaps: string[] } {
+  const store = { controllerHome: ctx.controllerHome, repoId: repository.repoId };
+  const work = workId ? getWorkContract(store, workId) : undefined;
+  if (work) {
+    const scopes = cognitiveScopesForWork(work, ctx.controllerHome);
+    return { scopes, projectId: scopes.find(scope => scope.kind === 'project')?.id, gaps: [] };
+  }
+  const instance = readForgeInstanceIdentity(ctx.controllerHome);
+  if (!instance) return { scopes: [], gaps: ['forge_instance_identity_unavailable'] };
+  const project = resolveProjectForRepositoryPlacement({
+    controllerHome: ctx.controllerHome,
+    forgeInstanceId: instance.instanceId,
+    repositoryId: repository.repoId,
+    checkoutId: repository.activeCheckoutId,
+  });
+  if (!project) return { scopes: [], gaps: ['project_placement_unavailable'] };
+  return {
+    projectId: project.projectId,
+    scopes: [
+      { schemaVersion: 1, kind: 'project', id: project.projectId },
+      { schemaVersion: 1, kind: 'workspace', id: project.workspaceId },
+    ],
+    gaps: [],
+  };
+}
+
+function rhContextKnowledgeAudit(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  args: Record<string, unknown>,
+): Record<string, unknown> {
+  const workId = typeof args.work_id === 'string' && args.work_id.trim() ? args.work_id.trim() : undefined;
+  const resolved = rhContextKnowledgeScopes(ctx, repository, workId);
+  const requestedKind = typeof args.knowledge_scope_kind === 'string' ? args.knowledge_scope_kind.trim() : '';
+  const requestedId = typeof args.knowledge_scope_id === 'string' ? args.knowledge_scope_id.trim() : '';
+  const scopes = resolved.scopes.filter(scope =>
+    (!requestedKind || scope.kind === requestedKind) && (!requestedId || scope.id === requestedId));
+  const scopeMismatch = resolved.scopes.length > 0 && scopes.length === 0 && Boolean(requestedKind || requestedId);
+  const rawQuery = typeof args.knowledge_query === 'string' ? args.knowledge_query.trim() : '';
+  const query = rawQuery === '*' ? '' : rawQuery;
+  const audit = auditCognitiveMemory(ctx.controllerHome, {
+    scopes,
+    ...(query ? { query } : {}),
+    ...(typeof args.knowledge_memory_id === 'string' && args.knowledge_memory_id.trim()
+      ? { memoryId: args.knowledge_memory_id.trim() } : {}),
+    ...(typeof args.knowledge_concept === 'string' && args.knowledge_concept.trim()
+      ? { concept: args.knowledge_concept.trim() } : {}),
+    ...(typeof args.knowledge_facet === 'string' && args.knowledge_facet.trim()
+      ? { facet: args.knowledge_facet.trim() } : {}),
+    ...(typeof args.knowledge_source_kind === 'string' && args.knowledge_source_kind.trim()
+      ? { sourceKind: args.knowledge_source_kind.trim() as 'experience' | 'outcome' | 'knowledge' | 'controller' | 'system' | 'external' } : {}),
+    ...(typeof args.knowledge_source_work_id === 'string' && args.knowledge_source_work_id.trim()
+      ? { sourceWorkId: args.knowledge_source_work_id.trim() } : {}),
+    ...(typeof args.knowledge_limit === 'number' ? { limit: args.knowledge_limit } : {}),
+  });
+  const usage = cognitiveUsageFeedbackForContext({
+    controllerHome: ctx.controllerHome,
+    repoId: repository.repoId,
+    scopes,
+    ...(resolved.projectId ? { projectId: resolved.projectId } : {}),
+  });
+  const usageByAddress = new Map(usage.map(item => [memoryAddressKey(item.address), item]));
+  const activation = query
+    ? activateCognitiveMemory(ctx.controllerHome, scopes, query, {
+        maxItems: Math.min(32, Math.max(1, typeof args.knowledge_limit === 'number' ? Math.trunc(args.knowledge_limit) : 24)),
+        usageFeedback: usage,
+      })
+    : undefined;
+  const activationByAddress = new Map((activation?.items ?? []).map(item => [
+    memoryAddressKey({ scope: item.memory.scope, id: item.memory.id }),
+    { score: item.score, reasons: item.reasons, activationPath: item.activationPath },
+  ]));
+  return {
+    readonly: true,
+    advisoryOnly: true,
+    authorityBoundary: 'Learned memory never overrides project contracts, authorization, verification, Requirement/Plan/Work, or semantic acceptance.',
+    scopes,
+    filters: {
+      ...(rawQuery ? { query: rawQuery } : {}),
+      ...(requestedKind ? { scopeKind: requestedKind } : {}),
+      ...(requestedId ? { scopeId: requestedId } : {}),
+      ...(typeof args.knowledge_memory_id === 'string' && args.knowledge_memory_id.trim() ? { memoryId: args.knowledge_memory_id.trim() } : {}),
+      ...(typeof args.knowledge_concept === 'string' && args.knowledge_concept.trim() ? { concept: args.knowledge_concept.trim() } : {}),
+      ...(typeof args.knowledge_facet === 'string' && args.knowledge_facet.trim() ? { facet: args.knowledge_facet.trim() } : {}),
+      ...(typeof args.knowledge_source_kind === 'string' && args.knowledge_source_kind.trim() ? { sourceKind: args.knowledge_source_kind.trim() } : {}),
+      ...(typeof args.knowledge_source_work_id === 'string' && args.knowledge_source_work_id.trim() ? { sourceWorkId: args.knowledge_source_work_id.trim() } : {}),
+    },
+    items: audit.items.map(entry => {
+      const address = memoryAddressKey({ scope: entry.memory.scope, id: entry.memory.id });
+      return {
+        memory: entry.memory,
+        relations: entry.relations,
+        recentUsage: usageByAddress.get(address),
+        activation: activationByAddress.get(address),
+      };
+    }),
+    inspected: audit.inspected,
+    truncated: audit.truncated,
+    gaps: [...resolved.gaps, ...(scopeMismatch ? ['requested_cognitive_scope_not_reachable'] : [])],
+  };
+}
+
+function rhContextLearningRecall(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  query: string,
+  workId?: string,
+  limit = RH_CONTEXT_AUTOMATIC_RECALL_LIMIT,
+): Record<string, unknown> {
+  const resolved = rhContextKnowledgeScopes(ctx, repository, workId);
+  if (!query.trim() || resolved.scopes.length === 0) {
+    return { advisoryOnly: true, scopes: resolved.scopes, items: [], gaps: resolved.gaps };
+  }
+  const usage = cognitiveUsageFeedbackForContext({
+    controllerHome: ctx.controllerHome,
+    repoId: repository.repoId,
+    scopes: resolved.scopes,
+    ...(resolved.projectId ? { projectId: resolved.projectId } : {}),
+  });
+  const activation = resolveCognitiveAttention({
+    controllerHome: ctx.controllerHome,
+    scopes: resolved.scopes,
+    query: query.slice(0, 4_000),
+    now: new Date().toISOString(),
+    maxItems: Math.min(8, Math.max(1, limit)),
+    maxBytes: 12 * 1024,
+    usageFeedback: usage,
+  });
+  return {
+    advisoryOnly: true,
+    authorityBoundary: 'Learned context may guide model decisions but never grants execution, lifecycle, or acceptance authority.',
+    scopePolicy: 'unified_relevance_with_narrow_scope_prior',
+    scopes: resolved.scopes,
+    items: activation.items.map(entry => ({
+      memoryId: memoryAddressKey({ scope: entry.memory.scope, id: entry.memory.id }),
+      text: entry.memory.canonicalText,
+      score: entry.score,
+      reasons: entry.reasons,
+      activationPath: entry.activationPath,
+      facets: entry.memory.facets,
+      concepts: entry.memory.concepts,
+      provenance: entry.memory.provenance,
+    })),
+    gaps: [...resolved.gaps, ...activation.gaps],
+    progressiveAttention: {
+      workingSetBounded: true,
+      moreCandidatesAvailable: activation.truncated,
+      inspectedCandidates: activation.inspectedCandidates,
+      modelDecision: activation.truncated
+        ? 'This is an initial working set, not semantic completeness. If the current decision still lacks relevant prior context, issue a narrower rh_context query or an explicit knowledge_query/knowledge_limit expansion; otherwise reuse this working set through routine micro-steps.'
+        : 'Decide whether this working set is semantically sufficient. Reuse it through routine micro-steps; only recall again when the task meaning/strategy changes or missing prior context could change the decision.',
+    },
+  };
+}
+
 const RH_CONTEXT_SEMANTIC_QUERY_LIMIT = 8;
 
 const RH_CONTEXT_SEMANTIC_LOCATION_LIMIT = 200;
@@ -96,6 +280,7 @@ interface RhContextSemanticNavigationProjection {
   providers: unknown[];
   policyDeniedLocations: number;
   policyDeniedReads: number;
+  materialPolicyDeniedReads: number;
   policyDeniedReadSamples: string[];
   requestTruncated: boolean;
   freshness: 'not_requested' | 'changed_during_query' | 'current_at_query';
@@ -116,6 +301,7 @@ async function rhContextSemanticNavigation(
   let anyLocationTruncated = false;
   let policyDeniedLocations = 0;
   let policyDeniedReads = 0;
+  let materialPolicyDeniedReads = 0;
   const policyDeniedReadSamples = new Set<string>();
   const semanticAccessScope = createHash('sha256')
     .update(JSON.stringify({ profile: policy.profile, readGlobs: policy.readGlobs, denyGlobs: policy.denyGlobs }))
@@ -163,6 +349,7 @@ async function rhContextSemanticNavigation(
     const decision = resolveMcpPath(repoRoot, relativePath, policy, 'read');
     if (decision.ok) return true;
     policyDeniedReads += 1;
+    if (!isIncidentalSemanticDependencyProbe(relativePath)) materialPolicyDeniedReads += 1;
     if (policyDeniedReadSamples.size < 20) policyDeniedReadSamples.add(relativePath);
     return false;
   };
@@ -171,6 +358,12 @@ async function rhContextSemanticNavigation(
     cacheScope: `mcp:${semanticAccessScope}`,
     sourceIdentity: sourceFingerprintBefore,
     profile: policy.profile,
+    readPolicy: {
+      profile: policy.profile,
+      readGlobs: [...policy.readGlobs],
+      denyGlobs: [...policy.denyGlobs],
+      maxFileBytes: policy.maxFileBytes,
+    },
     allowRepositoryPath,
   });
 
@@ -180,12 +373,27 @@ async function rhContextSemanticNavigation(
       continue;
     }
     const semantic = outcome.result;
+    const sidecarDeniedReads = Math.max(0, Number(semantic.policyDeniedReads ?? 0));
+    policyDeniedReads += sidecarDeniedReads;
+    materialPolicyDeniedReads += Math.max(0, Number(semantic.materialPolicyDeniedReads ?? sidecarDeniedReads));
+    const sidecarDeniedSamples = semantic.details?.policyDeniedReadSamples;
+    if (Array.isArray(sidecarDeniedSamples)) {
+      for (const sample of sidecarDeniedSamples) {
+        if (policyDeniedReadSamples.size >= 20) break;
+        if (typeof sample === 'string' && sample.trim()) policyDeniedReadSamples.add(sample);
+      }
+    }
     const allowedLocations = semantic.locations.filter((location) => {
       const decision = resolveMcpPath(repoRoot, location.path, policy, 'read');
       if (decision.ok) return true;
       policyDeniedLocations += 1;
       return false;
     });
+    // With no resolved requested relationship, even dependency-only denied reads
+    // may conceal material evidence. Preserve admission blocking for this case.
+    if (allowedLocations.length === 0 && sidecarDeniedReads > 0 && Number(semantic.materialPolicyDeniedReads ?? sidecarDeniedReads) === 0) {
+      materialPolicyDeniedReads += sidecarDeniedReads;
+    }
     const truncated = allowedLocations.length > RH_CONTEXT_SEMANTIC_LOCATION_LIMIT;
     anyLocationTruncated ||= truncated;
     results.push({
@@ -199,6 +407,7 @@ async function rhContextSemanticNavigation(
       returnedLocations: Math.min(allowedLocations.length, RH_CONTEXT_SEMANTIC_LOCATION_LIMIT),
       truncated,
       policyDeniedReads: semantic.policyDeniedReads ?? 0,
+      materialPolicyDeniedReads: semantic.materialPolicyDeniedReads ?? semantic.policyDeniedReads ?? 0,
       ...(semantic.details ?? {}),
     });
   }
@@ -227,7 +436,7 @@ async function rhContextSemanticNavigation(
   }
 
   const requestTruncated = raw.length > RH_CONTEXT_SEMANTIC_QUERY_LIMIT;
-  const incomplete = requestTruncated || anyLocationTruncated || policyDeniedLocations > 0 || policyDeniedReads > 0 || errors.length > 0 || sourceChangedDuringQuery;
+  const incomplete = requestTruncated || anyLocationTruncated || policyDeniedLocations > 0 || materialPolicyDeniedReads > 0 || errors.length > 0 || sourceChangedDuringQuery;
   const languages = new Set(results.map((entry) => String(entry.language ?? '')).filter(Boolean));
   const singleLanguage = languages.size === 1 ? [...languages][0] : undefined;
   const scope = singleLanguage === 'typescript'
@@ -247,6 +456,7 @@ async function rhContextSemanticNavigation(
     providers: defaultSemanticProviderRegistry.list(),
     policyDeniedLocations,
     policyDeniedReads,
+    materialPolicyDeniedReads,
     policyDeniedReadSamples: Array.from(policyDeniedReadSamples),
     requestTruncated,
     freshness: raw.length === 0 ? 'not_requested' : sourceChangedDuringQuery ? 'changed_during_query' : 'current_at_query',
@@ -268,49 +478,96 @@ async function rhContextSemanticNavigation(
   };
 }
 
-function codegraphIndexExists(controllerHome: string, root: string): boolean {
-  return existsSync(join(codegraphRepositoryCacheRoot(controllerHome, root), 'codegraph.db'))
-    || existsSync(join(root, '.codegraph', 'codegraph.db'));
-}
-
 /**
- * Managed worktrees borrow one repository baseline CodeGraph from a non-worktree
- * checkout. Dirty worktree bytes remain a raw/lexical overlay; they never create
- * a second structural-index authority merely because execution is isolated.
- * Repo-local `.codegraph` is retained only as a legacy-readable fallback.
+ * Work-specific source evidence uses the exact registered physical placement.
+ * Work semantic identity stays in Kernel; Repository Registry owns checkout
+ * resolution. This projection neither creates source state nor chooses a
+ * different checkout when the exact Work target has disappeared.
  */
-export function resolveStructuralIndexRoot(
-  controllerHome: string,
-  repository: ReturnType<typeof resolveRepositorySelection>,
-): string | undefined {
-  const active = repository.checkouts.find((checkout) => checkout.checkoutId === repository.activeCheckoutId);
-  const nonWorktreeRoots = repository.checkouts
-    .filter((checkout) => checkout.checkoutId !== repository.activeCheckoutId && checkout.worktree !== true && repositoryCheckoutLifecycle(checkout) === 'active')
-    .map((checkout) => checkout.canonicalRoot);
-  const candidates = active?.worktree === true
-    ? [...nonWorktreeRoots, repository.canonicalRoot]
-    : [repository.canonicalRoot, ...nonWorktreeRoots];
-  return [...new Set(candidates)].find((root) => codegraphIndexExists(controllerHome, root));
+function selectContextSourceRepository(
+  ctx: MultiRepositoryMcpToolContext,
+  args: Record<string, unknown>,
+  operation: string,
+): ReturnType<typeof selected> {
+  const workId = operation === 'search' && typeof args.query === 'string' && args.query.trim()
+    && typeof args.work_id === 'string' ? args.work_id.trim() : '';
+  if (!workId) return selected(ctx, args);
+  const repository = selected(ctx, { ...args, checkout_id: undefined });
+  const work = getWorkContract({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, workId);
+  if (!work) throw new Error(`CONTEXT_WORK_NOT_FOUND: ${workId}`);
+  if (work.repoId && work.repoId !== repository.repoId) {
+    throw new Error(`CONTEXT_WORK_REPOSITORY_MISMATCH: ${workId}`);
+  }
+  const handle = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
+  const workCheckoutId = handle?.checkoutId?.trim()
+    || work.executionPlacement?.checkoutId?.trim()
+    || work.checkoutId?.trim();
+  // Pure semantic Work has no physical source. Keep explicitly elected
+  // repository context for this case instead of inventing source placement.
+  if (!workCheckoutId) return selected(ctx, args);
+  const requestedCheckoutId = typeof args.checkout_id === 'string' ? args.checkout_id.trim() : '';
+  if (requestedCheckoutId && requestedCheckoutId !== workCheckoutId) {
+    throw new Error(`CONTEXT_WORK_CHECKOUT_MISMATCH: ${workId}`);
+  }
+  if (handle?.state === 'cleaned' || handle?.state === 'failed') {
+    throw new Error(`CONTEXT_WORK_CHECKOUT_RETIRED: ${workId}`);
+  }
+  let selectedCheckout: ReturnType<typeof selected>;
+  try {
+    selectedCheckout = selected(ctx, { ...args, repo_id: repository.repoId, checkout_id: workCheckoutId });
+  } catch {
+    throw new Error(`CONTEXT_WORK_CHECKOUT_UNAVAILABLE: ${workId}`);
+  }
+  if (selectedCheckout.activeCheckoutId !== workCheckoutId) {
+    throw new Error(`CONTEXT_WORK_CHECKOUT_MISMATCH: ${workId}`);
+  }
+  if (handle?.expectedHead && freshGitIdentity(selectedCheckout.canonicalRoot).head !== handle.expectedHead) {
+    throw new Error(`CONTEXT_WORK_SOURCE_REVISION_MISMATCH: ${workId}`);
+  }
+  return selectedCheckout;
 }
 
 export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, name: string, args: Record<string, unknown>): Promise<CallToolResult | undefined> {
   if (name !== 'rh_context') return undefined;
-    const repository = selected(ctx, args);
     const operation = String(args.operation ?? 'get');
+    const repository = selectContextSourceRepository(ctx, args, operation);
     if (!allowedFacadeOperations('rh_context').includes(operation)) {
       return invalidFacadeOperation('rh_context', operation);
     }
     if (operation === 'search') {
       const query = typeof args.query === 'string' ? args.query.trim() : '';
-      if (!query) {
+      const knowledgeAuditRequested = rhContextKnowledgeAuditRequested(args);
+      if (!query && !knowledgeAuditRequested) {
         const facade = buildFacadeResult({
           status: 'failed',
-          summary: 'rh_context.search requires a non-empty query.',
+          summary: 'rh_context.search requires a non-empty code query or explicit knowledge audit fields.',
           data: { operation, repoId: repository.repoId },
           suggestedNextActions: [],
         });
         return result(facade as unknown as Record<string, unknown>, true);
       }
+      const cognitionAudit = knowledgeAuditRequested ? rhContextKnowledgeAudit(ctx, repository, args) : undefined;
+      const includeLearningRecall = args.include_learning_recall !== false;
+      const learningRecall = query && !knowledgeAuditRequested && includeLearningRecall
+        ? rhContextLearningRecall(ctx, repository, query, typeof args.work_id === 'string' ? args.work_id.trim() || undefined : undefined)
+        : undefined;
+      if (!query && cognitionAudit) {
+        const items = Array.isArray(cognitionAudit.items) ? cognitionAudit.items : [];
+        const facade = buildFacadeResult({
+          status: 'ok',
+          summary: `Retrieved ${items.length} bounded learned-memory audit item(s).`,
+          data: { operation, repoId: repository.repoId, cognitionAudit },
+          warnings: [],
+          suggestedNextActions: [],
+          detailLevel: args.detail_level === 'detail' || args.detail_level === 'raw' ? args.detail_level : 'summary',
+          rawAvailable: false,
+        });
+        // cognitionAudit is already bounded by scope/item/relation/usage/activation budgets.
+        // Preserve its nested provenance and reasoning rather than letting generic facade depth
+        // bounding turn the read-only audit contract into opaque "[bounded-depth]" markers.
+        (facade.data as typeof facade.data & { cognitionAudit: typeof cognitionAudit }).cognitionAudit = cognitionAudit;
+        return result(facade as unknown as Record<string, unknown>);
+      }
       const legacySemanticQuery = rhContextLegacySemanticQuery(query);
       const retrievalQuery = legacySemanticQuery.retrievalQuery;
       const list = (value: unknown): string[] => Array.isArray(value)
@@ -321,11 +578,10 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
         : 'implementation';
       const impactDomains = list(args.impact_domains)
         .filter((domain): domain is ControllerContextImpactDomain => CONTROLLER_CONTEXT_IMPACT_DOMAINS.includes(domain as ControllerContextImpactDomain));
+      // CodeGraph is opt-in. Ordinary source location never starts a graph index.
       const structuralContext = args.structural_context === 'off' || args.structural_context === 'auto' || args.structural_context === 'required'
         ? args.structural_context
-        : retrievalMode === 'plan' || retrievalMode === 'debug'
-          ? 'required'
-          : 'auto';
+        : 'off';
       const requestedCheckIds = list(args.requested_check_ids);
       // Source retrieval is the default Context responsibility. Check
       // readiness is only meaningful when the controller has named the
@@ -340,25 +596,32 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
             checkoutId: repository.activeCheckoutId,
           })
         : undefined;
-      const pack = await buildControllerContextPackAsync(repository.canonicalRoot, ctx.policy, {
+      // GPT supplies repository-language code hints for natural-language intents.
+      // Forge only searches those literal terms; it does not translate or infer semantics.
+      const codeSearchTerms = list(args.search_terms).filter((term) => term.length <= 160).slice(0, 8);
+      const exactCodeQuery = !/\s/u.test(retrievalQuery) && isCodeShapedTerm(retrievalQuery);
+      const pack = await buildControllerContextPackInSidecar({
+        repoRoot: repository.canonicalRoot,
+        policy: ctx.policy,
+        options: {
         description: retrievalQuery,
-        // Short code-like queries remain useful exact lexical needles. Long
-        // semantic prompts are already tokenized from description; adding the
-        // whole prompt as an exact needle prevents batch-search early exit and
-        // forces a full bounded repository scan for a phrase that will not match.
-        searchTerms: retrievalQuery.length <= 160 ? [retrievalQuery] : undefined,
+        // Only an actual single code identifier is an implicit exact needle.
+        // Prose (including mixed-language queries) stays in description; the
+        // model supplies matching source-language hints through search_terms.
+        searchTerms: codeSearchTerms.length ? codeSearchTerms
+          : exactCodeQuery ? [retrievalQuery] : undefined,
         knownPaths: list(args.known_paths),
         includeGlobs: list(args.include_globs),
         excludeGlobs: list(args.exclude_globs),
         maxFiles: typeof args.max_files === 'number' ? args.max_files : undefined,
         maxSnippets: typeof args.max_snippets === 'number' ? args.max_snippets : undefined,
         structuralContext,
-        structuralIndexRoot: structuralContext === 'off' ? undefined : resolveStructuralIndexRoot(ctx.controllerHome, repository),
         retrievalMode,
         impactDomains,
-        session: rhContextReadSessionId(ctx)
-          ? { sessionId: rhContextReadSessionId(ctx)!, repoId: repository.repoId, checkoutId: repository.activeCheckoutId }
-          : undefined,
+          session: rhContextReadSessionId(ctx)
+            ? { sessionId: rhContextReadSessionId(ctx)!, repoId: repository.repoId, checkoutId: repository.activeCheckoutId }
+            : undefined,
+        },
       });
       const explicitSemanticNavigation = Array.isArray(args.semantic_navigation) ? args.semantic_navigation : [];
       const semanticRequests = [...explicitSemanticNavigation, ...legacySemanticQuery.requests];
@@ -376,7 +639,7 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       const semanticReasonCodes = Array.from(new Set([
         ...semanticNavigation.errors.map((entry) => `semantic.${String(entry.code ?? 'provider_error').toLowerCase()}`),
         ...(semanticNavigation.requestTruncated ? ['semantic.request_truncated'] : []),
-        ...(semanticNavigation.policyDeniedLocations > 0 || semanticNavigation.policyDeniedReads > 0 ? ['semantic.policy_denied'] : []),
+        ...(semanticNavigation.policyDeniedLocations > 0 || semanticNavigation.materialPolicyDeniedReads > 0 ? ['semantic.policy_denied'] : []),
         ...(semanticNavigation.freshness === 'changed_during_query' ? ['semantic.source_changed_during_query'] : []),
         ...(semanticNavigation.requested > 0 && semanticNavigation.staticClosure.status !== 'complete_for_requested_symbols' ? ['semantic.static_closure_incomplete'] : []),
       ]));
@@ -446,13 +709,15 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
           omitted: pack.omitted,
           limits: pack.limits,
           contextContract: pack.contextContract,
+          ...(cognitionAudit ? { cognitionAudit } : {}),
+          ...(learningRecall ? { learningRecall } : {}),
           ...(executionReadiness ? {
             executionReadiness,
             registeredChecks: checks.slice(0, 80).map((check) => ({ id: check.id, description: check.description, source: check.source, effects: check.effects })),
           } : {}),
           retrievalPolicy: {
             defaultBackend: 'bounded_lexical',
-            structuralBackend: 'codegraph',
+            structuralBackend: 'retired',
             rawReadTool: 'read_repository_file',
             shellSearchFallbackOnly: true,
             executionReadiness: 'requested_check_ids_only',
@@ -460,7 +725,7 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
         },
         warnings,
         suggestedNextActions: [],
-        detailLevel: 'summary',
+        detailLevel: args.detail_level === 'detail' || args.detail_level === 'raw' ? args.detail_level : 'summary',
         rawAvailable: true,
       });
       // ContextClosureReceipt already enforces bounded paths, tests, skills, semantic providers,
@@ -468,6 +733,41 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       // but it must not corrupt this runtime-issued round-trip contract because rh_work validates
       // the exact full receipt digest supplied by the Controller during engineering re-entry.
       (facade.data as typeof facade.data & { contextClosure: typeof contextClosure }).contextClosure = contextClosure;
+      // Individual snippets are bounded, but broad searches can still aggregate
+      // a very large direct MCP payload. Keep ContextClosure authority inline and
+      // externalize only the heavy file collection through the existing Result Store.
+      const boundedFiles = boundedRuntimeResult({
+        controllerHome: ctx.controllerHome,
+        repoId: repository.repoId,
+        sessionId: ctx.sessionId,
+        principalId: ctx.principalId,
+        controllerInstanceId: ctx.controllerInstanceId,
+        workId: typeof args.work_id === 'string' ? args.work_id.trim() || undefined : undefined,
+      }, pack.files);
+      const data = facade.data as typeof facade.data & {
+        files: typeof pack.files;
+        filesResult?: unknown;
+        filesTruncated?: boolean;
+        fileCount?: number;
+        filePreview?: Array<{ path: string; reasons: string[]; hitLines: number[]; snippetCount: number }>;
+      };
+      if (boundedFiles.externalized) {
+        data.files = [];
+        data.filesResult = boundedFiles.value;
+        data.filesTruncated = true;
+        data.fileCount = pack.files.length;
+        data.filePreview = pack.files.slice(0, 10).map((file) => ({
+          path: file.path,
+          reasons: file.reasons.slice(0, 4),
+          hitLines: file.hitLines.slice(0, 12),
+          snippetCount: file.snippetCount,
+        }));
+      } else {
+        data.files = pack.files;
+      }
+      if (cognitionAudit) {
+        (facade.data as typeof facade.data & { cognitionAudit: typeof cognitionAudit }).cognitionAudit = cognitionAudit;
+      }
       return result(facade as unknown as Record<string, unknown>);
     }
     const startedAt = performance.now();
@@ -476,20 +776,20 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       const pluginMatch = /^plugin\.([^.]+)\.(.+)$/.exec(requestedCapabilityId);
       const manifests = pluginMatch ? (() => {
         const pluginId = pluginMatch[1];
-        const targets = [repository];
-        const controllerRepository = controllerPluginRepository(ctx.controllerHome);
-        if (controllerRepository.repoId !== repository.repoId) targets.push(controllerRepository);
-        for (const target of targets) {
-          try {
-            return [getAssistantPluginManifest(ctx.controllerHome, target, pluginId)];
-          } catch (error) {
-            if (error instanceof Error && error.message.startsWith('PLUGIN_NOT_FOUND:')) continue;
-            throw error;
-          }
+        try {
+          return [getAssistantPluginManifest(ctx.controllerHome, repository, pluginId)];
+        } catch (error) {
+          if (!(error instanceof Error) || !error.message.startsWith('PLUGIN_NOT_FOUND:')) throw error;
+        }
+        try {
+          return [getControllerPluginManifest(ctx.controllerHome, pluginId)];
+        } catch (error) {
+          if (!(error instanceof Error) || !error.message.startsWith('PLUGIN_NOT_FOUND:')) throw error;
         }
         return [];
       })() : [];
       const descriptor = getCapabilityDescriptor(requestedCapabilityId, manifests);
+      const coreCapability = getCoreCapabilityExecutionSchema(requestedCapabilityId);
       const pluginAction = getPluginActionCapabilitySchema(requestedCapabilityId, manifests);
       const facade = buildFacadeResult({
         status: 'ok',
@@ -509,10 +809,11 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
             requestedCapabilityId,
             found: Boolean(descriptor),
             descriptor,
+            coreCapability,
             pluginAction,
           },
           toolArchitecture: {
-            facadeTools: ['rh_access', 'rh_status', 'rh_inbox', 'rh_context', 'rh_work'],
+            facadeTools: [...FACADE_TOOLS],
             domainSchemaLoading: 'exact_capability_fast_path',
           },
           bounded: true,
@@ -534,18 +835,21 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       ? args.query.trim()
       : '';
     if (capabilityIntentQuery) {
-      const manifestOptions = { preferStored: true };
+      const learningRecall = args.include_learning_recall === false
+        ? undefined
+        : rhContextLearningRecall(ctx, repository, capabilityIntentQuery);
+      // Intent-ranked capability discovery must reflect the executable plugin contract.
+      // Persisted manifests are status projections and may outlive a source release that moved an action.
+      const manifestOptions = { preferStored: false };
       const repositoryManifests = listAssistantPluginManifests(ctx.controllerHome, repository, manifestOptions);
-      const controllerRepository = controllerPluginRepository(ctx.controllerHome);
-      const controllerManifests = repository.repoId === controllerRepository.repoId
-        ? []
-        : listAssistantPluginManifests(ctx.controllerHome, controllerRepository, manifestOptions);
+      const controllerManifests = listControllerPluginManifests(ctx.controllerHome, manifestOptions);
       const manifests = [...new Map(
-        [...repositoryManifests, ...controllerManifests].map((manifest) => [manifest.pluginId, manifest] as const),
+        [...controllerManifests, ...repositoryManifests].map((manifest) => [manifest.pluginId, manifest] as const),
       ).values()];
       const matches = searchCapabilityDescriptors(capabilityIntentQuery, manifests, 12)
         .map((match) => ({
           ...match,
+          coreCapability: getCoreCapabilityExecutionSchema(match.capabilityId),
           pluginAction: getPluginActionCapabilitySchema(match.capabilityId, manifests),
         }));
       const facade = buildFacadeResult({
@@ -560,10 +864,11 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
             query: capabilityIntentQuery,
             matches,
             readOnlyDiscovery: true,
-            executeWith: 'plugin_action_execute',
+            executeWith: 'capability-specific',
           },
+          ...(learningRecall ? { learningRecall } : {}),
           toolArchitecture: {
-            facadeTools: ['rh_access', 'rh_status', 'rh_inbox', 'rh_context', 'rh_work'],
+            facadeTools: [...FACADE_TOOLS],
             domainSchemaLoading: 'intent_ranked_capability_search',
             exactCapabilityLookupStillAvailable: true,
           },
@@ -598,20 +903,25 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       ? readActiveWorkCandidates({ ...store, limit: 20 })
       : { contracts: [], invalid: [] as InvalidActiveWorkCandidate[] };
     const activeContractScan = activeWorkProjection.contracts;
-    const currentCutoffMs = Date.now() - RH_CONTEXT_CURRENT_WINDOW_MS;
-    const currentContractScan = isSummary
-      ? activeContractScan.filter((contract) => isCurrentRhContextWork(contract, currentCutoffMs))
+    const currentLineageWorkIds = work
+      ? currentTaskLineageWorkIds([work.workId], readWorkContractStore(store).contracts)
+      : new Set<string>();
+    const recentActivityCutoffMs = Date.now() - RH_CONTEXT_RECENT_ACTIVITY_WINDOW_MS;
+    const recentActiveContractScan = isSummary
+      ? activeContractScan.filter((contract) => isRecentRhContextWork(contract, recentActivityCutoffMs))
       : activeContractScan;
-    const activeContracts = isSummary ? currentContractScan.slice(0, 3) : activeContractScan;
+    const activeContracts = isSummary ? recentActiveContractScan.slice(0, 3) : activeContractScan;
     const recentJobs = !isSummary && (operation === 'list' || !workId)
       ? listExecutionJobs(ctx.controllerHome, repository.repoId, 20)
-        .filter((job) => timestampIsCurrent(job.updatedAt, currentCutoffMs))
+        .filter((job) => timestampIsRecent(job.updatedAt, recentActivityCutoffMs))
         .slice(0, 5)
       : [];
     const processScan = isSummary
       ? listRecoverableProcessRecords(ctx.controllerHome, repository.repoId)
       : listProcessRecords(ctx.controllerHome, repository.repoId, workId ? 100 : 50);
-    const relevantProcesses = processScan.filter((process) => workId ? process.workId === workId : timestampIsCurrent(process.updatedAt, currentCutoffMs));
+    const relevantProcesses = processScan.filter((process) => work
+      ? Boolean(process.workId && currentLineageWorkIds.has(process.workId))
+      : timestampIsRecent(process.updatedAt, recentActivityCutoffMs));
     const liveProcessIds = new Set(processRuntimeResourceDiagnostics().activeProcessIds);
     const activeProcesses = relevantProcesses.filter((process) => liveProcessIds.has(process.processId) && isManagedProcessActive(process));
     const workController = work ? getControllerSession(store, work.workId) : undefined;
@@ -620,10 +930,7 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       ? []
       : (() => {
           const repositoryManifests = listAssistantPluginManifests(ctx.controllerHome, repository, manifestOptions);
-          const controllerRepository = controllerPluginRepository(ctx.controllerHome);
-          const controllerManifests = repository.repoId === controllerRepository.repoId
-            ? []
-            : listAssistantPluginManifests(ctx.controllerHome, controllerRepository, manifestOptions);
+          const controllerManifests = listControllerPluginManifests(ctx.controllerHome, manifestOptions);
           return [...new Map(
             [...repositoryManifests, ...controllerManifests].map((manifest) => [manifest.pluginId, manifest] as const),
           ).values()];
@@ -636,17 +943,86 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       .filter((check): check is (typeof checks)[number] => Boolean(check))
       .map((check) => ({ id: check.id, description: check.description, source: check.source }));
     const pendingAttention = listHandoffItems({ ...store, status: 'pending', limit: isSummary ? 20 : 5 });
-    const currentWorkIds = new Set(currentContractScan.map((entry) => entry.workId));
-    const currentAttentionScan = isSummary
-      ? pendingAttention.filter((item) => (
-        Boolean(item.workId && currentWorkIds.has(item.workId))
-        || timestampIsCurrent(item.updatedAt, currentCutoffMs)
-      ))
-      : pendingAttention;
-    const workAttention = work ? currentAttentionScan.find((item) => item.workId === work.workId) : undefined;
-    const currentAttentionItems = isSummary
-      ? currentAttentionScan.slice(0, 3)
-      : pendingAttention;
+    const currentAttentionScan = listHandoffAttentionItems(store, isSummary ? 20 : 5);
+    const workAttentionItems = work
+      ? currentAttentionScan.filter((item) => Boolean(item.workId && currentLineageWorkIds.has(item.workId)))
+      : [];
+    const workAttention = workAttentionItems[0];
+    const resumeContext = work ? (() => {
+      const semanticWork = workSemanticView(work);
+      const requirementRecord = work.requirementId?.trim()
+        ? readRequirement({ controllerHome: ctx.controllerHome }, work.requirementId.trim())
+        : undefined;
+      const semanticRequirement = requirementRecord ? requirementSemanticView(requirementRecord.value) : undefined;
+      const plan = work.planId?.trim() ? getPlanContract(store, work.planId.trim()) : undefined;
+      const semanticPlan = plan ? planSemanticView(plan) : undefined;
+      const exactCheckout = work.checkoutId?.trim()
+        ? repository.checkouts.find((candidate) => candidate.checkoutId === work.checkoutId)
+        : repository.checkouts.find((candidate) => candidate.checkoutId === repository.activeCheckoutId);
+      const source = freshGitIdentity(exactCheckout?.canonicalRoot ?? repository.canonicalRoot);
+      const unresolvedHumanRequests = workAttentionItems
+        .filter((item) => Boolean(item.creationReason && RESUME_CONTEXT_HUMAN_REQUEST_REASONS.has(item.creationReason)))
+        .slice(0, 8)
+        .map((item) => ({
+          id: item.id,
+          reason: item.reason.slice(0, 500),
+          creationReason: item.creationReason,
+          blockingDecision: item.blockingDecision?.slice(0, 500),
+          recommendedDecision: item.recommendedDecision.slice(0, 500),
+        }));
+      const checkReceiptRefs = work.checkRefs
+        .flatMap((record) => record.receipt?.receiptId?.trim() ? [record.receipt.receiptId.trim()] : [])
+        .slice(-24);
+      return {
+        schemaVersion: 1 as const,
+        derived: true as const,
+        semantic: {
+          ...(semanticRequirement ? { requirement: semanticRequirement } : {}),
+          ...(semanticPlan ? { plan: semanticPlan } : {}),
+          work: semanticWork,
+        },
+        source: {
+          checkoutId: exactCheckout?.checkoutId ?? work.checkoutId,
+          worktree: exactCheckout?.worktree ?? false,
+          head: source.head,
+          branch: source.branch,
+          dirty: source.dirty,
+          workingTreeFingerprint: source.workingTreeFingerprint,
+          observedAt: new Date(source.sampledAt).toISOString(),
+        },
+        staleness: {
+          requirementBasisStale: Boolean(semanticRequirement && semanticPlan?.requirementBasisRevision && semanticRequirement.revision !== semanticPlan.requirementBasisRevision),
+          workRequirementBasisStale: Boolean(semanticRequirement && semanticWork.requirementRevision && semanticRequirement.revision !== semanticWork.requirementRevision),
+          workPlanBasisStale: Boolean(semanticPlan && semanticWork.planRevision && semanticPlan.revision !== semanticWork.planRevision),
+          sourceBasisStale: Boolean(semanticPlan?.sourceBasisRevision && source.head && semanticPlan.sourceBasisRevision !== source.head),
+          advisoryOnly: true as const,
+        },
+        unresolvedHumanRequests,
+        durableHandles: {
+          processes: relevantProcesses.slice(0, 8).map((process) => ({
+            processId: process.processId,
+            status: process.status,
+            workId: process.workId,
+            updatedAt: process.updatedAt,
+          })),
+          ...(workController ? { controller: {
+            controllerType: workController.controllerType,
+            sessionId: workController.sessionId,
+            leaseExpiresAt: workController.leaseExpiresAt,
+          } } : {}),
+        },
+        receipts: {
+          resultRefs: semanticWork.resultRefs,
+          ...(work.completionReceipt?.receiptId?.trim() ? { completionReceiptRef: work.completionReceipt.receiptId.trim() } : {}),
+          checkReceiptRefs,
+        },
+      };
+    })() : undefined;
+    const currentAttentionItems = work
+      ? workAttentionItems
+      : isSummary
+        ? currentAttentionScan.slice(0, 3)
+        : currentAttentionScan;
     const attention = isSummary
       ? currentAttentionItems.map((item) => ({
         id: item.id,
@@ -695,8 +1071,7 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       work: work
         ? {
             workId: work.workId,
-            status: work.status,
-            mode: work.mode,
+            state: work.semanticState,
             objective: work.objective.slice(0, 160),
             continuation: buildWorkContinuationSnapshot(work),
           }
@@ -706,14 +1081,13 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       activeController: workController ? { controllerType: workController.controllerType, sessionId: workController.sessionId, leaseExpiresAt: workController.leaseExpiresAt } : undefined,
       activeProcesses: activeProcesses.slice(0, 3).map((process) => ({ processId: process.processId, workId: process.workId, status: process.status, route: process.route, startedAt: process.startedAt, updatedAt: process.updatedAt })),
       recentProcesses: relevantProcesses.slice(0, 5).map((process) => ({ processId: process.processId, workId: process.workId, status: process.status, route: process.route, startedAt: process.startedAt, updatedAt: process.updatedAt })),
+      currentTask: work ? currentTaskSemanticProjectionForWork(work) : undefined,
+      ...(resumeContext ? { resumeContext } : {}),
       activeWork: activeContracts.map((entry) => ({
+        relation: 'repository_inventory' as const,
+        relevance: ['ownership', 'conflict', 'release_admission'] as const,
         workId: entry.workId,
-        status: entry.status,
-        mode: entry.mode,
-        objective: entry.objective.slice(0, 160),
-        semantics: buildWorkContinuationSnapshot(entry).semantics,
-        reconciliationRequired: buildWorkContinuationSnapshot(entry).reconciliationRequired,
-        nextSafeAction: buildWorkContinuationSnapshot(entry).nextSafeAction,
+        state: entry.semanticState,
       })),
       invalidActiveWork: activeWorkProjection.invalid.slice(0, 3).map(summarizeInvalidActiveWorkCandidate),
       activeAttention: attention,
@@ -721,21 +1095,23 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
         availableChecks: checks.length,
         selectedChecks: selectedChecks.length,
         capabilityInventoryDeferred: true,
-        activeWork: currentContractScan.length,
+        activeWork: recentActiveContractScan.length,
         activeWorkShown: activeContracts.length,
+        recentActiveWork: recentActiveContractScan.length,
         invalidActiveWork: activeWorkProjection.invalid.length,
         invalidActiveWorkShown: Math.min(activeWorkProjection.invalid.length, 3),
         storedNonTerminalWork: activeContractScan.length,
-        currentWork: currentContractScan.length,
-        historicalNonTerminalWork: Math.max(0, activeContractScan.length - currentContractScan.length),
-        currentAttention: currentAttentionScan.length,
+        currentWork: work ? 1 : 0,
+        historicalNonTerminalWork: Math.max(0, activeContractScan.length - recentActiveContractScan.length),
+        currentAttention: work ? workAttentionItems.length : 0,
+        repositoryAttention: currentAttentionScan.length,
         currentAttentionShown: attention.length,
         activeProcesses: activeProcesses.length,
         recentProcesses: relevantProcesses.length,
         historicalProcessScanDeferred: true,
         pendingAttentionScanned: pendingAttention.length,
         historicalPendingAttention: Math.max(0, pendingAttention.length - currentAttentionScan.length),
-        omittedCurrentAttention: Math.max(0, currentAttentionScan.length - attention.length),
+        omittedCurrentAttention: Math.max(0, (work ? workAttentionItems.length : 0) - attention.length),
         omittedPendingAttention: Math.max(0, pendingAttention.length - attention.length),
       },
       historicalExecutionJobsIncluded: false,
@@ -768,6 +1144,8 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
         domainSchemaLoading: 'static_stable_surface',
         dynamicDomainSchemaLoadingSupported: false,
       },
+      currentTask: work ? currentTaskSemanticProjectionForWork(work) : undefined,
+      ...(resumeContext ? { resumeContext } : {}),
       work: work ? { ...work, continuation: buildWorkContinuationSnapshot(work) } : undefined,
       executionJob: executionJob ? summarizeWorkListItem(executionJob) : undefined,
       executionState: work ? (workAttention ? 'blocked' : activeProcesses.length > 0 ? 'executing' : workController ? 'controller_active' : 'waiting_trigger') : undefined,
@@ -775,11 +1153,10 @@ export async function callContextAdapter(ctx: MultiRepositoryMcpToolContext, nam
       activeProcesses: activeProcesses.slice(0, 10),
       recentProcesses: relevantProcesses.slice(0, 20),
       activeWork: activeContracts.map((entry) => ({
+        relation: 'repository_inventory' as const,
+        relevance: ['ownership', 'conflict', 'release_admission'] as const,
         workId: entry.workId,
-        status: entry.status,
-        mode: entry.mode,
-        objective: entry.objective.slice(0, 240),
-        continuation: buildWorkContinuationSnapshot(entry),
+        state: entry.semanticState,
       })),
       invalidActiveWork: activeWorkProjection.invalid.slice(0, 10).map(summarizeInvalidActiveWorkCandidate),
       recentExecutionJobs: recentJobs.map(summarizeWorkListItem),