@lazyingart/agintiflow 0.20.151 → 0.20.156

package/docs/student-committee-supervisor.md

@@ -31,7 +31,7 @@ SCS uses the selected main model for every internal role.
 | Role | Right | Boundary |
 | --- | --- | --- |
 | Committee | Draft one next-phase plan with acceptance criteria and stop conditions. | Cannot approve plans or call tools. |
-| Student | Approve/veto the phase plan, review failure evidence, and approve/reject finish. | Cannot call tools or override runtime safety. |
+| Student | Act as the independent validator: approve/veto the phase plan, review failure evidence, and approve/reject finish. | Cannot call tools, approve its own work, or override runtime safety. |
 | Supervisor | Execute the approved phase with the existing browser, shell, file, canvas, and wrapper tools. | Cannot replace the strategic plan without student review. |
 
 The runtime remains the real authority for command policy, filesystem guardrails, secret redaction, session persistence, and user interruption.
@@ -44,9 +44,10 @@ When SCS is active:
 - Parallel scouts are disabled by default unless explicitly requested, avoiding duplicate advisory layers.
 - The normal `createPlan()` path is replaced by a committee draft plus student approval.
 - An approved supervisor instruction is injected into the execution loop.
-- Failed or blocked tools trigger a bounded student monitor review.
+- Failed, blocked, suspicious, or mismatched tools trigger a bounded student validator review.
 - Every fourth execution step triggers a bounded progress review for long runs.
 - `finish` and assistant-content completion pass through a final student gate.
+- If the student validator rejects progress or finish, the runtime asks the committee for a new phase plan and sends that plan back through the student gate before the supervisor continues.
 - Decisions are persisted as `scs.*` events and the phase pack is saved as a session artifact.
 
 The current implementation is deliberately bounded:
@@ -93,6 +94,10 @@ Avoid SCS for:
 
 SCS emits compact event names:
 
+- `conversation.continued`
+- `surgical_context.prepared`
+- `surgical_context.failed`
+- `scs.plan.requested`
 - `scs.enabled`
 - `scs.committee.plan_drafted`
 - `scs.student.approve_plan`
@@ -102,10 +107,13 @@ SCS emits compact event names:
 - `scs.student.reject_phase`
 - `scs.student.finish_allowed`
 - `scs.student.finish_rejected`
+- `scs.committee.replan_drafted`
 - `scs.supervisor.phase_started`
 
 These are saved in the normal session event log under `~/.agintiflow/sessions/<session-id>/events.jsonl`, with project pointers under `.aginti-sessions/`.
 
+Browser and CDP helper commands are reviewed by evidence, not only by exit status. If a click or selector command reports `ok: true` but returns broad whole-page text, repeated navigation/history/sidebar text, or no scoped target evidence, SCS treats the result as suspicious and asks the supervisor to verify state or switch to a precise selector before continuing.
+
 ## Design Reference
 
 The deeper design research lives in [references/student-committee-supervisor-mode.md](../references/student-committee-supervisor-mode.md). The important design choice is that SCS is a typed event gate, not a free-form debate. Internal roles emit structured decisions, and the runtime decides what those decisions are allowed to do.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.151",
+  "version": "0.20.156",
   "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-cli-chat.js

