@piagent/platform 1.5.5 → 1.6.1

package/packages/piagent-core/runtime/verification/exact-verifier-reuse.ts

@@ -0,0 +1,101 @@
+import crypto from "node:crypto";
+
+import type { TaskContract } from "../../extensions/guard-types.ts";
+import { extractShellCommandInput, normalizeShellCommandForPolicy } from "../../extensions/guard-shell-analysis.ts";
+import { commandMatchesVerifyPlan } from "../../extensions/runtime-evidence.js";
+import { passingVerifyCommandsForDigest } from "../../extensions/task-contract-view.js";
+import {
+  workingTreeSnapshot,
+  workingTreeSnapshotHasUnavailableEvidence
+} from "../../extensions/task-state.js";
+import { workingTreeEvidenceDigest } from "../../extensions/task-lifecycle.js";
+
+const SHELL_TOOLS = new Set(["bash", "shell", "exec"]);
+const REUSE_COMMAND = "printf '%s\\n' 'Piagent reused exact verifier evidence for the unchanged working tree; the verifier was not rerun.'";
+
+export type ExactVerifierReuseDecision = {
+  reused: boolean;
+  reasonCode: string;
+  commandDigest: string | null;
+  workingTreeDigest: string | null;
+};
+
+function messageText(message: unknown): string {
+  if (!message || typeof message !== "object") return "";
+  const content = (message as Record<string, any>).content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => block?.type === "text").map((block) => String(block.text ?? "")).join("\n");
+}
+
+function latestOperatorText(entries: unknown[]): string {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index] as Record<string, any> | undefined;
+    if (entry?.type === "message" && entry.message?.role === "user") return messageText(entry.message);
+  }
+  return "";
+}
+
+export function operatorExplicitlyRequestedVerifierExecution(entries: unknown[]): boolean {
+  const value = latestOperatorText(entries).normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+  return /\b(rerun|run again|test again|verify again|one more run|final run|last run)\b/.test(value)
+    || /\b(run|execute)\b[^\n]{0,80}\b(test|tests|verify|verifier|lint|typecheck|build)\b/.test(value)
+    || /\b(chay lai|test lai|verify lai|kiem tra lai|kiem thu lai|lan cuoi|chay (?:mot|1) lan nua)\b/.test(value)
+    || /\b(chay|thuc hien)\b[^\n]{0,80}\b(test|kiem thu|verify|verifier|lint|typecheck|build)\b/.test(value);
+}
+
+export function evaluateExactVerifierReuse(input: {
+  task?: TaskContract;
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  workingTreeDigest: string | null;
+  sessionEntries?: unknown[];
+}): ExactVerifierReuseDecision {
+  const no = (reasonCode: string): ExactVerifierReuseDecision => ({ reused: false, reasonCode, commandDigest: null, workingTreeDigest: input.workingTreeDigest });
+  const task = input.task;
+  if (!task || task.trace.outcome !== "pending" || task.changeMode !== "source-change") return no("no-pending-source-task");
+  if (!SHELL_TOOLS.has(input.toolName)) return no("not-shell-tool");
+  if (operatorExplicitlyRequestedVerifierExecution(input.sessionEntries ?? [])) return no("operator-requested-execution");
+  if (Object.hasOwn(input.toolInput, "args") && Array.isArray(input.toolInput.args) && input.toolInput.args.length > 0) return no("shell-args-present");
+  const extracted = extractShellCommandInput(input.toolInput);
+  if (!extracted.command || extracted.reason) return no("shell-command-unavailable");
+  const command = normalizeShellCommandForPolicy(extracted.command);
+  if (!commandMatchesVerifyPlan(command, task.verifyCommands)) return no("not-exact-verifier");
+  const passing = passingVerifyCommandsForDigest(task, input.workingTreeDigest);
+  const exactVerifier = task.verifyCommands.find((candidate) => (
+    passing.has(candidate.trim())
+    && commandMatchesVerifyPlan(command, [candidate])
+  ));
+  if (!exactVerifier) return no("current-tree-pass-missing");
+  const field = typeof input.toolInput.command === "string" ? "command" : typeof input.toolInput.cmd === "string" ? "cmd" : null;
+  if (!field) return no("mutable-command-field-missing");
+  input.toolInput[field] = REUSE_COMMAND;
+  return {
+    reused: true,
+    reasonCode: "current-tree-exact-verifier-reused",
+    commandDigest: crypto.createHash("sha256").update(exactVerifier.trim()).digest("hex"),
+    workingTreeDigest: input.workingTreeDigest
+  };
+}
+
+export function reuseCurrentTreeExactVerifier(input: {
+  cwd: string;
+  task?: TaskContract;
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  sessionEntries?: unknown[];
+}): ExactVerifierReuseDecision {
+  if (!input.task || !SHELL_TOOLS.has(input.toolName)) {
+    return { reused: false, reasonCode: "not-applicable", commandDigest: null, workingTreeDigest: null };
+  }
+  const extracted = extractShellCommandInput(input.toolInput);
+  const command = extracted.command ? normalizeShellCommandForPolicy(extracted.command) : "";
+  if (!command || !commandMatchesVerifyPlan(command, input.task.verifyCommands)) {
+    return { reused: false, reasonCode: "not-exact-verifier", commandDigest: null, workingTreeDigest: null };
+  }
+  const snapshot = workingTreeSnapshot(input.cwd) as Record<string, string>;
+  const workingTreeDigest = workingTreeSnapshotHasUnavailableEvidence(snapshot)
+    ? null
+    : workingTreeEvidenceDigest(snapshot);
+  return evaluateExactVerifierReuse({ ...input, workingTreeDigest });
+}

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

