@lazyingart/agintiflow 0.20.157 → 0.20.164

package/README.md

@@ -56,8 +56,9 @@ Most agent tools are either a chat box with hidden state or an expensive one-mod
 | Writing without agent noise | `writing_specialist` drafts novels, books, scripts, essays, and paper prose in an isolated writing-only context, then the main agent handles files, formatting, citations, checks, and artifacts. |
 | Visual and web evidence | `read_image` reads screenshots/figures with typed perception artifacts, `web_research` saves sourced research artifacts, and `research_wrapper` can ask Codex `gpt-5.4-mini` medium for a strict-JSON second opinion. |
 | Scouts before big work | Parallel scouts can cheaply map architecture, tests, risks, symbols, and integration points before the main executor edits anything. |
-| 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`. |
+| SCS by default | Student-Committee-Supervisor mode adds a typed gate: committee drafts, student approves/monitors, supervisor executes. Use `/scs off` or `--no-scs` only when speed matters more than validation. |
 | 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. |
+| MCP without tool sprawl | Project/global MCP servers can be connected through a fixed guarded bridge. AgInTiFlow lists tools/resources/prompts and calls selected server tools without dumping untrusted remote tool schemas directly into every model turn. |
 | 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. |
 
 ## Quick Start
@@ -153,8 +154,10 @@ aginti --language de
 | Review current repo | `/review [focus]` |
 | Toggle SCS quality gate | `/scs` |
 | Use SCS only for complex work | `/scs auto` or `aginti --scs auto "task"` |
+| Disable SCS for simple work | `/scs off` or `aginti --no-scs "task"` |
 | Control dynamic step budgets | `--dynamic-steps auto\|on\|off` |
 | Work with AAPS workflows | `aginti aaps status`, `/aaps validate` |
+| Inspect or call MCP servers | `aginti mcp status`, `/mcp tools <server>`, `/mcp call <server> <tool> '{"arg":"value"}'` |
 | Choose models | `/route`, `/model`, `/spare`, `/wrapper`, `/auxiliary model` |
 | Switch permissions | `-s safe`, `-s normal`, `-s danger`, or `/safe`, `/normal`, `/danger` |
 | Enable Venice shortcut | `/venice` |
@@ -237,10 +240,11 @@ The website keeps the visual walkthrough in a carousel so this README can stay f
 | Patch workflow | Codex-style patch envelopes, unified diffs, exact replacements, hashes, compact diffs, and path guardrails. |
 | Parallel scouts | Optional scout calls for architecture, implementation, review, tests, git flow, research, symbol tracing, and dependency risk. |
 | Image reading and web research | `read_image` uses OpenAI vision for workspace images when `OPENAI_API_KEY` is configured. `web_research` preserves source lists, and optional OpenAI hosted web search or `research_wrapper` can be used for higher-confidence research. |
-| SCS mode | Optional Student-Committee-Supervisor quality gate for complicated or risky tasks. |
+| SCS mode | Default Student-Committee-Supervisor quality gate with independent planning, execution, and validation roles. |
 | AAPS adapter | Optional `@lazyingart/aaps` integration for `.aaps` workflow init, validate, parse, compile, dry-run, and run commands. |
 | Image generation | Optional GRS AI and Venice image tools with saved manifests and canvas artifact previews. |
-| Skill library | Built-in Markdown skills for code, websites, Android/iOS, Python, Rust, Java, LaTeX, writing, reviews, source ingestion/OCR, structured JSON, autonomous artifact pipelines, GitHub, AAPS, and more. |
+| Skill library | Built-in Markdown skills plus project-local `.aginti/skills/<id>/SKILL.md` skills for reusable workflow knowledge that should not be hard-coded into the runtime. |
+| External skill packs | Whole Agent Skills repositories can be loaded as grouped packs without flattening. A sibling `../scientific-agent-skills` checkout is discovered as the `scientific` category, so commands like `aginti skills rdkit` and `aginti skills "single cell scanpy"` expose K-Dense Scientific Agent Skills when present. |
 | Skill Mesh | Optional strict skill recording/sharing for reviewed reusable skill packs. If unused, AgInTiFlow runs normally without background sharing. |
 | Multilingual UI | CLI and docs language support for English, Japanese, Simplified/Traditional Chinese, Korean, French, Spanish, Arabic, Vietnamese, German, and Russian. |
 

package/docs/external-skill-packs.md

@@ -0,0 +1,59 @@
+# External Skill Packs
+
+AgInTiFlow can load reviewed external Agent Skills repositories as grouped skill
+packs. This keeps large third-party collections intact instead of flattening
+them into AgInTiFlow's built-in `skills/` directory.
+
+## Scientific Agent Skills
+
+When `/home/lachlan/ProjectsLFS/Agent/scientific-agent-skills` exists,
+AgInTiFlow automatically discovers it as:
+
+- pack: `scientific-agent-skills`
+- label: `Scientific Agent Skills`
+- category: `scientific`
+- skills directory: `scientific-skills/`
+
+The skills are shown as `source=external-pack category=scientific
+pack=scientific-agent-skills` in `aginti skills`.
+
+Example:
+
+```bash
+aginti skills rdkit
+aginti skills "single cell scanpy"
+```
+
+The original repository remains a separate checkout. AgInTiFlow only reads
+`*/SKILL.md` files and preserves each skill's local references, scripts, and
+assets in that checkout.
+
+## Generic Pack Loading
+
+Set `AGINTIFLOW_SKILL_PACKS` to one or more pack roots separated by the platform
+path delimiter or commas:
+
+```bash
+AGINTIFLOW_SKILL_PACKS=/path/to/pack-a:/path/to/pack-b aginti skills
+```
+
+Each pack may contain one of these layouts:
+
+- `scientific-skills/<skill-id>/SKILL.md`
+- `skills/<skill-id>/SKILL.md`
+- `<skill-id>/SKILL.md`
+
+AgInTiFlow supports both its native frontmatter (`id`, `label`, `description`,
+`triggers`, `tools`) and the broader Agent Skills dialect used by K-Dense
+(`name`, `description`, `allowed-tools`, nested `metadata`).
+
+## Design Rules
+
+- External packs are optional. Missing packs do not block startup.
+- Built-in and project-local skills win on ID collisions.
+- External pack skills are selected only when their name, triggers, or
+  description match the task.
+- Skills are prompt guidance, not trusted executable tools. Scripts inside a
+  pack still run only through AgInTiFlow's normal command policy.
+- Pack metadata is retained in CLI, web config, capability reports, and prompt
+  context so users can see where a skill came from.

package/docs/mcp.md

@@ -0,0 +1,120 @@
+# AgInTiFlow MCP Bridge
+
+AgInTiFlow supports MCP as a guarded runtime bridge. MCP is separate from Markdown skills: skills add prompt guidance, while MCP servers expose executable tools, resources, and prompts.
+
+## Configuration
+
+AgInTiFlow loads MCP servers from these sources, later sources overriding earlier server IDs:
+
+- Global: `~/.agintiflow/mcp.json`
+- Project: `.aginti/mcp.json`
+- Extra paths: `AGINTIFLOW_MCP_CONFIG`, separated by the OS path delimiter or commas
+- Inline JSON: `AGINTIFLOW_MCP_CONFIG_JSON`
+- Inline server map: `AGINTIFLOW_MCP_SERVERS`
+
+Claude-style `mcpServers` and plain `servers` maps are both accepted.
+
+```json
+{
+  "mcpServers": {
+    "filesystem-readonly": {
+      "transport": "stdio",
+      "command": "node",
+      "args": ["./tools/filesystem-mcp.js"],
+      "trust": "read-only",
+      "readOnly": true,
+      "allowedTools": ["list_files", "read_file"]
+    },
+    "research": {
+      "transport": "http",
+      "url": "http://127.0.0.1:4321/mcp",
+      "trust": "untrusted"
+    }
+  }
+}
+```
+
+## CLI And Chat
+
+Inspect MCP status:
+
+```bash
+aginti mcp status
+aginti mcp config --json
+aginti mcp tools filesystem-readonly
+aginti mcp resources filesystem-readonly
+aginti mcp read filesystem-readonly aginti://example/resource
+aginti mcp prompts research
+aginti mcp prompt research summarize '{"topic":"protein design"}'
+aginti mcp call filesystem-readonly read_file '{"path":"README.md"}'
+aginti mcp restart filesystem-readonly
+```
+
+Inside the interactive CLI:
+
+```text
+/mcp status
+/mcp tools filesystem-readonly
+/mcp call filesystem-readonly read_file {"path":"README.md"}
+/mcp off
+/mcp on
+```
+
+## Runtime Model Contract
+
+The model sees a fixed bridge toolset:
+
+- `mcp_list_servers`
+- `mcp_list_tools`
+- `mcp_call_tool`
+- `mcp_list_resources`
+- `mcp_read_resource`
+- `mcp_list_prompts`
+- `mcp_get_prompt`
+
+AgInTiFlow intentionally does not dump every remote MCP tool into the model by default. This avoids tool-name collisions, tool poisoning, and unbounded prompt growth. Remote tool descriptions, resources, prompts, and results are always untrusted context and never override system, developer, user, project, or permission instructions.
+
+## Policy
+
+MCP calls pass through AgInTiFlow policy:
+
+- Stdio servers require shell tools to be enabled.
+- Stdio server commands are host processes, even when the agent shell sandbox is Docker. AgInTiFlow checks them against host command policy and requires `trust=trusted` or `allowHostProcess=true` when the command is broader than the narrow read-only host allowlist.
+- `allowedTools` and `deniedTools` are enforced before a tool call.
+- `readOnly` servers block mutating-looking tools unless explicitly trusted.
+- Mutating-looking tools require `allowedTools`, `trust=trusted`, `allowAllTools=true`, or a trusted destructive run mode.
+- Safe mode blocks reading resources/prompts from `trust=untrusted` servers.
+- Secret-like fields in returned data are redacted before logs and model context.
+
+Every MCP operation records normal AgInTiFlow tool events, so sessions remain auditable through CLI logs, web run output, and session event JSONL.
+
+## Web UI
+
+The web UI exposes configured MCP servers in the capability panel and `/api/mcp`:
+
+```bash
+curl http://127.0.0.1:3210/api/mcp
+curl -X POST http://127.0.0.1:3210/api/mcp \
+  -H 'content-type: application/json' \
+  -d '{"argv":["tools","filesystem-readonly"]}'
+```
+
+Use the MCP toggle in Advanced Settings to disable bridge tools for a run without changing project configuration.
+
+## Current Scope
+
+Implemented now:
+
+- Config loading and redacted public summaries.
+- Stdio client lifecycle with lazy startup, request timeouts, stderr capture, and shutdown.
+- Streamable HTTP client lifecycle.
+- Guarded bridge tools in the model loop.
+- CLI `/mcp` and `aginti mcp` commands.
+- Web API and status panel.
+- Smoke coverage with a real local stdio MCP server.
+
+Not implemented yet:
+
+- OAuth and elicitation UX.
+- Dynamic direct tool registration such as `mcp__server__tool`.
+- AgInTiFlow acting as an MCP server for external clients.

package/docs/npm-publishing.md

@@ -38,8 +38,10 @@ Trusted Publishing is preferred. A local automation token can be used only for b
 ```bash
 cp .env.example .env
 # Add NPM_TOKEN or NODE_AUTH_TOKEN locally only.
