@piagent/platform 1.5.5 → 1.6.1

package/packages/piagent-core/runtime/context/context-evidence-qualification.ts

@@ -0,0 +1,32 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { TaskContract } from "../../extensions/guard-types.js";
+import type { ObservedTaskContext, RuntimeSessionState } from "../session/runtime-state.ts";
+
+type TaskIdentity = { taskId: string; taskRunId: string };
+
+type ContextEvidenceQualificationDependencies = {
+  state: RuntimeSessionState;
+  activeTask: (ctx: ExtensionContext) => TaskContract | undefined;
+};
+
+export function recordObservedContextEvidence(
+  ctx: ExtensionContext,
+  entry: ObservedTaskContext | undefined,
+  taskIdentity: TaskIdentity | undefined,
+  dependencies: ContextEvidenceQualificationDependencies
+): void {
+  if (!entry) return;
+  dependencies.state.rememberObservedContext(ctx, entry);
+  const activeTask = dependencies.activeTask(ctx);
+  if (
+    taskIdentity
+    && activeTask?.trace.outcome === "pending"
+    && activeTask.taskId === taskIdentity.taskId
+    && activeTask.taskRunId === taskIdentity.taskRunId
+  ) {
+    dependencies.state.rememberQualifiedContextEvidence(ctx, taskIdentity.taskRunId, entry);
+  } else if (!activeTask || activeTask.trace.outcome !== "pending") {
+    dependencies.state.rememberPreTaskContext(ctx, entry);
+  }
+}

package/packages/piagent-core/runtime/context/prefix-telemetry.ts

