@lazyingart/agintiflow 0.4.0 → 0.5.0

package/README.md

@@ -66,6 +66,8 @@ 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"
@@ -113,6 +115,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:

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 dependency-free website test sample and runs safe tests when dependencies are present.
+- `maintenance`: creates dry-run maintenance scripts/plans under `maintenance/` and validates script syntax; no global installs.
+- `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.0",
+  "version": "0.5.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 safe checks if you can without installing packages.`,
+    { 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 dry-run maintenance plans and scripts under ${maintenanceDir} for Miniforge/conda, R, Python tooling, CmdStan/CmdStanR, and PyStan. Validate scripts safely if you can.`,
+    {
+      routingMode: "complex",
+      taskProfile: "maintenance",
+      sandboxMode: "docker-workspace",
+      packageInstallPolicy: "block",
+      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,74 @@
+#!/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"
+  );
+
+  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"],
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await fs.rm(tempRoot, { recursive: true, force: true });
+}

package/scripts/smoke-web-api.js

@@ -83,6 +83,13 @@ 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");
+  }
   const savedKey = await fetchJson("/api/keys/deepseek", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -231,6 +238,7 @@ try {
         endpoints: [
           "/api/config",
           "/api/keys/status",
+          "/api/capabilities",
           "POST /api/keys/:provider",
           "/api/sandbox/status",
           "/api/sandbox/preflight",

package/src/agent-runner.js

@@ -156,7 +156,10 @@ function createInitialState(config, sessionId) {
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           "A frontend canvas/artifacts tunnel exists. Use send_to_canvas when important markdown, diffs, screenshots, images, or workspace files should be highlighted in the UI. It is optional and ordinary final text can still go directly to finish.",
           "For visual-output requests such as draw, plot, graph, chart, diagram, figure, image, or visualization, proactively publish a canvas artifact even when the user does not mention canvas. If workspace file tools are enabled, prefer creating a small SVG or markdown artifact and call send_to_canvas with selected=true.",
-          "For LaTeX/PDF requests, create the needed source/assets, compile with the available allowlisted TeX toolchain, and publish the resulting PDF through send_to_canvas. For subfolder documents, keep outputs beside the source. Use pdflatex-compatible figure formats such as PDF or PNG.",
+          "Work like a practical coding agent: inspect when useful, edit with file tools, run safe checks when they add confidence, and keep outputs inside the workspace.",
+          "Use the canvas tunnel for outputs the user would likely want to inspect visually, such as figures, PDFs, screenshots, images, important markdown, or generated files.",
+          "For environment or system-maintenance work, prefer project-local dry-run plans/scripts unless the configured policy explicitly allows stronger actions.",
+          "When the requested outcome is complete and a useful check has passed or been honestly skipped, stop and call finish.",
           "When done, call finish with a concise result.",
         ].join(" "),
       },
@@ -178,7 +181,8 @@ function createInitialState(config, sessionId) {
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           "Canvas/artifacts tunnel: available through send_to_canvas for optional frontend rendering.",
           "Visual-output requests should produce a canvas artifact without requiring the user to ask for canvas explicitly.",
-          "LaTeX/PDF requests should produce source artifacts and, when possible, a compiled PDF artifact. For subfolder documents, keep outputs beside the source. For figure-in-document tasks, create PDF/PNG figures that pdflatex can include.",
+          "Use file, shell, browser, canvas, and wrapper tools when they are useful; choose the workflow from the user's request.",
+          "Keep environment or system-maintenance actions project-local and reversible unless policy explicitly permits stronger actions.",
         ]
           .filter(Boolean)
           .join("\n"),
@@ -369,22 +373,31 @@ function sanitizeToolResult(result) {
 }
 
 async function runShellCommand(command, config, policy = evaluateCommandPolicy(command, config)) {
-  if (config.useDockerSandbox) {
-    return runDockerSandboxCommand(command, config, policy);
-  }
-
-  const result = await exec(command, {
-    cwd: config.commandCwd,
-    timeout: 5000,
-    maxBuffer: 200 * 1024,
-    shell: "/bin/bash",
-    env: safeExecutionEnv(),
-  });
+  try {
+    const result = config.useDockerSandbox
+      ? await runDockerSandboxCommand(command, config, policy)
+      : await exec(command, {
+          cwd: config.commandCwd,
+          timeout: 30000,
+          maxBuffer: 200 * 1024,
+          shell: "/bin/bash",
+          env: safeExecutionEnv(),
+        });
 
-  return {
-    stdout: redactSensitiveText(result.stdout).trim().slice(0, 8000),
-    stderr: redactSensitiveText(result.stderr).trim().slice(0, 4000),
-  };
+    return {
+      ok: true,
+      exitCode: 0,
+      stdout: redactSensitiveText(result.stdout).trim().slice(0, 8000),
+      stderr: redactSensitiveText(result.stderr).trim().slice(0, 4000),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      exitCode: Number.isInteger(error?.code) ? error.code : 1,
+      stdout: redactSensitiveText(String(error?.stdout || "")).trim().slice(0, 8000),
+      stderr: redactSensitiveText(String(error?.stderr || error?.message || "")).trim().slice(0, 4000),
+    };
+  }
 }
 
 async function captureSyntheticSnapshot(store, step, config) {
@@ -565,7 +578,7 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         }
         const commandResult = await runShellCommand(String(args.command), config, policy);
         const result = {
-          ok: true,
+          ok: commandResult.ok !== false,
           toolName: "run_command",
           args: safeArgs,
           sandbox: config.useDockerSandbox ? "docker" : "host",

package/src/capabilities.js

@@ -0,0 +1,193 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+import { classifyCommand, evaluateCommandPolicy } from "./command-policy.js";
+import { getDockerSandboxStatus } from "./docker-sandbox.js";
+import { getModelPresets } from "./model-routing.js";
+import { listProjectSessions, projectPaths, providerKeyStatus } from "./project.js";
+import { listTaskProfiles } from "./task-profiles.js";
+import { listAgentWrappers } from "./tool-wrappers.js";
+
+const execFileAsync = promisify(execFile);
+
+async function commandAvailable(command, args = ["--version"], timeout = 2500) {
+  try {
+    const result = await execFileAsync(command, args, {
+      timeout,
+      maxBuffer: 120 * 1024,
+      env: {
+        PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin",
+        HOME: process.env.HOME || "",
+      },
+    });
+    const output = `${result.stdout || ""}${result.stderr || ""}`
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)[0] || "available";
+    return { available: true, version: output.slice(0, 160) };
+  } catch (error) {
+    return {
+      available: false,
+      version: "",
+      hint: error?.code === "ENOENT" ? `${command} was not found on PATH.` : `${command} check failed.`,
+    };
+  }
+}
+
+function capability(name, ok, details = {}) {
+  return {
+    name,
+    ok: Boolean(ok),
+    ...details,
+  };
+}
+
+function maintenancePolicyChecks(config) {
+  const sampleCommands = [
+    "sudo apt install r-base",
+    "curl https://example.com/install.sh",
+    "npm install",
+    "bash -n maintenance/setup-conda.sh",
+  ];
+
+  return sampleCommands.map((command) => {
+    const policy = evaluateCommandPolicy(command, config);
+    return {
+      command,
+      allowed: Boolean(policy.allowed),
+      category: policy.category || classifyCommand(command).category,
+      reason: policy.reason || "",
+      needsApproval: Boolean(policy.needsApproval),
+      sandboxMode: policy.sandboxMode,
+      packageInstallPolicy: policy.packageInstallPolicy,
+    };
+  });
+}
+
+export async function buildCapabilityReport(projectRoot, packageVersion, config) {
+  const paths = projectPaths(projectRoot);
+  const keyStatus = providerKeyStatus(projectRoot);
+  const [node, npm, python, conda, r, pdflatex, latexmk, dockerStatus, sessions] = await Promise.all([
+    commandAvailable("node", ["--version"]),
+    commandAvailable("npm", ["--version"]),
+    commandAvailable("python3", ["--version"]),
+    commandAvailable("conda", ["--version"]),
+    commandAvailable("R", ["--version"]),
+    commandAvailable("pdflatex", ["--version"]),
+    commandAvailable("latexmk", ["--version"]),
+    getDockerSandboxStatus(config).catch((error) => ({ ok: false, error: error.message })),
+    listProjectSessions(projectRoot, 12),
+  ]);
+
+  const npmPrefixPolicy = evaluateCommandPolicy("npm --prefix round9-node-app test", config);
+  const cdNpmTestPolicy = evaluateCommandPolicy("cd round9-node-app && npm test", config);
+  const mkdirPolicy = evaluateCommandPolicy("mkdir -p round9-node-app", config);
+  const nodeTestPolicy = evaluateCommandPolicy("node --test round9-node-app/test/app.test.js", config);
+  const bashSyntaxPolicy = evaluateCommandPolicy("bash -n maintenance/setup-conda.sh", config);
+  const texPolicy = evaluateCommandPolicy("pdflatex -interaction=nonstopmode -halt-on-error docs/note.tex", config);
+
+  const checks = [
+    capability("node", node.available, node),
+    capability("npm", npm.available, npm),
+    capability("python3", python.available, python),
+    capability("conda", conda.available, conda.available ? conda : { ...conda, setup: "Optional. Generate a dry-run Miniforge setup plan under maintenance/ before installing." }),
+    capability("R", r.available, r.available ? r : { ...r, setup: "Optional. Generate a project-local R setup plan; do not install globally from the agent." }),
+    capability("pdflatex", pdflatex.available, pdflatex.available ? pdflatex : { ...pdflatex, setup: "LaTeX tasks should create .tex source and an honest setup report when TeX is unavailable." }),
+    capability("latexmk", latexmk.available, latexmk.available ? latexmk : { ...latexmk, setup: "latexmk is optional if pdflatex is available." }),
+    capability("docker", Boolean(dockerStatus?.dockerAvailable), dockerStatus || {}),
+    capability("deepseek-key", keyStatus.deepseek, { envVars: keyStatus.envVars.deepseek }),
+    capability("openai-key", keyStatus.openai, { envVars: keyStatus.envVars.openai }),
+    capability("file-tools", Boolean(config.allowFileTools), { workspace: config.commandCwd }),
+    capability("shell-tool", Boolean(config.allowShellTool), {
+      sandboxMode: config.sandboxMode,
+      packageInstallPolicy: config.packageInstallPolicy,
+    }),
+    capability("npm-prefix-test-policy", Boolean(npmPrefixPolicy.allowed), npmPrefixPolicy),
+    capability("cd-npm-test-policy", Boolean(cdNpmTestPolicy.allowed), cdNpmTestPolicy),
+    capability("mkdir-policy", Boolean(mkdirPolicy.allowed), mkdirPolicy),
+    capability("node-test-policy", Boolean(nodeTestPolicy.allowed), nodeTestPolicy),
+    capability("bash-syntax-policy", Boolean(bashSyntaxPolicy.allowed), bashSyntaxPolicy),
+    capability("tex-policy", Boolean(texPolicy.allowed), texPolicy),
+  ];
+
+  return {
+    ok: true,
+    generatedAt: new Date().toISOString(),
+    package: {
+      name: "@lazyingart/agintiflow",
+      version: packageVersion,
+    },
+    project: {
+      root: paths.root,
+      commandCwd: path.resolve(config.commandCwd),
+      sessionsDir: paths.sessionsDir,
+      sessionDbPath: paths.sessionDbPath,
+      sharedSessionFolder: path.resolve(config.sessionsDir) === path.resolve(paths.sessionsDir),
+    },
+    routing: {
+      active: {
+        provider: config.provider,
+        model: config.model,
+        routingMode: config.routingMode,
+        routeReason: config.routeReason,
+      },
+      presets: getModelPresets(),
+    },
+    keys: {
+      deepseek: keyStatus.deepseek,
+      openai: keyStatus.openai,
+      mock: true,
+      localEnv: keyStatus.localEnv,
+      envVars: keyStatus.envVars,
+    },
+    tools: {
+      wrappers: listAgentWrappers().map((wrapper) => ({
+        name: wrapper.name,
+        label: wrapper.label,
+        available: wrapper.available,
+        role: wrapper.role,
+      })),
+      taskProfiles: listTaskProfiles().map((profile) => ({
+        id: profile.id,
+        label: profile.label,
+        tools: profile.tools,
+      })),
+    },
+    checks,
+    maintenancePolicy: maintenancePolicyChecks(config),
+    sessions,
+    actionableSetup: checks
+      .filter((check) => !check.ok && check.setup)
+      .map((check) => ({
+        capability: check.name,
+        setup: check.setup,
+      })),
+  };
+}
+
+export function printCapabilityReport(report) {
+  console.log(`AgInTiFlow capabilities ${report.package.version}`);
+  console.log(`project=${report.project.root}`);
+  console.log(`cwd=${report.project.commandCwd}`);
+  console.log(`sessions=${report.project.sessionsDir}`);
+  console.log(`sessionDb=${report.project.sessionDbPath}`);
+  console.log(`sharedSessions=${report.project.sharedSessionFolder}`);
+  console.log(
+    `route=${report.routing.active.routingMode} ${report.routing.active.provider}/${report.routing.active.model}`
+  );
+  console.log(
+    `keys: deepseek=${report.keys.deepseek ? "available" : "missing"} openai=${
+      report.keys.openai ? "available" : "missing"
+    } mock=available localEnv=${report.keys.localEnv}`
+  );
+  for (const check of report.checks) {
+    const suffix = check.version ? ` ${check.version}` : check.reason ? ` ${check.reason}` : check.hint ? ` ${check.hint}` : "";
+    console.log(`${check.ok ? "OK" : "MISS"} ${check.name}${suffix}`);
+  }
+  if (report.actionableSetup.length > 0) {
+    console.log("setup:");
+    for (const item of report.actionableSetup) {
+      console.log(`- ${item.capability}: ${item.setup}`);
+    }
+  }
+}

package/src/cli.js

@@ -3,6 +3,7 @@ import { loadConfig } from "./config.js";
 import { listAgentWrappers } from "./tool-wrappers.js";
 import { getModelPresets } from "./model-routing.js";
 import { getDockerSandboxStatus, runDockerPreflight } from "./docker-sandbox.js";
+import { buildCapabilityReport, printCapabilityReport } from "./capabilities.js";
 import {
   doctorReport,
   initProject,
@@ -306,19 +307,53 @@ async function handleSessionsCommand(argv) {
 }
 
 export async function main(argv = process.argv.slice(2)) {
+  if (argv[0] === "--version" || argv[0] === "version" || argv[0] === "-v") {
+    console.log(packageJson.version);
+    return;
+  }
+
   if (argv[0] === "init") {
     printInitResult(await initProject(process.cwd()));
     return;
   }
 
   if (argv[0] === "doctor") {
-    const config = loadConfig({ goal: "doctor" }, { packageDir, baseDir: process.cwd() });
-    const report = await doctorReport(process.cwd(), packageJson.version, config);
+    const parsed = parseArgs(argv.slice(1).filter((arg) => arg !== "--json" && arg !== "--capabilities"));
+    const config = loadConfig(
+      {
+        ...parsed,
+        goal: "doctor",
+        allowShellTool: parsed.allowShellTool ?? true,
+        allowFileTools: parsed.allowFileTools ?? true,
+      },
+      { packageDir, baseDir: process.cwd() }
+    );
+    const report = argv.includes("--capabilities")
+      ? await buildCapabilityReport(process.cwd(), packageJson.version, config)
+      : await doctorReport(process.cwd(), packageJson.version, config);
     if (argv.includes("--json")) console.log(JSON.stringify(report, null, 2));
+    else if (argv.includes("--capabilities")) printCapabilityReport(report);
     else printDoctorReport(report);
     return;
   }
 
+  if (argv[0] === "capabilities") {
+    const parsed = parseArgs(argv.slice(1).filter((arg) => arg !== "--json"));
+    const config = loadConfig(
+      {
+        ...parsed,
+        goal: "capabilities",
+        allowShellTool: parsed.allowShellTool ?? true,
+        allowFileTools: parsed.allowFileTools ?? true,
+      },
+      { packageDir, baseDir: process.cwd() }
+    );
+    const report = await buildCapabilityReport(process.cwd(), packageJson.version, config);
+    if (argv.includes("--json")) console.log(JSON.stringify(report, null, 2));
+    else printCapabilityReport(report);
+    return;
+  }
+
   if (argv[0] === "keys/status") {
     await handleKeyCommand(["status"]);
     return;

package/src/command-policy.js

@@ -27,12 +27,19 @@ const READ_ONLY_PATTERNS = [
 
 const TEST_PATTERNS = [
   /^npm\s+(run\s+)?(check|test|build|lint)(?:\s+--\s+[-\w./:=]+)*$/,
+  /^npm\s+--prefix\s+[-\w./]+\s+(run\s+)?(check|test|build|lint)(?:\s+--\s+[-\w./:=]+)*$/,
   /^npm\s+test$/,
   /^node\s+--check\s+[-\w./]+$/,
+  /^node\s+--test(?:\s+[-\w./]+)*$/,
+  /^bash\s+-n\s+[-\w./]+\.sh$/,
+  /^sh\s+-n\s+[-\w./]+\.sh$/,
+  /^python(?:3)?\s+-m\s+py_compile\s+[-\w./]+\.py$/,
   /^python(?:3)?\s+-m\s+pytest(?:\s+[-\w./:=]+)*$/,
   /^pytest(?:\s+[-\w./:=]+)*$/,
 ];
 
+const SAFE_WORKSPACE_WRITE_PATTERNS = [/^mkdir\s+-p\s+[-\w./]+$/];
+
 const TOOLCHAIN_PATTERNS = [
   /^python(?:3)?\s+[-\w./]+\.py(?:\s+[-\w./:=]+)*$/,
   /^latexmk\s+(?=[-\w./=\s]*-pdf\b)(?:(?:-cd|-pdf|-interaction=nonstopmode|-halt-on-error|-output-directory=[-\w./]+)\s+)+[-\w./]+\.tex$/,
@@ -107,10 +114,19 @@ function matchAny(patterns, command) {
   return patterns.some((pattern) => pattern.test(command));
 }
 
-export function classifyCommand(command) {
-  const normalized = String(command || "").trim();
-  if (!normalized) return { category: "blocked", reason: "Command is empty." };
+function isSafeRelativeDir(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized || normalized.startsWith("/") || normalized.startsWith("~")) return false;
+  return normalized.split("/").every((part) => part && part !== "." && part !== "..");
+}
+
+function isSafeVirtualWorkspaceDir(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized.startsWith("/workspace/")) return false;
+  return isSafeRelativeDir(normalized.replace(/^\/workspace\//, ""));
+}
 
+function classifySimpleCommand(normalized) {
   if (ALWAYS_BLOCKED_PATTERNS.some((pattern) => pattern.test(normalized))) {
     return { category: "blocked", reason: "Command is blocked because it may expose secrets or publish packages." };
   }
@@ -119,6 +135,14 @@ export function classifyCommand(command) {
   if (BLOCKED_SHELL_TOKENS.some((part) => normalized.includes(part))) {
     return { category: "blocked", reason: `Command contains blocked shell syntax: ${normalized}` };
   }
+  if (matchAny(SAFE_WORKSPACE_WRITE_PATTERNS, normalized)) {
+    const target = normalized.replace(/^mkdir\s+-p\s+/, "");
+    const virtualWorkspacePath = isSafeVirtualWorkspaceDir(target);
+    if (!isSafeRelativeDir(target) && !virtualWorkspacePath) {
+      return { category: "blocked", reason: `mkdir target must be a safe workspace-relative directory: ${target}` };
+    }
+    return { category: "workspace-write", needsNetwork: false, writesWorkspace: true, virtualWorkspacePath };
+  }
   if (BLOCKED_WRITE_TOKENS.some((part) => lowered.includes(part))) {
     return { category: "blocked", reason: `Command contains a write-capable or network token: ${normalized}` };
   }
@@ -142,6 +166,26 @@ export function classifyCommand(command) {
   return { category: "blocked", reason: `Command is outside the execution allowlist: ${normalized}` };
 }
 
+function classifyCdCommand(normalized) {
+  const match = normalized.match(/^cd\s+([-\w./]+)\s+&&\s+(.+)$/);
+  if (!match) return null;
+  const [, dir, inner] = match;
+  const virtualWorkspacePath = isSafeVirtualWorkspaceDir(dir);
+  if (!isSafeRelativeDir(dir) && !virtualWorkspacePath) {
+    return { category: "blocked", reason: `cd target must be a safe workspace-relative directory: ${dir}` };
+  }
+  const innerClassification = classifySimpleCommand(inner.trim());
+  if (innerClassification.category === "blocked") return innerClassification;
+  return { ...innerClassification, cdDir: dir, virtualWorkspacePath };
+}
+
+export function classifyCommand(command) {
+  const normalized = String(command || "").trim();
+  if (!normalized) return { category: "blocked", reason: "Command is empty." };
+
+  return classifyCdCommand(normalized) || classifySimpleCommand(normalized);
+}
+
 export function evaluateCommandPolicy(command, config) {
   const classification = classifyCommand(command);
   const sandboxMode = normalizeSandboxMode(config.sandboxMode);
@@ -151,6 +195,16 @@ export function evaluateCommandPolicy(command, config) {
     return { allowed: false, ...classification, sandboxMode, packageInstallPolicy };
   }
 
+  if (classification.virtualWorkspacePath && !config.useDockerSandbox) {
+    return {
+      allowed: false,
+      ...classification,
+      reason: "Virtual /workspace shell paths are allowed only inside Docker sandbox mode.",
+      sandboxMode,
+      packageInstallPolicy,
+    };
+  }
+
   if (!config.allowShellTool) {
     return {
       allowed: false,

package/src/model-client.js

@@ -156,8 +156,10 @@ export async function createPlan(client, config, state) {
             : "",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           "A canvas/artifacts tunnel is available through send_to_canvas. Use it when an output should be highlighted visually, such as screenshots, image files, important markdown, diffs, or generated artifact paths. It is optional for ordinary text answers.",
-          "When the user asks to draw, plot, graph, chart, diagram, create a figure, or visualize something, include a canvas artifact even if the user does not mention canvas. Prefer a small SVG file or concise markdown figure when file tools are available.",
-          "When the user asks for LaTeX, TeX, a paper, manuscript, report, or PDF, plan to create the needed source/assets, compile with the available allowlisted TeX toolchain, and publish the PDF through the canvas tunnel. For subfolder documents, keep outputs beside the source. For generated figures, use pdflatex-compatible formats such as PDF or PNG.",
+          "Work like a practical coding agent: inspect when useful, edit with file tools, run safe checks when they add confidence, and keep outputs inside the workspace.",
+          "Use the canvas tunnel for outputs the user would likely want to inspect visually, such as figures, PDFs, screenshots, images, important markdown, or generated files.",
+          "For environment or system-maintenance work, prefer project-local dry-run plans/scripts unless the configured policy explicitly allows stronger actions.",
+          "Plan for a complete result, not endless exploration; finish once the request is satisfied and checks have passed or been honestly skipped.",
           "Return a numbered plan only.",
         ]
           .filter(Boolean)

package/src/task-profiles.js

@@ -10,7 +10,7 @@ export const TASK_PROFILES = {
     id: "code",
     label: "Code writing",
     prompt:
-      "Act like a coding agent: inspect files first, make targeted workspace-local edits, run relevant checks, and report changed files and residual risks.",
+      "Act like a coding agent: understand the request, edit workspace files, run useful safe checks, and report changed files and residual risks.",
     tools: ["files", "shell", "sandbox"],
   },
   writing: {
@@ -45,14 +45,21 @@ export const TASK_PROFILES = {
     id: "node",
     label: "Node",
     prompt:
-      "For Node.js tasks, inspect package scripts, use npm checks/tests when safe, and keep generated files inside the project workspace.",
+      "For Node.js tasks, use the local project structure, add tests when useful, and run safe npm/node checks when available.",
     tools: ["files", "shell", "sandbox"],
   },
+  website: {
+    id: "website",
+    label: "Website testing",
+    prompt:
+      "For website-testing tasks, create or inspect the site, add a simple local test/check file when useful, and run safe checks without installing packages unless approved.",
+    tools: ["files", "shell", "canvas", "sandbox"],
+  },
   aaps: {
     id: "aaps",
     label: "AAPS",
     prompt:
-      "For AAPS tasks, recognize .aaps folders and @lazyingart/aaps package workflows. Prefer project-local config, safe publish preparation, and explicit secret handling.",
+      "For AAPS tasks, recognize .aaps folders and @lazyingart/aaps workflows, keep work project-local, and avoid secrets or publishing.",
     tools: ["files", "shell", "sandbox"],
   },
   latex: {
@@ -66,7 +73,7 @@ export const TASK_PROFILES = {
     id: "maintenance",
     label: "System maintenance",
     prompt:
-      "For system maintenance, diagnose first, prefer idempotent scripts, ask for approval before privileged or destructive operations, and avoid leaking credentials.",
+      "For system maintenance, diagnose first, prefer reversible project-local plans or dry-run scripts, and avoid privileged/global/destructive actions unless explicitly approved.",
     tools: ["shell", "sandbox", "files"],
   },
 };

package/web.js

@@ -13,6 +13,7 @@ import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./src/comma
 import { summarizeWorkspaceTools, WORKSPACE_TOOL_NAMES } from "./src/workspace-tools.js";
 import { listTaskProfiles, normalizeTaskProfile } from "./src/task-profiles.js";
 import { loadProjectEnv, projectPaths, providerKeyStatus, setProviderKey } from "./src/project.js";
+import { buildCapabilityReport } from "./src/capabilities.js";
 import {
   buildArtifacts,
   countUnreadArtifacts,
@@ -24,6 +25,7 @@ import {
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageDir = __dirname;
+const packageJson = JSON.parse(await fs.readFile(path.join(packageDir, "package.json"), "utf8"));
 const baseDir = path.resolve(process.env.AGINTIFLOW_RUNTIME_DIR || process.cwd());
 const sessionsDir = path.join(baseDir, ".sessions");
 loadProjectEnv(baseDir);
@@ -539,6 +541,18 @@ app.get("/api/keys/status", (_req, res) => {
   res.json({ ok: true, keyStatus: publicKeyStatus(baseDir) });
 });
 
+app.get("/api/capabilities", async (_req, res) => {
+  const preferences = normalizePreferencePayload({}, db.getPreferences());
+  const config = buildRunConfig({
+    ...preferences,
+    goal: "capabilities",
+    allowShellTool: true,
+    allowFileTools: true,
+  });
+  const report = await buildCapabilityReport(baseDir, packageJson.version, config);
+  res.json(report);
+});
+
 app.post("/api/keys/:provider", async (req, res) => {
   try {
     const result = await setProviderKey(baseDir, req.params.provider, req.body?.apiKey || req.body?.key || "");