@lazyingart/agintiflow 0.20.275 → 0.20.276

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.275",
+  "version": "0.20.276",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/scripts/smoke-dynamic-step-budget.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import crypto from "node:crypto";
+import assertStrict from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs/promises";
 import net from "node:net";
@@ -30,6 +31,7 @@ import {
   buildFailedTestRecoveryPacket,
   buildKnownConstrainedPhasePlan,
   buildTaskOwnedCommitCommand,
+  changedGitStatusPaths,
   bindPatchContextRepairArguments,
   canonicalizeVerifiedArtifactCompletion,
   completedDeepResearchReuse,
@@ -52,6 +54,7 @@ import {
   mergeDurableGitEvidence,
   nextStepRuntimeConfig,
   patchContextScopeMismatchAttemptCount,
+  parseGitPorcelainStatus,
   pythonMainGuardOrderDefects,
   projectAcceptanceFromMarkdown,
   projectTestVerificationFinishBlock,
@@ -62,6 +65,7 @@ import {
   recordCanonicalGeneratedOutputProgress,
   recordAlreadyCommittedRepositoryRepair,
   recordProjectVerificationOutcome,
+  repositoryStateInspectionCommand,
   recordExactOutputProgress,
   recordStaticDiscoveryProgress,
   resetGoalScopedRuntimeState,
@@ -6495,6 +6499,101 @@ try {
     }),
     "plain task prose was mistaken for a repository-state gate without Git-status evidence"
   );
+  assertStrict.deepEqual(
+    parseGitPorcelainStatus(
+      " M build_deck.py\n D dist/deck.pdf\n?? output/deck.pptx\n?? output/slide 1.png\n"
+    ),
+    [
+      { status: " M", path: "build_deck.py" },
+      { status: " D", path: "dist/deck.pdf" },
+      { status: "??", path: "output/deck.pptx" },
+      { status: "??", path: "output/slide 1.png" },
+    ],
+    "bounded porcelain parsing lost a deletion, untracked output, or path containing spaces"
+  );
+  assertStrict.deepEqual(
+    changedGitStatusPaths(
+      {
+        entries: [
+          { status: " M", path: "unrelated.md", fingerprint: "same" },
+          { status: " M", path: "build_deck.py", fingerprint: "before" },
+        ],
+      },
+      {
+        entries: [
+          { status: " M", path: "unrelated.md", fingerprint: "same" },
+          { status: " M", path: "build_deck.py", fingerprint: "after" },
+          { status: " D", path: "dist/deck.pdf", fingerprint: "missing" },
+          { status: "??", path: "output/deck.pptx", fingerprint: "file:1" },
+        ],
+      }
+    ),
+    ["build_deck.py", "dist/deck.pdf", "output/deck.pptx"],
+    "command-bound Git capture included untouched pre-existing dirt or lost generated relocation paths"
+  );
+  const producerMutationState = {
+    goal: "Rebuild the generated presentation.",
+    meta: {
+      goalContract: { revision: 3, taskGoal: "Rebuild the generated presentation." },
+      activeExecutionContract: { revision: 3 },
+    },
+  };
+  recordProjectVerificationOutcome(
+    producerMutationState,
+    {
+      toolName: "run_command",
+      ok: true,
+      exitCode: 0,
+      args: { command: "python3 build_deck.py" },
+      commandPolicy: {
+        category: "toolchain",
+        writesWorkspace: true,
+        mayMutateProject: false,
+      },
+      projectMutationPaths: [
+        "build_deck.py",
+        "dist/deck.pdf",
+        "output/deck.pptx",
+      ],
+      stdout: "wrote output/deck.pptx",
+      stderr: "",
+    },
+    { commandCwd: workspace, taskProfile: "slides" }
+  );
+  assertStrict.deepEqual(
+    producerMutationState.meta.projectVerification.mutationHistory.at(-1).paths,
+    ["build_deck.py", "dist/deck.pdf", "output/deck.pptx"],
+    "a producer command discarded the exact Git paths captured across its execution boundary"
+  );
+  const inspectedRepositoryState = structuredClone(repositoryCleanGateFailure);
+  inspectedRepositoryState.meta.goalContract = { revision: 4 };
+  const repositoryInspectionResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: repositoryStateInspectionCommand() },
+    stdout: " D dist/deck.pdf\n?? output/deck.pptx\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    inspectedRepositoryState,
+    repositoryInspectionResult,
+    {
+      commandCwd: workspace,
+      taskProfile: "slides",
+      testFailureRepositoryStateRepair: true,
+      testFailureSignature: "repository-state-gate",
+    }
+  );
+  const inspectedRepositoryRuntime = nextStepRuntimeConfig(
+    { provider: "deepseek", taskProfile: "slides", commandCwd: workspace },
+    inspectedRepositoryState
+  );
+  assertStrict.deepEqual(
+    inspectedRepositoryRuntime.repositoryStateRepairObservedPaths,
+    ["dist/deck.pdf", "output/deck.pptx"],
+    "a bounded dirty-worktree inspection did not persist exact path candidates for the next turn"
+  );
   assert(
     unchangedFailedTestRerunBlock(
       repositoryCleanGateFailure,

package/scripts/smoke-progressive-tool-selection.js

@@ -2003,10 +2003,15 @@ sameNames(
   "repository-state repair exposed document mutation tools"
 );
 assert(
-  /stage and commit only those changes/i.test(
+  /exact bounded Git status inspection once/i.test(
     repositoryStateRepairTools.find((item) => item.function.name === "run_command")?.function.description || ""
   ),
-  "repository-state repair did not explain the bounded Git workflow"
+  "repository-state repair did not constrain the first recovery turn to one status inspection"
+);
+assertStrict.deepEqual(
+  repositoryStateRepairTools[0].function.parameters.properties.command.enum,
+  ["git status --porcelain=v1 --untracked-files=all"],
+  "repository-state repair exposed an open-ended shell instead of the exact status command"
 );
 const conciseRepositoryStateRepairRuntime = nextStepRuntimeConfig(
   { provider: "deepseek", taskProfile: "slides" },
@@ -2056,6 +2061,63 @@ sameNames(
   ["run_command", "finish"],
   "a concise clean-repository acceptance failure exposed content mutation tools"
 );
+const observedRepositoryState = {
+  meta: {
+    goalContract: { revision: 7 },
+    projectVerification: {
+      mutationRevision: 18,
+      repositoryStateInspection: {
+        version: 1,
+        mutationRevision: 18,
+        failureSignature: "observed-repository-state-gate",
+        command: "git status --porcelain=v1 --untracked-files=all",
+        entries: [
+          { status: " D", path: "dist/deck.pdf" },
+          { status: "??", path: "output/deck.pptx" },
+          { status: " M", path: "unrelated-notes.md" },
+        ],
+      },
+      testRuns: [{
+        command: "python acceptance.py --phase final",
+        mutationRevision: 18,
+        passed: false,
+        failureEvidenceVersion: 2,
+        failureSignature: "observed-repository-state-gate",
+        failureSummary: "acceptance failed: repository is not clean",
+      }],
+    },
+  },
+  messages: [],
+};
+const observedRepositoryRuntime = nextStepRuntimeConfig(
+  { provider: "deepseek", taskProfile: "slides" },
+  observedRepositoryState
+);
+assertStrict.deepEqual(
+  observedRepositoryRuntime.repositoryStateRepairObservedPaths,
+  ["dist/deck.pdf", "output/deck.pptx", "unrelated-notes.md"],
+  "the clean-state recovery phase lost exact paths from its bounded status observation"
+);
+const observedRepositoryTools = selectProgressiveTools(allTools, {
+  config: observedRepositoryRuntime,
+  goal: "Commit only the accepted presentation relocation.",
+  profile: "slides",
+});
+sameNames(
+  observedRepositoryTools,
+  ["commit_project_changes", "finish"],
+  "an observed clean-state recovery did not replace the shell with path-enumerated commit selection"
+);
+assertStrict.deepEqual(
+  observedRepositoryTools[0].function.parameters.required,
+  ["paths", "message"],
+  "the observed-path commit did not require explicit task-owned path selection"
+);
+assertStrict.deepEqual(
+  observedRepositoryTools[0].function.parameters.properties.paths.items.enum,
+  ["dist/deck.pdf", "output/deck.pptx", "unrelated-notes.md"],
+  "the observed-path commit broadened its candidate scope beyond the exact status result"
+);
 const taskOwnedRepositoryState = {
   meta: {
     goalContract: { revision: 6 },

package/src/agent-runner.js

@@ -2237,6 +2237,11 @@ export function buildKnownConstrainedPhasePlan(
       Array.isArray(runtimeConfig.repositoryStateRepairCommitPaths) &&
       runtimeConfig.repositoryStateRepairCommitPaths.length > 0
   );
+  const repositoryObservedCommitReady = Boolean(
+    repositoryStateRepair &&
+      Array.isArray(runtimeConfig.repositoryStateRepairObservedPaths) &&
+      runtimeConfig.repositoryStateRepairObservedPaths.length > 0
+  );
   const plan = repositoryStateRepair
     ? repositoryCommitReady
       ? [
@@ -2244,9 +2249,16 @@ export function buildKnownConstrainedPhasePlan(
           `2. Run the exact retained verification command after that commit: ${command}`,
           "3. Finish only after that exact command passes at the current mutation revision.",
         ].join("\n")
+      : repositoryObservedCommitReady
+        ? [
+            "1. Use the offered commit_project_changes tool once and select the complete task-owned subset from the exact observed dirty paths.",
+            "2. Include intended generated-output relocations and deletions, but exclude unrelated pre-existing work.",
+            `3. Run the exact retained verification command after that commit: ${command}`,
+            "4. Finish only after that exact command passes at the current mutation revision.",
+          ].join("\n")
       : [
-          "1. Inspect the current repository status and diff using the smallest read-only Git command needed.",
-          "2. Preserve task-owned work, stage and commit only those changes, and do not alter source content merely to make the worktree clean.",
+          "1. Run the one exact bounded Git status inspection offered by the runtime.",
+          "2. On the next turn, select and commit only task-owned paths from the runtime-enumerated candidates.",
           `3. Run the exact retained verification command after the repository state is clean: ${command}`,
           "4. Finish only after that exact command passes at the current mutation revision.",
         ].join("\n")
@@ -2294,7 +2306,9 @@ export function buildKnownConstrainedPhasePlan(
   const recoveryInstruction = repositoryStateRepair
     ? repositoryCommitReady
       ? "The current failure is only a repository-state acceptance gate. The runtime already knows the task-owned changed paths, so call commit_project_changes with a concise factual subject. Do not inspect again or invent another source edit."
-      : "The current failure is a repository-state acceptance gate, not a content defect. Use only the offered Git-capable command tool to inspect and cleanly commit task-owned changes, then run the exact retained verifier. Do not invent another source edit."
+      : repositoryObservedCommitReady
+        ? "The bounded status inspection is complete. Select the complete task-owned subset from the exact offered paths and call commit_project_changes once. Do not include unrelated work, inspect again, or invent another source edit."
+        : "The current failure is a repository-state acceptance gate, not a content defect. Run only the exact offered status inspection once. The runtime will convert its result into a bounded path-selection commit phase; do not start a status/diff loop or invent another source edit."
     : freshSourceMutation
       ? runtimeConfig.completionFreshMutationNeedsSourceRead === true
         ? "Completion was rejected because a fresh canonical source correction is still missing. Read one exact offered project file now; command, test, Git, and finish actions remain intentionally unavailable until the source is grounded and materially patched."
@@ -6055,6 +6069,15 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
           generatedArtifactProducer
         )
     );
+    const commandMutationPaths = Array.isArray(toolResult.projectMutationPaths)
+      ? [
+          ...new Set(
+            toolResult.projectMutationPaths
+              .map(safeTaskOwnedCommitPath)
+              .filter(Boolean)
+          ),
+        ].slice(0, 64)
+      : [];
     let requiredBatch = currentRequiredCommandBatch(verification, requiredCommands);
     const activeExecutionContract = state.meta?.activeExecutionContract;
     const activeTurnCommands =
@@ -6074,6 +6097,7 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
     let batchRequiredCommands = requiredBatch?.requiredCommands || requiredCommands;
     if (projectContentMutation) {
       delete state.meta.verifiedCompletionCandidate;
+      delete verification.repositoryStateInspection;
       if (
         requiredCommand &&
         batchRequiredCommands.includes(requiredCommand) &&
@@ -6108,7 +6132,7 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
         revision: verification.mutationRevision,
         at: now,
         toolName,
-        paths: [],
+        paths: commandMutationPaths,
         commandCategory: String(commandPolicy.category || "general-shell"),
       }, config);
       if (
@@ -6125,8 +6149,61 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
             generatedArtifactProducer,
           ]),
         ].slice(0, 12);
+        if (commandMutationPaths.length) {
+          activeExecutionContract.materialMutationPaths = [
+            ...new Set([
+              ...(Array.isArray(activeExecutionContract.materialMutationPaths)
+                ? activeExecutionContract.materialMutationPaths
+                : []),
+              ...commandMutationPaths,
+            ]),
+          ].slice(0, 24);
+        }
       }
     }
+    if (commandIncludesGitCommit(command)) {
+      delete verification.repositoryStateInspection;
+    }
+    if (
+      commandSucceeded &&
+      config.testFailureRepositoryStateRepair === true &&
+      projectCommandsEquivalent(
+        command,
+        REPOSITORY_STATE_INSPECTION_COMMAND,
+        config
+      )
+    ) {
+      const currentFailure = [...verification.testRuns]
+        .reverse()
+        .find(
+          (candidate) =>
+            candidate?.passed !== true &&
+            Number(candidate?.mutationRevision || 0) ===
+              verification.mutationRevision
+        );
+      const entries = (
+        Array.isArray(toolResult.repositoryStateStatusEntries)
+          ? toolResult.repositoryStateStatusEntries
+              .map((entry) => ({
+                status: String(entry?.status || ""),
+                path: safeTaskOwnedCommitPath(entry?.path),
+              }))
+              .filter((entry) => entry.path)
+          : parseGitPorcelainStatus(toolResult.stdout)
+      ).slice(0, 64);
+      verification.repositoryStateInspection = {
+        version: REPOSITORY_STATE_INSPECTION_VERSION,
+        mutationRevision: verification.mutationRevision,
+        failureSignature: String(
+          config.testFailureSignature || currentFailure?.failureSignature || ""
+        ),
+        command: REPOSITORY_STATE_INSPECTION_COMMAND,
+        entries,
+        at: now,
+      };
+      toolResult.repositoryStateInspection = verification.repositoryStateInspection;
+      toolResult.repositoryStateObservedPaths = entries.map((entry) => entry.path);
+    }
     const run = {
       command,
       at: now,
@@ -6400,6 +6477,158 @@ function safeTaskOwnedCommitPath(value = "") {
   return candidate;
 }
 
+const REPOSITORY_STATE_INSPECTION_VERSION = 1;
+const REPOSITORY_STATE_INSPECTION_COMMAND =
+  "git status --porcelain=v1 --untracked-files=all";
+
+export function repositoryStateInspectionCommand() {
+  return REPOSITORY_STATE_INSPECTION_COMMAND;
+}
+
+function decodeGitPorcelainPath(value = "") {
+  const raw = String(value || "").trimEnd();
+  if (!raw.startsWith('"')) return raw;
+  // Git's quoted-path grammar overlaps JSON for ordinary escaped paths. Octal
+  // escapes are deliberately rejected instead of guessing a path that may be
+  // staged later.
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return "";
+  }
+}
+
+export function parseGitPorcelainStatus(output = "") {
+  const entries = [];
+  const seen = new Set();
+  for (const line of String(output || "").replace(/\r/g, "").split("\n")) {
+    if (line.length < 4 || line[2] !== " ") continue;
+    const status = line.slice(0, 2);
+    if (!/^[ MADRCUT?!]{2}$/u.test(status)) continue;
+    const candidate = safeTaskOwnedCommitPath(
+      decodeGitPorcelainPath(line.slice(3))
+    );
+    if (!candidate || seen.has(candidate)) continue;
+    seen.add(candidate);
+    entries.push({ status, path: candidate });
+    if (entries.length >= 256) break;
+  }
+  return entries;
+}
+
+async function gitStatusPathFingerprint(commandCwd = "", relativePath = "") {
+  const root = path.resolve(commandCwd || process.cwd());
+  const candidate = safeTaskOwnedCommitPath(relativePath);
+  if (!candidate) return "";
+  const absolutePath = path.resolve(root, candidate);
+  const relative = path.relative(root, absolutePath);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return "";
+  try {
+    const stat = await fs.lstat(absolutePath);
+    return [
+      stat.isFile() ? "file" : stat.isDirectory() ? "directory" : stat.isSymbolicLink() ? "symlink" : "other",
+      Number(stat.mode || 0),
+      Number(stat.size || 0),
+      Number(stat.mtimeMs || 0),
+      Number(stat.ctimeMs || 0),
+      Number(stat.ino || 0),
+    ].join(":");
+  } catch (error) {
+    return error?.code === "ENOENT" ? "missing" : "unavailable";
+  }
+}
+
+async function captureGitWorktreeSnapshot(config = {}) {
+  const commandCwd = path.resolve(config.commandCwd || process.cwd());
+  const stdout = await new Promise((resolve) => {
+    let text = "";
+    let settled = false;
+    let timer;
+    const finish = (value = null) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(value);
+    };
+    const child = spawn(
+      "git",
+      ["status", "--porcelain=v1", "--untracked-files=all"],
+      {
+        cwd: commandCwd,
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true,
+      }
+    );
+    timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(null);
+    }, 5000);
+    child.stdout?.on("data", (chunk) => {
+      text += String(chunk || "");
+      if (text.length > 1024 * 1024) {
+        child.kill("SIGKILL");
+        finish(null);
+      }
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? text : null));
+  });
+  if (typeof stdout !== "string") return null;
+  const parsed = parseGitPorcelainStatus(stdout);
+  if (parsed.length >= 256) return null;
+  const entries = await Promise.all(
+    parsed.map(async (entry) => ({
+      ...entry,
+      fingerprint: await gitStatusPathFingerprint(commandCwd, entry.path),
+    }))
+  );
+  return { version: 1, entries };
+}
+
+export function changedGitStatusPaths(before = null, after = null) {
+  if (!before || !after || !Array.isArray(before.entries) || !Array.isArray(after.entries)) {
+    return [];
+  }
+  const prior = new Map(
+    before.entries
+      .filter((entry) => safeTaskOwnedCommitPath(entry?.path))
+      .map((entry) => [String(entry.path), entry])
+  );
+  return [
+    ...new Set(
+      after.entries
+        .filter((entry) => {
+          const candidate = safeTaskOwnedCommitPath(entry?.path);
+          if (!candidate) return false;
+          const previous = prior.get(candidate);
+          return Boolean(
+            !previous ||
+              String(previous.status || "") !== String(entry.status || "") ||
+              String(previous.fingerprint || "") !== String(entry.fingerprint || "")
+          );
+        })
+        .map((entry) => safeTaskOwnedCommitPath(entry.path))
+        .filter(Boolean)
+    ),
+  ].slice(0, 64);
+}
+
+function currentRepositoryStateInspection(verification = {}, testRun = {}) {
+  const inspection = verification.repositoryStateInspection;
+  if (
+    !inspection ||
+    Number(inspection.version || 0) !== REPOSITORY_STATE_INSPECTION_VERSION ||
+    Number(inspection.mutationRevision || 0) !==
+      Math.max(0, Number(verification.mutationRevision || 0)) ||
+    String(inspection.failureSignature || "") !==
+      String(testRun?.failureSignature || "") ||
+    !Array.isArray(inspection.entries)
+  ) {
+    return null;
+  }
+  return inspection;
+}
+
 function taskOwnedMutationPathsSinceLatestCommit(verification = {}) {
   const latestCommittedRevision = [...(verification.commandRuns || [])]
     .reverse()
@@ -7932,6 +8161,8 @@ function runCommandResultHasDurableProgress(toolResult = {}) {
   return Boolean(
     policyAllowsMutation ||
       policy.substantiveTest === true ||
+      (Array.isArray(toolResult.projectMutationPaths) &&
+        toolResult.projectMutationPaths.length > 0) ||
       (Array.isArray(toolResult.verifiedGeneratedOutputPaths) &&
         toolResult.verifiedGeneratedOutputPaths.length > 0)
   );
@@ -11944,6 +12175,29 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
       runtimeConfig.testFailureRepairPatchTargets = [];
       runtimeConfig.repositoryStateRepairCommitPaths =
         taskOwnedMutationPathsSinceLatestCommit(verification);
+      const repositoryInspection = currentRepositoryStateInspection(
+        verification,
+        retainedFailedTest
+      );
+      const observedEntries = runtimeConfig.repositoryStateRepairCommitPaths.length
+        ? []
+        : (repositoryInspection?.entries || [])
+            .map((entry) => ({
+              status: String(entry?.status || ""),
+              path: safeTaskOwnedCommitPath(entry?.path),
+            }))
+            .filter((entry) => entry.path)
+            .slice(0, 64);
+      runtimeConfig.repositoryStateRepairObservedEntries = observedEntries;
+      runtimeConfig.repositoryStateRepairObservedPaths = observedEntries.map(
+        (entry) => entry.path
+      );
+      runtimeConfig.repositoryStateRepairInspectionCommand =
+        REPOSITORY_STATE_INSPECTION_COMMAND;
+      runtimeConfig.repositoryStateRepairInspectionRequired = Boolean(
+        runtimeConfig.repositoryStateRepairCommitPaths.length === 0 &&
+          !repositoryInspection
+      );
     } else if (retainedRepositoryStateRepair) {
       delete runtimeConfig.completionFreshMutationRequired;
       delete runtimeConfig.completionFreshMutationRevision;
@@ -14258,20 +14512,45 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
       ? config.taskOwnedCommitPaths
       : []),
   ].map(safeTaskOwnedCommitPath).filter(Boolean);