@@ -0,0 +1,47 @@
+import crypto from "node:crypto";
+
+type ProviderToolMetadata = {
+  name: string;
+  description?: unknown;
+  parameters?: unknown;
+};
+
+function canonicalValue(value: unknown): unknown {
+  if (value === null || ["string", "number", "boolean"].includes(typeof value)) return value;
+  if (Array.isArray(value)) return value.map((item) => canonicalValue(item));
+  if (!value || typeof value !== "object") return undefined;
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>)
+      .filter(([, item]) => item !== undefined && typeof item !== "function" && typeof item !== "symbol")
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, item]) => [key, canonicalValue(item)])
+  );
+}
+
+export function deepCanonicalJson(value: unknown): string {
+  return JSON.stringify(canonicalValue(value));
+}
+
+function hash(value: string): string {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+export function buildPrefixTelemetry(systemPrompt: string, tools: ProviderToolMetadata[]): {
+  systemPromptHash: string;
+  toolSchemaHash: string;
+  prefixSurfaceHash: string;
+  canonicalToolSurface: string;
+} {
+  const providerSurface = tools
+    .map((tool) => ({ name: tool.name, description: tool.description, parameters: tool.parameters }))
+    .sort((left, right) => left.name.localeCompare(right.name));
+  const canonicalToolSurface = deepCanonicalJson(providerSurface);
+  const systemPromptHash = hash(systemPrompt);
+  const toolSchemaHash = hash(canonicalToolSurface);
+  return {
+    systemPromptHash,
+    toolSchemaHash,
+    prefixSurfaceHash: hash(`${systemPromptHash}\0${toolSchemaHash}`),
+    canonicalToolSurface
+  };
+}

package/packages/piagent-core/runtime/context/repository-memory-hints.ts

@@ -0,0 +1,27 @@
+import { estimateContextTokens } from "../../extensions/context-engine.js";
+
+type RepositoryMemoryCandidate = {
+  record: { id?: string; fact: string; citations: Array<{ path: string }> };
+  matchedTerms: string[];
+};
+
+export function formatRepositoryMemoryHints(
+  candidates: RepositoryMemoryCandidate[],
+  budgetTokens: number
+): { text: string; ids: string[] } {
+  if (budgetTokens < 80 || candidates.length === 0) return { text: "", ids: [] };
+  const lines = [
+    "[Piagent repository memory: advisory only]",
+    "Verify every hint against the cited current file before relying on it."
+  ];
+  const ids: string[] = [];
+  for (const candidate of candidates) {
+    const paths = candidate.record.citations.slice(0, 4).map((citation) => citation.path).join(", ");
+    const line = `- ${candidate.record.fact.slice(0, 320)} [sources: ${paths}]`;
+    const proposed = [...lines, line].join("\n");
+    if (estimateContextTokens(proposed) > budgetTokens) break;
+    lines.push(line);
+    if (candidate.record.id) ids.push(candidate.record.id);
+  }
+  return ids.length > 0 ? { text: lines.join("\n"), ids } : { text: "", ids: [] };
+}

package/packages/piagent-core/runtime/hooks/agent-prompt-telemetry.ts

@@ -0,0 +1,56 @@
+import type { RuntimeModelSnapshot } from "../model/runtime-snapshot.ts";
+import { runtimeModelSnapshotDigest } from "../model/runtime-snapshot.ts";
+import type { ModelRouteEvaluation } from "../model/model-route-runtime.ts";
+import type { SolverShadowEvaluation } from "../solver/solver-shadow.ts";
+
+export function runtimeSnapshotTelemetry(snapshot?: RuntimeModelSnapshot) {
+  if (!snapshot) return undefined;
+  return {
+    schemaVersion: snapshot.schemaVersion,
+    digest: runtimeModelSnapshotDigest(snapshot),
+    provider: snapshot.provider,
+    modelId: snapshot.modelId,
+    contextWindow: snapshot.contextWindow,
+    requestedThinkingLevel: snapshot.requestedThinkingLevel,
+    effectiveThinkingLevel: snapshot.effectiveThinkingLevel,
+    warningCount: snapshot.warnings.length
+  };
+}
+
+export function solverShadowTelemetry(evaluation?: SolverShadowEvaluation) {
+  if (evaluation?.status !== "ok") return evaluation;
+  return {
+    mode: evaluation.decision.mode,
+    route: evaluation.decision.route,
+    featureHash: evaluation.features.featureHash,
+    reasonCodes: evaluation.decision.reasonCodes,
+    confidence: evaluation.decision.confidence,
+    reused: evaluation.reused,
+    persisted: evaluation.persisted,
+    durationMs: evaluation.durationMs,
+    warnings: evaluation.warnings
+  };
+}
+
+export function modelRouteTelemetry(evaluation?: ModelRouteEvaluation) {
+  if (evaluation?.status !== "ok") return evaluation;
+  return {
+    mode: evaluation.decision.mode,
+    objective: evaluation.decision.objective,
+    capabilityBand: evaluation.decision.capabilityBand,
+    safetyFloor: evaluation.decision.safetyFloor,
+    disposition: evaluation.decision.disposition,
+    selectionSource: evaluation.decision.selectionSource,
+    provider: evaluation.decision.provider,
+    modelId: evaluation.decision.modelId,
+    effort: evaluation.decision.effort,
+    downgradeSteps: evaluation.decision.downgradeSteps,
+    enforced: evaluation.decision.enforced,
+    decisionDigest: evaluation.decision.decisionDigest,
+    reasonCodes: evaluation.decision.reasonCodes,
+    reused: evaluation.reused,
+    persisted: evaluation.persisted,
+    durationMs: evaluation.durationMs,
+    warnings: evaluation.warnings
+  };
+}

package/packages/piagent-core/runtime/hooks/agent-start-hook.ts

@@ -7,7 +7,10 @@ import {
   ensureContextIndexV2,
   estimateContextTokens
 } from "../../extensions/context-engine.js";
-import { buildSelectedContextPack } from "../../extensions/criterion-context-pack.js";
+import {
+  buildSelectedContextPack,
+  composeCriterionContextEntries
+} from "../../extensions/criterion-context-pack.js";
 import { matchesProtectedPath } from "../../extensions/policy-core.js";
 import { selectRepositoryMemoryFacts } from "../../extensions/repository-memory.js";
 import type { TaskContract } from "../../extensions/guard-types.js";
@@ -15,9 +18,12 @@ import {
   contextPlanAcceptsConfidence,
   planAdaptiveContext
 } from "../context/adaptive-planner.ts";
+import { stageContextDelivery } from "../context/context-delivery.ts";
+import { measureContextDeltaShadow, type ContextDeltaShadowMode } from "../context/context-delta-shadow.ts";
+import { buildPrefixTelemetry } from "../context/prefix-telemetry.ts";
+import { formatRepositoryMemoryHints } from "../context/repository-memory-hints.ts";
 import { modelCapabilityFromContext } from "../model/capabilities.ts";
 import type { RuntimeModelSnapshot } from "../model/runtime-snapshot.ts";
-import { runtimeModelSnapshotDigest } from "../model/runtime-snapshot.ts";
 import type { ModelRouteEvaluation } from "../model/model-route-runtime.ts";
 import { buildTaskResumeContext } from "../recovery/resume-state.ts";
 import { planRetrievalRoute } from "../context/retrieval-route-policy.ts";
@@ -25,7 +31,7 @@ import type { SolverShadowEvaluation } from "../solver/solver-shadow.ts";
 import { observeTrajectorySync } from "../trajectory/trajectory-observability.ts";
 import type { TrajectorySyncOptions, TrajectorySyncResult } from "../trajectory/trajectory-runtime.ts";
 import { trajectoryRecommendationRef } from "../trajectory/trajectory-runtime.ts";
-import { RuntimeSessionState } from "../session/runtime-state.ts";
+import { RuntimeSessionState, type ContextInjectionItem } from "../session/runtime-state.ts";
 import {
   compactManagedProjectInstructions,
   rewriteLegacyProjectInstructions
@@ -37,16 +43,20 @@ import {
   automaticTaskIntakeMode
 } from "../workflows/task-intake.ts";
 import { CONTEXT_PACK_MAX_TOKENS } from "../runtime-limits.ts";
+import { modelRouteTelemetry, runtimeSnapshotTelemetry, solverShadowTelemetry } from "./agent-prompt-telemetry.ts";
 
 type RuntimeIntakeResult = {
   started: boolean;
   text: string;
   task?: TaskContract;
+  plannedContext?: Array<{ path: string; reason: string }>;
+  plannedContextComplete?: boolean;
 };
 
 type AgentStartHookDependencies = {
   state: RuntimeSessionState;
   autoContextEnabled: boolean;
+  contextDeltaShadowMode: ContextDeltaShadowMode;
   activeTask: (ctx: ExtensionContext) => TaskContract | undefined;
   readProtectedPaths: (ctx: ExtensionContext) => string[];
   contextExcludePatterns: (ctx: ExtensionContext) => string[];
@@ -71,36 +81,18 @@ type AgentStartHookDependencies = {
   telemetry: (ctx: ExtensionContext, payload: Record<string, unknown>) => void;
 };
 
-function formatRepositoryMemoryHints(candidates: Array<{
-  record: { id?: string; fact: string; citations: Array<{ path: string }> };
-  matchedTerms: string[];
-}>, budgetTokens: number): { text: string; ids: string[] } {
-  if (budgetTokens < 80 || candidates.length === 0) return { text: "", ids: [] };
-  const lines = [
-    "[Piagent repository memory: advisory only]",
-    "Verify every hint against the cited current file before relying on it."
-  ];
-  const ids: string[] = [];
-  for (const candidate of candidates) {
-    const paths = candidate.record.citations.slice(0, 4).map((citation) => citation.path).join(", ");
-    const line = `- ${candidate.record.fact.slice(0, 320)} [sources: ${paths}]`;
-    const proposed = [...lines, line].join("\n");
-    if (estimateContextTokens(proposed) > budgetTokens) break;
-    lines.push(line);
-    if (candidate.record.id) ids.push(candidate.record.id);
-  }
-  return ids.length > 0 ? { text: lines.join("\n"), ids } : { text: "", ids: [] };
-}
-
 export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStartHookDependencies): void {
   pi.on("before_agent_start", async (event, ctx) => {
     const projectInstructions = rewriteLegacyProjectInstructions(event.systemPrompt);
     const query = looksLikeGovernedBoilerplate(event.prompt) ? extractTaskRequest(event.prompt) : event.prompt.trim();
     const signal = classifyContextTask(query);
+    const turn = dependencies.state.currentTurn(ctx, signal.promptHash) ?? dependencies.state.beginTurn(ctx, signal.promptHash);
     const readProtectedPaths = dependencies.readProtectedPaths(ctx);
+    const protectedTarget = signal.paths.some((candidate) => matchesProtectedPath(candidate, readProtectedPaths));
     const protectedOnlyTarget = signal.paths.length > 0
       && signal.paths.every((candidate) => matchesProtectedPath(candidate, readProtectedPaths));
-    const activeTask = dependencies.activeTask(ctx);
+    const sessionTask = dependencies.activeTask(ctx);
+    const activeTask = sessionTask?.trace.outcome === "pending" ? sessionTask : undefined;
     const runtimeIntakeMode = !activeTask ? automaticTaskIntakeMode(query, readProtectedPaths) : undefined;
     const runtimeIntake = Boolean(runtimeIntakeMode);
     const compactMode = protectedOnlyTarget
@@ -122,10 +114,10 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       .map((tool) => ({
         name: tool.name,
         description: tool.description,
-        parameters: tool.parameters,
-        promptGuidelines: tool.promptGuidelines
+        parameters: tool.parameters
       }));
-    const toolSchemaTokens = estimateContextTokens(JSON.stringify(toolMetadata));
+    const prefix = buildPrefixTelemetry(effectiveSystemPrompt, toolMetadata);
+    const toolSchemaTokens = estimateContextTokens(prefix.canonicalToolSurface);
     const systemPromptTokens = estimateContextTokens(effectiveSystemPrompt);
     const autoPackUseful = activeTask?.trace.outcome !== "pending"
       && (runtimeIntake || signal.paths.length === 0);
@@ -154,6 +146,7 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
     if (activeTask) observeTrajectorySync(ctx, dependencies.syncTrajectory?.(ctx, activeTask, { sourceHook: "agent-start", recommendationRef }), dependencies.telemetry);
     dependencies.telemetry(ctx, {
       event: "agent_prompt",
+      turnId: turn.turnId,
       promptHash: signal.promptHash,
       promptChars: signal.promptChars,
       workflow: signal.workflow,
@@ -162,56 +155,16 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       activePiagentTools: [...active].filter((toolName) => PIAGENT_TOOL_NAMES.has(toolName)).length,
       toolSchemaTokens,
       systemPromptTokens,
-      systemPromptHash: crypto.createHash("sha256").update(effectiveSystemPrompt).digest("hex"),
+      systemPromptHash: prefix.systemPromptHash,
+      toolSchemaHash: prefix.toolSchemaHash,
+      prefixSurfaceHash: prefix.prefixSurfaceHash,
+      taskRunId: activeTask?.taskRunId,
       legacyProjectInstructionsRewritten: projectInstructions.rewritten,
       managedInstructionsCompacted: compactedInstructions.compacted,
       contextUsage: ctx.getContextUsage(),
-      runtimeSnapshot: runtimeSnapshot
-        ? {
-            schemaVersion: runtimeSnapshot.schemaVersion,
-            digest: runtimeModelSnapshotDigest(runtimeSnapshot),
-            provider: runtimeSnapshot.provider,
-            modelId: runtimeSnapshot.modelId,
-            contextWindow: runtimeSnapshot.contextWindow,
-            requestedThinkingLevel: runtimeSnapshot.requestedThinkingLevel,
-            effectiveThinkingLevel: runtimeSnapshot.effectiveThinkingLevel,
-            warningCount: runtimeSnapshot.warnings.length
-          }
-        : undefined,
-      solverShadow: solverShadow?.status === "ok"
-        ? {
-            mode: solverShadow.decision.mode,
-            route: solverShadow.decision.route,
-            featureHash: solverShadow.features.featureHash,
-            reasonCodes: solverShadow.decision.reasonCodes,
-            confidence: solverShadow.decision.confidence,
-            reused: solverShadow.reused,
-            persisted: solverShadow.persisted,
-            durationMs: solverShadow.durationMs,
-            warnings: solverShadow.warnings
-          }
-        : solverShadow,
-      modelRoute: modelRoute?.status === "ok"
-        ? {
-            mode: modelRoute.decision.mode,
-            objective: modelRoute.decision.objective,
-            capabilityBand: modelRoute.decision.capabilityBand,
-            safetyFloor: modelRoute.decision.safetyFloor,
-            disposition: modelRoute.decision.disposition,
-            selectionSource: modelRoute.decision.selectionSource,
-            provider: modelRoute.decision.provider,
-            modelId: modelRoute.decision.modelId,
-            effort: modelRoute.decision.effort,
-            downgradeSteps: modelRoute.decision.downgradeSteps,
-            enforced: modelRoute.decision.enforced,
-            decisionDigest: modelRoute.decision.decisionDigest,
-            reasonCodes: modelRoute.decision.reasonCodes,
-            reused: modelRoute.reused,
-            persisted: modelRoute.persisted,
-            durationMs: modelRoute.durationMs,
-            warnings: modelRoute.warnings
-          }
-        : modelRoute
+      runtimeSnapshot: runtimeSnapshotTelemetry(runtimeSnapshot),
+      solverShadow: solverShadowTelemetry(solverShadow),
+      modelRoute: modelRouteTelemetry(modelRoute)
     });
 
     const finishAgentStart = async (contextMessage?: {
@@ -225,36 +178,133 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       const intake = await dependencies.startAutomaticTask(query, ctx);
       if (intake?.task) observeTrajectorySync(ctx, dependencies.syncTrajectory?.(ctx, intake.task, { sourceHook: "agent-start", recommendationRef }), dependencies.telemetry);
       if (!selectedContext && !intake) return systemPromptUpdate;
-      const criterionContext = !selectedContext && intake?.task?.criterionGraph?.mode === "criterion-graph"
-        ? buildSelectedContextPack(ctx.cwd, intake.task.contextManifest.filter((entry) => /^criterion-/.test(entry.reason)), {
-            budgetTokens: CONTEXT_PACK_MAX_TOKENS, limit: 6, excludePatterns: readProtectedPaths
+      const discoveryItems = selectedContext?.customType === "piagent-context-pack-v2" && Array.isArray(selectedContext.details.selectedItems)
+        ? selectedContext.details.selectedItems as Array<Record<string, unknown>>
+        : [];
+      const discoveryPlan = selectedContext?.customType === "piagent-context-pack-v2"
+        && selectedContext.details.contextPlan && typeof selectedContext.details.contextPlan === "object"
+        ? selectedContext.details.contextPlan as { budgetTokens?: unknown; limit?: unknown }
+        : undefined;
+      const fallbackBudget = signal.paths.length === 0 ? 680 : signal.lane === "tiny" ? 420 : 560;
+      const criterionBudget = Number.isFinite(Number(discoveryPlan?.budgetTokens))
+        ? Math.max(100, Math.min(CONTEXT_PACK_MAX_TOKENS, Math.trunc(Number(discoveryPlan?.budgetTokens))))
+        : fallbackBudget;
+      const criterionLimit = Number.isFinite(Number(discoveryPlan?.limit))
+        ? Math.max(1, Math.min(6, Math.trunc(Number(discoveryPlan?.limit))))
+        : signal.paths.length > 0 ? 3 : 4;
+      const criterionMode = dependencies.autoContextEnabled && intake?.task?.criterionGraph?.mode === "criterion-graph";
+      const criterionEntries = intake?.task?.criterionGraph?.mode === "criterion-graph"
+        ? composeCriterionContextEntries({
+            explicitPaths: signal.paths,
+            criteria: intake.task.acceptanceCriteria,
+            plannedEntries: intake.plannedContext ?? [],
+            plannedSelectionComplete: intake.plannedContextComplete === true,
+            retrievedItems: discoveryItems
+          }, { limit: criterionLimit })
+        : [];
+      const criterionContext = criterionMode
+        ? buildSelectedContextPack(ctx.cwd, criterionEntries, {
+            budgetTokens: criterionBudget,
+            limit: criterionLimit,
+            focusText: [query, ...intake.task.acceptanceCriteria].join("\n"),
+            excludePatterns: dependencies.contextExcludePatterns(ctx)
           })
         : undefined;
-      if (criterionContext?.selected.length) dependencies.telemetry(ctx, {
-        event: "criterion_context_pack", selected: criterionContext.selected.length,
-        estimatedTokens: criterionContext.estimatedTokens, selectedPaths: criterionContext.selected.map((entry) => entry.path)
+      const criterionReasonCode = !dependencies.autoContextEnabled
+        ? "auto-context-disabled"
+        : intake?.task?.criterionGraph?.mode !== "criterion-graph"
+          ? "criterion-graph-unavailable"
+          : criterionEntries.length === 0
+            ? "no-candidates"
+            : !criterionContext?.selected.length ? "no-readable-selection" : "selected";
+      if (intake?.task) dependencies.telemetry(ctx, {
+        event: "criterion_context_pack", turnId: turn.turnId, selected: criterionContext?.selected.length ?? 0,
+        candidates: criterionEntries.length,
+        budgetTokens: criterionBudget,
+        estimatedTokens: criterionContext?.estimatedTokens ?? 0,
+        reasonCode: criterionReasonCode,
+        selectedPaths: criterionContext?.selected.map((entry) => entry.path) ?? []
       });
-      const content = [selectedContext?.content, intake?.text, criterionContext?.text].filter(Boolean).join("\n\n");
+      const composedContext = criterionContext?.selected.length ? criterionContext : undefined;
+      const deliveredSelectedContext = criterionMode ? undefined : selectedContext;
+      const content = [deliveredSelectedContext?.content, intake?.text, composedContext?.text].filter(Boolean).join("\n\n");
+      const deliveryTask = intake?.task ?? activeTask;
+      const selectedPackPaths = deliveredSelectedContext?.customType === "piagent-context-pack-v2" && Array.isArray(deliveredSelectedContext.details.paths)
+        ? deliveredSelectedContext.details.paths.filter((value): value is string => typeof value === "string")
+        : [];
+      const criterionPaths = composedContext?.selected.map((entry) => entry.path) ?? [];
+      const selectedPackItems = (deliveredSelectedContext?.details.selectedItems as ContextInjectionItem[] | undefined)
+        ?? selectedPackPaths.map((path) => ({ path, estimatedTokens: 0 }));
+      const injectionItems: ContextInjectionItem[] = composedContext?.selected ?? selectedPackItems;
+      const deliveryEntries = new Map<string, { path: string; reason: string }>();
+      for (const filePath of selectedPackPaths) {
+        deliveryEntries.set(filePath, {
+          path: filePath,
+          reason: "Runtime confirmed delivery of a bounded Context Engine navigation pack."
+        });
+      }
+      for (const filePath of criterionPaths) {
+        deliveryEntries.set(filePath, {
+          path: filePath,
+          reason: "Runtime confirmed delivery of criterion-selected context."
+        });
+      }
+      const deliveryId = deliveryTask && deliveryEntries.size > 0 ? crypto.randomUUID() : undefined;
+      if (deliveryTask && deliveryId) {
+        const retrievalKey = typeof deliveredSelectedContext?.details.retrievalKey === "string" ? deliveredSelectedContext.details.retrievalKey : undefined;
+        stageContextDelivery(ctx, {
+          deliveryId,
+          taskRunId: deliveryTask.taskRunId,
+          turnId: turn.turnId,
+          entries: [...deliveryEntries.values()],
+          pack: retrievalKey
+            ? {
+                retrievalKey,
+                queryHash: String(deliveredSelectedContext?.details.queryHash ?? ""),
+                confidence: String(deliveredSelectedContext?.details.confidence ?? "unknown"),
+                estimatedTokens: Number(deliveredSelectedContext?.details.estimatedTokens ?? 0),
+                paths: selectedPackPaths
+              }
+            : undefined,
+          injection: {
+            source: composedContext ? "criterion-pack" : deliveredSelectedContext?.customType === "piagent-context-pack-v2" ? "auto-pack" : "criterion-seed",
+            queryHash: String(deliveredSelectedContext?.details.queryHash ?? signal.promptHash),
+            confidence: String(deliveredSelectedContext?.details.confidence ?? (criterionPaths.length > 0 ? "high" : "unknown")),
+            estimatedTokens: Number(deliveredSelectedContext?.details.estimatedTokens ?? composedContext?.estimatedTokens ?? 0),
+            selectedItems: injectionItems
+          }
+        }, { state: dependencies.state, telemetry: dependencies.telemetry });
+      }
       return {
         ...(systemPromptUpdate ?? {}),
         message: {
-          customType: selectedContext?.customType ?? "piagent-runtime-task-intake",
+          customType: deliveredSelectedContext?.customType ?? "piagent-runtime-task-intake",
           content,
           display: false,
           details: {
-            ...(selectedContext?.details ?? {}),
+            ...(deliveredSelectedContext?.details ?? {}),
+            ...(composedContext ? {
+              schemaVersion: 1,
+              queryHash: signal.promptHash,
+              estimatedTokens: composedContext.estimatedTokens,
+              paths: composedContext.selected.map((entry) => entry.path),
+              selectedItems: composedContext.selected
+            } : {}),
+            contextDelivery: deliveryId ? { schemaVersion: 1, deliveryId } : undefined,
             runtimeTask: intake?.task
               ? {
                   taskId: intake.task.taskId,
                   taskRunId: intake.task.taskRunId,
+                  changeMode: intake.task.changeMode,
+                  mutationPolicy: intake.task.mutationPolicy,
                   scope: intake.task.scope,
                   verifyCommands: intake.task.verifyCommands,
                   criterionGraph: intake.task.criterionGraph ? { mode: intake.task.criterionGraph.mode, graphDigest: intake.task.criterionGraph.graphDigest, nodes: intake.task.criterionGraph.nodes.length } : null,
                   intakeMode: intake.task.intakeMode
                 }
               : undefined,
-            criterionContext: criterionContext?.selected.length ? {
-              paths: criterionContext.selected.map((entry) => entry.path), estimatedTokens: criterionContext.estimatedTokens
+            criterionContext: composedContext ? {
+              paths: composedContext.selected.map((entry) => entry.path), estimatedTokens: composedContext.estimatedTokens
             } : undefined,
             runtimeIntakeStarted: intake?.started ?? false
           }
@@ -263,6 +313,9 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
     };
 
     const packKey = dependencies.promptPackKey(ctx, signal.promptHash);
+    if (!autoPackUseful && activeTask?.trace.outcome === "pending" && query.length >= 20 && signal.workflow !== "usage" && dependencies.autoContextEnabled) {
+      await measureContextDeltaShadow({ ctx, query, turnId: turn.turnId, task: activeTask, mode: dependencies.contextDeltaShadowMode, protectedTarget, excludePatterns: dependencies.contextExcludePatterns(ctx), telemetry: dependencies.telemetry });
+    }
     if (
       query.length < 20
       || signal.workflow === "usage"
@@ -304,6 +357,7 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       if (!status.exists || status.stale) {
         dependencies.telemetry(ctx, {
           event: "context_pack",
+          turnId: turn.turnId,
           queryHash: signal.promptHash,
           confidence: "none",
           candidates: 0,
@@ -348,6 +402,7 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       });
       dependencies.telemetry(ctx, {
         event: "context_pack",
+        turnId: turn.turnId,
         queryHash: pack.queryHash,
         confidence: pack.confidence,
         candidates: pack.candidates,
@@ -379,10 +434,12 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       }
       if (!contextPlanAcceptsConfidence(plan, pack.confidence) || pack.selected.length === 0) return finishAgentStart();
       const memoryBudgetTokens = Math.max(0, plan.budgetTokens - pack.estimatedTokens);
-      const memoryHints = formatRepositoryMemoryHints(
-        selectRepositoryMemoryFacts(ctx.cwd, query, { limit: 2, excludePatterns }),
-        memoryBudgetTokens
-      );
+      const memoryHints = runtimeIntake
+        ? { text: "", ids: [] }
+        : formatRepositoryMemoryHints(
+            selectRepositoryMemoryFacts(ctx.cwd, query, { limit: 2, excludePatterns }),
+            memoryBudgetTokens
+          );
       dependencies.telemetry(ctx, {
         event: "repository_memory_selected",
         queryHash: signal.promptHash,
@@ -392,27 +449,29 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
         estimatedTokens: estimateContextTokens(memoryHints.text),
         planReceipt: plan.receipt
       });
-      dependencies.state.rememberInjectedContextPack(ctx, dependencies.retrievalKey(ctx, query), {
-        queryHash: pack.queryHash,
-        confidence: pack.confidence,
-        estimatedTokens: pack.estimatedTokens,
-        paths: pack.selected.map((item) => item.path)
-      });
-      for (const selected of pack.selected) {
-        dependencies.state.rememberObservedContext(ctx, {
-          path: selected.path,
-          reason: "Runtime injected a bounded Context Engine navigation pack."
-        });
-      }
       return finishAgentStart({
         customType: "piagent-context-pack-v2",
         content: [pack.text, memoryHints.text].filter(Boolean).join("\n\n"),
         details: {
           schemaVersion: 2,
           queryHash: pack.queryHash,
+          retrievalKey: dependencies.retrievalKey(ctx, query),
           confidence: pack.confidence,
           estimatedTokens: pack.estimatedTokens,
           paths: pack.selected.map((item) => item.path),
+          selectedItems: pack.selected.map((item) => ({
+            path: item.path,
+            estimatedTokens: item.estimatedTokens,
+            sources: item.sources,
+            links: item.links,
+            fileContentHash: item.fileContentHash,
+            ...(item.sanitizedContentDigest ? { sanitizedContentDigest: item.sanitizedContentDigest } : {}),
+            payloadHash: item.payloadHash,
+            representation: item.representation,
+            ranges: item.ranges,
+            generation: item.generation,
+            sensitiveContentRedacted: item.sensitiveContentRedacted
+          })),
           repositoryMemoryIds: memoryHints.ids,
           currentSnapshot: plan.currentSnapshot,
           contextPlan: plan
@@ -421,6 +480,7 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
     } catch (error) {
       dependencies.telemetry(ctx, {
         event: "context_pack",
+        turnId: turn.turnId,
         queryHash: signal.promptHash,
         confidence: "none",
         candidates: 0,