@piagent/platform 1.6.0 → 1.7.1

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

@@ -1,43 +1,15 @@
 import type { FailureClassification } from "../../extensions/failure-types.ts";
 import { failureClassificationValidationErrors } from "../../extensions/failure-types.ts";
+import {
+  RECOVERY_ACTIONS, RECOVERY_CEILINGS, RECOVERY_POLICY_VERSION, RECOVERY_REASON_CODES, recoveryDecisionValidationErrors
+} from "../../extensions/recovery-decision-validation.ts";
 import type { TrajectoryPhase } from "../trajectory/trajectory-types.ts";
 
-export const RECOVERY_POLICY_VERSION = "recovery-v1" as const;
-export const RECOVERY_ACTIONS = Object.freeze(["repair", "retry", "fresh-session", "ask-operator", "handoff", "blocked"] as const);
-export const RECOVERY_CEILINGS = Object.freeze({
-  sourceRepairPasses: 1,
-  transientVerifierRetries: 1,
-  unknownDiagnosticPasses: 1,
-  providerRetries: 1
-} as const);
+export { RECOVERY_ACTIONS, RECOVERY_CEILINGS, RECOVERY_POLICY_VERSION, RECOVERY_REASON_CODES, recoveryDecisionValidationErrors };
 
 export type RecoveryAction = typeof RECOVERY_ACTIONS[number];
 export type RecoveryDisposition = "scheduled" | "failed" | "succeeded" | "declined";
