@lazyingart/agintiflow 0.4.1 → 0.6.0

package/README.md

@@ -66,10 +66,13 @@ Useful project commands:
 ```bash
 aginti keys status
 printf '%s' "$DEEPSEEK_API_KEY" | aginti keys set deepseek --stdin
+aginti capabilities
+aginti doctor --capabilities
 aginti sessions list
 aginti sessions show <session-id>
 aginti resume <session-id> "continue with a short follow-up"
 aginti --profile code --provider mock --routing manual "Create notes/hello.md"
+aginti --allow-shell --sandbox-mode docker-workspace --approve-package-installs "set up and test this project"
 ```
 
 Run from a source checkout:
@@ -113,6 +116,29 @@ npm start -- --resume your-session-id
 
 The package exposes both `aginti` and `aginti-cli`; they run the same CLI entrypoint.
 
+## Capability Checks
+
+Use the capability report to verify a project folder before running real agent work:
+
+```bash
+aginti capabilities
+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, 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:
+
+```bash
+AGINTIFLOW_REAL_DEEPSEEK=1 \
+AGINTIFLOW_REAL_WORKSPACE=/home/lachlan/ProjectsLFS/aginti-test \
+AGINTIFLOW_REAL_WEB_BASE_URL=http://127.0.0.1:3220 \
+npm run real:deepseek
+```
+
+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).
+
 ## Web UI
 
 The web app includes:
@@ -156,12 +182,12 @@ AgInTiFlow is intentionally conservative:
 - Shell commands are disabled unless the shell tool is enabled.
 - Workspace file tools stay inside `commandCwd` and block `.env`, secret-like paths, `.git`, node_modules writes, absolute escapes, binary files, and huge files.
 - File writes record before/after SHA-256 hashes and compact redacted diffs.
-- Guarded shell mode only allows inspection, test/build checks, and approved setup commands.
+- 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.
 - Docker read-only mode mounts the workspace read-only and disables container network access.
 - Docker workspace-write mode is the web UI default so plot, PDF, and test outputs can be written inside the mounted workspace.
-- Docker workspace-write mode is required for approved package or environment setup.
+- Docker workspace-write mode is the preferred place for approved package or environment setup, including `apt-get`, `npm`, `pip`, `curl`, and `wget` workflows inside the container.
 - Package installs default to `prompt`, so npm/pip/conda/venv setup is blocked until explicitly approved.
-- NPM publishing, npm token commands, sudo, destructive git actions, curl/wget, and shell chaining are blocked.
+- 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.
 - NPM tokens and API keys are redacted from tool logs and API responses.
 - Every tool request and result is written to structured logs.
 
@@ -286,9 +312,9 @@ The setup script idempotently builds `agintiflow-sandbox:latest` from `docker/sa
 
 | Mode | Workspace mount | Network | Intended use |
 | --- | --- | --- | --- |
-| `host` | local process | host network | legacy read-only inspection only |
+| `host` | local process | host network | direct project work; privileged/destructive commands require explicit trust |
 | `docker-readonly` | read-only `/workspace` | none | safe coding inspection and tests that do not write files |