-set -a && source .env && set +a
-npm publish --access public
+npm run publish:env:whoami
+npm run publish:env
 ```
 
+`publish:env` reads `.env`, writes a temporary npm config, runs npm with that config, and deletes it. Do not use global `~/.npmrc` for agent-driven publishing because it can be stale, point at the wrong account, or leak between projects.
+
 Never commit `.env`, `.npmrc`, npm tokens, OTPs, npm debug logs, or generated credential material. The runtime command policy intentionally blocks npm publish and npm token commands during agent runs.

package/docs/skills-and-tools.md

@@ -4,7 +4,7 @@ AgInTiFlow separates **skills** from **tools** so the agent can stay general whi
 
 ## Definitions
 
-**Skill**: Markdown guidance stored at `skills/<id>/SKILL.md`. A skill describes when to use a workflow, what to inspect first, which outputs matter, and which tools are usually useful. Skills are prompt context, not executable code.
+**Skill**: Markdown guidance stored at built-in `skills/<id>/SKILL.md` or project-local `.aginti/skills/<id>/SKILL.md`. A skill describes when to use a workflow, what to inspect first, which outputs matter, and which tools are usually useful. Skills are prompt context, not executable code.
 
 **Tool**: A deterministic or bounded callable capability exposed to the model, such as `inspect_project`, `read_file`, `apply_patch`, `run_command`, `web_search`, `web_research`, `read_image`, `writing_specialist`, `research_wrapper`, `generate_image`, `preview_workspace`, `tmux_capture_pane`, or `send_to_canvas`.
 
@@ -12,7 +12,35 @@ 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, source ingestion/OCR, structured JSON, autonomous artifact pipelines, tmux session control, Android, R/Stan, Python, C/C++, shell scripting, AAPS, novel writing, and supervision/student-agent training.
+The package ships built-in skills for code engineering, website/app building, LaTeX manuscripts, books, Microsoft Word documents, image generation, GitHub maintenance, system maintenance, source ingestion/OCR, structured JSON, autonomous artifact pipelines, tmux session control, Android, R/Stan, Python, C/C++, shell scripting, AAPS, skill creation, novel writing, and supervision/student-agent training.
+
+## External Skill Packs
+
+AgInTiFlow can also load whole external Agent Skills repositories as grouped
+skill packs. This is for large curated collections that should remain intact,
+with their own references, scripts, assets, and upstream history.
+
+The current default scientific pack integration looks for the sibling checkout:
+
+```bash
+/home/lachlan/ProjectsLFS/Agent/scientific-agent-skills
+```
+
+When present, it appears as `source=external-pack category=scientific
+pack=scientific-agent-skills`:
+
+```bash
+aginti skills rdkit
+aginti skills "single cell scanpy"
+```
+
+For arbitrary pack roots, set:
+
+```bash
+AGINTIFLOW_SKILL_PACKS=/path/to/pack-a:/path/to/pack-b aginti skills
+```
+
+See [External Skill Packs](external-skill-packs.md).
 
 List them from a project:
 
@@ -53,10 +81,14 @@ Selected skills are injected into the plan and execution prompts. The LLM still
 
 ## Adding A Skill
 
-Create `skills/<id>/SKILL.md` with valid YAML frontmatter and a short Markdown body. Keep descriptions strings, not YAML arrays, because loaders expect `id`, `label`, and `description` as scalar strings.
+For a reusable project workflow, create `.aginti/skills/<id>/SKILL.md` with valid YAML frontmatter and a short Markdown body. These skills are loaded from the current project, shown as `source=project-local`, and are preferred for task-specific knowledge that should not become core runtime policy.
+
+Built-in package skills live at `skills/<id>/SKILL.md`. Keep descriptions strings, not YAML arrays, because loaders expect `id`, `label`, and `description` as scalar strings.
 
 Good skills are small, actionable, and tool-aware. They should say what to inspect, what to create or verify, and what to avoid. They should not hard-code one exact task.
 
+Use the built-in `skill-creator` skill when the user asks AgInTiFlow to learn or document a reusable method. It should create project-local skills first, then propose SkillMesh sharing only after the workflow has been validated.
+
 For visual or current-information tasks, prefer:
 
 - `read_image` for screenshots, plots, diagrams, microscopy images, scanned text, and UI debugging.

package/docs/student-committee-supervisor.md

@@ -1,13 +1,13 @@
 # Student-Committee-Supervisor Mode
 
-Student-Committee-Supervisor mode, or SCS, is an optional quality gate for complicated AgInTiFlow tasks.
+Student-Committee-Supervisor mode, or SCS, is the default quality gate for AgInTiFlow tasks.
 
-It is intentionally separate from the normal fast pipeline. Small requests should stay cheap and direct. SCS is for work where a weak plan, repeated failed action, or premature finish would be expensive.
+It separates planning, execution, and validation so the executor does not grade its own work. Use `--no-scs` or `/scs off` only when latency matters more than independent validation.
 
 ## Commands
 
 ```bash
