@lazyingart/agintiflow 0.20.300 → 0.20.301

package/docs/supervision-campaign-ledger.md

@@ -56,6 +56,22 @@ in `evidence_json` and `events`.
 
 ## Current Campaign Findings
 
+### Established media-chain reuse and permission boundaries
+
+`media-chain-readiness-020` passed after reconciling a stale machine-ledger
+`running` row with the retained session's terminal `session.finished` event.
+AgInTi inspected the existing Musia, LabCanvas, LALACHAN, Xiaoyunque, and
+LazyEdit entry points and produced `media-routine-readiness.md` without
+generating media, starting or focusing a browser, uploading, copying to
+Nutstore, creating a remote job, or publishing.
+
+The independent acceptance contract verified every required source-grounded
+entry, 16 read-only command results, zero forbidden external-action tools, and
+zero long jobs. The resulting contract keeps four permissions independent:
+reviewed-song generation, music-video generation, LazyEdit processing, and
+public platform publication. An earlier stage or old context cannot authorize a
+later irreversible stage.
+
 ### Retained dependencies, linked-worktree commits, and clean visual evidence
 
 `data-analysis-retained-dependencies-060` resumed the original DeepSeek session

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.300",
+  "version": "0.20.301",
   "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-model-roles.js

@@ -31,14 +31,23 @@ import {
 } from "../src/scs-controller.js";
 import {
   buildScsEvidenceLedger,
+  buildTmuxGitIntent,
   deriveScsTaskContract,
   evaluateScsEvidence,
   gitActionsSatisfyContract,
   inferSuccessfulGitActionsFromCommandResult,
+  inferSuccessfulGitActionsFromTmuxCapture,
+  reconcileTmuxGitEvidenceEvents,
 } from "../src/scs-evidence.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { classifyGoalIntent, isDirectAnswerIntent } from "../src/goal-intent.js";
 import { languageWriterDefaults } from "../src/writing-specialist.js";
+import {
+  attachVerifiedTmuxGitEvidence,
+  recordDurableEvidenceCategories,
+  rememberTmuxGitIntent,
+  sanitizeToolResult,
+} from "../src/agent-runner.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 for (const key of [
@@ -1117,6 +1126,195 @@ assert(
     !committedEvaluation.missing.some((item) => item.category === "git"),
   "a successful git commit did not satisfy the explicit git requirement"
 );
