@lazyingart/agintiflow 0.20.65 → 0.20.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.65",
+  "version": "0.20.67",
   "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-aaps-adapter.js

@@ -24,6 +24,7 @@ async function exists(file) {
 const init = await runAapsAction("init", ["Smoke AAPS Project"], { cwd: tempRoot, packageDir: repoRoot });
 assert(init.ok, "AAPS init failed");
 assert(await exists(path.join(tempRoot, "aaps.project.json")), "AAPS init did not write manifest");
+assert(await exists(path.join(tempRoot, "agents", "agent_registry.json")), "AAPS init did not write starter agent registry");
 assert(await exists(path.join(tempRoot, "workflows", "main.aaps")), "AAPS init did not write starter workflow");
 
 const files = await runAapsAction("files", [], { cwd: tempRoot, packageDir: repoRoot });
@@ -43,10 +44,7 @@ if (discovery.found) {
 
   const compile = await runAapsAction("compile", ["check"], { cwd: tempRoot, packageDir: repoRoot });
   assert(compile.json?.phase?.parse === "ok", `AAPS compile check did not return a structured parse-ok report\n${formatAapsResult(compile)}`);
-  assert(
-    compile.json?.status === "missing_components" || compile.json?.ok === true,
-    `AAPS compile check returned an unexpected status\n${formatAapsResult(compile)}`
-  );
+  assert(compile.ok && compile.json?.ok === true, `AAPS starter should compile cleanly after init\n${formatAapsResult(compile)}`);
 } else {
   const validate = await runAapsAction("validate", [], { cwd: tempRoot, packageDir: repoRoot });
   assert(validate.ok === false && validate.error, "AAPS missing path should return a structured error");

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 } from "../src/interactive-cli.js";
-import { buildSupervisorInstruction } from "../src/scs-controller.js";
+import { buildScsEvidencePack, buildSupervisorInstruction } from "../src/scs-controller.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -208,6 +208,27 @@ 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");
+const longStdout = [
+  "=== Student-Committee-Supervisor present ===",
+  "3:SCS stands for **Student-Committee-Supervisor**",
+  "=== Syntax-Checker Sentinel absent ===",
+  "OK: absent",
+  "=== Residual content ===",
+  "py_compile FOUND",
+  "f-string FOUND",
+  "artifact integrity FOUND",
+].join("\n");
+const scsEvidence = buildScsEvidencePack({
+  goal: "verify SCS artifact",
+  messages: [
+    {
+      role: "tool",
+      content: JSON.stringify({ toolName: "run_command", ok: true, stdout: `${longStdout}\n${"x".repeat(700)}` }),
+    },
+  ],
+});
+assert(scsEvidence.includes("Student-Committee-Supervisor"), "SCS evidence pack should preserve raw verification stdout");
+assert(scsEvidence.includes("Syntax-Checker Sentinel absent"), "SCS evidence pack should keep absence checks visible to the final gate");
 
 const output = await runCli(["models"]);
 assert(output.includes("/route") && output.includes("/spare") && output.includes("venice-gpt"), "aginti models output missing role details");
@@ -237,6 +258,7 @@ console.log(
         "requested-tools-parser",
         "malformed-text-tool-retry",
         "scs-supervisor-identity",
+        "scs-evidence-stdout",
         "cli-models-command",
         "venice-shortcut",
       ],

package/src/aaps-adapter.js

@@ -478,13 +478,21 @@ async function createAapsStarterProject({ cwd = process.cwd(), name = "" } = {})
   const projectDir = path.resolve(cwd || process.cwd());
   const projectName = String(name || path.basename(projectDir) || "AgInTiFlow AAPS Project").trim();
   const workflowDir = path.join(projectDir, "workflows");
+  const agentsDir = path.join(projectDir, "agents");
   const reportsDir = path.join(projectDir, "reports");
   const runsDir = path.join(projectDir, "runs");
   const artifactsDir = path.join(projectDir, "artifacts");