-aginti --scs "fix this complicated project and verify it"
+aginti "fix this complicated project and verify it"
 aginti --scs auto "migrate this app and run the checks"
 aginti --no-scs "answer this simple question"
 ```
@@ -22,7 +22,7 @@ Inside interactive chat:
 /scs status
 ```
 
-`/scs` without arguments toggles the feature: off becomes on, and on/auto becomes off.
+`/scs` without arguments toggles the feature: off becomes on, and on/auto becomes off. The default for new sessions is `on`.
 
 ## Role Contract
 
@@ -47,6 +47,8 @@ When SCS is active:
 - Failed, blocked, suspicious, or mismatched tools trigger a bounded student validator review.
 - Every fourth execution step triggers a bounded progress review for long runs.
 - `finish` and assistant-content completion pass through a final student gate.
+- A deterministic task contract and evidence ledger are built under the student gate. The contract records required evidence categories such as file, command, artifact, browser, visual, git, or publish evidence. The ledger classifies recent tool and event evidence into those categories.
+- The final gate compares the contract, approved plan, executor finish claim, and evidence ledger. A model approval cannot override missing deterministic evidence for evidence-bearing tasks unless the run is reporting a real external blocker.
 - If the student validator rejects progress or finish, the runtime asks the committee for a new phase plan and sends that plan back through the student gate before the supervisor continues.
 - Decisions are persisted as `scs.*` events and the phase pack is saved as a session artifact.
 