+  const observedRepositoryCommitPaths = Array.isArray(
+    config.repositoryStateRepairObservedPaths
+  )
+    ? config.repositoryStateRepairObservedPaths
+        .map(safeTaskOwnedCommitPath)
+        .filter(Boolean)
+    : [];
+  const requestedObservedCommitPaths = Array.isArray(args.paths)
+    ? [...new Set(args.paths.map(safeTaskOwnedCommitPath).filter(Boolean))]
+    : [];
+  const observedCommitPathSet = new Set(observedRepositoryCommitPaths);
+  const selectedRepositoryCommitPaths = repositoryCommitPaths.length
+    ? repositoryCommitPaths
+    : requestedObservedCommitPaths.length > 0 &&
+        requestedObservedCommitPaths.length === args.paths?.length &&
+        requestedObservedCommitPaths.every((candidate) =>
+          observedCommitPathSet.has(candidate)
+        )
+      ? requestedObservedCommitPaths
+      : [];
   if (
     requestedToolName === "commit_project_changes" &&
-    repositoryCommitPaths.length > 0 &&
+    selectedRepositoryCommitPaths.length > 0 &&
     typeof args.message === "string" &&
     args.message.trim()
   ) {
-    const commitCommand = buildTaskOwnedCommitCommand(repositoryCommitPaths, args.message);
+    const commitCommand = buildTaskOwnedCommitCommand(
+      selectedRepositoryCommitPaths,
+      args.message
+    );
     if (commitCommand) {
       args = { command: commitCommand };
       toolName = "run_command";
       autoCorrection = {
         requestedToolName,
         toolName,
-        reason: "evidence-derived-task-owned-commit",
+        reason: repositoryCommitPaths.length
+          ? "evidence-derived-task-owned-commit"
+          : "observed-task-owned-commit-selection",
       };
     }
   }
