@lazyingart/agintiflow 0.20.25 → 0.20.38

package/README.md

@@ -50,6 +50,8 @@ aginti --list-profiles
 aginti --sandbox-status
 ```
 
+When AgInTiFlow is installed globally from npm, normal `aginti`, `aginti chat`, `aginti resume`, and `aginti web` startup checks npm for a newer `@lazyingart/agintiflow` release at a throttled interval. If a newer version is found, it runs `npm install -g @lazyingart/agintiflow@latest` and restarts the CLI once. Source checkouts and non-TTY automation skip this behavior. Force a check with `aginti update`, skip one run with `--no-auto-update`, or disable it with `AGINTIFLOW_NO_AUTO_UPDATE=1`.
+
 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:
 
 ```bash
@@ -117,7 +119,7 @@ aginti web --port 3210
 # then open http://127.0.0.1:3210
 ```
 
-`aginti web` uses the folder it is launched from as the project root, default working directory, session store, and settings database. CLI and web runs share the same project-local `.sessions/` folder.
+`aginti web` uses the folder it is launched from as the project root and default working directory. CLI and web runs share project-local pointers in `.aginti-sessions/`, while canonical session history and artifacts live under `~/.agintiflow/sessions/<session-id>/`.
 
 Run the installed CLI without a live provider key by using the local mock route:
 
@@ -132,8 +134,11 @@ aginti keys status
 printf '%s' "$DEEPSEEK_API_KEY" | aginti keys set deepseek --stdin
 aginti capabilities
 aginti doctor --capabilities
+aginti update
 aginti sessions list
 aginti sessions show <session-id>
+aginti sessions rename <session-id> "friendly title"
+aginti storage migrate
 aginti resume
 aginti resume latest
 aginti resume <session-id> "continue with a short follow-up"
@@ -194,7 +199,7 @@ aginti capabilities --json
 aginti doctor --capabilities
 ```
 
-The report checks the project root, command cwd, shared `.sessions/`, provider-key presence, DeepSeek routes, guarded file and shell tools, OS/platform hints, Docker status, wrappers, task profiles, TeX, Node/npm, Python, R, conda, and maintenance command policy. It never prints API key or token values.
+The report checks the project root, command cwd, shared `.aginti-sessions/` project index, global `~/.agintiflow/sessions/` store, provider-key presence, DeepSeek routes, guarded file and shell tools, OS/platform hints, Docker status, wrappers, task profiles, TeX, Node/npm, Python, R, conda, and maintenance command policy. It never prints API key or token values.
 
 Live DeepSeek verification is opt-in because it spends provider credits:
 
@@ -409,7 +414,7 @@ Package policy values:
 
 Toolchain commands such as `python3 plot.py`, `latexmk -pdf paper.tex`, and `pdflatex -interaction=nonstopmode -halt-on-error paper.tex` are allowlisted only when the shell tool is enabled. In Docker mode the project folder is mounted as `/workspace`; any file written to `/workspace/report.pdf` appears on the host as `<your-project>/report.pdf`. CLI runs print both the host workspace and the Docker mapping before execution. File and canvas tools accept both normal relative paths and Docker virtual paths like `/workspace/report.pdf`, while other absolute host paths remain blocked.
 
-The web chat mirrors the CLI session store while keeping browser-native controls. Launch `aginti web` from the same project folder and it reads the same `.sessions/` history as `aginti` and `aginti resume`. In the web UI, Enter sends and Shift+Enter adds a newline. `Pipe to run` writes an ASAP message (`→`) to `.sessions/<session-id>/inbox.jsonl` so an active CLI or web agent can consume it at the next safe boundary. `Queue after finish` stores a browser-local next prompt (`↳`) and starts it after the current web run finishes; queued items have Edit and Remove buttons. Esc or Stop stops active web runs. Generated local sites should use the built-in `preview_workspace` or `open_workspace_file` tools; AgInTiFlow avoids transient localhost servers inside Docker because those containers stop between commands and their ports are not host-published.
+The web chat mirrors the CLI session store while keeping browser-native controls. Launch `aginti web` from the same project folder and it reads the same `.aginti-sessions/` pointers and `~/.agintiflow/sessions/` history as `aginti` and `aginti resume`. In the web UI, Enter sends and Shift+Enter adds a newline. `Pipe to run` writes an ASAP message (`→`) to `~/.agintiflow/sessions/<session-id>/inbox.jsonl` so an active CLI or web agent can consume it at the next safe boundary. `Queue after finish` stores a browser-local next prompt (`↳`) and starts it after the current web run finishes; queued items have Edit and Remove buttons. Esc or Stop stops active web runs. Generated local sites should use the built-in `preview_workspace` or `open_workspace_file` tools; AgInTiFlow avoids transient localhost servers inside Docker because those containers stop between commands and their ports are not host-published.
 
 Safe preflight endpoints:
 