-  await Promise.all([fs.mkdir(workflowDir, { recursive: true }), fs.mkdir(reportsDir, { recursive: true }), fs.mkdir(runsDir, { recursive: true }), fs.mkdir(artifactsDir, { recursive: true })]);
+  await Promise.all([
+    fs.mkdir(workflowDir, { recursive: true }),
+    fs.mkdir(agentsDir, { recursive: true }),
+    fs.mkdir(reportsDir, { recursive: true }),
+    fs.mkdir(runsDir, { recursive: true }),
+    fs.mkdir(artifactsDir, { recursive: true }),
+  ]);
 
   const manifestPath = path.join(projectDir, "aaps.project.json");
   const workflowPath = path.join(workflowDir, "main.aaps");
+  const agentRegistryPath = path.join(agentsDir, "agent_registry.json");
   const created = [];
   if (!fsSync.existsSync(manifestPath)) {
     const now = new Date().toISOString();
@@ -501,6 +509,7 @@ async function createAapsStarterProject({ cwd = process.cwd(), name = "" } = {})
       updated: now,
       paths: {
         workflows: "workflows",
+        agents: "agents",
         blocks: "blocks",
         skills: "skills",
         modules: "modules",
@@ -515,6 +524,7 @@ async function createAapsStarterProject({ cwd = process.cwd(), name = "" } = {})
       runDatabase: "runs/aaps-runs.jsonl",
       tools: ["node", "python3", "git", "aginti"],
       models: ["deepseek-v4-flash", "deepseek-v4-pro"],
+      agents: ["planner"],
       files: {
         workflows: ["workflows/main.aaps"],
         blocks: [],
@@ -530,6 +540,22 @@ async function createAapsStarterProject({ cwd = process.cwd(), name = "" } = {})
     await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
     created.push("aaps.project.json");
   }
+  if (!fsSync.existsSync(agentRegistryPath)) {
+    const registry = {
+      agents: [
+        {
+          name: "planner",
+          purpose: "Plan large project work in small, verifiable phases for the starter AAPS workflow.",
+          invocation: "prompt",
+          supportedTasks: ["planning", "workflow_planning", "compile_prompt"],
+          safety: ["project-local edits only", "ask before risky shell commands", "no secrets in logs"],
+          fallback: "prepare prompt-only handoff",
+        },
+      ],
+    };
+    await fs.writeFile(agentRegistryPath, `${JSON.stringify(registry, null, 2)}\n`, "utf8");
+    created.push("agents/agent_registry.json");
+  }
   if (!fsSync.existsSync(workflowPath)) {
     const source = `pipeline "${projectName} Starter" {
   subtitle "A project-local AAPS workflow for AgInTiFlow"

package/src/scs-controller.js

@@ -166,7 +166,7 @@ export function buildScsEvidencePack(state = {}, context = {}) {
         return `tool:${parsed.toolName || message.tool_call_id || "unknown"} ok=${parsed.ok !== false} done=${Boolean(parsed.done)} ${compactJson(
           {
             error: parsed.error || parsed.reason || "",
-            stdout: parsed.stdout ? String(parsed.stdout).slice(0, 300) : "",
+            stdout: parsed.stdout ? String(parsed.stdout).slice(0, 1200) : "",
             path: parsed.path || "",
             changes: Array.isArray(parsed.changes) ? parsed.changes.map((change) => change.path).filter(Boolean) : [],
           },
@@ -458,7 +458,7 @@ export async function reviewScsFinish(client, config, state, result = "", contex
       {
         role: "system",
         content:
-          "You are the SCS student final gate. Decide if the supervisor has enough concrete evidence to finish. Emit finish_allowed or finish_rejected only. Be strict for coding/system tasks, but do not demand impossible checks. Return strict JSON with keys: role, decision, confidence, evidence, reason, next_required_action.",
+          "You are the SCS student final gate. Decide if the supervisor has enough concrete evidence to finish. Emit finish_allowed or finish_rejected only. Be strict for coding/system tasks, but do not demand impossible checks. Evaluate both the proposed final result and the evidence pack; tool stdout in recentMessages/recentEvents is raw command evidence and does not need to be duplicated in the final answer. Reject only when neither the final answer nor the evidence pack contains concrete file/tool/check evidence for the acceptance criteria. Return strict JSON with keys: role, decision, confidence, evidence, reason, next_required_action.",
       },
       {
         role: "user",