@piagent/platform 1.2.17 → 1.3.0-ie.8

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

@@ -0,0 +1,340 @@
+export const MAX_PERFORMANCE_REPAIR_REVISIONS = 2;
+export const MAX_PERFORMANCE_MUTATIONS_PER_REVISION = 8;
+export const MAX_PERFORMANCE_REPAIR_PATHS = 12;
+
+export type PerformanceReviewVerifierState =
+  | "not-required"
+  | "required"
+  | "passed"
+  | "correction-required"
+  | "retry-ready"
+  | "locked";
+
+export type PerformanceReviewToolKind = "inspection" | "mutation" | "verifier";
+
+export type PerformanceReviewCheckpoint = {
+  workingTreeDigest: string;
+  attempt: number;
+  activityObserved: boolean;
+  reviewSatisfied: boolean;
+  inspectionCalls: number;
+  shellInspectionCalls: number;
+  expectedPaths: string[];
+  reviewedPaths: string[];
+  mutationObserved: boolean;
+  revision: number;
+  successfulMutationCalls: number;
+  successfulMutationsInRevision: number;
+  mutatedPaths: string[];
+  verifierCalls: number;
+  verifierCallsInRevision: number;
+  verifierState: PerformanceReviewVerifierState;
+  transientRetryUsed: boolean;
+  invalidated: boolean;
+  pendingToolCallId?: string;
+  pendingToolKind?: PerformanceReviewToolKind;
+};
+
+export type PerformanceReviewCredit = {
+  workingTreeDigest: string;
+  commandHash: string;
+  reviewedPaths: string[];
+  recordedAt: string;
+};
+
+type PerformanceReviewReservation = {
+  toolCallId: string;
+  kind: PerformanceReviewToolKind;
+  toolName: string;
+  workingTreeDigest: string;
+  workingTreeSnapshot: Record<string, string>;
+  targetPaths: string[];
+  revision: number;
+  verifierRetry: boolean;
+};
+
+export type PerformanceReviewToolCompletion = {
+  success: boolean;
+  postWorkingTreeDigest: string;
+  postWorkingTreeSnapshot: Record<string, string>;
+  exitCode?: number;
+  failure?: {
+    retryable?: boolean;
+    sourceMutationPermission?: string;
+    confidence?: string;
+  };
+};
+
+export type PerformanceReviewToolCompletionResult =
+  | "unmatched"
+  | "ignored"
+  | "recorded"
+  | "passed"
+  | "correction-opened"
+  | "retry-opened"
+  | "locked"
+  | "invalidated";
+
+function evictOldest<K, V>(map: Map<K, V>, maximum: number): void {
+  while (map.size > maximum) map.delete(map.keys().next().value as K);
+}
+
+function uniquePaths(values: string[]): string[] {
+  return [...new Set(values.map((value) => String(value ?? "").replaceAll("\\", "/").replace(/^\.\//, "").trim()).filter(Boolean))].sort();
+}
+
+function exactPathSet(left: string[], right: string[]): boolean {
+  const normalizedLeft = uniquePaths(left);
+  const normalizedRight = uniquePaths(right);
+  return normalizedLeft.length > 0
+    && normalizedLeft.length === normalizedRight.length
+    && normalizedLeft.every((file, index) => file === normalizedRight[index]);
+}
+
+function changedSnapshotPaths(before: Record<string, string>, after: Record<string, string>): string[] {
+  return uniquePaths([...new Set([...Object.keys(before), ...Object.keys(after)])]
+    .filter((file) => before[file] !== after[file]));
+}
+
+export class PerformanceReviewState {
+  readonly #checkpoints = new Map<string, PerformanceReviewCheckpoint>();
+  readonly #credits = new Map<string, PerformanceReviewCredit>();
+  readonly #reservations = new Map<string, PerformanceReviewReservation>();
+
+  checkpoint(taskRunId: string): PerformanceReviewCheckpoint | undefined {
+    const checkpoint = this.#checkpoints.get(taskRunId);
+    return checkpoint ? {
+      ...checkpoint,
+      expectedPaths: [...checkpoint.expectedPaths],
+      reviewedPaths: [...checkpoint.reviewedPaths],
+      mutatedPaths: [...checkpoint.mutatedPaths]
+    } : undefined;
+  }
+
+  rememberCheckpoint(
+    taskRunId: string,
+    workingTreeDigest: string,
+    attempt: number,
+    expectedPaths: string[] = [],
+    reviewedPaths: string[] = []
+  ): void {
+    const expected = uniquePaths(expectedPaths);
+    const reviewed = uniquePaths(reviewedPaths);
+    this.#checkpoints.set(taskRunId, {
+      workingTreeDigest,
+      attempt,
+      activityObserved: false,
+      reviewSatisfied: exactPathSet(expected, reviewed),
+      inspectionCalls: 0,
+      shellInspectionCalls: 0,
+      expectedPaths: expected,
+      reviewedPaths: reviewed,
+      mutationObserved: false,
+      revision: 0,
+      successfulMutationCalls: 0,
+      successfulMutationsInRevision: 0,
+      mutatedPaths: [],
+      verifierCalls: 0,
+      verifierCallsInRevision: 0,
+      verifierState: "not-required",
+      transientRetryUsed: false,
+      invalidated: false
+    });
+    evictOldest(this.#checkpoints, 100);
+  }
+
+  rememberReadActivity(taskRunId: string, toolName = "read"): void {
+    const checkpoint = this.#checkpoints.get(taskRunId);
+    if (!checkpoint || !["read", "grep", "find", "ls"].includes(String(toolName).toLowerCase())) return;
+    checkpoint.activityObserved = true;
+    checkpoint.inspectionCalls += 1;
+  }
+
+  #key(taskRunId: string, toolCallId: string): string {
+    return `${taskRunId}\u0000${toolCallId}`;
+  }
+
+  reserveTool(taskRunId: string, reservation: Omit<PerformanceReviewReservation, "revision" | "verifierRetry">): boolean {
+    const checkpoint = this.#checkpoints.get(taskRunId);
+    if (!checkpoint || checkpoint.invalidated || checkpoint.pendingToolCallId || checkpoint.workingTreeDigest !== reservation.workingTreeDigest) return false;
+    const key = this.#key(taskRunId, reservation.toolCallId);
+    if (this.#reservations.has(key)) return false;
+    this.#reservations.set(key, {
+      ...reservation,
+      workingTreeSnapshot: { ...reservation.workingTreeSnapshot },
+      targetPaths: uniquePaths(reservation.targetPaths),
+      revision: checkpoint.revision,
+      verifierRetry: reservation.kind === "verifier" && checkpoint.verifierState === "retry-ready"
+    });
+    checkpoint.pendingToolCallId = reservation.toolCallId;
+    checkpoint.pendingToolKind = reservation.kind;
+    evictOldest(this.#reservations, 200);
+    return true;
+  }
+
+  completeTool(taskRunId: string, toolCallId: string, result: PerformanceReviewToolCompletion): PerformanceReviewToolCompletionResult {
+    const key = this.#key(taskRunId, toolCallId);
+    const reservation = this.#reservations.get(key);
+    this.#reservations.delete(key);
+    const checkpoint = this.#checkpoints.get(taskRunId);
+    if (!reservation || !checkpoint) return "unmatched";
+    if (checkpoint.pendingToolCallId === toolCallId) {
+      delete checkpoint.pendingToolCallId;
+      delete checkpoint.pendingToolKind;
+    }
+    const changedPaths = changedSnapshotPaths(reservation.workingTreeSnapshot, result.postWorkingTreeSnapshot);
+    const treeChanged = result.postWorkingTreeDigest !== reservation.workingTreeDigest;
+    if (checkpoint.invalidated || checkpoint.workingTreeDigest !== reservation.workingTreeDigest || checkpoint.revision !== reservation.revision) {
+      return this.#invalidate(checkpoint);
+    }
+    if (reservation.kind === "inspection") return this.#completeInspection(checkpoint, reservation, result.success, treeChanged);
+    if (reservation.kind === "mutation") return this.#completeMutation(checkpoint, reservation, result, changedPaths, treeChanged);
+    return this.#completeVerifier(checkpoint, reservation, result, treeChanged);
+  }
+
+  #completeInspection(checkpoint: PerformanceReviewCheckpoint, reservation: PerformanceReviewReservation, success: boolean, treeChanged: boolean): PerformanceReviewToolCompletionResult {
+    if (!success) return treeChanged ? this.#invalidate(checkpoint) : this.#lock(checkpoint);
+    if (treeChanged) return this.#invalidate(checkpoint);
+    checkpoint.activityObserved = true;
+    if (["bash", "shell", "exec", "exec_command"].includes(reservation.toolName.toLowerCase())) checkpoint.shellInspectionCalls += 1;
+    else checkpoint.inspectionCalls += 1;
+    return "recorded";
+  }
+
+  #completeMutation(
+    checkpoint: PerformanceReviewCheckpoint,
+    reservation: PerformanceReviewReservation,
+    result: PerformanceReviewToolCompletion,
+    changedPaths: string[],
+    treeChanged: boolean
+  ): PerformanceReviewToolCompletionResult {
+    if (!result.success) return treeChanged ? this.#invalidate(checkpoint) : this.#lock(checkpoint);
+    if (!treeChanged) return this.#lock(checkpoint);
+    if (
+      changedPaths.length === 0
+      || changedPaths.some((file) => !reservation.targetPaths.includes(file))
+      || changedPaths.some((file) => !checkpoint.reviewedPaths.includes(file))
+    ) return this.#invalidate(checkpoint);
+    const nextRevision = checkpoint.revision === 0 ? 1 : checkpoint.revision;
+    const nextMutationCalls = checkpoint.successfulMutationsInRevision + 1;
+    const nextMutatedPaths = uniquePaths([...checkpoint.mutatedPaths, ...changedPaths]);
+    if (
+      nextRevision > MAX_PERFORMANCE_REPAIR_REVISIONS
+      || nextMutationCalls > MAX_PERFORMANCE_MUTATIONS_PER_REVISION
+      || nextMutatedPaths.length > MAX_PERFORMANCE_REPAIR_PATHS
+    ) {
+      checkpoint.verifierState = "locked";
+      checkpoint.reviewSatisfied = false;
+      return "locked";
+    }
+    checkpoint.workingTreeDigest = result.postWorkingTreeDigest;
+    checkpoint.activityObserved = true;
+    checkpoint.reviewSatisfied = false;
+    checkpoint.mutationObserved = true;
+    checkpoint.revision = nextRevision;
+    checkpoint.successfulMutationCalls += 1;
+    checkpoint.successfulMutationsInRevision = nextMutationCalls;
+    checkpoint.mutatedPaths = nextMutatedPaths;
+    checkpoint.verifierState = "required";
+    return "recorded";
+  }
+
+  #completeVerifier(
+    checkpoint: PerformanceReviewCheckpoint,
+    reservation: PerformanceReviewReservation,
+    result: PerformanceReviewToolCompletion,
+    treeChanged: boolean
+  ): PerformanceReviewToolCompletionResult {
+    if (treeChanged) return this.#invalidate(checkpoint);
+    checkpoint.activityObserved = true;
+    checkpoint.verifierCalls += 1;
+    checkpoint.verifierCallsInRevision += 1;
+    if (reservation.verifierRetry) checkpoint.transientRetryUsed = true;
+    if (result.success && (result.exitCode === undefined || result.exitCode === 0)) {
+      checkpoint.verifierState = "passed";
+      checkpoint.reviewSatisfied = exactPathSet(checkpoint.expectedPaths, checkpoint.reviewedPaths);
+      return "passed";
+    }
+    checkpoint.reviewSatisfied = false;
+    if (result.failure?.retryable === true && !checkpoint.transientRetryUsed) {
+      checkpoint.verifierState = "retry-ready";
+      return "retry-opened";
+    }
+    const correctionEligible = result.failure?.sourceMutationPermission === "eligible-in-scope" && result.failure?.confidence === "high";
+    if (correctionEligible && checkpoint.revision < MAX_PERFORMANCE_REPAIR_REVISIONS) {
+      checkpoint.revision += 1;
+      checkpoint.successfulMutationsInRevision = 0;
+      checkpoint.verifierCallsInRevision = 0;
+      checkpoint.verifierState = "correction-required";
+      return "correction-opened";
+    }
+    checkpoint.verifierState = "locked";
+    return "locked";
+  }
+
+  #invalidate(checkpoint: PerformanceReviewCheckpoint): "invalidated" {
+    checkpoint.invalidated = true;
+    checkpoint.reviewSatisfied = false;
+    return "invalidated";
+  }
+
+  #lock(checkpoint: PerformanceReviewCheckpoint): "locked" {
+    checkpoint.activityObserved = true;
+    checkpoint.reviewSatisfied = false;
+    checkpoint.verifierState = "locked";
+    return "locked";
+  }
+
+  invalidateCheckpoint(taskRunId: string): void {
+    const checkpoint = this.#checkpoints.get(taskRunId);
+    if (checkpoint) this.#invalidate(checkpoint);
+  }
+
+  denyTool(taskRunId: string): boolean {
+    const checkpoint = this.#checkpoints.get(taskRunId);
+    if (!checkpoint) return false;
+    checkpoint.activityObserved = true;
+    checkpoint.verifierState = "locked";
+    this.#invalidate(checkpoint);
+    return true;
+  }
+
+  rememberCredit(taskRunId: string, credit: PerformanceReviewCredit): void {
+    this.#credits.set(taskRunId, { ...credit, reviewedPaths: [...credit.reviewedPaths] });
+    const checkpoint = this.#checkpoints.get(taskRunId);
+    if (checkpoint && checkpoint.workingTreeDigest === credit.workingTreeDigest && !checkpoint.invalidated) {
+      checkpoint.activityObserved = true;
+      checkpoint.reviewSatisfied = exactPathSet(checkpoint.expectedPaths, credit.reviewedPaths);
+      checkpoint.shellInspectionCalls = Math.max(1, checkpoint.shellInspectionCalls);
+      checkpoint.reviewedPaths = uniquePaths(credit.reviewedPaths);
+    }
+    evictOldest(this.#credits, 100);
+  }
+
+  credit(taskRunId: string, currentWorkingTreeDigest?: string): PerformanceReviewCredit | undefined {
+    const credit = this.#credits.get(taskRunId);
+    if (!credit) return undefined;
+    if (currentWorkingTreeDigest !== undefined && credit.workingTreeDigest !== currentWorkingTreeDigest) {
+      this.#credits.delete(taskRunId);
+      return undefined;
+    }
+    return { ...credit, reviewedPaths: [...credit.reviewedPaths] };
+  }
+
+  invalidateCredit(taskRunId: string): boolean {
+    return this.#credits.delete(taskRunId);
+  }
+
+  clearReview(taskRunId: string): void {
+    this.#checkpoints.delete(taskRunId);
+    this.#credits.delete(taskRunId);
+    const prefix = `${taskRunId}\u0000`;
+    for (const key of this.#reservations.keys()) {
+      if (key.startsWith(prefix)) this.#reservations.delete(key);
+    }
+  }
+
+  clearTask(taskRunId: string): void {
+    this.clearReview(taskRunId);
+  }
+}

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