-| `docker-workspace` | writable `/workspace` | none by default, enabled only for approved package installs | web UI default for environment setup, plotting, and LaTeX/PDF compilation inside the mounted project |
+| `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 |
 
 Package policy values:
 
@@ -296,7 +322,7 @@ Package policy values:
 | --- | --- |
 | `block` | Always block npm/pip/conda/venv setup. |
 | `prompt` | Return a clear approval-required error; the UI can switch to approved. |
-| `allow` | Permit allowlisted setup commands only in `docker-workspace`. |
+| `allow` | Permit package/setup commands. Docker workspace mode also allows broader shell/network commands while keeping secrets and npm publishing blocked. |
 
 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 they require `docker-workspace` because they write outputs back to `/workspace`. File and canvas tools accept both normal relative paths and Docker virtual paths like `/workspace/report.pdf`, while other absolute host paths remain blocked.
 

package/docs/real-deepseek-capabilities.md

@@ -0,0 +1,51 @@
+# Real DeepSeek Capability Suite
+
+AgInTiFlow keeps deterministic mock smoke tests for CI, but Round 9 added an opt-in live suite for validating DeepSeek v4 flash/pro behavior against a real project folder.
+
+## Prerequisites
+
+- Node.js 22+
+- A project folder initialized with `aginti init`
+- `DEEPSEEK_API_KEY` in the environment or project-local `.aginti/.env`
+- Optional web UI running from the same project folder
+
+Never print or commit API keys. The suite reports only provider availability.
+
+## Static Capability Report
+
+```bash
+aginti capabilities
+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.
+
+## Live DeepSeek Suite
+
+Run from the source repository:
+
+```bash
+AGINTIFLOW_REAL_DEEPSEEK=1 \
+AGINTIFLOW_REAL_WORKSPACE=/home/lachlan/ProjectsLFS/aginti-test \
+AGINTIFLOW_REAL_WEB_BASE_URL=http://127.0.0.1:3220 \
+npm run real:deepseek
+```
+
+Optional case filter:
+
+```bash
+AGINTIFLOW_REAL_DEEPSEEK=1 AGINTIFLOW_REAL_CASES=flash,pro npm run real:deepseek
+```
+
+## What It Validates
+
+- `flash`: DeepSeek v4 flash creates a dependency-free Node/HTML app with `node:test` tests and runs `npm --prefix <app> test` when safe.
+- `pro`: DeepSeek v4 pro resumes/improves the app and expands tests.
+- `latex`: creates `.tex` source and compiles only if a TeX toolchain is available; otherwise writes an honest setup artifact.
+- `website`: creates a website test sample and runs checks with the configured shell/package policy.
+- `maintenance`: verifies the agent can prepare project-local maintenance work and use Docker/package policy for broader setup commands without exposing secrets.
+- `aaps`: creates a project-local `.aaps` sample and notes for `@lazyingart/aaps` workflows without publishing.
+- `web`: when `AGINTIFLOW_REAL_WEB_BASE_URL` is set, starts a web run and verifies CLI/web session sharing.
+
+The suite writes a JSON summary with session IDs, generated files, routes, and failures. It is intentionally opt-in because it spends live model credits.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "AgInTiFlow is a resumable Playwright website-control agent with OpenAI-compatible tool calling.",
   "license": "Apache-2.0",
@@ -40,7 +40,9 @@
     "public/",
     "scripts/install-docker-ubuntu.sh",
     "scripts/setup-agent-toolchain-docker.sh",
+    "scripts/real-deepseek-capabilities.js",
     "scripts/smoke-coding-tools.js",
+    "scripts/smoke-capabilities.js",
     "scripts/smoke-toolchain-docker.js",
     "scripts/smoke-web-api.js",
     "src/",
@@ -59,8 +61,10 @@
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
     "smoke:toolchain-docker": "node scripts/smoke-toolchain-docker.js",
     "smoke:web-api": "node scripts/smoke-web-api.js",
