@lazyingart/agintiflow 0.20.52 → 0.20.53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/README.md +229 -383
  2. package/package.json +3 -1
  3. package/references/notes/readme-full-reference-2026-05-05.md +520 -0
  4. package/website/README.md +100 -0
  5. package/website/assets/screenshots/app-overview.jpg +0 -0
  6. package/website/assets/screenshots/cli-launch.jpg +0 -0
  7. package/website/assets/screenshots/conversation-history.jpg +0 -0
  8. package/website/assets/screenshots/mobile-overview.jpg +0 -0
  9. package/website/assets/screenshots/run-output.jpg +0 -0
  10. package/website/assets/screenshots/sandbox-status.jpg +0 -0
  11. package/website/assets/screenshots/task-controls.jpg +0 -0
package/README.md CHANGED
@@ -12,507 +12,353 @@
12
12
 
13
13
  ![Node.js](https://img.shields.io/badge/Node.js-22%2B-339933?logo=nodedotjs&logoColor=white)
14
14
  ![Playwright](https://img.shields.io/badge/Browser-Playwright-2EAD33?logo=playwright&logoColor=white)
15
- ![Express](https://img.shields.io/badge/Web-Express-111827)
16
- ![Text Models](https://img.shields.io/badge/Text%20Models-DeepSeek%20%2B%20Venice%20%2B%20OpenAI-0ea5e9)
17
- ![Aux Image Models](https://img.shields.io/badge/Aux%20Image-GRS%20AI%20%2B%20Venice-ec4899)
15
+ ![CLI + Web](https://img.shields.io/badge/Interface-CLI%20%2B%20Web-0ea5e9)
16
+ ![Text Models](https://img.shields.io/badge/Text-DeepSeek%20%2B%20Venice%20%2B%20OpenAI%20%2B%20Qwen-2563eb)
17
+ ![Aux Image](https://img.shields.io/badge/Aux%20Image-GRS%20AI%20%2B%20Venice-ec4899)
18
18
  ![Sandbox](https://img.shields.io/badge/Shell-Docker%20Sandbox-f97316)
19
19
  ![Status](https://img.shields.io/badge/Status-Prototype-7c3aed)
20
20
 
21
- AgInTiFlow is AgInTi's web-first agent platform for controlled website automation, persistent conversations, resumable runs, guarded local commands, and optional coding-agent wrappers.
21
+ AgInTiFlow is a local web and CLI agent workspace for real project folders. It combines cheap model routing, inspectable tool use, durable sessions, guarded file/shell/browser actions, optional image generation, and structured large-task supervision.
22
22
 
23
- It is designed for workflows where an AI agent should act, but every tool, log, and session state should remain inspectable.
23
+ The short version: run `aginti` inside a project, give it a task, inspect what it plans, see every tool call, resume later, and keep the outputs in your workspace.
24
+
25
+ **Links**
26
+
27
+ | Resource | URL |
28
+ | --- | --- |
29
+ | Website | [https://flow.lazying.art](https://flow.lazying.art) |
30
+ | GitHub | [https://github.com/lazyingart/AgInTiFlow](https://github.com/lazyingart/AgInTiFlow) |
31
+ | npm | [https://www.npmjs.com/package/@lazyingart/agintiflow](https://www.npmjs.com/package/@lazyingart/agintiflow) |
32
+ | AAPS npm | [https://www.npmjs.com/package/@lazyingart/aaps](https://www.npmjs.com/package/@lazyingart/aaps) |
33
+ | Full archived README reference | [references/notes/readme-full-reference-2026-05-05.md](references/notes/readme-full-reference-2026-05-05.md) |
24
34
 
25
35
  <p align="center">
26
36
  <img src="./demos/agintiflow-cli-launch.jpg" alt="AgInTiFlow interactive CLI launch screen with colorful terminal banner, Docker workspace status, and chat input panel" width="960" />
27
37
  </p>
28
38
 
29
- ## Product Snapshot
39
+ ## Why This Exists
30
40
 
31
- | Area | Direction |
41
+ Most agent tools are either a chat box with hidden state or an expensive one-model loop. AgInTiFlow is built around a different philosophy:
42
+
43
+ | Principle | What it means in practice |
32
44
  | --- | --- |
33
- | Core loop | Plan -> use tools -> log events -> finish or resume |
34
- | Browser control | Playwright, lazy browser startup, domain allowlists |
35
- | Model layer | Smart routing over DeepSeek fast/pro presets with manual OpenAI-compatible fallback |
36
- | Local tools | Guarded workspace file tools, Codex-style patching, optional shell commands, tmux session control, Docker sandbox support, and advisory agent wrappers |
37
- | Memory | Session state, persisted web settings, chat continuation |
38
- | Operator UX | Multilingual web UI with provider selection, run output, and conversation history |
45
+ | Cheap intelligence changes the architecture | DeepSeek V4 Flash and Pro make it practical to spend more calls on routing, scouting, review, and recovery instead of forcing one expensive call to do everything. |
46
+ | Inspectable beats mysterious | Plans, tool calls, file diffs, command output, canvas artifacts, and session events are saved and resumable. |
47
+ | Role-based models | Route, main, spare, wrapper, and auxiliary image roles are separate. You can use cheap route models, stronger main models, optional OpenAI/Qwen/Venice routes, and GRS AI/Venice image tools. |
48
+ | Scouts before big work | Parallel scouts can cheaply map architecture, tests, risks, symbols, and integration points before the main executor edits anything. |
49
+ | SCS for high-risk work | Student-Committee-Supervisor mode adds a typed gate: committee drafts, student approves/monitors, supervisor executes. Use `/scs` or `--scs auto`. |
50
+ | AAPS for large workflows | AAPS describes top-down agentic pipeline scripts; AgInTiFlow can act as the interactive backend that validates, compiles, and executes those workflows. |
51
+ | Local safety by default | Docker workspace mode, path guardrails, secret redaction, blocked npm publish/token commands, and visible logs keep the agent practical without making it opaque. |
39
52
 
40
53
  ## Quick Start
41
54
 
42
- Install the published CLI:
55
+ Install and open a project:
43
56
 
44
57
  ```bash
45
58
  npm install -g @lazyingart/agintiflow
46
59
  cd /path/to/your-project
47
60
  aginti init
48
- aginti doctor
49
- aginti --list-routes
50
- aginti --list-profiles
51
- aginti --sandbox-status
61
+ aginti
52
62
  ```
53
63
 
54
- 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`.
55
-
56
- 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:
64
+ On first interactive use, AgInTiFlow opens an auth wizard if no main model key is found. Pick DeepSeek, OpenAI, Qwen, or Venice, paste the key, and it saves to the ignored project-local `.aginti/.env` file with restricted permissions. You can rerun setup any time:
57
65
 
58
66
  ```bash
59
67
  aginti auth
60
- aginti auth openai
68
+ aginti auth deepseek
61
69
  aginti auth venice
62
- # inside chat, use /login or /auth for the same wizard
63
- # or non-interactively:
64
- printf '%s' "$DEEPSEEK_API_KEY" | aginti keys set deepseek --stdin
65
- printf '%s' "$QWEN_API_KEY" | aginti keys set qwen --stdin
66
- printf '%s' "$VENICE_API_KEY" | aginti keys set venice --stdin
67
-
68
- # optional image-generation auxiliary skill:
69
70
  aginti login grsai
70
- # inside chat, use /auxiliary grsai
71
71
  ```
72
72
 
73
- Start an interactive Codex-style CLI chat from any project folder:
73
+ Launch the web UI from the same project:
74
74
 
75
75
  ```bash
76
- aginti
77
- # or explicitly:
78
- aginti chat
79
- # choose a UI language, or omit it to follow your system locale:
80
- aginti --language ja
81
- aginti --language zh-Hans
76
+ aginti web --port 3210
77
+ # open http://127.0.0.1:3210
82
78
  ```
83
79
 
84
- Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/instructions` to inspect `AGINTI.md`, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. `Ctrl+J` inserts a new line in the colored input panel, Enter sends, arrow keys move through wrapped multiline input, and `Ctrl+A`/`Ctrl+E` jump to the current line start/end. During an active run, Enter sends the draft as an ASAP pipe message (`→`) and Tab queues it for after the run (`↳`); ASAP messages are consumed before after-finish queued prompts, Alt+Up edits the last piped message, and Shift+Left edits the last after-finish queued message. Idle Esc is ignored so it does not disturb the input panel; during a run, Esc waits when `→` messages are pending and otherwise stops the run cleanly. Ctrl+C always stops and prints the resume command. The input panel always shows the current `cwd` footer and a single live status row, so long goals and tool updates are compacted instead of flooding the transcript. Assistant responses start on a fresh line after the `aginti>` header with a colored response gutter and render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, tables, and red/green patch diff lines. Resuming a session prints the full saved chat history with wrapped messages before the prompt.
85
-
86
- CLI and app language can follow the system locale or be set with `--language`, `--lang`, `-L`, or the interactive `/language` command. Supported codes are `en`, `ja`, `zh-Hans`, `zh-Hant`, `ko`, `fr`, `es`, `ar`, `vi`, `de`, and `ru`; longer names plus old `jp` and `cn-*` aliases still work. See [docs/cli-i18n.md](docs/cli-i18n.md).
87
-
88
- `aginti init` creates `AGINTI.md` at the project root. This is the editable project-instruction file for both CLI and web runs, similar to `AGENTS.md` or project memory in other agents. Keep durable preferences, commands, and constraints there, but never secrets. You can edit it manually or ask in chat, for example: `update AGINTI.md to remember that this project uses pytest and npm run check`.
89
-
90
- For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSeek v4 pro by default and exposes `apply_patch` as a deterministic workspace tool. It supports exact replacements, Codex-style patch envelopes, and unified diffs, with preflight checks, path guardrails, hashes, and compact per-file diffs. See [docs/patch-tools.md](docs/patch-tools.md).
91
-
92
- 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`.
93
-
94
- 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).
95
-
96
- 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).
97
-
98
- 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`.
99
-
100
- For complicated tasks that need stricter quality control, enable Student-Committee-Supervisor mode with `/scs`, `--scs`, or `--scs 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).
101
-
102
- 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).
103
-
104
- 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`.
105
-
106
- For raster image work, AgInTiFlow has optional `image_generation` and `venice_image_generation` skills backed by the `generate_image` tool and local `GRSAI` or `VENICE_API_KEY` credentials. The skill tells the model when image generation is appropriate; the tool saves manifests/images under `artifacts/images` and sends the result to the canvas. See [docs/auxiliary-image-generation.md](docs/auxiliary-image-generation.md) and [references/venice-model-reference.md](references/venice-model-reference.md).
107
-
108
- For long-running shell work, AgInTiFlow exposes host-side tmux tools when the shell tool is enabled: `tmux_list_sessions`, `tmux_capture_pane`, `tmux_send_keys`, and `tmux_start_session`. Use normal prompts such as `start this test server in tmux and monitor it` or `check my tmux session`. The agent captures panes before interacting, redacts outputs, blocks secret-like sends, and avoids sending sudo passwords or destructive commands. Tmux is intentionally host-side: Docker `run_command` containers are short-lived, so tmux servers started there cannot persist.
109
-
110
- AgInTiFlow now ships a Markdown skill library in `skills/<id>/SKILL.md`. Skills are prompt playbooks, while tools are deterministic actions such as `apply_patch`, `run_command`, `web_search`, `generate_image`, and `send_to_canvas`. Built-in skills cover code, websites/apps, LaTeX manuscripts, books, Word documents, image generation, GitHub, system maintenance, Android, R/Stan, Python, C/C++, shell, AAPS, and novel writing. See [docs/skills-and-tools.md](docs/skills-and-tools.md).
80
+ Run without live model credentials for smoke tests:
111
81
 
112
82
  ```bash
113
- aginti skills
114
- aginti skills website
115
- aginti --list-skills latex
116
- # in chat:
117
- /skills github commit
83
+ aginti --provider mock --routing manual --allow-file-tools "Create notes/hello.md with a smoke-test note"
118
84
  ```
119
85
 
120
- Launch the local web UI from an installed package:
86
+ Use a language explicitly, or omit it to follow your system locale:
121
87
 
122
88
  ```bash
123
- aginti web --port 3210
124
- # then open http://127.0.0.1:3210
89
+ aginti --language ja
90
+ aginti --language zh-Hans
91
+ aginti --language de
125
92
  ```
126
93
 
127
- `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>/`.
94
+ ## Daily Commands
128
95
 
129
- Run the installed CLI without a live provider key by using the local mock route:
96
+ | Goal | Command |
97
+ | --- | --- |
98
+ | Start interactive chat | `aginti` or `aginti chat` |
99
+ | Start local web app | `aginti web --port 3210` |
100
+ | Save provider keys | `aginti auth`, `/auth`, `/login` |
101
+ | Review current repo | `/review [focus]` |
102
+ | Toggle SCS quality gate | `/scs` |
103
+ | Use SCS only for complex work | `/scs auto` or `aginti --scs auto "task"` |
104
+ | Work with AAPS workflows | `aginti aaps status`, `/aaps validate` |
105
+ | Choose models | `/route`, `/model`, `/spare`, `/wrapper`, `/auxiliary model` |
106
+ | Enable Venice shortcut | `/venice` |
107
+ | Generate images | `/auxiliary image`, then ask for an image |
108
+ | Resume current project | `aginti resume` |
109
+ | Browse all sessions | `aginti resume --all-sessions` |
110
+ | Queue into a running session | `aginti queue <session-id> "extra instruction"` |
111
+ | Clean empty sessions | `aginti --remove-empty-sessions` |
112
+ | Check capabilities | `aginti capabilities`, `aginti doctor --capabilities` |
113
+ | Sync reviewed skills | `aginti skillmesh status`, `aginti skillmesh sync` |
114
+ | Update CLI | `aginti update` |
115
+
116
+ Interactive chat supports slash completion, Up/Down selectors, multiline input with `Ctrl+J`, full resume history, Markdown rendering, visible run status, ASAP pipe messages during a run, and clean interruption/resume with `Ctrl+C`. Installed interactive commands also check npm for a newer AgInTiFlow release and show an update/skip selector; source checkouts and non-TTY automation are left alone.
117
+
118
+ For a fully controlled one-shot resume, use an explicit session id and choose the task profile deliberately. Use `auto` for normal routing or `android` when the work is Android/emulator-specific:
130
119
 
131
120
  ```bash
132
- aginti --provider mock --routing manual --allow-file-tools "Create notes/hello.md with a smoke-test note"
121
+ PROFILE=android # or auto
122
+ aginti --resume <session-id> \
123
+ --profile "$PROFILE" \
124
+ --sandbox-mode host \
125
+ --package-install-policy allow \
126
+ --approve-package-installs \
127
+ --allow-shell \
128
+ --allow-file-tools \
129
+ --allow-destructive \
130
+ "Take a fresh screenshot of the running app in the emulator, save it with a durable filename in this project, and keep git status clean."
133
131
  ```
134
132
 
135
- Useful project commands:
136
-
137
- ```bash
138
- aginti keys status
139
- printf '%s' "$DEEPSEEK_API_KEY" | aginti keys set deepseek --stdin
140
- aginti capabilities
141
- aginti doctor --capabilities
142
- aginti update
143
- aginti sessions list
144
- aginti sessions show <session-id>
145
- aginti sessions rename <session-id> "friendly title"
146
- aginti --remove-empty-sessions
147
- aginti --remove-sessions
148
- aginti storage migrate
149
- aginti resume
150
- aginti resume --all-sessions
151
- aginti resume latest
152
- aginti resume <session-id> "continue with a short follow-up"
153
- aginti queue <session-id> "extra instruction for the running agent"
154
- aginti aaps status
155
- aginti aaps init "Project Workflow"
156
- aginti aaps validate
157
- aginti chat
158
- # then in chat: /review [focus]
159
- # then in chat: /scs auto
160
- # then in chat: /aaps validate
161
- aginti --profile code "write a small Python CLI app with tests"
162
- aginti --scs auto "fix this complicated project and verify it"
163
- aginti --latex "draw a figure, write a short LaTeX report, and compile the PDF"
164
- aginti "set up this project and run the tests"
165
- ```
133
+ ## Real Screenshots
166
134
 
167
- Bare `aginti resume` lists sessions for the current cwd by default. Use `--all-sessions` to browse the global session index; in the interactive selector, type a number to resume, `q` to quit, `/text` to filter the visible list, or `/` to clear the filter.
135
+ | CLI launch | Web app overview |
136
+ | --- | --- |
137
+ | <img src="./demos/agintiflow-cli-launch.jpg" alt="AgInTiFlow CLI launch" width="480" /> | <img src="./website/assets/screenshots/app-overview.jpg" alt="AgInTiFlow web app overview" width="480" /> |
168
138
 
169
- Session cleanup is cwd-scoped by default. `aginti --remove-empty-sessions` shows only empty sessions and preselects them; `aginti --remove-sessions` shows all cwd sessions with nothing preselected. The cleanup selector uses Space to select or activate the focused button, Up/Down to move, Tab to switch to Delete/Cancel, and a second Delete/Cancel confirmation before deleting the project pointer and central `~/.agintiflow/sessions/<session-id>` data.
139
+ | Task controls | Runtime output |
140
+ | --- | --- |
141
+ | <img src="./website/assets/screenshots/task-controls.jpg" alt="AgInTiFlow task controls" width="480" /> | <img src="./website/assets/screenshots/run-output.jpg" alt="AgInTiFlow runtime output" width="480" /> |
170
142
 
171
- 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.
143
+ | Conversation history | Sandbox status |
144
+ | --- | --- |
145
+ | <img src="./website/assets/screenshots/conversation-history.jpg" alt="AgInTiFlow conversation history" width="480" /> | <img src="./website/assets/screenshots/sandbox-status.jpg" alt="AgInTiFlow sandbox status" width="480" /> |
172
146
 
173
- In interactive chat, `/scs` toggles SCS on or off for the session, `/scs auto` activates it only for complex/risky work, `/scs on` forces it on, `/scs off` restores the normal fast pipeline, and `/scs status` explains the current mode.
147
+ | Mobile overview |
148
+ | --- |
149
+ | <img src="./website/assets/screenshots/mobile-overview.jpg" alt="AgInTiFlow mobile overview" width="480" /> |
174
150
 
175
- Run from a source checkout:
151
+ Older launch screenshots are kept in the source repository under [demos/archive/](https://github.com/lazyingart/AgInTiFlow/tree/main/demos/archive).
176
152
 
177
- ```bash
178
- cd /home/lachlan/ProjectsLFS/Agent/AgInTiFlow
179
- npm install
180
- npx playwright install chromium
181
- npm run web
182
- ```
153
+ ## Core Capabilities
183
154
 
184
- Open `http://127.0.0.1:3210`.
155
+ | Capability | What AgInTiFlow provides |
156
+ | --- | --- |
157
+ | CLI agent workspace | Persistent terminal chat with project cwd, session resume, visible model/tool state, and clean command hints. |
158
+ | Local web workspace | Browser UI for sessions, runtime logs, artifacts, model settings, project controls, canvas previews, and sandbox status. |
159
+ | File tools | `inspect_project`, `list_files`, `read_file`, `search_files`, `write_file`, `apply_patch`, `open_workspace_file`, and `preview_workspace`. |
160
+ | Shell tools | Guarded host or Docker workspace shell execution with package-install policy and command safety checks. |
161
+ | Browser tools | Playwright browser actions with lazy startup and optional domain allowlists. |
162
+ | Model routing | DeepSeek fast/pro defaults, manual OpenAI/Qwen/Venice/mock routes, spare models, wrapper models, and auxiliary image models. |
163
+ | Patch workflow | Codex-style patch envelopes, unified diffs, exact replacements, hashes, compact diffs, and path guardrails. |
164
+ | Parallel scouts | Optional scout calls for architecture, implementation, review, tests, git flow, research, symbol tracing, and dependency risk. |
165
+ | SCS mode | Optional Student-Committee-Supervisor quality gate for complicated or risky tasks. |
166
+ | AAPS adapter | Optional `@lazyingart/aaps` integration for `.aaps` workflow init, validate, parse, compile, dry-run, and run commands. |
167
+ | Image generation | Optional GRS AI and Venice image tools with saved manifests and canvas artifact previews. |
168
+ | Skill library | Built-in Markdown skills for code, websites, Android/iOS, Python, Rust, Java, LaTeX, writing, reviews, GitHub, AAPS, and more. |
169
+ | Skill Mesh | Optional strict skill recording/sharing for reviewed reusable skill packs. If unused, AgInTiFlow runs normally without background sharing. |
170
+ | Multilingual UI | CLI and docs language support for English, Japanese, Simplified/Traditional Chinese, Korean, French, Spanish, Arabic, Vietnamese, German, and Russian. |
171
+
172
+ ## Models And Roles
173
+
174
+ AgInTiFlow does not treat "the model" as one global setting. It has roles:
175
+
176
+ | Role | Default | Purpose |
177
+ | --- | --- | --- |
178
+ | Route | `deepseek/deepseek-v4-flash` | Cheap planner, triage, short tasks, routing decisions. |
179
+ | Main | `deepseek/deepseek-v4-pro` | Complex coding, debugging, writing, research, long tasks. |
180
+ | Spare | `openai/gpt-5.4` medium | Optional fallback or cross-check route. |
181
+ | Wrapper | `codex/gpt-5.5` medium | Optional external coding-agent advisor. |
182
+ | Auxiliary | `grsai/nano-banana-2` | Image generation and other non-text helper tools. |
185
183
 
186
- Run a CLI task:
184
+ Useful selectors:
187
185
 
188
- ```bash
189
- AGENT_PROVIDER=deepseek npm start -- "List this folder and summarize what each project is for"
186
+ ```text
187
+ /models
188
+ /route
189
+ /model
190
+ /spare
191
+ /wrapper
192
+ /auxiliary model
193
+ /venice
190
194
  ```
191
195
 
192
- Use the dedicated CLI entrypoint:
196
+ Venice routes can be used for optional uncensored or less restricted creative work. DeepSeek remains the economic default for normal engineering workflows. See [docs/model-selection.md](docs/model-selection.md) and [references/venice-model-reference.md](references/venice-model-reference.md).
193
197
 
194
- ```bash
195
- npx aginti-cli --routing smart --allow-shell "List this folder"
196
- npx aginti-cli --list-routes
197
- npx aginti-cli --list-wrappers
198
- npx aginti-cli --sandbox-status --sandbox-mode docker-readonly --cwd /home/lachlan/ProjectsLFS/Agent/AgInTiFlow
199
- npx aginti-cli --sandbox-preflight --sandbox-mode docker-workspace --cwd /home/lachlan/ProjectsLFS/Agent/AgInTiFlow
200
- ```
198
+ ## AAPS And Large Workflows
201
199
 
202
- Start from a URL:
200
+ AAPS is the pipeline-script layer; AgInTiFlow is the interactive agent/tool backend.
203
201
 
204
202
  ```bash
205
- npm start -- --start-url https://news.ycombinator.com "Summarize this page"
203
+ aginti aaps status
204
+ aginti aaps init "Project Workflow"
205
+ aginti aaps validate
206
+ aginti aaps compile check
206
207
  ```
207
208
 
208
- Resume a run:
209
+ Inside chat:
209
210
 
210
- ```bash
211
- npm start -- --resume your-session-id
211
+ ```text
212
+ /aaps on
213
+ /aaps validate
214
+ /aaps dry-run workflows/main.aaps
212
215
  ```
213
216
 
214
- The package exposes both `aginti` and `aginti-cli`; they run the same CLI entrypoint.
217
+ Use AAPS when the task is bigger than a single chat: app development with stages, paper/book workflows, validation gates, recovery steps, artifact production, or top-down agentic scripts. See [docs/aaps.md](docs/aaps.md) and the package [https://www.npmjs.com/package/@lazyingart/aaps](https://www.npmjs.com/package/@lazyingart/aaps).
215
218
 
216
- ## Capability Checks
219
+ ## Local API Quick Reference
217
220
 
218
- Use the capability report to verify a project folder before running real agent work:
221
+ The web app exposes local APIs for UI and automation. These endpoints report state without exposing raw API keys or npm tokens:
219
222
 
220
223
  ```bash
221
- aginti capabilities
222
- aginti capabilities --json
223
- aginti doctor --capabilities
224
+ curl http://127.0.0.1:3210/api/config
225
+ curl http://127.0.0.1:3210/api/capabilities
226
+ curl http://127.0.0.1:3210/api/sandbox/status
227
+ curl -X POST http://127.0.0.1:3210/api/sandbox/preflight \
228
+ -H 'Content-Type: application/json' \
229
+ -d '{"sandboxMode":"docker-workspace","buildImage":true}'
230
+ curl http://127.0.0.1:3210/api/workspace/changes
231
+ curl "http://127.0.0.1:3210/api/sessions/<session-id>/artifacts"
232
+ curl "http://127.0.0.1:3210/api/sessions/<session-id>/inbox"
224
233
  ```
225
234
 
226
- 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.
227
-
228
- Live DeepSeek verification is opt-in because it spends provider credits:
235
+ Run the credential-free API smoke test:
229
236
 
230
237
  ```bash
231
- AGINTIFLOW_REAL_DEEPSEEK=1 \
232
- AGINTIFLOW_REAL_WORKSPACE=/home/lachlan/ProjectsLFS/aginti-test \
233
- AGINTIFLOW_REAL_WEB_BASE_URL=http://127.0.0.1:3220 \
234
- npm run real:deepseek
238
+ npm run smoke:web-api
235
239
  ```
236
240
 
237
- The live suite asks DeepSeek v4 flash/pro to create and improve a Node app, generate LaTeX/PDF artifacts when TeX exists, create a website-test sample, write Docker-safe maintenance plans, create an AAPS sample, and verify CLI/web session sharing. See [docs/real-deepseek-capabilities.md](docs/real-deepseek-capabilities.md).
238
-
239
- ## Web UI
240
-
241
- The web app includes:
242
-
243
- - Routing dropdown for smart, fast, complex, and manual model selection.
244
- - Project folder indicator showing project root, command cwd, session folder, and session database.
245
- - First-run provider setup panel with mock fallback and project-local DeepSeek/OpenAI key save.
246
- - Task profile dropdown for code, writing, design docs, Python, shell, Node, AAPS, LaTeX, and system maintenance workflows.
247
- - Provider dropdown for DeepSeek, OpenAI, and local mock mode when manual routing is needed.
248
- - Language dropdown with 11 persisted UI locales.
249
- - Editable model field, with DeepSeek v4 flash as the fast default and DeepSeek v4 pro as the complex route.
250
- - Goal, start URL, allowed domains, working directory, and max-step controls.
251
- - Sandbox mode, Docker image/status, package-install approval state, safe setup warnings, and recent sandbox logs.
252
- - Wrapper capability panel with an opt-in wrapper toggle and a preferred-wrapper selector defaulting to Codex.
253
- - Workspace Files panel showing file tools, recent file changes, blocked write attempts, hashes, and compact diffs.
254
- - Canvas & Artifacts modal with agent-selected renders, screenshot/file explorer, text/image preview, notifications, unread badge, select-to-read, and manual mark-seen.
255
- - Toggleable shell tool, agent wrappers, headless browser, password typing, and destructive actions.
256
- - Persistent conversation panel above compact runtime logs, so follow-up messages stay close to the top.
257
- - Conversation manager modal for auto-renaming, manual renaming, and deleting saved chat history.
258
-
259
- `Start URL` is only a suggestion. The browser opens only when the model chooses a browser tool.
241
+ ## Storage, Safety, And Resume
260
242
 
261
- ## Website
243
+ AgInTiFlow stores canonical sessions centrally and keeps only project-local pointers:
262
244
 
263
- In the source repository, the marketing website lives in `website/`, is published at `https://flow.lazying.art`, and is separate from the app UI in `public/`.
264
-
265
- ```bash
266
- python3 -m http.server 4310 --directory website
267
- node scripts/capture-website-screenshots.js
268
- ```
269
-
270
- The screenshot script captures the live app at `http://127.0.0.1:3210/` by default and writes carousel assets to `website/assets/screenshots/`.
271
- GitHub Pages deploys the `website/` directory through `.github/workflows/pages.yml`; `website/CNAME` sets the custom domain to `flow.lazying.art`.
245
+ | Location | Purpose |
246
+ | --- | --- |
247
+ | `~/.agintiflow/sessions/<session-id>/` | Canonical state, events, browser state, artifacts, snapshots, canvas files. |
248
+ | `<project>/.aginti-sessions/` | Project-local session pointers and web UI database. Ignored by git. |
249
+ | `<project>/.aginti/.env` | Optional project-local API keys with restricted permissions. Ignored by git. |
250
+ | `<project>/AGINTI.md` | Editable project instructions and durable local preferences. Safe to commit if it contains no secrets. |
272
251
 
273
- ## Safety Model
252
+ Safety defaults:
274
253
 
275
- AgInTiFlow is intentionally conservative:
254
+ - Docker workspace mode is the normal CLI/web default for practical coding and artifact generation.
255
+ - Secret-like paths, `.env`, `.git`, `node_modules` writes, absolute escapes, huge files, and binary edits are blocked by file tools.
256
+ - Shell commands are policy checked; npm publish, npm token commands, sudo, destructive git, and credential reads are blocked.
257
+ - File writes record hashes and compact diffs.
258
+ - Tool calls and results are logged into structured session events.
259
+ - The web and CLI both use the same session store, so a run can be inspected and resumed later.
276
260
 
277
- - Password typing is blocked unless explicitly enabled.
278
- - Destructive browser actions are blocked unless explicitly enabled.
279
- - Shell commands are disabled unless the shell tool is enabled.
280
- - Workspace file tools stay inside `commandCwd` and block `.env`, secret-like paths, `.git`, node_modules writes, absolute escapes, binary files, and huge files.
281
- - File writes record before/after SHA-256 hashes and compact redacted diffs.
282
- - Guarded shell mode is policy-based: normal inspection/tests are available, Docker workspace mode can run broader setup/network commands when package installs are approved, and host privileged/destructive work requires explicit trust.
283
- - Docker read-only mode mounts the workspace read-only and disables container network access.
284
- - Docker workspace-write mode is the CLI/web default so plot, PDF, and test outputs can be written inside the mounted workspace.
285
- - Docker workspace-write mode with package policy `allow` is the default for normal agent work. It permits practical setup commands such as `npm`, `pip`, `conda`, `curl`, `wget`, and `chmod` inside Docker while keeping host sudo/global installs blocked.
286
- - Host mode falls back to `prompt`, so npm/pip/conda/venv setup and privileged/destructive commands require explicit trust.
287
- - NPM publishing, npm token commands, API-key reads, and credential files stay blocked. Broader shell commands require either Docker workspace mode with package policy `allow`, or explicit host trust.
288
- - NPM tokens and API keys are redacted from tool logs and API responses.
289
- - Every tool request and result is written to structured logs.
261
+ Detailed runtime notes are in [docs/runtime-modes-and-autonomy.md](docs/runtime-modes-and-autonomy.md), [docs/patch-tools.md](docs/patch-tools.md), and [docs/agent-runtime-pipe.md](docs/agent-runtime-pipe.md).
290
262
 
291
263
  ## Configuration
292
264
 
265
+ Common environment variables:
266
+
293
267
  ```bash
294
- AGENT_PROVIDER=deepseek
295
- LLM_MODEL=deepseek-chat
296
- OPENAI_API_KEY=...
297
268
  DEEPSEEK_API_KEY=...
298
- MAX_STEPS=15
299
- HEADLESS=true
300
- ALLOWED_DOMAINS=news.ycombinator.com,github.com
301
- ALLOW_SHELL_TOOL=true
302
- ALLOW_FILE_TOOLS=true
303
- SANDBOX_MODE=docker-workspace
304
- PACKAGE_INSTALL_POLICY=prompt
305
- USE_DOCKER_SANDBOX=true
306
- DOCKER_SANDBOX_IMAGE=agintiflow-sandbox:latest
307
- COMMAND_CWD=/home/lachlan/ProjectsLFS/Agent
269
+ OPENAI_API_KEY=...
270
+ QWEN_API_KEY=...
271
+ VENICE_API_KEY=...
272
+ GRSAI_API_KEY=...
273
+ AGENT_PROVIDER=deepseek
274
+ AGENT_ROUTING_MODE=smart
308
275
  AGINTI_TASK_PROFILE=auto
276
+ AGINTI_LANGUAGE=en
277
+ SANDBOX_MODE=docker-workspace
278
+ PACKAGE_INSTALL_POLICY=allow
279
+ COMMAND_CWD=/path/to/project
309
280
  ```
310
281
 
311
- Defaults:
312
-
313
- | Route | Provider | Default model | Override |
314
- | --- | --- | --- | --- |
315
- | `smart` | DeepSeek | Fast for normal tasks, pro for complex tasks | `AGENT_ROUTING_MODE=smart` |
316
- | `fast` | DeepSeek | `deepseek-v4-flash` | `DEEPSEEK_FAST_MODEL` |
317
- | `complex` | DeepSeek | `deepseek-v4-pro` | `DEEPSEEK_PRO_MODEL` |
318
- | `manual` | DeepSeek/OpenAI/Qwen/Venice | user supplied | `AGENT_PROVIDER`, `LLM_MODEL` |
319
-
320
- Provider credentials:
321
-
322
- | Provider | API key | Base URL |
323
- | --- | --- | --- |
324
- | OpenAI | `OPENAI_API_KEY` | `https://api.openai.com/v1` |
325
- | DeepSeek | `DEEPSEEK_API_KEY` | `https://api.deepseek.com/v1` |
326
- | Qwen | `QWEN_API_KEY` | `QWEN_BASE_URL` or DashScope compatible mode |
327
- | Venice | `VENICE_API_KEY` | `VENICE_API_BASE` or `https://api.venice.ai/api/v1` |
328
-
329
- Project-local credentials can be stored without committing secrets:
282
+ Project-local keys:
330
283
 
331
284
  ```bash
332
285
  aginti init
333
286
  printf '%s' "$DEEPSEEK_API_KEY" | aginti keys set deepseek --stdin
287
+ printf '%s' "$VENICE_API_KEY" | aginti keys set venice --stdin
334
288
  ```
335
289
 
336
- This writes `.aginti/.env` with `0600` permissions and adds safe `.gitignore` entries. APIs and logs expose only key presence, never raw values.
337
-
338
- ## Agent Wrappers
339
-
340
- AgInTiFlow can expose external coding agents as advisory tools when `ALLOW_WRAPPER_TOOLS=true` or the web UI toggle is enabled. Wrappers are not a replacement for the core runner; they are used for second opinions, codebase analysis, or planning when they are installed and authenticated. The preferred wrapper defaults to Codex and can be changed with `PREFERRED_WRAPPER=codex`, `aginti --allow-wrappers --wrapper codex`, or the web UI dropdown.
341
-
342
- Current wrappers:
343
-
344
- | Wrapper | Command | Safety mode |
345
- | --- | --- | --- |
346
- | Codex | `codex exec` | read-only sandbox, primary `gpt-5.5` medium, spare `gpt-5.4-mini` high |
347
- | Claude Code | `claude --print` | plan permission mode |
348
- | Gemini CLI | `gemini` | advisory prompt |
349
- | GitHub Copilot CLI | `gh copilot` | advisory prompt |
350
- | Qwen Code | `qwen` | plan approval mode |
351
-
352
- Wrapper prompts are capped and filtered for destructive intent unless destructive actions are explicitly enabled.
353
-
354
- ## npm Release Safety
355
-
356
- AgInTiFlow is published as `@lazyingart/agintiflow`.
357
-
358
- Preferred release path:
359
-
360
- 1. Bump `package.json` version.
361
- 2. Run `npm test` and `npm pack --dry-run`.
362
- 3. Create a GitHub Release or run `.github/workflows/npm-publish.yml` manually.
363
- 4. Let npm Trusted Publishing use GitHub Actions OIDC and `npm publish --access public --provenance`.
364
-
365
- Trusted Publishing setup on npm:
366
-
367
- ```bash
368
- npm install -g npm@^11.5.1
369
- npm trust github @lazyingart/agintiflow --repo lazyingart/AgInTiFlow --file npm-publish.yml
370
- ```
371
-
372
- The npm trust command may require the package to exist first and may require an OTP in the browser/account flow. Do not commit `.npmrc`, `.env`, npm tokens, OTPs, or npm debug logs.
373
-
374
- Local token fallback is only for bootstrapping when Trusted Publishing cannot be used:
375
-
376
- ```bash
377
- cp .env.example .env
378
- # Put NPM_TOKEN or NODE_AUTH_TOKEN in .env locally only.
379
- set -a && source .env && set +a
380
- npm publish --access public
381
- ```
382
-
383
- Never publish with `npm publish` from inside an agent run. The runtime command policy blocks npm publish and npm token commands by design.
290
+ More detail:
384
291
 
385
- ## Platform And Docker Bootstrap
292
+ - [docs/model-selection.md](docs/model-selection.md)
293
+ - [docs/auxiliary-image-generation.md](docs/auxiliary-image-generation.md)
294
+ - [docs/cli-i18n.md](docs/cli-i18n.md)
295
+ - [docs/skillmesh.md](docs/skillmesh.md)
386
296
 
387
- AgInTiFlow is designed for Linux, macOS, Windows through WSL2, and best-effort native Windows use. The most portable shell/toolchain path is `docker-workspace`; native Windows host shell commands should be treated as best effort unless you run inside WSL2.
297
+ ## Documentation Map
388
298
 
389
- Platform notes:
390
-
391
- | Platform | Recommended setup |
299
+ | Topic | Link |
392
300
  | --- | --- |
393
- | Ubuntu/Debian | Node.js 22+, optional `scripts/install-docker-ubuntu.sh`, Docker workspace mode for broad toolchains. |
394
- | Red Hat/Fedora/Rocky/Alma | Node.js 22+, Docker/Podman-compatible Docker CLI from `dnf`/vendor docs; do not use the Ubuntu Docker script. |
395
- | macOS | Node.js 22+ from Homebrew/nvm/fnm, Docker Desktop or Colima, optional MacTeX/BasicTeX for host LaTeX. |
396
- | Windows | Prefer WSL2 with Docker Desktop WSL integration. Native Windows host mode is best effort; Docker/WSL is recommended for Bash, LaTeX, Python/R/Stan, and package-manager workflows. |
301
+ | AAPS adapter | [docs/aaps.md](docs/aaps.md) |
302
+ | Model selection and roles | [docs/model-selection.md](docs/model-selection.md) |
303
+ | SCS mode | [docs/student-committee-supervisor.md](docs/student-committee-supervisor.md) |
304
+ | Large-codebase engineering | [docs/large-codebase-engineering.md](docs/large-codebase-engineering.md) |
305
+ | Runtime modes and autonomy | [docs/runtime-modes-and-autonomy.md](docs/runtime-modes-and-autonomy.md) |
306
+ | Skills and tools | [docs/skills-and-tools.md](docs/skills-and-tools.md) |
307
+ | Skill Mesh | [docs/skillmesh.md](docs/skillmesh.md) |
308
+ | Housekeeping logs | [docs/housekeeping.md](docs/housekeeping.md) |
309
+ | npm publishing | [docs/npm-publishing.md](docs/npm-publishing.md) |
310
+ | Product roadmap | [docs/productive-agent-roadmap.md](docs/productive-agent-roadmap.md) |
311
+ | Supervised capability curriculum | [docs/supervised-capability-curriculum.md](docs/supervised-capability-curriculum.md) |
312
+ | Full older README reference | [references/notes/readme-full-reference-2026-05-05.md](references/notes/readme-full-reference-2026-05-05.md) |
397
313
 
398
- LaTeX support first checks the active environment for `latexmk` or `pdflatex`. If your host already has MacTeX, BasicTeX, TeX Live, or MiKTeX on `PATH`, host-mode LaTeX tasks can compile directly without downloading TeX again. Docker-mode LaTeX uses the companion image; the setup script preflights an existing image and skips rebuilds when the Docker toolchain already has `latexmk` and `pdflatex`.
314
+ ## Development
399
315
 
400
- Ubuntu helper:
316
+ Run from source:
401
317
 
402
318
  ```bash
403
- ./scripts/install-docker-ubuntu.sh
319
+ git clone https://github.com/lazyingart/AgInTiFlow.git
320
+ cd AgInTiFlow
321
+ npm install
322
+ npx playwright install chromium
323
+ npm run check
324
+ npm test
404
325
  ```
405
326
 
406
- If running as `root` and configuring Docker for a regular user:
327
+ Start local web from source:
407
328
 
408
329
  ```bash
409
- DOCKER_TARGET_USER=lachlan ./scripts/install-docker-ubuntu.sh
330
+ npm run web
331
+ # open http://127.0.0.1:3210
410
332
  ```
411
333
 
412
- Open a new login shell, or run `newgrp docker`, before testing non-root Docker access.
413
-
414
- Build or verify the companion agent toolchain sandbox:
334
+ Useful smoke checks:
415
335
 
416
336
  ```bash
417
- ./scripts/setup-agent-toolchain-docker.sh
337
+ npm run smoke:web-api
338
+ npm run smoke:coding-tools
339
+ npm run smoke:aaps-adapter
340
+ npm run smoke:cli-chat
418
341
  npm run smoke:toolchain-docker
419
342
  ```
420
343
 
421
- The setup script checks whether `agintiflow-sandbox:latest` already exists and runs a Docker preflight before rebuilding. If Node, npm, Python, NumPy, Matplotlib, `latexmk`, and `pdflatex` are already ready inside the image, it exits without redownloading TeX Live. Set `AGINTIFLOW_FORCE_TOOLCHAIN_REBUILD=true` only when you intentionally want a fresh image. The script also creates persistent companion folders under `~/.agintiflow/docker/`: `home/` maps to `/aginti-home`, `cache/` maps to `/aginti-cache`, and `env/` maps to `/aginti-env`. Python/conda-style toolchains should live under `/aginti-env` so they survive across agent runs. OS package changes from `apt-get` are container-ephemeral unless you rebuild the image.
422
-
423
- ## Sandbox Modes
424
-
425
- | Mode | Workspace mount | Network | Intended use |
426
- | --- | --- | --- | --- |
427
- | `host` | local process | host network | direct project work; privileged/destructive commands require explicit trust |
428
- | `docker-readonly` | read-only `/workspace` | none | safe coding inspection and tests that do not write files |
429
- | `docker-workspace` | writable `/workspace` | none by default, enabled for approved package/setup/network commands | web UI default for environment setup, plotting, LaTeX/PDF, dependency installs, and broad toolchain work inside the mounted project |
430
-
431
- Package policy values:
432
-
433
- | Policy | Behavior |
434
- | --- | --- |
435
- | `block` | Always block npm/pip/conda/venv setup. |
436
- | `prompt` | Return a clear approval-required error; the UI can switch to approved. |
437
- | `allow` | Permit package/setup commands. Docker workspace mode also allows broader shell/network commands while keeping secrets and npm publishing blocked. |
438
-
439
- 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.
440
-
441
- 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.
442
-
443
- Safe preflight endpoints:
444
-
445
- ```bash
446
- curl http://127.0.0.1:3210/api/sandbox/status
447
- curl -X POST http://127.0.0.1:3210/api/sandbox/preflight \
448
- -H 'Content-Type: application/json' \
449
- -d '{"sandboxMode":"docker-workspace","buildImage":true}'
450
- curl http://127.0.0.1:3210/api/workspace/changes
451
- curl "http://127.0.0.1:3210/api/sessions/<session-id>/artifacts"
452
- curl "http://127.0.0.1:3210/api/sessions/<session-id>/inbox"
453
- ```
454
-
455
- These endpoints report Docker/image/workspace readiness, recent sandbox logs, file-change provenance, and renderable artifact metadata without returning API keys or npm tokens. Artifact content is loaded on demand through guarded session/workspace reads.
344
+ The smoke scripts use the local mock provider unless explicitly marked as real-provider tests.
456
345
 
457
- Credential-free API smoke test:
346
+ ## Release Notes
458
347
 
459
- ```bash
460
- npm run smoke:web-api
461
- ```
348
+ AgInTiFlow is published as `@lazyingart/agintiflow`. Preferred release path is GitHub Actions Trusted Publishing with npm provenance. Local token publishing is only a fallback for bootstrapping and should never commit `.env`, `.npmrc`, npm tokens, OTPs, or debug logs.
462
349
 
463
- The smoke script starts the web server on a random localhost port, checks `/api/config`, `/api/sandbox/status`, `/api/sandbox/preflight`, runs mock agent tasks, verifies persisted chat history, and exercises the canvas/artifacts selection API.
350
+ See [docs/npm-publishing.md](docs/npm-publishing.md) for the full release workflow.
464
351
 
465
- ## Runtime Artifacts
352
+ ## Support
466
353
 
467
- 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`.
354
+ If this project is useful, support development here:
468
355
 
469
- | File | Purpose |
356
+ | Support | URL |
470
357
  | --- | --- |
471
- | `state.json` | Resumable model and tool state |
472
- | `plan.md` | Execution plan |
473
- | `events.jsonl` | Structured event log |
474
- | `storage-state.json` | Browser session persistence |
475
- | `artifacts/step-XXX.png` | Screenshots |
476
- | `artifacts/step-XXX.snapshot.json` | DOM snapshots |
477
-
478
- The web UI derives the Canvas & Artifacts tunnel from `canvas.item`, `canvas.selected`, snapshot, file-change, and final-answer events. Models can call `send_to_canvas` to highlight a text block, diff, image, or workspace file; otherwise the user can manually select any derived artifact in the explorer.
479
-
480
- ## Project Structure
481
-
482
- ```text
483
- AgInTiFlow/
484
- ├── public/ # Web UI
485
- ├── src/ # Agent runtime, tools, guardrails, storage
486
- ├── docker/ # Shell sandbox image
487
- ├── scripts/ # Docker bootstrap helper
488
- ├── bin/ # aginti/aginti-cli entrypoint
489
- ├── logos/ # Brand assets and crop notes
490
- ├── references/ # Design philosophy and research notes
491
- ├── tools/ # Reusable project documentation helpers
492
- ├── website/ # Static marketing site and screenshot carousel
493
- ├── run.js # CLI entrypoint
494
- └── web.js # Express web server
495
- ```
496
-
497
- ## Development
498
-
499
- ```bash
500
- npm run check
501
- npm run smoke:web-api
502
- npm run smoke:coding-tools
503
- npm test
504
- ```
505
-
506
- `npm run check` validates JavaScript syntax for the CLI, web server, and runtime modules. The smoke scripts use the local mock provider, so they do not require DeepSeek or OpenAI credentials.
507
-
508
- ## Prompt Tools
509
-
510
- This repo includes small prompt helpers for repeatable documentation and i18n work:
511
-
512
- ```bash
513
- node tools/readme_prompt_tool.js agintiflow
514
- node tools/readme_prompt_tool.js aginti-landing
515
- node tools/webapp_i18n_prompt_tool.js
516
- ```
358
+ | GitHub Sponsors: LazyingArt | [https://github.com/sponsors/lazyingart](https://github.com/sponsors/lazyingart) |
359
+ | GitHub Sponsors: Lachlan Chen | [https://github.com/sponsors/lachlanchen](https://github.com/sponsors/lachlanchen) |
360
+ | LazyingArt | [https://lazying.art](https://lazying.art) |
361
+ | Chat | [https://chat.lazying.art](https://chat.lazying.art) |
362
+ | OnlyIdeas | [https://onlyideas.art](https://onlyideas.art) |
517
363
 
518
- The README helper captures the documentation style used here: concise overview, full language links, product signals, quick start, safety notes, and localized README targets. The webapp i18n helper captures the full UI translation key contract for future language backfills.
364
+ AgInTiFlow is developed by AgInTi Lab, LazyingArt LLC.