@@ -15057,6 +15336,20 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         const policy = evaluateCommandPolicy(rawCommand, config);
         const observedCommand = normalizeProjectCommand(rawCommand);
         const observedInnerCommand = explicitExitProbeStatus(observedCommand).command;
+        const repositoryStateInspectionRequested = projectCommandsEquivalent(
+          observedCommand,
+          REPOSITORY_STATE_INSPECTION_COMMAND,
+          config
+        );
+        const generatedArtifactProducer = safeProjectProducerSegment(
+          observedCommand,
+          config
+        );
+        const captureMutationScope = Boolean(
+          policy.writesWorkspace ||
+            policy.mayMutateProject === true ||
+            generatedArtifactProducer
+        );
         const requiredCommands = effectiveRequiredProjectCommands(
           state,
           state.meta?.projectVerification || {},
@@ -15068,10 +15361,24 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         const exactOutputSnapshotsBefore = isRequiredCommand && policy.writesWorkspace
           ? await captureExactOutputSnapshots(state, config)
           : [];
+        const gitWorktreeBefore = captureMutationScope
+          ? await captureGitWorktreeSnapshot(config)
+          : null;
         if (config.useDockerSandbox) {
           await ensureDockerSandboxReady(config, observers);
         }
         const commandResult = await runShellCommand(rawCommand, config, policy);
+        const gitWorktreeAfter = captureMutationScope
+          ? await captureGitWorktreeSnapshot(config)
+          : null;
+        const repositoryStateInspectionSnapshot =
+          repositoryStateInspectionRequested && commandResult.ok !== false
+            ? await captureGitWorktreeSnapshot(config)
+            : null;
+        const projectMutationPaths = changedGitStatusPaths(
+          gitWorktreeBefore,
+          gitWorktreeAfter
+        );
         const generatedOutputPaths = commandResult.ok !== false
           ? await verifiedGeneratedOutputPaths(state, exactOutputSnapshotsBefore, config)
           : [];
@@ -15106,6 +15413,20 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
           ...(generatedOutputPaths.length
             ? { verifiedGeneratedOutputPaths: generatedOutputPaths }
             : {}),
+          ...(projectMutationPaths.length
+            ? { projectMutationPaths }
+            : {}),
+          ...(repositoryStateInspectionSnapshot
+            ? {
+                repositoryStateStatusEntries:
+                  repositoryStateInspectionSnapshot.entries.map(
+                    ({ status, path: statusPath }) => ({
+                      status,
+                      path: statusPath,
+                    })
+                  ),
+              }
+            : {}),
           ...commandResult,
           ...(permissionAdvice ? { permissionAdvice } : {}),
         };