-    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools",
-    "pack:dry-run": "npm pack --dry-run"
+    "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:capabilities",
+    "pack:dry-run": "npm pack --dry-run",
+    "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },
   "dependencies": {
     "express": "^5.1.0",

package/scripts/real-deepseek-capabilities.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import { runAgent } from "../src/agent-runner.js";
+import { buildCapabilityReport } from "../src/capabilities.js";
+import { resolveRuntimeConfig } from "../src/config.js";
+import { initProject, listProjectSessions, providerKeyStatus, showProjectSession } from "../src/project.js";
+
+const execFileAsync = promisify(execFile);
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(await fs.readFile(path.join(repoRoot, "package.json"), "utf8"));
+const projectRoot = path.resolve(process.env.AGINTIFLOW_REAL_WORKSPACE || "/home/lachlan/ProjectsLFS/aginti-test");
+const webBaseUrl = String(process.env.AGINTIFLOW_REAL_WEB_BASE_URL || "").replace(/\/$/, "");
+const enabled = process.env.AGINTIFLOW_REAL_DEEPSEEK === "1";
+const stamp = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+function isJavaScriptTest(file) {
+  const base = path.basename(file);
+  return /^(test|.+\.(test|spec))\.[mc]?js$/.test(base) || (file.includes("/test/") && /\.[mc]?js$/.test(base));
+}
+
+function selectedCases() {
+  const raw = process.env.AGINTIFLOW_REAL_CASES || "flash,pro,latex,website,maintenance,aaps";
+  return new Set(raw.split(",").map((item) => item.trim()).filter(Boolean));
+}
+
+function baseConfig(goal, overrides = {}) {
+  return resolveRuntimeConfig(
+    {
+      provider: "deepseek",
+      routingMode: overrides.routingMode || "smart",
+      model: overrides.model || "",
+      goal,
+      commandCwd: projectRoot,
+      maxSteps: overrides.maxSteps || 12,
+      sandboxMode: overrides.sandboxMode || "host",
+      packageInstallPolicy: overrides.packageInstallPolicy || "block",
+      allowShellTool: overrides.allowShellTool ?? true,
+      allowFileTools: true,
+      taskProfile: overrides.taskProfile || "auto",
+      resume: overrides.resume || "",
+      sessionId: overrides.sessionId || "",
+    },
+    {
+      baseDir: projectRoot,
+      packageDir: repoRoot,
+      provider: "deepseek",
+      routingMode: overrides.routingMode || "smart",
+      model: overrides.model || "",
+      commandCwd: projectRoot,
+      maxSteps: overrides.maxSteps || 12,
+      sandboxMode: overrides.sandboxMode || "host",
+      packageInstallPolicy: overrides.packageInstallPolicy || "block",
+      allowShellTool: overrides.allowShellTool ?? true,
+      allowFileTools: true,
+      taskProfile: overrides.taskProfile || "auto",
+      resume: overrides.resume || "",
+      sessionId: overrides.resume ? "" : overrides.sessionId,
+    }
+  );
+}
+
+async function runCliCase(name, goal, overrides = {}) {
+  const config = baseConfig(goal, {
+    ...overrides,
+    sessionId: overrides.sessionId || `round9-${name}-${stamp}`,
+  });
+  const startedAt = new Date().toISOString();
+  const result = await runAgent(config);
+  const sessionId = result.sessionId || config.sessionId || config.resume;
+  const session = await showProjectSession(projectRoot, sessionId).catch(() => null);
+  return {
+    name,
+    channel: "cli",
+    sessionId,
+    provider: config.provider,
+    model: config.model,
+    routingMode: config.routingMode,
+    taskProfile: config.taskProfile,
+    startedAt,
+    result: result.result || "",
+    stopped: Boolean(result.stopped),
+    events: session?.events?.length || 0,
+  };
+}
+
+async function fetchJson(url, options = {}) {
+  const response = await fetch(url, options);
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(`${url} failed ${response.status}: ${data.error || response.statusText}`);
+  return data;
+}
+
+async function waitForWebRun(sessionId) {
+  const deadline = Date.now() + 180000;
+  while (Date.now() < deadline) {
+    const run = await fetchJson(`${webBaseUrl}/api/runs/${encodeURIComponent(sessionId)}`);
+    if (run.status === "finished" || run.status === "failed") return run;
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+  }
+  throw new Error(`Web run timed out: ${sessionId}`);
+}
+
+async function runWebCase(name, goal, overrides = {}) {
+  if (!webBaseUrl) return null;
+  const started = await fetchJson(`${webBaseUrl}/api/runs`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      provider: "deepseek",
+      routingMode: overrides.routingMode || "smart",
+      model: overrides.model || "",
+      goal,
+      commandCwd: projectRoot,
+      sandboxMode: overrides.sandboxMode || "host",
+      packageInstallPolicy: overrides.packageInstallPolicy || "block",
+      allowShellTool: overrides.allowShellTool ?? true,
+      allowFileTools: true,
+      maxSteps: overrides.maxSteps || 12,
+      taskProfile: overrides.taskProfile || "auto",
+      headless: true,
+    }),
+  });
+  const run = await waitForWebRun(started.sessionId);
+  return {
+    name,
+    channel: "web",
+    sessionId: started.sessionId,
+    provider: run.provider,
+    model: run.model,
+    status: run.status,
+    result: run.result || "",
+    error: run.error || "",
+  };
+}
+
+async function assertFile(relativePath) {
+  const absolutePath = path.join(projectRoot, relativePath);
+  const stat = await fs.stat(absolutePath).catch(() => null);
+  return {
+    path: relativePath,
+    exists: Boolean(stat),
+    size: stat?.size || 0,
+  };
+}
+
+async function listFilesRecursive(relativeDir) {
+  const root = path.join(projectRoot, relativeDir);
+  const entries = [];
+  async function visit(currentAbs, currentRel) {
+    const children = await fs.readdir(currentAbs, { withFileTypes: true }).catch(() => []);
+    for (const child of children) {
+      const childAbs = path.join(currentAbs, child.name);
+      const childRel = path.posix.join(currentRel.split(path.sep).join(path.posix.sep), child.name);
+      if (child.isDirectory()) await visit(childAbs, childRel);
+      else if (child.isFile()) entries.push(childRel);
+    }
+  }
+  await visit(root, relativeDir);
+  return entries;
+}
+
+async function runLocalCheck(command, args, cwdRel = ".") {
+  try {
+    const result = await execFileAsync(command, args, {
+      cwd: path.join(projectRoot, cwdRel),
+      timeout: 90000,
+      maxBuffer: 2 * 1024 * 1024,
+      env: {
+        ...process.env,
+        npm_config_loglevel: "warn",
+      },
+    });
+    return {
+      ok: true,
+      command: [command, ...args].join(" "),
+      stdout: String(result.stdout || "").slice(0, 1600),
+      stderr: String(result.stderr || "").slice(0, 1600),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      command: [command, ...args].join(" "),
+      stdout: String(error.stdout || "").slice(0, 1600),
+      stderr: String(error.stderr || error.message || "").slice(0, 1600),
+    };
+  }
+}
+
+function addCheck(report, name, ok, details = {}) {
+  report.checks.push({ name, ok: Boolean(ok), ...details });
+  if (!ok) report.ok = false;
+}
+
+function addStoppedWarning(report, run) {
+  if (run?.stopped) {
+    report.warnings.push(`${run.name} reached max steps before finish(); artifacts were validated separately.`);
+  }
+}
+
+if (!enabled) {
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        skipped: true,
+        reason: "Set AGINTIFLOW_REAL_DEEPSEEK=1 to run live DeepSeek capability checks.",
+      },
+      null,
+      2
+    )
+  );
+  process.exit(0);
+}
+
+await initProject(projectRoot);
+const keyStatus = providerKeyStatus(projectRoot);
+if (!keyStatus.deepseek) {
+  console.log(
+    JSON.stringify(
+      {
+        ok: false,
+        skipped: true,
+        reason: "DeepSeek key is not available by env or project-local .aginti/.env.",
+      },
+      null,
+      2
+    )
+  );
+  process.exit(0);
+}
+
+const cases = selectedCases();
+const appDir = `round9/deepseek-app-${stamp}`;
+const report = {
+  ok: true,
+  projectRoot,
+  webBaseUrl: webBaseUrl || "",
+  stamp,
+  capabilities: await buildCapabilityReport(
+    projectRoot,
+    packageJson.version,
+    baseConfig("capability report", { allowShellTool: true, allowFileTools: true })
+  ),
+  runs: [],
+  files: [],
+  checks: [],
+  warnings: [],
+};
+
+if (cases.has("flash")) {
+  const run = await runCliCase(
+    "flash-node-app",
+    `Create a small dependency-free Node and HTML app with tests under ${appDir}. Run safe checks if you can.`,
+    { routingMode: "fast", taskProfile: "node", maxSteps: 24 }
+  );
+  report.runs.push(run);
+  addStoppedWarning(report, run);
+  const files = await listFilesRecursive(appDir);
+  const testFile = files.find(isJavaScriptTest);
+  const appHasCode = files.some((file) => /\.(js|mjs)$/.test(file));
+  const appHasHtml = files.some((file) => /\.html$/.test(file));
+  const testResult = testFile ? await runLocalCheck("node", ["--test", testFile]) : { ok: false, command: "node --test <missing>" };
+  report.files.push(await assertFile(testFile || `${appDir}/test/app.test.js`));
+  addCheck(report, "flash-node-app-files", appHasCode && appHasHtml && Boolean(testFile), { files });
+  addCheck(report, "flash-node-app-tests", testResult.ok, testResult);
+}
+
+if (cases.has("pro")) {
+  const previous = report.runs.find((run) => run.name === "flash-node-app");
+  const run = await runCliCase(
+    "pro-improve-app",
+    `Improve the app in ${appDir} with a useful new feature and matching tests. Run safe checks if you can.`,
+    {
+      routingMode: "complex",
+      taskProfile: "code",
+      maxSteps: 24,
+      resume: previous?.sessionId || "",
+      sessionId: previous ? "" : `round9-pro-improve-${stamp}`,
+    }
+  );
+  report.runs.push(run);
+  addStoppedWarning(report, run);
+  const files = await listFilesRecursive(appDir);
+  const testFile = files.find(isJavaScriptTest);
+  const testResult = testFile ? await runLocalCheck("node", ["--test", testFile]) : { ok: false, command: "node --test <missing>" };
+  addCheck(report, "pro-improve-app-tests", testResult.ok, testResult);
+}
+
+if (cases.has("latex")) {
+  const texDir = `round9/latex-${stamp}`;
+  const run = await runCliCase(
+    "latex-report",
+    `Write a small LaTeX note under ${texDir} about AgInTiFlow capability testing. Compile it if TeX is available; otherwise create an honest setup note.`,
+    { routingMode: "complex", taskProfile: "latex", maxSteps: 16 }
+  );
+  report.runs.push(run);
+  addStoppedWarning(report, run);
+  const files = await listFilesRecursive(texDir);
+  report.files.push(await assertFile(files.find((file) => file.endsWith(".tex")) || `${texDir}/note.tex`));
+  addCheck(report, "latex-source", files.some((file) => file.endsWith(".tex")), { files });
+  addCheck(report, "latex-pdf-or-setup", files.some((file) => file.endsWith(".pdf") || /setup|readme/i.test(file)), { files });
+}
+
+if (cases.has("website")) {
+  const websiteDir = `round9/website-test-${stamp}`;
+  const run = await runCliCase(
+    "website-test",
+    `Create a small website under ${websiteDir} with a simple local test or check file. Run useful checks under the configured policy.`,
+    { routingMode: "fast", taskProfile: "website", maxSteps: 24 }
+  );
+  report.runs.push(run);
+  addStoppedWarning(report, run);
+  const files = await listFilesRecursive(websiteDir);
+  const nodeTest = files.find(isJavaScriptTest);
+  const pythonTest = files.find((file) => /(^|\/)(test_.*|.*_test)\.py$/.test(path.basename(file)));
+  const shellTest = files.find((file) => /^test[-_\w]*\.sh$/.test(path.basename(file)));
+  const testResult = nodeTest
+    ? await runLocalCheck("node", ["--test", nodeTest])
+    : pythonTest
+      ? await runLocalCheck("python3", [pythonTest])
+      : shellTest
+        ? await runLocalCheck("bash", ["-n", shellTest])
+        : { ok: false, command: "<missing website test>" };
+  report.files.push(await assertFile(nodeTest || pythonTest || shellTest || `${websiteDir}/test/website.test.js`));
+  addCheck(report, "website-test-files", files.some((file) => file.endsWith(".html")) && Boolean(nodeTest || pythonTest || shellTest), { files });
+  addCheck(report, "website-test-runs", testResult.ok, testResult);
+}
+
+if (cases.has("maintenance")) {
+  const maintenanceDir = `maintenance/round9-${stamp}`;
+  const run = await runCliCase(
+    "maintenance-plan",
+    `Create project-local maintenance plans and scripts under ${maintenanceDir} for Miniforge/conda, R, Python tooling, CmdStan/CmdStanR, and PyStan. Use Docker/package policy for setup checks when useful.`,
+    {
+      routingMode: "complex",
+      taskProfile: "maintenance",
+      sandboxMode: "docker-workspace",
+      packageInstallPolicy: "allow",
+      maxSteps: 24,
+    }
+  );
+  report.runs.push(run);
+  addStoppedWarning(report, run);
+  const files = await listFilesRecursive(maintenanceDir);
+  const shellScripts = files.filter((file) => file.endsWith(".sh"));
+  const syntaxResults = [];
+  for (const script of shellScripts) syntaxResults.push(await runLocalCheck("bash", ["-n", script]));
+  report.files.push(await assertFile(files.find((file) => /\.md$/i.test(file)) || `${maintenanceDir}/README.md`));
+  addCheck(report, "maintenance-plan-files", files.some((file) => /\.md$/i.test(file)) && shellScripts.length > 0, { files });
+  addCheck(report, "maintenance-shell-syntax", syntaxResults.every((item) => item.ok), { syntaxResults });
+}
+
+if (cases.has("aaps")) {
+  const run = await runCliCase(
+    "aaps-sample",
+    "Create a small project-local AAPS sample and notes for @lazyingart/aaps workflows.",
+    { routingMode: "fast", taskProfile: "aaps", maxSteps: 14 }
+  );
+  report.runs.push(run);
+  addStoppedWarning(report, run);
+  const files = [
+    ...(await listFilesRecursive(".aaps")),
+    ...(await listFilesRecursive("aaps-sample")),
+  ];
+  const aapsFile = files.find((file) => file.includes(".aaps/") || file.endsWith(".aaps") || file.endsWith(".json"));
+  report.files.push(await assertFile(aapsFile || ".aaps/round9-sample.json"));
+  addCheck(report, "aaps-sample-files", Boolean(aapsFile), { files });
+}
+
+if (webBaseUrl) {
+  const run = await runWebCase(
+    "web-sync-real",
+    `Create notes/web-real-${stamp}.md with a short note that this web run shares the project session folder.`,
+    { routingMode: "fast", taskProfile: "code", maxSteps: 10 }
+  );
+  report.runs.push(run);
+  report.files.push(await assertFile(`notes/web-real-${stamp}.md`));
+  addCheck(report, "web-sync-file", (await assertFile(`notes/web-real-${stamp}.md`)).exists, {
+    sessionId: run?.sessionId,
+    status: run?.status,
+  });
+}
+
+report.sessions = await listProjectSessions(projectRoot, 20);
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok) process.exitCode = 1;

