@piagent/platform 1.6.0 → 1.6.1

package/packages/piagent-core/runtime/recovery/pristine-task-policy-refresh.ts

@@ -0,0 +1,91 @@
+import type { ProjectProfile, TaskContract } from "../../extensions/guard-types.ts";
+import { compileCriterionGraph } from "../../extensions/criterion-graph.js";
+import { meaningfulVerificationCommands, selectVerificationPlan } from "../../extensions/verification-intelligence.js";
+import { workingTreeSnapshot, workingTreeSnapshotHasUnavailableEvidence } from "../../extensions/task-state.js";
+
+export type PristineTaskVerificationRefresh = {
+  task: TaskContract;
+  refreshed: boolean;
+  reason: string;
+  verifyGroup?: string;
+  previousCommands: string[];
+  nextCommands: string[];
+};
+
+function sameStringRecord(left: Record<string, string>, right: Record<string, string>): boolean {
+  const leftEntries = Object.entries(left).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+  const rightEntries = Object.entries(right).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+  return leftEntries.length === rightEntries.length
+    && leftEntries.every(([key, value], index) => rightEntries[index]?.[0] === key && rightEntries[index]?.[1] === value);
+}
+
+function sameCommands(left: string[], right: string[]): boolean {
+  return left.length === right.length && left.every((command, index) => command === right[index]);
+}
+
+/**
+ * Refresh profile-derived verifier commands only while an automatic task is
+ * still byte-for-byte pristine. This lets a corrected workspace profile reach
+ * a resumed task without rewriting any source-change evidence or weakening an
+ * already-started implementation contract.
+ */
+export function refreshPristineRuntimeTaskVerification(
+  cwd: string,
+  task: TaskContract,
+  profile: ProjectProfile,
+  updatedAt = new Date().toISOString()
+): PristineTaskVerificationRefresh {
+  const previousCommands = meaningfulVerificationCommands(task.verifyCommands);
+  const unchanged = (reason: string): PristineTaskVerificationRefresh => ({
+    task, refreshed: false, reason, previousCommands, nextCommands: previousCommands
+  });
+  if (task.trace.outcome !== "pending" || task.intakeMode !== "runtime" || task.changeMode !== "source-change") {
+    return unchanged("task-not-refreshable");
+  }
+  if ((task.changedFiles?.length ?? 0) > 0 || (task.observedChangedFiles?.length ?? 0) > 0 || (task.verifyEvidence?.length ?? 0) > 0) {
+    return unchanged("task-has-runtime-evidence");
+  }
+  const configuredGroups = profile.verifyCommands && typeof profile.verifyCommands === "object"
+    ? profile.verifyCommands
+    : {};
+  const retainedGroup = task.verifyGroup && Object.hasOwn(configuredGroups, task.verifyGroup)
+    ? task.verifyGroup
+    : undefined;
+  const plan = selectVerificationPlan(profile, retainedGroup, task.changeMode, cwd, task.scope);
+  if (plan.error) return unchanged("profile-verifier-invalid");
+  const nextCommands = meaningfulVerificationCommands(plan.commands);
+  if (nextCommands.length === 0) return unchanged("profile-verifier-unavailable");
+  if (sameCommands(previousCommands, nextCommands) && task.verifyGroup === plan.group) {
+    return unchanged("profile-verifier-current");
+  }
+  if (!task.baselineFileDigests || typeof task.baselineFileDigests !== "object" || Array.isArray(task.baselineFileDigests)) {
+    return unchanged("baseline-unavailable");
+  }
+  const baseline = task.baselineFileDigests;
+  const current = workingTreeSnapshot(cwd) as Record<string, string>;
+  if (workingTreeSnapshotHasUnavailableEvidence(current) || !sameStringRecord(baseline, current)) {
+    return unchanged("working-tree-not-pristine");
+  }
+  const refreshed: TaskContract = {
+    ...task,
+    verifyGroup: plan.group,
+    verifyCommands: nextCommands,
+    criterionGraph: compileCriterionGraph({
+      acceptanceCriteria: task.acceptanceCriteria,
+      scope: task.scope,
+      verifyCommands: nextCommands,
+      changeMode: task.changeMode,
+      mode: task.criterionGraph?.mode ?? "mechanical",
+      createdAt: task.criterionGraph?.createdAt ?? task.createdAt
+    }) as NonNullable<TaskContract["criterionGraph"]>,
+    updatedAt
+  };
+  return {
+    task: refreshed,
+    refreshed: true,
+    reason: "pristine-profile-verifier-refresh",
+    verifyGroup: plan.group,
+    previousCommands,
+    nextCommands
+  };
+}

package/packages/piagent-core/runtime/recovery/recovery-policy.ts

@@ -29,6 +29,9 @@ export type RecoveryReasonCode =
   | "provider-transient-retry"
   | "provider-retry-exhausted"
   | "permission-expansion-forbidden"