@@ -3,6 +3,31 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { toolResultFingerprint } from "../../extensions/context-engine.js";
 import { workingTreeSnapshot } from "../../extensions/task-state.js";
 import type { TaskContract } from "../../extensions/guard-types.ts";
+import type { RecoveryHistoryEntry } from "../recovery/recovery-policy.ts";
+import type { ResumeState } from "../recovery/resume-state.ts";
+import { ModelAuthorshipState } from "./model-authorship-state.ts";
+import type { ModelMutationIdentity } from "./model-authorship-state.ts";
+import type { ModelMutationProof } from "../quality/model-mutation-proof.ts";
+import { PerformanceReviewState } from "./performance-review-state.ts";
+import type {
+  PerformanceReviewCheckpoint,
+  PerformanceReviewCredit,
+  PerformanceReviewToolCompletion,
+  PerformanceReviewToolCompletionResult
+} from "./performance-review-state.ts";
+export {
+  MAX_PERFORMANCE_MUTATIONS_PER_REVISION,
+  MAX_PERFORMANCE_REPAIR_PATHS,
+  MAX_PERFORMANCE_REPAIR_REVISIONS
+} from "./performance-review-state.ts";
+export type {
+  PerformanceReviewCheckpoint,
+  PerformanceReviewCredit,
+  PerformanceReviewToolCompletion,
+  PerformanceReviewToolCompletionResult,
+  PerformanceReviewToolKind,
+  PerformanceReviewVerifierState
+} from "./performance-review-state.ts";
 
 export type ObservedTaskContext = { path: string; reason: string };
 
