@piagent/platform 1.6.0 → 1.7.1

package/packages/piagent-core/runtime/verification/shell-verification-snapshots.ts

@@ -0,0 +1,56 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { toolResultFingerprint } from "../../extensions/context-engine.js";
+import { captureWorkspaceVerificationSnapshot } from "../../extensions/workspace-verification-snapshot.js";
+
+/** Host invocation state; equal commands in parallel must not consume each other. */
+export class ShellVerificationSnapshots {
+  readonly #snapshots = new Map<string, ReturnType<typeof captureWorkspaceVerificationSnapshot> | null>();
+  readonly #consumed = new Map<string, ReturnType<typeof captureWorkspaceVerificationSnapshot>>();
+  #overflowed = false;
+
+  #key(ctx: ExtensionContext, toolName: string, input: unknown, toolCallId?: string, taskRunId = ""): string {
+    const fingerprint = toolResultFingerprint(toolName, input, []).key;
+    return `${ctx.cwd}\u0000${ctx.sessionManager.getSessionId()}\u0000${taskRunId}\u0000${toolCallId ?? fingerprint}\u0000${fingerprint}`;
+  }
+
+  remember(ctx: ExtensionContext, toolName: string, input: unknown, toolCallId?: string, taskRunId?: string): void {
+    const key = this.#key(ctx, toolName, input, toolCallId, taskRunId);
+    // Ambiguous duplicate invocation IDs cannot supply a before-snapshot.
+    if (this.#snapshots.has(key)) { this.#snapshots.set(key, null); return; }
+    this.#snapshots.set(key, captureWorkspaceVerificationSnapshot(ctx.cwd));
+    while (this.#snapshots.size > 100) {
+      this.#overflowed = true; // Lost in-flight identity cannot become a cached pass later in this process.
+      this.#snapshots.delete(this.#snapshots.keys().next().value as string);
+    }
+  }
+
+  consume(ctx: ExtensionContext, toolName: string, input: unknown, toolCallId?: string, taskRunId?: string) {
+    const key = this.#key(ctx, toolName, input, toolCallId, taskRunId);
+    const snapshot = this.#snapshots.get(key);
+    this.#snapshots.delete(key);
+    if (snapshot) {
+      this.#consumed.set(key, snapshot);
+      while (this.#consumed.size > 100) this.#consumed.delete(this.#consumed.keys().next().value as string);
+    }
+    return snapshot ?? undefined;
+  }
+
+  claimObservation(ctx: ExtensionContext, toolName: string, input: unknown, toolCallId: string | undefined,
+    taskRunId: string, snapshot: ReturnType<typeof captureWorkspaceVerificationSnapshot> | undefined): boolean {
+    const key = this.#key(ctx, toolName, input, toolCallId, taskRunId);
+    const issued = this.#consumed.get(key);
+    this.#consumed.delete(key);
+    return issued !== undefined && issued === snapshot;
+  }
+
+  hasPending(ctx: ExtensionContext, taskRunId: string): boolean {
+    const prefix = `${ctx.cwd}\0${ctx.sessionManager.getSessionId()}\0${taskRunId}\0`;
+    return this.#overflowed || [...this.#snapshots.keys()].some((key) => key.startsWith(prefix));
+  }
+
+  clear(ctx: ExtensionContext): void {
+    const prefix = `${ctx.cwd}\u0000${ctx.sessionManager.getSessionId()}\u0000`;
+    for (const key of this.#snapshots.keys()) if (key.startsWith(prefix)) this.#snapshots.delete(key);
+    for (const key of this.#consumed.keys()) if (key.startsWith(prefix)) this.#consumed.delete(key);
+  }
+}

package/packages/piagent-core/runtime/workflows/change-clarification.ts

@@ -0,0 +1,61 @@
+const CHANGE_INTENT = /\b(?:add|build|change|correct|create|fix|implement|modify|mutate|refactor|remove|rename|repair|replace|update|write|sua|them|doi|cap nhat|xoa|tao)\b/i;
+const EXPLICIT_CHANGE_REQUEST = [
+  /^(?:(?:ok(?:ay|e)?|then|now|please|so|vay|bay gio|anh|em|vui long|lam on|tien hanh|tiep tuc|thuc hien)\b[\s,.:;!—–-]*)*(?:add|apply|build|change|correct|create|fix|implement|modify|mutate|refactor|remove|rename|repair|replace|update|write|sua|them|doi|cap nhat|xoa|tao)\b/i,
+  /^(?:please\s+)?(?:can|could|would|will)\s+you\s+(?:please\s+)?(?:add|apply|build|change|correct|create|fix|implement|modify|refactor|remove|rename|repair|replace|update|write)\b/i,
+  /^(?:i\s+(?:need|want)\s+you\s+to|(?:anh|a|toi|minh)\s+(?:can|muon)\s+em)\s+(?:add|apply|build|change|correct|create|fix|implement|modify|refactor|remove|rename|repair|replace|update|write|sua|them|doi|cap nhat|xoa|tao)\b/i,
+  /^(?:(?:ok(?:ay|e)?|then|now|please|so|vay|bay gio)\b[\s,.:;!—–-]*)*(?:go\s+ahead(?:\s+and|\s+with)?|proceed(?:\s+to|\s+with)?|tien\s+hanh|tiep\s+tuc|thuc\s+hien)\b.{0,40}\b(?:add|apply|build|changes?|fix|implementation|implement|modify|repair|replace|update|sua|them|doi|cap nhat|xoa|tao)\b/i,
+  /\b(?:add|apply|build|change|correct|create|fix|implement|modify|mutate|refactor|remove|rename|repair|replace|update|write|sua|them|doi|cap nhat|xoa|tao)\b.{0,64}\b(?:di|nhe|luon|cho anh|giup anh|go ahead)\b/i
+];
+const CHANGE_CHOICE_QUESTION = [
+  /\b(?:should|do|does|did|must|need|can|could|would|may)\s+(?:i|we|you|he|she|they)\b.{0,160}\b(?:or|hay)\b/i,
+  /\b(?:i|we|you|a|anh|em|minh|toi|tui|chung ta)\s+(?:need\s+to|have\s+to|should|can|could|would|co\s+can|can|nen|co\s+the|phai)\b.{0,160}\b(?:or|hay)\b/i,
+  /\b(?:co\s+nen|co\s+can|co\s+phai|lieu\s+co|nen|can)\b.{0,160}\b(?:or|hay)\b/i
+];
+const ENGLISH_YES_NO_CHANGE_QUESTION = /^(?:(?:so|then|now)\b[\s,.:;!—–-]*)*(?:should|must|do|does|did|can|could|would|may)\s+(?:i|we|you|he|she|they)\b/i;
+const ENGLISH_WH_CHANGE_QUESTION = /^(?:(?:so|then|now)\b[\s,.:;!—–-]*)*(?:what|which|when|where|why|how)\b/i;
+const VIETNAMESE_CHANGE_QUESTION = /\b(?:(?:a|anh|em|minh|toi|tui|chung\s+ta)\s+(?:co\s+can|can|nen|co\s+the|phai)|co\s+nen|co\s+can|co\s+phai|lieu\s+co)\b/i;
+
+export function foldChangeIntent(value: string): string {
+  return String(value ?? "")
+    .normalize("NFKD")
+    .replace(/\p{M}/gu, "")
+    .replace(/[đĐ]/g, (character) => character === "Đ" ? "D" : "d")
+    .toLowerCase();
+}
+
+export function hasChangeIntent(value: string): boolean {
+  return CHANGE_INTENT.test(foldChangeIntent(value));
+}
+
+export function isExplicitChangeRequest(value: string): boolean {
+  const folded = foldChangeIntent(value);
+  return EXPLICIT_CHANGE_REQUEST.some((pattern) => pattern.test(folded));
+}
+
+/** Host-neutral linguistic classification; workflow authority is applied by task intake. */
+export function isLightweightNonAuthorizingChangeLanguage(prompt: string): boolean {
+  const text = String(prompt ?? "").trim();
+  const folded = foldChangeIntent(text);
+  if (!text || /^\/[a-z0-9-]+\b/i.test(text) || !CHANGE_INTENT.test(folded)) return false;
+  const hasChoiceSeparator = /\b(?:or|hay)\b/i.test(folded);
+  const choiceBranches = hasChoiceSeparator ? folded.split(/\b(?:or|hay)\b/i) : [];
+  const mixedChangeChoice = choiceBranches.some((branch) => CHANGE_INTENT.test(branch))
+    && choiceBranches.some((branch) => !CHANGE_INTENT.test(branch));
+  // A punctuated change-vs-non-change choice remains a question even when its
+  // change branch starts with "em fix" or ends in "sửa luôn". Two change
+  // branches such as "can you fix or replace...?" remain an explicit request.
+  if (mixedChangeChoice && /[?]\s*$/.test(text)) return true;
+  if (isExplicitChangeRequest(folded)) return false;
+  if (hasChoiceSeparator && CHANGE_CHOICE_QUESTION.some((pattern) => pattern.test(folded))) return true;
+  if (ENGLISH_YES_NO_CHANGE_QUESTION.test(folded)) return true;
+  return VIETNAMESE_CHANGE_QUESTION.test(folded) && (/[?]\s*$/.test(text) || /\bkhong\b[\s?.!]*$/i.test(folded));
+}
+
+export function isNonAuthorizingChangeLanguage(prompt: string): boolean {
+  const text = String(prompt ?? "").trim();
+  if (!text) return false;
+  if (isLightweightNonAuthorizingChangeLanguage(text)) return true;
+  if (isExplicitChangeRequest(text)) return false;
+  const folded = foldChangeIntent(text);
+  return CHANGE_INTENT.test(folded) && ENGLISH_WH_CHANGE_QUESTION.test(folded);
+}

package/packages/piagent-core/runtime/workflows/input-routing.ts

@@ -3,8 +3,17 @@ import path from "node:path";
 
 import { redactSensitiveText } from "../../extensions/redaction-core.js";
 import { LONG_INPUT_CHARS, MAX_INLINE_COLLAPSED_TASK_CHARS } from "../runtime-limits.ts";
+import {
+  type WorkflowId,
+  stripWorkflowCommand,
+  workflowIdFromCommand
+} from "./webui-workflow.ts";
 
-export type FreshWorkflow = "task" | "scout" | "be-to-fe";
+export type FreshWorkflow = WorkflowId;
+
+export function workflowIdFromInput(input: string): WorkflowId | null {
+  return workflowIdFromCommand(input);
+}
 
 export function looksLikeGovernedBoilerplate(text: string): boolean {
   const lower = text.toLowerCase();
@@ -29,10 +38,7 @@ function extractFencedBlockAfter(label: RegExp, text: string): string | undefine
 }
 
 export function stripLeadingWorkflowCommand(input: string): string {
-  return input
-    .replace(/^\/(?:piagent-workflow|workflow)\s+(?:task|scout|be-to-fe|review|plan|platform-improve|discuss|commit|pr)\b\s*/i, "")
-    .replace(/^\/(?:task|scout|be-to-fe|review|plan|platform-improve|discuss|commit|pr)\b\s*/i, "")
-    .trim();
+  return stripWorkflowCommand(input);
 }
 
 export function extractTaskRequest(text: string): string {
@@ -47,6 +53,11 @@ export function extractTaskRequest(text: string): string {
   return stripLeadingWorkflowCommand(text.trim());
 }
 
+/** Normalize the delivered agent prompt, not the earlier surface input. */
+export function agentStartTaskRequest(prompt: string): string {
+  return looksLikeGovernedBoilerplate(prompt) ? extractTaskRequest(prompt) : prompt.trim();
+}
+
 export function trimTaskForInline(input: string): string {
   const normalized = stripLeadingWorkflowCommand(input).trim().replace(/\n{3,}/g, "\n\n");
   if (normalized.length <= MAX_INLINE_COLLAPSED_TASK_CHARS) return normalized;
@@ -55,13 +66,8 @@ export function trimTaskForInline(input: string): string {
 
 export function chooseFreshWorkflow(original: string, task: string): FreshWorkflow {
   const semantic = stripLeadingWorkflowCommand(task || original).toLowerCase();
-  const starts = original.trim().toLowerCase();
-  const workflowStart = starts.match(/^\/(?:piagent-workflow|workflow)\s+(task|scout|be-to-fe)\b/);
-  if (workflowStart?.[1] === "be-to-fe") return "be-to-fe";
-  if (workflowStart?.[1] === "scout") return "scout";
-  if (workflowStart?.[1] === "task") return "task";
-  if (starts.startsWith("/be-to-fe")) return "be-to-fe";
-  if (starts.startsWith("/scout")) return "scout";
+  const explicit = workflowIdFromInput(original);
+  if (explicit) return explicit;
   const asksForWrite = /\b(implement|support|surface|consume|write|change|fix)\b/.test(semantic);
   if (/\b(scout|read-only|read only|audit|mapping|mapping matrix|map contract)\b/.test(semantic) && !asksForWrite) {
     return "scout";
@@ -73,7 +79,7 @@ export function chooseFreshWorkflow(original: string, task: string): FreshWorkfl
 }
 
 export function isPiagentWorkflowInput(text: string): boolean {
-  return /^\/(?:piagent-workflow|workflow|task|be-to-fe|scout|review|plan|platform-improve)\b/i.test(text.trim());
+  return workflowIdFromInput(text) !== null;
 }
 
 export function isFreshOrUtilityInput(text: string): boolean {
@@ -104,7 +110,8 @@ export function buildFreshCommand(cwd: string, workflow: FreshWorkflow, original
     // never becomes task instructions or provider-visible document content.
     return `/fresh ${workflow} --session-title "${shortTaskLabel(task)}" Read task intake from ${intakePath}. ${reason}`;
   }
-  return `/fresh ${workflow} ${trimTaskForInline(task)}`;
+  const inline = trimTaskForInline(task);
+  return [`/fresh ${workflow}`, inline].filter(Boolean).join(" ");
 }
 
 export function shortTaskLabel(text: string): string {

package/packages/piagent-core/runtime/workflows/runtime-intake-compaction.ts

@@ -0,0 +1,201 @@
+import { RUNTIME_INTAKE_MESSAGE_MAX_CHARS } from "../runtime-limits.ts";
+import { verifierCommandBoundsError } from "../../extensions/verification-intelligence.js";
+
+const COMPACTION_MARKER = "[Piagent intake guidance compacted; the complete operator request and durable Task Contract remain authoritative.]";
+const MAX_EXACT_FINAL_OUTPUT_LINE_CHARS = 512;
+
+function edgeBounded(value: string, maximum: number): string {
+  if (value.length <= maximum) return value;
+  const marker = " … ";
+  const available = maximum - marker.length;
+  const head = Math.floor(available * 0.6);
+  return `${value.slice(0, head).trimEnd()}${marker}${value.slice(-(available - head)).trimStart()}`;
+}
+
+function legacyHeadTail(text: string): string {
+  const marker = `\n\n${COMPACTION_MARKER}\n\n`;
+  const available = RUNTIME_INTAKE_MESSAGE_MAX_CHARS - marker.length;
+  const head = Math.floor(available * 0.58);
+  return `${text.slice(0, head).trimEnd()}${marker}${text.slice(-(available - head)).trimStart()}`;
+}
+
+function compactProofTag(tag: string): string {
+  const identity = tag.match(/^\[(criterion-[0-9]{2}|fallback)/)?.[1] ?? "fallback";
+  if (tag.includes(":fallback")) return `[${identity}:fallback]`;
+  if (tag.includes(":")) return `[${identity}:candidate]`;
+  return `[${identity}]`;
+}
+
+/** Compress locations and repeated boilerplate, never semantic proof bodies. */
+function semanticCriticalProof(lines: string[]): string[] {
+  if (lines.length === 0) return [];
+  const bodies = new Map<string, Set<string>>();
+  for (const line of lines.slice(1)) {
+    if (!line.trim() || /^(?:Candidate tags |No concrete criterion-linked |Exact final-output contract:)/.test(line)) continue;
+    const match = line.match(/^- ((?:\[(?:criterion-[0-9]{2}|fallback)(?::[^\]]+)?\])*)\s*(.+)$/);
+    const body = match?.[2] ?? line;
+    const tags = bodies.get(body) ?? new Set<string>();
+    for (const tag of match?.[1].match(/\[(?:criterion-[0-9]{2}|fallback)(?::[^\]]+)?\]/g) ?? []) tags.add(compactProofTag(tag));
+    bodies.set(body, tags);
+  }
+  return [
+    "Critical behavioral proof:",
+    ...[...bodies].map(([body, tags]) => `- ${tags.size ? `${[...tags].join("")} ` : ""}${body}`),
+    "Use linked durable live assertions after final mutation and before exact verifiers; candidate tags are locations, not proof. Fallback tags require focused tests."
+  ];
+}
+
+function minimalCriticalProof(lines: string[]): string[] {
+  if (lines.length === 0) return [];
+  const tags = [...new Set((lines.join("\n").match(/\[(?:criterion-[0-9]{2}|fallback)(?::[^\]]+)?\]/g) ?? []).map(compactProofTag))].slice(0, 12);
+  return [
+    "Critical behavioral proof:",
+    `- ${tags.join("")} Detailed semantic proof hints omitted; consult the complete operator contract.`,
+    "Fallback tags require a focused test. Run proof after final mutation and before exact verifiers; prose or transient probes are insufficient."
+  ];
+}
+
+function minimalExecutionMap(lines: string[]): string[] {
+  if (lines.length === 0) return [];
+  const rows = lines.slice(1, 13).map((line) => {
+    const criterion = line.match(/^-\s+(criterion-[0-9]{2})\b/)?.[1];
+    const target = line.match(/^-\s+criterion-[0-9]{2}\s+(\S+)/)?.[1];
+    const after = line.match(/\bafter=(\S+)/)?.[1];
+    if (!criterion) return `- ${edgeBounded(line.replace(/^-\s*/, ""), 72)}`;
+    return `- ${criterion}${target ? ` ${edgeBounded(target, 38)}` : ""}${after ? ` after=${edgeBounded(after, 18)}` : ""}`;
+  });
+  return [lines[0], ...rows];
+}
+
+function identityOnlyExecutionMap(lines: string[]): string[] {
+  if (lines.length === 0) return [];
+  return [
+    lines[0],
+    ...lines.slice(1, 13).map((line, index) => `- ${line.match(/\bcriterion-[0-9]{2}\b/)?.[0] ?? `criterion-${String(index + 1).padStart(2, "0")}`}`)
+  ];
+}
+
+function structuredCompaction(text: string): string | undefined {
+  const lines = text.split("\n");
+  const critical = lines.indexOf("Critical behavioral proof:");
+  const exactOutput = lines.findIndex((line) => line.startsWith("Exact final-output contract:"));
+  const exact = lines.indexOf("Exact verifier commands:");
+  const execution = lines.indexOf("Execution map (planning only):");
+  const reuse = lines.findIndex((line, index) => index > execution && line.startsWith("Use runtime-delivered source;"));
+  if (!(exact >= 0 && execution > exact && reuse > execution)) return undefined;
+  const publicContract = critical >= 0
+    ? lines.findIndex((line, index) => index > critical && index < exact && line === "Existing public contract:")
+    : -1;
+  const criticalLines = critical >= 0 ? lines.slice(critical, publicContract > critical ? publicContract : exact) : [];
+  const exactOutputLines = exactOutput >= 0 && exactOutput < exact ? [lines[exactOutput]] : [];
+  const exactLines = lines.slice(exact, execution);
+  const executionLines = lines.slice(execution, reuse);
+  const prefixEnd = [critical, exactOutput, exact].filter((index) => index >= 0).sort((left, right) => left - right)[0];
+  const prefix = lines.slice(0, prefixEnd).slice(0, 3);
+  const finalGuidance = [...lines].reverse().find(Boolean) ?? "";
+  const compose = (proof: string[], map: string[], compactPrefix = false) => [
+    ...(compactPrefix ? prefix.map((line) => edgeBounded(line, 360)) : prefix),
+    COMPACTION_MARKER,
+    ...proof,
+    ...exactOutputLines,
+    ...displayExactLines,
+    ...map,
+    lines[reuse],
+    finalGuidance
+  ].filter(Boolean).join("\n");
+  const presentedCommands = exactLines.slice(1)
+    .map((line) => line.match(/^Verifier\s+\d+\s+\(run as an exact standalone shell command\): (.*)$/)?.[1] ?? line)
+    .filter((command) => command.trim());
+  const displayExactLines = [
+    "Exact verifier commands:",
+    ...presentedCommands.map((command, index) => `Verifier ${index + 1} (run as an exact standalone shell command): ${command}`)
+  ];
+  const verifierError = verifierCommandBoundsError(presentedCommands);
+  if (verifierError) return [
+    ...prefix.slice(0, 2).map((line) => edgeBounded(line, 220)),
+    COMPACTION_MARKER,
+    ...exactOutputLines.map((line) => edgeBounded(line, 260)),
+    "Exact verifier commands:",
+    `Runtime intake refused: ${verifierError} No verifier was truncated or accepted as evidence; correct the profile and restart the task.`,
+    ...minimalExecutionMap(executionLines),
+    edgeBounded(lines[reuse], 220),
+    "Stop this task until a bounded exact verifier is configured."
+  ].filter(Boolean).join("\n");
+  if (exactOutputLines.some((line) => line.length > MAX_EXACT_FINAL_OUTPUT_LINE_CHARS)) return [
+    ...prefix.slice(0, 2).map((line) => edgeBounded(line, 220)),
+    COMPACTION_MARKER,
+    "Exact final-output contract:",
+    `Runtime intake refused: the mandatory exact final-output guidance exceeds ${MAX_EXACT_FINAL_OUTPUT_LINE_CHARS} characters and cannot be carried verbatim. Shorten the directive and restart the task.`,
+    ...displayExactLines,
+    ...identityOnlyExecutionMap(executionLines).slice(0, 9),
+    "Stop this task until the exact final-output contract can be injected without mutation."
+  ].filter(Boolean).join("\n");
+  const preferred = compose(criticalLines, executionLines);
+  if (preferred.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return preferred;
+  // An ordinary contract can overflow because of navigation and repeated
+  // instructions. Preserve its actionable partitions before discarding hints.
+  const semanticProof = semanticCriticalProof(criticalLines);
+  const proofPreserving = compose(semanticProof, minimalExecutionMap(executionLines), true);
+  if (proofPreserving.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return proofPreserving;
+  const compactProofPreserving = [
+    ...prefix.slice(0, 1).map((line) => edgeBounded(line, 120)),
+    COMPACTION_MARKER,
+    ...semanticProof,
+    ...exactOutputLines,
+    ...displayExactLines,
+    ...identityOnlyExecutionMap(executionLines),
+    edgeBounded(lines[reuse], 120),
+    edgeBounded(finalGuidance, 120)
+  ].filter(Boolean).join("\n");
+  if (compactProofPreserving.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return compactProofPreserving;
+  const minimal = compose(minimalCriticalProof(criticalLines), minimalExecutionMap(executionLines), true);
+  if (minimal.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return minimal;
+  const guaranteed = [
+    ...prefix.slice(0, 2).map((line) => edgeBounded(line, 220)),
+    COMPACTION_MARKER,
+    ...minimalCriticalProof(criticalLines),
+    ...exactOutputLines,
+    ...displayExactLines,
+    ...minimalExecutionMap(executionLines),
+    edgeBounded(lines[reuse], 220),
+    edgeBounded(finalGuidance, 220)
+  ].filter(Boolean).join("\n");
+  if (guaranteed.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return guaranteed;
+  const final = [
+    ...prefix.slice(0, 1).map((line) => edgeBounded(line, 120)),
+    COMPACTION_MARKER,
+    ...minimalCriticalProof(criticalLines),
+    ...exactOutputLines,
+    ...displayExactLines,
+    ...identityOnlyExecutionMap(executionLines),
+    edgeBounded(lines[reuse], 120),
+    edgeBounded(finalGuidance, 120)
+  ].filter(Boolean).join("\n");
+  if (final.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return final;
+  const absoluteFallback = [
+    COMPACTION_MARKER,
+    ...minimalCriticalProof(criticalLines).slice(0, 2).map((line) => edgeBounded(line, 420)),
+    ...exactOutputLines,
+    ...displayExactLines,
+    ...identityOnlyExecutionMap(executionLines).slice(0, 9),
+    edgeBounded(lines[reuse], 100),
+    edgeBounded(finalGuidance, 100)
+  ].filter(Boolean).join("\n");
+  if (absoluteFallback.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return absoluteFallback;
+  return [
+    COMPACTION_MARKER,
+    ...exactOutputLines,
+    ...displayExactLines,
+    "Runtime intake refused: mandatory exact output and verifier guidance cannot fit the bounded provider intake without mutation. Shorten the configured contract and restart the task.",
+    "Stop this task; do not infer or reconstruct omitted acceptance details."
+  ].filter(Boolean).join("\n");
+}
+
+export function boundedRuntimeIntakeMessage(value: string): string {
+  const text = String(value ?? "").replace(/\r\n/g, "\n");
+  const structured = structuredCompaction(text);
+  if (text.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) {
+    return structured?.includes("Runtime intake refused:") ? structured : text;
+  }
+  return structured ?? legacyHeadTail(text);
+}

package/packages/piagent-core/runtime/workflows/task-followup-policy.ts

@@ -0,0 +1,163 @@
+import { normalizePathCandidate } from "../../extensions/policy-core.js";
+import { isCurrentWorkingTreeDigest } from "../../extensions/working-tree-digest.js";
+import { foldChangeIntent } from "./change-clarification.ts";
+import { classifyConditionalRepairIntent } from "./task-repair-intent.ts";
+
+export type PriorTaskScopeEvidence = {
+  trace?: { outcome?: string };
+  changedFiles?: unknown;
+  observedChangedFiles?: unknown;
+  contextManifest?: unknown;
+};
+
+type FollowupAcceptanceTask = PriorTaskScopeEvidence & {
+  taskRunId?: unknown;
+  sessionId?: unknown;
+  createdAt?: unknown;
+  changeMode?: unknown;
+  mutationPolicy?: unknown;
+  intakeMode?: unknown;
+  operatorRequest?: unknown;
+  summary?: unknown;
+  scope?: unknown;
+  baselineFileDigests?: unknown;
+  finalFileDigests?: unknown;
+};
+
+type FileDigestRecord = Record<string, string>;
+
+export function hasConditionalRepairIntent(text: string): boolean {
+  return classifyConditionalRepairIntent(text) !== "none";
+}
+
+function refersToEarlierImplementation(prompt: string): boolean {
+  const folded = foldChangeIntent(prompt);
+  const negatesPriorTurnReview = /\b(?:do not|don't|without|ignore|skip)\s+(?:review|verify|inspect|test|check|fix|continue|complete|apply|address)\b[\s\S]{0,200}\b(?:implementation|requirements?|obligations?|changes?|fix|logic|work)\s+(?:from|in)\s+(?:the\s+)?(?:earlier|previous|prior)\s+(?:turn|message)\b/i
+    .test(folded);
+  if (negatesPriorTurnReview) return false;
+  return [
+    /\b(?:current|existing|earlier|previous|prior|above)\s+(?:changes?|fix|implementation|logic|work)\b/i,
+    /\b(?:earlier|previous|prior|original|above)\s+(?:instructions?|obligations?|request|requirements?|task)\b/i,
+    /\b(?:changes?|fix|implementation|logic|work)\s+(?:above|earlier|previously|just\s+(?:completed|made|implemented))\b/i,
+    /\bwhat\s+(?:you|we)\s+just\s+(?:changed|fixed|implemented)\b/i,
+    /\b(?:review|verify|inspect|test|check|fix|continue|complete|apply|address)\b[\s\S]{0,200}\b(?:implementation|requirements?|obligations?|changes?|fix|logic|work)\s+(?:from|in)\s+(?:the\s+)?(?:earlier|previous|prior)\s+(?:turn|message)\b/i,
+    /\b(?:implementation|phan|logic|thay doi|yeu cau)\s+(?:hien tai|truoc do|vua roi|vua sua|vua lam|vua trien khai)\b/i,
+    /\b(?:vua sua|vua lam|vua trien khai|thay doi vua roi|thay doi truoc do)\b/i
+  ].some((pattern) => pattern.test(folded));
+}
+
+function fileDigestRecord(value: unknown): FileDigestRecord | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const entries = Object.entries(value);
+  const normalized = entries.map(([file, digest]) => [normalizePathCandidate(file), digest] as const);
+  if (normalized.some(([file, digest]) => !file || !isCurrentWorkingTreeDigest(digest))) return undefined;
+  if (new Set(normalized.map(([file]) => file)).size !== normalized.length) return undefined;
+  return Object.fromEntries(normalized);
+}
+
+function sameFileDigestRecord(left: FileDigestRecord, right: FileDigestRecord): boolean {
+  const leftEntries = Object.entries(left).sort(([a], [b]) => a.localeCompare(b));
+  const rightEntries = Object.entries(right).sort(([a], [b]) => a.localeCompare(b));
+  return leftEntries.length === rightEntries.length
+    && leftEntries.every(([file, digest], index) => file === rightEntries[index]?.[0] && digest === rightEntries[index]?.[1]);
+}
+
+function changedDigestFiles(baseline: FileDigestRecord, final: FileDigestRecord): string[] {
+  return [...new Set([...Object.keys(baseline), ...Object.keys(final)])]
+    .filter((file) => baseline[file] !== final[file])
+    .sort();
+}
+
+function normalizedFiles(value: unknown): string[] {
+  return [...new Set((Array.isArray(value) ? value : [])
+    .filter((file): file is string => typeof file === "string")
+    .map((file) => normalizePathCandidate(file))
+    .filter(Boolean))]
+    .sort();
+}
+
+function sameFiles(left: string[], right: string[]): boolean {
+  return left.length === right.length && left.every((file, index) => file === right[index]);
+}
+
+/**
+ * A zero-delta verification follow-up may prove the immediately preceding
+ * implementation without claiming those files as its own mutation. The
+ * lineage is intentionally strict: same session, adjacent completed source
+ * task, exact snapshot continuity, exact child focus, and an explicit
+ * reference to earlier work. Ambiguity returns only the task-local delta.
+ */
+export function completedFollowupAcceptanceEvidenceFiles(
+  task: FollowupAcceptanceTask,
+  tasks: FollowupAcceptanceTask[],
+  taskLocalDelta: string[],
+  currentFileDigests: unknown
+): string[] {
+  const local = normalizedFiles(taskLocalDelta);
+  const prompt = typeof task.operatorRequest === "string" && task.operatorRequest.trim()
+    ? task.operatorRequest
+    : typeof task.summary === "string" ? task.summary : "";
+  const current = fileDigestRecord(currentFileDigests);
+  const childBaseline = fileDigestRecord(task.baselineFileDigests);
+  const createdAt = typeof task.createdAt === "string" ? Date.parse(task.createdAt) : Number.NaN;
+  if (
+    task.intakeMode !== "runtime"
+    || task.changeMode !== "source-change"
+    || task.mutationPolicy !== "allowed"
+    || typeof task.taskRunId !== "string"
+    || typeof task.sessionId !== "string"
+    || !Number.isFinite(createdAt)
+    || !refersToEarlierImplementation(prompt)
+    || !current
+    || !childBaseline
+  ) return local;
+
+  const prior = tasks
+    .filter((candidate) => candidate.taskRunId !== task.taskRunId
+      && candidate.sessionId === task.sessionId
+      && typeof candidate.createdAt === "string"
+      && Number.isFinite(Date.parse(candidate.createdAt))
+      && Date.parse(candidate.createdAt) < createdAt)
+    .sort((left, right) => Date.parse(String(right.createdAt)) - Date.parse(String(left.createdAt)));
+  if (tasks.some((candidate) => candidate.taskRunId !== task.taskRunId
+    && candidate.sessionId === task.sessionId
+    && typeof candidate.createdAt === "string"
+    && Date.parse(candidate.createdAt) === createdAt)) return local;
+  const parent = prior[0];
+  if (!parent || (prior[1] && Date.parse(String(prior[1].createdAt)) === Date.parse(String(parent.createdAt)))) return local;
+  if (parent.trace?.outcome !== "completed" || parent.changeMode !== "source-change" || parent.mutationPolicy === "forbidden") return local;
+
+  const parentBaseline = fileDigestRecord(parent.baselineFileDigests);
+  const parentFinal = fileDigestRecord(parent.finalFileDigests);
+  if (!parentBaseline || !parentFinal || !sameFileDigestRecord(parentFinal, childBaseline)) return local;
+  const parentChanged = normalizedFiles(parent.changedFiles);
+  if (parentChanged.length === 0 || !sameFiles(parentChanged, changedDigestFiles(parentBaseline, parentFinal))) return local;
+
+  const exactFocus = new Set(normalizedFiles(task.scope).filter((file) => !/[?*\[\]{}]/.test(file)));
+  const inherited = parentChanged.filter((file) => exactFocus.has(file) && Object.hasOwn(current, file));
+  return [...new Set([...local, ...inherited])].sort();
+}
+
+export function completedFollowupScope(
+  prompt: string,
+  task: PriorTaskScopeEvidence | undefined,
+  plausiblePath: (value: string) => boolean
+): string[] {
+  if (!refersToEarlierImplementation(prompt) || task?.trace?.outcome !== "completed") return [];
+  const changed = [task.changedFiles, task.observedChangedFiles]
+    .flatMap((value) => Array.isArray(value) ? value : []);
+  const context = Array.isArray(task.contextManifest)
+    ? task.contextManifest.map((item) => item && typeof item === "object" ? (item as { path?: unknown }).path : undefined)
+    : [];
+  return [...new Set([...changed, ...context]
+    .filter((value): value is string => typeof value === "string")
+    .map((value) => normalizePathCandidate(value))
+    .filter((candidate): candidate is string => Boolean(
+      candidate
+      && candidate !== "."
+      && !candidate.startsWith(".pi/")
+      && !["AGENTS.md", "README.md", "REVIEW_GUIDELINES.md"].includes(candidate)
+      && plausiblePath(candidate)
+    )))]
+    .slice(0, 8);
+}