@lazyingart/agintiflow 0.20.126 → 0.20.128

package/README.md

@@ -103,13 +103,15 @@ Provider signup and key pages:
 | Qwen / DashScope | [https://bailian.console.aliyun.com/](https://bailian.console.aliyun.com/) | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1` |
 | GRS AI image tools | [https://grsai.ai/dashboard/api-keys](https://grsai.ai/dashboard/api-keys) | Configure with `/auxiliary grsai` or `aginti login grsai` |
 
-The CLI quietly auto-starts or reuses the local web UI from the same project. It tries `http://127.0.0.1:3210` first, then `3211`, `3212`, and so on if the port is already occupied. The active URL is shown in the CLI launch header. If startup is blocked or unavailable, the same header row shows the recovery hint; run `/webapp [port]` inside the CLI to retry.
+The CLI quietly auto-starts or reuses the local web UI from the same project. It tries `http://127.0.0.1:3210` first, then `3211`, `3212`, and so on if the port is already occupied by another project. The active URL is shown in the CLI launch header. If startup is blocked, stale, or unavailable, the same header row shows the recovery hint; run `/webapp [port]` inside the CLI to retry, or `/webapp restart [port]` to stop and relaunch the local webapp with the current project and canonical `~/.agintiflow` session home.
 
 Package installation also makes a best-effort, non-blocking webapp initialization. Install never fails because the optional local webapp could not start.
 
 Launch the web UI explicitly when you want a foreground web server:
 
 ```bash
+aginti webapp
+aginti webapp restart
 aginti web --port 3210
 # opens http://127.0.0.1:3210, or the next available port
 ```
@@ -143,7 +145,7 @@ aginti --language de
 | Goal | Command |
 | --- | --- |
 | Start interactive chat | `aginti` or `aginti chat` |
-| Start local web app | Auto-starts with `aginti`; foreground mode is `aginti web --port 3210` |
+| Start local web app | Auto-starts with `aginti`; detached command is `aginti webapp`; restart with `aginti webapp restart`; foreground mode is `aginti web --port 3210` |
 | Save provider keys | `aginti auth`, `/auth`, `/login` |
 | Review current repo | `/review [focus]` |
 | Toggle SCS quality gate | `/scs` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.126",
+  "version": "0.20.128",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/public/app.js

@@ -2061,6 +2061,12 @@ function resetArtifactViewer() {
   artifactViewerBodyEl.innerHTML = `<p class="subtle">${t("artifactViewerEmpty")}</p>`;
 }
 
+function artifactRawUrl(artifactId, { download = false } = {}) {
+  if (!currentSessionId || !artifactId) return "";
+  const base = `/api/sessions/${encodeURIComponent(currentSessionId)}/artifacts/${encodeURIComponent(artifactId)}/raw`;
+  return download ? `${base}?download=1` : base;
+}
+
 function renderArtifactShell() {
   renderArtifactBadge();
   renderArtifactList();
@@ -2075,23 +2081,40 @@ function renderArtifactContent(content) {
   artifactViewerTitleEl.textContent = content.title || item?.title || t("artifactViewerEmptyTitle");
   artifactViewerMetaEl.textContent = [content.path || item?.path, item ? artifactLabel(item) : ""].filter(Boolean).join(" · ");
   artifactViewerKindEl.textContent = content.kind || item?.kind || "";
+  const streamedUrl = content.url || (content.id ? artifactRawUrl(content.id) : "");
+  const downloadUrl = content.downloadUrl || (content.id ? artifactRawUrl(content.id, { download: true }) : "");
+  const renderUrl = streamedUrl || content.dataUrl;
 
-  if (content.dataUrl && (content.kind === "pdf" || content.mime === "application/pdf")) {
+  if (renderUrl && (content.kind === "pdf" || content.mime === "application/pdf")) {
     artifactViewerBodyEl.innerHTML = `
-      <iframe class="artifact-pdf-frame" src="${content.dataUrl}" title="${escapeHtml(content.title || "Artifact PDF")}"></iframe>
+      <iframe class="artifact-pdf-frame" src="${renderUrl}" title="${escapeHtml(content.title || "Artifact PDF")}"></iframe>
     `;
     return;
   }
 
-  if (content.dataUrl) {
+  if (renderUrl && (content.kind === "image" || String(content.mime || "").startsWith("image/"))) {
     artifactViewerBodyEl.innerHTML = `
       <figure class="artifact-image-frame">
-        <img class="artifact-preview-image" src="${content.dataUrl}" alt="${escapeHtml(content.title || "Artifact image")}" />
+        <img class="artifact-preview-image" src="${renderUrl}" alt="${escapeHtml(content.title || "Artifact image")}" />
       </figure>
     `;
     return;
   }
 
+  if ((content.tooLargeForInline || content.binary) && streamedUrl) {
+    artifactViewerBodyEl.innerHTML = `
+      <div class="artifact-large-file">
+        <strong>${escapeHtml(content.preview || "Artifact is available as a streamed file.")}</strong>
+        <p>${escapeHtml(content.path || item?.path || content.title || "Generated artifact")}</p>
+        <div class="artifact-file-actions">
+          <a class="secondary-button" href="${streamedUrl}" target="_blank" rel="noreferrer">Open preview</a>
+          <a class="secondary-button" href="${downloadUrl}" download="${escapeHtml(artifactDownloadName(item, content))}">Download</a>
+        </div>
+      </div>
+    `;
+    return;
+  }
+
   const text = typeof content.text === "string" ? content.text : "";
   if (content.kind === "markdown" || /markdown/i.test(content.mime || "")) {
     artifactViewerBodyEl.innerHTML = `<div class="artifact-markdown markdown-body">${renderMarkdown(text)}</div>`;
@@ -2110,15 +2133,19 @@ function artifactDownloadName(item, content) {
       ? ".pdf"
       : content.mime?.startsWith("image/png")
         ? ".png"
-        : content.mime?.startsWith("image/svg")
-          ? ".svg"
-          : content.kind === "json"
-            ? ".json"
-            : content.kind === "diff"
-              ? ".diff"
-              : content.kind === "markdown"
-                ? ".md"
-                : ".txt";
+        : content.mime?.startsWith("image/jpeg")
+          ? ".jpg"
+          : content.mime?.startsWith("image/webp")
+            ? ".webp"
+            : content.mime?.startsWith("image/svg")
+              ? ".svg"
+              : content.kind === "json"
+                ? ".json"
+                : content.kind === "diff"
+                  ? ".diff"
+                  : content.kind === "markdown"
+                    ? ".md"
+                    : ".txt";
   const base = sourceName
     .split("/")
     .filter(Boolean)
@@ -2153,6 +2180,21 @@ async function downloadArtifact(artifactId) {
     const data = await response.json().catch(() => ({}));
     if (!response.ok) throw new Error(data.error || t("artifactDownloadFailed"));
 
+    if ((data.downloadUrl || data.url) && !data.dataUrl && typeof data.text !== "string") {
+      const link = document.createElement("a");
+      link.href = data.downloadUrl || artifactRawUrl(artifactId, { download: true }) || data.url;
+      link.download = artifactDownloadName(item, data);
+      document.body.append(link);
+      link.click();
+      link.remove();
+
+      markArtifactRead(artifactId);
+      renderArtifactBadge();
+      renderArtifactList();
+      artifactStatusEl.textContent = t("artifactDownloadReady");
+      return;
+    }
+
     const blob = data.dataUrl
       ? blobFromDataUrl(data.dataUrl)
       : new Blob([typeof data.text === "string" ? data.text : JSON.stringify(data, null, 2)], {

package/public/styles.css

@@ -1602,6 +1602,29 @@ button.danger {
   background: white;
 }
 
+.artifact-large-file {
+  display: grid;
+  gap: 10px;
+  align-content: start;
+  margin: 0;
+  padding: 18px;
+  border: 1px solid var(--line);
+  border-radius: 16px;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.artifact-large-file p {
+  margin: 0;
+  color: var(--muted);
+  overflow-wrap: anywhere;
+}
+
+.artifact-file-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
 .artifact-editor {
   min-height: 100%;
   height: 100%;

package/scripts/smoke-canvas-artifacts.js

@@ -1,7 +1,13 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { buildArtifacts, normalizeCanvasPayload, persistCanvasPayloadFile, readArtifactContent } from "../src/artifact-tunnel.js";
+import {
+  buildArtifacts,
+  normalizeCanvasPayload,
+  persistCanvasPayloadFile,
+  readArtifactContent,
+  resolveArtifactFile,
+} from "../src/artifact-tunnel.js";
 import { SessionStore } from "../src/session-store.js";
 
 async function main() {
@@ -54,6 +60,81 @@ async function main() {
   if (!content.ok) throw new Error(content.error || "persisted artifact could not be read");
   if (!String(content.text || "").includes("Durable report")) throw new Error("persisted artifact content mismatch");
 
+  const largeImagePath = path.join(workspace, "large-preview.png");
+  const pngHeader = Buffer.from("89504e470d0a1a0a", "hex");
+  await fs.writeFile(largeImagePath, Buffer.concat([pngHeader, Buffer.alloc(4_200_000)]));
+  const largeNormalized = normalizeCanvasPayload(
+    {
+      title: "Large preview image",
+      kind: "image",
+      path: "large-preview.png",
+      selected: true,
+    },
+    config
+  );
+  if (!largeNormalized.ok) throw new Error(largeNormalized.reason || "large image canvas payload normalization failed");
+  const largePersisted = await persistCanvasPayloadFile(largeNormalized.payload, { config, store });
+  if (!largePersisted.ok) throw new Error(largePersisted.reason || "large image canvas artifact persistence failed");
+  if (!largePersisted.payload.artifactPersisted) throw new Error("large image was not persisted into session artifacts");
+
+  const largeEvents = [
+    {
+      timestamp: new Date().toISOString(),
+      type: "canvas.item",
+      data: {
+        ...largePersisted.payload,
+        commandCwd: workspace,
+      },
+    },
+  ];
+  const { items: largeItems } = buildArtifacts({ sessionId: store.sessionId, events: largeEvents, store });
+  const largeContent = await readArtifactContent(largeItems[0], { store, config });
+  if (!largeContent.ok) throw new Error(largeContent.error || "large artifact metadata could not be read");
+  if (largeContent.dataUrl) throw new Error("large artifact should not be inlined as a data URL");
+  if (!largeContent.url || !largeContent.downloadUrl || !largeContent.tooLargeForInline) {
+    throw new Error("large artifact did not expose streamed preview URLs");
+  }
+  const largeFile = await resolveArtifactFile(largeItems[0], { store, config });
+  if (!largeFile.ok || largeFile.size <= 4_000_000 || largeFile.mime !== "image/png") {
+    throw new Error("large artifact file resolver returned invalid metadata");
+  }
+
+  const largePdfPath = path.join(workspace, "compiled-paper.pdf");
+  await fs.writeFile(largePdfPath, Buffer.concat([Buffer.from("%PDF-1.7\n"), Buffer.alloc(4_200_000)]));
+  const pdfNormalized = normalizeCanvasPayload(
+    {
+      title: "Compiled paper",
+      kind: "pdf",
+      path: "compiled-paper.pdf",
+      selected: true,
+    },
+    config
+  );
+  if (!pdfNormalized.ok) throw new Error(pdfNormalized.reason || "large PDF canvas payload normalization failed");
+  const pdfPersisted = await persistCanvasPayloadFile(pdfNormalized.payload, { config, store });
+  if (!pdfPersisted.ok) throw new Error(pdfPersisted.reason || "large PDF canvas artifact persistence failed");
+  const { items: pdfItems } = buildArtifacts({
+    sessionId: store.sessionId,
+    events: [
+      {
+        timestamp: new Date().toISOString(),
+        type: "canvas.item",
+        data: {
+          ...pdfPersisted.payload,
+          commandCwd: workspace,
+        },
+      },
+    ],
+    store,
+  });
+  const pdfContent = await readArtifactContent(pdfItems[0], { store, config });
+  if (!pdfContent.ok || pdfContent.kind !== "pdf" || pdfContent.mime !== "application/pdf") {
+    throw new Error(`large PDF artifact did not expose PDF metadata: ${JSON.stringify(pdfContent)}`);
+  }
+  if (!pdfContent.tooLargeForInline || !pdfContent.url || !pdfContent.downloadUrl || pdfContent.dataUrl) {
+    throw new Error("large PDF artifact should stream through preview/download URLs instead of inline data");
+  }
+
   const missing = await persistCanvasPayloadFile({ ...normalized.payload, path: "missing.png" }, { config, store });
   if (missing.ok) throw new Error("missing canvas path should fail persistence");
 

package/scripts/smoke-capabilities.js

@@ -26,6 +26,7 @@ async function runCli(args, envOverrides = {}) {
       ...process.env,
       AGINTIFLOW_RUNTIME_DIR: "",
       AGINTIFLOW_HOME: agintiflowHome,
+      AGINTIFLOW_NO_WEB_AUTO_START: "1",
       ...envOverrides,
     },
   });
@@ -41,6 +42,7 @@ async function runCliIn(cwd, args, envOverrides = {}) {
       ...process.env,
       AGINTIFLOW_RUNTIME_DIR: "",
       AGINTIFLOW_HOME: agintiflowHome,
+      AGINTIFLOW_NO_WEB_AUTO_START: "1",
       ...envOverrides,
     },
   });

package/scripts/smoke-cli-chat.js

@@ -78,6 +78,7 @@ function runCli(args, inputText) {
         ...process.env,
         AGINTIFLOW_RUNTIME_DIR: "",
         AGINTIFLOW_HOME: agintiflowHome,
+        AGINTIFLOW_NO_WEB_AUTO_START: "1",
         AGINTIFLOW_PREVIEW_TTL_MS: "1000",
         AGINTI_LANGUAGE: "en",
       },
@@ -146,6 +147,7 @@ async function runTmuxInterruptSmoke({ key, expected }) {
     "env",
     `AGINTIFLOW_HOME=${shellQuote(agintiflowHome)}`,
     "AGINTIFLOW_RUNTIME_DIR=",
+    "AGINTIFLOW_NO_WEB_AUTO_START=1",
     "AGINTI_LANGUAGE=en",
     "AGINTI_INTERRUPT_FORCE_EXIT_MS=2500",
     shellQuote(process.execPath),

package/scripts/smoke-web-api.js

@@ -350,6 +350,37 @@ try {
     throw new Error("artifact content endpoint did not return renderable content");
   }
 
+  const largeSessionId = "large-artifact-smoke";
+  const largeStore = new SessionStore(paths.globalSessionsDir, largeSessionId, sessionStoreOptions(runtimeDir, largeSessionId));
+  await largeStore.ensure();
+  const largeCanvasDir = path.join(largeStore.artifactsDir, "canvas");
+  await fs.mkdir(largeCanvasDir, { recursive: true });
+  const largeImagePath = path.join(largeCanvasDir, "large-image.png");
+  await fs.writeFile(largeImagePath, Buffer.concat([Buffer.from("89504e470d0a1a0a", "hex"), Buffer.alloc(4_200_000)]));
+  await largeStore.appendEvent("canvas.item", {
+    artifactId: "large-image",
+    title: "Large streamed image",
+    kind: "image",
+    path: "large-image.png",
+    sessionFilePath: largeImagePath,
+    selected: true,
+  });
+  const largeArtifacts = await fetchJson(`/api/sessions/${encodeURIComponent(largeSessionId)}/artifacts`);
+  if (!largeArtifacts.items?.some((item) => item.id === "large-image")) {
+    throw new Error("large artifact endpoint did not list session artifact");
+  }
+  const largeContent = await fetchJson(`/api/sessions/${encodeURIComponent(largeSessionId)}/artifacts/large-image`);
+  if (!largeContent.tooLargeForInline || !largeContent.url || largeContent.dataUrl) {
+    throw new Error("large artifact metadata did not switch to streamed preview");
+  }
+  const rawResponse = await fetch(`${baseUrl}/api/sessions/${encodeURIComponent(largeSessionId)}/artifacts/large-image/raw`);
+  if (!rawResponse.ok) throw new Error(`large artifact raw endpoint failed: ${rawResponse.status}`);
+  if (!/^image\/png\b/i.test(rawResponse.headers.get("content-type") || "")) {
+    throw new Error("large artifact raw endpoint did not preserve image content type");
+  }
+  const rawBytes = await rawResponse.arrayBuffer();
+  if (rawBytes.byteLength <= 4_000_000) throw new Error("large artifact raw endpoint returned truncated content");
+
   const deleted = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}`, {
     method: "DELETE",
   });
@@ -384,6 +415,7 @@ try {
           "/api/workspace/changes",
           "/api/sessions/:id/artifacts",
           "/api/sessions/:id/artifacts/:artifactId",
+          "/api/sessions/:id/artifacts/:artifactId/raw",
           "POST /api/sessions/:id/artifacts/select",
         ],
         provider: run.provider,

package/scripts/smoke-web-autostart.js

@@ -7,13 +7,18 @@ import { ensureAgintiWebApp } from "../src/web-autostart.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const runtimeDir = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-web-autostart-"));
+const homeDir = path.join(runtimeDir, "stable-web-home");
+const inheritedHome = path.join(runtimeDir, "leaked-cli-home");
 const preferredPort = 44500 + Math.floor(Math.random() * 1000);
 let childPid = 0;
+const originalHome = process.env.AGINTIFLOW_HOME;
 
 try {
+  process.env.AGINTIFLOW_HOME = inheritedHome;
   const first = await ensureAgintiWebApp({
     packageDir: repoRoot,
     cwd: runtimeDir,
+    home: homeDir,
     preferredPort,
     host: "127.0.0.1",
   });
@@ -25,17 +30,35 @@ try {
   if (!health.ok || Number(health.port) !== preferredPort) {
     throw new Error(`auto-started web health was invalid: ${JSON.stringify(health)}`);
   }
+  if (path.resolve(health.agintiflowHome) !== path.resolve(homeDir) || path.resolve(health.runtimeDir) !== path.resolve(runtimeDir)) {
+    throw new Error(`auto-started webapp inherited the wrong context: ${JSON.stringify(health)}`);
+  }
   const second = await ensureAgintiWebApp({
     packageDir: repoRoot,
     cwd: runtimeDir,
+    home: homeDir,
     preferredPort,
     host: "127.0.0.1",
   });
   if (!second.ok || !second.reused || second.url !== first.url) {
     throw new Error(`expected second auto-start call to reuse existing webapp, got ${JSON.stringify(second)}`);
   }
+  const restarted = await ensureAgintiWebApp({
+    packageDir: repoRoot,
+    cwd: runtimeDir,
+    home: homeDir,
+    preferredPort,
+    host: "127.0.0.1",
+    restart: true,
+  });
+  if (!restarted.ok || !restarted.restarted || restarted.url !== first.url || Number(restarted.pid) === childPid) {
+    throw new Error(`expected restart on same URL with a new pid, got ${JSON.stringify(restarted)}`);
+  }
+  childPid = Number(restarted.pid) || childPid;
   console.log(`web auto-start smoke passed: ${first.url}`);
 } finally {
+  if (originalHome === undefined) delete process.env.AGINTIFLOW_HOME;
+  else process.env.AGINTIFLOW_HOME = originalHome;
   if (childPid) {
     try {
       process.kill(childPid, "SIGTERM");

package/scripts/smoke-webapp-command.js

@@ -47,7 +47,8 @@ async function runCase({ port, env = {}, expectHeader, label }) {
     env: {
       ...process.env,
       AGINTIFLOW_NO_ANIMATION: "1",
-      AGINTIFLOW_HOME: path.join(runtimeDir, `.agintiflow-home-${label}`),
+      AGINTIFLOW_HOME: path.join(runtimeDir, `.ignored-cli-home-${label}`),
+      AGINTIFLOW_WEB_HOME: path.join(runtimeDir, `.agintiflow-web-home-${label}`),
       ...env,
     },
     stdio: ["pipe", "pipe", "pipe"],
@@ -64,10 +65,15 @@ async function runCase({ port, env = {}, expectHeader, label }) {
     await waitFor(() => output.stdout.includes(expectHeader), child, `${label} launch header`, output);
     child.stdin.write(`/webapp ${port}\n`);
     await waitFor(() => output.stdout.includes(`webapp=http://127.0.0.1:${port}`), child, `${label} /webapp command`, output);
+    child.stdin.write(`/webapp restart ${port}\n`);
+    await waitFor(() => output.stdout.includes(`webapp=http://127.0.0.1:${port} restarted`), child, `${label} /webapp restart command`, output);
     const health = await fetch(`http://127.0.0.1:${port}/health`).then((response) => response.json());
     if (!health.ok || health.app !== "agintiflow" || Number(health.port) !== port) {
       throw new Error(`invalid /webapp health response for ${label}: ${JSON.stringify(health)}`);
     }
+    if (path.resolve(health.agintiflowHome) !== path.resolve(path.join(runtimeDir, `.agintiflow-web-home-${label}`))) {
+      throw new Error(`webapp command inherited the wrong home for ${label}: ${JSON.stringify(health)}`);
+    }
   } finally {
     child.kill("SIGTERM");
     await killPort(port);

package/src/artifact-tunnel.js

@@ -60,6 +60,16 @@ function mimeForPath(filePath) {
   return IMAGE_MIME_BY_EXT.get(ext) || BINARY_RENDER_MIME_BY_EXT.get(ext) || "text/plain; charset=utf-8";
 }
 
+function isRenderableBinaryMime(mime) {
+  return String(mime || "").startsWith("image/") || mime === "application/pdf";
+}
+
+function artifactRawUrl(item, download = false) {
+  if (!item?.sessionId || !item?.id) return "";
+  const base = `/api/sessions/${encodeURIComponent(item.sessionId)}/artifacts/${encodeURIComponent(item.id)}/raw`;
+  return download ? `${base}?download=1` : base;
+}
+
 function safeCanvasFilename(artifactId, filePath) {
   const rawBase = path.basename(String(filePath || "artifact"));
   const safeBase = rawBase
@@ -285,24 +295,13 @@ export function findArtifact(items, artifactId) {
   return items.find((item) => item.id === artifactId) || null;
 }
 
-export async function readArtifactContent(item, { store, config }) {
+export async function resolveArtifactFile(item, { store, config } = {}) {
   if (!item) {
     return { ok: false, error: "Artifact not found." };
   }
 
-  if (item.ref?.type === "inline") {
-    return {
-      ok: true,
-      id: item.id,
-      kind: item.kind,
-      title: item.title,
-      path: item.path || "",
-      mime: item.mime || "text/plain; charset=utf-8",
-      text: redactSensitiveText(String(item.ref.text || "")),
-    };
-  }
-
   if (item.ref?.type === "session-file") {
+    if (!store?.sessionDir) return { ok: false, error: "Artifact session store is unavailable." };
     const absolutePath = path.resolve(item.ref.path);
     if (!isInside(store.sessionDir, absolutePath)) {
       return { ok: false, error: "Artifact path is outside this session." };
@@ -311,32 +310,14 @@ export async function readArtifactContent(item, { store, config }) {
     const stat = await fs.stat(absolutePath).catch(() => null);
     if (!stat?.isFile()) return { ok: false, error: "Artifact file is missing." };
     const mime = mimeForPath(absolutePath);
-    const isBinaryRenderable = mime.startsWith("image/") || mime === "application/pdf";
-    const maxBytes = isBinaryRenderable ? MAX_ARTIFACT_IMAGE_BYTES : MAX_ARTIFACT_TEXT_BYTES;
-    if (stat.size > maxBytes) return { ok: false, error: "Artifact is too large to preview safely." };
-
-    const buffer = await fs.readFile(absolutePath);
-    if (isBinaryRenderable) {
-      return {
-        ok: true,
-        id: item.id,
-        kind: mime === "application/pdf" ? "pdf" : "image",
-        title: item.title,
-        path: item.path || "",
-        mime,
-        dataUrl: `data:${mime};base64,${buffer.toString("base64")}`,
-      };
-    }
-
-    if (buffer.includes(0)) return { ok: false, error: "Binary artifact cannot be rendered as text." };
     return {
       ok: true,
-      id: item.id,
-      kind: item.kind,
+      absolutePath,
+      size: stat.size,
+      mime,
+      kind: mime === "application/pdf" ? "pdf" : mime.startsWith("image/") ? "image" : item.kind,
       title: item.title,
       path: item.path || "",
-      mime,
-      text: redactSensitiveText(buffer.toString("utf8")),
     };
   }
 
@@ -350,33 +331,87 @@ export async function readArtifactContent(item, { store, config }) {
     const target = resolveWorkspacePath(itemConfig, item.ref.path);
     const stat = await fs.stat(target.absolutePath).catch(() => null);
     if (!stat?.isFile()) return { ok: false, error: "Workspace file is missing." };
-
     const mime = mimeForPath(target.absolutePath);
-    const isBinaryRenderable = mime.startsWith("image/") || mime === "application/pdf";
+    return {
+      ok: true,
+      absolutePath: target.absolutePath,
+      size: stat.size,
+      mime,
+      kind: mime === "application/pdf" ? "pdf" : mime.startsWith("image/") ? "image" : item.kind,
+      title: item.title,
+      path: item.path || "",
+    };
+  }
+
+  return { ok: false, error: "Artifact has no readable file." };
+}
+
+export async function readArtifactContent(item, { store, config }) {
+  if (!item) {
+    return { ok: false, error: "Artifact not found." };
+  }
+
+  if (item.ref?.type === "inline") {
+    return {
+      ok: true,
+      id: item.id,
+      kind: item.kind,
+      title: item.title,
+      path: item.path || "",
+      mime: item.mime || "text/plain; charset=utf-8",
+      text: redactSensitiveText(String(item.ref.text || "")),
+    };
+  }
+
+  if (item.ref?.type === "session-file" || item.ref?.type === "workspace-file") {
+    const resolved = await resolveArtifactFile(item, { store, config });
+    if (!resolved.ok) return resolved;
+
+    const isBinaryRenderable = isRenderableBinaryMime(resolved.mime);
     const maxBytes = isBinaryRenderable ? MAX_ARTIFACT_IMAGE_BYTES : MAX_ARTIFACT_TEXT_BYTES;
-    if (stat.size > maxBytes) return { ok: false, error: "Workspace file is too large to preview safely." };
+    const url = artifactRawUrl(item);
+    const downloadUrl = artifactRawUrl(item, true);
+    const base = {
+      ok: true,
+      id: item.id,
+      kind: resolved.kind,
+      title: item.title,
+      path: item.path || "",
+      mime: resolved.mime,
+      size: resolved.size,
+      url,
+      downloadUrl,
+    };
+
+    if (resolved.size > maxBytes) {
+      return {
+        ...base,
+        tooLargeForInline: true,
+        preview: isBinaryRenderable
+          ? "Large renderable artifact is available through the streamed artifact endpoint."
+          : "Large artifact is available through the streamed artifact endpoint.",
+      };
+    }
 
-    const buffer = await fs.readFile(target.absolutePath);
+    const buffer = await fs.readFile(resolved.absolutePath);
     if (isBinaryRenderable) {
       return {
-        ok: true,
-        id: item.id,
-        kind: mime === "application/pdf" ? "pdf" : "image",
-        title: item.title,
-        path: item.path || "",
-        mime,
-        dataUrl: `data:${mime};base64,${buffer.toString("base64")}`,
+        ...base,
+        dataUrl: `data:${resolved.mime};base64,${buffer.toString("base64")}`,
+      };
+    }
+
+    if (buffer.includes(0)) {
+      return {
+        ...base,
+        binary: true,
+        preview: "Binary artifact is available through the streamed artifact endpoint.",
       };
     }
 
-    if (buffer.includes(0)) return { ok: false, error: "Binary workspace file cannot be rendered as text." };
     return {
-      ok: true,
-      id: item.id,
+      ...base,
       kind: item.kind,
-      title: item.title,
-      path: item.path || "",
-      mime,
       text: redactSensitiveText(buffer.toString("utf8")),
     };
   }

package/src/cli.js

@@ -95,11 +95,12 @@ function printUnknownCliOptions(options = []) {
 }
 
 async function maybeEnsureDefaultWebApp(args = {}, { commandCwd = process.cwd() } = {}) {
-  if (args.web) return { ok: false, url: "" };
+  if (args.web || args.webapp) return { ok: false, url: "" };
   try {
     return await ensureAgintiWebApp({
       packageDir,
       cwd: args.commandCwd || commandCwd || process.cwd(),
+      home: args.webHome || "",
       host: args.host || process.env.AGINTI_WEB_HOST || "127.0.0.1",
       preferredPort: args.port || process.env.AGINTI_WEB_PORT || 3210,
       language: args.language ? resolveLanguage(args.language) : "",
@@ -379,6 +380,9 @@ export function parseArgs(argv) {
     sandboxStatus: false,
     sandboxPreflight: false,
     web: false,
+    webapp: false,
+    webAction: "",
+    webHome: "",
     interactive: false,
     port: "",
     host: "",
@@ -399,6 +403,21 @@ export function parseArgs(argv) {
       parts.push(...argv.slice(i + 1));
       break;
     }
+    if ((arg === "web" || arg === "--web") && String(argv[i + 1] || "").toLowerCase() === "restart") {
+      result.webapp = true;
+      result.webAction = "restart";
+      i += 1;
+      continue;
+    }
+    if (arg === "webapp" || arg === "--webapp" || arg === "web-ui" || arg === "--web-ui") {
+      result.webapp = true;
+      const next = String(argv[i + 1] || "");
+      if (next && !next.startsWith("--")) {
+        result.webAction = next.toLowerCase();
+        i += 1;
+      }
+      continue;
+    }
     if (arg === "web" || arg === "--web") {
       result.web = true;
       continue;
@@ -417,6 +436,11 @@ export function parseArgs(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--web-home") {
+      result.webHome = readOption(argv, i);
+      i += 1;
+      continue;
+    }
     if (arg === "--language" || arg === "--lang" || arg === "-L") {
       const first = readOption(argv, i);
       const second = argv[i + 2] && !String(argv[i + 2]).startsWith("--") ? argv[i + 2] : "";
@@ -1880,6 +1904,33 @@ export async function main(argv = process.argv.slice(2)) {
   const args = { ...parsedArgs, commandCwd: parsedArgs.commandCwd || commandCwd };
   exitOnUnknownOptions(args);
 
+  if (args.webapp) {
+    const action = String(args.webAction || "start").toLowerCase();
+    if (!["start", "restart", "reuse"].includes(action)) {
+      console.error("Usage: aginti webapp [start|restart] [--port 3210] [--host 127.0.0.1]");
+      process.exit(1);
+    }
+    const result = await ensureAgintiWebApp({
+      packageDir,
+      cwd: args.commandCwd || commandCwd,
+      home: args.webHome || "",
+      host: args.host || process.env.AGINTI_WEB_HOST || "127.0.0.1",
+      preferredPort: args.port || process.env.AGINTI_WEB_PORT || 3210,
+      language: args.language ? resolveLanguage(args.language) : "",
+      restart: action === "restart",
+      respectAutoStartDisable: false,
+    }).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), url: "" }));
+    if (!result.ok) {
+      console.error(`webapp unavailable: ${result.error || "unknown"}`);
+      process.exit(1);
+    }
+    const state = result.restarted ? "restarted" : result.reused ? "reused" : "started";
+    console.log(`webapp: ${result.url} ${state}`);
+    console.log(`project: ${result.runtimeDir || path.resolve(args.commandCwd || commandCwd)}`);
+    console.log(`home: ${result.agintiflowHome || ""}`);
+    return;
+  }
+
   if (args.web) {
     if (args.port) process.env.PORT = String(args.port);
     if (args.host) process.env.HOST = String(args.host);

package/src/i18n.js

@@ -139,7 +139,7 @@ const TRANSLATIONS = {
     helpSkills: "List Markdown skills selected for a topic.",
     helpSkillMesh: "Manage strict reviewed skill sharing.",
     helpProfile: "Set task profile, e.g. code, website, latex, maintenance.",
-    helpWebapp: "Start or reuse the local webapp and print its URL.",
+    helpWebapp: "Start, reuse, or restart the local webapp and print its URL.",
     helpWebSearch: "Enable or disable the web_search tool.",
     helpEnableScs: "Toggle Student-Committee-Supervisor gated execution.",
     helpScouts: "Enable parallel DeepSeek scouts and set scout count.",

package/src/interactive-cli.js

@@ -881,7 +881,7 @@ function printHelp() {
       `  ${command("/skills [query]", "List Markdown skills selected for a topic.", "helpSkills")}`,
       `  ${command("/skillmesh [status|off|record|share|sync]", "Manage strict reviewed skill sharing.", "helpSkillMesh")}`,
       `  ${command("/profile <name>", "Set task profile, e.g. code, website, latex, maintenance.", "helpProfile")}`,
-      `  ${command("/webapp [port]", "Start or reuse the local webapp and print its URL.", "helpWebapp")}`,
+      `  ${command("/webapp [port|restart]", "Start, reuse, or restart the local webapp and print its URL.", "helpWebapp")}`,
       `  ${command("/web-search on|off", "Enable or disable the web_search tool.", "helpWebSearch")}`,
       `  ${command("/web-research <query>", "Run a sourced web_research turn with persisted evidence.", "helpWebSearch")}`,
       `  ${command("/image-read <path> [question]", "Run read_image on a workspace screenshot/image.", "helpWebSearch")}`,
@@ -3010,20 +3010,24 @@ async function handleCommand(line, state, packageDir) {
     return true;
   }
   if (command === "webapp" || command === "web") {
-    const port = Number(value) || Number(process.env.AGINTI_WEB_PORT || process.env.PORT || 3210);
-    printSystemLine("webapp=starting");
+    const words = value.split(/\s+/).filter(Boolean);
+    const restart = words.some((word) => word.toLowerCase() === "restart");
+    const portValue = words.find((word) => /^\d+$/.test(word));
+    const port = Number(portValue) || Number(process.env.AGINTI_WEB_PORT || process.env.PORT || 3210);
+    printSystemLine(restart ? "webapp=restarting" : "webapp=starting");
     const result = await ensureAgintiWebApp({
       packageDir,
       cwd: state.commandCwd || process.cwd(),
       host: process.env.AGINTI_WEB_HOST || process.env.HOST || "127.0.0.1",
       preferredPort: port,
       language: state.language,
+      restart,
       respectAutoStartDisable: false,
     }).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), url: "" }));
     if (result.ok) {
       state.webAppUrl = result.url;
       state.webAppNotice = "";
-      printSystemLine(`webapp=${result.url} ${result.reused ? "reused" : "started"}`);
+      printSystemLine(`webapp=${result.url} ${result.restarted ? "restarted" : result.reused ? "reused" : "started"}`);
     } else {
       state.webAppUrl = "";
       state.webAppNotice = `webapp unavailable - use /webapp to retry; error: ${compactLine(result.error || "unknown", 72)}`;

package/src/web-autostart.js

@@ -1,6 +1,7 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import http from "node:http";
 import net from "node:net";
+import os from "node:os";
 import path from "node:path";
 
 const DEFAULT_HOST = "127.0.0.1";
@@ -20,7 +21,40 @@ function webUrl(host, port) {
   return `http://${host}:${port}`;
 }
 
-function fetchHealth(host, port, timeoutMs = 450) {
+function isInside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function samePath(left = "", right = "") {
+  if (!left || !right) return false;
+  return path.resolve(left) === path.resolve(right);
+}
+
+function defaultAgintiflowHome() {
+  return path.join(os.homedir(), ".agintiflow");
+}
+
+function isLikelyTransientPath(value = "") {
+  if (!value) return false;
+  const resolved = path.resolve(value);
+  const tmp = path.resolve(os.tmpdir());
+  return isInside(tmp, resolved) || /agintiflow-(cli-chat|webapp-command|web-autostart|web-port|smoke|test)-/i.test(resolved);
+}
+
+function resolveWebHome(home = "") {
+  const explicit = home || process.env.AGINTIFLOW_WEB_HOME || process.env.AGINTI_WEB_HOME || "";
+  if (explicit) return path.resolve(explicit);
+  const inherited = process.env.AGINTIFLOW_HOME || "";
+  if (inherited && !isLikelyTransientPath(inherited)) return path.resolve(inherited);
+  return defaultAgintiflowHome();
+}
+
+function resolveRuntimeDir(cwd = "") {
+  return path.resolve(process.env.AGINTIFLOW_WEB_RUNTIME_DIR || cwd || process.cwd());
+}
+
+function fetchHealthDetails(host, port, timeoutMs = 450) {
   return new Promise((resolve) => {
     const req = http.get(`${webUrl(host, port)}/health`, { timeout: timeoutMs }, (res) => {
       let body = "";
@@ -31,20 +65,28 @@ function fetchHealth(host, port, timeoutMs = 450) {
       res.on("end", () => {
         try {
           const json = JSON.parse(body || "{}");
-          resolve(Boolean(res.statusCode === 200 && json.ok && (json.app === "agintiflow" || Number(json.port) === port)));
+          resolve({
+            ok: Boolean(res.statusCode === 200 && json.ok && (json.app === "agintiflow" || Number(json.port) === port)),
+            statusCode: res.statusCode,
+            ...json,
+          });
         } catch {
-          resolve(false);
+          resolve({ ok: false });
         }
       });
     });
     req.on("timeout", () => {
       req.destroy();
-      resolve(false);
+      resolve({ ok: false });
     });
-    req.on("error", () => resolve(false));
+    req.on("error", () => resolve({ ok: false }));
   });
 }
 
+async function fetchHealth(host, port, timeoutMs = 450) {
+  return (await fetchHealthDetails(host, port, timeoutMs)).ok;
+}
+
 function canListen(host, port) {
   return new Promise((resolve) => {
     const server = net.createServer();
@@ -64,14 +106,104 @@ async function waitForHealth(host, port, timeoutMs = 7000) {
   return false;
 }
 
-export async function findReusableOrFreeWebPort({ host = DEFAULT_HOST, preferredPort = DEFAULT_PORT, attempts = MAX_PORT_ATTEMPTS } = {}) {
+function compatibleHealth(health = {}, { cwd = "", home = "", packageDir = "" } = {}) {
+  if (!health.ok || health.app !== "agintiflow") return false;
+  if (!health.runtimeDir || !health.agintiflowHome) return false;
+  if (!samePath(health.runtimeDir, cwd)) return false;
+  if (!samePath(health.agintiflowHome, home)) return false;
+  if (health.packageDir && packageDir && !samePath(health.packageDir, packageDir)) return false;
+  return true;
+}
+
+function listenerPids(port) {
+  return new Promise((resolve) => {
+    execFile("lsof", [`-tiTCP:${port}`, "-sTCP:LISTEN"], { encoding: "utf8" }, (error, stdout) => {
+      if (error) {
+        resolve([]);
+        return;
+      }
+      resolve(
+        String(stdout || "")
+          .split(/\s+/)
+          .map((value) => Number(value))
+          .filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid)
+      );
+    });
+  });
+}
+
+async function waitForPortRelease(host, port, timeoutMs = 5000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!(await fetchHealth(host, port, 220)) && (await canListen(host, port))) return true;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  return false;
+}
+
+async function stopWebAppOnPort({ host, port, health = {} } = {}) {
+  const pids = new Set();
+  if (Number.isInteger(Number(health.pid)) && Number(health.pid) > 0) pids.add(Number(health.pid));
+  for (const pid of await listenerPids(port)) pids.add(pid);
+  if (pids.size === 0) return { ok: false, error: `Could not identify AgInTiFlow webapp process on ${host}:${port}.` };
+
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      // Already stopped or not owned by this user.
+    }
+  }
+  if (await waitForPortRelease(host, port, 3500)) return { ok: true, pids: [...pids], forced: false };
+
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      // Ignore.
+    }
+  }
+  const released = await waitForPortRelease(host, port, 2000);
+  return released
+    ? { ok: true, pids: [...pids], forced: true }
+    : { ok: false, pids: [...pids], error: `AgInTiFlow webapp on ${host}:${port} did not stop.` };
+}
+
+export async function findReusableOrFreeWebPort({
+  host = DEFAULT_HOST,
+  preferredPort = DEFAULT_PORT,
+  attempts = MAX_PORT_ATTEMPTS,
+  cwd = process.cwd(),
+  home = "",
+  packageDir = process.cwd(),
+  restart = false,
+} = {}) {
   const startPort = normalizePort(preferredPort);
   const normalizedHost = normalizeHost(host);
+  const runtimeDir = resolveRuntimeDir(cwd);
+  const homeDir = resolveWebHome(home);
   for (let offset = 0; offset < attempts; offset += 1) {
     const port = startPort + offset;
     if (port >= 65536) break;
-    if (await fetchHealth(normalizedHost, port)) {
-      return { port, host: normalizedHost, url: webUrl(normalizedHost, port), reused: true, available: false };
+    const health = await fetchHealthDetails(normalizedHost, port);
+    if (health.ok) {
+      if (restart && Number(port) === startPort) {
+        const stopped = await stopWebAppOnPort({ host: normalizedHost, port, health });
+        if (!stopped.ok) return { port, host: normalizedHost, url: "", reused: false, available: false, stopped, error: stopped.error };
+        return {
+          port,
+          host: normalizedHost,
+          url: webUrl(normalizedHost, port),
+          reused: false,
+          available: true,
+          restarted: true,
+          stopped,
+        };
+      }
+      if (compatibleHealth(health, { cwd: runtimeDir, home: homeDir, packageDir })) {
+        return { port, host: normalizedHost, url: webUrl(normalizedHost, port), reused: true, available: false, health };
+      }
+      continue;
     }
     if (await canListen(normalizedHost, port)) {
       return { port, host: normalizedHost, url: webUrl(normalizedHost, port), reused: false, available: true };
@@ -83,32 +215,40 @@ export async function findReusableOrFreeWebPort({ host = DEFAULT_HOST, preferred
 export async function ensureAgintiWebApp({
   packageDir = process.cwd(),
   cwd = process.cwd(),
+  home = "",
   host = DEFAULT_HOST,
   preferredPort = DEFAULT_PORT,
   language = "",
+  restart = false,
   respectAutoStartDisable = true,
 } = {}) {
   if (respectAutoStartDisable && (process.env.AGINTI_NO_WEB_AUTO_START === "1" || process.env.AGINTIFLOW_NO_WEB_AUTO_START === "1")) {
     return { ok: false, disabled: true, url: "" };
   }
 
-  const candidate = await findReusableOrFreeWebPort({ host, preferredPort });
+  const runtimeDir = resolveRuntimeDir(cwd);
+  const homeDir = resolveWebHome(home);
+  const candidate = await findReusableOrFreeWebPort({ host, preferredPort, cwd: runtimeDir, home: homeDir, packageDir, restart });
   if (!candidate.port) {
-    return { ok: false, error: `No available AgInTiFlow web port from ${normalizePort(preferredPort)}.`, url: "" };
+    return { ok: false, error: candidate.error || `No available AgInTiFlow web port from ${normalizePort(preferredPort)}.`, url: "" };
+  }
+  if (candidate.error || (!candidate.available && !candidate.reused)) {
+    return { ok: false, error: candidate.error || `No reusable or free AgInTiFlow web port from ${normalizePort(preferredPort)}.`, url: "" };
   }
   if (candidate.reused) {
-    return { ok: true, reused: true, started: false, ...candidate };
+    return { ok: true, reused: true, started: false, runtimeDir, agintiflowHome: homeDir, ...candidate };
   }
 
   const child = spawn(process.execPath, [path.join(packageDir, "web.js")], {
-    cwd,
+    cwd: runtimeDir,
     detached: true,
     stdio: "ignore",
     env: {
       ...process.env,
       HOST: candidate.host,
       PORT: String(candidate.port),
-      AGINTIFLOW_RUNTIME_DIR: cwd,
+      AGINTIFLOW_RUNTIME_DIR: runtimeDir,
+      AGINTIFLOW_HOME: homeDir,
       AGINTIFLOW_PACKAGE_DIR: packageDir,
       ...(language ? { AGINTI_LANGUAGE: language } : {}),
     },
@@ -117,6 +257,16 @@ export async function ensureAgintiWebApp({
 
   const healthy = await waitForHealth(candidate.host, candidate.port);
   return healthy
-    ? { ok: true, reused: false, started: true, pid: child.pid, ...candidate }
+    ? {
+        ok: true,
+        reused: false,
+        started: true,
+        restarted: Boolean(candidate.restarted),
+        stopped: candidate.stopped,
+        pid: child.pid,
+        runtimeDir,
+        agintiflowHome: homeDir,
+        ...candidate,
+      }
     : { ok: false, error: `Started web process ${child.pid}, but ${candidate.url}/health did not become ready.`, url: "" };
 }

package/web.js

@@ -1,3 +1,4 @@
+import { createReadStream } from "node:fs";
 import fs from "node:fs/promises";
 import express from "express";
 import path from "node:path";
@@ -43,6 +44,7 @@ import {
   countUnreadArtifacts,
   findArtifact,
   readArtifactContent,
+  resolveArtifactFile,
   serializeArtifacts,
 } from "./src/artifact-tunnel.js";
 
@@ -75,6 +77,17 @@ function isSafeSessionId(sessionId) {
   return /^[A-Za-z0-9._:-]+$/.test(String(sessionId || "")) && !String(sessionId || "").includes("..");
 }
 
+function safeDownloadFilename(value) {
+  const basename = path.basename(String(value || "artifact").replace(/\\/g, "/"));
+  return (
+    basename
+      .replace(/[\r\n"\\]+/g, "_")
+      .replace(/^\.+/, "")
+      .replace(/[^A-Za-z0-9._ -]+/g, "-")
+      .slice(0, 120) || "artifact"
+  );
+}
+
 function mapEventLogs(events) {
   return events.map((event) => ({
     at: event.timestamp,
@@ -877,6 +890,39 @@ app.get("/api/sessions/:sessionId/artifacts/:artifactId", async (req, res) => {
   res.json(content);
 });
 
+app.get("/api/sessions/:sessionId/artifacts/:artifactId/raw", async (req, res) => {
+  const bundle = await loadArtifactBundle(req.params.sessionId);
+  if (bundle.error) {
+    res.status(bundle.status || 500).json({ error: bundle.error });
+    return;
+  }
+
+  const artifact = findArtifact(bundle.items, req.params.artifactId);
+  const file = await resolveArtifactFile(artifact, bundle);
+  if (!file.ok) {
+    res.status(artifact ? 400 : 404).json({ error: file.error || "Artifact not found." });
+    return;
+  }
+
+  const filename = safeDownloadFilename(file.path || file.title || file.absolutePath);
+  const disposition = req.query.download === "1" ? "attachment" : "inline";
+  res.setHeader("Content-Type", file.mime || "application/octet-stream");
+  res.setHeader("Content-Length", String(file.size));
+  res.setHeader("Content-Disposition", `${disposition}; filename="${filename}"`);
+  res.setHeader("Cache-Control", "private, max-age=0, no-cache");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+
+  const stream = createReadStream(file.absolutePath);
+  stream.on("error", (error) => {
+    if (!res.headersSent) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    res.destroy(error);
+  });
+  stream.pipe(res);
+});
+
 app.post("/api/sessions/:sessionId/artifacts/select", async (req, res) => {
   const bundle = await loadArtifactBundle(req.params.sessionId);
   if (bundle.error) {
@@ -1337,7 +1383,21 @@ app.post("/api/runs/:sessionId/stop", async (req, res) => {
 });
 
 app.get("/health", (_req, res) => {
-  res.json({ ok: true, app: "agintiflow", port, url: `http://${host}:${port}` });
+  res.json({
+    ok: true,
+    app: "agintiflow",
+    version: packageJson.version,
+    pid: process.pid,
+    host,
+    port,
+    url: `http://${host}:${port}`,
+    runtimeDir: baseDir,
+    projectRoot: baseDir,
+    agintiflowHome: storagePaths.agintiflowHome,
+    sessionsDir,
+    projectSessionsDir,
+    packageDir,
+  });
 });
 
 await fs.mkdir(sessionsDir, { recursive: true });