@piagent/platform 1.6.1 → 1.7.1

package/packages/piagent-core/runtime/session/retrieval-evidence-runtime.ts

@@ -0,0 +1,188 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const RETRIEVAL_EVIDENCE_VERSION = "retrieval-evidence-v1" as const;
+export const RETRIEVAL_EVIDENCE_TOOLS = new Set(["read", "grep", "find", "ls"]);
+
+export type RetrievalEvidenceObservation = {
+  toolName: string;
+  callFingerprint: string;
+  outputHash: string;
+  target?: string;
+  deterministicMiss?: boolean;
+  nonEvidenceFailure?: boolean;
+};
+
+export type RetrievalEvidenceCheckpoint = {
+  version: typeof RETRIEVAL_EVIDENCE_VERSION;
+  reason: "evidence-checkpoint" | "evidence-saturated";
+  calls: number;
+  uniqueCalls: number;
+  repeatedCalls: number;
+  uniqueTargets: number;
+  deterministicMisses: number;
+  noNovelEvidenceStreak: number;
+  generation: number;
+  generationCalls: number;
+  text: string;
+};
+
+type RetrievalTurnState = {
+  turnId?: string;
+  calls: number;
+  repeatedCalls: number;
+  deterministicMisses: number;
+  noNovelEvidenceStreak: number;
+  generation: number;
+  generationCalls: number;
+  adviceCount: number;
+  lastAdviceAt: number;
+  // Operation-wide sets keep the accounting truthful across a mutation. The
+  // generation-local sets below decide whether a result is fresh for the
+  // current tree revision.
+  callFingerprints: Set<string>;
+  generationCallFingerprints: Set<string>;
+  outputHashes: Set<string>;
+  targets: Set<string>;
+  generationTargets: Set<string>;
+};
+
+function newState(generation = 0, turnId?: string): RetrievalTurnState {
+  return {
+    turnId,
+    calls: 0,
+    repeatedCalls: 0,
+    deterministicMisses: 0,
+    noNovelEvidenceStreak: 0,
+    generation,
+    generationCalls: 0,
+    adviceCount: 0,
+    lastAdviceAt: 0,
+    callFingerprints: new Set(),
+    generationCallFingerprints: new Set(),
+    outputHashes: new Set(),
+    targets: new Set(),
+    generationTargets: new Set()
+  };
+}
+
+function sessionKey(ctx: ExtensionContext): string {
+  return `${ctx.cwd}\u0000${ctx.sessionManager.getSessionId()}`;
+}
+
+function boundedTarget(value: string | undefined): string | undefined {
+  const normalized = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (!normalized) return undefined;
+  return normalized.length <= 512
+    ? normalized
+    : `${normalized.slice(0, 255)}…${normalized.slice(-256)}`;
+}
+
+function checkpointText(checkpoint: Omit<RetrievalEvidenceCheckpoint, "text">): string {
+  const prefix = checkpoint.reason === "evidence-saturated"
+    ? "Piagent retrieval saturation"
+    : "Piagent retrieval checkpoint";
+  return `[${prefix}: ${checkpoint.calls} calls; ${checkpoint.uniqueCalls} unique; ${checkpoint.repeatedCalls} repeated; ${checkpoint.deterministicMisses} deterministic misses; ${checkpoint.uniqueTargets} targets. `
+    + "If the acceptance criteria are covered, stop broad scouting and synthesize now. Continue only for a named unresolved criterion, a concrete contradiction, or a required focused test. Do not repeat an exact call, revisit a known-missing target, or batch patterns against an unconfirmed target.]";
+}
+
+/**
+ * Tracks evidence novelty for one operator operation. It never blocks a new
+ * source path: the model keeps its full reasoning/retrieval capability. The
+ * runtime only emits bounded checkpoints when search becomes long or stops
+ * producing new evidence.
+ */
+export class RetrievalEvidenceRuntime {
+  readonly #states = new Map<string, RetrievalTurnState>();
+
+  beginTurn(ctx: ExtensionContext, turnId?: string): void {
+    const key = sessionKey(ctx);
+    this.#states.set(key, newState(0, turnId));
+    while (this.#states.size > 100) this.#states.delete(this.#states.keys().next().value as string);
+  }
+
+  invalidateAfterMutation(ctx: ExtensionContext, turnId?: string): void {
+    const key = sessionKey(ctx);
+    const current = this.#states.get(key);
+    const prior = current && (!turnId || !current.turnId || current.turnId === turnId)
+      ? current
+      : newState(0, turnId);
+    if (turnId && !prior.turnId) prior.turnId = turnId;
+    // Keep the operation totals so a mutation cannot erase token accounting,
+    // but clear novelty/negative evidence because the working tree changed.
+    prior.generation += 1;
+    prior.generationCalls = 0;
+    prior.noNovelEvidenceStreak = 0;
+    prior.adviceCount = 0;
+    prior.lastAdviceAt = 0;
+    prior.generationCallFingerprints.clear();
+    prior.outputHashes.clear();
+    prior.generationTargets.clear();
+    this.#states.set(key, prior);
+  }
+
+  clearSession(ctx: ExtensionContext): void {
+    this.#states.delete(sessionKey(ctx));
+  }
+
+  observe(
+    ctx: ExtensionContext,
+    observation: RetrievalEvidenceObservation,
+    turnId?: string
+  ): RetrievalEvidenceCheckpoint | undefined {
+    const toolName = String(observation.toolName ?? "").toLowerCase();
+    if (!RETRIEVAL_EVIDENCE_TOOLS.has(toolName)) return undefined;
+    const key = sessionKey(ctx);
+    const current = this.#states.get(key);
+    const state = current && (!turnId || !current.turnId || current.turnId === turnId)
+      ? current
+      : newState(0, turnId);
+    if (turnId && !state.turnId) state.turnId = turnId;
+    this.#states.set(key, state);
+
+    state.calls += 1;
+    state.generationCalls += 1;
+    const target = boundedTarget(observation.target);
+    const repeatedAcrossOperation = state.callFingerprints.has(observation.callFingerprint);
+    const repeatedCall = state.generationCallFingerprints.has(observation.callFingerprint);
+    const repeatedOutput = Boolean(observation.outputHash) && state.outputHashes.has(observation.outputHash);
+    const knownTarget = target ? state.generationTargets.has(target) : false;
+    if (repeatedAcrossOperation) state.repeatedCalls += 1;
+    if (observation.deterministicMiss) state.deterministicMisses += 1;
+
+    const novel = !observation.nonEvidenceFailure
+      && !repeatedCall
+      && !observation.deterministicMiss
+      && (!repeatedOutput || !knownTarget);
+    state.noNovelEvidenceStreak = novel ? 0 : state.noNovelEvidenceStreak + 1;
+    state.callFingerprints.add(observation.callFingerprint);
+    state.generationCallFingerprints.add(observation.callFingerprint);
+    if (observation.outputHash) state.outputHashes.add(observation.outputHash);
+    if (target) {
+      state.targets.add(target);
+      state.generationTargets.add(target);
+    }
+
+    const saturated = state.noNovelEvidenceStreak >= 4;
+    const periodic = state.generationCalls >= 32 && state.generationCalls % 32 === 0;
+    const enoughDistance = state.adviceCount === 0
+      ? state.generationCalls >= 4
+      : state.generationCalls - state.lastAdviceAt >= 8;
+    if (state.adviceCount >= 4 || !enoughDistance || (!saturated && !periodic)) return undefined;
+
+    state.adviceCount += 1;
+    state.lastAdviceAt = state.generationCalls;
+    const checkpoint = {
+      version: RETRIEVAL_EVIDENCE_VERSION,
+      reason: saturated ? "evidence-saturated" as const : "evidence-checkpoint" as const,
+      calls: state.calls,
+      uniqueCalls: state.callFingerprints.size,
+      repeatedCalls: state.repeatedCalls,
+      uniqueTargets: state.targets.size,
+      deterministicMisses: state.deterministicMisses,
+      noNovelEvidenceStreak: state.noNovelEvidenceStreak,
+      generation: state.generation,
+      generationCalls: state.generationCalls
+    };
+    return { ...checkpoint, text: checkpointText(checkpoint) };
+  }
+}

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

@@ -1,8 +1,11 @@
 import crypto from "node:crypto";
+export { createHostWireSession, observeHostWireInput, HOST_WIRE_PHASE_EDGES } from "../trajectory/trajectory-runtime.ts";
+export type { HostWireSession, HostWireSessionOptions, HostWireOperation } from "../trajectory/trajectory-runtime.ts";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isRuntimeOwnedContextEvidenceEntry } from "../../extensions/context-evidence.js";
 import { toolResultFingerprint } from "../../extensions/context-engine.js";
