@lazyingart/agintiflow 0.20.49 → 0.20.50

package/README.md

@@ -13,7 +13,8 @@
 ![Node.js](https://img.shields.io/badge/Node.js-22%2B-339933?logo=nodedotjs&logoColor=white)
 ![Playwright](https://img.shields.io/badge/Browser-Playwright-2EAD33?logo=playwright&logoColor=white)
 ![Express](https://img.shields.io/badge/Web-Express-111827)
-![Models](https://img.shields.io/badge/Models-OpenAI%20%2B%20DeepSeek-0ea5e9)
+![Text Models](https://img.shields.io/badge/Text%20Models-DeepSeek%20%2B%20Venice%20%2B%20OpenAI-0ea5e9)
+![Aux Image Models](https://img.shields.io/badge/Aux%20Image-GRS%20AI%20%2B%20Venice-ec4899)
 ![Sandbox](https://img.shields.io/badge/Shell-Docker%20Sandbox-f97316)
 ![Status](https://img.shields.io/badge/Status-Prototype-7c3aed)
 
@@ -50,7 +51,7 @@ aginti --list-profiles
 aginti --sandbox-status
 ```
 
-When AgInTiFlow is installed globally from npm, normal `aginti`, `aginti chat`, `aginti resume`, and `aginti web` startup revalidates npm for a newer `@lazyingart/agintiflow` release before the session starts. If a newer version is found in an interactive terminal, AgInTiFlow shows an Up/Down selector with `Update now`, `Skip this time`, and `Skip this version`; updating runs `npm install -g @lazyingart/agintiflow@latest` and restarts the CLI once. Source checkouts, non-TTY automation, and utility commands skip this behavior. Force a check with `aginti update`, skip one run with `--no-auto-update`, disable it with `AGINTIFLOW_NO_AUTO_UPDATE=1`, or throttle startup checks with `AGINTIFLOW_AUTO_UPDATE_STARTUP_INTERVAL_MS`.
+When AgInTiFlow is installed globally from npm, normal `aginti`, `aginti chat`, `aginti resume`, and `aginti web` startup revalidates npm for a newer `@lazyingart/agintiflow` release before the session starts. If a newer version is found in an interactive terminal, AgInTiFlow shows an Up/Down selector with `Update now`, `Skip this time`, and `Skip this version`; updating runs `npm install -g @lazyingart/agintiflow@latest` and restarts the CLI once. Source checkouts, non-TTY automation, and utility commands skip this behavior. If you skip or disable auto-update, AgInTiFlow runs as normal using your current version. Force a check with `aginti update`, skip one run with `--no-auto-update`, disable it with `AGINTIFLOW_NO_AUTO_UPDATE=1`, or throttle startup checks with `AGINTIFLOW_AUTO_UPDATE_STARTUP_INTERVAL_MS`.
 
 On first interactive use, if no main model key is detected, `aginti` opens an auth wizard. Use Up/Down to choose DeepSeek, OpenAI, Qwen, or Venice, paste the key, and press Enter to save it to the project-local ignored file `.aginti/.env` with `0600` permissions. The wizard points to DeepSeek keys at `https://platform.deepseek.com/api_keys`, OpenAI keys at `https://platform.openai.com/api-keys`, and Venice at `https://venice.ai`. It then offers the optional auxiliary image key; press Esc to skip. You can rerun it even when keys already exist:
 
@@ -90,10 +91,14 @@ For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSee
 
 Model choice is role-based: `/route` defaults to DeepSeek V4 Flash, `/model` or `/main` defaults to DeepSeek V4 Pro, `/spare` defaults to OpenAI GPT-5.4 medium, `/wrapper` defaults to Codex GPT-5.5 medium when enabled, and `/auxiliary` defaults to GRS AI/Nano Banana for image tools. See [docs/model-selection.md](docs/model-selection.md) and run `aginti models`.
 
+AAPS large-workflow support is available through the optional adapter. Use `aginti aaps status`, `aginti aaps init`, `aginti aaps validate`, or `/aaps` in chat to manage project-local `.aaps` workflows without making AAPS a hard dependency of AgInTiFlow. This lets AAPS describe the top-down pipeline while AgInTiFlow remains the interactive agent/tool backend. See [docs/aaps.md](docs/aaps.md).
+
 For larger repositories, use `--profile large-codebase` or choose **Large codebase engineering** in the web UI. The web default stays **Auto**, and Auto now escalates codebase/system/debugging prompts to the same engineering loop when needed. Complex work routes to DeepSeek v4 pro, starts with `inspect_project`, then uses search/read/patch/check loops inspired by Codex, Copilot SDK, Claude Code, Gemini CLI, Qwen, and Claw Code. See [docs/large-codebase-engineering.md](docs/large-codebase-engineering.md).
 
 AgInTiFlow can also spend cheap DeepSeek calls on parallel scout notes before the main executor starts a complicated task. It first writes a bounded project map to `.aginti/codebase-map.json`, then runs scouts for architecture, implementation, review, research, context mapping, tests, git workflow, integration, symbol tracing, and dependency risks. A coordinator Swarm Board is injected for the main agent and saved as `artifacts/scout-blackboard.json` in the session. The executor still does the real file/shell/browser work itself. Disable with `--no-parallel-scouts` or set `--scout-count 1..10`.
 
+For complicated tasks that need stricter quality control, enable Student-Committee-Supervisor mode with `/enabless`, `--enabless`, or `--enabless auto`. SCS uses the main model for a typed gate: committee drafts the next phase, student approves/monitors/rejects weak evidence, and supervisor executes with the normal guarded tools. It disables duplicate scout advice by default, logs typed `scs.*` events, caps retries to avoid deadlock, and stays off unless you opt in or choose auto mode. See [docs/student-committee-supervisor.md](docs/student-committee-supervisor.md).
+
 The next productive-agent roadmap is tracked in [docs/productive-agent-roadmap.md](docs/productive-agent-roadmap.md): durable codebase maps, stronger scout blackboards, long-run checkpoints, LSP/symbol tools, test triage, and release automation. Runtime choices, Docker persistence, host full-access tradeoffs, tmux sessions, and rolling-plan autonomy are documented in [docs/runtime-modes-and-autonomy.md](docs/runtime-modes-and-autonomy.md). The supervised self-development protocol is in [docs/self-development-supervision.md](docs/self-development-supervision.md).
 
 For current docs, install errors, package/toolchain setup, and source discovery, the agent has a guarded `web_search` tool. It returns compact search results without browser search-engine loops and respects configured domain allowlists. Disable with `--no-web-search`.
@@ -146,9 +151,15 @@ aginti resume --all-sessions
 aginti resume latest
 aginti resume <session-id> "continue with a short follow-up"
 aginti queue <session-id> "extra instruction for the running agent"
+aginti aaps status
+aginti aaps init "Project Workflow"
+aginti aaps validate
 aginti chat
 # then in chat: /review [focus]
+# then in chat: /enabless auto
+# then in chat: /aaps validate
 aginti --profile code "write a small Python CLI app with tests"
+aginti --enabless auto "fix this complicated project and verify it"
 aginti --latex "draw a figure, write a short LaTeX report, and compile the PDF"
 aginti "set up this project and run the tests"
 ```
@@ -159,6 +170,8 @@ Session cleanup is cwd-scoped by default. `aginti --remove-empty-sessions` shows
 
 In interactive chat, `/review [focus]` starts a bounded repository review. It begins from git status/diff and project instructions, reads manifests/entry points/tests/changed files first, avoids generated or binary folders, limits discovery passes, and reports findings before any summary.
 
+In interactive chat, `/enabless` turns on SCS for the session, `/enabless auto` activates it only for complex/risky work, `/enabless off` restores the normal fast pipeline, and `/enabless status` explains the current mode.
+
 Run from a source checkout:
 
 ```bash

package/docs/aaps.md

@@ -0,0 +1,70 @@
+# AAPS Adapter
+
+AgInTiFlow can use AAPS as a declarative control plane for large work. AAPS owns the top-down workflow script (`.aaps`), project manifest, validation contracts, compile reports, and run artifacts. AgInTiFlow remains the interactive agent runtime with model routing, file tools, shell policy, Docker mode, tmux, sessions, and canvas artifacts.
+
+The integration is intentionally lightweight. AgInTiFlow does not vendor the AAPS parser or require AAPS as a hard dependency. It discovers AAPS at runtime in this order:
+
+1. `AAPS_BIN` or `AGINTI_AAPS_BIN`.
+2. `node_modules/.bin/aaps` in the current project.
+3. `aaps` on `PATH`.
+4. A sibling development checkout at `~/ProjectsLFS/AAPS/scripts/aaps.js` when present.
+
+## CLI
+
+```bash
+aginti aaps status
+aginti aaps init "My AAPS Project"
+aginti aaps files
+aginti aaps validate
+aginti aaps parse
+aginti aaps compile check
+aginti aaps check workflows/main.aaps
+aginti aaps dry-run workflows/main.aaps
+aginti aaps run workflows/main.aaps
+```
+
+Inside the interactive CLI, use the same commands with a slash:
+
+```text
+/aaps
+/aaps on
+/aaps init
+/aaps validate
+/aaps compile check
+/aaps dry-run workflows/main.aaps
+```
+
+`/aaps on` switches the session to the AAPS task profile and raises the step budget for workflow work. `/aaps off` returns to the Auto profile.
+
+## Safety
+
+The adapter keeps paths project-relative and uses `execFile`, not shell interpolation. `status`, `files`, and `init` work without AAPS installed. Validation, parse, compile, check, and run require a discovered AAPS CLI.
+
+`compile check` and `validate` are the recommended first checks. `run` can execute commands declared by the `.aaps` workflow, so treat it like any other project execution step and run only workflows you intend to execute.
+
+`aginti aaps install` installs `@lazyingart/aaps` as a project dev dependency only when the current project has `package.json`. Use `aginti aaps install global` only when you intentionally want a global npm install.
+
+## Project Shape
+
+`aginti aaps init` creates a starter project without overwriting existing files:
+
+```text
+aaps.project.json
+workflows/main.aaps
+reports/
+runs/
+artifacts/
+```
+
+The starter workflow is deliberately simple: it defines a planner agent and a `draft_plan` task that writes `reports/aaps-plan.md`. Use it as a safe scaffold, then expand the workflow with blocks, validations, recovery steps, and review gates.
+
+## When To Use AAPS
+
+Use AAPS when a task is too large for a single chat-style loop and benefits from explicit phases:
+
+- Multi-stage app development with review, tests, repair, screenshots, and release notes.
+- Paper or book pipelines with outline, draft, figures, review, export, and publication checks.
+- Data/research workflows with ingestion, cleaning, analysis, validation, and report artifacts.
+- Recurring project maintenance with inspect, plan, patch, test, and commit stages.
+
+For ordinary one-off coding or writing tasks, use normal AgInTiFlow prompts.

package/docs/student-committee-supervisor.md

@@ -0,0 +1,104 @@
+# Student-Committee-Supervisor Mode
+
+Student-Committee-Supervisor mode, or SCS, is an optional quality gate for complicated AgInTiFlow tasks.
+
+It is intentionally separate from the normal fast pipeline. Small requests should stay cheap and direct. SCS is for work where a weak plan, repeated failed action, or premature finish would be expensive.
+
+## Commands
+
+```bash
+aginti --enabless "fix this complicated project and verify it"
+aginti --enabless auto "migrate this app and run the checks"
+aginti --no-enabless "answer this simple question"
+```
+
+Inside interactive chat:
+
+```text
+/enabless
+/enabless auto
+/enabless off
+/enabless status
+```
+
+`/scs` is also accepted as a serious alias.
+
+## Role Contract
+
+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. |
+| 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.
+
+## Runtime Behavior
+
+When SCS is active:
+
+- `config.provider` and `config.model` switch to the main model role, except mock mode keeps the local mock route for smoke tests.
+- 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.
+- Every fourth execution step triggers a bounded progress review for long runs.
+- `finish` and assistant-content completion pass through a final student gate.
+- Decisions are persisted as `scs.*` events and the phase pack is saved as a session artifact.
+
+The current implementation is deliberately bounded:
+
+- Committee plan retries are capped.
+- Student monitor calls are capped.
+- Finish rejections are capped to avoid deadlock.
+- If the monitor cannot produce strict JSON, AgInTiFlow uses a conservative fallback decision and records the parser warning.
+
+## Auto Mode
+
+`/enabless auto` and `--enabless auto` activate SCS for complex, risky, or long-running work. Signals include:
+
+- high smart-routing complexity score;
+- profiles such as code, app, Android/iOS, large-codebase, GitHub, maintenance, security, LaTeX, research, and supervision;
+- prompts mentioning multi-file work, regressions, builds, deployments, tmux, emulators, Docker, PDFs, or similar high-friction workflows.
+
+Auto mode stays off for simple turns.
+
+## When To Use It
+
+Use SCS for:
+
+- large coding tasks with ambiguous scope;
+- Android/iOS/system tasks where environment checks matter;
+- migrations, refactors, release work, and GitHub workflows;
+- long-running tmux or simulator jobs;
+- paper/LaTeX work where final artifacts need evidence;
+- self-supervision or capability-training runs.
+
+Avoid SCS for:
+
+- `ls`, `pwd`, short factual answers, and small one-file edits;
+- tasks where latency matters more than plan quality;
+- already well-scoped prompts that normal routing handles reliably.
+
+## Event Trail
+
+SCS emits compact event names:
+
+- `scs.enabled`
+- `scs.committee.plan_drafted`
+- `scs.student.approve_plan`
+- `scs.student.veto_plan`
+- `scs.student.rethink_plan`
+- `scs.student.accept_phase`
+- `scs.student.reject_phase`
+- `scs.student.finish_allowed`
+- `scs.student.finish_rejected`
+- `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/`.
+
+## 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.49",
+  "version": "0.20.50",
   "type": "module",
   "description": "AgInTiFlow is a web-first coding agent and CLI with DeepSeek routing, sandboxed tools, model providers, canvas artifacts, and optional wrappers.",
   "license": "Apache-2.0",
@@ -49,6 +49,7 @@
     "scripts/real-deepseek-capabilities.js",
     "scripts/smoke-auxiliary-tools.js",
     "scripts/smoke-auth.js",
+    "scripts/smoke-aaps-adapter.js",
     "scripts/smoke-canvas-artifacts.js",
     "scripts/smoke-cli-chat.js",
     "scripts/smoke-coding-tools.js",
@@ -77,6 +78,7 @@
     "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check src/*.js && node --check scripts/seed-supervised-homework.js",
     "setup:toolchain-docker": "scripts/setup-agent-toolchain-docker.sh",
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
+    "smoke:aaps-adapter": "node scripts/smoke-aaps-adapter.js",
     "smoke:auxiliary-tools": "node scripts/smoke-auxiliary-tools.js",
     "smoke:auth": "node scripts/smoke-auth.js",
     "smoke:canvas-artifacts": "node scripts/smoke-canvas-artifacts.js",
@@ -93,7 +95,7 @@
     "real:deepseek": "node scripts/real-deepseek-capabilities.js",
     "supervision:seed": "node scripts/seed-supervised-homework.js",
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
-    "test": "npm run check && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:auxiliary-tools && npm run smoke:auth && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:auth && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },