@piagent/platform 1.5.4 → 1.6.0

package/packages/piagent-core/runtime/session/runtime-state.ts

@@ -1,5 +1,7 @@
+import crypto from "node:crypto";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+import { isRuntimeOwnedContextEvidenceEntry } from "../../extensions/context-evidence.js";
 import { toolResultFingerprint } from "../../extensions/context-engine.js";
 import { workingTreeSnapshot } from "../../extensions/task-state.js";
 import type { TaskContract } from "../../extensions/guard-types.ts";
@@ -38,6 +40,39 @@ export type InjectedContextPack = {
   paths: string[];
 };
 
+export type ContextInjectionItem = {
+  path: string;
+  estimatedTokens: number;
+  sources?: string[];
+  links?: Array<{ kind: string; path: string }>;
+  fileContentHash?: string;
+  sanitizedContentDigest?: string;
+  payloadHash?: string;
+  representation?: string;
+  ranges?: Array<{ start: number; end: number }>;
+  generation?: number;
+  sensitiveContentRedacted?: boolean;
+};
+
+export type ContextInjectionTelemetry = {
+  source: string;
+  queryHash: string;
+  confidence: string;
+  estimatedTokens: number;
+  selectedItems: ContextInjectionItem[];
+};
+
+export type PendingContextDelivery = {
+  deliveryId: string;
+  taskRunId: string;
+  turnId?: string;
+  entries: ObservedTaskContext[];
+  pack?: InjectedContextPack & { retrievalKey: string };
+  injection?: ContextInjectionTelemetry;
+};
+
+export type RuntimeTurn = { turnId: string; promptHash: string };
+
 function evictOldest<K, V>(map: Map<K, V>, maximum: number): void {
   while (map.size > maximum) map.delete(map.keys().next().value as K);
 }