@@ -59,23 +61,23 @@ The current implementation is deliberately bounded:
 
 ## Auto Mode
 
-`/scs auto` and `--scs auto` activate SCS for complex, risky, or long-running work. Signals include:
+`/scs auto` and `--scs auto` are still available when a user wants cheaper routing for simple turns. Auto mode activates SCS for complex, risky, or long-running work. Signals include:
 
 - high smart-routing complexity score;
 - profiles such as code, app, Android/iOS, large-codebase, GitHub, maintenance, security, LaTeX, research, and supervision;
 - prompts mentioning multi-file work, regressions, builds, deployments, tmux, emulators, Docker, PDFs, or similar high-friction workflows.
 
-Auto mode stays off for simple turns.
+Auto mode stays off for simple turns, but it is not the default.
 
 ## Dynamic Step Budgets
 
 AgInTiFlow treats `maxSteps` as the initial run budget. Near the boundary, the runtime may grant a bounded extension only when recent tool/file/artifact evidence shows concrete progress and no permission blocker is being bypassed.
 
-Normal mode uses a lightweight deterministic monitor. `/scs on` and activated `/scs auto` runs add the SCS student budget gate, which can emit `extend_steps`, `deny_extension`, or `rethink_plan`. More steps never escalate permissions, package policy, host access, destructive actions, or secret access. Use `--dynamic-steps off` when a strict hard stop is required. The detailed design is tracked in [references/dynamic-step-budget-and-scs-auto.md](../references/dynamic-step-budget-and-scs-auto.md).
+Normal mode uses a lightweight deterministic monitor. Default SCS runs and activated `/scs auto` runs add the SCS student budget gate, which can emit `extend_steps`, `deny_extension`, or `rethink_plan`. More steps never escalate permissions, package policy, host access, destructive actions, or secret access. Use `--dynamic-steps off` when a strict hard stop is required. The detailed design is tracked in [references/dynamic-step-budget-and-scs-auto.md](../references/dynamic-step-budget-and-scs-auto.md).
 
