frontend-project-context 1.6.0 → 1.7.0

package/src/project-context/capabilities.mjs

@@ -26,17 +26,32 @@ import {
   UPGRADE_ASSESSMENT_SCHEMA_VERSION,
   UPGRADE_RESULT_BUNDLE_SCHEMA_VERSION,
 } from "./upgrade-schema.mjs";
+import {
+  ADAPTIVE_CONTEXT_BUNDLE_SCHEMA_VERSION,
+  CONTEXT_QUERY_SCHEMA_VERSION,
+  COVERAGE_AUDIT_SCHEMA_VERSION,
+  ROUTING_INDEX_SCHEMA_VERSION,
+} from "./adaptive-context-schema.mjs";
+import {
+  HOST_PROMOTION_EVIDENCE_SCHEMA_VERSION,
+  TRUTH_RECONCILIATION_INPUT_SCHEMA_VERSION,
+  TRUTH_RECONCILIATION_REVIEW_BUNDLE_SCHEMA_VERSION,
+} from "./truth-reconciliation-schema.mjs";
 
 function schemas(projectionLockWritten = 1) {
   return {
     actionPlan: ACTION_PLAN_SCHEMA_VERSION,
+    adaptiveContextBundle: ADAPTIVE_CONTEXT_BUNDLE_SCHEMA_VERSION,
     assistBundle: ASSIST_BUNDLE_SCHEMA_VERSION,
     capabilities: CAPABILITIES_SCHEMA_VERSION,
     contract: 2,
+    contextQuery: CONTEXT_QUERY_SCHEMA_VERSION,
+    coverageAudit: COVERAGE_AUDIT_SCHEMA_VERSION,
     dashboardViewModel: DASHBOARD_SCHEMA_VERSION,
     evidenceBundle: EVIDENCE_BUNDLE_SCHEMA_VERSION,
     evidenceInput: EVIDENCE_INPUT_SCHEMA_VERSION,
     integrationReviewBundle: INTEGRATION_REVIEW_BUNDLE_SCHEMA_VERSION,
+    hostPromotionEvidence: HOST_PROMOTION_EVIDENCE_SCHEMA_VERSION,
     projectionLock: 2,
     projectionLockReadable: [1, 2],
     projectionLockWritten,
@@ -47,10 +62,13 @@ function schemas(projectionLockWritten = 1) {
     migrationManifest: 2,
     migrationPlan: MIGRATION_PLAN_SCHEMA_VERSION,
     reviewBundle: REVIEW_BUNDLE_SCHEMA_VERSION,
+    routingIndex: ROUTING_INDEX_SCHEMA_VERSION,
     sourceLock: 1,
     stageContextBundle: STAGE_CONTEXT_BUNDLE_SCHEMA_VERSION,
     stageReceipt: STAGE_RECEIPT_SCHEMA_VERSION,
     taskContextPlan: TASK_CONTEXT_PLAN_SCHEMA_VERSION,
+    truthReconciliationInput: TRUTH_RECONCILIATION_INPUT_SCHEMA_VERSION,
+    truthReconciliationReviewBundle: TRUTH_RECONCILIATION_REVIEW_BUNDLE_SCHEMA_VERSION,
     upgradeAssessment: UPGRADE_ASSESSMENT_SCHEMA_VERSION,
     upgradeResultBundle: UPGRADE_RESULT_BUNDLE_SCHEMA_VERSION,
   };

package/src/project-context/checker.mjs

@@ -8,7 +8,8 @@ import { findConflicts, validateOverrides } from "./scope-compiler.mjs";
 import { parseProjectionMarker, RENDERER_VERSION, renderProjection } from "./renderer.mjs";
 import { resolveWritableInside } from "./path-policy.mjs";
 
-export async function checkProject(root, project) {
+export async function checkProject(root, project, options = {}) {
+  const sourceReadContext = options.sourceReadContext;
   const findings = [];
   const contractSourceIds = new Set(project.contract.sources.map((source) => source.id));
   const sourceLock = new Map(project.sourcesLock.sources.map((entry) => [entry.id, entry.digest]));
@@ -25,7 +26,7 @@ export async function checkProject(root, project) {
       continue;
     }
     try {
-      const actual = await readSourceDigest(root, source);
+      const actual = await readSourceDigest(root, source, sourceReadContext);
       if (actual !== locked) findings.push({ code: "source-changed", source: source.id, path: source.path, expected: locked, actual });
     } catch (error) {
       const code = error.code === "source-missing"
@@ -51,7 +52,7 @@ export async function checkProject(root, project) {
   const sourceMap = new Map(project.contract.sources.map((source) => [source.id, source]));
   for (const item of project.contract.items.filter((candidate) => candidate.status === "approved")) {
     try {
-      const verification = await verifyItem(root, item, sourceMap);
+      const verification = await verifyItem(root, item, sourceMap, sourceReadContext);
       if (verification) findings.push(verification);
     } catch (error) {
       findings.push({

package/src/project-context/cli.mjs

@@ -1,4 +1,5 @@
 import { buildSetupAssistBundle, buildSyncAssistBundle } from "./assist.mjs";
+import { buildAdaptiveContextBundleFiles, buildAdaptiveContextDeliveryFiles, buildCoverageAuditFiles, indexContextFiles } from "./adaptive-context.mjs";
 import { approvePendingItems, approveProposal } from "./approver.mjs";
 import { buildItemProposal, registerSource } from "./authoring.mjs";
 import { blockingContextFindings, checkExitCode, checkProject } from "./checker.mjs";
@@ -22,6 +23,7 @@ import { buildProjectStatus } from "./project-status.mjs";
 import { renderContextBundle } from "./renderer.mjs";
 import { buildIntegrationReviewBundleFiles, buildStageContextBundleFiles } from "./task-context.mjs";
 import { applyMigrationPlanFile, buildMigrationPlanFile, buildUpgradeAssessment } from "./upgrade.mjs";
+import { buildTruthReconciliationReviewFiles } from "./truth-reconciliation.mjs";
 
 const HELP = `project-context — model-neutral project contract compiler
 
@@ -44,6 +46,9 @@ Usage:
   project-context discover --project PATH [--output FILE --write] [--json]
   project-context approve --project PATH (--proposal FILE | --pending) --ids ID... --by NAME [--rationale TEXT] [--write] [--json | --full-json]
   project-context context --project PATH --path RELATIVE_PATH... [--task TEXT] [--locale zh-CN|en|all] [--json]
+  project-context context-query --project PATH --input FILE [--previous FILE] [--json | --prompt]
+  project-context coverage-audit --project PATH [--changed-path RELATIVE_PATH...] [--json]
+  project-context index-context --project PATH [--write] [--json]
   project-context publish --project PATH --target agents|ruler --output FILE [--path RELATIVE_PATH...] [--write] [--json]
   project-context publish-entry --project PATH --output AGENTS.md [--write] [--json]
   project-context remove-entry --project PATH --output AGENTS.md [--write] [--json]
@@ -53,19 +58,20 @@ Usage:
   project-context preflight --project PATH --plan FILE [--json]
   project-context stage-context --project PATH --plan FILE --stage STAGE_ID [--receipt FILE...] [--receipt-bundle FILE...] [--changed-path RELATIVE_PATH...] [--json]
   project-context integration-review --project PATH --plan FILE [--receipt FILE...] [--receipt-bundle FILE...] [--main-changed-path RELATIVE_PATH...] [--branch-changed-path RELATIVE_PATH...] [--json]
+  project-context reconcile-truth --project PATH --input FILE... [--previous-review FILE] [--json]
 
 All commands are read-only unless their own --write flag is present.
 `;
 const VALUE_FLAGS = new Set([
-  "project", "id", "name", "input", "output", "proposal", "by", "task", "target", "rationale",
+  "project", "id", "name", "output", "proposal", "by", "task", "target", "rationale",
   "kind", "pointer", "reference", "subject", "value", "value-json", "statement", "scope", "scope-path",
   "verification", "verification-source", "verification-expected-json",
-  "expected-digest", "expected-item-digest", "expected-source-digest", "locale", "plan", "stage", "from-version", "assessment",
+  "expected-digest", "expected-item-digest", "expected-source-digest", "locale", "plan", "stage", "from-version", "assessment", "previous", "previous-review",
 ]);
 const LIST_FLAGS = new Set([
-  "ids", "path", "changed-path", "sources", "overrides", "affected-items", "receipt", "receipt-bundle", "main-changed-path", "branch-changed-path",
+  "ids", "path", "input", "changed-path", "sources", "overrides", "affected-items", "receipt", "receipt-bundle", "main-changed-path", "branch-changed-path",
 ]);
-const BOOLEAN_FLAGS = new Set(["write", "json", "full-json", "help", "pending"]);
+const BOOLEAN_FLAGS = new Set(["write", "json", "full-json", "help", "pending", "prompt"]);
 const COMMAND_OPTIONS = new Map([
   ["init", new Set(["project", "id", "name", "write", "json", "help"])],
   ["capabilities", new Set(["project", "json", "help"])],
@@ -98,6 +104,9 @@ const COMMAND_OPTIONS = new Map([
   ["discover", new Set(["project", "output", "write", "json", "help"])],
   ["approve", new Set(["project", "proposal", "pending", "ids", "by", "rationale", "write", "json", "full-json", "help"])],
   ["context", new Set(["project", "path", "task", "locale", "json", "help"])],
+  ["context-query", new Set(["project", "input", "previous", "json", "prompt", "help"])],
+  ["coverage-audit", new Set(["project", "changed-path", "json", "help"])],
+  ["index-context", new Set(["project", "write", "json", "help"])],
   ["publish", new Set(["project", "target", "output", "path", "write", "json", "help"])],
   ["publish-entry", new Set(["project", "output", "write", "json", "help"])],
   ["remove-entry", new Set(["project", "output", "write", "json", "help"])],
@@ -107,6 +116,7 @@ const COMMAND_OPTIONS = new Map([
   ["preflight", new Set(["project", "plan", "json", "help"])],
   ["stage-context", new Set(["project", "plan", "stage", "receipt", "receipt-bundle", "changed-path", "json", "help"])],
   ["integration-review", new Set(["project", "plan", "receipt", "receipt-bundle", "main-changed-path", "branch-changed-path", "json", "help"])],
+  ["reconcile-truth", new Set(["project", "input", "previous-review", "json", "help"])],
 ]);
 
 export function parseArgs(argv) {
@@ -348,7 +358,7 @@ async function runCommand(command, options) {
     return { exitCode: result.exitCode, stdout: jsonOrText(options, result.status, summary), stderr: "" };
   }
   if (command === "evidence") {
-    const bundle = await buildEvidenceBundleFile(root, required(options, "input"));
+    const bundle = await buildEvidenceBundleFile(root, oneListValue(options, "input"));
     const summary = [
       `Evidence ${bundle.result}; project health ${bundle.projectContext.health}.`,
       `Finding codes: ${bundle.projectContext.findingCodes.join(", ") || "none"}.`,
@@ -411,6 +421,26 @@ async function runCommand(command, options) {
     const summary = `Stage context ${bundle.status}: ${bundle.stage.id}; ${bundle.contractItems.length} contract item(s), ${bundle.readTargets.length} read target(s), ${bundle.budget.usedUtf8Bytes}/${bundle.budget.maxUtf8Bytes} UTF-8 bytes.\n`;
     return { exitCode: bundle.status === "ready" ? 0 : 1, stdout: jsonOrText(options, bundle, summary), stderr: "" };
   }
+  if (command === "context-query") {
+    if (options.json && options.prompt) fail("argument-conflict", "context-query accepts only one of --json or --prompt");
+    if (options.prompt) {
+      const result = await buildAdaptiveContextDeliveryFiles(root, oneListValue(options, "input"), { previousPath: options.previous });
+      return { exitCode: result.bundle.taskHealth === "ready" ? 0 : 1, stdout: result.content, stderr: "" };
+    }
+    const bundle = await buildAdaptiveContextBundleFiles(root, oneListValue(options, "input"), { previousPath: options.previous });
+    const summary = `Adaptive context ${bundle.taskHealth}: ${bundle.hydratedItems.length} hydrated, ${bundle.retainedItemIds.length} retained, ${bundle.deferredItems.length} deferred item(s); audit ${bundle.budget.audit.usedUtf8Bytes}/${bundle.budget.audit.maxUtf8Bytes}, delivery ${bundle.budget.delivery.usedUtf8Bytes}/${bundle.budget.delivery.maxUtf8Bytes} UTF-8 bytes.\n`;
+    return { exitCode: bundle.taskHealth === "ready" ? 0 : 1, stdout: jsonOrText(options, bundle, summary), stderr: "" };
+  }
+  if (command === "coverage-audit") {
+    const audit = await buildCoverageAuditFiles(root, options["changed-path"] ?? []);
+    const summary = `Registration coverage ${audit.registrationCoverage}: ${audit.categories["review-required"].length} review-required candidate(s).\n`;
+    return { exitCode: audit.registrationCoverage === "review-required" ? 1 : 0, stdout: jsonOrText(options, audit, summary), stderr: "" };
+  }
+  if (command === "index-context") {
+    const index = await indexContextFiles(root, { write: options.write });
+    const summary = `Routing index ${options.write ? "written" : "preview"}: ${index.items.length} item(s), ${index.sources.length} source(s); ${index.indexDigest}.\n`;
+    return { exitCode: 0, stdout: jsonOrText(options, index, summary), stderr: "" };
+  }
   if (command === "integration-review") {
     const bundle = await buildIntegrationReviewBundleFiles(root, required(options, "plan"), {
       receiptPaths: options.receipt ?? [],
@@ -421,6 +451,11 @@ async function runCommand(command, options) {
     const summary = `Integration review ${bundle.status}: ${bundle.findings.length} finding(s), ${bundle.contractOverlapItemIds.length} contract overlap(s), ${bundle.decisionCandidates.length} decision candidate(s).\n`;
     return { exitCode: bundle.status === "reviewable" ? 0 : 1, stdout: jsonOrText(options, bundle, summary), stderr: "" };
   }
+  if (command === "reconcile-truth") {
+    const bundle = await buildTruthReconciliationReviewFiles(root, required(options, "input"), { previousReviewPath: options["previous-review"] });
+    const summary = `Truth reconciliation ${bundle.summary.taskHealth}: ${bundle.summary.collisionGroups} collision group(s), ${bundle.summary.findings} finding(s); existing delivery ${bundle.summary.existingDelivery}.\n`;
+    return { exitCode: bundle.summary.taskHealth === "ready" ? 0 : 1, stdout: jsonOrText(options, bundle, summary), stderr: "" };
+  }
   const project = await loadProject(root);
   if (command === "register") {
     const result = await registerSource(root, project, {

package/src/project-context/contract-schema.mjs

@@ -308,7 +308,7 @@ export function validateProjectionLock(lock) {
       if (entry.regionId !== "project-context-ai-entry") fail("schema-invalid-enum", "AI Entry regionId is invalid");
       string(entry.regionDigest, `${label}.regionDigest`);
       if (!SHA256.test(entry.regionDigest)) fail("schema-invalid", "AI Entry regionDigest must be sha256");
-      if (entry.rendererVersion !== 1) fail("schema-version-unsupported", "AI Entry rendererVersion must be 1");
+      if (![1, 2, 3].includes(entry.rendererVersion)) fail("schema-version-unsupported", "AI Entry rendererVersion must be 1, 2, or 3");
       if (typeof entry.createdFile !== "boolean") fail("schema-invalid", `${label}.createdFile must be boolean`);
     } else {
       if (entry.target !== "agents" && entry.target !== "ruler") fail("schema-invalid-enum", "projection target is invalid");

package/src/project-context/discovery.mjs

@@ -145,7 +145,7 @@ export async function discoverProject(root, contract) {
           id: "fact-package-manager",
           subject: "project.package-manager",
           value: packageJson.packageManager,
-          statement: `The project declares package manager ${packageJson.packageManager}.`,
+          statement: `项目声明使用包管理器 ${packageJson.packageManager}。`,
           source,
         }));
       }
@@ -155,7 +155,7 @@ export async function discoverProject(root, contract) {
           id: `fact-${scriptId}`,
           subject: `project.${scriptId.replaceAll("-", ".")}`,
           value: packageJson.scripts[name],
-          statement: `The project declares the ${name} script.`,
+          statement: `项目声明了 ${name} 脚本。`,
           source,
         }));
       }
@@ -167,7 +167,7 @@ export async function discoverProject(root, contract) {
           id: `fact-${dependencyId}`,
           subject: `project.${dependencyId.replaceAll("-", ".")}`,
           value: dependencies[name],
-          statement: `The project declares ${name} as a dependency.`,
+          statement: `项目声明 ${name} 为依赖。`,
           source,
         }));
       }
@@ -181,7 +181,7 @@ export async function discoverProject(root, contract) {
       id: `fact-${configId}`,
       subject: `project.${configId.replaceAll("-", ".")}`,
       value: true,
-      statement: `The project contains ${relative}.`,
+      statement: `项目包含 ${relative}。`,
       source,
     }));
   }
@@ -191,7 +191,7 @@ export async function discoverProject(root, contract) {
       id: `fact-${generatedId("top-level-directory", relative)}`,
       subject: "project.structure.top-level-directory",
       value: relative,
-      statement: `The project contains the top-level directory ${relative}.`,
+      statement: `项目包含顶层目录 ${relative}。`,
       source,
       scope: { kind: "path-prefix", path: relative },
     }));
@@ -221,7 +221,7 @@ export async function discoverProject(root, contract) {
       kind: "reference",
       subject: `agent-rules.${slug(relative)}`,
       value: relative,
-      statement: `Review the existing Agent instruction source at ${relative}.`,
+      statement: `阅读现有 AI Agent 指令源 ${relative}。`,
       source,
       scope: relative.includes("/") && !relative.startsWith(".")
         ? { kind: "path-prefix", path: path.posix.dirname(relative) }
@@ -243,7 +243,7 @@ export async function discoverProject(root, contract) {
         kind: "reference",
         subject: `registered-source.${source.id.replaceAll("-", ".")}`,
         value: source.path ?? source.reference,
-        statement: `Review the explicitly registered project source ${source.id}.`,
+        statement: `阅读显式登记的项目源 ${source.id}。`,
         source: source.id,
       }));
     } catch {

package/src/project-context/exchange-schema.mjs

@@ -2,11 +2,11 @@ import { canonicalValue, digestJson, validateJsonValue } from "./canonical-json.
 import { fail } from "./errors.mjs";
 import { normalizeRelativePath } from "./path-policy.mjs";
 
-export const PACKAGE_VERSION = "1.6.0";
-export const EXCHANGE_PROTOCOL_VERSION = 4;
+export const PACKAGE_VERSION = "1.7.0";
+export const EXCHANGE_PROTOCOL_VERSION = 7;
 export const ACTION_PLAN_SCHEMA_VERSION = 2;
 export const REVIEW_BUNDLE_SCHEMA_VERSION = 2;
-export const CAPABILITIES_SCHEMA_VERSION = 4;
+export const CAPABILITIES_SCHEMA_VERSION = 7;
 
 export const ACTION_KINDS = Object.freeze([
   "accept-source-change",
@@ -22,10 +22,11 @@ export const ACTION_KINDS = Object.freeze([
 ]);
 
 export const COMMANDS = Object.freeze([
-  "accept-source-change", "approve", "capabilities", "check", "context", "dashboard", "deprecate",
+  "accept-source-change", "approve", "capabilities", "check", "context", "context-query", "coverage-audit", "dashboard", "deprecate",
   "deprecate-source", "discover", "evidence", "init", "integration-review", "preflight", "propose", "publish", "register",
-  "publish-entry", "remove-entry", "review-source", "revise", "setup", "stage-context", "status", "sync",
+  "index-context", "publish-entry", "remove-entry", "review-source", "revise", "setup", "stage-context", "status", "sync",
   "upgrade-apply", "upgrade-check", "upgrade-plan",
+  "reconcile-truth",
 ]);
 
 const ACTION_KIND_SET = new Set(ACTION_KINDS);

package/src/project-context/maintenance.mjs

@@ -79,7 +79,7 @@ export function sourceImpact(project, sourceId) {
   return { ...relations, directProjectionPaths, staleProjectionPaths };
 }
 
-export async function reviewSource(root, project, sourceId) {
+export async function reviewSource(root, project, sourceId, options = {}) {
   const source = project.contract.sources.find((entry) => entry.id === sourceId);
   if (!source) fail("source-not-found", `source is not registered: ${sourceId}`, { details: { source: sourceId } });
   const sourceObjectDigest = digestJson(source);
@@ -104,7 +104,7 @@ export async function reviewSource(root, project, sourceId) {
   let status;
   let reason;
   try {
-    currentDigest = await readSourceDigest(root, source);
+    currentDigest = await readSourceDigest(root, source, options.sourceReadContext);
     if (lockedDigest === null || lockedDigest !== source.digest) {
       status = "unreadable";
       reason = lockedDigest === null ? "source-lock-missing" : "source-lock-mismatch";

package/src/project-context/migration-manifest.mjs

@@ -22,8 +22,9 @@ const MIGRATION_KINDS = new Set([
 ]);
 const ROLLBACK_CLASSES = new Set(["package-only", "reversible-data", "forward-only"]);
 const CONSUMER_CHANGE_KEYS = new Set([
-  "actionPlan", "capabilities", "evidenceBundle", "evidenceInput", "exchange",
-  "integrationReviewBundle", "reviewBundle", "stageContextBundle", "stageReceipt", "taskContextPlan",
+  "actionPlan", "adaptiveContextBundle", "capabilities", "contextQuery", "coverageAudit", "evidenceBundle", "evidenceInput", "exchange",
+  "hostPromotionEvidence", "integrationReviewBundle", "reviewBundle", "routingIndex", "stageContextBundle", "stageReceipt", "taskContextPlan",
+  "truthReconciliationInput", "truthReconciliationReviewBundle",
 ]);
 
 function invalid(message, details) {
@@ -102,7 +103,7 @@ export function validateMigrationManifest(input) {
   ]), "migration manifest");
   if (manifest.schemaVersion !== MIGRATION_MANIFEST_SCHEMA_VERSION) invalid("migration manifest schemaVersion must be 2");
   exactKeys(manifest.package, new Set(["name", "version"]), "migration manifest package");
-  if (manifest.package.name !== "frontend-project-context" || manifest.package.version !== "1.6.0") invalid("migration manifest package does not match this runtime");
+  if (manifest.package.name !== "frontend-project-context" || manifest.package.version !== "1.7.0") invalid("migration manifest package does not match this runtime");
   versions(manifest.upgradeFrom, "upgradeFrom");
   if (manifest.upgradeFrom.length === 0) invalid("upgradeFrom must not be empty");
   exactKeys(manifest.stores, new Set(["contract", "projectionLock", "proposal", "sourceLock"]), "stores");
@@ -110,8 +111,9 @@ export function validateMigrationManifest(input) {
   exactKeys(manifest.renderers, new Set(["aiEntry", "projection"]), "renderers");
   for (const name of Object.keys(manifest.renderers)) versionMatrix(manifest.renderers[name], `renderers.${name}`);
   exactKeys(manifest.protocols, new Set([
-    "exchange", "actionPlan", "reviewBundle", "evidenceInput", "evidenceBundle", "taskContextPlan",
-    "stageReceipt", "stageContextBundle", "integrationReviewBundle",
+    "exchange", "actionPlan", "adaptiveContextBundle", "contextQuery", "coverageAudit", "reviewBundle", "evidenceInput", "evidenceBundle", "taskContextPlan",
+    "routingIndex", "stageReceipt", "stageContextBundle", "integrationReviewBundle", "hostPromotionEvidence",
+    "truthReconciliationInput", "truthReconciliationReviewBundle",
   ]), "protocols");
   for (const name of Object.keys(manifest.protocols)) versionMatrix(manifest.protocols[name], `protocols.${name}`);
   if (!Array.isArray(manifest.builtInMigrations)) invalid("builtInMigrations must be an array");

package/src/project-context/renderer.mjs

@@ -1,5 +1,5 @@
 import { canonicalJson, digestJson, sha256 } from "./canonical-json.mjs";
-import { describeScope, effectiveItems } from "./scope-compiler.mjs";
+import { describeScope, effectiveItems, scopeApplies } from "./scope-compiler.mjs";
 import { normalizeRelativePath } from "./path-policy.mjs";
 
 const KIND_TITLES = new Map([
@@ -107,6 +107,80 @@ export function renderContextBundle(contract, paths, task, options = {}) {
   return renderCollectedBundle(collectBundle(contract, paths), contract.sources, task, options);
 }
 
+export function renderSelectedContextBundle(contract, paths, itemIds, task, options = {}) {
+  const selected = new Set(itemIds);
+  const normalizedPaths = paths.map((value) => normalizeRelativePath(value, { allowRoot: true, label: "target path" }));
+  const selectedItems = contract.items.filter((item) => item.status === "approved" && selected.has(item.id));
+  const sections = normalizedPaths.map((targetPath) => ({
+    path: targetPath,
+    items: selectedItems.filter((item) => scopeApplies(item.scope, targetPath)).sort((left, right) => left.id.localeCompare(right.id)),
+  }));
+  const bundle = {
+    project: contract.project,
+    contractDigest: digestJson(contract),
+    paths: normalizedPaths,
+    sections,
+    itemIds: [...selected].sort(),
+  };
+  return renderCollectedBundle(bundle, contract.sources, task, options);
+}
+
+// Task delivery deliberately has its own renderer. Managed AGENTS/Ruler projections
+// keep using renderCollectedBundle and RENDERER_VERSION 3 byte-for-byte.
+function renderTaskItem(item, locale) {
+  const sources = item.sources.map((source) => `\`${source}\``).join(", ");
+  const value = canonicalJson(item.value);
+  const fence = fenceFor(value);
+  const subject = item.subject === item.id ? "" : `Subject: \`${item.subject}\`; `;
+  return `- **${item.id}** — ${localizedStatement(item.statement, locale)}\n  - ${subject}Scope: \`${describeScope(item.scope)}\`; source IDs: ${sources}\n  - Value (canonical JSON):\n\n    ${fence}json\n    ${value}\n    ${fence}`;
+}
+
+export function renderTaskContextBundle(contract, paths, itemIds, task, options = {}) {
+  const locale = options.locale ?? "zh-CN";
+  const selected = new Set(itemIds);
+  const normalizedPaths = paths.map((value) => normalizeRelativePath(value, { allowRoot: true, label: "target path" }));
+  const effectiveByPath = normalizedPaths.map((targetPath) => ({
+    path: targetPath,
+    items: effectiveItems(contract.items, targetPath)
+      .filter((item) => selected.has(item.id))
+      .sort((left, right) => left.id.localeCompare(right.id)),
+  }));
+  const commonIds = effectiveByPath.length === 0 ? new Set() : new Set(effectiveByPath[0].items.map((item) => item.id));
+  for (const section of effectiveByPath.slice(1)) {
+    const ids = new Set(section.items.map((item) => item.id));
+    for (const id of [...commonIds]) if (!ids.has(id)) commonIds.delete(id);
+  }
+  const common = effectiveByPath[0]?.items.filter((item) => commonIds.has(item.id)) ?? [];
+  const lines = [
+    "# Project Context Task Delivery",
+    "",
+    `Project: **${contract.project.name}** (\`${contract.project.id}\`)`,
+    `Contract digest: \`${digestJson(contract)}\``,
+  ];
+  const fence = fenceFor(task);
+  lines.push("", "## Task constraint", "", fence, String(task), fence);
+  const renderKinds = (items) => {
+    for (const [kind, title] of KIND_TITLES) {
+      const entries = items.filter((item) => item.kind === kind);
+      if (entries.length > 0) lines.push("", `### ${title}`, "", ...entries.map((item) => renderTaskItem(item, locale)));
+    }
+  };
+  if (common.length > 0) {
+    lines.push("", "## Applies to all targets");
+    renderKinds(common);
+  }
+  for (const section of effectiveByPath) {
+    const delta = section.items.filter((item) => !commonIds.has(item.id));
+    lines.push("", `## Target delta: \`${section.path}\``);
+    if (delta.length === 0) lines.push("", "No additional approved contract items apply.");
+    else renderKinds(delta);
+  }
+  lines.push("", "## Source IDs", "");
+  const sourceIds = [...new Set(effectiveByPath.flatMap((section) => section.items.flatMap((item) => item.sources)))].sort();
+  lines.push(sourceIds.length === 0 ? "No sources selected." : sourceIds.map((id) => `- \`${id}\``).join("\n"));
+  return `${lines.join("\n")}\n`;
+}
+
 export function renderProjection(contract, paths, target) {
   const bundle = collectBundle(contract, paths);
   const body = renderCollectedBundle(bundle, contract.sources);

package/src/project-context/source-reader.mjs

@@ -33,7 +33,20 @@ export function readJsonPointer(value, pointer) {
   return current;
 }
 
-async function digestDirectory(absolute) {
+export function createSourceReadContext() {
+  return {
+    cache: new Map(),
+    metrics: { sourceDigestReads: 0, sourceBodyReads: 0, sourceIdentityReads: 0 },
+  };
+}
+
+async function cached(context, key, read) {
+  if (!context?.cache) return read();
+  if (!context.cache.has(key)) context.cache.set(key, Promise.resolve().then(read));
+  return context.cache.get(key);
+}
+
+async function digestDirectory(absolute, context) {
   const entries = [];
   async function visit(directory, prefix) {
     const children = (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
@@ -46,7 +59,11 @@ async function digestDirectory(absolute) {
       } else if (child.isDirectory()) {
         await visit(full, relative);
       } else if (child.isFile()) {
-        entries.push([relative, sha256(await readFile(full))]);
+        const body = await cached(context, `body:${full}`, async () => {
+          if (context?.metrics) context.metrics.sourceBodyReads += 1;
+          return readFile(full);
+        });
+        entries.push([relative, sha256(body)]);
       }
     }
   }
@@ -54,42 +71,58 @@ async function digestDirectory(absolute) {
   return sha256(canonicalJson(entries));
 }
 
-export async function digestPath(projectRoot, relativePath) {
-  const { absolute } = await resolveExistingInside(projectRoot, relativePath);
-  const info = await stat(absolute);
-  if (info.isDirectory()) return digestDirectory(absolute);
-  if (!info.isFile()) fail("source-unsupported", `source is not a regular file or directory: ${relativePath}`);
-  return sha256(await readFile(absolute));
+export async function digestPath(projectRoot, relativePath, context) {
+  return cached(context, `digest:${relativePath}`, async () => {
+    if (context?.metrics) context.metrics.sourceDigestReads += 1;
+    const { absolute } = await resolveExistingInside(projectRoot, relativePath);
+    const info = await stat(absolute);
+    if (info.isDirectory()) return digestDirectory(absolute, context);
+    if (!info.isFile()) fail("source-unsupported", `source is not a regular file or directory: ${relativePath}`);
+    const body = await cached(context, `body:${absolute}`, async () => {
+      if (context?.metrics) context.metrics.sourceBodyReads += 1;
+      return readFile(absolute);
+    });
+    return sha256(body);
+  });
 }
 
-export async function digestPathIdentity(projectRoot, relativePath) {
-  const { absolute } = await resolveExistingInside(projectRoot, relativePath);
-  const info = await stat(absolute);
-  const kind = info.isDirectory() ? "directory" : info.isFile() ? "file" : null;
-  if (!kind) fail("source-unsupported", `source is not a regular file or directory: ${relativePath}`);
-  return sha256(canonicalJson({ kind }));
+export async function digestPathIdentity(projectRoot, relativePath, context) {
+  return cached(context, `identity:${relativePath}`, async () => {
+    if (context?.metrics) context.metrics.sourceIdentityReads += 1;
+    const { absolute } = await resolveExistingInside(projectRoot, relativePath);
+    const info = await stat(absolute);
+    const kind = info.isDirectory() ? "directory" : info.isFile() ? "file" : null;
+    if (!kind) fail("source-unsupported", `source is not a regular file or directory: ${relativePath}`);
+    return sha256(canonicalJson({ kind }));
+  });
 }
 
-export async function readSourceDigest(projectRoot, source) {
+export async function readSourceDigest(projectRoot, source, context) {
   if (sourceStatus(source) === "deprecated") return null;
   if (source.kind === "human-decision" || source.kind === "external-reference") return null;
-  if (source.kind === "path") return digestPathIdentity(projectRoot, source.path);
-  if (source.kind === "file") return digestPath(projectRoot, source.path);
-  return sha256(canonicalJson(await readJsonSourceValue(projectRoot, source)));
+  if (source.kind === "path") return digestPathIdentity(projectRoot, source.path, context);
+  if (source.kind === "file") return digestPath(projectRoot, source.path, context);
+  return sha256(canonicalJson(await readJsonSourceValue(projectRoot, source, context)));
 }
 
-async function readJsonSourceValue(projectRoot, source) {
-  const { absolute } = await resolveExistingInside(projectRoot, source.path);
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(absolute, "utf8"));
-  } catch (error) {
-    fail("source-json-invalid", `cannot parse JSON source: ${source.path}`, { cause: error });
-  }
-  return readJsonPointer(parsed, source.pointer);
+async function readJsonSourceValue(projectRoot, source, context) {
+  return cached(context, `json:${source.path}:${source.pointer}`, async () => {
+    const { absolute } = await resolveExistingInside(projectRoot, source.path);
+    let parsed;
+    try {
+      const body = await cached(context, `body:${absolute}`, async () => {
+        if (context?.metrics) context.metrics.sourceBodyReads += 1;
+        return readFile(absolute, "utf8");
+      });
+      parsed = JSON.parse(body);
+    } catch (error) {
+      fail("source-json-invalid", `cannot parse JSON source: ${source.path}`, { cause: error });
+    }
+    return readJsonPointer(parsed, source.pointer);
+  });
 }
 
-export async function verifyItem(projectRoot, item, sourceMap) {
+export async function verifyItem(projectRoot, item, sourceMap, context) {
   const verification = item.verification;
   if (!verification || verification.kind === "none") return null;
   const source = sourceMap.get(verification.source);
@@ -106,7 +139,7 @@ export async function verifyItem(projectRoot, item, sourceMap) {
     if (source.kind !== "json-pointer") {
       return { code: "verification-source-incompatible", item: item.id, source: source.id };
     }
-    const actualValue = await readJsonSourceValue(projectRoot, source);
+    const actualValue = await readJsonSourceValue(projectRoot, source, context);
     if (canonicalJson(actualValue) !== canonicalJson(verification.expected)) {
       return { code: "verification-failed", item: item.id, source: source.id, expected: verification.expected, actual: actualValue };
     }
@@ -115,7 +148,7 @@ export async function verifyItem(projectRoot, item, sourceMap) {
   if (verification.kind !== "path-digest") {
     return { code: "verification-kind-unsupported", item: item.id, source: source.id };
   }
-  const actual = await digestPath(projectRoot, source.path);
+  const actual = await digestPath(projectRoot, source.path, context);
   const expected = verification.expected ?? source.digest;
   if (actual !== expected) return { code: "verification-failed", item: item.id, source: source.id, expected, actual };
   return null;

package/src/project-context/task-context.mjs

@@ -1,4 +1,5 @@
 import { canonicalJson, digestJson } from "./canonical-json.mjs";
+import { selectAdaptiveItems } from "./adaptive-context.mjs";
 import { blockingContextFindings, checkProject } from "./checker.mjs";
 import { ProjectContextError, fail } from "./errors.mjs";
 import { readJsonFile } from "./io.mjs";
@@ -91,8 +92,18 @@ function normalizedReceipts(receiptInputs, plan) {
   return byStage;
 }
 
-function selectedItems(contract, targetPaths, findings) {
+function selectedItems(contract, targetPaths, findings, adaptiveText) {
   const byId = new Map();
+  if (adaptiveText !== undefined) {
+    const adaptiveFindings = [];
+    const selection = selectAdaptiveItems(contract, null, {
+      task: { text: adaptiveText, topics: [], paths: targetPaths, changedPaths: [], itemIds: [] },
+      level: "initial",
+    }, { findings: adaptiveFindings });
+    findings.push(...adaptiveFindings);
+    for (const item of selection.selected) byId.set(item.id, item);
+  }
+  if (adaptiveText === undefined) {
   for (const targetPath of targetPaths) {
     try {
       for (const item of effectiveItems(contract.items, targetPath)) byId.set(item.id, item);
@@ -102,6 +113,7 @@ function selectedItems(contract, targetPaths, findings) {
       for (const item of contract.items.filter((entry) => entry.status === "approved" && scopeApplies(entry.scope, targetPath))) byId.set(item.id, item);
     }
   }
+  }
   return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id)).map((item) => ({
     id: item.id,
     kind: item.kind,
@@ -205,7 +217,7 @@ async function buildStageContextBundleCore(root, project, plan, options, receipt
     if (receipt.status !== "completed") findings.push(finding("stage-dependency-blocked", "blocked", { stageId: stage.id, dependencyStageId: dependencyId }));
   }
   const targetPaths = uniqueSorted([...stage.paths, ...changedPaths]);
-  const contractItems = selectedItems(project.contract, targetPaths, findings);
+  const contractItems = selectedItems(project.contract, targetPaths, findings, `${plan.task.goal}\n${stage.objective}`);
   const readTargets = mergeReadTargets([
     ...stage.paths.map((entry) => ({ path: entry, reason: "stage-scope" })),
     ...changedPaths.map((entry) => ({ path: entry, reason: "host-changed-path-signal" })),