@lazyingart/agintiflow 0.20.49 → 0.20.50

package/src/agent-runner.js

@@ -27,6 +27,15 @@ import { hostShellOption, platformInfo, platformLabel } from "./platform.js";
 import { captureTmuxPane, listTmuxSessions, sendTmuxKeys, startTmuxSession } from "./tmux-tools.js";
 import { languageInstruction } from "./i18n.js";
 import { flushHousekeeping } from "./housekeeping.js";
+import {
+  buildSupervisorInstruction,
+  createScsPlan,
+  reviewScsFinish,
+  reviewScsProgress,
+  reviewScsToolResult,
+  shouldReviewScsProgress,
+  shouldReviewToolResult,
+} from "./scs-controller.js";
 
 const exec = promisify(execCallback);
 const BROWSER_TOOLS = new Set(["open_url", "open_workspace_file", "preview_workspace", "click", "type", "scroll", "press", "back"]);
@@ -332,6 +341,9 @@ async function createInitialState(config, sessionId) {
           config.allowParallelScouts
             ? `Parallel DeepSeek scouts may run before complex execution. Scout count: ${config.parallelScoutCount}.`
             : "Parallel scouts are disabled.",
+          config.scsActive
+            ? "Student-Committee-Supervisor mode is active. A committee/student gate will approve a phase plan, and you will execute as the supervisor under the approved phase constraints."
+            : "",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           skillContext,
           engineeringGuidance,
@@ -378,6 +390,7 @@ async function createInitialState(config, sessionId) {
             : "",
           config.allowWebSearch ? "Web search tool: enabled." : "Web search tool: disabled.",
           config.allowParallelScouts ? `Parallel scouts: enabled count=${config.parallelScoutCount}.` : "Parallel scouts: disabled.",
+          config.scsActive ? "SCS mode: active. Wait for the approved supervisor phase instruction before treating the plan as executable." : "",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           skillContext,
           engineeringGuidance,
@@ -1283,6 +1296,8 @@ export async function runAgent(config) {
       model: config.model,
       routingMode: config.routingMode,
       routeReason: config.routeReason,
+      scsActive: Boolean(config.scsActive),
+      scsMode: config.enableScs || "off",
       goal: config.goal,
     });
     await store.appendEvent("skills.selected", {
@@ -1305,17 +1320,75 @@ export async function runAgent(config) {
     model: config.model,
     routingMode: config.routingMode,
     routeReason: config.routeReason,
+    scsActive: Boolean(config.scsActive),
+    scsMode: config.enableScs || "off",
   });
 
   try {
     throwIfAborted(config);
     if (!state.plan) {
-      const plan = await createPlan(client, config, state);
-      state.plan = plan;
-      await store.savePlan(plan);
-      await store.appendEvent("plan.created", { plan });
+      if (config.scsActive) {
+        const scsPlan = await createScsPlan(client, config, state, {
+          events: await store.loadEvents(),
+          taskProfile: config.taskProfile,
+          goal: config.goal,
+        });
+        state.plan = scsPlan.plan;
+        state.meta.scs = scsPlan.scs;
+        state.messages.push({
+          role: "user",
+          content: scsPlan.supervisorInstruction,
+        });
+        state.meta.scs.supervisorInstructionInjected = true;
+        await store.saveJsonArtifact("scs-phase-001.json", scsPlan.scs).catch(() => "");
+        await store.appendEvent("scs.enabled", {
+          mode: config.enableScs,
+          model: `${config.provider}/${config.model}`,
+        });
+        await store.appendEvent("scs.committee.plan_drafted", {
+          phase: scsPlan.scs.phase,
+          phaseGoal: scsPlan.scs.phaseGoal,
+          plan: scsPlan.plan,
+          acceptanceCriteria: scsPlan.scs.acceptanceCriteria,
+        });
+        await store.appendEvent(`scs.student.${scsPlan.scs.student.decision}`, scsPlan.scs.student);
+        await store.appendEvent("scs.supervisor.phase_started", {
+          phase: scsPlan.scs.phase,
+          phaseGoal: scsPlan.scs.phaseGoal,
+        });
+        await store.savePlan(scsPlan.plan);
+        await store.appendEvent("plan.created", { plan: scsPlan.plan, scs: true });
+        await store.saveState(state);
+        observers.event("plan.created", { plan: scsPlan.plan, scs: true });
+        observers.event("scs.student.approve_plan", scsPlan.scs.student);
+        emitConsole(config, `SCS: student approved phase plan (${Math.round((scsPlan.scs.student.confidence || 0) * 100)}%).`, {
+          kind: "meta",
+        });
+      } else {
+        const plan = await createPlan(client, config, state);
+        state.plan = plan;
+        await store.savePlan(plan);
+        await store.appendEvent("plan.created", { plan });
+        await store.saveState(state);
+        observers.event("plan.created", { plan });
+      }
+    } else if (config.scsActive && !state.meta?.scs?.supervisorInstructionInjected) {
+      state.meta.scs = state.meta.scs || {
+        enabled: true,
+        mode: config.enableScs || "on",
+        active: true,
+        model: `${config.provider}/${config.model}`,
+        phase: 1,
+        plan: state.plan,
+        finishRejects: 0,
+        monitorReviews: 0,
+      };
+      state.messages.push({
+        role: "user",
+        content: buildSupervisorInstruction(state.meta.scs),
+      });
+      state.meta.scs.supervisorInstructionInjected = true;
       await store.saveState(state);
-      observers.event("plan.created", { plan });
     }
 
     if (shouldRunParallelScouts(config, state)) {
@@ -1379,6 +1452,8 @@ export async function runAgent(config) {
       routingMode: config.routingMode,
       routeReason: config.routeReason,
       taskProfile: config.taskProfile,
+      scsActive: Boolean(config.scsActive),
+      scsMode: config.enableScs || "off",
       commandCwd: config.commandCwd,
       allowShellTool: config.allowShellTool,
       allowWrapperTools: config.allowWrapperTools,
@@ -1399,6 +1474,7 @@ export async function runAgent(config) {
     emitConsole(config, `Provider: ${config.provider}`, { kind: "meta" });
     emitConsole(config, `Model: ${config.model}`, { kind: "meta" });
     emitConsole(config, `Routing: ${config.routingMode} (${config.routeReason})`, { kind: "meta" });
+    if (config.scsActive) emitConsole(config, `SCS: ${config.enableScs || "on"} using main-model policy`, { kind: "meta" });
     emitConsole(config, `Workspace: ${config.commandCwd}`, { kind: "meta" });
     emitConsole(config, `Sessions: ${config.sessionsDir}`, { kind: "meta" });
     if (config.projectSessionsDir) emitConsole(config, `Project session index: ${config.projectSessionsDir}`, { kind: "meta" });
@@ -1517,6 +1593,37 @@ export async function runAgent(config) {
           continue;
         }
         const fallback = assistantMessage.content?.trim() || "No tool call returned.";
+        if (config.scsActive) {
+          const decision = await reviewScsFinish(client, config, state, fallback, {
+            events: await store.loadEvents(),
+            taskProfile: config.taskProfile,
+            goal: config.goal,
+          });
+          state.meta.scs = state.meta.scs || { enabled: true, mode: config.enableScs || "on", active: true };
+          state.meta.scs.lastStudentDecision = decision;
+          await store.appendEvent(`scs.student.${decision.decision}`, decision);
+          observers.event(`scs.student.${decision.decision}`, {
+            decision: decision.decision,
+            reason: decision.reason,
+          });
+          if (decision.decision === "finish_rejected") {
+            state.meta.scs.finishRejects = (state.meta.scs.finishRejects || 0) + 1;
+            state.messages.push({
+              role: "user",
+              content: [
+                "SCS student rejected the proposed finish.",
+                `Reason: ${decision.reason || "Finish lacked enough evidence."}`,
+                "Supervisor: continue with the approved phase, collect concrete evidence, or call finish with a clear blocker.",
+              ].join("\n"),
+            });
+            state.stepsCompleted = step;
+            state.updatedAt = new Date().toISOString();
+            await store.saveState(state);
+            emitConsole(config, `SCS: finish rejected: ${decision.reason || "needs more evidence"}`, { kind: "meta" });
+            continue;
+          }
+          emitConsole(config, `SCS: finish approved (${Math.round((decision.confidence || 0) * 100)}%).`, { kind: "meta" });
+        }
         appendChatEntry(state, "assistant", fallback);
         await store.appendEvent("session.finished", {
           result: fallback,
@@ -1547,6 +1654,43 @@ export async function runAgent(config) {
         });
         await applyToolLoopGuard(state, toolResult, store, observers);
 
+        if (config.scsActive && shouldReviewToolResult(toolResult, state)) {
+          const decision = await reviewScsToolResult(client, config, state, toolResult, {
+            events: await store.loadEvents(),
+            taskProfile: config.taskProfile,
+            goal: config.goal,
+          });
+          state.meta.scs = state.meta.scs || { enabled: true, mode: config.enableScs || "on", active: true };
+          state.meta.scs.monitorReviews = (state.meta.scs.monitorReviews || 0) + 1;
+          state.meta.scs.lastStudentDecision = decision;
+          await store.appendEvent(`scs.student.${decision.decision}`, {
+            ...decision,
+            toolName: toolResult.toolName,
+          });
+          observers.event(`scs.student.${decision.decision}`, {
+            decision: decision.decision,
+            reason: decision.reason,
+            toolName: toolResult.toolName,
+          });
+          if (decision.decision === "rethink_plan" || decision.decision === "reject_phase") {
+            state.messages.push({
+              role: "user",
+              content: [
+                "SCS student monitor requested a rethink based on tool evidence.",
+                `Decision: ${decision.decision}`,
+                `Reason: ${decision.reason || "No reason provided."}`,
+                decision.nextRequiredAction ? `Next required action: ${decision.nextRequiredAction}` : "",
+                "Supervisor: do not repeat the same failed call. Adjust within the approved phase or finish with a concrete blocker if the phase is invalidated.",
+              ]
+                .filter(Boolean)
+                .join("\n"),
+            });
+            emitConsole(config, `SCS: ${decision.decision} after ${toolResult.toolName}: ${decision.reason || "reviewed"}`, {
+              kind: "meta",
+            });
+          }
+        }
+
         if (toolResult.toolName === "run_command") {
           observers.log("command.output", {
             command: redactSensitiveText(toolResult.args?.command || ""),
@@ -1580,6 +1724,37 @@ export async function runAgent(config) {
         }
 
         if (toolResult.done) {
+          if (config.scsActive) {
+            const decision = await reviewScsFinish(client, config, state, toolResult.result, {
+              events: await store.loadEvents(),
+              taskProfile: config.taskProfile,
+              goal: config.goal,
+            });
+            state.meta.scs = state.meta.scs || { enabled: true, mode: config.enableScs || "on", active: true };
+            state.meta.scs.lastStudentDecision = decision;
+            await store.appendEvent(`scs.student.${decision.decision}`, decision);
+            observers.event(`scs.student.${decision.decision}`, {
+              decision: decision.decision,
+              reason: decision.reason,
+            });
+            if (decision.decision === "finish_rejected") {
+              state.meta.scs.finishRejects = (state.meta.scs.finishRejects || 0) + 1;
+              state.messages.push({
+                role: "user",
+                content: [
+                  "SCS student rejected the proposed finish.",
+                  `Reason: ${decision.reason || "Finish lacked enough evidence."}`,
+                  "Supervisor: continue with the approved phase, collect concrete evidence, or call finish with a clear blocker.",
+                ].join("\n"),
+              });
+              state.stepsCompleted = step;
+              state.updatedAt = new Date().toISOString();
+              await store.saveState(state);
+              emitConsole(config, `SCS: finish rejected: ${decision.reason || "needs more evidence"}`, { kind: "meta" });
+              continue;
+            }
+            emitConsole(config, `SCS: finish approved (${Math.round((decision.confidence || 0) * 100)}%).`, { kind: "meta" });
+          }
           const queuedCount = await injectQueuedUserMessages(store, state, observers);
           if (queuedCount > 0) {
             state.stepsCompleted = step;
@@ -1615,6 +1790,42 @@ export async function runAgent(config) {
 
       if (continueForQueuedInput) continue;
 
+      if (config.scsActive && shouldReviewScsProgress(step, state)) {
+        const decision = await reviewScsProgress(client, config, state, {
+          events: await store.loadEvents(),
+          taskProfile: config.taskProfile,
+          goal: config.goal,
+        });
+        state.meta.scs = state.meta.scs || { enabled: true, mode: config.enableScs || "on", active: true };
+        state.meta.scs.monitorReviews = (state.meta.scs.monitorReviews || 0) + 1;
+        state.meta.scs.lastStudentDecision = decision;
+        await store.appendEvent(`scs.student.${decision.decision}`, {
+          ...decision,
+          step,
+          trigger: "periodic",
+        });
+        observers.event(`scs.student.${decision.decision}`, {
+          decision: decision.decision,
+          reason: decision.reason,
+          trigger: "periodic",
+        });
+        if (decision.decision === "rethink_plan" || decision.decision === "reject_phase") {
+          state.messages.push({
+            role: "user",
+            content: [
+              "SCS student requested a periodic rethink.",
+              `Decision: ${decision.decision}`,
+              `Reason: ${decision.reason || "No reason provided."}`,
+              decision.nextRequiredAction ? `Next required action: ${decision.nextRequiredAction}` : "",
+              "Supervisor: adjust the next action within the approved phase, collect stronger evidence, or finish with a concrete blocker if the phase is invalidated.",
+            ]
+              .filter(Boolean)
+              .join("\n"),
+          });
+          emitConsole(config, `SCS: periodic ${decision.decision}: ${decision.reason || "reviewed"}`, { kind: "meta" });
+        }
+      }
+
       await injectQueuedUserMessages(store, state, observers);
 
       state.stepsCompleted = step;

package/src/cli.js

@@ -34,6 +34,7 @@ import { languageLabel, resolveLanguage } from "./i18n.js";
 import { maybeAutoUpdate } from "./auto-update.js";
 import { readHousekeepingSummary } from "./housekeeping.js";
 import { handleSkillMeshCommand } from "./skillmesh.js";
+import { handleAapsCliCommand } from "./aaps-adapter.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -105,6 +106,7 @@ export function parseArgs(argv) {
     image: false,
     language: "",
     autoUpdate: undefined,
+    enableScs: "",
   };
 
   const parts = [];
@@ -148,6 +150,16 @@ export function parseArgs(argv) {
       result.autoUpdate = true;
       continue;
     }
+    if (arg === "--enabless" || arg === "--enable-scs" || arg === "--scs") {
+      const value = readOption(argv, i);
+      result.enableScs = value || "on";
+      if (value) i += 1;
+      continue;
+    }
+    if (arg === "--no-enabless" || arg === "--disable-scs" || arg === "--no-scs") {
+      result.enableScs = "off";
+      continue;
+    }
     if (arg === "--start-url") {
       result.startUrl = readOption(argv, i);
       i += 1;
@@ -383,11 +395,40 @@ export function parseArgs(argv) {
 
 function printUsage() {
   console.log(
-    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti update OR aginti models OR aginti skills [query] OR aginti skillmesh [status|off|record|share|sync|serve|service] OR aginti housekeeping [--json] OR aginti auth [deepseek|openai|qwen|venice|grsai] OR aginti resume [--all-sessions] [latest|<session-id>] ["prompt"] OR aginti --remove-empty-sessions OR aginti --remove-sessions OR aginti queue <session-id> "message" OR aginti [--no-auto-update] [--language en|ja|zh-Hans|zh-Hant|ko|fr|es|ar|vi|de|ru] [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|qwen|venice|mock] [--model MODEL] [--route-model MODEL] [--main-model MODEL] [--spare-model MODEL --spare-reasoning medium] [--aux-provider grsai|venice --aux-model MODEL] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-file-tools|--no-file-tools] [--web-search|--no-web-search] [--parallel-scouts|--no-parallel-scouts --scout-count 1..10] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex --wrapper-model gpt-5.5] [--list-models|--list-routes] "your task"'
+    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti update OR aginti models OR aginti aaps [status|init|files|validate|compile|check|run] OR aginti skills [query] OR aginti skillmesh [status|off|record|share|sync|serve|service] OR aginti housekeeping [--json] OR aginti auth [deepseek|openai|qwen|venice|grsai] OR aginti resume [--all-sessions] [latest|<session-id>] ["prompt"] OR aginti --remove-empty-sessions OR aginti --remove-sessions OR aginti queue <session-id> "message" OR aginti [--no-auto-update] [--language en|ja|zh-Hans|zh-Hant|ko|fr|es|ar|vi|de|ru] [--image] [--latex] [--enabless|--enabless auto|--no-enabless] [--routing smart|fast|complex|manual] [--provider deepseek|openai|qwen|venice|mock] [--model MODEL] [--route-model MODEL] [--main-model MODEL] [--spare-model MODEL --spare-reasoning medium] [--aux-provider grsai|venice --aux-model MODEL] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-file-tools|--no-file-tools] [--web-search|--no-web-search] [--parallel-scouts|--no-parallel-scouts --scout-count 1..10] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex --wrapper-model gpt-5.5] [--list-models|--list-routes] "your task"'
   );
   console.log(`Languages: ${["en", "ja", "zh-Hans", "zh-Hant", "ko", "fr", "es", "ar", "vi", "de", "ru"].map((code) => `${code}=${languageLabel(code)}`).join(", ")}`);
 }
 
+function stripLeadingGlobalOptions(argv = []) {
+  let index = 0;
+  const options = {
+    commandCwd: "",
+  };
+  while (index < argv.length) {
+    const arg = argv[index];
+    if (arg === "--no-auto-update" || arg === "--auto-update") {
+      index += 1;
+      continue;
+    }
+    if (arg === "--language" || arg === "--lang" || arg === "-L") {
+      index += readOption(argv, index) ? 2 : 1;
+      continue;
+    }
+    if (arg === "--cwd") {
+      const cwd = readOption(argv, index);
+      if (cwd) options.commandCwd = path.resolve(cwd);
+      index += cwd ? 2 : 1;
+      continue;
+    }
+    break;
+  }
+  return {
+    argv: argv.slice(index),
+    options,
+  };
+}
+
 function providerLabel(provider) {
   const normalized = String(provider || "").toLowerCase();
   if (normalized === "openai") return "OpenAI";
@@ -421,6 +462,7 @@ function agentDefaults(args) {
     allowAuxiliaryTools: args.allowAuxiliaryTools ?? true,
     allowWebSearch: args.allowWebSearch ?? true,
     allowParallelScouts: args.allowParallelScouts ?? true,
+    enableScs: args.enableScs || process.env.AGINTI_SCS_MODE || "off",
     parallelScoutCount: args.parallelScoutCount || (Number.isFinite(envScoutCount) && envScoutCount > 0 ? envScoutCount : 3),
     sandboxMode: args.sandboxMode || envSandboxMode || "docker-workspace",
     packageInstallPolicy: args.packageInstallPolicy || envPackageInstallPolicy || "allow",
@@ -1036,6 +1078,20 @@ export async function main(argv = process.argv.slice(2)) {
   });
   if (autoUpdateResult.restarted) process.exit(autoUpdateResult.exitCode ?? 0);
 
+  const stripped = stripLeadingGlobalOptions(argv);
+  const commandArgv = stripped.argv;
+  const commandCwd = stripped.options.commandCwd || process.cwd();
+
+  if (commandArgv[0] === "aaps") {
+    try {
+      await handleAapsCliCommand(commandArgv.slice(1), { cwd: commandCwd, packageDir });
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+    return;
+  }
+
   if (argv.includes("--remove-empty-sessions") || argv[0] === "remove-empty-sessions") {
     await handleRemoveSessionsCommand({ emptyOnly: true });
     return;

package/src/config.js

@@ -7,6 +7,7 @@ import { loadProjectEnv, projectPaths, resolveProjectRoot } from "./project.js";
 import { normalizeTaskProfile } from "./task-profiles.js";
 import { recommendedMaxStepsForTask } from "./engineering-guidance.js";
 import { resolveLanguage } from "./i18n.js";
+import { normalizeScsMode, shouldActivateScs } from "./scs-controller.js";
 
 function parseBoolean(value, fallback) {
   if (value === undefined) return fallback;
@@ -75,7 +76,15 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     auxiliaryModel: overrides.auxiliaryModel || args.auxiliaryModel || process.env.AGINTI_AUX_MODEL || "",
   });
 
-  const defaults = getProviderDefaults(route.provider);
+  const scsMode = normalizeScsMode(overrides.enableScs ?? args.enableScs ?? process.env.AGINTI_SCS_MODE ?? "off");
+  const scsActive = shouldActivateScs(scsMode, {
+    goal: args.goal || "",
+    taskProfile,
+    complexityScore: route.complexityScore,
+  });
+  const activeProvider = scsActive && route.provider !== "mock" ? modelRoles.main.provider : route.provider;
+  const activeModel = scsActive && route.provider !== "mock" ? modelRoles.main.model : route.model;
+  const defaults = getProviderDefaults(activeProvider);
   const defaultMaxSteps = recommendedMaxStepsForTask({
     goal: args.goal || "",
     taskProfile,
@@ -86,6 +95,14 @@ export function resolveRuntimeConfig(args, overrides = {}) {
   const requestedSandboxMode =
     overrides.sandboxMode || args.sandboxMode || process.env.SANDBOX_MODE || (dockerRequested ? "docker-workspace" : "host");
   const sandboxMode = normalizeSandboxMode(requestedSandboxMode);
+  const explicitParallelScouts =
+    overrides.allowParallelScouts !== undefined ||
+    args.allowParallelScouts !== undefined ||
+    process.env.AGINTI_PARALLEL_SCOUTS !== undefined;
+  const allowParallelScouts = parseBoolean(
+    overrides.allowParallelScouts ?? args.allowParallelScouts ?? process.env.AGINTI_PARALLEL_SCOUTS,
+    true
+  );
 
   return {
     ...defaults,
@@ -100,6 +117,9 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     language,
     routeReason: route.reason,
     routeComplexityScore: route.complexityScore,
+    enableScs: scsMode,
+    scsActive,
+    scsModelPolicy: scsActive ? "main" : "route",
     modelRoles,
     routeProvider: modelRoles.route.provider,
     routeModel: modelRoles.route.model,
@@ -114,10 +134,10 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     auxiliaryModel: modelRoles.auxiliary.model,
     requestedProvider,
     requestedModel: overrides.model || args.model || process.env.LLM_MODEL || "",
-    provider: route.provider,
+    provider: activeProvider,
     apiKey: overrides.apiKey || defaults.apiKey,
     baseURL: overrides.baseURL || defaults.baseURL,
-    model: route.model || defaults.model,
+    model: activeModel || defaults.model,
     maxSteps: parseNumber(overrides.maxSteps ?? args.maxSteps ?? process.env.MAX_STEPS, defaultMaxSteps),
     headless: parseBoolean(overrides.headless ?? args.headless ?? process.env.HEADLESS, false),
     allowedDomains: Array.isArray(overrides.allowedDomains)
@@ -136,10 +156,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
       true
     ),
     allowWebSearch: parseBoolean(overrides.allowWebSearch ?? args.allowWebSearch ?? process.env.ALLOW_WEB_SEARCH, true),
-    allowParallelScouts: parseBoolean(
-      overrides.allowParallelScouts ?? args.allowParallelScouts ?? process.env.AGINTI_PARALLEL_SCOUTS,
-      true
-    ),
+    allowParallelScouts: scsActive && !explicitParallelScouts ? false : allowParallelScouts,
     parallelScoutCount: clampNumber(
       parseNumber(overrides.parallelScoutCount ?? args.parallelScoutCount ?? process.env.AGINTI_SCOUT_COUNT, 3),
       1,

package/src/i18n.js

@@ -130,6 +130,7 @@ const TRANSLATIONS = {
     helpSpare: "Open spare selector, or set e.g. /spare openai/gpt-5.4 medium.",
     helpWrapper: "Configure optional external wrapper.",
     helpAuxiliary: "Manage optional auxiliary skills, including image generation.",
+    helpAaps: "Manage AAPS workflows through the optional @lazyingart/aaps adapter.",
     helpNew: "Start a fresh session on the next message.",
     helpResume: "Continue a saved session.",
     helpSessions: "List recent sessions in this project.",

package/src/interactive-cli.js

@@ -33,6 +33,8 @@ import {
   setSkillMeshMode,
   skillMeshModeChoices,
 } from "./skillmesh.js";
+import { normalizeScsMode } from "./scs-controller.js";
+import { formatAapsResult, runAapsAction } from "./aaps-adapter.js";
 
 const useColor = Boolean(input.isTTY && output.isTTY && process.env.AGINTIFLOW_NO_COLOR !== "1");
 const ansi = {
@@ -73,6 +75,7 @@ const SLASH_COMMANDS = [
   "/instructions",
   "/memory",
   "/auxiliary",
+  "/aaps",
   "/new",
   "/resume",
   "/sessions",
@@ -85,6 +88,8 @@ const SLASH_COMMANDS = [
   "/profile",
   "/web-search",
   "/scouts",
+  "/enabless",
+  "/scs",
   "/models",
   "/venice",
   "/route",
@@ -652,6 +657,7 @@ function printHelp() {
       `  ${command("/spare [provider/model] [reasoning]", "Open spare selector, or set e.g. /spare openai/gpt-5.4 medium.", "helpSpare")}`,
       `  ${command("/wrapper [on|off|codex model reasoning]", "Configure optional external wrapper.", "helpWrapper")}`,
       `  ${command("/auxiliary [status|grsai|venice|model [provider/model]|on|off|image]", "Manage optional auxiliary skills, including image generation.", "helpAuxiliary")}`,
+      `  ${command("/aaps [status|init|files|validate|compile|check|run]", "Manage AAPS workflows through the optional @lazyingart/aaps adapter.", "helpAaps")}`,
       `  ${command("/new", "Start a fresh session on the next message.", "helpNew")}`,
       `  ${command("/resume <session-id>", "Continue a saved session.", "helpResume")}`,
       `  ${command("/review [focus]", "Run a bounded repo/diff review with controlled context gathering.", "helpReview")}`,
@@ -662,6 +668,7 @@ function printHelp() {
       `  ${command("/profile <name>", "Set task profile, e.g. code, website, latex, maintenance.", "helpProfile")}`,
       `  ${command("/web-search on|off", "Enable or disable the web_search tool.", "helpWebSearch")}`,
       `  ${command("/scouts on|off|<1-10>", "Enable parallel DeepSeek scouts and set scout count.", "helpScouts")}`,
+      `  ${command("/enabless [auto|off|status]", "Enable Student-Committee-Supervisor gated execution.", "helpEnableScs")}`,
       `  ${command("/routing <mode>", "Set routing: smart, fast, complex, manual.", "helpRouting")}`,
       `  ${command("/provider [name]", "Open provider selector, or set deepseek/openai/qwen/venice/mock.", "helpProvider")}`,
       `  ${command("/docker on", "Use docker-workspace with approved package installs.", "helpDockerOn")}`,
@@ -1602,7 +1609,7 @@ function printStatus(state) {
   );
   printSystemLine(`profile=${state.taskProfile} maxSteps=${state.maxSteps}`);
   printSystemLine(
-    `shell=${state.allowShellTool} files=${state.allowFileTools} webSearch=${state.allowWebSearch} scouts=${state.allowParallelScouts}:${state.parallelScoutCount} auxiliary=${state.allowAuxiliaryTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
+    `shell=${state.allowShellTool} files=${state.allowFileTools} webSearch=${state.allowWebSearch} scouts=${state.allowParallelScouts}:${state.parallelScoutCount} scs=${state.enableScs || "off"} auxiliary=${state.allowAuxiliaryTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
   );
   if (state.sandboxMode !== "host") {
     printSystemLine(`dockerWorkspace=/workspace -> ${state.commandCwd || process.cwd()}`);
@@ -1737,6 +1744,7 @@ function createState(args = {}) {
     allowAuxiliaryTools: args.allowAuxiliaryTools ?? true,
     allowWebSearch: args.allowWebSearch ?? true,
     allowParallelScouts: args.allowParallelScouts ?? true,
+    enableScs: normalizeScsMode(args.enableScs || process.env.AGINTI_SCS_MODE || "off"),
     parallelScoutCount: args.parallelScoutCount || 3,
     allowWrapperTools: args.allowWrapperTools ?? false,
     allowDestructive: args.allowDestructive ?? false,
@@ -2629,6 +2637,35 @@ async function handleCommand(line, state, packageDir) {
     printAgentMessage("Usage: /auxiliary [status|select|grsai|venice|model [grsai/nano-banana-2]|on|off|image]");
     return true;
   }
+  if (command === "aaps") {
+    const [action = "status", ...aapsArgs] = value.split(/\s+/).filter(Boolean);
+    const normalizedAction = String(action || "status").toLowerCase();
+    if (normalizedAction === "on" || normalizedAction === "auto") {
+      state.taskProfile = "aaps";
+      state.maxSteps = Math.max(state.maxSteps, 36);
+      printSystemLine(`aaps=${normalizedAction} profile=aaps maxSteps=${state.maxSteps}`);
+      printAgentMessage("AAPS mode enabled. Use `/aaps init`, `/aaps validate`, `/aaps compile`, or write normal requests about .aaps workflows.");
+      return true;
+    }
+    if (normalizedAction === "off") {
+      state.taskProfile = "auto";
+      printSystemLine("aaps=off profile=auto");
+      return true;
+    }
+    try {
+      const result = await runAapsAction(normalizedAction, aapsArgs, {
+        cwd: state.commandCwd || process.cwd(),
+        packageDir,
+      });
+      printAgentMessage(formatAapsResult(result));
+      if (result.ok === false && result.error) {
+        printSystemLine(`aaps=failed ${result.error}`);
+      }
+    } catch (error) {
+      printAgentMessage(error instanceof Error ? error.message : String(error));
+    }
+    return true;
+  }
   if (command === "new") {
     state.sessionId = "";
     printAgentMessage("Next message will start a new session.");
@@ -2769,6 +2806,40 @@ async function handleCommand(line, state, packageDir) {
     printSystemLine(`parallelScouts=${state.allowParallelScouts ? "on" : "off"} count=${state.parallelScoutCount}`);
     return true;
   }
+  if (command === "enabless" || command === "scs") {
+    const rawMode = String(value || "").trim().toLowerCase();
+    const mode = value ? normalizeScsMode(value) : "on";
+    const knownMode =
+      !rawMode ||
+      ["on", "off", "auto", "smart", "status", "?", "true", "false", "yes", "no", "y", "n", "1", "0", "enable", "disable", "enabled", "disabled"].includes(
+        rawMode
+      );
+    if (!knownMode) {
+      printAgentMessage("Usage: /enabless [auto|off|status]. `/enabless` turns SCS on for the session.");
+      return true;
+    }
+    if (value === "status" || value === "?") {
+      printAgentMessage(
+        [
+          `SCS mode: ${state.enableScs || "off"}`,
+          "Student-Committee-Supervisor gates complex work with one main model: committee drafts, student approves/monitors, supervisor executes.",
+          "Use `/enabless` for on, `/enabless auto` for complex-task auto mode, or `/enabless off` for the normal fast pipeline.",
+        ].join("\n")
+      );
+      return true;
+    }
+    state.enableScs = mode;
+    if (mode === "on") {
+      state.allowParallelScouts = false;
+    }
+    printSystemLine(`scs=${state.enableScs}${state.enableScs !== "off" ? ` main=${state.mainProvider || "deepseek"}/${state.mainModel || "deepseek-v4-pro"}` : ""}`);
+    if (state.enableScs === "on") {
+      printAgentMessage("SCS enabled. Next run uses the main model for committee planning, student gates, and supervisor execution.");
+    } else if (state.enableScs === "auto") {
+      printAgentMessage("SCS auto enabled. It activates for complex, risky, or long-running tasks and stays off for simple turns.");
+    }
+    return true;
+  }
   if (command === "models") {
     printModelRoles(state);
     return true;
@@ -3024,6 +3095,7 @@ async function runPrompt(prompt, state, packageDir) {
       allowAuxiliaryTools: state.allowAuxiliaryTools,
       allowWebSearch: state.allowWebSearch,
       allowParallelScouts: state.allowParallelScouts,
+      enableScs: state.enableScs,
       parallelScoutCount: state.parallelScoutCount,
       allowWrapperTools: state.allowWrapperTools,
       allowDestructive: state.allowDestructive,