+  | "protected-path-forbidden"
+  // Legacy persisted recovery records may still carry this value. New runtime
+  // decisions never emit it because task scope is advisory.
   | "scope-replan-required"
   | "transient-verifier-retry"
   | "transient-retry-unavailable"
@@ -185,11 +188,11 @@ export function selectRecoveryDecision(input: RecoveryPolicyInput): RecoveryDeci
   if (input.currentPhase === "terminal") return decision(input, "blocked", ["terminal-phase"]);
   if (input.currentPhase === "handoff") return decision(input, "handoff", ["handoff-already-observed"]);
   if (input.classification.category === "passed") return decision(input, "handoff", ["no-failure"]);
-  // A completion boundary violation cannot be repaired within the immutable
-  // task contract. Stop before stale-verifier or unknown-diagnostic retries so
-  // recovery never spends another turn attempting source work outside scope.
+  // Protected-path evidence cannot be repaired by another model turn. The
+  // failure category also accepts historical scope diagnostics for replay
+  // compatibility, but current task scope itself is advisory.
   if (input.classification.category === "scope-protected-path") {
-    return decision(input, "handoff", ["scope-replan-required"]);
+    return decision(input, "handoff", ["protected-path-forbidden"]);
   }
 
   const counts = countsFor(input);

package/packages/piagent-core/runtime/recovery/resume-state.ts

@@ -2,7 +2,6 @@ import path from "node:path";
 
 import type { TaskContract } from "../../extensions/guard-types.ts";
 import { allVerifyCommandsPassCurrentTree } from "../../extensions/task-contract-view.js";
-import { criterionGraphGuidance } from "../../extensions/criterion-graph.js";
 import { replayTaskCheckpoints, taskRecoveryDecision } from "../../extensions/task-journal.js";
 import { taskDigestMigrationArchiveStatus, workingTreeSnapshot, workingTreeSnapshotHasUnavailableEvidence } from "../../extensions/task-state.js";
 import { workingTreeEvidenceDigest } from "../../extensions/task-lifecycle.js";
@@ -10,12 +9,21 @@ import { hashEvidenceCommand } from "../../extensions/runtime-evidence.js";
 import { WORKING_TREE_DIGEST_ALGORITHM, isCurrentWorkingTreeDigest, workingTreeSnapshotUsesCurrentAlgorithm } from "../../extensions/working-tree-digest.js";
 import { handoffProjectionPath, readHandoffProjection } from "./handoff-projection.ts";
 import { inspectTaskAuthorityResumePolicy, type AuthorityResumeDecision } from "../policy/authority-resume-policy.ts";
+import { presentedAcceptanceCriteria, presentedCriterionGraphGuidance } from "../session/task-contract-presentation.ts";
+import { operatorRequestCarryLines } from "../session/operator-request-carry.ts";
 import { readTrajectoryStore } from "../trajectory/trajectory-store.ts";
 import { findVerifierFileSnapshot, inspectVerifierStaleness, readVerifierFileSnapshots } from "../inspection/verifier-snapshot-store.ts";
 
 export const RESUME_STATE_VERSION = "resume-v1" as const;
 export const RESUME_CONTEXT_VERSION = "resume-context-v1" as const;
