@lazyingart/agintiflow 0.20.63 → 0.20.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.63",
+  "version": "0.20.65",
   "type": "module",
   "description": "Low-cost, project-aware Web and CLI agents with DeepSeek/Venice/OpenAI routing, visible tool calls, durable sessions, scouts, AAPS, SCS, and guarded local execution.",
   "license": "Apache-2.0",

package/scripts/smoke-cli-chat.js

@@ -15,7 +15,7 @@ import {
   formatWorkspaceChange,
   stripMarkdown,
 } from "../src/interactive-cli.js";
-import { parseArgs } from "../src/cli.js";
+import { parseArgs, parseResumeCommandArgs, splitResumeCommandArgv } from "../src/cli.js";
 import { dockerPolicyTimeoutMs, dockerUserCommand } from "../src/docker-sandbox.js";
 import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
 
@@ -286,6 +286,48 @@ try {
   if (scsAutoArgs.enableScs !== "auto" || scsAutoArgs.goal !== "fix this project") {
     throw new Error("--scs auto should consume auto and preserve the task");
   }
+  const resumeAfterOptions = parseResumeCommandArgs([
+    "web-agent-smoke",
+    "--provider",
+    "deepseek",
+    "--routing",
+    "smart",
+    "--sandbox-mode",
+    "host",
+    "--scout-count",
+    "3",
+  ]);
+  const resumeAfterParsed = parseArgs(resumeAfterOptions.optionArgv);
+  if (
+    resumeAfterOptions.sessionId !== "web-agent-smoke" ||
+    resumeAfterOptions.prompt ||
+    resumeAfterParsed.provider !== "deepseek" ||
+    resumeAfterParsed.routingMode !== "smart" ||
+    resumeAfterParsed.sandboxMode !== "host" ||
+    resumeAfterParsed.parallelScoutCount !== 3
+  ) {
+    throw new Error("resume subcommand options after the session id should remain options, not prompt text");
+  }
+  const resumePromptAfterDash = parseResumeCommandArgs(["web-agent-smoke", "--provider", "mock", "--", "--provider should be prompt"]);
+  if (
+    resumePromptAfterDash.sessionId !== "web-agent-smoke" ||
+    resumePromptAfterDash.prompt !== "--provider should be prompt" ||
+    parseArgs(resumePromptAfterDash.optionArgv).provider !== "mock"
+  ) {
+    throw new Error("resume subcommand should preserve explicit prompt text after --");
+  }
+  const leadingResume = splitResumeCommandArgv(["--provider", "mock", "--routing", "manual", "resume", "latest"]);
+  if (
+    !leadingResume ||
+    leadingResume.resumeArgv.join(" ") !== "latest" ||
+    parseArgs(leadingResume.leadingOptionArgv).provider !== "mock" ||
+    parseArgs(leadingResume.leadingOptionArgv).routingMode !== "manual"
+  ) {
+    throw new Error("leading global options before resume should still invoke the resume subcommand");
+  }
+  if (splitResumeCommandArgv(["--provider", "mock", "resume", "a normal task"]) !== null) {
+    throw new Error("leading global options should not turn an ordinary resume-themed prompt into the resume subcommand");
+  }
 
   await runCli(["init"], "");
   const instructions = await fs.readFile(path.join(tempRoot, "AGINTI.md"), "utf8");
@@ -420,6 +462,7 @@ try {
           "skills-command",
           "review-command",
           "scs-command-toggle",
+          "resume-command-options",
           "slash-prefix-autoselect",
           "slash-prefix-canonical-history",
           "instructions-chat-edit",

package/scripts/smoke-model-roles.js

@@ -11,6 +11,7 @@ import {
 } from "../src/model-routing.js";
 import { normalizeTextToolCallResponse, parseTextToolCalls, usesTextToolProtocol } from "../src/model-client.js";
 import { modelRoleChoices } from "../src/interactive-cli.js";
+import { buildSupervisorInstruction } from "../src/scs-controller.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -204,6 +205,9 @@ assert(usesTextToolProtocol({ provider: "venice", model: "gemma-4-uncensored" })
 assert(usesTextToolProtocol({ provider: "venice", model: "e2ee-venice-uncensored-24b-p" }), "Venice 1.1 should use text tool protocol");
 assert(usesTextToolProtocol({ provider: "venice", model: "venice-uncensored" }), "Venice legacy 1.1 should use text tool protocol");
 assert(!usesTextToolProtocol({ provider: "venice", model: "venice-uncensored-1-2" }), "Venice 1.2 should keep native tool calls first");
+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");
 
 const output = await runCli(["models"]);
 assert(output.includes("/route") && output.includes("/spare") && output.includes("venice-gpt"), "aginti models output missing role details");
@@ -232,6 +236,7 @@ console.log(
         "venice-text-tool-parser",
         "requested-tools-parser",
         "malformed-text-tool-retry",
+        "scs-supervisor-identity",
         "cli-models-command",
         "venice-shortcut",
       ],

package/src/cli.js

@@ -65,6 +65,205 @@ function readOptionalScsMode(argv, index) {
   return { mode: value, consumed: true };
 }
 
+const CLI_VALUE_OPTIONS = new Set([
+  "--port",
+  "--host",
+  "--language",
+  "--lang",
+  "-L",
+  "--start-url",
+  "--resume",
+  "--session-id",
+  "--provider",
+  "--model",
+  "--route-provider",
+  "--route-model",
+  "--main-provider",
+  "--main-model",
+  "--spare-provider",
+  "--spare-model",
+  "--spare-reasoning",
+  "--wrapper-model",
+  "--wrapper-reasoning",
+  "--aux-provider",
+  "--auxiliary-provider",
+  "--aux-model",
+  "--auxiliary-model",
+  "--routing",
+  "--cwd",
+  "--sandbox-mode",
+  "--package-install-policy",
+  "--max-steps",
+  "--scout-count",
+  "--wrapper",
+  "--preferred-wrapper",
+  "--profile",
+  "--task-profile",
+]);
+
+const CLI_FLAG_OPTIONS = new Set([
+  "--web",
+  "--chat",
+  "--interactive",
+  "--no-auto-update",
+  "--auto-update",
+  "--enable-scs",
+  "--disable-scs",
+  "--no-scs",
+  "--approve-package-installs",
+  "--latex",
+  "--image",
+  "--image-gen",
+  "--image-generation",
+  "--allow-shell",
+  "--no-shell",
+  "--allow-destructive",
+  "--trusted-host-shell",
+  "--allow-file-tools",
+  "--no-file-tools",
+  "--allow-auxiliary-tools",
+  "--allow-auxiliary",
+  "--no-auxiliary-tools",
+  "--no-auxiliary",
+  "--web-search",
+  "--no-web-search",
+  "--parallel-scouts",
+  "--no-parallel-scouts",
+  "--allow-wrappers",
+  "--docker-sandbox",
+  "--headless",
+  "--list-routes",
+  "--list-models",
+  "--models",
+  "--list-wrappers",
+  "--list-profiles",
+  "--list-skills",
+  "--sandbox-status",
+  "--sandbox-preflight",
+  "--scs",
+]);
+
+function collectCliOption(argv, index) {
+  const arg = argv[index];
+  if (arg === "--scs" || arg === "--enable-scs") {
+    const { consumed } = readOptionalScsMode(argv, index);
+    return { recognized: true, args: consumed ? [arg, argv[index + 1]] : [arg], nextIndex: index + (consumed ? 2 : 1) };
+  }
+  if (arg === "--language" || arg === "--lang" || arg === "-L") {
+    const first = readOption(argv, index);
+    const second = argv[index + 2] && !String(argv[index + 2]).startsWith("--") ? argv[index + 2] : "";
+    if (["cn", "zh"].includes(String(first || "").toLowerCase()) && ["s", "t"].includes(String(second || "").toLowerCase())) {
+      return { recognized: true, args: [arg, first, second], nextIndex: index + 3 };
+    }
+    return first
+      ? { recognized: true, args: [arg, first], nextIndex: index + 2 }
+      : { recognized: true, args: [arg], nextIndex: index + 1 };
+  }
+  if (CLI_VALUE_OPTIONS.has(arg)) {
+    const value = readOption(argv, index);
+    return value
+      ? { recognized: true, args: [arg, value], nextIndex: index + 2 }
+      : { recognized: true, args: [arg], nextIndex: index + 1 };
+  }
+  if (CLI_FLAG_OPTIONS.has(arg)) {
+    return { recognized: true, args: [arg], nextIndex: index + 1 };
+  }
+  return { recognized: false, args: [], nextIndex: index };
+}
+
+function looksLikeResumeSessionSelector(value) {
+  if (!value) return true;
+  const normalized = String(value);
+  return (
+    normalized === "latest" ||
+    normalized.startsWith("web-agent-") ||
+    normalized.startsWith("round") ||
+    normalized.startsWith("session-") ||
+    normalized.startsWith("aginti-")
+  );
+}
+
+function looksLikeResumeInvocation(resumeArgv = []) {
+  for (let index = 0; index < resumeArgv.length;) {
+    const arg = resumeArgv[index];
+    if (arg === "--" || looksLikeResumeSessionSelector(arg)) return looksLikeResumeSessionSelector(arg);
+    if (arg === "--all-sessions") {
+      index += 1;
+      continue;
+    }
+    const collected = collectCliOption(resumeArgv, index);
+    if (collected.recognized) {
+      index = collected.nextIndex;
+      continue;
+    }
+    return looksLikeResumeSessionSelector(arg);
+  }
+  return true;
+}
+
+export function splitResumeCommandArgv(argv = []) {
+  if (argv[0] === "resume") {
+    return { leadingOptionArgv: [], resumeArgv: argv.slice(1) };
+  }
+
+  const leadingOptionArgv = [];
+  let index = 0;
+  while (index < argv.length) {
+    if (argv[index] === "resume") {
+      const resumeArgv = argv.slice(index + 1);
+      return looksLikeResumeInvocation(resumeArgv) ? { leadingOptionArgv, resumeArgv } : null;
+    }
+    const collected = collectCliOption(argv, index);
+    if (!collected.recognized) return null;
+    leadingOptionArgv.push(...collected.args);
+    index = collected.nextIndex;
+  }
+  return null;
+}
+
+export function parseResumeCommandArgs(resumeArgv = [], leadingOptionArgv = []) {
+  const optionArgv = [...leadingOptionArgv];
+  const positional = [];
+  const promptParts = [];
+  let allSessions = false;
+  let promptMode = false;
+
+  for (let index = 0; index < resumeArgv.length;) {
+    const arg = resumeArgv[index];
+    if (promptMode) {
+      promptParts.push(arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--") {
+      promptMode = true;
+      index += 1;
+      continue;
+    }
+    if (arg === "--all-sessions") {
+      allSessions = true;
+      index += 1;
+      continue;
+    }
+    const collected = collectCliOption(resumeArgv, index);
+    if (collected.recognized) {
+      optionArgv.push(...collected.args);
+      index = collected.nextIndex;
+      continue;
+    }
+    if (positional.length === 0) positional.push(arg);
+    else promptParts.push(arg);
+    index += 1;
+  }
+
+  return {
+    allSessions,
+    optionArgv,
+    sessionId: positional[0] || "",
+    prompt: promptParts.join(" ").trim(),
+  };
+}
+
 export function parseArgs(argv) {
   const result = {
     goal: "",
@@ -1114,6 +1313,7 @@ export async function main(argv = process.argv.slice(2)) {
   const stripped = stripLeadingGlobalOptions(argv);
   const commandArgv = stripped.argv;
   const commandCwd = stripped.options.commandCwd || process.cwd();
+  const resumeCommand = splitResumeCommandArgv(commandArgv);
 
   if (commandArgv[0] === "aaps") {
     try {
@@ -1254,27 +1454,25 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
-  if (commandArgv[0] === "resume") {
-    const resumeArgv = commandArgv.slice(1);
-    const allSessions = resumeArgv.includes("--all-sessions");
-    const positional = resumeArgv.filter((arg) => arg !== "--all-sessions");
-    let sessionId = positional[0] || "";
-    const prompt = positional.slice(1).join(" ").trim();
+  if (resumeCommand) {
+    const resumeOptions = parseResumeCommandArgs(resumeCommand.resumeArgv, resumeCommand.leadingOptionArgv);
+    let sessionId = resumeOptions.sessionId;
+    const prompt = resumeOptions.prompt;
     try {
-      sessionId = await resolveResumeSessionId(sessionId, { allSessions });
+      sessionId = await resolveResumeSessionId(sessionId, { allSessions: resumeOptions.allSessions });
     } catch (error) {
       console.error(error instanceof Error ? error.message : String(error));
       process.exit(1);
     }
     if (!sessionId) return;
     if (!prompt) {
-      await startInteractiveCli(agentDefaults({ ...parseArgs([]), resume: sessionId, commandCwd }), {
+      await startInteractiveCli(agentDefaults({ ...parseArgs(resumeOptions.optionArgv), resume: sessionId, commandCwd }), {
         packageDir,
         packageVersion: packageJson.version,
       });
       return;
     }
-    const resumeArgs = agentDefaults({ ...parseArgs([prompt]), resume: sessionId, goal: prompt, commandCwd });
+    const resumeArgs = agentDefaults({ ...parseArgs([...resumeOptions.optionArgv, prompt]), resume: sessionId, goal: prompt, commandCwd });
     if (!(await ensureDeepSeekKeyForOneShot(resumeArgs))) process.exit(1);
     const config = loadConfig(resumeArgs, { packageDir });
     await runAgent(config);

package/src/scs-controller.js

@@ -207,7 +207,8 @@ export function buildSupervisorInstruction(scs = {}) {
   const criteria = normalizeStringList(scs.acceptanceCriteria);
   const stopConditions = normalizeStringList(scs.stopConditions);
   return [
-    "SCS mode is enabled. You are the supervisor executor.",
+    "SCS mode is enabled. SCS means Student-Committee-Supervisor; do not redefine the acronym.",
+    "You are the supervisor executor in that Student-Committee-Supervisor pipeline.",
     "Execute the approved phase plan. You may choose exact tools and paths, but you may not replace the strategic plan with a new one.",
     formatBehaviorContractForPrompt(),
     "If tool evidence invalidates the plan, stop repeating the failed path and explain the blocker through finish or wait for student review.",