@@ -435,7 +440,7 @@ The smoke script starts the web server on a random localhost port, checks `/api/
 
 ## Runtime Artifacts
 
-Each run stores state under `.sessions/<session-id>/`:
+Each run stores canonical state under `~/.agintiflow/sessions/<session-id>/`. The project folder keeps `.aginti-sessions/<session-id>/session.json` as a lightweight pointer plus `.aginti-sessions/web-state.sqlite` for web UI preferences and friendly session titles. Legacy `.sessions/` folders are read and copied by `aginti storage migrate`.
 
 | File | Purpose |
 | --- | --- |

package/docs/agent-runtime-pipe.md

@@ -1,11 +1,12 @@
 # Agent Runtime Pipe
 
-AgInTiFlow keeps CLI and web runs equivalent by using the project folder as the source of truth.
+AgInTiFlow keeps CLI and web runs equivalent by using a project-local session index plus a global canonical session store.
 
 - Project root: the folder where `aginti` or `aginti web` is launched.
-- Session store: `<project>/.sessions/`.
-- Web settings database: `<project>/.sessions/web-state.sqlite`.
-- Runtime inbox: `<project>/.sessions/<session-id>/inbox.jsonl`.
+- Project session index: `<project>/.aginti-sessions/`.
+- Web settings database: `<project>/.aginti-sessions/web-state.sqlite`.
+- Canonical session store: `~/.agintiflow/sessions/<session-id>/`.
+- Runtime inbox: `~/.agintiflow/sessions/<session-id>/inbox.jsonl`.
 
 When a run is active, the web chat and `aginti queue <session-id> "..."` append messages to the inbox instead of trying to mutate the running process directly. The web API exposes `GET /api/sessions/:id/inbox`, `POST /api/sessions/:id/inbox`, `PATCH /api/sessions/:id/inbox/:itemId`, and `DELETE /api/sessions/:id/inbox/:itemId` so browser users can inspect, edit, or remove pending pipe messages before the runner consumes them. The runner drains the inbox at safe boundaries: before each model step and after tool execution. This mirrors the event-queue style used by mature agent UIs while keeping the backend decoupled from any specific frontend.
 

package/docs/cli-i18n.md

@@ -75,7 +75,7 @@ The web app already has an 11-language dropdown. Launching web with a language s
 aginti web --language de --port 3210
 ```
 
-The web preference is stored in the project-local `.sessions/web-state.sqlite` database, so the CLI and web app can share sessions while each frontend keeps its own UI controls.
+The web preference is stored in the project-local `.aginti-sessions/web-state.sqlite` database, so the CLI and web app can share sessions while each frontend keeps its own UI controls.
 
 ## Notes
 

package/docs/project-agent-lessons.md

@@ -35,7 +35,7 @@ Round 8 distilled implementation lessons from local agent projects and applied t
 ## Applied In AgInTiFlow
 
 - `aginti web` now defaults command execution to the folder it was launched from.
-- CLI and web share `.sessions/` in the project root.
+- CLI and web share `.aginti-sessions/` project pointers and `~/.agintiflow/sessions/` canonical history.
 - `aginti init`, `aginti doctor`, `aginti keys`, `aginti sessions`, and `aginti resume` provide basic project lifecycle control.
 - Task profiles wire lightweight skill prompts into CLI/web runs while keeping the LLM responsible for the main plan.
 - Project-local `.aginti/.env` can store provider keys safely with 0600 permissions and ignored git entries.

package/docs/real-deepseek-capabilities.md

@@ -19,7 +19,7 @@ aginti capabilities --json
 aginti doctor --capabilities
 ```
 
-The report checks project root, command cwd, shared `.sessions/`, provider-key presence, DeepSeek routes, file/shell tools, Docker status, wrappers, task profiles, TeX, Node/npm, Python, R, conda, and maintenance command guardrails.
+The report checks project root, command cwd, project-local `.aginti-sessions/`, global `~/.agintiflow/sessions/`, provider-key presence, DeepSeek routes, file/shell tools, Docker status, wrappers, task profiles, TeX, Node/npm, Python, R, conda, and maintenance command guardrails.
 
 ## Live DeepSeek Suite
 

package/docs/self-development-supervision.md

@@ -32,7 +32,7 @@ aginti --profile large-codebase --parallel-scouts --scout-count 5 \
   "inspect this repo, implement the requested change, run focused checks, and stop before commit"
 ```
 
-Use `aginti web --port 3221` from the same folder if a browser UI is preferred. CLI and web will share `.sessions/`.
+Use `aginti web --port 3221` from the same folder if a browser UI is preferred. CLI and web will share `.aginti-sessions/` project pointers and `~/.agintiflow/sessions/` canonical history.
 
 ## Supervisor Duties
 