-export const RESUME_CONTEXT_MAX_CHARS = 6_000;
+export const RESUME_CONTEXT_MAX_CHARS = 12_000;
+// Validated task text is bounded in Unicode code points by JSON Schema. Astral
+// characters occupy two UTF-16 code units, so the exceptional resume ceiling
+// must cover the worst valid lossless task even though the normal target stays
+// at 12k. This overflow is explicit and is never used for routine compaction.
+export const RESUME_CONTEXT_LOSSLESS_MAX_CHARS = 40_000;
+export const RESUME_CONTEXT_LOSSLESS_OVERFLOW_MARKER = `[Piagent lossless resume overflow: the ${RESUME_CONTEXT_MAX_CHARS}-character target was exceeded; complete authoritative task truth is retained.]`;
+export const LEGACY_TASK_TRUTH_OVERFLOW_MARKER = `[Piagent legacy-task-truth-overflow: automatic continuation is paused because lossless task truth exceeds the ${RESUME_CONTEXT_LOSSLESS_MAX_CHARS}-character exceptional ceiling.]`;
 type ResumePlanStep = {
   id: string;
   title: string;
@@ -153,44 +161,129 @@ function limitedLines(values: unknown[], maximumItems: number, maximumChars: num
   return selected;
 }
 
+function losslessManualResumeContent(task: TaskContract): string {
+  return [
+    "[Piagent durable task resume]",
+    RESUME_CONTEXT_LOSSLESS_OVERFLOW_MARKER,
+    `Task: ${compact(task.taskId, 120)} (${compact(task.taskRunId, 120)})`,
+    `Goal: ${task.summary}`,
+    `Expected output: ${task.expectedOutput}`,
+    "Acceptance focus:", ...presentedAcceptanceCriteria(task).map((value, index) => `- C${index + 1}: ${value}`),
+    "Exact verifier commands:", ...task.verifyCommands.map((value, index) => `${index + 1}. ${value}`),
+    "Continue only under the current runtime-enforced task state and every durable task clause above; do not infer progress from transcript memory."
+  ].join("\n");
+}
+
+/** Exact UTF-16 traffic size for the smallest lossless automatic legacy resume. */
+export function legacyTaskResumeTruthChars(task: TaskContract): number {
+  return operatorRequestCarryLines(task).length > 0 ? 0 : losslessManualResumeContent(task).length;
+}
+
+function legacyTaskTruthOverflowsAutomaticResume(task: TaskContract): boolean {
+  const chars = legacyTaskResumeTruthChars(task);
+  return chars > RESUME_CONTEXT_LOSSLESS_MAX_CHARS;
+}
+
+function legacyOverflowResumeContent(task: TaskContract): string {
+  return [
+    "[Piagent durable task resume]",
+    LEGACY_TASK_TRUTH_OVERFLOW_MARKER,
+    `Task: ${compact(task.taskId, 120)} (${compact(task.taskRunId, 120)})`,
+    "The durable task remains byte-for-byte intact, but its complete acceptance truth cannot be injected safely in one automatic resume.",
+    "Do not mutate or auto-continue this task. Ask the operator to re-intake the original request as a new bounded task or provide an explicit compact handoff."
+  ].join("\n");
+}
+
 export function buildTaskResumeContext(task: TaskContract, resume: ResumeState): {
   customType: "piagent-runtime-task-resume";
   content: string;
   details: Record<string, unknown>;
 } {
-  const criteria = limitedLines(task.acceptanceCriteria, 8, 180, (value, index) => `- C${index + 1}: ${value}`);
+  if (legacyTaskTruthOverflowsAutomaticResume(task)) {
+    return {
+      customType: "piagent-runtime-task-resume",
+      content: legacyOverflowResumeContent(task),
+      details: {
+        resumeContextVersion: RESUME_CONTEXT_VERSION, taskId: task.taskId, taskRunId: task.taskRunId,
+        phase: resume.phase, checkpointId: resume.latestCheckpoint?.checkpointId ?? null,
+        decision: "blocked", enforcementSafe: false, verifierEvidenceCurrent: resume.verifierEvidenceCurrent,
+        staleVerifierEvidence: resume.staleVerifierEvidence, losslessOverflow: true,
+        legacyTaskTruthOverflow: true, nextAction: resume.reconstruction.nextAction
+      }
+    };
+  }
+  const operatorTruth = operatorRequestCarryLines(task);
+  const presentedCriteria = presentedAcceptanceCriteria(task);
+  const criteria = operatorTruth.length > 0
+    ? limitedLines(presentedCriteria, 8, 180, (value, index) => `- C${index + 1}: ${value}`)
+    : presentedCriteria.map((value, index) => `- C${index + 1}: ${value}`);
   const scope = limitedLines(task.scope, 8, 100, (value) => `- ${value}`);
   const plan = resume.reconstruction.plan.slice(0, 12).map((step) => (
     `- ${step.id}: ${step.status}; ${compact(step.title, 140)}${step.dependsOn.length > 0 ? `; after=${step.dependsOn.join(",")}` : ""}`
   ));
   if (resume.reconstruction.plan.length > 12) plan.push(`- [${resume.reconstruction.plan.length - 12} more steps retained in the Task Contract]`);
-  const verifiers = limitedLines(task.verifyCommands, 8, 180, (value, index) => `${index + 1}. ${value}`);
-  const executionMap = criterionGraphGuidance(task.criterionGraph, 8).map((line: string) => `- ${line}`);
+  const verifiers = task.verifyCommands.map((value, index) => `${index + 1}. ${value}`);
+  const executionMap = presentedCriterionGraphGuidance(task, 8).map((line: string) => `- ${line}`);
   const next = resume.reconstruction.nextAction;
   const lines = [
     "[Piagent durable task resume]",
     "This brief is reconstructed from the current Task Contract, journal, trajectory, handoff and working tree. Durable files remain authoritative.",
     `Task: ${compact(task.taskId, 160)} (${compact(task.taskRunId, 160)})`,
-    `Goal: ${compact(task.summary, 500)}`,
-    `Expected output: ${compact(task.expectedOutput, 400)}`,
+    `Goal: ${operatorTruth.length > 0 ? compact(task.summary, 500) : task.summary}`,
+    ...operatorTruth,
+    `Expected output: ${operatorTruth.length > 0 ? compact(task.expectedOutput, 400) : task.expectedOutput}`,
     "Acceptance focus:", ...criteria,
-    "Scope:", ...scope,
+    "Initial focus (advisory):", ...scope,
+    "Initial focus guides retrieval/review and neither authorizes nor forbids mutation.",
     "Work plan/progress:", ...plan,
     ...(executionMap.length > 0 ? ["Execution map (planning only):", ...executionMap] : []),
     `Current phase/checkpoint: ${resume.phase ?? "unknown"} / ${resume.latestCheckpoint?.checkpointId ?? "none"}`,
     `Verifier state: current=${resume.verifierEvidenceCurrent}; stale=${resume.staleVerifierEvidence}; tree=${resume.currentTreeDigest}`,
     "Exact verifier commands:", ...verifiers,
     `Next safe action: ${next.action}${next.stepId ? ` (${next.stepId})` : ""}. ${compact(next.reason, 500)}`,
-    ...(next.exactCommands.length > 0 ? ["Required commands for that action:", ...limitedLines(next.exactCommands, 8, 180, (value, index) => `${index + 1}. ${value}`)] : []),
+    ...(next.exactCommands.length > 0 ? ["Required commands for that action:", ...next.exactCommands.map((value, index) => `${index + 1}. ${value}`)] : []),
     `Resume safety: decision=${resume.decision}; enforcementSafe=${resume.enforcementSafe}; handoff=${resume.handoff.exists ? resume.handoff.path : "none"}.`,
     "Do not infer progress from transcript memory, reopen completed steps, or mutate when the next action is inspect-handoff, wait-paused, or terminal."
   ];
   let content = lines.join("\n");
   if (content.length > RESUME_CONTEXT_MAX_CHARS) {
-    const marker = "\n[Middle details shortened; complete task truth remains in the Task Contract.]\n";
-    const available = RESUME_CONTEXT_MAX_CHARS - marker.length;
-    const head = Math.floor(available * 0.7);
-    content = `${content.slice(0, head).trimEnd()}${marker}${content.slice(-(available - head)).trimStart()}`;
+    const boundedOperatorTruth = operatorRequestCarryLines(task);
+    content = boundedOperatorTruth.length > 0 ? [
+      "[Piagent durable task resume]",
+      `Task: ${compact(task.taskId, 160)} (${compact(task.taskRunId, 160)})`,
+      ...boundedOperatorTruth,
+      "Acceptance focus:", ...limitedLines(presentedAcceptanceCriteria(task), 8, 160, (value, index) => `- C${index + 1}: ${value}`),
+      `Current phase/checkpoint: ${resume.phase ?? "unknown"} / ${resume.latestCheckpoint?.checkpointId ?? "none"}`,
+      "Exact verifier commands:", ...verifiers,
+      `Next safe action: ${next.action}${next.stepId ? ` (${next.stepId})` : ""}. ${compact(next.reason, 400)}`,
+      `Resume safety: decision=${resume.decision}; enforcementSafe=${resume.enforcementSafe}.`,
+      "Continue from current source. Preserve every operator clause exactly; do not infer progress from transcript memory."
+    ].join("\n") : losslessManualResumeContent(task);
+    if (content.length > RESUME_CONTEXT_MAX_CHARS && boundedOperatorTruth.length > 0) {
+      content = [
+        "[Piagent durable task resume]",
+        RESUME_CONTEXT_LOSSLESS_OVERFLOW_MARKER,
+        `Task: ${compact(task.taskId, 120)} (${compact(task.taskRunId, 120)})`,
+        ...boundedOperatorTruth,
+        "Acceptance focus:", ...limitedLines(presentedAcceptanceCriteria(task), 12, 220, (value, index) => `- C${index + 1}: ${value}`),
+        "Exact verifier commands:", ...verifiers,
+        `Next safe action: ${next.action}${next.stepId ? ` (${next.stepId})` : ""}. ${compact(next.reason, 300)}`,
+        `Resume safety: decision=${resume.decision}; enforcementSafe=${resume.enforcementSafe}.`,
+        "Continue only from current source, the complete operator request, exact verifiers, and durable atomic acceptance facts."
+      ].join("\n");
+      if (content.length > RESUME_CONTEXT_LOSSLESS_MAX_CHARS) {
+        content = [
+          "[Piagent durable task resume]",
+          RESUME_CONTEXT_LOSSLESS_OVERFLOW_MARKER,
+          `Task: ${compact(task.taskId, 120)} (${compact(task.taskRunId, 120)})`,
+          ...boundedOperatorTruth,
+          "Exact verifier commands:", ...verifiers,
+          `Next safe action: ${next.action}${next.stepId ? ` (${next.stepId})` : ""}. ${compact(next.reason, 240)}`,
+          `Resume safety: decision=${resume.decision}; enforcementSafe=${resume.enforcementSafe}.`,
+          "The complete operator request above is the acceptance source of truth. Continue only from current source and these exact verifiers."
+        ].join("\n");
+      }
+    }
   }
   return {
     customType: "piagent-runtime-task-resume",
@@ -205,6 +298,7 @@ export function buildTaskResumeContext(task: TaskContract, resume: ResumeState):
       enforcementSafe: resume.enforcementSafe,
       verifierEvidenceCurrent: resume.verifierEvidenceCurrent,
       staleVerifierEvidence: resume.staleVerifierEvidence,
+      losslessOverflow: content.length > RESUME_CONTEXT_MAX_CHARS,
       nextAction: resume.reconstruction.nextAction
     }
   };
@@ -220,6 +314,7 @@ export function inspectTaskResumeState(
   const currentTreeDigest = workingTreeEvidenceDigest(currentDigests);
   const authorityPolicy = inspectTaskAuthorityResumePolicy(cwd, task);
   const archive = taskDigestMigrationArchiveStatus(cwd, task);
+  const legacyTruthOverflow = task.trace.outcome === "pending" && legacyTaskTruthOverflowsAutomaticResume(task);
   const algorithmReady = task.workingTreeDigestAlgorithm === WORKING_TREE_DIGEST_ALGORITHM
     && isCurrentWorkingTreeDigest(currentTreeDigest)
     && workingTreeSnapshotUsesCurrentAlgorithm(currentDigests)
@@ -265,8 +360,9 @@ export function inspectTaskResumeState(
   if (!trajectory.enforcementSafe) warnings.push(`trajectory state is unsafe: ${trajectory.warnings[0] ?? "unknown error"}`);
   if (!algorithmReady) warnings.push("working-tree digest algorithm/evidence is not current and proof-capable");
   if (!archive.valid) warnings.push(archive.reason);
+  if (legacyTruthOverflow) warnings.push("legacy-task-truth-overflow requires explicit operator re-intake or compact handoff");
   if (refreshRequired) warnings.push("legacy evidence was archived; run each exact configured verifier once against the current wt-content-v2 tree");
-  const enforcementSafe = authorityReady && !identityConflict && algorithmReady && archive.valid && journal.corruptions.length === 0 && trajectory.enforcementSafe && handoffValid;
+  const enforcementSafe = authorityReady && !identityConflict && !legacyTruthOverflow && algorithmReady && archive.valid && journal.corruptions.length === 0 && trajectory.enforcementSafe && handoffValid;
   const recovery = refreshRequired ? { decision: "resume", reason: "Digest migration requires current exact verifier evidence." } : taskRecoveryDecision(task, journal);
   const decision: ResumeState["decision"] = terminal
     ? "terminal"
@@ -281,6 +377,8 @@ export function inspectTaskResumeState(
             : "resume";
   const reason = terminal
     ? `Task contract is immutable after ${task.trace.outcome}.`
+    : legacyTruthOverflow
+      ? "legacy-task-truth-overflow: automatic continuation is paused; ask the operator to re-intake the original request or provide a compact handoff."
     : journal.corruptions.length > 0
       ? `task journal is corrupt: ${journal.corruptions[0]}`
     : !authorityReady

package/packages/piagent-core/runtime/recovery/semantic-repair-handshake.ts

@@ -11,7 +11,6 @@ import { safeTaskId } from "../../extensions/task-state.js";
 import { isCurrentWorkingTreeDigest } from "../../extensions/working-tree-digest.js";
 
 const HASH = /^[a-f0-9]{64}$/;
-const GLOB = /[?*[\]{}]/;
 const MAX_FILE_BYTES = 256 * 1024;
 export const MAX_SEMANTIC_REPAIR_PATHS = 12;
 export const MAX_SEMANTIC_REPAIR_REVISIONS = 2;
@@ -106,13 +105,6 @@ function tokenHash(token: string): string {
   return crypto.createHash("sha256").update(token).digest("hex");
 }
 
-function exactDeclaredPath(task: TaskContract, target: string): boolean {
-  return (task.scope ?? []).some((candidate) => {
-    const normalized = normalizePathCandidate(candidate);
-    return Boolean(normalized && !GLOB.test(normalized) && normalized === target);
-  });
-}
-
 function isTestPath(file: string): boolean {
   return /(^|\/)(?:test|tests|spec|__tests__)(\/|$)|[._-](?:test|spec)\.[cm]?[jt]sx?$/i.test(file);
 }
@@ -146,12 +138,13 @@ export function decideSemanticRepairHandshake(input: {
   verifierCurrent: boolean;
 }): SemanticRepairHandshakeDecision {
   const targets = uniquePaths(input.mutationTargets), delta = new Set(uniquePaths(input.currentDeltaPaths));
+  const targetSet = new Set(targets);
   const empty = { authorized: false, conflictCodes: [], eligibleTargets: [], eligiblePaths: [], pathConflictCodes: {} };
   if (!input.verifierCurrent || targets.length === 0 || delta.size === 0) return empty;
-  const candidates = uniquePaths([...delta, ...(input.task.scope ?? []).filter((item) => !GLOB.test(item))]);
+  const candidates = uniquePaths([...delta, ...targets]);
   const pathConflictCodes: Record<string, string[]> = {}, sourceTexts = new Map<string, string>();
   for (const file of candidates) {
-    if (isTestPath(file) || (!delta.has(file) && !exactDeclaredPath(input.task, file))) continue;
+    if (isTestPath(file) || (!delta.has(file) && !targetSet.has(file))) continue;
     const source = readSmallFile(input.cwd, file), conflicts = contentLinkedConflictCodes(input.task, source);
     if (conflicts.length === 0) continue;
     pathConflictCodes[file] = conflicts;
@@ -161,7 +154,7 @@ export function decideSemanticRepairHandshake(input: {
   if (sourcePaths.length === 0) return empty;
   const relatedTests = candidates.filter((file) => (
     isTestPath(file)
-    && (delta.has(file) || exactDeclaredPath(input.task, file))
+    && (delta.has(file) || targetSet.has(file))
     && sourcePaths.some((sourcePath) => acceptanceExecutableTestBinding({
       sourceEntry: { path: sourcePath, text: sourceTexts.get(sourcePath) ?? "" },
       testEntry: { path: file, text: readSmallFile(input.cwd, file) }
@@ -181,8 +174,9 @@ export function decideSemanticRepairHandshake(input: {
  * This is intentionally narrower than semantic repair: every target must be
  * an actual current task delta, must have been observed in this task, and must
  * still carry successful structured-mutation authorship for the exact task,
- * run, and session. The caller separately enforces task scope and CAP-09/12/13
- * authority before persisting the reservation.
+ * run, and session. The caller separately enforces CAP-09/12/13 and every
+ * normal protected-path, permission, approval, and exact-target guard before
+ * persisting the reservation; task scope is advisory.
  */
 export function decideBoundedRecoveryHandshake(input: {
   task: TaskContract;

package/packages/piagent-core/runtime/recovery/task-evidence-coverage-refresh.ts

@@ -0,0 +1,217 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type { TaskContract } from "../../extensions/guard-types.ts";
+import { readTaskJournal } from "../../extensions/task-journal.js";
+import {
+  directChildGitEvidenceRoots,
+  normalizedGitPath
+} from "../../extensions/workspace-evidence-roots.js";
+import {
+  workingTreeSnapshot,
+  workingTreeSnapshotHasUnavailableEvidence
+} from "../../extensions/task-state.js";
+import { workingTreeEvidenceDigest } from "../../extensions/working-tree-digest.js";
+import { readMutationProvenance } from "../inspection/mutation-provenance-store.ts";
+import { readTaskBaselineManifest } from "../inspection/source-evidence-store.ts";
+
+// Some filesystems expose timestamps at coarse granularity. Requiring a clear
+// pre-task gap prevents a file created in the same timestamp bucket as task
+// startup from being mistaken for legacy baseline state.
+const LEGACY_EVIDENCE_TIMESTAMP_SAFETY_MS = 2_000;
+
+export type TaskEvidenceCoverageRefresh = {
+  task: TaskContract;
+  refreshed: boolean;
+  reason: string;
+  addedPaths: string[];
+  retainedMutationPaths: string[];
+  ambiguousPaths: string[];
+  previousBaselineDigest: string;
+  nextBaselineDigest: string;
+};
+
+function strings(value: unknown): string[] {
+  return Array.isArray(value)
+    ? [...new Set(value.filter((item): item is string => typeof item === "string" && item.trim().length > 0)
+      .map((item) => normalizedGitPath(item).replace(/\/$/, "")))]
+    : [];
+}
+
+function decodedMutationPath(value: unknown): string | undefined {
+  if (typeof value !== "string" || value.length > 8192 || !/^[A-Za-z0-9_-]*$/.test(value)) return undefined;
+  try {
+    const decoded = Buffer.from(value, "base64url").toString("utf8");
+    const normalized = normalizedGitPath(decoded);
+    return normalized && normalized !== "." && normalized !== ".." && !normalized.startsWith("../")
+      ? normalized
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function journalMutationPaths(cwd: string, taskRunId: string): { paths: string[]; corruptions: string[] } {
+  const journal = readTaskJournal(cwd, { taskRunId });
+  const paths: string[] = [];
+  for (const event of journal.events) {
+    if (event.eventType !== "checkpoint" || event.taskRunId !== taskRunId) continue;
+    const evidence = event.data?.evidence;
+    if (!evidence || typeof evidence !== "object" || Array.isArray(evidence)) continue;
+    paths.push(...strings((evidence as Record<string, unknown>).files));
+    paths.push(...strings((evidence as Record<string, unknown>).targetPaths));
+  }
+  return { paths: [...new Set(paths)].sort(), corruptions: journal.corruptions };
+}
+
+function provenanceMutationPaths(cwd: string, taskRunId: string): { paths: string[]; corruptions: string[] } {
+  const provenance = readMutationProvenance(cwd, taskRunId);
+  const paths = provenance.records.flatMap((record) => record.changes
+    .map((change) => decodedMutationPath(change.repoPathBase64))
+    .filter((item): item is string => Boolean(item)));
+  return { paths: [...new Set(paths)].sort(), corruptions: provenance.corruptions };
+}
+
+function isLegacyLooseHiddenPath(file: string, childGitPrefixes: string[]): boolean {
+  const normalized = normalizedGitPath(file);
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) return false;
+  if (childGitPrefixes.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`))) return false;
+  return normalized.split("/").some((segment) => segment.startsWith(".") && segment.length > 1);
+}
+
+function fileStatePredatesTask(cwd: string, file: string, createdAt: string): boolean {
+  const taskStartedAt = Date.parse(createdAt);
+  if (!Number.isFinite(taskStartedAt)) return false;
+  const absolute = path.resolve(cwd, file);
+  const relative = path.relative(cwd, absolute);
+  if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return false;
+
+  // The legacy inventory has no content digest for this path. Metadata that is
+  // older than the task is the only local positive evidence that the exact file
+  // state existed before task execution. A symlink, unreadable component, zero
+  // timestamp, or any task-time ctime/mtime remains an ordinary task delta.
+  let current = cwd;
+  try {
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+      current = path.join(current, segment);
+      const component = fs.lstatSync(current);
+      if (component.isSymbolicLink()) return false;
+    }
+    const stat = fs.lstatSync(absolute);
+    if (!stat.isFile() || stat.isSymbolicLink()) return false;
+    const timestamps = [stat.birthtimeMs, stat.ctimeMs, stat.mtimeMs];
+    const latestSafeTimestamp = taskStartedAt - LEGACY_EVIDENCE_TIMESTAMP_SAFETY_MS;
+    return timestamps.every((value) => Number.isFinite(value) && value > 0 && value <= latestSafeTimestamp);
+  } catch {
+    return false;
+  }
+}
+
+function manifestProvenBaselinePaths(
+  cwd: string,
+  task: TaskContract,
+  previousBaseline: Record<string, string>,
+  current: Record<string, string>,
+  candidates: string[]
+): string[] {
+  if (candidates.length === 0) return [];
+  try {
+    const manifest = readTaskBaselineManifest(cwd, task.taskRunId);
+    if (!manifest || manifest.taskId !== task.taskId || manifest.taskRunId !== task.taskRunId) return [];
+    const expanded = { ...previousBaseline };
+    for (const file of candidates) expanded[file] = current[file];
+    return workingTreeEvidenceDigest(expanded) === manifest.baselineTreeDigest ? candidates : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Reconcile the one coverage gap introduced when parent-workspace evidence
+ * began including hidden project source. Only paths the legacy collector could
+ * not see are adopted, and any path with durable mutation evidence remains a
+ * real task delta. Existing baseline entries are never rewritten.
+ */
+export function refreshLegacyHiddenWorkspaceEvidenceCoverage(
+  cwd: string,
+  task: TaskContract
+): TaskEvidenceCoverageRefresh {
+  const previousBaseline = task.baselineFileDigests ?? {};
+  const previousBaselineDigest = workingTreeEvidenceDigest(previousBaseline);
+  const unchanged = (
+    reason: string,
+    retainedMutationPaths: string[] = [],
+    ambiguousPaths: string[] = []
+  ): TaskEvidenceCoverageRefresh => ({
+    task,
+    refreshed: false,
+    reason,
+    addedPaths: [],
+    retainedMutationPaths,
+    ambiguousPaths,
+    previousBaselineDigest,
+    nextBaselineDigest: previousBaselineDigest
+  });
+
+  if (task.trace.outcome !== "pending" || task.changeMode !== "source-change") return unchanged("task-not-refreshable");
+  if (!previousBaseline || typeof previousBaseline !== "object" || Array.isArray(previousBaseline)) return unchanged("baseline-unavailable");
+  const childGitPrefixes = directChildGitEvidenceRoots(cwd).map((root) => normalizedGitPath(root.prefix)).filter(Boolean);
+  if (childGitPrefixes.length === 0) return unchanged("not-parent-multi-repo-workspace");
+
+  const current = workingTreeSnapshot(cwd) as Record<string, string>;
+  if (workingTreeSnapshotHasUnavailableEvidence(current)) return unchanged("current-evidence-unavailable");
+  const candidates = Object.keys(current)
+    .filter((file) => previousBaseline[file] === undefined && isLegacyLooseHiddenPath(file, childGitPrefixes))
+    .sort();
+  if (candidates.length === 0) return unchanged("coverage-current");
+
+  const journal = journalMutationPaths(cwd, task.taskRunId);
+  const provenance = provenanceMutationPaths(cwd, task.taskRunId);
+  if (journal.corruptions.length > 0 || provenance.corruptions.length > 0) {
+    return unchanged("mutation-evidence-unavailable");
+  }
+  const mutated = new Set([
+    ...strings(task.observedChangedFiles),
+    ...strings(task.changedFiles),
+    ...journal.paths,
+    ...provenance.paths
+  ]);
+  const retainedMutationPaths = candidates.filter((file) => mutated.has(file));
+  const unclaimedCandidates = candidates.filter((file) => !mutated.has(file));
+  // A current, integrity-validated baseline manifest is stronger than file
+  // timestamps: if adding the currently observed missing paths reconstructs
+  // its exact task-start tree digest, none of those paths changed after start.
+  // Legacy manifests that did not cover the paths simply fail this equality
+  // and retain the conservative timestamp fallback.
+  const manifestProven = new Set(manifestProvenBaselinePaths(cwd, task, previousBaseline, current, unclaimedCandidates));
+  const addedPaths = unclaimedCandidates.filter((file) => manifestProven.has(file) || fileStatePredatesTask(cwd, file, task.createdAt));
+  const added = new Set(addedPaths);
+  const ambiguousPaths = unclaimedCandidates.filter((file) => !added.has(file));
+  if (addedPaths.length === 0) {
+    return unchanged(
+      ambiguousPaths.length > 0 ? "coverage-candidates-ambiguous" : "coverage-candidates-have-mutation-evidence",
+      retainedMutationPaths,
+      ambiguousPaths
+    );
+  }
+
+  const baselineFileDigests = { ...previousBaseline };
+  for (const file of addedPaths) baselineFileDigests[file] = current[file];
+  const refreshed: TaskContract = {
+    ...task,
+    baselineChangedFiles: Object.keys(baselineFileDigests).sort(),
+    baselineFileDigests
+  };
+  return {
+    task: refreshed,
+    refreshed: true,
+    reason: ambiguousPaths.length > 0
+      ? "legacy-hidden-workspace-coverage-partially-expanded"
+      : "legacy-hidden-workspace-coverage-expanded",
+    addedPaths,
+    retainedMutationPaths,
+    ambiguousPaths,
+    previousBaselineDigest,
+    nextBaselineDigest: workingTreeEvidenceDigest(baselineFileDigests)
+  };
+}

package/packages/piagent-core/runtime/registration/context-commands.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { stageContextDelivery } from "../context/context-delivery.ts";
+import { semanticCompactionCancelled } from "../session/system-prompt.ts";
 
 type ExtensionContext = any;
 
@@ -236,6 +237,19 @@ export function registerContextCommands(pi: ExtensionAPI, deps: Record<string, a
   function compactCurrentSession(ctx: ExtensionContext): void {
     const sessionId = ctx.sessionManager.getSessionId();
     const instructions = semanticCompactionInstructions(ctx.cwd, sessionId);
+    if (semanticCompactionCancelled(instructions)) {
+      telemetry(ctx, {
+        event: "compaction_cancelled",
+        mode: "semantic",
+        reason: "lossless-task-truth-exceeds-carry-target",
+        hasTaskContract: Boolean(compactSessionTask(ctx.cwd, sessionId))
+      });
+      ctx.ui.notify("Piagent kept the current context because compacting it would lose required task details.", "warning");
+      emitRuntimeMessage(ctx, "piagent-context-compaction-cancelled", instructions, {
+        reason: "lossless-task-truth-exceeds-carry-target"
+      });
+      return;
+    }
     telemetry(ctx, {
       event: "compaction_requested",
       mode: "semantic",
@@ -428,10 +442,10 @@ export function registerContextCommands(pi: ExtensionAPI, deps: Record<string, a
           content: [
             `mode: ${orchestration.defaultMode}`,
             `helpersMode: ${helpersMode()}`,
-            `subagents: bounded read-only scout/planning/review; max ${orchestration.maxConcurrentSubagents}`,
+            `helpers: max ${orchestration.maxConcurrentSubagents} fresh read-only total; requires >=30% projected net token saving`,
             `lenses: ${orchestration.defaultReviewLenses.join(", ")}`,
             `fieldGuide: ${orchestration.fieldGuide.enabled ? `${fieldGuidePath} (${fieldGuideExists ? "exists" : "missing"})` : "off"}`,
-            "writer: single writer by default; parallel writers need explicit approval + isolation"
+            "writer: parent only; helper workers and retries are disabled"
           ].join("\n"),
           display: true,
           details: {