@@ -48,6 +83,8 @@ export class RuntimeSessionState {
   readonly #seenToolResults = new Map<string, { outputHash: string; recordedAt: string }>();
   readonly #autoPackedPrompts = new Set<string>();
   readonly #injectedContextPacks = new Map<string, InjectedContextPack>();
+  readonly #pendingContextDeliveries = new Map<string, PendingContextDelivery>();
+  readonly #turnBySession = new Map<string, RuntimeTurn>();
   readonly #modelAuthorship = new ModelAuthorshipState();
   readonly #performanceReview = new PerformanceReviewState();
   readonly #recoveryHistoryByTask = new Map<string, RecoveryHistoryEntry[]>();
@@ -55,6 +92,8 @@ export class RuntimeSessionState {
   readonly #deliveredResumeContexts = new Set<string>();
   readonly #taskIdentityBySession = new Map<string, { taskId: string; taskRunId: string }>();
   readonly #observedContextBySession = new Map<string, Map<string, ObservedTaskContext>>();
+  readonly #preTaskContextBySession = new Map<string, { turnId: string; entries: Map<string, ObservedTaskContext> }>();
+  readonly #qualifiedContextEvidenceByTask = new Map<string, Map<string, ObservedTaskContext>>();
   readonly #shellMutationSnapshots = new Map<string, Record<string, string>>();
 
   constructor(options: { maxObservedContext: number }) {
@@ -76,6 +115,21 @@ export class RuntimeSessionState {
     return this.#taskIdentityBySession.get(this.sessionKey(ctx));
   }
 
+  beginTurn(ctx: ExtensionContext, promptHash: string): RuntimeTurn {
+    const turn = { turnId: crypto.randomUUID(), promptHash };
+    const sessionKey = this.sessionKey(ctx);
+    this.#turnBySession.set(sessionKey, turn);
+    this.#preTaskContextBySession.set(sessionKey, { turnId: turn.turnId, entries: new Map() });
+    evictOldest(this.#turnBySession, 100);
+    evictOldest(this.#preTaskContextBySession, 100);
+    return { ...turn };
+  }
+
+  currentTurn(ctx: ExtensionContext, promptHash?: string): RuntimeTurn | undefined {
+    const turn = this.#turnBySession.get(this.sessionKey(ctx));
+    return turn && (!promptHash || turn.promptHash === promptHash) ? { ...turn } : undefined;
+  }
+
   hasAdvisedTool(ctx: ExtensionContext, toolName: string): boolean {
     return this.#advisedTools.has(`${this.sessionKey(ctx)}\u0000${toolName}`);
   }
@@ -103,8 +157,66 @@ export class RuntimeSessionState {
     return [...(this.#observedContextBySession.get(this.sessionKey(ctx))?.values() ?? [])];
   }
 
+  rememberPreTaskContext(ctx: ExtensionContext, entry: ObservedTaskContext): void {
+    const turn = this.currentTurn(ctx);
+    const epoch = this.#preTaskContextBySession.get(this.sessionKey(ctx));
+    if (!turn || !epoch || epoch.turnId !== turn.turnId || !isRuntimeOwnedContextEvidenceEntry(entry)) return;
+    epoch.entries.set(entry.path, structuredClone(entry));
+    evictOldest(epoch.entries, this.#maxObservedContext);
+  }
+
+  preTaskContext(ctx: ExtensionContext): ObservedTaskContext[] {
+    const turn = this.currentTurn(ctx);
+    const epoch = this.#preTaskContextBySession.get(this.sessionKey(ctx));
+    if (!turn || !epoch || epoch.turnId !== turn.turnId) return [];
+    return [...epoch.entries.values()].map((entry) => structuredClone(entry));
+  }
+
+  promotePreTaskContext(ctx: ExtensionContext, taskRunId: string, selected: ObservedTaskContext[]): void {
+    const eligible = new Map(this.preTaskContext(ctx).map((entry) => [entry.path, entry]));
+    for (const entry of selected) {
+      const observed = eligible.get(entry.path);
+      if (observed) this.rememberQualifiedContextEvidence(ctx, taskRunId, observed);
+    }
+    const epoch = this.#preTaskContextBySession.get(this.sessionKey(ctx));
+    if (epoch) epoch.entries.clear();
+  }
+
+  qualifiedTaskContext(ctx: ExtensionContext): ObservedTaskContext[] {
+    const taskRunId = this.taskIdentity(ctx)?.taskRunId;
+    return taskRunId ? this.qualifiedContextEvidence(ctx, taskRunId) : [];
+  }
+
   clearObservedContext(ctx: ExtensionContext): void {
-    this.#observedContextBySession.delete(this.sessionKey(ctx));
+    const sessionKey = this.sessionKey(ctx);
+    this.#observedContextBySession.delete(sessionKey);
+    this.#preTaskContextBySession.delete(sessionKey);
+    const prefix = `${sessionKey}\u0000`;
+    for (const key of this.#qualifiedContextEvidenceByTask.keys()) {
+      if (key.startsWith(prefix)) this.#qualifiedContextEvidenceByTask.delete(key);
+    }
+  }
+
+  rememberQualifiedContextEvidence(
+    ctx: ExtensionContext,
+    taskRunId: string,
+    entry: ObservedTaskContext
+  ): void {
+    if (!taskRunId || !entry.path) return;
+    const key = `${this.sessionKey(ctx)}\u0000${taskRunId}`;
+    let evidence = this.#qualifiedContextEvidenceByTask.get(key);
+    if (!evidence) {
+      evidence = new Map();
+      this.#qualifiedContextEvidenceByTask.set(key, evidence);
+    }
+    evidence.set(entry.path, structuredClone(entry));
+    evictOldest(evidence, this.#maxObservedContext);
+    evictOldest(this.#qualifiedContextEvidenceByTask, 100);
+  }
+
+  qualifiedContextEvidence(ctx: ExtensionContext, taskRunId: string): ObservedTaskContext[] {
+    const key = `${this.sessionKey(ctx)}\u0000${taskRunId}`;
+    return [...(this.#qualifiedContextEvidenceByTask.get(key)?.values() ?? [])].map((entry) => structuredClone(entry));
   }
 
   #shellMutationSnapshotKey(ctx: ExtensionContext, toolName: string, input: unknown): string {
@@ -153,6 +265,18 @@ export class RuntimeSessionState {
     return this.#injectedContextPacks.get(`${this.sessionKey(ctx)}\u0000${key}`);
   }
 
+  stageContextDelivery(ctx: ExtensionContext, delivery: PendingContextDelivery): void {
+    this.#pendingContextDeliveries.set(`${this.sessionKey(ctx)}\u0000${delivery.deliveryId}`, structuredClone(delivery));
+    evictOldest(this.#pendingContextDeliveries, 100);
+  }
+
+  takeContextDelivery(ctx: ExtensionContext, deliveryId: string): PendingContextDelivery | undefined {
+    const key = `${this.sessionKey(ctx)}\u0000${deliveryId}`;
+    const delivery = this.#pendingContextDeliveries.get(key);
+    this.#pendingContextDeliveries.delete(key);
+    return delivery ? structuredClone(delivery) : undefined;
+  }
+
   performanceReviewCheckpoint(taskRunId: string): PerformanceReviewCheckpoint | undefined {
     return this.#performanceReview.checkpoint(taskRunId);
   }
@@ -300,6 +424,7 @@ export class RuntimeSessionState {
     this.#recoveryHistoryByTask.delete(taskId);
     this.#resumeStateByTaskRun.delete(taskRunId);
     this.#deliveredResumeContexts.delete(`${this.sessionKey(ctx)}\u0000${taskRunId}`);
+    this.#qualifiedContextEvidenceByTask.delete(`${this.sessionKey(ctx)}\u0000${taskRunId}`);
     this.clearShellMutationSnapshots(ctx);
   }
 
@@ -319,12 +444,39 @@ export class RuntimeSessionState {
     evictOldest(this.#seenToolResults, 500);
   }
 
+  clearTaskBoundary(ctx: ExtensionContext, taskRunId: string): void {
+    const sessionKey = this.sessionKey(ctx);
+    const prefix = `${sessionKey}\u0000`;
+    const taskIdentity = this.#taskIdentityBySession.get(sessionKey);
+    if (taskIdentity && taskIdentity.taskRunId !== taskRunId) return;
+    this.#taskIdentityBySession.delete(sessionKey);
+    this.#observedContextBySession.delete(sessionKey);
+    this.#preTaskContextBySession.delete(sessionKey);
+    this.clearShellMutationSnapshots(ctx);
+    this.#performanceReview.clearTask(taskRunId);
+    this.#modelAuthorship.clear(taskRunId);
+    this.#deliveredResumeContexts.delete(`${prefix}${taskRunId}`);
+    this.#qualifiedContextEvidenceByTask.delete(`${prefix}${taskRunId}`);
+    for (const values of [this.#autoPackedPrompts, this.#deliveredResumeContexts]) {
+      for (const key of values) {
+        if (key.startsWith(prefix)) values.delete(key);
+      }
+    }
+    for (const values of [this.#seenToolResults, this.#injectedContextPacks, this.#pendingContextDeliveries]) {
+      for (const key of values.keys()) {
+        if (key.startsWith(prefix)) values.delete(key);
+      }
+    }
+  }
+
   clearSession(ctx: ExtensionContext): void {
     const sessionKey = this.sessionKey(ctx);
     const prefix = `${sessionKey}\u0000`;
     const taskIdentity = this.#taskIdentityBySession.get(sessionKey);
     this.#taskIdentityBySession.delete(sessionKey);
+    this.#turnBySession.delete(sessionKey);
     this.#observedContextBySession.delete(sessionKey);
+    this.#preTaskContextBySession.delete(sessionKey);
     this.clearShellMutationSnapshots(ctx);
     if (taskIdentity) {
       this.#performanceReview.clearTask(taskIdentity.taskRunId);
@@ -335,7 +487,7 @@ export class RuntimeSessionState {
         if (key.startsWith(prefix)) values.delete(key);
       }
     }
-    for (const values of [this.#seenToolResults, this.#injectedContextPacks]) {
+    for (const values of [this.#seenToolResults, this.#injectedContextPacks, this.#pendingContextDeliveries, this.#qualifiedContextEvidenceByTask]) {
       for (const key of values.keys()) {
         if (key.startsWith(prefix)) values.delete(key);
       }

package/packages/piagent-core/runtime/session/system-prompt.ts

@@ -8,9 +8,9 @@ const RUNTIME_MANAGED_PROJECT_INSTRUCTIONS = [
   "Piagent runtime-managed task flow:",
   "1. Runtime creates the task contract automatically for a bounded source-changing request before the model starts.",
   "2. Only when runtime intake pauses for broad, high-risk, or ambiguous scope, call `piagent_task_start` exactly once with project-relative path/glob scope; reuse an active contract.",
-  "3. Read the narrow target and nearest relevant test, then use ordinary read/edit/bash tools.",
-  "4. Run every exact runtime-provided verifier after the latest mutation. Automatic tasks need no management calls.",
-  "5. Runtime hooks enforce policy and record context, changes, current-tree verification, trace and final gate. Diagnostic groups appear only for explicit requests or manual high-risk checkpoints."
+  "3. Use complete runtime-delivered source directly; do not reread it normally. On edit drift/oldText mismatch, use attached recovery; otherwise reread the affected region once. Never retry guessed anchors. Otherwise read only missing source or a concrete criterion-linked focused test. Globs/directories grant scope, not file targets. When creating an explicitly requested new path, do not probe that destination with read first; create it, then read back or verify it. If existence matters, use a non-erroring existence check.",
+  "4. Preserve every runtime-provided verifier exactly and keep commands separate. Run the exact verifier set once on the final tree; rerun only after a later mutation or a runtime-authorized same-tree infrastructure retry. Automatic tasks need no management calls.",
+  "5. Treat the current source and durable Task Contract as authoritative. Keep one writer, bound helper delegation, preserve the user's exact scope, and report unresolved risk. Runtime hooks enforce policy and record context, changes, current-tree verification, trace and final gate. Diagnostic groups appear only for explicit requests or manual high-risk checkpoints."
 ].join("\n");
 
 export function rewriteLegacyProjectInstructions(systemPrompt: string): {
@@ -34,7 +34,7 @@ export function compactManagedProjectInstructions(
 ): { systemPrompt: string; compacted: boolean } {
   const concise = mode === "protected"
     ? "Piagent protected-path policy: do not read, disclose, or mutate protected content. Refuse without tool calls."
-    : "Piagent runtime task is injected below. Root project instructions are already loaded; do not re-read root AGENTS.md. Use task-relevant source/tests and ordinary tools, run the exact verifier after final edits, and make no task-management calls.";
+    : "Piagent runtime task is injected below. Root project instructions are already loaded; do not re-read root AGENTS.md. Treat current source and the durable Task Contract as authoritative; preserve the user's exact scope, keep one writer, bound helpers, and report unresolved risk. Use complete runtime-delivered source directly without rereading it normally. On edit drift/oldText mismatch, use attached recovery; otherwise reread the affected region once. Never retry guessed anchors. Otherwise read only missing source or a concrete criterion-linked focused test. Globs/directories grant scope, not file targets. For an explicitly requested new path, create it without a speculative read, then read back or verify it. Preserve every runtime verifier exactly and keep commands separate. Run the exact verifier set once on the final tree; rerun only after a later mutation or a runtime-authorized same-tree infrastructure retry. Make no task-management calls.";
   const markerStart = "<!-- piagent-managed:start -->";
   const markerEnd = "<!-- piagent-managed:end -->";
   const start = systemPrompt.indexOf(markerStart);