@piagent/platform 1.6.1 → 1.8.0

package/packages/piagent-core/runtime/hooks/session-start-hook.ts

@@ -31,6 +31,20 @@ import type { ResumeState } from "../recovery/resume-state.ts";
 
 type SessionTaskReference = { taskId?: string; taskRunId?: string };
 
+type SessionStartIdentity = { cwd: string; sessionId: string };
+
+function sessionContextMatches(ctx: ExtensionContext, identity: SessionStartIdentity): boolean {
+  try {
+    return ctx.cwd === identity.cwd && ctx.sessionManager.getSessionId() === identity.sessionId;
+  } catch {
+    // Pi invalidates every session-bound ctx getter after a replacement or
+    // reload. A stale startup hook belongs to the outgoing runtime; the new
+    // runtime receives its own session_start event and must be the only one to
+    // publish startup telemetry or bind post-start surfaces.
+    return false;
+  }
+}
+
 type SessionStartHookDependencies = {
   state: RuntimeSessionState;
   loadProfile: (ctx: ExtensionContext) => ProjectProfile;
@@ -66,6 +80,7 @@ export function registerSessionStartHook(pi: ExtensionAPI, dependencies: Session
     if (!hasOperatorSessionName(operatorSessionName)) pi.setSessionName(`pi:${name}`);
 
     const sessionId = ctx.sessionManager.getSessionId();
+    const sessionIdentity = { cwd: ctx.cwd, sessionId };
     const sessionName = currentSessionName(ctx);
     const taskReference = dependencies.taskReference(ctx);
     const activeTaskRunId = readSessionTaskBinding(ctx.cwd, sessionId)?.activeTaskRunId ?? taskReference?.taskRunId;
@@ -283,7 +298,7 @@ export function registerSessionStartHook(pi: ExtensionAPI, dependencies: Session
     const permissionProfile = dependencies.permissionProfile(ctx, profile);
     const executionBackend = resolveExecutionBackend();
     const contextHint = preflight.recommendation === "fresh-session"
-      ? " Context is high; use /fresh task or /fresh scout for new work."
+      ? " Context is high; use /fresh <workflow> for new work (/fresh help lists every workflow)."
       : preflight.recommendation === "compact"
         ? " Context is warm; run /task-preflight before large work."
         : "";
@@ -308,6 +323,11 @@ export function registerSessionStartHook(pi: ExtensionAPI, dependencies: Session
     if (updateNotice) ctx.ui.notify(updateNotice, "info");
 
     let engineStatus: unknown;
+    // Capture ExtensionAPI state before the first await. Pi invalidates the
+    // captured `pi` object as soon as a concurrent session replacement/reload
+    // wins; consulting it after context-index I/O would then surface a noisy
+    // extension failure even though the replacement session is healthy.
+    const activeToolCount = pi.getActiveTools().length;
     try {
       engineStatus = await contextIndexV2Status(ctx.cwd, {
         excludePatterns: dependencies.contextExcludePatterns(profile)
@@ -315,22 +335,34 @@ export function registerSessionStartHook(pi: ExtensionAPI, dependencies: Session
     } catch (error) {
       engineStatus = { exists: false, error: error instanceof Error ? error.message : String(error) };
     }
-    dependencies.telemetry(ctx, {
-      event: "session_start",
-      // Benchmark and efficiency projections must be able to distinguish a
-      // genuine zero-recovery session from telemetry produced before this
-      // receipt/result protocol existed.
-      editRecoveryContextTelemetryVersion: 1,
-      activeTools: pi.getActiveTools().length,
-      index: engineStatus,
-      taskMigration: migration,
-      taskId: resumedTask?.taskId,
-      taskRunId: resumedTask?.taskRunId,
-      captureRetention,
-      taskJournalRetention,
-      taskRecovery,
-      executionBackend
-    });
-    await dependencies.afterStart?.(ctx);
+    if (!sessionContextMatches(ctx, sessionIdentity)) return;
+    try {
+      dependencies.telemetry(ctx, {
+        event: "session_start",
+        // Benchmark and efficiency projections must be able to distinguish a
+        // genuine zero-recovery session from telemetry produced before this
+        // receipt/result protocol existed.
+        editRecoveryContextTelemetryVersion: 1,
+        activeTools: activeToolCount,
+        index: engineStatus,
+        taskMigration: migration,
+        taskId: resumedTask?.taskId,
+        taskRunId: resumedTask?.taskRunId,
+        captureRetention,
+        taskJournalRetention,
+        taskRecovery,
+        executionBackend
+      });
+    } catch (error) {
+      if (!sessionContextMatches(ctx, sessionIdentity)) return;
+      throw error;
+    }
+    if (!sessionContextMatches(ctx, sessionIdentity)) return;
+    try {
+      await dependencies.afterStart?.(ctx);
+    } catch (error) {
+      if (!sessionContextMatches(ctx, sessionIdentity)) return;
+      throw error;
+    }
   });
 }

package/packages/piagent-core/runtime/hooks/tool-result-hook.ts

@@ -1,37 +1,37 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-
 import { estimateContextTokens, toolResultFingerprint } from "../../extensions/context-engine.js";
 import { matchesProtectedPath } from "../../extensions/policy-core.js";
 import { changedSnapshotFiles, taskDeltaFilesFromSnapshot } from "../../extensions/task-contract-view.js";
 import { classifyVerificationFailure } from "../../extensions/verification-intelligence.js";
 import { redactForStorage } from "../../extensions/redaction-core.js";
 import { appendObservedBashResult, hashEvidenceCommand, observedBashResultFromToolResultEvent } from "../../extensions/runtime-evidence.js";
-import { workingTreeSnapshot, workingTreeSnapshotHasUnavailableEvidence } from "../../extensions/task-state.js";
-import { workingTreeObservation } from "../../extensions/working-tree-digest.js";
+import { workingTreeSnapshotHasUnavailableEvidence } from "../../extensions/task-state.js";
+import { captureWorkspaceVerificationSnapshot } from "../../extensions/workspace-verification-snapshot.js";
 import { recordObservedContextEvidence } from "../context/context-evidence-qualification.ts";
 import { confirmContextDeliveryFromToolResult, type ContextDeliveryConfirmationDependencies } from "../context/context-delivery.ts";
 import { recordMutationResult } from "../inspection/mutation-provenance-recorder.ts";
-import { classifyToolFailure } from "../inspection/tool-failure-classification.ts";
+import { classifyToolFailure, handledToolFailure } from "../inspection/tool-failure-classification.ts";
 import { classifyDirectSubagentResult, type DirectSubagentResult } from "../orchestration/subagent-tool-policy.ts";
 import { boundedGitDiffReview } from "../quality/performance-assurance.ts";
 import { currentFileContentDigests } from "../quality/model-mutation-proof.ts";
 import { boundedPerformanceReviewResultText } from "../quality/performance-review-evidence.ts";
 import { buildEditRecoveryContext, type EditRecoveryContext } from "../recovery/edit-recovery-context.ts";
 import { EditRecoveryDeliveryState } from "../recovery/edit-recovery-delivery.ts";
+import { RetrievalEvidenceRuntime } from "../session/retrieval-evidence-runtime.ts";
 import { attachToolResultCompactionDetails, compactToolResultDetails, compactToolResultTextContent, type ToolResultCaptureSummary } from "../session/tool-result-compaction.ts";
 import type { ObservedTaskContext } from "../session/runtime-state.ts";
 import { observeTrajectorySync } from "../trajectory/trajectory-observability.ts";
 import type { TrajectorySyncResult } from "../trajectory/trajectory-runtime.ts";
 import { filterGrepProtectedContent, filterProtectedPathListContent } from "./tool-result-content-guards.ts";
-import { patchLineStats } from "./tool-result-metadata.ts";
+import { editVerificationMarker, patchLineStats } from "./tool-result-metadata.ts";
+import { handledNavigationToolResult } from "./tool-result-navigation.ts";
+import { attachRetrievalCheckpoint, observeRetrievalResult } from "./tool-result-retrieval.ts";
 import { appendToolResultText, boundedToolResultText, countChangedStringLeaves, isPlainRecord, numericExitCode, redactToolResultTextContent, successfulToolResult } from "./tool-result-value-helpers.ts";
 
 export { filterGrepProtectedContent, filterProtectedPathListContent };
 type ToolResultEvent = { toolCallId?: string; toolName: string; input?: unknown; content?: unknown; details?: unknown; isError?: boolean; usage?: unknown };
 type ObservedBashResult = NonNullable<ReturnType<typeof observedBashResultFromToolResultEvent>>;
 type ObservedVerificationResult = ObservedBashResult & { outputText?: string };
-type WorkingTreeObservation = ReturnType<typeof workingTreeObservation>;
-
 type ToolResultHookDependencies = ContextDeliveryConfirmationDependencies & {
   readProtectedPaths: (ctx: ExtensionContext) => string[];
   recordObservedBash: (observed: ObservedBashResult) => void;
@@ -48,15 +48,15 @@ type ToolResultHookDependencies = ContextDeliveryConfirmationDependencies & {
     event: ToolResultEvent,
     pendingContext: ObservedTaskContext[],
     maxManifestFiles: number,
-    shellSnapshotBefore?: Record<string, string>, eventTree?: WorkingTreeObservation
+    shellSnapshotBefore?: Record<string, string>, eventTree?: ReturnType<typeof captureWorkspaceVerificationSnapshot>
   ) => unknown;
   recordObservedTaskVerification: (
     pi: ExtensionAPI,
     ctx: ExtensionContext,
     observed: ObservedVerificationResult,
     pendingContext: ObservedTaskContext[],
-    maxManifestFiles: number, shellSnapshotBefore?: Record<string, string>, eventTree?: WorkingTreeObservation,
-    readProtectedPaths?: string[]
+    maxManifestFiles: number, shellSnapshotBefore?: Record<string, string>, eventTree?: ReturnType<typeof captureWorkspaceVerificationSnapshot>,
+    readProtectedPaths?: string[], preWorkspaceRevisionDigest?: string
   ) => unknown;
   extractLikelyPath: (cwd: string, input: Record<string, unknown>) => string | undefined;
   mutationTargets: (cwd: string, toolName: string, input: Record<string, unknown>) => string[];
@@ -91,10 +91,15 @@ type ToolResultHookDependencies = ContextDeliveryConfirmationDependencies & {
 
 export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResultHookDependencies): void {
   const editRecoveryDelivery = new EditRecoveryDeliveryState();
+  const retrievalEvidence = new RetrievalEvidenceRuntime();
   pi.on("session_compact", async (_event, ctx) => editRecoveryDelivery.advanceEpoch(ctx));
-  pi.on("session_shutdown", async (_event, ctx) => editRecoveryDelivery.clearSession(ctx));
+  pi.on("session_shutdown", async (_event, ctx) => {
+    editRecoveryDelivery.clearSession(ctx);
+    retrievalEvidence.clearSession(ctx);
+  });
   pi.on("tool_result", async (event, ctx) => {
     confirmContextDeliveryFromToolResult(pi, ctx, event, dependencies);
+    const currentTurnId = dependencies.state.currentTurn?.(ctx)?.turnId;
     const taskIdentity = dependencies.state.taskIdentity(ctx);
     const resultToolCallId = event.toolCallId ?? toolResultFingerprint(event.toolName, event.input, []).key;
     const readProtectedPaths = dependencies.readProtectedPaths(ctx);
@@ -115,9 +120,10 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
     const observedContextEntry = dependencies.observedTaskContext(ctx.cwd, event, readProtectedPaths);
     recordObservedContextEvidence(ctx, observedContextEntry, taskIdentity, dependencies);
     const pendingContext = dependencies.state.qualifiedTaskContext(ctx);
-    const shellSnapshotBefore = dependencies.isShellTool(event.toolName)
-      ? dependencies.state.consumeShellMutationSnapshot(ctx, event.toolName, event.input)
+    const shellVerificationBefore = dependencies.isShellTool(event.toolName)
+      ? dependencies.state.consumeShellVerificationSnapshot(ctx, event.toolName, event.input, resultToolCallId)
       : undefined;
+    const shellSnapshotBefore = shellVerificationBefore?.snapshot as Record<string, string> | undefined;
     const currentTask = dependencies.activeTask(ctx);
     const subagentResult = classifyDirectSubagentResult({
       toolName: event.toolName,
@@ -129,8 +135,9 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
     if (subagentResult) dependencies.recordSubagentResult?.(ctx, event, subagentResult);
     const effectiveToolError = event.isError === true || subagentResult?.failed === true;
     const eventTree = currentTask
-      ? workingTreeObservation(workingTreeSnapshot(ctx.cwd) as Record<string, string>)
+      ? captureWorkspaceVerificationSnapshot(ctx.cwd)
       : undefined;
+    dependencies.state.projectVerification.observe(ctx, currentTask, event, shellVerificationBefore, eventTree);
     dependencies.recordObservedTaskChanges(pi, ctx, event, pendingContext, dependencies.maxManifestFiles, shellSnapshotBefore, eventTree);
     if (observed) {
       dependencies.recordObservedTaskVerification(
@@ -138,7 +145,7 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
         ctx,
         { ...observed, toolCallId: observed.toolCallId ?? resultToolCallId, outputText: boundedToolResultText(event.content) },
         pendingContext,
-        dependencies.maxManifestFiles, shellSnapshotBefore, eventTree, readProtectedPaths
+        dependencies.maxManifestFiles, shellSnapshotBefore, eventTree, readProtectedPaths, shellVerificationBefore?.workspaceRevisionDigest ?? undefined
       );
     }
 
@@ -239,6 +246,7 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
     const successfulDirectMutation = successfulToolResult(event)
       && directMutationTool;
     const shellTreeChanged = shellChangedPaths.length > 0;
+    if (successfulDirectMutation || shellTreeChanged) retrievalEvidence.invalidateAfterMutation(ctx, currentTurnId);
     if (taskIdentity && currentTreeDigest && (reviewCandidate || existingCredit || successfulDirectMutation || shellSnapshotBefore)) {
       if (shellTreeChanged || directMutationResult.changedPaths.length > 0) {
         dependencies.state.invalidatePerformanceReviewCredit(taskIdentity.taskRunId);
@@ -294,6 +302,20 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
       resultChanged = true;
     }
     const resultTarget = dependencies.extractLikelyPath(ctx.cwd, isPlainRecord(event.input) ? event.input : {});
+    const handledNavigationFailure = effectiveToolError && handledToolFailure(toolFailureReasonCode, normalizedToolName);
+    if (handledNavigationFailure) {
+      const navigation = handledNavigationToolResult({
+        toolName: normalizedToolName,
+        reasonCode: String(toolFailureReasonCode),
+        targetPath: resultTarget,
+        content: resultContent,
+        details: resultDetails,
+        redactText: dependencies.redactText
+      });
+      resultContent = navigation.content;
+      resultDetails = navigation.details;
+      resultChanged = true;
+    }
     dependencies.observeEditFreshness?.(ctx, event, {
       taskRunId: taskIdentity?.taskRunId,
       successful: successfulToolResult(event),
@@ -377,6 +399,9 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
       outputHash: fingerprint.outputHash,
       recordedAt: dependencies.now()
     });
+    const retrievalCheckpoint = observeRetrievalResult({ runtime: retrievalEvidence, ctx, turnId: currentTurnId,
+      observation: { toolName: normalizedToolName, callFingerprint: fingerprint.key, outputHash: fingerprint.outputHash,
+        target: resultTarget, deterministicMiss: handledNavigationFailure, nonEvidenceFailure: effectiveToolError } });
     if (repeated && ["read", "grep", "find", "ls", "subagent"].includes(event.toolName) && fingerprint.outputChars > 0) {
       resultContent = [{
         type: "text",
@@ -394,7 +419,6 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
         : { value: resultDetails, piagentDelta: delta };
       resultChanged = true;
     }
-
     const captureCache = new Map<string, ToolResultCaptureSummary>();
     const compactedContent = compactToolResultTextContent(ctx.cwd, event, ctx, resultContent, captureCache);
     const compactionCaptures = [...compactedContent.captures];
@@ -419,6 +443,13 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
       resultContent = appendToolResultText(resultContent, editRecovery.text);
       resultChanged = true;
     }
+    const checkpointResult = attachRetrievalCheckpoint({ checkpoint: retrievalCheckpoint, content: resultContent,
+      details: resultDetails, ctx, turnId: currentTurnId, telemetry: dependencies.telemetry });
+    if (checkpointResult.changed) {
+      resultContent = checkpointResult.content;
+      resultDetails = checkpointResult.details;
+      resultChanged = true;
+    }
 
     const resultFingerprintId = event.toolCallId ?? fingerprint.key;
     const record = dependencies.activity ?? dependencies.telemetry;
@@ -429,8 +460,8 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
     const lineStats = patchLineStats(event.details);
     const editRecoveryFailure = ["edit-anchor-not-unique", "edit-anchor-stale"].includes(String(toolFailureReasonCode));
     record(ctx, {
-      activityId: `result:${resultFingerprintId}`,
-      event: "tool_result",
+      activityId: `result:${resultFingerprintId}`, event: "tool_result",
+      ...editVerificationMarker(taskIdentity, eventTree, successfulToolResult(event), changedPaths),
       recordedAt: dependencies.now(),
       toolCallId: resultFingerprintId,
       toolName: event.toolName,
@@ -446,6 +477,8 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
       sensitiveValuesRedacted,
       isError: effectiveToolError,
       reasonCode: failureReasonCode,
+      handledFailure: handledNavigationFailure || undefined,
+      retrievalCheckpoint: retrievalCheckpoint?.reason,
       // An explicit false is evidence too: it proves that every classified
       // edit-anchor failure passed through the recovery policy even when the
       // target was too large, private, protected, or otherwise ineligible.
@@ -460,8 +493,8 @@ export function registerToolResultHook(pi: ExtensionAPI, dependencies: ToolResul
 
     if (resultChanged) {
       return resultDetails === undefined
-        ? { content: resultContent }
-        : { content: resultContent, details: resultDetails };
+        ? { content: resultContent, ...(handledNavigationFailure ? { isError: false } : {}) }
+        : { content: resultContent, details: resultDetails, ...(handledNavigationFailure ? { isError: false } : {}) };
     }
   });
 }

package/packages/piagent-core/runtime/hooks/tool-result-metadata.ts

@@ -11,3 +11,12 @@ export function patchLineStats(details: unknown): { additions?: number; deletion
   }
   return { additions, deletions };
 }
+
+export function editVerificationMarker(identity: { taskId: string; taskRunId: string } | undefined,
+  tree: { proofCapable: boolean; digest: string; workspaceRevisionDigest: string | null } | undefined,
+  successful: boolean, changedPaths: string[]) {
+  return { taskUsageVersion: 1, taskId: identity?.taskId, taskRunId: identity?.taskRunId,
+    mutationObserved: successful && changedPaths.length > 0 && tree?.proofCapable === true,
+    postWorkingTreeDigest: tree?.proofCapable ? tree.digest : null,
+    postWorkspaceRevisionDigest: tree?.proofCapable ? tree.workspaceRevisionDigest : null };
+}

package/packages/piagent-core/runtime/hooks/tool-result-navigation.ts

@@ -0,0 +1,36 @@
+import { appendToolResultText, isPlainRecord } from "./tool-result-value-helpers.ts";
+
+function handledNavigationText(reasonCode: string): string {
+  const guidance = reasonCode === "target-is-directory"
+    ? "List the directory once and choose a child"
+    : "Discover from one confirmed parent";
+  return `[Piagent navigation: ${reasonCode} — handled negative evidence, not a runtime failure. ${guidance}; do not retry this call.]`;
+}
+
+export function handledNavigationToolResult(input: {
+  toolName: string;
+  reasonCode: string;
+  targetPath?: string;
+  content: unknown;
+  details: unknown;
+  redactText: (value: string) => string;
+}): { content: unknown; details: unknown } {
+  const targetPath = input.targetPath
+    ? input.redactText(input.targetPath).replace(/\s+/g, " ").trim().slice(0, 1_024) || undefined
+    : undefined;
+  const navigation = {
+    schemaVersion: 1,
+    handled: true,
+    reasonCode: input.reasonCode,
+    targetPath,
+    retryExactCall: false
+  };
+  const text = handledNavigationText(input.reasonCode);
+  const content = ["read", "grep", "find", "ls"].includes(input.toolName)
+    ? [{ type: "text", text }]
+    : appendToolResultText(input.content, text);
+  const details = isPlainRecord(input.details)
+    ? { ...input.details, piagentNavigation: navigation }
+    : { ...(input.details === undefined ? {} : { value: input.details }), piagentNavigation: navigation };
+  return { content, details };
+}

package/packages/piagent-core/runtime/hooks/tool-result-retrieval.ts

@@ -0,0 +1,42 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import {
+  RetrievalEvidenceRuntime,
+  type RetrievalEvidenceCheckpoint,
+  type RetrievalEvidenceObservation
+} from "../session/retrieval-evidence-runtime.ts";
+import { appendToolResultText, isPlainRecord } from "./tool-result-value-helpers.ts";
+
+export function observeRetrievalResult(input: {
+  runtime: RetrievalEvidenceRuntime;
+  ctx: ExtensionContext;
+  observation: RetrievalEvidenceObservation;
+  turnId?: string;
+}): RetrievalEvidenceCheckpoint | undefined {
+  return input.runtime.observe(input.ctx, input.observation, input.turnId);
+}
+
+export function attachRetrievalCheckpoint(input: {
+  checkpoint?: RetrievalEvidenceCheckpoint;
+  content: unknown;
+  details: unknown;
+  ctx: ExtensionContext;
+  turnId?: string;
+  telemetry: (ctx: ExtensionContext, payload: Record<string, unknown>) => void;
+}): { content: unknown; details: unknown; changed: boolean } {
+  if (!input.checkpoint) return { content: input.content, details: input.details, changed: false };
+  const details = isPlainRecord(input.details)
+    ? { ...input.details, piagentRetrievalCheckpoint: input.checkpoint }
+    : { ...(input.details === undefined ? {} : { value: input.details }), piagentRetrievalCheckpoint: input.checkpoint };
+  input.telemetry(input.ctx, {
+    event: "retrieval_evidence_checkpoint",
+    turnId: input.turnId,
+    ...input.checkpoint,
+    text: undefined
+  });
+  return {
+    content: appendToolResultText(input.content, input.checkpoint.text),
+    details,
+    changed: true
+  };
+}

package/packages/piagent-core/runtime/input/chat-images.ts

@@ -105,7 +105,7 @@ function normalizeImagePathCandidate(candidate: string, cwd: string, options: {
   return path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
 }
 
-function extractLocalImagePathCandidates(text: string, cwd: string): string[] {
+export function extractLocalImagePathCandidates(text: string, cwd: string): string[] {
   const candidates = new Set<string>();
   const imageExt = "(?:png|jpe?g|gif|webp|bmp)";
   const wholeTextPath = normalizeImagePathCandidate(text, cwd, { allowBareRelative: false });

package/packages/piagent-core/runtime/inspection/activity-event-adapter.ts

@@ -54,7 +54,7 @@ export function adaptActivityTelemetryEvent(input: ActivityEventAdapterInput): R
   const toolCallRef = hasOperation ? opaque("tool", rawToolCall) : null;
   const activityType = hasOperation ? "tool" : ["bash", "shell", "exec"].includes(toolName) ? "command" : "other";
   const resultFailure = eventName === "tool_result" && (event.isError === true || typeof event.exitCode === "number" && event.exitCode !== 0);
-  const failed = resultFailure && !handledToolFailure(event.reasonCode);
+  const failed = resultFailure && !handledToolFailure(event.reasonCode, toolName);
   const blocked = eventName === "tool_decision";
   // `tool_call` is emitted before policy authorization. Calling it "started"
   // made the Dashboard claim a command was running while it was still waiting

package/packages/piagent-core/runtime/inspection/same-process-bridge-proof.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 
-export const PINNED_BRIDGE_HOST_VERSION = "0.84.1" as const;
+export const PINNED_BRIDGE_HOST_VERSION = "0.87.1" as const;
 export const SAME_PROCESS_BRIDGE_PROOF_VERSION = "piagent-webui-same-process-bridge-v1" as const;
 
 const HOST_EVENTS = Object.freeze([

package/packages/piagent-core/runtime/inspection/task-handoff-history.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 
 import { redactSensitiveText } from "../../extensions/redaction-core.js";
-import { readHandoffProjection } from "../recovery/handoff-projection.ts";
+import { handoffIdentityMatchesTask, readHandoffProjection } from "../recovery/handoff-projection.ts";
 import { inspectTaskResumeState } from "../recovery/resume-state.ts";
 import { inspectBoundedContextTelemetry } from "./context-telemetry-inspection.ts";
 import { taskRunOpaqueRef } from "./task-run-index.ts";
@@ -34,7 +34,7 @@ function nextAction(cwd: string, task: Task) {
 
 function currentHandoff(cwd: string, task: Task) {
   const handoff = readHandoffProjection(cwd, task.taskRunId); if (!handoff) return null;
-  if (handoff.identity.taskId !== task.taskId || handoff.identity.taskRunId !== task.taskRunId) throw new Error("handoff-identity-conflict");
+  if (!handoffIdentityMatchesTask(handoff.identity, task as any)) throw new Error("handoff-identity-conflict");
   return { handoffRef: opaque("handoff", `${task.taskRunId}\0${handoff.generatedAt}\0${handoff.tree.currentDigest ?? "none"}`),
     generatedAt: handoff.generatedAt, phase: display(handoff.state.phase, 64) || null, taskOutcome: handoff.state.taskOutcome,
     gateDecision: handoff.state.gateDecision, completionApproved: handoff.state.completionApproved,

package/packages/piagent-core/runtime/inspection/tool-failure-classification.ts

@@ -1,5 +1,6 @@
 export type ToolFailureReasonCode =
   | "target-not-found"
+  | "target-is-directory"
   | "search-target-missing"
   | "edit-anchor-not-unique"
   | "edit-anchor-stale"
@@ -28,6 +29,36 @@ function commandFromInput(input: unknown): string {
     ? (args as { command: string }).command : "";
 }
 
+const CONFLICTING_FAILURE = /\b(?:EACCES|EPERM|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENETUNREACH|EAI_AGAIN|ENOSPC|EMFILE|ENOMEM)\b|permission denied|operation not permitted|timed? out|authentication (?:failed|required)|unauthorized|rate limit|invalid (?:regular expression|regex|pattern|option)|regex parse error|syntax error|unterminated|unclosed|unknown option|^usage:/im;
+const MISSING_TARGET = /\b(?:ENOENT|ENOTDIR)\b|no such file or directory|(?:file|path) (?:does not exist|not found)|not a directory|cannot find the (?:file|path)|no valid search paths given|\bos error 2\b/i;
+
+function standaloneSearchWithPartialEvidence(command: string, text: string): boolean {
+  const source = command.trim();
+  if (!/^(?:rg|grep|git\s+grep)\b/.test(source)) return false;
+  // A compound shell can fail for a second reason after a useful search. Do
+  // not neutralize its whole result from one missing-path diagnostic.
+  if (/[\r\n;<>]|&&|\|\||\$\(|`|(?<!\|)\|(?!\|)/.test(source)) return false;
+  if (CONFLICTING_FAILURE.test(text)) return false;
+
+  let usefulMatches = false;
+  let missingTarget = false;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (!/^\s*(?:rg|grep):/i.test(line) && /^.+?:\d+:/.test(line)) {
+      usefulMatches = true;
+      continue;
+    }
+    if (MISSING_TARGET.test(line)) {
+      missingTarget = true;
+      continue;
+    }
+    if (/^(?:command|process) exited with (?:code|status) [12]$/i.test(line)) continue;
+    return false;
+  }
+  return usefulMatches && missingTarget;
+}
+
 export function classifyToolFailure(toolName: string, isError: boolean, content: unknown, input?: unknown): ToolFailureReasonCode | null {
   const text = boundedText(content);
   const subagent = /(?:^|[._-])subagents?(?:$|[._-])/i.test(toolName);
@@ -53,18 +84,28 @@ export function classifyToolFailure(toolName: string, isError: boolean, content:
       return "edit-anchor-stale";
     }
   }
-  const readLike = /(?:^|[._-])(?:read|document[_-]?read)(?:$|[._-])/i.test(toolName);
-  if (readLike && /\bENOENT\b|no such file or directory|file (?:does not exist|not found)|cannot find the (?:file|path)/i.test(text)) {
+  const trustedRead = /^(?:read|piagent_document_read)$/i.test(toolName);
+  const conflictingFailure = CONFLICTING_FAILURE.test(text);
+  if (trustedRead && !conflictingFailure && /\bEISDIR\b|illegal operation on a directory|is a directory/i.test(text)) {
+    return "target-is-directory";
+  }
+  if (trustedRead && !conflictingFailure && /\bENOENT\b|no such file or directory|(?:file|path) (?:does not exist|not found)|cannot find the (?:file|path)/i.test(text)) {
     return "target-not-found";
   }
+  const structuredSearch = /^(?:grep|find|ls)$/i.test(toolName);
+  if (structuredSearch && !conflictingFailure && MISSING_TARGET.test(text)) {
+    return "search-target-missing";
+  }
   const shellLike = /^(?:bash|shell|exec|command)$/i.test(toolName);
-  const searchCommand = /^\s*(?:rg|grep|git\s+grep)\b/.test(commandFromInput(input));
-  const missingTarget = /no such file or directory|cannot find the (?:file|path)|\bos error 2\b/i.test(text);
-  const usefulMatches = text.split(/\r?\n/).some((line) => !/^\s*(?:rg|grep):/i.test(line) && /^.+?:\d+:/.test(line));
-  if (shellLike && searchCommand && missingTarget && usefulMatches) return "search-target-missing";
+  if (shellLike && standaloneSearchWithPartialEvidence(commandFromInput(input), text)) return "search-target-missing";
   return "tool-result-failed";
 }
 
-export function handledToolFailure(reasonCode: unknown): boolean {
-  return reasonCode === "search-target-missing";
+export function handledToolFailure(reasonCode: unknown, toolName: unknown): boolean {
+  const trustedTool = String(toolName ?? "").toLowerCase();
+  if (reasonCode === "target-not-found" || reasonCode === "target-is-directory") {
+    return trustedTool === "read" || trustedTool === "piagent_document_read";
+  }
+  return reasonCode === "search-target-missing"
+    && ["grep", "find", "ls", "bash", "shell", "exec", "command"].includes(trustedTool);
 }