@@ -92,4 +92,3 @@ npm test
 npm run pack:dry-run
 git diff --check
 ```
-

package/docs/skills-and-tools.md

@@ -12,7 +12,7 @@ AgInTiFlow separates **skills** from **tools** so the agent can stay general whi
 
 ## Built-In Skills
 
-The package ships built-in skills for code engineering, website/app building, LaTeX manuscripts, books, Microsoft Word documents, image generation, GitHub maintenance, system maintenance, tmux session control, Android, R/Stan, Python, C/C++, shell scripting, AAPS, and novel writing.
+The package ships built-in skills for code engineering, website/app building, LaTeX manuscripts, books, Microsoft Word documents, image generation, GitHub maintenance, system maintenance, tmux session control, Android, R/Stan, Python, C/C++, shell scripting, AAPS, novel writing, and supervision/student-agent training.
 
 List them from a project:
 

package/docs/supervised-capability-curriculum.md

@@ -0,0 +1,111 @@
+# Supervised Capability Curriculum
+
+AgInTiFlow should be trained and verified by supervising real tasks, not by trusting the agent's final summary. Each curriculum run uses a clean project under `~/ProjectsLFS/Aginti-Test/`, runs AgInTiFlow through a persistent tmux session, and verifies artifacts from outside the agent.
+
+## Verification Contract
+
+Every supervised task must end with independent checks:
+
+- Inspect `git status --short`.
+- Verify output files exist with `test -s`, `ls -lh`, `file`, or a domain-specific checker.
+- Read `~/.agintiflow/sessions/<session-id>/events.jsonl` for actual tool calls when claims matter.
+- For screenshots, PDFs, images, APKs, reports, and archives, keep a durable workspace path unless the user explicitly requested only a temporary preview.
+- Commit intentional project changes or explicitly report why the worktree is not clean.
+
+## Task Families
+
+| Profile | Example supervised task | Required evidence |
+| --- | --- | --- |
+| `auto` | Mixed request: inspect a messy folder, infer the purpose, write a report, run checks | Correct profile inference, durable files, useful checks, clean git status |
+| `code` | Add a CLI feature with tests | Patch diff, focused test output, git status |
+| `large-codebase` | Fix a cross-file bug in a generated multi-package repo | Codebase map, targeted reads, focused then broader checks |
+| `qa` | Build or repair a realistic testing project | focused check output, useful regression coverage, clean runnable test suite |
+| `database` | Fix a schema/query/migration bug in a local SQLite app | migration/query evidence, no data-loss ambiguity |
+| `devops` | Diagnose a broken Docker/service/CI setup without sudo | read-only evidence, idempotent fix, health/log check |
+| `security` | Review a small app for auth, path, secret, or shell risks | findings, patch or report, no secret leakage |
+| `data` | Clean messy CSV/JSON data and generate a report | raw preserved, cleaned output, validation script |
+| `docs` | Write source-backed README/API/tutorial docs | source reads, docs files, verified commands/examples |
+| `app` | Build a small usable app from scratch | Real app files, build/preview/install check, durable screenshot or demo |
+| `website` | Build a polished landing page or dashboard | Preview works, screenshots/artifacts saved, responsive layout |
+| `node` | Build/test a Node or TypeScript package | package manager detected, script/test output |
+| `python` | Write a package/script/notebook-style analysis | Python check/test, output artifact if generated |
+| `c-cpp` | Build a small CMake/Make project and fix a compiler error | Compiler output, binary/test result |
+| `r-stan` | Run a reproducible R/Stan/statistics analysis | Rscript/CmdStan evidence, saved plot/report |
+| `android` | Build, install, launch, screenshot an Android app | Gradle build/test, adb install/launch, durable screenshot |
+| `ios` | Build/test a SwiftUI or SwiftPM app/library | swift/xcodebuild evidence or signing/Xcode blocker, durable screenshot if simulator exists |
+| `java` | Repair a Maven/Gradle Java service or library | wrapper/build files inspected, compile/test output |
+| `go` | Fix a Go module with CLI/server tests | gofmt, focused `go test`, binary or smoke output |
+| `rust` | Fix a Cargo crate/workspace bug | cargo fmt/check/test evidence |
+| `dotnet` | Repair a .NET/C# app or library | dotnet restore/build/test evidence |
+| `php` | Fix a Composer/Laravel-style app | php lint/test or framework command output |
+| `ruby` | Fix a Ruby/Rails/gem project | bundle/rake/rspec evidence |
+| `latex` | Write and compile a paper/report | `.tex` source, PDF, compile log/pass evidence |
+| `paper` | Draft a research manuscript with sources and figures | Outline/source notes, manuscript file, figure/PDF when available |
+| `research` | Research a current technical topic | Source list, dated notes, clear evidence/inference split |
+| `writing` | Write a structured article/script | Durable draft file, outline/revision notes |
+| `book` | Plan and draft a chapter | Chapter map, chapter file, continuity notes |
+| `novel` | Draft a scene/chapter with character continuity | Story bible or continuity notes, chapter file |
+| `design` | Produce an engineering/product design doc | Options/tradeoffs, decision, verification criteria |
+| `slides` | Create a pitch deck, lecture deck, or poster | outline, slide source, exported/previewable artifact |
+| `education` | Create lesson materials with exercises and answers | learner objective, examples, exercise checks |
+| `image` | Generate an image with GRS AI or Venice | Manifest, generated image path, canvas preview |
+| `word` | Create/convert/edit a `.docx` style document | Input backup, output file, converter/tool evidence |
+| `github` | Commit/push/open PR or fix CI | status/diff first, gh/git output, conflict handling |
+| `shell` | Write and run a maintenance script | read-only diagnosis first, script syntax/check output |
+| `maintenance` | Diagnose/fix an environment/toolchain/system issue | evidence log, reversible commands, no silent host mutation |
+| `aaps` | Work with AAPS project conventions | `.aaps`/project files inspected, assumptions documented |
+
+## Supervision Loop
+
+1. Start or reuse a named tmux session in the supervised project.
+2. Give AgInTiFlow a normal user-level task, not a full implementation recipe.
+3. Poll the pane and session events until it finishes, blocks, or loops.
+4. If a reusable capability is missing, patch AgInTiFlow itself: profile, skill, tool, policy, prompt, UI, docs, or tests.
+5. Publish/install the updated AgInTiFlow build when possible, resume the same session, and ask it to continue.
+6. Record the result, missing capability, fix, and verification evidence.
+
+## Workspace Layout
+
+Future supervised homework should live under `~/ProjectsLFS/Aginti-Test/`:
+
+```text
+~/ProjectsLFS/Aginti-Test/
+  HOMEWORK.md
+  TASK-Profile-Auto/
+  TASK-Profile-Code/
+  TASK-Profile-Large-Codebase/
+  TASK-Profile-App/
+  TASK-Profile-Website/
+  TASK-Profile-Paper/
+  TASK-Profile-Research/
+  TASK-Profile-Supervision/
+```
+
+Durable example records should be copied into the AgInTiFlow repo under `aginti-work-examples/`.
+
+## Recursive Supervision
+
+The `supervision` profile and `supervision-student` skill are for training AgInTiFlow to be a better supervisor, not only a better worker. In recursive supervision:
+
+1. A student AgInTiFlow session performs a real task.
+2. A supervisor AgInTiFlow session monitors the student, verifies artifacts, and records flaws.
+3. Codex supervises the supervisor, checking whether it used evidence rather than belief.
+4. Repeated misses become AgInTiFlow upgrades.
+
+Use this only with explicit workspace boundaries and clear permission mode. The supervisor may request code/tool/profile improvements, but should not silently mutate unrelated projects.
+
+## Current Lesson From Android Supervision
+
+Canvas preview alone is not proof that an artifact was saved. AgInTiFlow now persists canvas file paths into session artifacts and its Android workflow asks for durable screenshot paths. Supervisors must still verify the workspace file or session artifact exists before reporting success.
+
+## Current Lesson From Auto Supervision
+
+For vague daily tasks, `auto` must borrow specialized habits without being told. The Pocket Greenhouse homework exposed two quality gates: generated output must be inspected and polished, not merely described, and final hygiene claims must use stack-specific recursive checks. AgInTiFlow now explicitly asks the model to fix obvious duplicates/noisy rows/stale summaries and to check Python transient files recursively before claiming none exist.
+
+## Current Lesson From Code Supervision
+
+The Pocket Ledger homework exposed that an explicit `code` profile should not be treated as a cheap short-turn route when the prompt asks to repair a repo and leave it clean. AgInTiFlow now routes `code` work to the complex model by default, gives it a larger cleanup budget, and tells it to prioritize functional checks when optional lint expands scope. The run also exposed that one-shot CLI defaults were overriding `SANDBOX_MODE=host`; env sandbox defaults are now covered by smoke tests.
+
+## Current Lesson From Large-Codebase Supervision
+
+The Checkout Workspace homework proved the large-codebase profile can repair cross-package failures from a vague prompt, but the first tmux run exposed launch fragility: an old tmux environment selected an inaccessible OpenAI model even though the intended route was DeepSeek. AgInTiFlow now has explicit language/platform profiles and a supervised homework seeder, and CLI defaults respect profile/model-role environment variables more consistently. Supervisors should still verify provider/model at launch before sending the project prompt.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.25",
+  "version": "0.20.38",
   "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,9 +49,11 @@
     "scripts/real-deepseek-capabilities.js",
     "scripts/smoke-auxiliary-tools.js",
     "scripts/smoke-auth.js",
+    "scripts/smoke-canvas-artifacts.js",
     "scripts/smoke-cli-chat.js",
     "scripts/smoke-coding-tools.js",
     "scripts/smoke-capabilities.js",
+    "scripts/smoke-auto-update.js",
     "scripts/smoke-inbox.js",
     "scripts/smoke-model-roles.js",
     "scripts/smoke-platform.js",
@@ -71,11 +73,12 @@
   "scripts": {
     "start": "node run.js",
     "web": "node web.js",
-    "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check src/*.js",
+    "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:auxiliary-tools": "node scripts/smoke-auxiliary-tools.js",
     "smoke:auth": "node scripts/smoke-auth.js",
+    "smoke:canvas-artifacts": "node scripts/smoke-canvas-artifacts.js",
     "smoke:cli-chat": "node scripts/smoke-cli-chat.js",
     "smoke:skills": "node scripts/smoke-skills.js",
     "smoke:toolchain-docker": "node scripts/smoke-toolchain-docker.js",
@@ -84,8 +87,11 @@
     "smoke:platform": "node scripts/smoke-platform.js",
     "smoke:tmux-tools": "node scripts/smoke-tmux-tools.js",
     "smoke:web-api": "node scripts/smoke-web-api.js",
+    "smoke:autoupdate": "node scripts/smoke-auto-update.js",
     "real:deepseek": "node scripts/real-deepseek-capabilities.js",
-    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:auxiliary-tools && npm run smoke:auth && npm run smoke:capabilities && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:skills && npm run smoke:tmux-tools && npm run smoke:cli-chat && npm run smoke:inbox",
+    "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: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"
   },

package/public/app.js

@@ -848,7 +848,11 @@ const COMPLEX_ENGINEERING_HINT = /\b(large|complex|complicated|monorepo|codebase
 
 function recommendedMaxStepsForProfile(profile = "auto", goal = "") {
   if (profile === "large-codebase") return 36;
+  if (profile === "app") return 40;
+  if (profile === "android") return 60;
+  if (profile === "supervision") return 40;
   if (profile === "latex") return 30;
+  if (["paper", "research", "book", "novel", "c-cpp", "r-stan", "github", "word", "maintenance"].includes(profile)) return 30;
   if (COMPLEX_ENGINEERING_HINT.test(goal || "")) return 36;
   if (/\b(latex|tex|pdflatex|latexmk|pdf|website|app|docker|system|install|setup|debug)\b/i.test(goal || "")) return 30;
   return 24;

package/references/backend-frontend-artifact-tunnel.md

@@ -9,13 +9,13 @@ The chat stream is good for conversation, but it is not enough for agent work th
 - Backend agents can optionally call `send_to_canvas` for important outputs.
 - Runtime events automatically expose screenshots, snapshots, file changes, and final answers.
 - The frontend can show unread artifact counts, lists, previews, and manual selection.
-- Users can open selected image/text artifacts without digging through `.sessions/`.
+- Users can open selected image/text artifacts without digging through `~/.agintiflow/sessions/`.
 
 The tunnel is optional. Agents can still answer normally with `finish`; they should use `send_to_canvas` only when an output benefits from visual focus or file-style inspection.
 
 ## Source Of Truth
 
-Session events are the durable backend contract. The tunnel is derived from `.sessions/<session-id>/events.jsonl` rather than a separate artifact database.
+Session events are the durable backend contract. The tunnel is derived from `~/.agintiflow/sessions/<session-id>/events.jsonl` rather than a separate artifact database.
 
 Relevant events:
 
@@ -165,7 +165,7 @@ The tunnel must never become a secret/file exfiltration path.
 Current safeguards:
 
 - Artifact list response exposes display paths, not absolute filesystem paths.
-- Session files must stay inside the owning `.sessions/<session-id>/` directory.
+- Session files must stay inside the owning `~/.agintiflow/sessions/<session-id>/` directory.
 - Workspace file reads reuse `checkWorkspaceToolUse("read_file", ...)`.
 - `.env`, `.npmrc`, keys, secret-like paths, `.git`, huge files, and binary text reads are blocked.
 - Text content is redacted through `redactSensitiveText`.

package/references/general-task-capability-taxonomy.md

@@ -0,0 +1,109 @@
+# General Task Capability Taxonomy
+
+AgInTiFlow should be useful as a daily local agent, not only as a coding demo.
+The UI should expose a manageable set of major profiles while the skill library
+and Auto routing cover detailed task families.
+
+## Profile Philosophy
+
+- `auto` is the daily default. It should infer the task family and borrow the
+  right profile and skill habits without forcing the user to select one.
+- Profiles are bias, not restrictions. A `writing` run may still inspect files,
+  run scripts, or use web search; a `code` run may still update docs.
+- Skills are markdown operating procedures selected by trigger words and task
+  profile. They are more granular than profiles and should cover common daily
+  subtasks.
+- Supervision is a meta-skill. It improves the agent, but it does not replace
+  domain skills for writing, coding, design, data, system work, and research.
+
+## Major Profiles
+
+| Profile | Daily task families covered | Quality gates |
+| --- | --- | --- |
+| `auto` | Mixed requests, vague folder cleanup, small shell/file tasks, inferred profile work | infer correctly, create durable output, run a useful check, final git/artifact state |
+| `code` | features, bug fixes, refactors, packages, scripts, APIs | pro route by default, inspect/search/read first, patch minimal files, focused tests, cleanup/gitingore artifacts, residual risk |
+| `large-codebase` | cross-file bugs, architecture changes, migrations, multi-package repos | context pack, symbol search, narrow-to-broad checks, no unrelated edits |
+| `qa` | failing tests, CI, flaky tests, coverage, regression harnesses | reproduce failure, identify root cause, add regression, rerun focused checks |
+| `database` | SQL, schema, migrations, seed data, persistence bugs | inspect schema/migrations, avoid data loss, reversible migration, query checks |
+| `devops` | Docker, CI/CD, deployment, services, ports, logs, runtime config | read-only diagnosis first, idempotent setup, no silent sudo, health/log proof |
+| `security` | auth, secrets, input validation, dependency risk, shell safety | no secret leakage, prioritize real exploitability, scanner plus review evidence |
+| `data` | CSV/JSON cleanup, ETL, plots, reports, notebooks, reproducible analysis | preserve raw data, validate rows/schema, rerun script, save clean artifacts |
+| `research` | current-source research, literature notes, technical comparisons | cite sources, separate evidence from inference, save dated notes |
+| `paper` | academic manuscripts, abstracts, figures, related work | outline claims, sources traceable, compile/check when possible |
+| `latex` | TeX reports, equations, figures, bibliography, PDF compile | use existing TeX first, compile enough passes, save PDF/source |
+| `writing` | articles, blog posts, scripts, copy, markdown, editing | durable draft, outline, revision notes, voice/tone preserved |
+| `book` | chapter maps, long-form structure, continuity | chapter files, style/continuity notes, revision plan |
+| `novel` | fiction scenes, character arcs, worldbuilding | story bible, scene files, continuity checks |
+| `docs` | README, API docs, tutorials, changelog, knowledge base | source-backed docs, runnable examples, link/command checks |
+| `slides` | pitch decks, lectures, posters, slide outlines | audience fit, concise slide structure, source/export when possible |
+| `education` | tutorials, courses, lessons, exercises, quizzes | learner level, objectives, examples, exercises and answers |
+| `design` | product specs, engineering designs, architecture decisions | goals, constraints, tradeoffs, decision record, verification criteria |
+| `website` | landing pages, dashboards, static sites, frontends | intentional visual design, responsive preview, screenshots/artifacts |
+| `app` | web/desktop/mobile/local apps, full-stack prototypes | coherent architecture, build/preview/install check, durable demo |
+| `android` | Android Gradle/Kotlin/Java apps, emulator/device checks | SDK/adb inspection, build/test/install/launch/screenshot |
+| `ios` | iOS, Swift, SwiftUI, Xcode, SPM, simulator work | Xcode/SPM inspection, build/test/simulator evidence or signing blocker |
+| `python` | Python packages, scripts, analysis, CLIs | pyproject/requirements, focused checks, cache hygiene |
+| `node` | JS/TS packages, React/Vite/Next/Express, CLIs | package manager detection, scripts/tests, lockfile discipline |
+| `java` | Java/Kotlin JVM, Maven, Gradle, Spring, JUnit | wrapper/build file inspection, compile/test evidence, no global JDK mutation |
+| `go` | Go modules, CLIs, servers, packages | go.mod inspection, gofmt, focused `go test` |
+| `rust` | Rust crates, Cargo workspaces, CLIs, services | Cargo metadata, fmt/check/test, dependency discipline |
+| `dotnet` | .NET/C#/ASP.NET projects | .sln/.csproj inspection, restore/build/test evidence |
+| `php` | PHP, Composer, Laravel/Symfony, WordPress-style work | composer/framework inspection, php lint/test evidence |
+| `ruby` | Ruby, Rails, Bundler, gems, RSpec/Minitest | Gemfile/routes/migrations inspection, bundle test evidence |
+| `c-cpp` | C/C++/CMake/Make, native debugging | out-of-tree builds, compiler/test output, sanitizer if available |
+| `r-stan` | R, Stan, statistics, reproducible reports | project-local libs, Rscript/CmdStan checks, plots/reports |
+| `word` | docx editing/conversion, Office workflows | preserve originals, converter evidence, verify output exists |
+| `image` | raster images, covers, posters, illustration assets | prompt quality, manifest, durable image path, canvas preview |
+| `github` | status, branches, pull, merge, rebase, commit, push, gh PRs | status/diff first, fast-forward preference, stop on conflicts/divergence |
+| `shell` | shell scripts, diagnostics, automation | read-only diagnosis, bash syntax/check, reversible scripts |
+| `maintenance` | system/software install, env repair, package/toolchain issues | safe mode awareness, no sudo hangs, manual command on permission blockers |
+| `aaps` | AAPS project conventions and automation files | inspect .aaps conventions, document assumptions, avoid secrets |
+| `supervision` | monitor another agent/session, recursive training | external evidence, flaw taxonomy, durable AgInTiFlow upgrades |
+
+## Skill Coverage Targets
+
+| Skill | Why it exists |
+| --- | --- |
+| `code` | baseline inspect-patch-test loop |
+| `code-review` | review mindset without accidental edits |
+| `qa-testing` | failure reproduction and regression discipline |
+| `data-analysis` | reproducible data and report artifacts |
+| `docs-knowledge` | source-backed docs instead of invented docs |
+| `database` | schema/migration/data-loss guardrails |
+| `devops-deployment` | runtime and setup work without unsafe host mutation |
+| `security-review` | secret hygiene and real-risk prioritization |
+| `presentation-slides` | deck/poster structure and export habits |
+| `writing-editing` | long-form and editing workflows |
+| `education-tutorial` | lesson/exercise structure |
+| Domain skills | Android, iOS/Swift, Java/JVM, Go, Rust, .NET/C#, PHP, Ruby, LaTeX, Word, R/Stan, C/C++, website, image, AAPS, GitHub, shell, tmux, supervision |
+
+## Supervised Homework Strategy
+
+Run one hard homework per major family under `~/ProjectsLFS/Aginti-Test/`.
+Each task should use realistic, imperfect user prompts so Auto and profile
+skills must infer the right workflow.
+
+1. Seed a project with realistic files, mistakes, and ambiguity.
+2. Start AgInTiFlow in a persistent tmux session from the task folder.
+3. Give a normal prompt, not a full solution recipe.
+4. Monitor pane output and `~/.agintiflow/sessions/<id>/events.jsonl`.
+5. Verify results externally: files, command output, git, screenshots, PDFs,
+   plots, docs, app launches, or PR metadata.
+6. If it fails, patch AgInTiFlow's profile, skill, tool, policy, UI, or tests.
+7. Resume the same student session and let AgInTiFlow finish.
+8. Record the example under `aginti-work-examples/`.
+
+## Next Homework Queue
+
+| Order | Folder | Profile focus | Stress prompt |
+| --- | --- | --- | --- |
+| 1 | `TASK-Profile-Code` | `auto` + `code` + `qa` | "this repo has some bugs; make it good and leave it clean" |
+| 2 | `TASK-Profile-Large-Codebase` | `large-codebase` | "a feature broke across packages; find and fix it" |
+| 3 | `TASK-Profile-Github` | `github` | "pull latest, commit my work, and push if safe" |
+| 4 | `TASK-Profile-Data` | `data` | "these CSVs are messy; produce useful analysis and a report" |
+| 5 | `TASK-Profile-Docs` | `docs` | "make the docs useful for a new user" |
+| 6 | `TASK-Profile-Website` | `website` + `design` | "make a beautiful website from this rough idea" |
+| 7 | `TASK-Profile-Paper` | `paper` + `latex` | "write a short manuscript with a figure and PDF" |
+| 8 | `TASK-Profile-Maintenance` | `maintenance` + `devops` + `shell` | "this tool won't run; diagnose and fix safely" |
+| 9 | `TASK-Profile-Security` | `security` | "review this small app for risky mistakes" |
+| 10 | `TASK-Profile-Writing` | `writing` + `word` + `slides` | "turn these notes into polished deliverables" |

package/references/supervision-student-recursive-training.md

@@ -0,0 +1,116 @@
+# Supervision Student Recursive Training
+
+AgInTiFlow should improve through supervised real work. The core pattern is:
+
+1. A student AgInTiFlow session attempts a concrete project.
+2. A supervisor watches it like a demanding user, not like an implementer.
+3. The supervisor verifies outcomes from filesystem, git, tests, devices, screenshots, logs, and session events.
+4. Failures become durable improvements to AgInTiFlow itself.
+5. The same session resumes and tries again.
+
+This pattern is useful because a young agent may not yet be a strong worker, but it can still learn to become a strong supervisor. A good supervisor can decompose quality, detect false completion, and force evidence-driven iteration.
+
+## Folder Layout
+
+Use one organized root for future profile training:
+
+```text
+~/ProjectsLFS/Aginti-Test/
+  HOMEWORK.md
+  TASK-Profile-Auto/
+  TASK-Profile-Code/
+  TASK-Profile-Large-Codebase/
+  TASK-Profile-App/
+  TASK-Profile-Website/
+  TASK-Profile-Paper/
+  TASK-Profile-Research/
+  TASK-Profile-Supervision/
+```
+
+Use the AgInTiFlow repo for durable example records:
+
+```text
+AgInTiFlow/
+  aginti-work-examples/
+    README.md
+    homework-ledger.md
+    android-tipsplit/
+      tipsplit-screenshot-*.png
+```
+
+## Supervision Contract
+
+The supervisor must not report success from the student's final answer alone.
+
+Required checks:
+
+- Inspect `git status --short`.
+- Check expected files with `test -s`, `ls -lh`, `file`, `rg`, or domain-specific validators.
+- Read relevant `~/.agintiflow/sessions/<session-id>/events.jsonl` entries for tool claims.
+- Verify screenshots/images/PDFs/APKs/reports exist after cleanup.
+- Record whether build/test/install/preview/research-source checks actually ran.
+- Save evidence in the example ledger.
+
+## Prompt Style
+
+Training prompts should be realistic and sometimes imperfect:
+
+- Short: "make a small Android app and install it"
+- Ambiguous: "fix this repo and make it good"
+- Broad: "write a paper-style report with figures"
+- Operational: "pull latest, handle conflicts safely, commit and push"
+
+The supervisor should not compensate by giving a full implementation recipe unless the student has already failed and the missing reusable capability is being diagnosed.
+
+## Failure Taxonomy
+
+When a student fails, classify the flaw before patching:
+
+- `planning`: skipped inspection, bad decomposition, wrong acceptance criteria.
+- `context`: read the wrong files, missed instructions, forgot prior state.
+- `tool`: lacked a first-class command/tool or used it incorrectly.
+- `policy`: unsafe command, host mutation, sudo prompt, destructive git behavior.
+- `artifact`: missing output, temp file deleted, wrong save path, no durable proof.
+- `verification`: claimed success without tests, screenshots, logs, or source checks.
+- `UX`: output technically works but is ugly, confusing, or too noisy.
+- `recovery`: looped on same error, did not stop on blocker, did not resume cleanly.
+
+## Upgrade Targets
+
+Prefer durable upgrades over rescue prompts:
+
+- Add task profiles for broad modes.
+- Add skills for repeated domain workflows.
+- Add tools for repeatable operations.
+- Add command-policy guards for unsafe/hanging commands.
+- Add smoke tests for regressions.
+- Improve UI/logging when the user cannot inspect progress.
+- Improve artifact persistence when evidence can disappear.
+
+## Recursive Training
+
+After worker profiles improve, train the `supervision` profile itself:
+
+1. Start a supervisor AgInTiFlow session.
+2. Ask it to supervise a smaller student session on a scoped task.
+3. The outer Codex supervisor checks the AgInTi supervisor, not the student directly.
+4. Grade whether the AgInTi supervisor found flaws, verified evidence, and requested durable improvements.
+5. Patch AgInTiFlow if the supervisor missed important quality gates.
+
+This builds toward self-improving behavior without granting blind autonomy.
+
+## Current Baseline
+
+Completed supervised example:
+
+- Android TipSplit app in `/home/lachlan/ProjectsLFS/Android-AgInTi-Test`.
+- Built and tested by AgInTiFlow.
+- Installed and launched on emulator.
+- Screenshot was first lost because it was temporary; AgInTiFlow was patched to persist canvas file artifacts.
+- A durable screenshot was then saved at `screenshots/tipsplit-screenshot-20260503-063332.png`.
+- Auto Pocket Greenhouse task in `/home/lachlan/ProjectsLFS/Aginti-Test/TASK-Profile-Auto`.
+- AgInTiFlow inferred a messy sensor folder, fixed the Python analysis, generated README/REPORT/CSV outputs, committed the result, corrected duplicated risk rows, and removed transient Python caches after supervisor review.
+
+Next recommended training run:
+
+- `TASK-Profile-Code`: seed a small multi-language repo with misleading names and broken tests. Grade inspect/search/read discipline, patch quality, focused checks, and clean git handling.

package/scripts/smoke-auto-update.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import {
+  compareSemver,
+  isGlobalNpmInstall,
+  isNewerVersion,
+  maybeAutoUpdate,
+  shouldAutoUpdateCommand,
+} from "../src/auto-update.js";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+const scopedGlobalPath = "/usr/local/lib/node_modules/@lazyingart/agintiflow";
+const windowsGlobalPath = "C:\\Users\\tester\\AppData\\Roaming\\npm\\node_modules\\@lazyingart\\agintiflow";
+
+assert(compareSemver("0.20.38", "0.20.37") === 1, "patch version compare failed");
+assert(compareSemver("0.21.0", "0.20.99") === 1, "minor version compare failed");
+assert(compareSemver("1.0.0", "0.99.99") === 1, "major version compare failed");
+assert(compareSemver("0.20.37", "0.20.37") === 0, "equal version compare failed");
+assert(compareSemver("0.20.37", "0.20.38") === -1, "older version compare failed");
+assert(isNewerVersion("0.20.38", "0.20.37"), "newer version predicate failed");
+assert(!isNewerVersion("0.20.37", "0.20.37"), "equal version should not update");
+assert(!isNewerVersion("0.20.36", "0.20.37"), "older latest should not update");
+
+assert(isGlobalNpmInstall(scopedGlobalPath), "Unix global npm install path not detected");
+assert(isGlobalNpmInstall(windowsGlobalPath), "Windows global npm install path not detected");
+assert(!isGlobalNpmInstall("/home/user/Projects/AgInTiFlow"), "source checkout should not look globally installed");
+
+assert(shouldAutoUpdateCommand([]), "plain interactive start should check updates");
+assert(shouldAutoUpdateCommand(["web"]), "web start should check updates");
+assert(shouldAutoUpdateCommand(["resume", "latest"]), "resume should check updates");
+assert(shouldAutoUpdateCommand(["write", "a", "test"]), "one-shot task should check updates in a TTY");
+assert(!shouldAutoUpdateCommand(["doctor"]), "doctor should skip updates");
+assert(!shouldAutoUpdateCommand(["models"]), "models should skip updates");
+assert(!shouldAutoUpdateCommand(["--version"]), "version should skip updates");
+assert(!shouldAutoUpdateCommand(["task", "--no-auto-update"]), "--no-auto-update should skip updates");
+
+const skipped = await maybeAutoUpdate({
+  argv: [],
+  force: true,
+  manual: false,
+  packageDir: "/home/user/Projects/AgInTiFlow",
+  packageName: "@lazyingart/agintiflow",
+  packageVersion: "0.20.37",
+  restart: false,
+});
+assert(skipped.skipped === "source-checkout", "source checkout update guard failed");
+
+console.log("auto-update smoke ok");
+

package/scripts/smoke-auxiliary-tools.js

@@ -11,6 +11,7 @@ import { SessionStore } from "../src/session-store.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-auxiliary-"));
+process.env.AGINTIFLOW_HOME = path.join(tempRoot, ".agintiflow-home");
 const runtimeDir = path.join(tempRoot, "runtime");
 const workspace = path.join(tempRoot, "workspace");
 await fs.mkdir(workspace, { recursive: true });