@@ -23,7 +48,11 @@ export class RuntimeSessionState {
   readonly #seenToolResults = new Map<string, { outputHash: string; recordedAt: string }>();
   readonly #autoPackedPrompts = new Set<string>();
   readonly #injectedContextPacks = new Map<string, InjectedContextPack>();
-  readonly #completionRecoveryAttempts = new Map<string, number>();
+  readonly #modelAuthorship = new ModelAuthorshipState();
+  readonly #performanceReview = new PerformanceReviewState();
+  readonly #recoveryHistoryByTask = new Map<string, RecoveryHistoryEntry[]>();
+  readonly #resumeStateByTaskRun = new Map<string, ResumeState>();
+  readonly #deliveredResumeContexts = new Set<string>();
   readonly #taskIdentityBySession = new Map<string, { taskId: string; taskRunId: string }>();
   readonly #observedContextBySession = new Map<string, Map<string, ObservedTaskContext>>();
   readonly #shellMutationSnapshots = new Map<string, Record<string, string>>();
@@ -124,17 +153,144 @@ export class RuntimeSessionState {
     return this.#injectedContextPacks.get(`${this.sessionKey(ctx)}\u0000${key}`);
   }
 
-  completionRecoveryAttempt(taskRunId: string): number {
-    return this.#completionRecoveryAttempts.get(taskRunId) ?? 0;
+  performanceReviewCheckpoint(taskRunId: string): PerformanceReviewCheckpoint | undefined {
+    return this.#performanceReview.checkpoint(taskRunId);
   }
 
-  rememberCompletionRecoveryAttempt(taskRunId: string, attempt: number): void {
-    this.#completionRecoveryAttempts.set(taskRunId, attempt);
-    evictOldest(this.#completionRecoveryAttempts, 100);
+  rememberPerformanceReviewCheckpoint(
+    taskRunId: string,
+    workingTreeDigest: string,
+    attempt: number,
+    expectedPaths: string[] = [],
+    reviewedPaths: string[] = []
+  ): void {
+    this.#performanceReview.rememberCheckpoint(taskRunId, workingTreeDigest, attempt, expectedPaths, reviewedPaths);
+  }
+
+  rememberPerformanceReviewActivity(taskRunId: string, toolName = "read"): void {
+    this.#performanceReview.rememberReadActivity(taskRunId, toolName);
+  }
+
+  reservePerformanceReviewTool(
+    taskRunId: string,
+    reservation: {
+      toolCallId: string;
+      kind: "inspection" | "mutation" | "verifier";
+      toolName: string;
+      workingTreeDigest: string;
+      workingTreeSnapshot: Record<string, string>;
+      targetPaths: string[];
+    }
+  ): boolean {
+    return this.#performanceReview.reserveTool(taskRunId, reservation);
+  }
+
+  completePerformanceReviewTool(
+    taskRunId: string,
+    toolCallId: string,
+    result: PerformanceReviewToolCompletion
+  ): PerformanceReviewToolCompletionResult {
+    const completion = this.#performanceReview.completeTool(taskRunId, toolCallId, result);
+    if (["locked", "invalidated"].includes(completion)) this.#performanceReview.invalidateCredit(taskRunId);
+    return completion;
+  }
+
+  invalidatePerformanceReviewCheckpoint(taskRunId: string): void {
+    this.#performanceReview.invalidateCheckpoint(taskRunId);
+  }
+
+  denyPerformanceReviewTool(taskRunId: string): void {
+    if (this.#performanceReview.denyTool(taskRunId)) this.#performanceReview.invalidateCredit(taskRunId);
+  }
+
+  clearPerformanceReview(taskRunId: string): void {
+    this.#performanceReview.clearReview(taskRunId);
+  }
+
+  rememberPerformanceReviewCredit(taskRunId: string, credit: PerformanceReviewCredit): void {
+    this.#performanceReview.rememberCredit(taskRunId, credit);
+  }
+
+  performanceReviewCredit(taskRunId: string, currentWorkingTreeDigest?: string): PerformanceReviewCredit | undefined {
+    return this.#performanceReview.credit(taskRunId, currentWorkingTreeDigest);
+  }
+
+  invalidatePerformanceReviewCredit(taskRunId: string): boolean {
+    return this.#performanceReview.invalidateCredit(taskRunId);
+  }
+
+  reserveAuthorizedModelMutation(
+    identity: ModelMutationIdentity,
+    toolCallId: string,
+    workingTreeSnapshotBefore: Record<string, string>,
+    targetPaths: string[],
+    proof: ModelMutationProof
+  ): boolean {
+    return this.#modelAuthorship.reserve(identity, toolCallId, workingTreeSnapshotBefore, targetPaths, proof);
   }
 
-  clearCompletionRecoveryAttempt(taskRunId: string): void {
-    this.#completionRecoveryAttempts.delete(taskRunId);
+  completeAuthorizedModelMutation(
+    identity: ModelMutationIdentity,
+    toolCallId: string,
+    success: boolean,
+    currentSnapshot: Record<string, string>,
+    currentContentDigests: Record<string, string> = {}
+  ): { changedPaths: string[]; recordedDigests: Record<string, string> } {
+    return this.#modelAuthorship.complete(identity, toolCallId, success, currentSnapshot, currentContentDigests);
+  }
+
+  successfulModelMutationDigests(identity: ModelMutationIdentity, currentSnapshot?: Record<string, string>): Record<string, string> {
+    return this.#modelAuthorship.digests(identity, currentSnapshot);
+  }
+
+  invalidateSuccessfulModelMutationPaths(identity: ModelMutationIdentity, paths: string[]): void {
+    this.#modelAuthorship.invalidate(identity, paths);
+  }
+
+  recoveryHistory(taskId: string): RecoveryHistoryEntry[] {
+    return [...(this.#recoveryHistoryByTask.get(taskId) ?? [])];
+  }
+
+  rememberRecoveryHistory(entry: RecoveryHistoryEntry): void {
+    const history = [...(this.#recoveryHistoryByTask.get(entry.taskId) ?? []), entry].slice(-20);
+    this.#recoveryHistoryByTask.set(entry.taskId, history);
+    evictOldest(this.#recoveryHistoryByTask, 100);
+  }
+
+  rememberResumeState(resume: ResumeState): void {
+    this.#resumeStateByTaskRun.set(resume.taskRunId, structuredClone(resume));
+    evictOldest(this.#resumeStateByTaskRun, 100);
+  }
+
+  resumeState(taskRunId: string): ResumeState | undefined {
+    const state = this.#resumeStateByTaskRun.get(taskRunId);
+    return state ? structuredClone(state) : undefined;
+  }
+
+  takeResumeContextState(ctx: ExtensionContext, taskRunId: string): ResumeState | undefined {
+    const key = `${this.sessionKey(ctx)}\u0000${taskRunId}`;
+    if (this.#deliveredResumeContexts.has(key)) return undefined;
+    const resume = this.#resumeStateByTaskRun.get(taskRunId);
+    if (!resume) return undefined;
+    this.#deliveredResumeContexts.add(key);
+    while (this.#deliveredResumeContexts.size > 200) {
+      this.#deliveredResumeContexts.delete(this.#deliveredResumeContexts.values().next().value as string);
+    }
+    return structuredClone(resume);
+  }
+
+  taskResumeBlock(taskRunId: string): string | undefined {
+    const resume = this.#resumeStateByTaskRun.get(taskRunId);
+    return resume && !resume.enforcementSafe && resume.decision !== "terminal" ? resume.reason : undefined;
+  }
+
+  clearDigestMigrationState(ctx: ExtensionContext, taskRunId: string, taskId: string): void {
+    this.#performanceReview.clearTask(taskRunId);
+    this.#modelAuthorship.clear(taskRunId);
+    this.#recoveryHistoryByTask.delete(taskId);
+    this.#resumeStateByTaskRun.delete(taskRunId);
+    this.#deliveredResumeContexts.delete(`${this.sessionKey(ctx)}\u0000${taskRunId}`);
+    this.clearShellMutationSnapshots(ctx);
   }
 
   previousToolResult(
@@ -160,8 +316,11 @@ export class RuntimeSessionState {
     this.#taskIdentityBySession.delete(sessionKey);
     this.#observedContextBySession.delete(sessionKey);
     this.clearShellMutationSnapshots(ctx);
-    if (taskIdentity) this.#completionRecoveryAttempts.delete(taskIdentity.taskRunId);
-    for (const values of [this.#advisedTools, this.#autoPackedPrompts]) {
+    if (taskIdentity) {
+      this.#performanceReview.clearTask(taskIdentity.taskRunId);
+      this.#modelAuthorship.clear(taskIdentity.taskRunId);
+    }
+    for (const values of [this.#advisedTools, this.#autoPackedPrompts, this.#deliveredResumeContexts]) {
       for (const key of values) {
         if (key.startsWith(prefix)) values.delete(key);
       }

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

@@ -1,3 +1,7 @@
+import type { TaskContract } from "../../extensions/guard-types.ts";
+import { SEMANTIC_COMPACTION_MAX_CHARS } from "../runtime-limits.ts";
+import { criterionGraphGuidance } from "../../extensions/criterion-graph.js";
+
 const LEGACY_PROJECT_INSTRUCTIONS_START = "Before implementation:\n\n1. Load `.pi/piagent-profile.json` with `piagent_context`.";
 const LEGACY_PROJECT_INSTRUCTIONS_END = "18. If the bundled `pi-subagents` parent skill is available, use it for delegation patterns, review loops, native supervisor coordination, and safety boundaries.";
 const RUNTIME_MANAGED_PROJECT_INSTRUCTIONS = [
@@ -50,3 +54,56 @@ export function compactManagedProjectInstructions(
   }
   return { systemPrompt, compacted: false };
 }
+
+function compactCarryOverText(value: unknown, maxChars: number): string {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (text.length <= maxChars) return text;
+  const marker = " ... ";
+  const available = maxChars - marker.length;
+  const head = Math.floor(available * 0.6);
+  return `${text.slice(0, head).trimEnd()}${marker}${text.slice(-(available - head)).trimStart()}`;
+}
+
+function compactCarryOverList(values: unknown[], limit: number, itemChars: number): string {
+  const selected = values.slice(0, limit).map((item) => compactCarryOverText(item, itemChars));
+  if (values.length > limit) selected.push(`[${values.length - limit} more retained in Task Contract]`);
+  return selected.join(", ") || "none recorded";
+}
+
+function boundedCarryOver(value: string): string {
+  if (value.length <= SEMANTIC_COMPACTION_MAX_CHARS) return value;
+  const marker = "\n\n[Piagent carry-over shortened; the durable Task Contract remains authoritative.]\n\n";
+  const available = SEMANTIC_COMPACTION_MAX_CHARS - marker.length;
+  const head = Math.floor(available * 0.72);
+  return `${value.slice(0, head).trimEnd()}${marker}${value.slice(-(available - head)).trimStart()}`;
+}
+
+export function buildSemanticCompactionInstructions(task?: TaskContract): string {
+  const taskState = task
+    ? [
+        `Current task: ${compactCarryOverText(task.taskId, 160)} (${task.riskLane})`,
+        `Session: ${compactCarryOverText(task.sessionName ?? task.sessionId, 160)}`,
+        `Goal: ${compactCarryOverText(task.summary, 600)}`,
+        "Acceptance criteria:",
+        ...task.acceptanceCriteria.slice(0, 12).map((criterion, index) => `- ${index + 1}. ${compactCarryOverText(criterion, 280)}`),
+        `Scope: ${compactCarryOverList(task.scope, 8, 80)}`,
+        ...(criterionGraphGuidance(task.criterionGraph, 8).length > 0 ? ["Execution map (planning only):", ...criterionGraphGuidance(task.criterionGraph, 8).map((line: string) => `- ${line}`)] : []),
+        `Changed files: ${compactCarryOverList(task.changedFiles, 8, 100)}`,
+        task.verifyCommands.length > 0
+          ? ["Exact verify commands:", ...task.verifyCommands.slice(0, 8).map((command, index) => `${index + 1}. ${compactCarryOverText(command, 180)}`)].join("\n")
+          : "Exact verify commands: not recorded",
+        `Outcome/blocker: ${task.trace.outcome}${task.trace.friction ? `; ${compactCarryOverText(task.trace.friction, 320)}` : ""}`,
+        "Full task truth is file-backed by the durable Task Contract; do not inspect private Piagent state directly."
+      ].join("\n")
+    : "No persisted task contract was found. Derive the current goal from the most recent user request.";
+  return boundedCarryOver([
+    "Create a structured Piagent carry-over summary.", taskState, "", "Preserve:",
+    "- current goal, acceptance criteria, explicit user decisions, and non-negotiable constraints",
+    "- architecture facts and invariants verified from repository files",
+    "- files changed, exact verification evidence, unresolved failures, blockers, and next action",
+    "- citations or paths needed to re-read advisory context", "", "Discard:",
+    "- superseded plans, repeated reads, raw tool logs, successful intermediate output, and speculative reasoning",
+    "- full source excerpts that can be re-read from the repository", "",
+    "Do not convert assumptions into facts. Mark unknowns explicitly. After compaction, re-read current files before editing."
+  ].join("\n"));
+}