package/src/progressive-tool-selection.js

@@ -1646,6 +1646,51 @@ function constrainRepositoryStateCommit(tool, paths = []) {
   };
 }
 
+function constrainObservedRepositoryStateCommit(tool, paths = []) {
+  if (!tool || !Array.isArray(paths) || paths.length === 0) return null;
+  const candidates = [...new Set(paths.map((item) => String(item || "").trim()).filter(Boolean))]
+    .slice(0, 64);
+  if (!candidates.length) return null;
+  return {
+    ...tool,
+    function: {
+      ...tool.function,
+      name: "commit_project_changes",
+      description: [
+        "Commit only the task-owned subset of the exact currently dirty paths discovered by the bounded repository inspection.",
+        "Select every intended task source, generated output, relocation deletion, or manifest involved in this task, and exclude unrelated pre-existing work.",
+        "The runtime rejects paths outside this exact observation and stages only the selected paths before creating one local commit.",
+        `Observed candidates: ${candidates.join(", ")}.`,
+      ].join(" "),
+      parameters: {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            minItems: 1,
+            maxItems: candidates.length,
+            uniqueItems: true,
+            items: {
+              type: "string",
+              enum: candidates,
+            },
+            description: "The complete task-owned subset of the exact observed dirty paths.",
+          },
+          message: {
+            type: "string",
+            minLength: 3,
+            maxLength: 120,
+            pattern: "^[^\\r\\n\\u0000]+$",
+            description: "A concise factual Git commit subject for the selected task-owned changes.",
+          },
+        },
+        required: ["paths", "message"],
+        additionalProperties: false,
+      },
+    },
+  };
+}
+
 function roundRobinToolNames(groups) {
   const names = [];
   const maxLength = Math.max(0, ...groups.map((group) => group.length));
@@ -2000,18 +2045,18 @@ export function selectProgressiveTools(
       if (commitProjectChanges) {
         return [commitProjectChanges, finish].filter(Boolean);
       }
-      const repositoryStateTool = runCommand
-        ? {
-            ...runCommand,
-            function: {
-              ...runCommand.function,
-              description: [
-                "Resolve the retained repository-state verification gate without changing task content merely to alter Git status.",
-                "Inspect status and diff, preserve intended task-owned changes, run appropriate checks, stage and commit only those changes, then rerun the exact retained verification command.",
-              ].join(" "),
-            },
-          }
-        : null;
+      const observedCommit = constrainObservedRepositoryStateCommit(
+        runCommand,
+        config.repositoryStateRepairObservedPaths
+      );
+      if (observedCommit) {
+        return [observedCommit, finish].filter(Boolean);
+      }
+      const repositoryStateTool = constrainRunCommand(
+        runCommand,
+        config.repositoryStateRepairInspectionCommand,
+        "Run this exact bounded Git status inspection once. The runtime records the current dirty paths and will offer a path-enumerated commit tool on the next turn; do not substitute a broader status/diff loop or alter project content."
+      );
       return [repositoryStateTool, finish].filter(Boolean);
     }
     const constrainedRepairPatch = annotateRequiredSymbolRepair(