-## When To Use It
+## When To Keep It On
 
-Use SCS for:
+Keep SCS on for:
 
 - large coding tasks with ambiguous scope;
 - Android/iOS/system tasks where environment checks matter;
@@ -84,7 +86,7 @@ Use SCS for:
 - paper/LaTeX work where final artifacts need evidence;
 - self-supervision or capability-training runs.
 
-Avoid SCS for:
+Turn SCS off only for:
 
 - `ls`, `pwd`, short factual answers, and small one-file edits;
 - tasks where latency matters more than plan quality;
@@ -114,6 +116,8 @@ These are saved in the normal session event log under `~/.agintiflow/sessions/<s
 
 Browser and CDP helper commands are reviewed by evidence, not only by exit status. If a click or selector command reports `ok: true` but returns broad whole-page text, repeated navigation/history/sidebar text, or no scoped target evidence, SCS treats the result as suspicious and asks the supervisor to verify state or switch to a precise selector before continuing.
 
+For upload, browser, visual, media, or external-service tasks, a successful helper command is not enough by itself. The ledger must include evidence that proves the requested state, such as the active page, visible count, screenshot, output artifact, build/test output, or committed/published state.
+
 ## Design Reference
 
-The deeper design research lives in [references/student-committee-supervisor-mode.md](../references/student-committee-supervisor-mode.md). The important design choice is that SCS is a typed event gate, not a free-form debate. Internal roles emit structured decisions, and the runtime decides what those decisions are allowed to do.
+The deeper design research lives in [references/student-committee-supervisor-mode.md](../references/student-committee-supervisor-mode.md) and [references/scs-evidence-validator-core-design.md](../references/scs-evidence-validator-core-design.md). The important design choice is that SCS is a typed event gate, not a free-form debate. Internal roles emit structured decisions, and the runtime decides what those decisions are allowed to do.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.157",
+  "version": "0.20.164",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",
@@ -48,6 +48,7 @@
     "references/notes/*.md",
     "references/run_design_scan.sh",
     "scripts/install-docker-ubuntu.sh",
+    "scripts/npm-publish-from-env.js",
     "scripts/setup-agent-toolchain-docker.sh",
     "scripts/real-deepseek-capabilities.js",
     "scripts/postinstall-webapp.js",
@@ -62,6 +63,8 @@
     "scripts/smoke-capabilities.js",
     "scripts/smoke-auto-update.js",
     "scripts/smoke-inbox.js",
+    "scripts/smoke-mcp.js",
+    "scripts/fixtures/mcp-stdio-smoke-server.mjs",
     "scripts/smoke-model-roles.js",
     "scripts/smoke-platform.js",
     "scripts/smoke-perception-research.js",
@@ -87,7 +90,7 @@
   "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 && node --check scripts/seed-supervised-homework.js",
+    "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check src/*.js && node --check src/mcp/*.js && node --check public/app.js && node --check scripts/seed-supervised-homework.js && node --check scripts/smoke-mcp.js && node --check scripts/fixtures/mcp-stdio-smoke-server.mjs",
     "setup:toolchain-docker": "scripts/setup-agent-toolchain-docker.sh",
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
     "smoke:dynamic-step-budget": "node scripts/smoke-dynamic-step-budget.js",
@@ -101,6 +104,7 @@
     "smoke:skillmesh": "node scripts/smoke-skillmesh.js",
     "smoke:toolchain-docker": "node scripts/smoke-toolchain-docker.js",
     "smoke:inbox": "node scripts/smoke-inbox.js",
+    "smoke:mcp": "node scripts/smoke-mcp.js",
     "smoke:model-roles": "node scripts/smoke-model-roles.js",
     "smoke:platform": "node scripts/smoke-platform.js",
     "smoke:perception-research": "node scripts/smoke-perception-research.js",
@@ -116,11 +120,14 @@
     "postinstall": "node scripts/postinstall-webapp.js",
     "supervision:seed": "node scripts/seed-supervised-homework.js",
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
-    "test": "npm run check && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && 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:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:cli-chat && npm run smoke:inbox",
+    "publish:env": "node scripts/npm-publish-from-env.js publish --access public",
+    "publish:env:whoami": "node scripts/npm-publish-from-env.js whoami",
+    "test": "npm run check && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:auth && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "express": "^5.1.0",
     "openai": "^6.3.0",
     "playwright": "^1.55.0"

package/public/app.js

@@ -84,6 +84,7 @@ const translations = {
     shellToolLabel: "Enable shell tool",
     fileToolLabel: "Enable file tools",
     auxiliaryToolLabel: "Enable auxiliary skills",
+    mcpToolLabel: "Enable MCP bridge",
     webSearchLabel: "Enable web search",
     parallelScoutsLabel: "Parallel DeepSeek scouts",
     parallelScoutCountLabel: "Scout count",
@@ -114,6 +115,8 @@ const translations = {
     wrappersOffLabel: "wrapper tools off",
     wrapperCapabilityTitle: "Agent wrappers",
     workspaceCapabilityTitle: "Workspace files",
+    mcpCapabilityTitle: "MCP servers",
+    mcpEmpty: "No MCP servers configured.",
     workspaceToolsLabel: "File tools",
     workspaceChangesEmpty: "No file changes yet.",
     changedLabel: "changed",
@@ -695,6 +698,7 @@ const stopRunButton = document.querySelector("#stop-run");
 const keyStatusEl = document.querySelector("#key-status");
 const allowAuxiliaryToolsField = document.querySelector("#allowAuxiliaryTools");
 const allowWebSearchField = document.querySelector("#allowWebSearch");
+const allowMcpToolsField = document.querySelector("#allowMcpTools");
 const allowParallelScoutsField = document.querySelector("#allowParallelScouts");
 const parallelScoutCountField = document.querySelector("#parallelScoutCount");
 const allowWrapperToolsField = document.querySelector("#allowWrapperTools");
@@ -704,6 +708,9 @@ const wrapperGridEl = document.querySelector("#wrapper-grid");
 const workspaceStatusEl = document.querySelector("#workspace-status");
 const workspaceToolsEl = document.querySelector("#workspace-tools");
 const workspaceChangesEl = document.querySelector("#workspace-changes");
+const mcpStatusEl = document.querySelector("#mcp-status");
+const mcpGridEl = document.querySelector("#mcp-grid");
+const mcpWarningsEl = document.querySelector("#mcp-warnings");
 const sandboxStatusEl = document.querySelector("#sandbox-status");
 const sandboxLogsEl = document.querySelector("#sandbox-logs");
 const checkSandboxButton = document.querySelector("#check-sandbox");
@@ -776,6 +783,7 @@ let lastWrappers = [];
 let lastSandbox = null;
 let lastWorkspace = null;
 let lastWorkspaceActivity = [];
+let lastMcp = null;
 let managedSessionId = "";
 let artifactItems = [];
 let selectedArtifactId = "";
@@ -975,6 +983,28 @@ function renderWorkspacePanel(workspace = lastWorkspace, activity = lastWorkspac
     .join("");
 }
 
+function renderMcpPanel(mcp = lastMcp) {
+  lastMcp = mcp || null;
+  if (!mcpStatusEl || !mcpGridEl || !mcpWarningsEl) return;
+  const servers = mcp?.servers || [];
+  const enabled = servers.filter((server) => server.enabled).length;
+  mcpStatusEl.textContent = servers.length
+    ? `${enabled}/${servers.length} enabled · config=${(mcp.loadedPaths || []).length || 0}`
+    : t("mcpEmpty");
+  mcpGridEl.innerHTML = servers
+    .map(
+      (server) => `
+        <div class="capability-chip" data-ready="${Boolean(server.enabled)}">
+          <strong>${escapeHtml(server.id || server.label || "mcp")}</strong>
+          <span>${escapeHtml(server.transport || "")} · trust=${escapeHtml(server.trust || "untrusted")}</span>
+        </div>
+      `
+    )
+    .join("");
+  mcpWarningsEl.textContent = (mcp?.warnings || []).join("\n");
+  mcpWarningsEl.hidden = !(mcp?.warnings || []).length;
+}
+
 function renderSandboxStatus(status = lastSandbox) {
   lastSandbox = status;
   if (!status) {
@@ -1352,6 +1382,7 @@ function formPayload() {
     allowFileTools: document.querySelector("#allowFileTools").checked,
     allowAuxiliaryTools: allowAuxiliaryToolsField?.checked ?? true,
     allowWebSearch: allowWebSearchField?.checked ?? true,
+    allowMcpTools: allowMcpToolsField?.checked ?? true,
     allowParallelScouts: allowParallelScoutsField?.checked ?? true,
     parallelScoutCount: Math.min(Math.max(Number(parallelScoutCountField?.value) || 3, 1), 10),
     allowWrapperTools: allowWrapperToolsField.checked,
@@ -3064,6 +3095,7 @@ async function loadConfig() {
   document.querySelector("#allowFileTools").checked = prefs.allowFileTools ?? true;
   if (allowAuxiliaryToolsField) allowAuxiliaryToolsField.checked = prefs.allowAuxiliaryTools ?? true;
   if (allowWebSearchField) allowWebSearchField.checked = prefs.allowWebSearch ?? true;
+  if (allowMcpToolsField) allowMcpToolsField.checked = prefs.allowMcpTools ?? true;
   if (allowParallelScoutsField) allowParallelScoutsField.checked = prefs.allowParallelScouts ?? true;
   if (parallelScoutCountField) parallelScoutCountField.value = String(prefs.parallelScoutCount || 3);
   allowWrapperToolsField.checked = prefs.allowWrapperTools ?? false;
@@ -3076,6 +3108,7 @@ async function loadConfig() {
   renderProjectStatus(data.project);
   renderWrapperStatus(data.wrappers || []);
   renderWorkspacePanel(data.workspace, []);
+  renderMcpPanel(data.mcp || null);
   await refreshWorkspaceChanges();
   renderSandboxLogs(data.sandbox?.logs || []);
   updateRoutingHint();

package/public/index.html

@@ -287,6 +287,15 @@
           <div id="workspace-changes" class="workspace-changes"></div>
         </section>
 
+        <section class="capability-card mcp-card">
+          <div>
+            <h2 data-i18n="mcpCapabilityTitle">MCP servers</h2>
+            <p id="mcp-status" class="subtle wrapper-status"></p>
+          </div>
+          <div id="mcp-grid" class="capability-grid"></div>
+          <pre id="mcp-warnings" class="sandbox-logs mcp-warnings"></pre>
+        </section>
+
         <section class="sandbox-card">
           <div class="header-row">
             <div>
@@ -429,6 +438,11 @@
               <span class="switch" aria-hidden="true"></span>
               <span data-i18n="auxiliaryToolLabel">Enable auxiliary skills</span>
             </label>
+            <label class="switch-label">
+              <input id="allowMcpTools" name="allowMcpTools" type="checkbox" checked />
+              <span class="switch" aria-hidden="true"></span>
+              <span data-i18n="mcpToolLabel">Enable MCP bridge</span>
+            </label>
             <label class="switch-label">
               <input id="allowParallelScouts" name="allowParallelScouts" type="checkbox" checked />
               <span class="switch" aria-hidden="true"></span>

package/public/styles.css

@@ -687,6 +687,15 @@ button.danger {
   background: linear-gradient(135deg, rgba(255, 253, 250, 0.9), rgba(239, 246, 255, 0.72));
 }
 
+.mcp-card {
+  border-color: rgba(15, 118, 110, 0.18);
+  background: linear-gradient(135deg, rgba(255, 253, 250, 0.92), rgba(204, 251, 241, 0.32));
+}
+
+.mcp-warnings[hidden] {
+  display: none;
+}
+
 .workspace-changes {
   display: grid;
   gap: 8px;