+const tmuxCommitCommand = [
+  'echo "===AGINTI_REVIEW_COMMIT_START==="',
+  'git add README.md && git commit -m "finish review"',
+  'echo "===COMMIT_EXIT:$?==="',
+].join(" ; ");
+const tmuxCommitIntent = buildTmuxGitIntent(tmuxCommitCommand);
+assert(
+  tmuxCommitIntent?.actions.includes("commit") &&
+    tmuxCommitIntent.markers.includes("===AGINTI_REVIEW_COMMIT_START==="),
+  "a marked workspace tmux commit command did not retain bounded Git intent"
+);
+const tmuxCommitCapture = {
+  ok: true,
+  toolName: "tmux_capture_pane",
+  target: "review:0.0",
+  content: [
+    "===AGINTI_REVIEW_COMMIT_START===",
+    "[review abc1234] finish review",
+    " 1 file changed, 2 insertions(+)",
+    "===COMMIT_EXIT:0===",
+  ].join("\n"),
+};
+const verifiedTmuxCommit = inferSuccessfulGitActionsFromTmuxCapture(
+  tmuxCommitIntent,
+  tmuxCommitCapture
+);
+assert(
+  verifiedTmuxCommit.length === 1 && verifiedTmuxCommit[0] === "commit",
+  "a fresh marked tmux capture did not prove its successful Git commit"
+);
+assert(
+  inferSuccessfulGitActionsFromTmuxCapture(tmuxCommitIntent, {
+    ...tmuxCommitCapture,
+    content: tmuxCommitCapture.content.replace("COMMIT_EXIT:0", "COMMIT_EXIT:1"),
+  }).length === 0,
+  "a nonzero tmux commit exit marker was accepted as Git evidence"
+);
+assert(
+  inferSuccessfulGitActionsFromTmuxCapture(tmuxCommitIntent, {
+    ...tmuxCommitCapture,
+    content: tmuxCommitCapture.content.replace("AGINTI_REVIEW_COMMIT_START", "STALE_COMMIT_START"),
+  }).length === 0,
+  "a tmux capture without the current command marker was accepted as fresh Git evidence"
+);
+const tmuxEvidenceState = {
+  meta: {
+    goalContract: { revision: 2 },
+    projectVerification: { mutationRevision: 3 },
+  },
+};
+const tmuxSendResult = {
+  ok: true,
+  toolName: "tmux_send_keys",
+  target: "review:0.0",
+  sentTextSha256: "a".repeat(64),
+};
+rememberTmuxGitIntent(
+  tmuxEvidenceState,
+  { text: tmuxCommitCommand },
+  tmuxSendResult
+);
+const trackedTmuxCapture = { ...tmuxCommitCapture };
+assert(
+  attachVerifiedTmuxGitEvidence(tmuxEvidenceState, trackedTmuxCapture).includes("commit"),
+  "the same-pane tmux capture did not close the pending Git intent"
+);
+recordDurableEvidenceCategories(tmuxEvidenceState, trackedTmuxCapture);
+assert(
+  tmuxEvidenceState.meta.durableGitEvidence.some(
+    (item) =>
+      item.action === "commit" &&
+      item.goalRevision === 2 &&
+      item.mutationRevision === 3
+  ),
+  "verified tmux commit evidence was not retained at the active goal and mutation revision"
+);
+assert(
+  !tmuxEvidenceState.meta.pendingTmuxGitEvidence["review:0.0"],
+  "verified tmux Git intent remained pending after same-pane capture"
+);
+const tmuxCommitLedger = buildScsEvidenceLedger({
+  context: {
+    events: [
+      {
+        type: "tool.completed",
+        data: {
+          ...tmuxCommitCapture,
+          verifiedGitActions: verifiedTmuxCommit,
+          verifiedGitGoalRevision: 1,
+          verifiedGitMutationRevision: 1,
+        },
+      },
+    ],
+  },
+});
+assert(
+  evaluateScsEvidence(commitContract, tmuxCommitLedger).missingGitActions.length === 0,
+  "verified tmux commit evidence did not satisfy the completion contract"
+);
+const historicalTmuxEvents = [
+  { type: "goal.updated", data: { revision: 2 } },
+  {
+    type: "tool.completed",
+    data: {
+      ok: true,
+      toolName: "run_command",
+      goalRevision: 2,
+      projectMutationRevision: 3,
+      args: { command: "git status --short" },
+      exitCode: 0,
+      stdout: " M README.md",
+    },
+  },
+  {
+    type: "tool.started",
+    data: {
+      toolName: "tmux_send_keys",
+      args: { target: "review:0.0", text: tmuxCommitCommand },
+    },
+  },
+  {
+    type: "tool.completed",
+    data: {
+      ...tmuxSendResult,
+      target: "review:0.0",
+    },
+  },
+  {
+    type: "tool.completed",
+    data: {
+      ...tmuxCommitCapture,
+      content: undefined,
+      contentPreview: tmuxCommitCapture.content,
+    },
+  },
+];
+const reconciledHistoricalEvents = reconcileTmuxGitEvidenceEvents(
+  historicalTmuxEvents
+);
+assert(
+  reconciledHistoricalEvents.at(-1)?.data?.verifiedGitActions?.includes("commit") &&
+    reconciledHistoricalEvents.at(-1)?.data?.verifiedGitGoalRevision === 2 &&
+    reconciledHistoricalEvents.at(-1)?.data?.verifiedGitMutationRevision === 3,
+  "restart reconciliation did not recover revision-scoped tmux commit evidence"
+);
+assert(
+  evaluateScsEvidence(
+    commitContract,
+    buildScsEvidenceLedger({ context: { events: historicalTmuxEvents } })
+  ).missingGitActions.length === 0,
+  "historical marked tmux commit events did not satisfy the completion contract"
+);
+for (const invalidEvents of [
+  historicalTmuxEvents.map((event, index) =>
+    index === 3 ? { ...event, type: "tool.failed", data: { ...event.data, ok: false } } : event
+  ),
+  historicalTmuxEvents.map((event, index) =>
+    index === 4 ? { ...event, data: { ...event.data, target: "other:0.0" } } : event
+  ),
+  historicalTmuxEvents.map((event, index) =>
+    index === 4
+      ? {
+          ...event,
+          data: {
+            ...event.data,
+            contentPreview: event.data.contentPreview.replace("COMMIT_EXIT:0", "COMMIT_EXIT:1"),
+          },
+        }
+      : event
+  ),
+]) {
+  assert(
+    !reconcileTmuxGitEvidenceEvents(invalidEvents).at(-1)?.data?.verifiedGitActions,
+    "failed, cross-pane, or nonzero historical tmux evidence was accepted"
+  );
+}
+const sanitizedLongTmuxCapture = sanitizeToolResult({
+  ...tmuxCommitCapture,
+  content: `${"old scrollback\n".repeat(200)}${tmuxCommitCapture.content}`,
+});
+assert(
+  sanitizedLongTmuxCapture.contentTruncated === true &&
+    sanitizedLongTmuxCapture.contentTail.includes("===COMMIT_EXIT:0===") &&
+    inferSuccessfulGitActionsFromTmuxCapture(
+      tmuxCommitIntent,
+      sanitizedLongTmuxCapture
+    ).includes("commit"),
+  "truncated tmux evidence did not preserve and verify its bounded content tail"
+);
 const recoveredCommitActions = inferSuccessfulGitActionsFromCommandResult({
   ok: true,
   exitCode: 0,

package/src/agent-runner.js

@@ -147,9 +147,11 @@ import {
   finishResultClaimsBlocker,
   finishResultClaimsIncompleteWork,
   hasScsBlockerEvidence,
+  buildTmuxGitIntent,
   inferAuthoritativeReadOnlyRoutine,
   inferGitActionsFromCommand,
   inferSuccessfulGitActionsFromCommandResult,
+  inferSuccessfulGitActionsFromTmuxCapture,
   isResponseOnlyEvidenceScope,
   successfulGitCommitProvesFileMutation,
   isObservationalGitAction,
@@ -9788,6 +9790,9 @@ export function sanitizeToolResult(result) {
       safeResult.contentTruncated = false;
     } else {
       safeResult.contentPreview = safeResult.content.slice(0, TOOL_RESULT_CONTENT_PREVIEW_CHARS);
+      if (safeResult.toolName === "tmux_capture_pane") {
+        safeResult.contentTail = safeResult.content.slice(-TOOL_RESULT_CONTENT_PREVIEW_CHARS);
+      }
       safeResult.contentTruncated = true;
       delete safeResult.content;
     }
@@ -13778,7 +13783,55 @@ export function mergeDurableGitEvidence(
   return [...merged.values()].slice(-Math.max(1, Number(limit || 40)));
 }
 
-function recordDurableEvidenceCategories(state = {}, toolResult = {}) {
+export function rememberTmuxGitIntent(state = {}, args = {}, toolResult = {}) {
+  const gitIntent = toolResult?.ok ? buildTmuxGitIntent(args.text || "") : null;
+  if (!gitIntent || !toolResult?.target) return null;
+  state.meta = state.meta || {};
+  const pendingByTarget = state.meta.pendingTmuxGitEvidence || {};
+  const pending = {
+    ...gitIntent,
+    target: toolResult.target,
+    sentTextSha256: toolResult.sentTextSha256,
+    goalRevision: Math.max(0, Number(state.meta?.goalContract?.revision || 0)),
+    mutationRevision: Math.max(
+      0,
+      Number(state.meta?.projectVerification?.mutationRevision || 0)
+    ),
+  };
+  pendingByTarget[toolResult.target] = pending;
+  state.meta.pendingTmuxGitEvidence = Object.fromEntries(
+    Object.entries(pendingByTarget).slice(-8)
+  );
+  toolResult.tmuxGitIntentActions = gitIntent.actions;
+  toolResult.tmuxGitIntentMarkers = gitIntent.markers;
+  return pending;
+}
+
+export function attachVerifiedTmuxGitEvidence(state = {}, toolResult = {}) {
+  const pendingByTarget = state.meta?.pendingTmuxGitEvidence || {};
+  const pending = pendingByTarget[toolResult?.target];
+  const verifiedGitActions = inferSuccessfulGitActionsFromTmuxCapture(
+    pending,
+    toolResult
+  );
+  if (!verifiedGitActions.length) return [];
+  toolResult.verifiedGitActions = verifiedGitActions;
+  toolResult.verifiedGitSource = "tmux_capture_pane";
+  toolResult.verifiedGitGoalRevision = Math.max(
+    0,
+    Number(pending.goalRevision || 0)
+  );
+  toolResult.verifiedGitMutationRevision = Math.max(
+    0,
+    Number(pending.mutationRevision || 0)
+  );
+  toolResult.verifiedGitCommandSha256 = String(pending.sentTextSha256 || "");
+  delete pendingByTarget[toolResult.target];
+  state.meta.pendingTmuxGitEvidence = pendingByTarget;
+  return verifiedGitActions;
+}
+
+export function recordDurableEvidenceCategories(state = {}, toolResult = {}) {
   if (!toolResult || toolResult.ok === false || toolResult.blocked || toolResult.skipped) return;
   state.meta = state.meta || {};
   const categories = new Set(
@@ -13798,33 +13851,50 @@ function recordDurableEvidenceCategories(state = {}, toolResult = {}) {
     categories.add("artifact");
   }
   if (toolName === "read_image") categories.add("visual");
+  const gitActions = toolName === "run_command" && Number(toolResult.exitCode ?? 0) === 0
+    ? inferSuccessfulGitActionsFromCommandResult(toolResult)
+    : Array.isArray(toolResult.verifiedGitActions)
+      ? toolResult.verifiedGitActions
+      : [];
   if (toolName === "run_command" && Number(toolResult.exitCode ?? 0) === 0) {
     categories.add("command");
     const command = String(toolResult.args?.command || "").trim();
-    const gitActions = inferSuccessfulGitActionsFromCommandResult(toolResult);
-    if (gitActions.length) {
-      categories.add("git");
-      if (successfulGitCommitProvesFileMutation(toolResult)) categories.add("file");
-      state.meta.durableGitActions = [
-        ...new Set([
-          ...(Array.isArray(state.meta.durableGitActions) ? state.meta.durableGitActions : []),
-          ...gitActions,
-        ]),
-      ];
-      const goalRevision = Math.max(0, Number(state.meta?.goalContract?.revision || 0));
-      const existingGitEvidence = Array.isArray(state.meta.durableGitEvidence)
-        ? state.meta.durableGitEvidence
-        : [];
-      state.meta.durableGitEvidence = mergeDurableGitEvidence(existingGitEvidence, gitActions, {
-        goalRevision,
-        mutationRevision: Math.max(
-          0,
-          Number(state.meta?.projectVerification?.mutationRevision || 0)
-        ),
-      });
-    }
     if (/\b(?:pytest|unittest|npm\s+test|pnpm\s+test|yarn\s+test)\b/i.test(command)) categories.add("test");
   }
+  if (gitActions.length) {
+    categories.add("git");
+    if (
+      successfulGitCommitProvesFileMutation(toolResult) ||
+      (gitActions.includes("commit") && toolResult.verifiedGitSource === "tmux_capture_pane")
+    ) {
+      categories.add("file");
+    }
+    state.meta.durableGitActions = [
+      ...new Set([
+        ...(Array.isArray(state.meta.durableGitActions) ? state.meta.durableGitActions : []),
+        ...gitActions,
+      ]),
+    ];
+    const goalRevision = Math.max(
+      0,
+      Number(toolResult.verifiedGitGoalRevision ?? state.meta?.goalContract?.revision ?? 0)
+    );
+    const mutationRevision = Math.max(
+      0,
+      Number(
+        toolResult.verifiedGitMutationRevision ??
+          state.meta?.projectVerification?.mutationRevision ??
+          0
+      )
+    );
+    const existingGitEvidence = Array.isArray(state.meta.durableGitEvidence)
+      ? state.meta.durableGitEvidence
+      : [];
+    state.meta.durableGitEvidence = mergeDurableGitEvidence(existingGitEvidence, gitActions, {
+      goalRevision,
+      mutationRevision,
+    });
+  }
   state.meta.durableEvidenceCategories = [...categories];
 }
 
@@ -18759,6 +18829,7 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
       }
       case "tmux_capture_pane": {
         const result = await captureTmuxPane(args, config);
+        attachVerifiedTmuxGitEvidence(state, result);
         const eventResult = sanitizeToolResult(result);
         await store.appendEvent(result.ok ? "tool.completed" : "tool.failed", eventResult);
         observers.event(result.ok ? "tool.completed" : "tool.failed", eventResult);
@@ -18766,6 +18837,7 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
       }
       case "tmux_send_keys": {
         const result = await sendTmuxKeys(args, config);
+        rememberTmuxGitIntent(state, args, result);
         const eventResult = sanitizeToolResult(result);
         await store.appendEvent(result.ok ? "tool.completed" : "tool.failed", eventResult);
         observers.event(result.ok ? "tool.completed" : "tool.failed", eventResult);

package/src/scs-evidence.js

@@ -2120,6 +2120,147 @@ export function inferSuccessfulGitActionsFromCommandResult(payload = {}) {
   return [];
 }
 
+export function buildTmuxGitIntent(command = "") {
+  const text = String(command || "");
+  // `$?` is expected in the explicit tmux exit marker. Remove only that
+  // non-command expansion before parsing; all other shell expansion remains
+  // subject to the normal ambiguity guard.
+  const parseable = text.replace(/\$\?/g, "0");
+  const actions = inferGitActionsFromCommand(parseable, {
+    requireFailurePropagation: false,
+  }).filter((action) => !isObservationalGitAction(action));
+  const markers = [
+    ...text.matchAll(/={3,}([A-Z0-9][A-Z0-9_-]{3,96}(?:START|BEGIN))={3,}/g),
+  ].map((match) => String(match[0] || ""));
+  if (!actions.length || !markers.length) return null;
+  return {
+    actions: unique(actions),
+    markers: unique(markers).slice(0, 4),
+  };
+}
+
+export function inferSuccessfulGitActionsFromTmuxCapture(intent = {}, payload = {}) {
+  if (
+    !intent ||
+    !payload ||
+    payload.ok === false ||
+    payload.blocked ||
+    String(payload.toolName || "") !== "tmux_capture_pane"
+  ) {
+    return [];
+  }
+  const content = [payload.content, payload.contentPreview, payload.contentTail]
+    .map((item) => String(item || ""))
+    .filter(Boolean)
+    .join("\n");
+  const markers = Array.isArray(intent.markers)
+    ? intent.markers.map(String).filter(Boolean)
+    : [];
+  if (!content || !markers.length || !markers.some((marker) => content.includes(marker))) {
+    return [];
+  }
+  const requested = Array.isArray(intent.actions)
+    ? intent.actions.map((item) => String(item || "").toLowerCase()).filter(Boolean)
+    : [];
+  const verified = [];
+  if (
+    requested.includes("commit") &&
+    /={3,}(?:GIT_)?COMMIT_EXIT\s*[:=]\s*0={3,}/i.test(content) &&
+    /^\[[^\]\n]+\s+[0-9a-f]{7,}\]\s+\S+/mi.test(content)
+  ) {
+    verified.push("commit");
+  }
+  return verified;
+}
+
+export function reconcileTmuxGitEvidenceEvents(events = []) {
+  const source = Array.isArray(events) ? events : [];
+  const pendingStarts = new Map();
+  const activeIntents = new Map();
+  let goalRevision = 0;
+  let mutationRevision = 0;
+
+  return source.map((event) => {
+    const type = String(event?.type || "");
+    const data = event?.data && typeof event.data === "object" ? event.data : {};
+    goalRevision = Math.max(
+      goalRevision,
+      Number(
+        data.goalRevision ??
+          (type === "goal.updated" ? data.revision : 0) ??
+          0
+      ) || 0
+    );
+    mutationRevision = Math.max(
+      mutationRevision,
+      Number(data.projectMutationRevision ?? data.mutationRevision ?? 0) || 0
+    );
+
+    const toolName = String(data.toolName || "");
+    const target = String(data.target || data.args?.target || "");
+    if (type === "tool.started" && toolName === "tmux_send_keys" && target) {
+      const intent = buildTmuxGitIntent(data.args?.text || "");
+      if (intent) {
+        pendingStarts.set(target, {
+          ...intent,
+          target,
+          goalRevision,
+          mutationRevision,
+        });
+      } else {
+        pendingStarts.delete(target);
+        activeIntents.delete(target);
+      }
+      return event;
+    }
+
+    if (["tool.completed", "tool.failed"].includes(type) && toolName === "tmux_send_keys" && target) {
+      const pending = pendingStarts.get(target);
+      pendingStarts.delete(target);
+      if (type === "tool.completed" && data.ok !== false && pending) {
+        activeIntents.set(target, {
+          ...pending,
+          sentTextSha256: String(data.sentTextSha256 || ""),
+        });
+      } else {
+        activeIntents.delete(target);
+      }
+      return event;
+    }
+
+    if (type === "tool.completed" && toolName === "tmux_capture_pane" && target) {
+      const pending = activeIntents.get(target);
+      const verifiedGitActions = inferSuccessfulGitActionsFromTmuxCapture(
+        pending,
+        data
+      );
+      if (verifiedGitActions.length) {
+        activeIntents.delete(target);
+        return {
+          ...event,
+          data: {
+            ...data,
+            verifiedGitActions,
+            verifiedGitSource: "tmux_capture_pane",
+            verifiedGitGoalRevision: Math.max(
+              0,
+              Number(pending.goalRevision || 0)
+            ),
+            verifiedGitMutationRevision: Math.max(
+              0,
+              Number(pending.mutationRevision || 0)
+            ),
+            verifiedGitCommandSha256: String(
+              pending.sentTextSha256 || ""
+            ),
+          },
+        };
+      }
+    }
+    return event;
+  });
+}
+
 export function successfulGitCommitProvesFileMutation(payload = {}) {
   if (!inferSuccessfulGitActionsFromCommandResult(payload).includes("commit")) return false;
   const output = String(payload.stdout || payload.result || "");
@@ -3955,7 +4096,9 @@ function toolPayloadToEvidence(payload = {}, source = "tool") {
   if (["read_image", "generate_image"].includes(toolName) || /\b(screenshot|visible|thumbnail|preview|image)\b/.test(text)) {
     push("visual", `${toolName || "tool"} supplied visual evidence`, payload.path || payload.outputPath || args.path || "");
   }
-  const gitActions = inferSuccessfulGitActionsFromCommandResult(payload);
+  const gitActions = Array.isArray(payload.verifiedGitActions)
+    ? payload.verifiedGitActions
+    : inferSuccessfulGitActionsFromCommandResult(payload);
   if (gitActions.length) {
     push(
       "git",
@@ -3964,8 +4107,18 @@ function toolPayloadToEvidence(payload = {}, source = "tool") {
       {
         gitAction: gitActions.at(-1),
         gitActions,
-        goalRevision: Math.max(0, Number(payload.goalRevision || 0)),
-        mutationRevision: Math.max(0, Number(payload.projectMutationRevision || 0)),
+        goalRevision: Math.max(
+          0,
+          Number(payload.verifiedGitGoalRevision ?? payload.goalRevision ?? 0)
+        ),
+        mutationRevision: Math.max(
+          0,
+          Number(
+            payload.verifiedGitMutationRevision ??
+              payload.projectMutationRevision ??
+              0
+          )
+        ),
       }
     );
   }
@@ -4038,7 +4191,9 @@ function messageToEvidence(message = {}) {
 }
 
 export function buildScsEvidenceLedger({ state = {}, context = {} } = {}) {
-  const events = Array.isArray(context.events) ? context.events : [];
+  const events = reconcileTmuxGitEvidenceEvents(
+    Array.isArray(context.events) ? context.events : []
+  );
   const messages = Array.isArray(state.messages) ? state.messages : [];
   const eventEvidence = events.flatMap(eventToEvidence);
   // Completed tools are mirrored into both the append-only event stream and