@@ -0,0 +1,164 @@
+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 minimalCriticalProof(lines: string[]): string[] {
+  if (lines.length === 0) return [];
+  const tags = [...new Set((lines.join("\n").match(/\[(?:criterion-[0-9]{2}|fallback)(?::[^\]]+)?\]/g) ?? []).map((tag) => {
+    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}]`;
+  }))].slice(0, 12);
+  return [
+    "Critical behavioral proof:",
+    `- ${tags.join("")} Prove every tagged observable clause with linked durable live assertions; the generic verifier alone is insufficient.`,
+    "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;
+  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-intake.ts

@@ -1,17 +1,41 @@
 import { classifyContextTask } from "../../extensions/context-engine.js";
 import { matchesAnyPath, matchesProtectedPath, normalizePathCandidate } from "../../extensions/policy-core.js";
 import type { ReviewLens } from "../../extensions/guard-types.js";
-import { LONG_INPUT_CHARS, RUNTIME_INTAKE_MESSAGE_MAX_CHARS } from "../runtime-limits.ts";
+import { LONG_INPUT_CHARS } from "../runtime-limits.ts";
+export { boundedRuntimeIntakeMessage } from "./runtime-intake-compaction.ts";
 
 const AUTO_INTAKE_MAX_PROMPT_CHARS = LONG_INPUT_CHARS;
 const AUTO_TASK_SUMMARY_CHARS = 700;
 const AUTO_ACCEPTANCE_CRITERION_CHARS = 600;
 const AUTO_ACCEPTANCE_CRITERIA_MAX = 12;
-const AUTO_INTAKE_CHANGE_INTENT = /\b(?:add|build|change|correct|create|fix|implement|modify|refactor|remove|rename|repair|replace|update|write|sua|them|doi|cap nhat|xoa|tao)\b/i;
+const AUTO_INTAKE_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 AUTO_INTAKE_READ_ONLY_LEAD = /^\s*\/?(?:analy[sz]e|audit|check|discuss|explain|inspect|plan|research|review|scout|summari[sz]e|why|how|can\s+(?:you|we)|kiem tra|nghien cuu|giai thich|danh gia)\b/i;
 const AUTO_INTAKE_MANUAL_RISK = /\b(?:credential|database|deploy|destructive|encryption|external provider|payment|permission|production|publish|secret|token rotation)\b/i;
 const AUTO_READ_ONLY_INTENT = /\b(?:analy[sz]e|audit|check|diagnos(?:e|is)|explain|inspect|investigate|plan|research|review|scout|summari[sz]e|triage|kiem tra|nghien cuu|giai thich|danh gia)\b/i;
-const AUTO_READ_ONLY_BOUNDARY = /\b(?:read-only|no edits?|do not edit(?: files?| source| project| repo)?|do not change (?:files?|source|project|repo)|do not mutate (?:files?|source|project|repo|workspace)|khong sua(?: file| source| project)?|khong edit(?: file| source| project)?|khong doi(?: file| source| project)?)\b/i;
+// Candidate wording is separated from the following qualifier. This keeps a
+// durable zero-delta instruction distinct from local path authority and from a
+// temporary "inspect first, edit later" instruction.
+const AUTO_NO_MUTATION_CANDIDATES = [
+  /\b(?:do not|don't|must not|never)\s+(?:edit|change|modify|mutate|touch|write(?:\s+to)?)\s+(?:(?:any|all|the|this|entire)\s+)?(?:files?|code|source(?:\s+files?)?|project(?:\s+files?)?|workspace|repo(?:sitory)?|anything)\b/i,
+  /\b(?:do not|don't|must not|never)\s+make\s+(?:any\s+)?(?:changes?|edits?|mutations?)(?:\s+to\s+(?:(?:any|all|the)\s+)?(?:files?|code|source(?:\s+files?)?|project(?:\s+files?)?|workspace|repo(?:sitory)?))?\b/i,
+  /\b(?:make\s+)?no\s+(?:(?:code|source|project|file|workspace|repo(?:sitory)?)\s+)?(?:changes?|edits?|mutations?)(?:\s+to\s+(?:(?:any|all|the)\s+)?(?:files?|code|source(?:\s+files?)?|project(?:\s+files?)?|workspace|repo(?:sitory)?))?\b/i,
+  /\bno\s+(?:project|source)\s+files?\s+(?:are\s+)?(?:changed|edited|modified|mutated)\b/i,
+  /\bwithout\s+(?:editing|changing|modifying|mutating|touching|writing(?:\s+to)?)\s+(?:(?:any|all|the)\s+)?(?:files?|code|source(?:\s+files?)?|project(?:\s+files?)?|workspace|repo(?:sitory)?)\b/i,
+  /\bleave\s+(?:(?:all|the|this|entire)\s+)?(?:files?|code|source|project|workspace|repo(?:sitory)?)\s+(?:fully\s+)?(?:unchanged|unmodified)\b/i,
+  /\b(?:zero\s+task\s+delta|mutation[- ]free)\b/i,
+  /\bkh(?:o|ô)ng\s+(?:s(?:u|ử)a|edit|thay\s+(?:d|đ)(?:o|ổ)i)\s+(?:b(?:a|ấ)t\s+k(?:y|ỳ)\s+)?(?:file|source|project|workspace|repo)\b/i
+];
+const AUTO_BOUNDARY_TAIL_PREFIX = "^(?:\\s|[,.;:!?()\\[\\]{}—–-])*(?:but\\s+)?";
+const AUTO_LOCAL_BOUNDARY_TAIL = new RegExp(`${AUTO_BOUNDARY_TAIL_PREFIX}(?:outside|beyond|under|within|inside|in|on|for(?!\\s+now\\b)|except(?:\\s+for)?|other\\s+than|apart\\s+from|to\\b|only\\s+(?:(?:edit|change|modify|mutate|touch|write)\\b|(?:in|under|within|outside)\\b|(?:[a-z0-9_.@*?-]+\\/))|ngo(?:a|à)i\\b|tr(?:u|ừ)\\b)`, "i");
+const AUTO_TEMPORARY_BOUNDARY_TAIL = new RegExp(`${AUTO_BOUNDARY_TAIL_PREFIX}(?:(?:not\\s+)?yet\\b|right\\s+now\\b|for\\s+now\\b|at\\s+(?:(?:this|the\\s+current)\\s+(?:step|stage|phase|time)|the\\s+moment)\\b|during\\s+(?:(?:this|the\\s+current)\\s+)?(?:step|stage|phase|planning)\\b|while\\b|unless\\b|until\\b|before\\b|hi(?:e|ệ)n\\s+t(?:a|ạ)i\\b|b(?:a|â)y\\s+gi(?:o|ờ)\\b)`, "i");
+const AUTO_GLOBAL_READ_ONLY_PATTERNS = [
+  /^\s*\/?read-only\s*(?:$|[.!?:;—–-])/im,
+  /^\s*\/?read-only\s+(?:task|run|session)\s*(?:$|[.!?:;—–-]|\b(?:to|for)\b)/im,
+  /^\s*\/?read-only\s+(?:assessment|review)\s*(?:$|[.!?:;—–-]|\b(?:of|for)\b)/im,
+  /\b(?:as|in)\s+(?:a\s+)?read-only\s+(?:mode|task|run|session|assessment|review)\b/i,
+  /\b(?:use|perform|conduct|run)\s+(?:a\s+)?read-only\s+(?:task|run|assessment|review)\b/i,
+  /\b(?:keep\s+)?(?:this\s+|the\s+)?(?:task|run|session|workspace|project|repo|repository)\s+(?:(?:is|must|should)\s+(?:be\s+|remain\s+)?|remain\s+)?read-only\b/i
+];
 const AUTO_EXECUTION_INTENT = /(?:\b(?:run|execute|execution|rerun|re-run|chay)\b.{0,80}\b(?:tests?|build|checks?|gates?|lint|typecheck|package|pack|verify|verification)\b|\b(?:npm|pnpm|yarn|bun)\s+(?:test|pack|run\s+(?:build|check|lint|typecheck|verify))\b)/i;
 
 export const AUTO_INTAKE_SNAPSHOT_PATTERNS = [
@@ -22,6 +46,27 @@ function uniqueStrings(values: string[]): string[] {
   return [...new Set(values)];
 }
 
+function noMutationBoundarySignals(text: string): { taskWide: boolean; temporary: boolean } {
+  let temporary = false;
+  for (const pattern of AUTO_NO_MUTATION_CANDIDATES) {
+    const matcher = new RegExp(pattern.source, `${pattern.flags}g`);
+    for (const match of text.matchAll(matcher)) {
+      const tail = text.slice((match.index ?? 0) + match[0].length, (match.index ?? 0) + match[0].length + 160);
+      if (AUTO_LOCAL_BOUNDARY_TAIL.test(tail)) continue;
+      if (AUTO_TEMPORARY_BOUNDARY_TAIL.test(tail)) {
+        temporary = true;
+        continue;
+      }
+      return { taskWide: true, temporary };
+    }
+  }
+  return { taskWide: false, temporary };
+}
+
+function hasGlobalReadOnlyBoundary(text: string): boolean {
+  return AUTO_GLOBAL_READ_ONLY_PATTERNS.some((pattern) => pattern.test(text));
+}
+
 const PLAUSIBLE_SCOPE_ROOT = /^(?:\.github|app|apps|bin|config|docs|examples|lib|logs|packages|pages|public|scripts|spec|src|test|tests|vendor|__tests__)(?:\/|$)/i;
 const PLAUSIBLE_SCOPE_FILE = /(?:^|\/)(?:\.[^/]+|[^/]+\.(?:bash|c|cc|cjs|cpp|css|csv|env|go|graphql|gql|h|hpp|html|java|js|json|jsx|kt|kts|md|mdx|mjs|php|proto|py|rb|rs|scss|sh|sql|svg|swift|toml|ts|tsx|txt|xml|yaml|yml))$/i;
 
@@ -37,18 +82,11 @@ export function automaticTaskSummary(prompt: string): string {
   return String(prompt ?? "").replace(/\s+/g, " ").trim().slice(0, AUTO_TASK_SUMMARY_CHARS);
 }
 
-export function boundedRuntimeIntakeMessage(value: string): string {
-  const text = String(value ?? "").replace(/\r\n/g, "\n");
-  if (text.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return text;
-  const marker = "\n\n[Piagent intake guidance compacted; the complete operator request and durable Task Contract remain authoritative.]\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()}`;
-}
-
 export function automaticTaskIntakeEligible(prompt: string, readProtectedPaths: string[]): boolean {
   const text = String(prompt ?? "").trim();
   if (!text || text.length > AUTO_INTAKE_MAX_PROMPT_CHARS) return false;
+  const noMutationBoundary = noMutationBoundarySignals(text);
+  if (noMutationBoundary.temporary && !noMutationBoundary.taskWide) return false;
   const signal = classifyContextTask(text);
   if (AUTO_EXECUTION_INTENT.test(text)) {
     if (/\bpiagent_task_start\b/i.test(text)) return false;
@@ -65,8 +103,9 @@ export function automaticReadOnlyTaskIntakeEligible(prompt: string, readProtecte
   if (!text || text.length > AUTO_INTAKE_MAX_PROMPT_CHARS) return false;
   const signal = classifyContextTask(text);
   if (signal.workflow === "usage" || signal.workflow === "permission" || signal.workflow === "context") return false;
-  if (!AUTO_READ_ONLY_INTENT.test(text) && !AUTO_READ_ONLY_BOUNDARY.test(text)) return false;
-  if (AUTO_INTAKE_CHANGE_INTENT.test(text) && !AUTO_READ_ONLY_BOUNDARY.test(text)) return false;
+  const readOnlyBoundary = noMutationBoundarySignals(text).taskWide || hasGlobalReadOnlyBoundary(text);
+  if (!AUTO_READ_ONLY_INTENT.test(text) && !readOnlyBoundary) return false;
+  if (AUTO_INTAKE_CHANGE_INTENT.test(text) && !readOnlyBoundary) return false;
   if (/\bpiagent_task_start\b/i.test(text)) return false;
   return !signal.paths.some((candidate) => matchesProtectedPath(candidate, readProtectedPaths));
 }
@@ -77,47 +116,171 @@ export function automaticTaskIntakeMode(prompt: string, readProtectedPaths: stri
   return undefined;
 }
 
+export function automaticTaskMutationPolicy(
+  prompt: string,
+  changeMode: "source-change" | "read-only"
+): "required" | "forbidden" {
+  const text = String(prompt ?? "");
+  // A feature can intentionally become read-only while the implementation
+  // still requires source changes. Only a task-wide boundary may suppress
+  // mutation; incidental domain wording such as "list/detail read-only" must
+  // never convert a delegated implementation into a zero-delta task.
+  return changeMode === "read-only"
+    || noMutationBoundarySignals(text).taskWide
+    || hasGlobalReadOnlyBoundary(text)
+    ? "forbidden"
+    : "required";
+}
+
 export function automaticTaskRiskLane(prompt: string): "tiny" | "normal" {
   return classifyContextTask(prompt).lane === "tiny" ? "tiny" : "normal";
 }
 
+const ATOMIC_CLAUSE_LEAD = /^(?:accept|add|build|change|correct|create|do not|emit|ensure|fail|fix|handle|implement|invalid|missing|modify|must|never|parse|preserve|reject|repair|return|support|throw|treat|update|verify|without)\b/i;
+
+function topLevelImperativeClauses(value: string): string[] {
+  const clauses: string[] = [];
+  let current = "", quote = "", round = 0, square = 0, curly = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index], previous = value[index - 1] ?? "", next = value[index + 1] ?? "";
+    if (quote) {
+      current += character;
+      if (character === quote && previous !== "\\") quote = "";
+      continue;
+    }
+    const apostropheInsideWord = character === "'" && /[\p{L}\p{N}]/u.test(previous) && /[\p{L}\p{N}]/u.test(next);
+    if ((character === "`" || character === '"' || character === "'") && !apostropheInsideWord) {
+      quote = character; current += character;
+      continue;
+    }
+    if (character === "(") round += 1;
+    else if (character === ")") round = Math.max(0, round - 1);
+    else if (character === "[") square += 1;
+    else if (character === "]") square = Math.max(0, square - 1);
+    else if (character === "{") curly += 1;
+    else if (character === "}") curly = Math.max(0, curly - 1);
+    if (character === ";" && round === 0 && square === 0 && curly === 0 && ATOMIC_CLAUSE_LEAD.test(value.slice(index + 1).trimStart())) {
+      if (current.trim().length >= 8) clauses.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  if (current.trim()) clauses.push(current.trim());
+  return clauses;
+}
+
 function splitAcceptanceCriterion(value: string): string[] {
   const normalized = value.replace(/^\s*(?:[-*+] |\d+[.)]\s+)/, "").replace(/\s+/g, " ").trim();
   if (!normalized || normalized.length < 8) return [];
   const label = normalized.match(/^(\[[^\]\n]{1,40}\])\s+/)?.[1] ?? "";
-  let remaining = label ? normalized.slice(label.length).trim() : normalized;
+  const body = label ? normalized.slice(label.length).trim() : normalized;
   const prefix = label ? `${label} ` : "";
   const available = AUTO_ACCEPTANCE_CRITERION_CHARS - prefix.length;
   const fragments: string[] = [];
-  while (remaining.length > available) {
-    const window = remaining.slice(0, available + 1);
-    const sentence = [...window.matchAll(/[.!?;:]\s+/g)].at(-1);
-    const clause = [...window.matchAll(/,\s+/g)].at(-1);
-    const whitespace = window.lastIndexOf(" ");
-    const preferred = sentence && sentence.index! + sentence[0].trimEnd().length >= Math.floor(available / 3)
-      ? sentence.index! + sentence[0].trimEnd().length
-      : clause && clause.index! + 1 >= Math.floor(available / 2)
-        ? clause.index! + 1
-        : whitespace;
-    const cut = preferred > 0 ? preferred : available;
-    fragments.push(`${prefix}${remaining.slice(0, cut).trim()}`);
-    remaining = remaining.slice(cut).trim();
+  const units = topLevelImperativeClauses(body)
+    .flatMap((clause) => clause.split(/(?<=[.!?])\s+(?=(?:[`"'([{]|[\p{Lu}\p{N}]|(?:do|must|never|verify)\b))/u))
+    .filter((item) => item.trim().length >= 8);
+  for (const unit of units) {
+    let remaining = unit.trim();
+    while (remaining.length > available) {
+      const window = remaining.slice(0, available + 1);
+      const sentence = [...window.matchAll(/[.!?;:]\s+/g)].at(-1);
+      const clause = [...window.matchAll(/,\s+/g)].at(-1);
+      const whitespace = window.lastIndexOf(" ");
+      const preferred = sentence && sentence.index! + sentence[0].trimEnd().length >= Math.floor(available / 3)
+        ? sentence.index! + sentence[0].trimEnd().length
+        : clause && clause.index! + 1 >= Math.floor(available / 2)
+          ? clause.index! + 1
+          : whitespace;
+      const cut = preferred > 0 ? preferred : available;
+      fragments.push(`${prefix}${remaining.slice(0, cut).trim()}`);
+      remaining = remaining.slice(cut).trim();
+    }
+    if (remaining) fragments.push(`${prefix}${remaining}`);
   }
-  if (remaining) fragments.push(`${prefix}${remaining}`);
   return fragments;
 }
 
-export function automaticAcceptanceCriteria(
-  prompt: string,
-  changeMode: "source-change" | "read-only" = "source-change"
-): string[] {
+function isPathOnlyCriterion(value: string): boolean {
+  const normalized = value
+    .replace(/^\s*(?:[-*+] |\d+[.)]\s+)/, "")
+    .replace(/^`|`$/g, "")
+    .trim();
+  return /^(?:[A-Za-z0-9_@.-]+\/)+[A-Za-z0-9_@.-]+$/.test(normalized);
+}
+
+function evenlySpacedCriteria(values: string[], limit: number): string[] {
+  if (limit <= 0) return [];
+  if (values.length <= limit) return values;
+  if (limit === 1) return [values[values.length - 1]];
+  return Array.from({ length: limit }, (_entry, index) => (
+    values[Math.round((index * (values.length - 1)) / (limit - 1))]
+  ));
+}
+
+function boundedAcceptanceCriteria(values: string[], limit: number): string[] {
+  if (limit <= 0 || values.length === 0) return [];
+  if (values.length <= limit) return values;
+  const highSignal = /\b(?:do not|fail(?:s|ed)?(?:[-\s]+)closed|invalid|missing|must|never|reject(?:s|ed|ion)?|throws?|typeerror|without mutat(?:e|ing)|unchanged)\b/i;
+  const required = values.filter((criterion) => highSignal.test(criterion));
+  const selectedRequired = evenlySpacedCriteria(required, Math.min(limit, required.length));
+  const selected = new Set(selectedRequired);
+  const remaining = values.filter((criterion) => !selected.has(criterion));
+  for (const criterion of evenlySpacedCriteria(remaining, limit - selected.size)) selected.add(criterion);
+  return values.filter((criterion) => selected.has(criterion));
+}
+
+type AtomicCriterionGroup = { criteria: string[]; index: number };
+
+function atomicCriterionScore(value: string): number {
+  const weighted = [
+    [/(?:\bdo not\b|\bdoes not\b|\bcannot\b|\bnever\b|\binvalid\b|\breject|\bthrow|\bfail(?:s|ed)?[- ]closed\b)/i, 8],
+    [/(?:\bidentical\b|\breplay|\bcanonical|\bidempoten)/i, 6],
+    [/(?:\bstale\b|changed owner|inclusive boundary)/i, 5],
+    [/\bexact(?:ly)?\b/i, 4],
+    [/(?:\bnon-finite\b|\bnon-json\b|\bmutat|\bdigest\b|\breturn|\boutput\b)/i, 3]
+  ] as const;
+  return weighted.reduce((score, [pattern, weight]) => score + (pattern.test(value) ? weight : 0), 0);
+}
+
+function atomicCoverageCriteria(groups: AtomicCriterionGroup[], limit: number): string[] {
+  const candidates = groups.flatMap((group) => group.criteria.map((criterion, clause) => ({ criterion, group: group.index, clause })));
+  if (candidates.length <= limit) return uniqueStrings(candidates.map((item) => item.criterion));
+  const representatives = groups.filter((group) => group.criteria.length > 0).map((group) => group.criteria.at(-1)!);
+  const selected = new Set(boundedAcceptanceCriteria(representatives, Math.min(limit, representatives.length)));
+  const ranked = candidates.filter((item) => !selected.has(item.criterion)).sort((left, right) => (
+    atomicCriterionScore(right.criterion) - atomicCriterionScore(left.criterion)
+    || left.group - right.group
+    || left.clause - right.clause
+  ));
+  for (const item of ranked) {
+    if (selected.size < limit) { selected.add(item.criterion); continue; }
+    if (groups.length <= limit || atomicCriterionScore(item.criterion) === 0) continue;
+    const sameGroupAlreadyCovered = candidates.some((candidate) => candidate.group === item.group && selected.has(candidate.criterion));
+    if (!sameGroupAlreadyCovered) continue;
+    const removable = candidates
+      .filter((candidate) => selected.has(candidate.criterion) && candidate.group !== item.group)
+      .sort((left, right) => (
+        Number(/^\[/.test(left.criterion)) - Number(/^\[/.test(right.criterion))
+        || atomicCriterionScore(left.criterion) - atomicCriterionScore(right.criterion)
+        || right.group - left.group
+      ))
+      .find((candidate) => atomicCriterionScore(candidate.criterion) < atomicCriterionScore(item.criterion));
+    if (removable) { selected.delete(removable.criterion); selected.add(item.criterion); }
+  }
+  return uniqueStrings(candidates.filter((item) => selected.has(item.criterion)).map((item) => item.criterion)).slice(0, limit);
+}
+
+export function automaticAcceptanceCriteria(prompt: string, changeMode: "source-change" | "read-only" = "source-change"): string[] {
   const lines = String(prompt ?? "").split(/\r?\n/);
-  const criteria: string[] = [];
-  const obligation = /\b(?:add|change only|do not|ensure|exactly|invalid|must|never|preserve|reject|return|throw|without)\b/i;
+  const criterionGroups: AtomicCriterionGroup[] = [];
+  const obligation = /\b(?:accept|add|build|change|change only|correct|create|do not|emits?|ensure|exactly|fail(?:s|ed)?(?:[-\s]+)closed|fix|handle|implement|invalid|missing|modify|must|never|parse|preserve|reject|repair|returns?|support|throw|treat|update|without)\b/i;
   let current = "";
   let currentIsBullet = false;
   const push = (value: string) => {
-    criteria.push(...splitAcceptanceCriterion(value));
+    if (isPathOnlyCriterion(value)) return;
+    criterionGroups.push({ criteria: splitAcceptanceCriterion(value), index: criterionGroups.length });
   };
   const flush = () => {
     if (current && (currentIsBullet || obligation.test(current))) push(current);
@@ -141,8 +304,14 @@ export function automaticAcceptanceCriteria(
   flush();
   const generic = changeMode === "read-only"
     ? ["No project files are changed.", "The final response addresses the requested diagnostic result."]
-    : ["Changes stay within the runtime-derived task scope.", "The configured verification command passes after the final mutation."];
-  return uniqueStrings([...criteria, ...generic]).slice(0, AUTO_ACCEPTANCE_CRITERIA_MAX);
+    : ["The configured verification command passes after the final mutation."];
+  const groupCount = criterionGroups.filter((group) => group.criteria.length > 0).length;
+  const reservedGeneric = Math.min(generic.length, Math.max(0, AUTO_ACCEPTANCE_CRITERIA_MAX - groupCount));
+  const uniqueCriteria = atomicCoverageCriteria(criterionGroups, AUTO_ACCEPTANCE_CRITERIA_MAX - reservedGeneric);
+  const selected = boundedAcceptanceCriteria(uniqueCriteria, AUTO_ACCEPTANCE_CRITERIA_MAX);
+  if (selected.length === AUTO_ACCEPTANCE_CRITERIA_MAX) return selected;
+  const missingGeneric = generic.filter((criterion) => !selected.includes(criterion));
+  return [...selected, ...missingGeneric].slice(0, AUTO_ACCEPTANCE_CRITERIA_MAX);
 }
 
 export function manualTaskIntakeEligible(prompt: string, readProtectedPaths: string[]): boolean {