-export type RecoveryReasonCode =
-  | "feature-disabled"
-  | "invalid-input"
-  | "terminal-phase"
-  | "handoff-already-observed"
-  | "no-failure"
-  | "stale-verifier-evidence"
-  | "source-repair-eligible"
-  | "dependency-mutation-not-authorized"
-  | "read-only-task"
-  | "repair-ceiling-reached"
-  | "repeated-hypothesis"
-  | "operator-environment-action"
-  | "provider-transient-retry"
-  | "provider-retry-exhausted"
-  | "permission-expansion-forbidden"
-  | "scope-replan-required"
-  | "transient-verifier-retry"
-  | "transient-retry-unavailable"
-  | "unknown-diagnostic-pass"
-  | "unknown-diagnostic-exhausted"
-  | "global-continuation-budget-exhausted"
-  | "repeated-progress-signature"
-  | "continuation-journal-unavailable"
-  | "manual-lifecycle-handoff";
+export type RecoveryReasonCode = typeof RECOVERY_REASON_CODES[number];
 
 export type RecoveryHistoryEntry = {
   taskId: string;
@@ -68,6 +40,7 @@ export type RecoveryPolicyInput = {
   exactVerifierAvailable?: boolean;
   currentTreeMatchesEvidence?: boolean;
   dependencyMutationAuthorized?: boolean;
+  independentDisposition?: "cancelled" | "reconcile" | "unsupported" | "halt" | "approval";
 };
 
 export type RecoveryDecision = {
@@ -93,10 +66,20 @@ export type RecoveryDecision = {
   hypothesisRef: string | null;
 };
 
-const HASH = /^[a-f0-9]{64}$/;
 const REF = /^[a-z0-9][a-z0-9:._-]{0,255}$/i;
 const COUNTED_DISPOSITIONS = new Set<RecoveryDisposition>(["scheduled", "failed", "succeeded"]);
 
+export function applyProofCapabilityHandoff(selected: RecoveryDecision, missing: string[] = [], hasIndependentRecovery = false): RecoveryDecision {
+  let reason: RecoveryReasonCode | undefined;
+  if (selected.failureCategory === "unknown" && !hasIndependentRecovery && selected.action !== "blocked"
+    && missing.some(item => /^critical acceptance evidence independent-required\b/i.test(item))) reason = "independent-acceptance-proof-required";
+  else if (selected.failureCategory === "unknown" && !hasIndependentRecovery && selected.action !== "blocked"
+    && missing.some(item => /^critical acceptance evidence source-proof-required\b/i.test(item))) reason = "source-acceptance-proof-required";
+  else if (missing.some(item => /^critical acceptance evidence adapter-unresolved\b/i.test(item))) reason = "deterministic-adapter-proof-required";
+  return reason ? { ...selected, action: "handoff", continuation: "none", nextPhase: null,
+    sourceMutationAllowed: false, reasonCodes: [reason] } : selected;
+}
+
 function validIdentity(input: RecoveryPolicyInput): boolean {
   return Boolean(
     input.task?.taskId?.trim()
@@ -178,19 +161,27 @@ function repairDecision(input: RecoveryPolicyInput): RecoveryDecision {
 }
 
 export function selectRecoveryDecision(input: RecoveryPolicyInput): RecoveryDecision {
-  const invalidClassification = failureClassificationValidationErrors(input.classification).length > 0
-    || !HASH.test(String(input.classification?.evidenceDigest ?? ""));
+  const invalidClassification = failureClassificationValidationErrors(input.classification).length > 0;
   if (!validIdentity(input) || invalidClassification) return decision(input, "blocked", ["invalid-input"]);
   if (!input.featureEnabled) return decision(input, "handoff", ["feature-disabled"]);
   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 independentCategories = { cancelled: "unknown", reconcile: "environment", unsupported: "unknown", halt: "unknown", approval: "environment" };
+  if (input.independentDisposition !== undefined && (typeof input.independentDisposition !== "string"
+    || !Object.hasOwn(independentCategories, input.independentDisposition)
+    || independentCategories[input.independentDisposition] !== input.classification.category)) return decision(input, "blocked", ["invalid-input"]);
+  if (input.independentDisposition === "cancelled") return decision(input, "handoff", ["independent-execution-cancelled"]);
+  if (input.independentDisposition === "reconcile") return decision(input, "ask-operator", ["independent-execution-reconciliation-required"], { continuation: "operator" });
+  if (input.independentDisposition === "unsupported") return decision(input, "handoff", ["independent-verifier-unsupported"]);
+  if (input.independentDisposition === "halt") return decision(input, "handoff", ["independent-verification-halted"]);
+  if (input.independentDisposition === "approval") return decision(input, "ask-operator", ["operator-environment-action"], { continuation: "operator" });
 
   const counts = countsFor(input);
   if (input.currentTreeMatchesEvidence === false && input.exactVerifierAvailable === true) {

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

@@ -1,21 +1,30 @@
 import path from "node:path";
+import { currentWorkspaceRevisionDigest } from "../../extensions/workspace-revision.js";
 
 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";
 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 { handoffIdentityMatchesTask, 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 +162,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 +299,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
     }
   };
@@ -218,8 +313,10 @@ export function inspectTaskResumeState(
   options: { protectedPaths?: string[] } = {}
 ): ResumeState {
   const currentTreeDigest = workingTreeEvidenceDigest(currentDigests);
+  const workspaceRevisionDigest = currentWorkspaceRevisionDigest(cwd);
   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)
@@ -233,7 +330,7 @@ export function inspectTaskResumeState(
   try {
     const handoff = readHandoffProjection(cwd, task.taskRunId);
     handoffExists = Boolean(handoff);
-    if (handoff && (handoff.identity.taskId !== task.taskId || handoff.identity.taskRunId !== task.taskRunId)) {
+    if (handoff && !handoffIdentityMatchesTask(handoff.identity, task)) {
       handoffValid = false;
       warnings.push("handoff identity conflicts with the task contract");
     }
@@ -242,13 +339,14 @@ export function inspectTaskResumeState(
     warnings.push(`handoff projection is invalid: ${error instanceof Error ? error.message : String(error)}`);
   }
   const passingEvidence = task.verifyEvidence.filter((evidence) => evidence.observed === true && evidence.matchedProfileCommand === true && evidence.exitCode === 0);
-  const invalidatedVerifierCommands = strings(passingEvidence.filter((evidence) => !isCurrentWorkingTreeDigest(evidence.workingTreeDigest) || evidence.workingTreeDigest !== currentTreeDigest).map((evidence) => evidence.command), 50);
-  const verifierEvidenceCurrent = algorithmReady && !refreshRequired && (task.changeMode === "read-only" || allVerifyCommandsPassCurrentTree(task, currentTreeDigest));
+  const invalidatedVerifierCommands = strings(passingEvidence.filter((evidence) => !isCurrentWorkingTreeDigest(evidence.workingTreeDigest) || evidence.workingTreeDigest !== currentTreeDigest
+    || !workspaceRevisionDigest || evidence.preWorkspaceRevisionDigest !== workspaceRevisionDigest || evidence.workspaceRevisionDigest !== workspaceRevisionDigest).map((evidence) => evidence.command), 50);
+  const verifierEvidenceCurrent = algorithmReady && !refreshRequired && (task.changeMode === "read-only" || allVerifyCommandsPassCurrentTree(task, currentTreeDigest, workspaceRevisionDigest));
   const staleVerifierEvidence = refreshRequired || (invalidatedVerifierCommands.length > 0 && !verifierEvidenceCurrent);
   const invalidatedFiles = staleVerifierEvidence
     ? staleVerifierFiles(cwd, task, passingEvidence, currentDigests, currentTreeDigest, options.protectedPaths ?? null)
     : { files: [], known: true };
-  if (staleVerifierEvidence) warnings.push("working tree changed after the latest passing verifier; prior evidence is stale");
+  if (staleVerifierEvidence) warnings.push("working tree or workspace baseline changed, or the prior verifier lacks baseline binding; prior evidence is stale");
   const latest = journal.checkpoints.at(-1);
   const latestCheckpoint = latest ? {
     checkpointId: String(latest.checkpointId ?? "checkpoint"),
@@ -265,8 +363,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 +380,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/activity-inspector-command.ts

@@ -143,7 +143,8 @@ export function registerActivityInspector(pi: ExtensionAPI, dependencies: Inspec
       runtimeInstanceId: WEBUI_RUNTIME_INSTANCE_REF,
       eventCursor: events.currentCursor(),
       resyncRequired: events.resyncRequired(),
-      eventReplay: events.retention()
+      eventReplay: events.retention(),
+      operationLiveness: typeof ctx.isIdle === "function" ? ctx.isIdle() ? "idle" : "running" : "unknown"
     });
     cached.set(key, { at: Date.now(), view });
     return view;