@@ -683,9 +683,13 @@ try {
   if (!reviewResult.stdout.includes("Review focus: changed files only") || !reviewResult.stdout.includes("Mock run complete")) {
     throw new Error("interactive /review did not launch the bounded review workflow");
   }
-  const scsOnResult = await runChat("/scs\n");
+  const scsDefaultStatusResult = await runChat("/scs status\n");
+  if (!scsDefaultStatusResult.stdout.includes("SCS mode: auto")) {
+    throw new Error("interactive /scs status did not show default auto mode");
+  }
+  const scsOnResult = await runChat("/scs on\n");
   if (!scsOnResult.stdout.includes("scs=on")) {
-    throw new Error("interactive /scs did not toggle SCS on");
+    throw new Error("interactive /scs on did not enable SCS");
   }
   const legacyScsAlias = "/enable" + "ss";
   const oldScsAliasResult = await runChat(`${legacyScsAlias}\n/exit\n`);
@@ -696,9 +700,9 @@ try {
   if (!scsOffResult.stdout.includes("scs=off")) {
     throw new Error("interactive /scs did not toggle SCS off");
   }
-  const scsStatusResult = await runChat("/scs status\n");
+  const scsStatusResult = await runCli(["chat", "--provider", "mock", "--routing", "manual", "--profile", "code", "--no-scs"], "/scs status\n");
   if (!scsStatusResult.stdout.includes("SCS mode: off")) {
-    throw new Error("interactive /scs status did not show current mode");
+    throw new Error("interactive /scs status did not show explicit off mode");
   }
   const scsAutoResult = await runChat("/scs auto\n");
   if (!scsAutoResult.stdout.includes("scs=auto")) {

package/scripts/smoke-coding-tools.js

@@ -441,6 +441,18 @@ try {
   );
   assert(androidReadonlyProbePolicy.allowed, "Android host read-only probes should not require full-host destructive access");
   assert(androidReadonlyProbePolicy.category === "read-only", "Android host probes should remain read-only");
+  const hostLocalhostJsonProbePolicy = evaluateCommandPolicy(
+    "curl -s http://127.0.0.1:9222/json/version | python3 -m json.tool",
+    hostWorkspacePolicy
+  );
+  assert(hostLocalhostJsonProbePolicy.allowed, "host localhost JSON probe should not require full-host destructive access");
+  assert(hostLocalhostJsonProbePolicy.category === "network-fetch", "host localhost JSON probe should stay classified as network-fetch");
+  const absolutePythonHelperPolicy = evaluateCommandPolicy(
+    "/home/lachlan/miniconda3/bin/python scripts/xyq_cdp_browser.py list-pages",
+    hostWorkspacePolicy
+  );
+  assert(absolutePythonHelperPolicy.allowed, "host absolute Python helper script should be allowed without full-host destructive access");
+  assert(absolutePythonHelperPolicy.category === "toolchain", "host absolute Python helper should remain classified as toolchain");
   const androidGradleBuildPolicy = evaluateCommandPolicy("cd android-app && ./gradlew :app:assembleDebug", hostWorkspacePolicy);
   assert(androidGradleBuildPolicy.allowed, "workspace-local Gradle Android build should be allowed in host workspace mode");
   assert(androidGradleBuildPolicy.category === "toolchain", "workspace-local Gradle Android build should be toolchain");
@@ -555,6 +567,18 @@ try {
     failedNetworkAdvice.instruction.includes("Stop and present this blocker"),
     "network failure advice did not tell the model to stop and ask"
   );
+  const failedDockerLocalhostAdvice = buildFailedCommandAdvice({
+    args: { command: "curl -fsS http://127.0.0.1:9222/json/version" },
+    commandPolicy: evaluateCommandPolicy("curl -fsS http://127.0.0.1:9222/json/version", dockerWorkspacePolicy),
+    commandResult: { ok: false, stderr: "curl: (7) Failed to connect to 127.0.0.1 port 9222: Connection refused" },
+    config: dockerWorkspacePolicy,
+    state: { sessionId: "coding-localhost-cdp-smoke" },
+  });
+  assert(failedDockerLocalhostAdvice?.failureKind === "host-local-service", "Docker localhost failure advice was not generated");
+  assert(
+    failedDockerLocalhostAdvice.suggestedCommand.includes("--sandbox-mode host"),
+    "Docker localhost advice did not suggest host mode"
+  );
   const failedOutsidePathAdvice = buildFailedCommandAdvice({
     args: { command: 'echo "outside permission test" > /home/lachlan/ProjectsLFS/outside.txt' },
     commandPolicy: evaluateCommandPolicy('echo "outside permission test" > /home/lachlan/ProjectsLFS/outside.txt', dockerWorkspacePolicy),
@@ -1149,6 +1173,8 @@ try {
           "command_policy_safe_chmod_sequence",
           "command_policy_host_workspace_chmod",
           "command_policy_android_host_probes",
+          "command_policy_host_localhost_json_probe",
+          "command_policy_absolute_python_helper",
           "command_policy_android_gradle_build",
           "command_policy_android_gradle_build_with_safe_env",
           "command_policy_cd_workspace",

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

@@ -5,13 +5,19 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { runAgent } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
-import { shouldActivateScs } from "../src/scs-controller.js";
+import {
+  browserSubmitFinishIssue,
+  isSuspiciousBroadBrowserToolResult,
+  shouldActivateScs,
+  shouldReviewToolResult,
+} from "../src/scs-controller.js";
 import {
   createStepBudgetState,
   decideStepBudgetExtension,
   normalizeDynamicStepsMode,
 } from "../src/step-budget-controller.js";
 import { SessionStore } from "../src/session-store.js";
+import { recommendedMaxStepsForTask } from "../src/engineering-guidance.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-dynamic-budget-"));
@@ -44,10 +50,67 @@ try {
     }),
     "/scs auto should activate for complex engineering prompts"
   );
+  assert(
+    shouldActivateScs("auto", {
+      goal: "Use Chrome Driver/CDP on 127.0.0.1:9222 to upload five reference images, choose an asset-library video, submit the browser form, and monitor progress.",
+      taskProfile: "auto",
+      complexityScore: 1,
+    }),
+    "/scs auto should activate for browser automation and host-local CDP workflows"
+  );
   assert(
     !shouldActivateScs("auto", { goal: "say hello", taskProfile: "auto", complexityScore: 0 }),
     "/scs auto should stay off for trivial prompts"
   );
+  const broadBrowserClick = {
+    toolName: "run_command",
+    ok: true,
+    args: {
+      command: "python scripts/browser_cdp.py click-text PAGE \"Create\"",
+    },
+    stdout: JSON.stringify({
+      ok: true,
+      text: Array(30)
+        .fill("New chat\nAsset library\nHistory\nAll\nYesterday\nThis month\nSettings\nUpload reference\nSubmit prompt")
+        .join("\n"),
+      x: 650,
+      y: 390,
+    }),
+  };
+  assert(
+    isSuspiciousBroadBrowserToolResult(broadBrowserClick),
+    "SCS should flag successful browser clicks that return broad whole-page text"
+  );
+  assert(
+    shouldReviewToolResult(broadBrowserClick, { meta: {} }),
+    "SCS should review suspicious broad browser click results"
+  );
+  assert(
+    !isSuspiciousBroadBrowserToolResult({
+      toolName: "run_command",
+      ok: true,
+      args: { command: "echo ok" },
+      stdout: "ok",
+    }),
+    "SCS should not flag ordinary successful shell output as a browser click problem"
+  );
+  assert(
+    recommendedMaxStepsForTask({
+      goal: "Use Chrome CDP to upload five images, select an asset-library video, choose non-VIP model, and submit the Xiaoyunque browser composer.",
+    }) >= 48,
+    "browser submit workflows need a larger default step budget"
+  );
+  assert(
+    browserSubmitFinishIssue(
+      "小云雀网页上传五张图，从资产库选择参考视频，然后提交生成",
+      "资产库旧三人视频 未执行；提交 未执行；步骤不足。"
+    ),
+    "SCS finish gate should reject unfinished browser submit reports"
+  );
+  assert(
+    !browserSubmitFinishIssue("小云雀网页提交生成", "停止：积分不足，需要用户处理 credits not enough。"),
+    "SCS finish gate should allow real external browser blockers"
+  );
 
   const normalBudget = createStepBudgetState(
     {
@@ -131,6 +194,7 @@ try {
       sessionId: "dynamic-step-budget-smoke",
     }
   );
+  assert(config.enableScs === "auto", "runtime config should default SCS mode to auto");
   const run = await runAgent(config);
   assert(!run.stopped, "mock run stopped instead of using dynamic extension");
   const written = await fs.readFile(path.join(workspace, "notes/dynamic-budget.md"), "utf8");

package/scripts/smoke-model-roles.js

@@ -11,7 +11,7 @@ import {
 } from "../src/model-routing.js";
 import { normalizeTextToolCallResponse, parseTextToolCalls, usesTextToolProtocol } from "../src/model-client.js";
 import { modelRoleChoices, selectorVisibleWindow } from "../src/interactive-cli.js";
-import { buildScsEvidencePack, buildSupervisorInstruction } from "../src/scs-controller.js";
+import { buildScsEvidencePack, buildSupervisorInstruction, shouldRequestScsReplan } from "../src/scs-controller.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -219,6 +219,10 @@ assert(!usesTextToolProtocol({ provider: "venice", model: "venice-uncensored-1-2
 const scsInstruction = buildSupervisorInstruction({ plan: "Create one file.", acceptanceCriteria: ["File exists."] });
 assert(scsInstruction.includes("Student-Committee-Supervisor"), "SCS supervisor instruction should define the acronym");
 assert(!scsInstruction.includes("Syntax-Checker Sentinel"), "SCS supervisor instruction should not allow alternate acronym expansions");
+assert(scsInstruction.includes("student is the independent validator"), "SCS supervisor instruction should define student as validator");
+assert(shouldRequestScsReplan({ decision: "finish_rejected" }), "finish rejection should trigger committee replan");
+assert(shouldRequestScsReplan({ decision: "rethink_plan" }), "student rethink should trigger committee replan");
+assert(!shouldRequestScsReplan({ decision: "finish_allowed" }), "finish approval should not trigger committee replan");
 const longStdout = [
   "=== Student-Committee-Supervisor present ===",
   "3:SCS stands for **Student-Committee-Supervisor**",
@@ -270,6 +274,7 @@ console.log(
         "requested-tools-parser",
         "malformed-text-tool-retry",
         "scs-supervisor-identity",
+        "scs-student-validator-replan",
         "scs-evidence-stdout",
         "cli-models-command",
         "venice-shortcut",

package/scripts/smoke-skills.js

@@ -22,6 +22,7 @@ assert(skills.length >= 27, "expected built-in skills to load");
 for (const required of [
   "aaps",
   "autonomous-artifact-pipeline",
+  "browser-automation",
   "code",
   "code-review",
   "data-analysis",
@@ -56,6 +57,13 @@ for (const required of [
 }
 
 assert(selectedIds("write a beautiful React website and preview it").includes("website-app"), "website prompt did not select website-app");
+assert(
+  selectedIds("control an existing Chrome CDP browser composer, upload images, choose model duration, and submit").includes(
+    "browser-automation"
+  ),
+  "browser automation prompt did not select browser-automation"
+);
+assert(selectedIds("小云雀 网页 上传 五张图 从资产库选择视频 提交").includes("browser-automation"), "Chinese XYQ prompt did not select browser-automation");
 assert(selectedIds("write a LaTeX paper and compile a PDF").includes("latex-manuscript"), "latex prompt did not select latex-manuscript");
 assert(selectedIds("edit a Microsoft Word docx and preserve the original").includes("word-documents"), "docx prompt did not select word-documents");
 assert(selectedIds("generate a logo image with grsai nanobanana").includes("image-generation"), "image prompt did not select image-generation");

package/skills/browser-automation/SKILL.md

@@ -0,0 +1,56 @@
+---
+id: browser-automation
+label: Browser Automation
+description: Control existing browser sessions, Chrome/CDP pages, web composers, upload dialogs, asset pickers, model selectors, forms, and submit/publish workflows with inspect-set-verify discipline.
+triggers:
+  - browser
+  - chrome
+  - cdp
+  - chromedriver
+  - playwright
+  - selenium
+  - web ui
+  - website
+  - upload
+  - attach
+  - asset library
+  - submit
+  - publish
+  - model selector
+  - prompt composer
+  - 小云雀
+  - 浏览器
+  - 网页
+  - 上传
+  - 资产库
+  - 提交
+tools:
+  - open_url
+  - click
+  - type
+  - press
+  - wait
+  - run_command
+  - read_image
+  - read_file
+  - search_files
+---
+# Browser Automation
+
+Treat browser work as state reconciliation, not passive inspection.
+
+Workflow:
+
+1. Identify the active page and the target final state: page/workspace, mode, model, duration, attachments, prompt text, and submit state.
+2. Inspect the current state from the latest snapshot, project helper scripts, screenshots, or read-only CDP/Playwright queries.
+3. If a required control is absent or unknown, set it with the smallest scoped action, then wait and verify. Do not stop just because the first state dump lacks a field.
+4. Prefer scoped selectors inside the relevant composer, toolbar, modal, asset picker, or form. Broad text clicks over the whole page are unreliable.
+5. If a helper reports `ok: true` but returns whole-page text, history/sidebar/nav text, unrelated examples, or an unscoped match, treat it as a wrong target and retry with scoped JS, coordinates from a screenshot, or a narrower selector.
+6. For uploads or asset-library selection, verify visible chips, thumbnails, filenames, counters, or previews before submitting.
+7. When multiple browser tabs or CDP targets exist, reconcile the target with the user-visible tab. Bring the controlled page to the front when possible, name the exact page id, URL, and workflow, and save screenshot evidence. Do not report that the user can see an upload if only a background page was verified.
+8. For model/duration/mode controls, distinguish selected state from ads, recommendations, and history labels.
+9. For model selectors, honor the exact requested tier. If the user asked for a non-VIP model and the toolbar says VIP, open the selector and choose a non-VIP option; if none exists, stop with that evidence instead of assuming account membership changes the selected model.
+10. Before irreversible or externally visible actions such as submit, publish, purchase, or account changes, verify all requested state. If verification remains impossible after a bounded set attempt, stop with the exact blocker and evidence.
+11. If the user requested submit/publish/generation, do not finish merely because time or steps are running low while assets, reference media, model choice, or the final submit remain skipped. Continue with a narrower action or stop only for an external blocker such as login, credits, captcha, server/internal error, missing account permission, or a user confirmation dialog.
+
+For logged-in browser sessions, preserve the user’s state. Do not open new tabs, navigate to home/history, or close pages unless the current composer is unusable and the user allowed it.