package/scripts/smoke-capabilities.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+
+const execFileAsync = promisify(execFile);
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-capabilities-"));
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+async function runCli(args) {
+  const result = await execFileAsync(process.execPath, [path.join(repoRoot, "bin/aginti-cli.js"), ...args], {
+    cwd: tempRoot,
+    timeout: 20000,
+    maxBuffer: 2 * 1024 * 1024,
+    env: {
+      ...process.env,
+      AGINTIFLOW_RUNTIME_DIR: "",
+    },
+  });
+  return result.stdout;
+}
+
+try {
+  await runCli(["init"]);
+  const capabilities = JSON.parse(await runCli(["capabilities", "--json"]));
+  assert(capabilities.project.root === tempRoot, "capabilities did not use cwd as project root");
+  assert(capabilities.project.commandCwd === tempRoot, "capabilities did not default commandCwd to project root");
+  assert(capabilities.project.sharedSessionFolder, "capabilities did not report shared session folder");
+  assert(capabilities.keys?.mock === true, "capabilities did not report mock availability");
+  assert(
+    capabilities.checks.some((check) => check.name === "npm-prefix-test-policy" && check.ok),
+    "npm --prefix test policy is not allowed"
+  );
+  assert(
+    capabilities.checks.some((check) => check.name === "cd-npm-test-policy" && check.ok),
+    "cd <dir> && npm test policy is not allowed"
+  );
+  assert(
+    capabilities.checks.some((check) => check.name === "mkdir-policy" && check.ok),
+    "safe mkdir -p policy is not allowed"
+  );
+  assert(
+    capabilities.checks.some((check) => check.name === "bash-syntax-policy" && check.ok),
+    "bash -n maintenance script policy is not allowed"
+  );
+  assert(
+    capabilities.maintenancePolicy.some((check) => check.command.startsWith("sudo") && !check.allowed),
+    "sudo maintenance command was not blocked"
+  );
+  assert(
+    capabilities.trustedDockerPolicy.some((check) => check.command.startsWith("apt-get install") && check.allowed),
+    "trusted Docker policy did not allow apt-get install"
+  );
+  assert(
+    capabilities.trustedDockerPolicy.some((check) => check.command.startsWith("wget") && check.allowed),
+    "trusted Docker policy did not allow wget"
+  );
+
+  const doctor = JSON.parse(await runCli(["doctor", "--capabilities", "--json"]));
+  assert(doctor.project.root === tempRoot, "doctor --capabilities used the wrong project root");
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        projectRoot: tempRoot,
+        checks: ["capabilities-cli", "doctor-capabilities", "maintenance-policy", "trusted-docker-policy"],
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await fs.rm(tempRoot, { recursive: true, force: true });
+}

