@lazyingart/agintiflow 0.3.0 → 0.4.0

package/src/cli.js

@@ -3,10 +3,21 @@ 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 {
+  doctorReport,
+  initProject,
+  listProjectSessions,
+  providerKeyStatus,
+  setProviderKey,
+  showProjectSession,
+} from "./project.js";
+import { listTaskProfiles } from "./task-profiles.js";
+import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(await fs.readFile(path.join(packageDir, "package.json"), "utf8"));
 
 function readOption(argv, index) {
   const value = argv[index + 1];
@@ -30,6 +41,7 @@ export function parseArgs(argv) {
     allowFileTools: undefined,
     allowWrapperTools: undefined,
     preferredWrapper: "",
+    taskProfile: "",
     useDockerSandbox: undefined,
     headless: undefined,
     maxSteps: undefined,
@@ -40,6 +52,7 @@ export function parseArgs(argv) {
     web: false,
     port: "",
     host: "",
+    listProfiles: false,
   };
 
   const parts = [];
@@ -135,6 +148,11 @@ export function parseArgs(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--profile" || arg === "--task-profile") {
+      result.taskProfile = readOption(argv, i);
+      i += 1;
+      continue;
+    }
     if (arg === "--docker-sandbox") {
       result.useDockerSandbox = true;
       result.sandboxMode = result.sandboxMode || "docker-readonly";
@@ -152,6 +170,10 @@ export function parseArgs(argv) {
       result.listWrappers = true;
       continue;
     }
+    if (arg === "--list-profiles") {
+      result.listProfiles = true;
+      continue;
+    }
     if (arg === "--sandbox-status") {
       result.sandboxStatus = true;
       continue;
@@ -183,7 +205,159 @@ function printWrappers() {
   }
 }
 
+function printProfiles() {
+  for (const profile of listTaskProfiles()) {
+    console.log(`${profile.id}: ${profile.label} - ${profile.prompt}`);
+  }
+}
+
+function printInitResult(result) {
+  console.log(`AgInTiFlow project initialized: ${result.projectRoot}`);
+  console.log(`control=${result.controlDir}`);
+  console.log(`sessions=${result.sessionsDir}`);
+  console.log(`created=${result.created.length} updated=${result.updated.length} skipped=${result.skipped.length}`);
+}
+
+function printDoctorReport(report) {
+  console.log(`AgInTiFlow ${report.package.version} (npm latest: ${report.package.npmLatest})`);
+  console.log(`node=${report.node.version} ok=${report.node.ok}`);
+  console.log(`project=${report.project.root}`);
+  console.log(`sessions=${report.project.sessionsDir}`);
+  console.log(`sessionDb=${report.project.sessionDbPath}`);
+  console.log(
+    `keys: deepseek=${report.keys.deepseek ? "available" : "missing"} openai=${
+      report.keys.openai ? "available" : "missing"
+    } mock=available localEnv=${report.project.localEnvPresent}`
+  );
+  console.log(
+    `sandbox=${report.sandbox?.sandboxMode || "unknown"} docker=${
+      report.sandbox?.dockerAvailable ? "available" : "missing"
+    } imageReady=${Boolean(report.sandbox?.imageReady)}`
+  );
+  console.log(
+    `wrappers=${report.wrappers.map((wrapper) => `${wrapper.name}:${wrapper.available ? "ok" : "missing"}`).join(" ")}`
+  );
+  console.log(`sessions=${report.sessions.length}`);
+}
+
+async function readStdin() {
+  let input = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) input += chunk;
+  return input.trim();
+}
+
+async function handleKeyCommand(argv) {
+  const [verb = "status", provider = ""] = argv;
+  if (verb === "status") {
+    const status = providerKeyStatus(process.cwd());
+    console.log(
+      `keys: deepseek=${status.deepseek ? "available" : "missing"} openai=${
+        status.openai ? "available" : "missing"
+      } mock=available localEnv=${status.localEnv}`
+    );
+    console.log("env vars: DeepSeek=DEEPSEEK_API_KEY or LLM_API_KEY; OpenAI=OPENAI_API_KEY or LLM_API_KEY");
+    return;
+  }
+
+  if (verb === "set") {
+    const target = provider || "deepseek";
+    if (!argv.includes("--stdin")) {
+      console.error(`Usage: aginti keys set ${target} --stdin`);
+      process.exit(1);
+    }
+    const key = await readStdin();
+    const result = await setProviderKey(process.cwd(), target, key);
+    console.log(`saved ${result.provider} key to project-local ignored env (${result.keyName})`);
+    return;
+  }
+
+  console.error("Usage: aginti keys status OR aginti keys set deepseek --stdin");
+  process.exit(1);
+}
+
+async function handleSessionsCommand(argv) {
+  const [verb = "list", sessionId = ""] = argv;
+  if (verb === "list") {
+    const sessions = await listProjectSessions(process.cwd(), 80);
+    if (sessions.length === 0) {
+      console.log("No project-local sessions found.");
+      return;
+    }
+    for (const session of sessions) {
+      const goal = session.goal ? ` ${session.goal.slice(0, 90)}` : "";
+      console.log(`${session.sessionId} ${session.provider}/${session.model} ${session.updatedAt}${goal}`);
+    }
+    return;
+  }
+
+  if (verb === "show") {
+    if (!sessionId) {
+      console.error("Usage: aginti sessions show <session-id>");
+      process.exit(1);
+    }
+    const session = await showProjectSession(process.cwd(), sessionId);
+    console.log(JSON.stringify(session, null, 2));
+    return;
+  }
+
+  console.error("Usage: aginti sessions list OR aginti sessions show <session-id>");
+  process.exit(1);
+}
+
 export async function main(argv = process.argv.slice(2)) {
+  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);
+    if (argv.includes("--json")) console.log(JSON.stringify(report, null, 2));
+    else printDoctorReport(report);
+    return;
+  }
+
+  if (argv[0] === "keys/status") {
+    await handleKeyCommand(["status"]);
+    return;
+  }
+
+  if (argv[0] === "keys") {
+    await handleKeyCommand(argv.slice(1));
+    return;
+  }
+
+  if (argv[0] === "login") {
+    const provider = argv[1] || "deepseek";
+    if (!argv.includes("--stdin") && process.stdin.isTTY) {
+      console.error(`Usage: printf '%s' '<key>' | aginti login ${provider} --stdin`);
+      process.exit(1);
+    }
+    const key = await readStdin();
+    const result = await setProviderKey(process.cwd(), provider, key);
+    console.log(`saved ${result.provider} key to project-local ignored env (${result.keyName})`);
+    return;
+  }
+
+  if (argv[0] === "sessions") {
+    await handleSessionsCommand(argv.slice(1));
+    return;
+  }
+
+  if (argv[0] === "resume") {
+    const sessionId = argv[1] || "";
+    const prompt = argv.slice(2).join(" ").trim();
+    if (!sessionId || !prompt) {
+      console.error('Usage: aginti resume <session-id> "new prompt"');
+      process.exit(1);
+    }
+    const config = loadConfig({ ...parseArgs([prompt]), resume: sessionId, goal: prompt }, { packageDir });
+    await runAgent(config);
+    return;
+  }
+
   const args = parseArgs(argv);
 
   if (args.web) {
@@ -204,6 +378,11 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (args.listProfiles) {
+    printProfiles();
+    return;
+  }
+
   if (args.sandboxStatus || args.sandboxPreflight) {
     const config = loadConfig({ ...args, goal: args.goal || "sandbox preflight" }, { packageDir });
     const result = args.sandboxPreflight

package/src/config.js

@@ -3,6 +3,8 @@ import crypto from "node:crypto";
 import { getProviderDefaults, normalizeRoutingMode, selectModelRoute } from "./model-routing.js";
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
 import { normalizeWrapperName } from "./tool-wrappers.js";
+import { loadProjectEnv, resolveProjectRoot } from "./project.js";
+import { normalizeTaskProfile } from "./task-profiles.js";
 
 function parseBoolean(value, fallback) {
   if (value === undefined) return fallback;
@@ -23,6 +25,8 @@ function parseList(value) {
 }
 
 export function resolveRuntimeConfig(args, overrides = {}) {
+  const baseDir = resolveProjectRoot(overrides.baseDir || process.cwd());
+  loadProjectEnv(baseDir);
   const requestedProvider =
     overrides.provider ||
     args.provider ||
@@ -37,7 +41,6 @@ export function resolveRuntimeConfig(args, overrides = {}) {
   });
 
   const defaults = getProviderDefaults(route.provider);
-  const baseDir = path.resolve(overrides.baseDir || process.cwd());
   const packageDir = path.resolve(overrides.packageDir || process.env.AGINTIFLOW_PACKAGE_DIR || baseDir);
   const dockerRequested = parseBoolean(overrides.useDockerSandbox ?? args.useDockerSandbox ?? process.env.USE_DOCKER_SANDBOX, false);
   const requestedSandboxMode =
@@ -53,6 +56,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     resume: args.resume || "",
     sessionId: overrides.sessionId || args.sessionId || process.env.SESSION_ID || `web-agent-${crypto.randomUUID()}`,
     routingMode,
+    taskProfile: normalizeTaskProfile(overrides.taskProfile || args.taskProfile || process.env.AGINTI_TASK_PROFILE || "auto"),
     routeReason: route.reason,
     routeComplexityScore: route.complexityScore,
     requestedProvider,
@@ -84,7 +88,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     ),
     useDockerSandbox: sandboxMode !== "host" || dockerRequested,
     dockerSandboxImage: overrides.dockerSandboxImage || process.env.DOCKER_SANDBOX_IMAGE || "agintiflow-sandbox:latest",
-    commandCwd: path.resolve(overrides.commandCwd || args.commandCwd || process.env.COMMAND_CWD || process.cwd()),
+    commandCwd: path.resolve(overrides.commandCwd || args.commandCwd || process.env.COMMAND_CWD || baseDir),
     sessionsDir: path.resolve(baseDir, ".sessions"),
     onLog: overrides.onLog,
     onEvent: overrides.onEvent,

package/src/model-client.js

@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 import { normalizeWrapperName, wrapperStatusText } from "./tool-wrappers.js";
+import { getTaskProfile } from "./task-profiles.js";
 
 export function createClient(config) {
   if (config.provider === "mock") {
@@ -27,14 +28,19 @@ function mockToolCall(name, args = {}) {
 }
 
 function latestToolPayload(messages) {
-  const toolMessage = [...messages].reverse().find((message) => message.role === "tool" && message.content);
-  if (!toolMessage) return null;
-
-  try {
-    return JSON.parse(toolMessage.content);
-  } catch {
-    return null;
+  for (const message of [...messages].reverse()) {
+    if (message.role === "user" && /^Continue with this new request:|^Goal:/i.test(String(message.content || ""))) {
+      return null;
+    }
+    if (message.role !== "tool" || !message.content) continue;
+    try {
+      const payload = JSON.parse(message.content);
+      return payload?.done ? null : payload;
+    } catch {
+      return null;
+    }
   }
+  return null;
 }
 
 function prepareMessages(config, messages) {
@@ -57,6 +63,10 @@ function mockPathForGoal(goal = "") {
   const text = String(goal);
   const explicit = text.match(/(?:file|path):\s*`?([A-Za-z0-9_./-]+)`?/i)?.[1];
   if (explicit) return explicit;
+  const createPath = text.match(
+    /\b(?:create|write|make|save|generate)\s+(?:a\s+|an\s+|the\s+)?(?:file\s+)?`?((?:\.\/)?[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+|[A-Za-z0-9_.-]+\.(?:md|txt|js|ts|json|py|tex|html|css|svg|csv|yml|yaml))`?/i
+  )?.[1];
+  if (createPath) return createPath.replace(/^[`'"]+|[`'",.]+$/g, "");
   if (/\.env/i.test(text)) return ".env";
   if (/outside|escape/i.test(text)) return "../outside-workspace.txt";
   if (/patch/i.test(text)) return "patch-target.txt";
@@ -111,6 +121,7 @@ function mockChatResponse(content, toolCalls = []) {
 }
 
 export async function createPlan(client, config, state) {
+  const taskProfile = getTaskProfile(config.taskProfile);
   if (client.mock) {
     return [
       "1. Inspect the request and prefer the local shell when available.",
@@ -143,6 +154,7 @@ export async function createPlan(client, config, state) {
           config.allowWrapperTools
             ? `Agent wrappers are enabled. Use the selected wrapper only: ${normalizeWrapperName(config.preferredWrapper)}. Status: ${wrapperStatusText()}.`
             : "",
+          `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.",
@@ -445,6 +457,15 @@ export async function requestNextStep(client, config, messages) {
   if (client.mock) {
     const toolPayload = latestToolPayload(messages);
     if (toolPayload) {
+      if (toolPayload.ok === false && !toolPayload.blocked) {
+        return mockChatResponse("Mock mode detected a tool failure and will stop instead of masking it.", [
+          mockToolCall("finish", {
+            result: `Mock run failed because ${toolPayload.toolName || "a tool"} failed: ${
+              toolPayload.error || toolPayload.reason || "unknown error"
+            }`,
+          }),
+        ]);
+      }
       const output = [
         toolPayload.stdout,
         toolPayload.stderr,

package/src/project.js

@@ -0,0 +1,332 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { listAgentWrappers } from "./tool-wrappers.js";
+import { getDockerSandboxStatus } from "./docker-sandbox.js";
+
+const execFileAsync = promisify(execFile);
+const LOCAL_ENV_KEYS = new Set([
+  "DEEPSEEK_API_KEY",
+  "OPENAI_API_KEY",
+  "LLM_API_KEY",
+  "LLM_BASE_URL",
+  "DEEPSEEK_FAST_MODEL",
+  "DEEPSEEK_PRO_MODEL",
+  "OPENAI_DEFAULT_MODEL",
+]);
+
+export function resolveProjectRoot(input = process.cwd()) {
+  return path.resolve(input || process.cwd());
+}
+
+export function projectPaths(projectRoot = process.cwd()) {
+  const root = resolveProjectRoot(projectRoot);
+  return {
+    root,
+    controlDir: path.join(root, ".aginti"),
+    envPath: path.join(root, ".aginti", ".env"),
+    envExamplePath: path.join(root, ".aginti", ".env.example"),
+    controlReadmePath: path.join(root, ".aginti", "README.md"),
+    notesDir: path.join(root, "notes"),
+    notesReadmePath: path.join(root, "notes", "README.md"),
+    sessionsDir: path.join(root, ".sessions"),
+    sessionDbPath: path.join(root, ".sessions", "web-state.sqlite"),
+    gitignorePath: path.join(root, ".gitignore"),
+  };
+}
+
+export function parseEnvText(text = "") {
+  const values = {};
+  for (const rawLine of String(text).split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || !line.includes("=")) continue;
+    const index = line.indexOf("=");
+    const key = line.slice(0, index).trim();
+    let value = line.slice(index + 1).trim();
+    if (!LOCAL_ENV_KEYS.has(key)) continue;
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    values[key] = value;
+  }
+  return values;
+}
+
+export function loadProjectEnv(projectRoot = process.cwd(), { override = false } = {}) {
+  const paths = projectPaths(projectRoot);
+  let loaded = false;
+  try {
+    const parsed = parseEnvText(fs.readFileSync(paths.envPath, "utf8"));
+    for (const [key, value] of Object.entries(parsed)) {
+      if (override || !process.env[key]) process.env[key] = value;
+    }
+    loaded = true;
+  } catch {
+    loaded = false;
+  }
+  return {
+    loaded,
+    path: paths.envPath,
+  };
+}
+
+async function ensureLine(filePath, lines) {
+  const desired = Array.isArray(lines) ? lines : [lines];
+  let current = "";
+  try {
+    current = await fsp.readFile(filePath, "utf8");
+  } catch {
+    current = "";
+  }
+
+  const existing = new Set(current.split(/\r?\n/).map((line) => line.trim()));
+  const missing = desired.filter((line) => !existing.has(line));
+  if (missing.length === 0) return { changed: false, path: filePath };
+
+  const prefix = current && !current.endsWith("\n") ? "\n" : "";
+  await fsp.writeFile(filePath, `${current}${prefix}${missing.join("\n")}\n`, "utf8");
+  return { changed: true, path: filePath, added: missing };
+}
+
+export async function initProject(projectRoot = process.cwd()) {
+  const paths = projectPaths(projectRoot);
+  const created = [];
+  const updated = [];
+  const skipped = [];
+
+  async function ensureDir(dirPath) {
+    const existed = await fsp.stat(dirPath).then(() => true).catch(() => false);
+    await fsp.mkdir(dirPath, { recursive: true });
+    (existed ? skipped : created).push(dirPath);
+  }
+
+  async function ensureFile(filePath, content, mode) {
+    const existed = await fsp.stat(filePath).then(() => true).catch(() => false);
+    if (!existed) {
+      await fsp.writeFile(filePath, content, mode ? { mode } : "utf8");
+      created.push(filePath);
+    } else {
+      skipped.push(filePath);
+    }
+  }
+
+  await ensureDir(paths.controlDir);
+  await ensureDir(paths.notesDir);
+  await ensureDir(paths.sessionsDir);
+  await ensureFile(
+    paths.controlReadmePath,
+    [
+      "# AgInTi Project Control",
+      "",
+      "This folder stores project-local AgInTiFlow configuration.",
+      "",
+      "- `.env` is ignored and can hold local provider keys.",
+      "- `.env.example` documents accepted variable names.",
+      "- `.sessions/` at the project root stores CLI and web run history.",
+      "",
+    ].join("\n")
+  );
+  await ensureFile(
+    paths.envExamplePath,
+    [
+      "# Copy values into .aginti/.env. Never commit real secrets.",
+      "DEEPSEEK_API_KEY=",
+      "OPENAI_API_KEY=",
+      "DEEPSEEK_FAST_MODEL=deepseek-v4-flash",
+      "DEEPSEEK_PRO_MODEL=deepseek-v4-pro",
+      "",
+    ].join("\n")
+  );
+  await ensureFile(
+    paths.notesReadmePath,
+    [
+      "# Notes",
+      "",
+      "Use this folder for agent-generated notes, drafts, and smoke-test files.",
+      "",
+    ].join("\n")
+  );
+
+  const gitignore = await ensureLine(paths.gitignorePath, [
+    ".aginti/.env",
+    ".aginti/.env.*",
+    "!.aginti/.env.example",
+    ".sessions/",
+  ]);
+  if (gitignore.changed) updated.push(paths.gitignorePath);
+  else skipped.push(paths.gitignorePath);
+
+  return {
+    ok: true,
+    projectRoot: paths.root,
+    controlDir: paths.controlDir,
+    sessionsDir: paths.sessionsDir,
+    created,
+    updated,
+    skipped,
+  };
+}
+
+export function providerKeyStatus(projectRoot = process.cwd()) {
+  const env = loadProjectEnv(projectRoot);
+  return {
+    openai: Boolean(process.env.OPENAI_API_KEY || process.env.LLM_API_KEY),
+    deepseek: Boolean(process.env.DEEPSEEK_API_KEY || process.env.LLM_API_KEY),
+    mock: true,
+    localEnv: env.loaded,
+    localEnvPath: env.path,
+    envVars: {
+      openai: ["OPENAI_API_KEY", "LLM_API_KEY"],
+      deepseek: ["DEEPSEEK_API_KEY", "LLM_API_KEY"],
+    },
+  };
+}
+
+export async function setProviderKey(projectRoot, provider, value) {
+  const normalizedProvider = String(provider || "").toLowerCase();
+  const keyName = normalizedProvider === "openai" ? "OPENAI_API_KEY" : "DEEPSEEK_API_KEY";
+  if (!["deepseek", "openai"].includes(normalizedProvider)) {
+    throw new Error("Provider must be deepseek or openai.");
+  }
+
+  const keyValue = String(value || "").trim();
+  if (!keyValue) throw new Error("Key value is required.");
+
+  const paths = projectPaths(projectRoot);
+  await fsp.mkdir(paths.controlDir, { recursive: true });
+  let parsed = {};
+  try {
+    parsed = parseEnvText(await fsp.readFile(paths.envPath, "utf8"));
+  } catch {
+    parsed = {};
+  }
+  parsed[keyName] = keyValue;
+  const output = Object.entries(parsed)
+    .filter(([key]) => LOCAL_ENV_KEYS.has(key))
+    .map(([key, envValue]) => `${key}=${JSON.stringify(envValue)}`)
+    .join("\n");
+  await fsp.writeFile(paths.envPath, `${output}\n`, { mode: 0o600 });
+  await fsp.chmod(paths.envPath, 0o600).catch(() => {});
+  loadProjectEnv(projectRoot, { override: true });
+  return {
+    ok: true,
+    provider: normalizedProvider,
+    keyName,
+    path: paths.envPath,
+  };
+}
+
+export async function listProjectSessions(projectRoot = process.cwd(), limit = 50) {
+  const paths = projectPaths(projectRoot);
+  const entries = await fsp.readdir(paths.sessionsDir, { withFileTypes: true }).catch(() => []);
+  const sessions = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const statePath = path.join(paths.sessionsDir, entry.name, "state.json");
+    try {
+      const state = JSON.parse(await fsp.readFile(statePath, "utf8"));
+      sessions.push({
+        sessionId: state.sessionId || entry.name,
+        provider: state.provider || "",
+        model: state.model || "",
+        goal: state.goal || "",
+        createdAt: state.createdAt || "",
+        updatedAt: state.updatedAt || state.createdAt || "",
+        stepsCompleted: state.stepsCompleted || 0,
+      });
+    } catch {
+      // Ignore malformed or unrelated session folders.
+    }
+  }
+  return sessions.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt))).slice(0, limit);
+}
+
+export async function showProjectSession(projectRoot, sessionId) {
+  const paths = projectPaths(projectRoot);
+  const safeId = String(sessionId || "");
+  if (!/^[A-Za-z0-9._:-]+$/.test(safeId) || safeId.includes("..")) {
+    throw new Error("Invalid session id.");
+  }
+  const sessionDir = path.join(paths.sessionsDir, safeId);
+  const state = JSON.parse(await fsp.readFile(path.join(sessionDir, "state.json"), "utf8"));
+  let events = [];
+  try {
+    const raw = await fsp.readFile(path.join(sessionDir, "events.jsonl"), "utf8");
+    events = raw
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch {
+    events = [];
+  }
+  return {
+    sessionId: state.sessionId || safeId,
+    provider: state.provider || "",
+    model: state.model || "",
+    goal: state.goal || "",
+    createdAt: state.createdAt || "",
+    updatedAt: state.updatedAt || "",
+    chat: state.chat || [],
+    events: events.slice(-80),
+  };
+}
+
+export async function npmLatestVersion(packageName = "@lazyingart/agintiflow") {
+  try {
+    const { stdout } = await execFileAsync("npm", ["view", packageName, "version", "--json"], {
+      timeout: 6000,
+      maxBuffer: 100 * 1024,
+      env: { PATH: process.env.PATH || "/usr/bin:/bin" },
+    });
+    return JSON.parse(stdout.trim());
+  } catch {
+    return "";
+  }
+}
+
+export async function doctorReport(projectRoot, packageVersion, config) {
+  const paths = projectPaths(projectRoot);
+  const keyStatus = providerKeyStatus(projectRoot);
+  const [sessions, dockerStatus, latestVersion] = await Promise.all([
+    listProjectSessions(projectRoot, 8),
+    getDockerSandboxStatus(config).catch((error) => ({ ok: false, error: error.message })),
+    npmLatestVersion(),
+  ]);
+
+  return {
+    ok: true,
+    package: {
+      name: "@lazyingart/agintiflow",
+      version: packageVersion,
+      npmLatest: latestVersion || "unknown",
+    },
+    node: {
+      version: process.version,
+      ok: Number(process.versions.node.split(".")[0]) >= 22,
+    },
+    project: {
+      root: paths.root,
+      controlDir: paths.controlDir,
+      sessionsDir: paths.sessionsDir,
+      sessionDbPath: paths.sessionDbPath,
+      localEnvPresent: keyStatus.localEnv,
+    },
+    keys: {
+      openai: keyStatus.openai,
+      deepseek: keyStatus.deepseek,
+      mock: true,
+    },
+    sandbox: dockerStatus,
+    wrappers: listAgentWrappers().map((wrapper) => ({
+      name: wrapper.name,
+      label: wrapper.label,
+      available: wrapper.available,
+    })),
+    sessions,
+  };
+}