-import { workingTreeSnapshot } from "../../extensions/task-state.js";
+import { ShellVerificationSnapshots } from "../verification/shell-verification-snapshots.ts";
+import { HostProjectVerification } from "../verification/host-project-verification.ts";
 import type { TaskContract } from "../../extensions/guard-types.ts";
 import type { RecoveryHistoryEntry } from "../recovery/recovery-policy.ts";
 import type { ResumeState } from "../recovery/resume-state.ts";
@@ -65,7 +68,7 @@ export type PendingContextDelivery = {
   pack?: InjectedContextPack & { retrievalKey: string };
   injection?: ContextInjectionTelemetry;
 };
-export type RuntimeTurn = { turnId: string; promptHash: string };
+export type RuntimeTurn = { turnId: string; promptHash: string; lightweightNonAuthorizingChange: boolean };
 
 function evictOldest<K, V>(map: Map<K, V>, maximum: number): void {
   while (map.size > maximum) map.delete(map.keys().next().value as K);
@@ -88,16 +91,13 @@ export class RuntimeSessionState {
   readonly #observedContextBySession = new Map<string, Map<string, ObservedTaskContext>>();
   readonly #preTaskContextBySession = new Map<string, { turnId: string; entries: Map<string, ObservedTaskContext> }>();
   readonly #qualifiedContextEvidenceByTask = new Map<string, Map<string, ObservedTaskContext>>();
-  readonly #shellMutationSnapshots = new Map<string, Record<string, string>>();
+  readonly #shellMutationSnapshots = new ShellVerificationSnapshots();
+  readonly projectVerification = new HostProjectVerification(this.#shellMutationSnapshots);
   readonly #sourceCheckoutReadGrants = new SourceCheckoutReadGrants();
 
-  constructor(options: { maxObservedContext: number }) {
-    this.#maxObservedContext = options.maxObservedContext;
-  }
+  constructor(options: { maxObservedContext: number }) { this.#maxObservedContext = options.maxObservedContext; }
 
-  sessionKey(ctx: ExtensionContext): string {
-    return `${ctx.cwd}\u0000${ctx.sessionManager.getSessionId()}`;
-  }
+  sessionKey(ctx: ExtensionContext): string { return `${ctx.cwd}\u0000${ctx.sessionManager.getSessionId()}`; }
 
   cacheTaskIdentity(ctx: ExtensionContext, task: TaskContract | undefined): void {
     const key = this.sessionKey(ctx);
@@ -107,11 +107,10 @@ export class RuntimeSessionState {
   }
 
   taskIdentity(ctx: ExtensionContext): { taskId: string; taskRunId: string } | undefined {
-    return this.#taskIdentityBySession.get(this.sessionKey(ctx));
-  }
+    return this.#taskIdentityBySession.get(this.sessionKey(ctx)); }
 
-  beginTurn(ctx: ExtensionContext, promptHash: string): RuntimeTurn {
-    const turn = { turnId: crypto.randomUUID(), promptHash };
+  beginTurn(ctx: ExtensionContext, promptHash: string, classification: { lightweightNonAuthorizingChange?: boolean } = {}): RuntimeTurn {
+    const turn = { turnId: crypto.randomUUID(), promptHash, lightweightNonAuthorizingChange: classification.lightweightNonAuthorizingChange === true };
     const sessionKey = this.sessionKey(ctx);
     this.#turnBySession.set(sessionKey, turn);
     this.#preTaskContextBySession.set(sessionKey, { turnId: turn.turnId, entries: new Map() });
@@ -125,10 +124,16 @@ export class RuntimeSessionState {
     return turn && (!promptHash || turn.promptHash === promptHash) ? { ...turn } : undefined;
   }
 
-  hasAdvisedTool(ctx: ExtensionContext, toolName: string): boolean {
-    return this.#advisedTools.has(`${this.sessionKey(ctx)}\u0000${toolName}`);
+  classifyTurn(ctx: ExtensionContext, promptHash: string, classification: { lightweightNonAuthorizingChange: boolean }): RuntimeTurn {
+    const turn = this.currentTurn(ctx, promptHash);
+    if (!turn) return this.beginTurn(ctx, promptHash, classification);
+    turn.lightweightNonAuthorizingChange = classification.lightweightNonAuthorizingChange;
+    this.#turnBySession.set(this.sessionKey(ctx), turn); return { ...turn };
   }
 
+  hasAdvisedTool(ctx: ExtensionContext, toolName: string): boolean {
+    return this.#advisedTools.has(`${this.sessionKey(ctx)}\u0000${toolName}`); }
+
   rememberAdvisedTool(ctx: ExtensionContext, toolName: string): void {
     this.#advisedTools.add(`${this.sessionKey(ctx)}\u0000${toolName}`);
     while (this.#advisedTools.size > 500) {
@@ -156,9 +161,7 @@ export class RuntimeSessionState {
     return this.#sourceCheckoutReadGrants.grant(this.sessionKey(ctx), checkoutPath);
   }
 
-  sourceCheckoutReadRoots(ctx: ExtensionContext): string[] {
-    return this.#sourceCheckoutReadGrants.roots(this.sessionKey(ctx));
-  }
+  sourceCheckoutReadRoots(ctx: ExtensionContext): string[] { return this.#sourceCheckoutReadGrants.roots(this.sessionKey(ctx)); }
 
   rememberPreTaskContext(ctx: ExtensionContext, entry: ObservedTaskContext): void {
     const turn = this.currentTurn(ctx);
@@ -222,30 +225,21 @@ export class RuntimeSessionState {
     return [...(this.#qualifiedContextEvidenceByTask.get(key)?.values() ?? [])].map((entry) => structuredClone(entry));
   }
 
-  #shellMutationSnapshotKey(ctx: ExtensionContext, toolName: string, input: unknown): string {
-    return `${this.sessionKey(ctx)}\u0000${toolResultFingerprint(toolName, input, []).key}`;
+  rememberShellMutationSnapshot(ctx: ExtensionContext, toolName: string, input: unknown, toolCallId?: string): void {
+    this.#shellMutationSnapshots.remember(ctx, toolName, input, toolCallId, this.taskIdentity(ctx)?.taskRunId);
   }
 
-  rememberShellMutationSnapshot(ctx: ExtensionContext, toolName: string, input: unknown): void {
-    this.#shellMutationSnapshots.set(
-      this.#shellMutationSnapshotKey(ctx, toolName, input),
-      workingTreeSnapshot(ctx.cwd) as Record<string, string>
-    );
-    evictOldest(this.#shellMutationSnapshots, 100);
+  consumeShellMutationSnapshot(ctx: ExtensionContext, toolName: string, input: unknown): Record<string, string> | undefined {
+    return this.consumeShellVerificationSnapshot(ctx, toolName, input)?.snapshot as Record<string, string> | undefined;
   }
 
-  consumeShellMutationSnapshot(ctx: ExtensionContext, toolName: string, input: unknown): Record<string, string> | undefined {
-    const key = this.#shellMutationSnapshotKey(ctx, toolName, input);
-    const snapshot = this.#shellMutationSnapshots.get(key);
-    this.#shellMutationSnapshots.delete(key);
-    return snapshot;
+  consumeShellVerificationSnapshot(ctx: ExtensionContext, toolName: string, input: unknown, toolCallId?: string) {
+    return this.#shellMutationSnapshots.consume(ctx, toolName, input, toolCallId, this.taskIdentity(ctx)?.taskRunId);
   }
 
   clearShellMutationSnapshots(ctx: ExtensionContext): void {
-    const prefix = `${this.sessionKey(ctx)}\u0000`;
-    for (const key of this.#shellMutationSnapshots.keys()) {
-      if (key.startsWith(prefix)) this.#shellMutationSnapshots.delete(key);
-    }
+    this.#shellMutationSnapshots.clear(ctx);
+    this.projectVerification.clear(ctx);
   }
 
   hasAutoPackedPrompt(key: string): boolean {

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

@@ -12,8 +12,8 @@ const RUNTIME_MANAGED_PROJECT_INSTRUCTIONS = [
   "Piagent runtime-managed task flow:",
   "1. Runtime creates the task contract automatically for a bounded source-changing request before the model starts.",
   "2. Only when runtime intake pauses for a broad, high-risk, or ambiguous task, call `piagent_task_start` exactly once with project-relative focus paths/globs; reuse an active contract.",
-  "3. Use complete runtime-delivered source directly; do not reread it normally. On edit drift/oldText mismatch, use attached recovery; otherwise reread the affected region once. Never retry guessed anchors. Otherwise read only missing source or a concrete criterion-linked focused test. Task scope seeds retrieval and review; it does not limit source mutation. Follow repository evidence across packages or child repos while preserving explicit user constraints. When creating an explicitly requested new path, do not probe that destination with read first; create it, then read back or verify it. If existence matters, use a non-erroring existence check.",
-  "4. Preserve every runtime-provided verifier exactly and keep commands separate. Run the exact verifier set once on the final tree; rerun only after a later mutation, an explicit operator request, or a runtime-authorized same-tree infrastructure retry. Before any repeat, use piagent_task_gate_check and run only commands reported missing for the current tree; Piagent reuses a durable exact pass on an unchanged tree. Automatic tasks need no other management calls.",
+  "3. Use complete runtime-delivered source directly; do not reread it normally. When the operator names an exact file, work from its delivered/current contents instead of listing or searching merely to rediscover it. Once exact current context is known for a coherent source-and-test or other multi-file change, prefer one apply_patch call over serial edit/write calls. On edit drift/oldText mismatch, use attached recovery; otherwise reread the affected region once. Never retry guessed anchors or batch multiple pattern calls against an unconfirmed target; confirm it once first. Otherwise read only missing source or a concrete criterion-linked focused test. Task scope seeds retrieval and review; it does not limit source mutation. Follow repository evidence across packages or child repos while preserving explicit user constraints. Report only paths and line references actually returned by tools; label inferences and unknowns, and never reread solely to format a citation. When creating an explicitly requested new path, do not probe that destination with read first; create it, then read back or verify it. If existence matters, use a non-erroring existence check.",
+  "4. Preserve every runtime-provided verifier exactly and keep commands separate. When you change source, add or update the smallest focused executable tests that directly exercise every explicit behavior, boundary, and error criterion unless current delivered tests already do; a broad verifier pass without criterion coverage is not completion evidence for that change. Run the exact verifier set once on the final tree; rerun only after a later mutation, an explicit operator request, or a runtime-authorized same-tree infrastructure retry. Do not warm up with an unfocused command already contained in that exact set; use a genuinely criterion-focused test or run the exact set directly. Before any repeat, use piagent_task_gate_check and run only commands reported missing for the current tree; Piagent reuses a durable exact pass on an unchanged tree. Automatic tasks need no other management calls.",
   "5. Treat the current source, the operator request, and the durable Task Contract as authoritative. The parent model reasons and implements directly. Helpers are off unless explicitly enabled; even then, allow at most one fresh read-only helper only when runtime evidence proves two independent lanes and at least 30% projected net token saving. Never delegate writes, inherit parent history, fan out, or retry a deterministic helper failure. Preserve explicit user constraints and report unresolved risk. Runtime-derived scope is only the initial focus and may expand when implementation evidence requires FE, BE, tests, configuration, or another child repo. Runtime hooks enforce protected paths and approvals and record context, changes, current-tree verification, trace and final gate. Diagnostic groups appear only for explicit requests or manual high-risk checkpoints."
 ].join("\n");
 
@@ -48,7 +48,7 @@ export function compactManagedProjectInstructions(
 ): { systemPrompt: string; compacted: boolean } {
   const concise = mode === "protected"
     ? "Piagent protected-path policy: do not read, disclose, or mutate protected content. Refuse without tool calls."
-    : "Piagent runtime task is injected below. Root project instructions are already loaded; do not re-read root AGENTS.md. Treat current source, the operator request, and the durable Task Contract as authoritative; preserve explicit user constraints and report unresolved risk. The parent reasons and implements directly. Helpers are opt-in and limited to one fresh read-only helper only with two independent lanes and at least 30% projected net token saving; never delegate writes, inherit parent history, fan out, or retry a deterministic helper failure. Runtime-derived scope is an initial retrieval/review focus, not a mutation boundary; follow repository evidence across packages and child repos. Use complete runtime-delivered source directly without rereading it normally. On edit drift/oldText mismatch, use attached recovery; otherwise reread the affected region once. Never retry guessed anchors. Otherwise read only missing source or a concrete criterion-linked focused test. For an explicitly requested new path, create it without a speculative read, then read back or verify it. Preserve every runtime verifier exactly and keep commands separate. Run the exact verifier set once on the final tree; rerun only after a later mutation or a runtime-authorized same-tree infrastructure retry. Make no task-management calls.";
+    : "Piagent runtime task is injected below. Root project instructions are already loaded; do not re-read root AGENTS.md. Treat current source, the operator request, and the durable Task Contract as authoritative; preserve explicit user constraints and report unresolved risk. The parent reasons and implements directly. Helpers are opt-in and limited to one fresh read-only helper only with two independent lanes and at least 30% projected net token saving; never delegate writes, inherit parent history, fan out, or retry a deterministic helper failure. Runtime-derived scope is an initial retrieval/review focus, not a mutation boundary; follow repository evidence across packages and child repos. Use complete runtime-delivered source directly without rereading it normally. For an exact operator-named file, use delivered/current contents instead of listing or searching merely to rediscover it. Once exact current context is known for a coherent source-and-test or other multi-file change, prefer one apply_patch call over serial edit/write calls. On edit drift/oldText mismatch, use attached recovery; otherwise reread the affected region once. Never retry guessed anchors or batch pattern calls against an unconfirmed target; confirm it once first. Otherwise read only missing source or a concrete criterion-linked focused test. When source is changed, add or update the smallest focused executable tests for every explicit behavior, boundary, and error criterion unless delivered tests already cover them; a broad verifier pass alone is not completion evidence for that change. Report only tool-observed paths and line references; label inferences and unknowns, and never reread solely to format a citation. For an explicitly requested new path, create it without a speculative read, then read back or verify it. Preserve every runtime verifier exactly and keep commands separate. Run the exact verifier set once on the final tree. Do not warm up with an unfocused command already contained in that exact set; rerun only after a later mutation or a runtime-authorized same-tree infrastructure retry. Make no task-management calls.";
   const markerStart = "<!-- piagent-managed:start -->";
   const markerEnd = "<!-- piagent-managed:end -->";
   const start = systemPrompt.indexOf(markerStart);

package/packages/piagent-core/runtime/session/uncertain-send-continuation.ts

@@ -0,0 +1,231 @@
+import { captureWorkspaceVerificationSnapshot } from "../../extensions/workspace-verification-snapshot.js";
+import { diagnosticDeliveryMatchesTask, type DiagnosticDelivery } from "../recovery/diagnostic-delivery.ts";
+import type { TaskContract } from "../../extensions/guard-types.js";
+import {
+  handoffIdentityMatchesTask,
+  readHandoffProjection,
+  taskAcceptanceDisposition,
+  type HandoffProjection
+} from "../recovery/handoff-projection.ts";
+
+export const UNCERTAIN_SEND_RECEIPT_TYPE = "piagent-uncertain-send-continuation-v1";
+
+function folded(value: unknown): string {
+  return String(value ?? "")
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/đ/g, "d")
+    .replace(/Đ/g, "D")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * Identify the narrow uncertain-delivery recovery protocol. Generic requests
+ * such as "continue" or "check the previous work" intentionally do not match:
+ * they remain free to start a different task in the same session.
+ */
+export function isUncertainSendContinuation(value: unknown): boolean {
+  const text = folded(value);
+  if (!text) return false;
+  const switchesWork = /\b(?:new|different|separate|unrelated)\s+(?:request|task|work)\b/.test(text)
+    || /\b(?:task|yeu cau|cong viec|viec)\s+moi\b/.test(text);
+  if (switchesWork) return false;
+  const interrupted = /\b(?:connection|delivery|send|session)\b.{0,100}\b(?:interrupted|disconnected|dropped|lost|uncertain)\b/.test(text)
+    || /\bket noi\b.{0,100}\b(?:gian doan|bi ngat|bi mat)\b/.test(text);
+  const mayHaveArrived = /\b(?:previous|prior|last)\s+(?:send|message|request)\b.{0,100}\b(?:may|might|could)\s+have\s+been\s+(?:delivered|sent|received)\b/.test(text)
+    || /\b(?:delivery|send|receipt)\b.{0,100}\b(?:unknown|uncertain|unconfirmed)\b/.test(text)
+    || /\b(?:tin nhan|yeu cau|lan gui)\s+(?:truoc|vua roi)\b.{0,100}\bco the\b.{0,60}\b(?:da gui|da nhan|duoc gui)\b/.test(text);
+  const sameRequest = /\bcontinue\b.{0,100}\b(?:same|original|previous|prior)\s+(?:request|task|work)\b/.test(text)
+    || /\bdurable\s+session\s+state\b/.test(text)
+    || /\bwithout\s+duplicating\b/.test(text)
+    || /\btiep tuc\b.{0,100}\b(?:cung|yeu cau|task|cong viec)\b/.test(text)
+    || /\bkhong\s+(?:lap lai|trung lap)\b/.test(text);
+  return interrupted && mayHaveArrived && sameRequest;
+}
+
+function bounded(values: unknown, maximum = 8): string[] {
+  return [...new Set((Array.isArray(values) ? values : [])
+    .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+    .map((value) => value.trim()))]
+    .slice(0, maximum);
+}
+
+export type TerminalUncertainSendReceipt = {
+  customType: typeof UNCERTAIN_SEND_RECEIPT_TYPE;
+  content: string;
+  details: {
+    schemaVersion: 1;
+    version: typeof UNCERTAIN_SEND_RECEIPT_TYPE;
+    state: "settled";
+    taskId: string;
+    taskRunId: string;
+    outcome: TaskContract["trace"]["outcome"];
+    gateDecision: "pass" | "fail";
+    completionApproved: boolean;
+    diagnosticDelivery?: DiagnosticDelivery;
+    changedFiles: string[];
+    missing: string[];
+    nextSafeAction: string;
+    replayed: false;
+    modelTurnStarted: false;
+  };
+};
+
+export type TerminalUncertainSendBinding = {
+  task: TaskContract;
+  text: string;
+  receipt?: TerminalUncertainSendReceipt;
+};
+
+export type UncertainSendRuntimeIntake = {
+  intake: {
+    started: false;
+    text: string;
+    task?: TaskContract;
+    plannedContext: [];
+    plannedContextComplete: true;
+    continuation: "terminal-uncertain-send";
+  };
+  trace: Record<string, unknown>;
+  task?: TaskContract;
+};
+
+type HandoffReader = (cwd: string, taskRunId: string) => HandoffProjection | undefined;
+
+/**
+ * Project a privacy-safe terminal receipt from the immediately prior durable
+ * task. Missing/corrupt/mismatched handoff state returns undefined so callers
+ * can fail closed without claiming that delivery or completion was observed.
+ */
+export function terminalUncertainSendReceipt(
+  cwd: string,
+  task: TaskContract | undefined,
+  readHandoff: HandoffReader = readHandoffProjection
+): TerminalUncertainSendReceipt | undefined {
+  if (!task || task.trace.outcome === "pending") return undefined;
+  let handoff;
+  try {
+    handoff = readHandoff(cwd, task.taskRunId);
+  } catch {
+    return undefined;
+  }
+  if (!handoff
+    || !handoffIdentityMatchesTask(handoff.identity, task)
+    || handoff.state.taskOutcome !== task.trace.outcome) return undefined;
+  if (handoff.state.completionApproved === true || handoff.state.diagnosticDelivery) {
+    const authoritativeAcceptance = taskAcceptanceDisposition(task);
+    if (handoff.acceptance.required !== authoritativeAcceptance.required
+      || handoff.acceptance.satisfied !== authoritativeAcceptance.satisfied
+      || handoff.acceptance.criteriaCount !== authoritativeAcceptance.criteriaCount
+      || handoff.acceptance.dispositionDigest !== authoritativeAcceptance.dispositionDigest) return undefined;
+  }
+  const diagnosticDelivery = handoff.state.diagnosticDelivery;
+  if (diagnosticDelivery && !diagnosticDeliveryMatchesTask(diagnosticDelivery, task, taskAcceptanceDisposition(task).dispositionDigest)) return undefined;
+  if (diagnosticDelivery) {
+    try {
+      const current = captureWorkspaceVerificationSnapshot(cwd);
+      if (!current.proofCapable || current.digest !== handoff.tree.currentDigest
+        || current.workspaceRevisionDigest !== handoff.tree.workspaceRevisionDigest) return undefined;
+    } catch { return undefined; }
+  }
+  const changedFiles = bounded(handoff.changedFiles.current, 12);
+  const missing = bounded(handoff.state.missing, 12);
+  const approved = handoff.state.completionApproved === true;
+  const lines = [
+    "[Piagent delivery receipt]",
+    `The immediately preceding task already settled as ${handoff.state.taskOutcome}; its durable contract was reused and no command, mutation, message, or model turn was replayed.`,
+    `Completion approved: ${approved ? "yes" : "no"}. Gate: ${handoff.state.gateDecision}.`,
+    ...(diagnosticDelivery ? ["Diagnostic delivery only: unproved criteria remain pending; no quality claim."] : []),
+    ...(changedFiles.length > 0 ? [`Changed files: ${changedFiles.join(", ")}.`] : []),
+    ...(missing.length > 0 ? [`Still missing: ${missing.join("; ")}.`] : []),
+    `Next safe action: ${handoff.nextSafeAction.action}.`
+  ];
+  return {
+    customType: UNCERTAIN_SEND_RECEIPT_TYPE,
+    content: lines.join("\n"),
+    details: {
+      schemaVersion: 1,
+      version: UNCERTAIN_SEND_RECEIPT_TYPE,
+      state: "settled",
+      taskId: task.taskId,
+      taskRunId: task.taskRunId,
+      outcome: task.trace.outcome,
+      gateDecision: handoff.state.gateDecision,
+      completionApproved: approved,
+      ...(diagnosticDelivery ? { diagnosticDelivery } : {}),
+      changedFiles,
+      missing,
+      nextSafeAction: handoff.nextSafeAction.action,
+      replayed: false,
+      modelTurnStarted: false
+    }
+  };
+}
+
+export function unavailableUncertainSendContext(task?: TaskContract): string {
+  const identity = task
+    ? `durable task ${task.taskId} (${task.taskRunId})`
+    : "the immediately preceding durable task";
+  return [
+    "[Piagent uncertain-send continuation]",
+    `Reuse ${identity}; do not create a replacement task or repeat prior mutations/messages.`,
+    "Its terminal handoff receipt is missing, corrupt, or identity-mismatched, so completion must not be inferred.",
+    "Report that the durable receipt is unavailable and require state inspection or an explicit new request before any further mutation."
+  ].join("\n");
+}
+
+/**
+ * Bind a synthetic reconnect continuation to the terminal task already bound
+ * to this durable session. This decision is intentionally separate from
+ * generic task intake so a receipt recovery cannot become a new read-only
+ * task merely because the previous operation settled before the client saw it.
+ */
+export function terminalUncertainSendBinding(
+  cwd: string,
+  task: TaskContract | undefined,
+  prompt: unknown,
+  readHandoff: HandoffReader = readHandoffProjection
+): TerminalUncertainSendBinding | undefined {
+  if (!task || task.trace.outcome === "pending" || !isUncertainSendContinuation(prompt)) return undefined;
+  const receipt = terminalUncertainSendReceipt(cwd, task, readHandoff);
+  return {
+    task,
+    text: receipt
+      ? `${receipt.content}\nRecovery-turn rule: return only this durable receipt; do not call tools, repeat work, or start another task.`
+      : unavailableUncertainSendContext(task),
+    receipt
+  };
+}
+
+export function uncertainSendRuntimeIntake(
+  cwd: string,
+  task: TaskContract | undefined,
+  prompt: unknown,
+  sessionId: string
+): UncertainSendRuntimeIntake | undefined {
+  if (!isUncertainSendContinuation(prompt) || task?.trace.outcome === "pending") return undefined;
+  const binding = terminalUncertainSendBinding(cwd, task, prompt);
+  return {
+    intake: {
+      started: false,
+      task: binding?.task,
+      text: binding?.text ?? unavailableUncertainSendContext(),
+      plannedContext: [],
+      plannedContextComplete: true,
+      continuation: "terminal-uncertain-send"
+    },
+    trace: {
+      event: binding ? "uncertain_send_terminal_task_bound" : "uncertain_send_task_binding_unavailable",
+      taskId: binding?.task.taskId,
+      taskRunId: binding?.task.taskRunId,
+      sessionId,
+      receiptAvailable: Boolean(binding?.receipt),
+      replacementTaskStarted: false,
+      replayed: false,
+      modelTurnStarted: true
+    },
+    task: binding?.task
+  };
+}

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

@@ -6,6 +6,7 @@ import {
   CONTEXT_WATCH_PERCENT,
   LONG_INPUT_CHARS
 } from "../runtime-limits.ts";
+import type { WorkflowId } from "../workflows/webui-workflow.ts";
 import { modelLabel } from "./message-signals.ts";
 
 export type UsageSnapshot = {
@@ -32,7 +33,7 @@ export type UsageSnapshot = {
 };
 
 export type ContextPreflight = {
-  workflow: string;
+  workflow: WorkflowId;
   inputChars: number;
   inputTokenEstimate: number;
   liveContext?: UsageSnapshot["contextUsage"];
@@ -107,7 +108,7 @@ function estimateTokensFromChars(chars: number): number {
   return Math.max(0, Math.ceil(chars / 4));
 }
 
-export function buildContextPreflight(snapshot: UsageSnapshot, workflow = "task", inputChars = 0): ContextPreflight {
+export function buildContextPreflight(snapshot: UsageSnapshot, workflow: WorkflowId = "task", inputChars = 0): ContextPreflight {
   const inputTokenEstimate = estimateTokensFromChars(inputChars);
   const live = snapshot.contextUsage;
   let projectedContext: ContextPreflight["projectedContext"];
@@ -151,7 +152,7 @@ export function buildContextPreflight(snapshot: UsageSnapshot, workflow = "task"
     commands: [
       "/task-preflight",
       "/task-preflight compact",
-      `/fresh ${workflow === "be-to-fe" ? "be-to-fe" : workflow === "scout" ? "scout" : "task"} <request>`,
+      `/fresh ${workflow} <request>`,
       "/usage",
       "/session"
     ]

package/packages/piagent-core/runtime/tools/apply-patch-tool.ts

@@ -162,9 +162,9 @@ function parseUpdateHunks(section: string[], repoPath: string): UpdateHunk[] {
       if (line[0] !== "-") newLines.push(line.slice(1));
       if (line[0] === "+" || line[0] === "-") changed = true;
     }
-    if (!bodyLines || !changed || oldLines.length === 0) {
-      fail("malformed-hunk", `Hunk must contain a change with stable old-side context: ${repoPath}`);
-    }
+    if (!bodyLines) fail("malformed-hunk", `Hunk body is empty: ${repoPath}. Put @@ on its own line, then add body lines prefixed by space, +, or -; no file was changed.`);
+    if (!changed) fail("malformed-hunk", `Hunk contains no change line: ${repoPath}. Include at least one + or - body line in addition to any exact unchanged context; no file was changed.`);
+    if (oldLines.length === 0) fail("malformed-hunk", `Hunk must contain a change and at least one exact old-side line: ${repoPath}. A plus-only Update File hunk is invalid; for an insertion or append, place an adjacent existing anchor line (prefixed by one space) before or after the new + lines according to the intended position. Keep @@ on its own line and put removed lines on separate - lines; no file was changed.`);
     hunks.push({ oldLines, newLines });
   }
   if (!hunkCount) fail("malformed-hunk", `Update contains no hunks: ${repoPath}`);
@@ -481,10 +481,10 @@ export function registerApplyPatchTool(
     name: "apply_patch",
     label: "Apply Patch",
     description: "Apply one validated OpenAI-style patch across multiple project files in a single guarded tool call.",
-    promptSnippet: "Use apply_patch for bounded multi-file Add File and Update File changes when exact old context is available.",
+    promptSnippet: "Prefer one coherent apply_patch call for a bounded source-and-test or other multi-file change only when exact old context for every target is available. Update hunks require an exact old-side anchor; plus-only insertions are invalid. Otherwise use one bounded writer per file.",
     promptGuidelines: [
-      "Wrap the patch in exact *** Begin Patch and *** End Patch delimiters.",
-      "Use each project-relative target once and include enough unchanged context for every update hunk to match exactly once."
+      "The patch value must contain only the raw patch: its first line is exactly *** Begin Patch, its last line is exactly *** End Patch, and no prose, JSON, code fence, or other content may appear before or after those delimiters. For each *** Update File hunk, put @@ on its own line. Put every old, new, or unchanged body line below it with a leading -, +, or space; never write @@ -old or @@ +new.",
+      "Use each project-relative target once. Every Update File hunk must include at least one exact old-side line prefixed by space or -; for append/insert, put an adjacent existing space-prefixed anchor before or after the + lines to preserve the intended position. Include enough context to match exactly once."
     ],
     parameters: Type.Object({ patch: Type.String({ minLength: 1, maxLength: MAX_PATCH_BYTES }) }, { additionalProperties: false }),
     executionMode: "sequential",

package/packages/piagent-core/runtime/tools/phase-tool-runtime.ts

@@ -12,7 +12,7 @@ export type PhaseMutationInput = {
   verificationCarrier?: boolean;
 };
 
-const MANAGED_HOST_TOOL_ORDER = Object.freeze(["read", "grep", "find", "ls", "edit", "write", "apply_patch", "bash", "shell", "exec"]);
+const MANAGED_HOST_TOOL_ORDER = Object.freeze(["read", "grep", "find", "ls", "apply_patch", "edit", "write", "bash", "shell", "exec"]);
 
 function phaseHostToolName(toolName: string): string {
   return toolName === "shell" || toolName === "exec" ? "bash" : toolName;