package/scripts/smoke-web-api.js

@@ -83,6 +83,16 @@ try {
   const keyStatus = await fetchJson("/api/keys/status");
   if (typeof keyStatus.keyStatus?.deepseek !== "boolean") throw new Error("key status endpoint is invalid");
   if ("localEnvPath" in keyStatus.keyStatus) throw new Error("key status leaked a local env path");
+  const capabilities = await fetchJson("/api/capabilities");
+  if (capabilities.project?.root !== runtimeDir || !Array.isArray(capabilities.checks)) {
+    throw new Error("capability endpoint returned an invalid project report");
+  }
+  if (!capabilities.checks.some((check) => check.name === "npm-prefix-test-policy")) {
+    throw new Error("capability endpoint did not include command policy checks");
+  }
+  if (!capabilities.trustedDockerPolicy?.some((check) => check.command.startsWith("apt-get install") && check.allowed)) {
+    throw new Error("capability endpoint did not report trusted Docker package policy");
+  }
   const savedKey = await fetchJson("/api/keys/deepseek", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -231,6 +241,7 @@ try {
         endpoints: [
           "/api/config",
           "/api/keys/status",
+          "/api/capabilities",
           "POST /api/keys/:provider",
           "/api/sandbox/status",
           "/api/sandbox/preflight",