@lazyingart/agintiflow 0.20.198 → 0.20.199

package/bin/aginti-cli.js

@@ -1,7 +1,22 @@
 #!/usr/bin/env node
-import { main } from "../src/cli.js";
+import fs from "node:fs";
 
-main().catch((error) => {
+const argv = process.argv.slice(2);
+
+function fail(error) {
   console.error(error);
   process.exit(1);
-});
+}
+
+try {
+  if (["--version", "version", "-v"].includes(argv[0])) {
+    const packageJson = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    console.log(packageJson.version);
+  } else {
+    import("../src/cli.js")
+      .then(({ main }) => main(argv))
+      .catch(fail);
+  }
+} catch (error) {
+  fail(error);
+}

package/docs/agent-runtime-pipe.md

@@ -8,6 +8,30 @@ AgInTiFlow keeps CLI and web runs equivalent by using a project-local session in
 - Canonical session store: `~/.agintiflow/sessions/<session-id>/`.
 - Runtime inbox: `~/.agintiflow/sessions/<session-id>/inbox.jsonl`.
 
+## Persistence Guarantees
+
+Long-lived processes reuse one SQLite session-index connection and prepared
+statement set per resolved `AGINTIFLOW_HOME`. The index enables WAL mode and a
+bounded busy timeout so CLI, web, and bridge processes can update the
+rebuildable index without repeatedly reopening and migrating the database.
+Call `closeSessionIndexConnections()` in tests or embedding hosts that switch
+runtime homes inside one process.
+
+Each `SessionStore` memoizes directory/pointer initialization and serializes
+its event appends. Concurrent callers therefore retain call order without
+recreating the session pointer for every event. `state.json` remains an atomic,
+fsynced save boundary. A missing state file is resumably absent; malformed JSON
+raises `SESSION_STATE_CORRUPT` instead of silently looking like a new session.
+
+## Machine Run Input
+
+`aginti run` uses deterministic input precedence: explicit `--stdin` reads
+standard input, otherwise a positional prompt wins, and piped standard input is
+used only when no positional prompt exists. This keeps positional automation
+working in subprocesses whose stdin is non-interactive while preserving both
+explicit and implicit pipe workflows. `aginti --version` is handled by the
+lightweight launcher without loading the full agent and web runtime.
+
 When a run is active, the web chat and `aginti queue <session-id> "..."` append messages to the inbox instead of trying to mutate the running process directly. The web API exposes `GET /api/sessions/:id/inbox`, `POST /api/sessions/:id/inbox`, `PATCH /api/sessions/:id/inbox/:itemId`, and `DELETE /api/sessions/:id/inbox/:itemId` so browser users can inspect, edit, or remove pending pipe messages before the runner consumes them. The runner drains the inbox at safe boundaries: before each model step and after tool execution. This mirrors the event-queue style used by mature agent UIs while keeping the backend decoupled from any specific frontend.
 
 The interactive CLI keeps the input panel visible while a run is working. Enter sends the current draft as an ASAP pipe message and displays it as `→`; the runner drains those messages before normal inbox items and before after-finish queued prompts. Tab stores the draft as an after-finish queue item and displays it as `↳`; those prompts run only after the current run completes. Alt+Up moves the last pending `→` message back into the editor, and Shift+Left moves the last pending `↳` message back into the editor. Idle Esc is ignored so it does not redraw the prompt into the transcript. During a run, Esc waits when `→` pipe messages are still pending and stops the run only when no ASAP pipe message is pending; Ctrl+C always stops. The current command cwd is rendered below the input panel in both idle and running states.

package/docs/labcanvas-chatops-fallback.md

@@ -0,0 +1,46 @@
+# LabCanvas ChatOps Fallback
+
+AgInTiFlow is a reasoning and tool-supervision fallback for LabCanvas. LabCanvas remains the owner of chat transport, schedules, exact-source media resolution, durable task state, routine selection, artifact validation, and delivery.
+
+## Contract
+
+LabCanvas should pass one bounded task packet containing:
+
+- exact current request and source-chat identity;
+- latest same-chat interruptions and a small amount of attributed context;
+- one selected routine and its contract paths;
+- current deterministic preflight and stage state;
+- exact artifact directory and irreversible-action gates.
+
+AgInTi should read `AGENTS.md` and the selected routine contract, then call established commands. It should not invent a second scheduler, publication pipeline, media downloader, CAD generator, or delivery mechanism.
+
+The default provider chain is `deepseek,localllm`. Switching providers is safe only when the first provider failed before inference or tool execution. Never replay an unknown task failure or timeout on another provider because the first attempt may already have caused a side effect.
+
+## Evidence Scope
+
+ChatOps prompts may include a trusted single-line marker:
+
+```text
+AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"chat-response","request":"Produce only the requested chat response."}
+```
+
+or:
+
+```text
+AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Create the requested PDF from the supplied evidence."}
+```
+
+For `chat-response`, ordinary conversation and routing do not require file or command evidence. For `task`, evidence requirements are inferred only from the exact request, not from surrounding wrapper prose. Artifact requests still require real artifacts.
+
+## Local Context Recovery
+
+LocalLLM planning compacts oversized goals to a bounded head-and-tail representation. Runtime compaction retains the first request and latest interruptions. A `LocalContextBudgetError` triggers one compact-and-retry cycle at the same step and records private recovery events. It does not authorize replaying task side effects.
+
+Validate with:
+
+```bash
+npm run check
+npm run smoke:context-budget-recovery
+npm run smoke:truthful-completion
+```
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.198",
+  "version": "0.20.199",
   "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",
@@ -86,6 +86,7 @@
     "scripts/local-first-agent-eval.mjs",
     "scripts/fixtures/local-first-agent-eval-fixtures.mjs",
     "scripts/smoke-run-stdin.js",
+    "scripts/smoke-runtime-core.js",
     "scripts/smoke-mcp.js",
     "scripts/fixtures/mcp-stdio-smoke-server.mjs",
     "scripts/smoke-model-roles.js",
@@ -121,7 +122,7 @@
   "scripts": {
     "start": "node run.js",
     "web": "node web.js",
-    "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check bin/aginti-public-research.js && node --check bin/aginti-safe-chat.js && node --check src/*.js && node --check src/mcp/*.js && node --check public/*.js && node --check scripts/postinstall-webapp.js && node --check scripts/seed-supervised-homework.js && node --check scripts/smoke-agentlink.js && node --check scripts/smoke-execution-policy.js && node --check scripts/smoke-math-rendering.js && node --check scripts/smoke-mcp.js && node --check scripts/smoke-public-research-wrapper.js && node --check scripts/smoke-safe-chat.js && node --check scripts/smoke-web-ui.js && node --check scripts/smoke-scs-evidence-visibility.js && node --check scripts/fixtures/mcp-stdio-smoke-server.mjs",
+    "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check bin/aginti-public-research.js && node --check bin/aginti-safe-chat.js && node --check src/*.js && node --check src/mcp/*.js && node --check public/*.js && node --check scripts/postinstall-webapp.js && node --check scripts/seed-supervised-homework.js && node --check scripts/smoke-agentlink.js && node --check scripts/smoke-execution-policy.js && node --check scripts/smoke-math-rendering.js && node --check scripts/smoke-mcp.js && node --check scripts/smoke-public-research-wrapper.js && node --check scripts/smoke-runtime-core.js && node --check scripts/smoke-safe-chat.js && node --check scripts/smoke-web-ui.js && node --check scripts/smoke-scs-evidence-visibility.js && node --check scripts/fixtures/mcp-stdio-smoke-server.mjs",
     "setup:toolchain-docker": "scripts/setup-agent-toolchain-docker.sh",
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
     "smoke:dynamic-step-budget": "node scripts/smoke-dynamic-step-budget.js",
@@ -140,8 +141,10 @@
     "smoke:inbox": "node scripts/smoke-inbox.js",
     "smoke:long-jobs": "node scripts/smoke-long-jobs.js",
     "smoke:run-stdin": "node scripts/smoke-run-stdin.js",
+    "smoke:runtime-core": "node scripts/smoke-runtime-core.js",
     "smoke:localllm-auto-max": "node scripts/smoke-localllm-auto-max.js",
     "smoke:local-resource-policy": "node scripts/smoke-local-resource-policy.js",
+    "smoke:context-budget-recovery": "node scripts/smoke-context-budget-recovery.js",
     "smoke:localllm-model-tiers": "node scripts/smoke-localllm-model-tiers.js",
     "smoke:localllm-provider": "node scripts/smoke-localllm-provider.js",
     "smoke:progressive-tools": "node scripts/smoke-progressive-tool-selection.js",
@@ -171,7 +174,7 @@
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
     "publish:env": "node scripts/npm-publish-from-env.js publish --access public",
     "publish:env:whoami": "node scripts/npm-publish-from-env.js whoami",
-    "test": "npm run check && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:session-runtime && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/scripts/smoke-run-stdin.js

@@ -7,10 +7,8 @@ import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const home = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-run-stdin-"));
-const command = [
-  path.join(root, "bin", "aginti-cli.js"),
-  "run",
-  "--stdin",
+const cliPath = path.join(root, "bin", "aginti-cli.js");
+const machineOptions = [
   "--json",
   "--provider",
   "mock",
@@ -27,48 +25,70 @@ const command = [
   "host",
 ];
 
-const output = await new Promise((resolve, reject) => {
-  const child = spawn(process.execPath, command, {
-    cwd: home,
-    stdio: ["pipe", "pipe", "pipe"],
-    env: {
-      ...process.env,
-      AGINTIFLOW_HOME: path.join(home, ".agintiflow"),
-      AGINTIFLOW_RUNTIME_DIR: "",
-      AGINTIFLOW_NO_WEB_AUTO_START: "1",
-      AGINTI_LANGUAGE: "en",
-    },
+async function runMachine(label, runArgs, stdin = "") {
+  const command = [cliPath, "run", ...runArgs];
+  const output = await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, command, {
+      cwd: home,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        AGINTIFLOW_HOME: path.join(home, ".agintiflow"),
+        AGINTIFLOW_RUNTIME_DIR: "",
+        AGINTIFLOW_NO_WEB_AUTO_START: "1",
+        AGINTI_LANGUAGE: "en",
+      },
+    });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${label} timed out\nstdout=${stdout}\nstderr=${stderr}`));
+    }, process.env.CI ? 90000 : 45000);
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code, stdout, stderr });
+    });
+    child.stdin.end(stdin);
   });
-  let stdout = "";
-  let stderr = "";
-  const timer = setTimeout(() => {
-    child.kill("SIGKILL");
-    reject(new Error(`machine run timed out\nstdout=${stdout}\nstderr=${stderr}`));
-  }, process.env.CI ? 90000 : 45000);
-  child.stdout.on("data", (chunk) => {
-    stdout += String(chunk);
-  });
-  child.stderr.on("data", (chunk) => {
-    stderr += String(chunk);
-  });
-  child.on("error", reject);
-  child.on("close", (code) => {
-    clearTimeout(timer);
-    resolve({ code, stdout, stderr });
-  });
-  child.stdin.end("Reply briefly that the machine transport smoke completed.");
-});
 
-const lines = output.stdout.trim().split(/\r?\n/).filter(Boolean);
-if (output.code !== 0) throw new Error(`machine run exited ${output.code}\n${output.stdout}\n${output.stderr}`);
-if (lines.length !== 1) throw new Error(`machine run emitted ${lines.length} stdout lines\n${output.stdout}`);
-const payload = JSON.parse(lines[0]);
-if (payload.ok !== true || !String(payload.result || "").trim()) {
-  throw new Error(`machine run returned an unusable payload\n${output.stdout}`);
+  const lines = output.stdout.trim().split(/\r?\n/).filter(Boolean);
+  if (output.code !== 0) throw new Error(`${label} exited ${output.code}\n${output.stdout}\n${output.stderr}`);
+  if (lines.length !== 1) throw new Error(`${label} emitted ${lines.length} stdout lines\n${output.stdout}`);
+  const payload = JSON.parse(lines[0]);
+  if (payload.ok !== true || !String(payload.result || "").trim()) {
+    throw new Error(`${label} returned an unusable payload\n${output.stdout}`);
+  }
+  if (/(?:^|\n)(?:Session|Provider|Model|Routing|Workspace|Plan):/i.test(output.stdout)) {
+    throw new Error(`${label} leaked interactive metadata\n${output.stdout}`);
+  }
+  if (output.stderr.trim()) throw new Error(`${label} leaked stderr\n${output.stderr}`);
 }
-if (/(?:^|\n)(?:Session|Provider|Model|Routing|Workspace|Plan):/i.test(output.stdout)) {
-  throw new Error(`machine run leaked interactive metadata\n${output.stdout}`);
+
+try {
+  await runMachine(
+    "explicit stdin machine run",
+    ["--stdin", ...machineOptions],
+    "Reply briefly that the explicit stdin transport smoke completed."
+  );
+  await runMachine(
+    "positional prompt machine run",
+    [...machineOptions, "Reply briefly that the positional prompt smoke completed."]
+  );
+  await runMachine(
+    "implicit piped stdin machine run",
+    machineOptions,
+    "Reply briefly that the implicit piped stdin smoke completed."
+  );
+} finally {
+  await fs.rm(home, { recursive: true, force: true });
 }
-if (output.stderr.trim()) throw new Error(`machine run leaked stderr\n${output.stderr}`);
 
-console.log("run stdin smoke passed");
+console.log("run input precedence smoke passed");

package/scripts/smoke-runtime-core.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-runtime-core-"));
+const originalHome = process.env.AGINTIFLOW_HOME;
+const originalHousekeeping = process.env.AGINTIFLOW_HOUSEKEEPING;
+process.env.AGINTIFLOW_HOUSEKEEPING = "0";
+
+const {
+  closeSessionIndexConnections,
+  listSessionIndex,
+  sessionIndexConnectionCount,
+  upsertSessionIndex,
+} = await import("../src/session-index.js");
+const { SessionStore } = await import("../src/session-store.js");
+
+try {
+  const firstHome = path.join(tempRoot, "home-one");
+  const firstProject = path.join(tempRoot, "project-one");
+  process.env.AGINTIFLOW_HOME = firstHome;
+
+  const indexStartedAt = performance.now();
+  for (let index = 0; index < 200; index += 1) {
+    assert.equal(
+      upsertSessionIndex({
+        sessionId: `runtime-${index}`,
+        projectRoot: firstProject,
+        commandCwd: firstProject,
+        status: "running",
+        goal: `runtime smoke ${index}`,
+      }),
+      true
+    );
+  }
+  const indexElapsedMs = performance.now() - indexStartedAt;
+  assert.equal(sessionIndexConnectionCount(), 1, "one runtime home should reuse one SQLite connection");
+  const firstRows = listSessionIndex({ projectRoot: firstProject, commandCwd: firstProject, limit: 500 });
+  assert.equal(firstRows.length, 200, "cached prepared queries lost indexed sessions");
+
+  const secondHome = path.join(tempRoot, "home-two");
+  const secondProject = path.join(tempRoot, "project-two");
+  process.env.AGINTIFLOW_HOME = secondHome;
+  assert.equal(
+    upsertSessionIndex({
+      sessionId: "other-home",
+      projectRoot: secondProject,
+      commandCwd: secondProject,
+      status: "saved",
+    }),
+    true
+  );
+  assert.equal(sessionIndexConnectionCount(), 2, "separate runtime homes must not share a SQLite connection");
+  assert.equal(listSessionIndex({ projectRoot: secondProject }).length, 1);
+  assert.equal(listSessionIndex({ projectRoot: firstProject }).length, 0, "runtime homes leaked index records");
+
+  process.env.AGINTIFLOW_HOME = firstHome;
+  const store = new SessionStore(path.join(firstHome, "sessions"), "event-order");
+  const eventStartedAt = performance.now();
+  await Promise.all(
+    Array.from({ length: 100 }, (_, index) => store.appendEvent("runtime.smoke", { index }))
+  );
+  const eventElapsedMs = performance.now() - eventStartedAt;
+  const events = await store.loadEvents();
+  assert.equal(events.length, 100, "concurrent appends lost or duplicated session events");
+  assert.deepEqual(
+    events.map((event) => event.data.index),
+    Array.from({ length: 100 }, (_, index) => index),
+    "concurrent session events were persisted out of order"
+  );
+
+  const missingStore = new SessionStore(path.join(firstHome, "sessions"), "missing-state");
+  assert.equal(await missingStore.loadState(), null, "an absent session state should remain resumably absent");
+
+  const corruptStore = new SessionStore(path.join(firstHome, "sessions"), "corrupt-state");
+  await fs.mkdir(corruptStore.sessionDir, { recursive: true });
+  await fs.writeFile(corruptStore.statePath, "{not-json\n", "utf8");
+  await assert.rejects(
+    corruptStore.loadState(),
+    (error) => error?.code === "SESSION_STATE_CORRUPT" && error?.name === "SessionStateCorruptionError",
+    "malformed session state must fail visibly instead of appearing missing"
+  );
+
+  closeSessionIndexConnections();
+  assert.equal(sessionIndexConnectionCount(), 0, "session index connections did not close cleanly");
+  console.log(
+    `runtime core smoke passed (200 index writes ${indexElapsedMs.toFixed(1)}ms; 100 ordered events ${eventElapsedMs.toFixed(1)}ms)`
+  );
+} finally {
+  closeSessionIndexConnections();
+  if (originalHome === undefined) delete process.env.AGINTIFLOW_HOME;
+  else process.env.AGINTIFLOW_HOME = originalHome;
+  if (originalHousekeeping === undefined) delete process.env.AGINTIFLOW_HOUSEKEEPING;
+  else process.env.AGINTIFLOW_HOUSEKEEPING = originalHousekeeping;
+  await fs.rm(tempRoot, { recursive: true, force: true });
+}

package/src/agent-runner.js

@@ -326,7 +326,11 @@ function compactJson(value, limit = 1200) {
 function compactMultiline(value = "", limit = 3600) {
   const text = redactSensitiveText(String(value || ""));
   if (!limit || text.length <= limit) return text;
-  return `${text.slice(0, Math.max(0, limit - 80)).trimEnd()}\n... [truncated ${text.length - limit + 80} chars]`;
+  const marker = `\n... [${text.length - limit} chars omitted] ...\n`;
+  const available = Math.max(0, limit - marker.length);
+  const head = Math.floor(available * 0.35);
+  const tail = Math.max(0, available - head);
+  return `${text.slice(0, head).trimEnd()}${marker}${text.slice(-tail).trimStart()}`;
 }
 
 function safeParseToolContent(content) {
@@ -379,7 +383,9 @@ function summarizeOriginalRequests(messages = [], limit = 6) {
     if (/^Previous assistant response retained as compacted history/i.test(content)) continue;
     requests.push(compactSingleLine(content, 1200));
   }
-  return [...new Set(requests)].slice(0, limit);
+  const unique = [...new Set(requests)];
+  if (unique.length <= limit) return unique;
+  return [unique[0], ...unique.slice(-(limit - 1))];
 }
 
 function countMessageChars(messages = []) {
@@ -393,7 +399,13 @@ function modelTimeoutMsForConfig(config = {}) {
 
 function buildCompactedRuntimeMessages(state, config, snapshot, step, options = {}) {
   const messages = Array.isArray(state?.messages) ? state.messages : [];
-  const systemMessages = messages.filter((message) => message?.role === "system").slice(0, 4);
+  const systemMessages = messages
+    .filter((message) => message?.role === "system")
+    .slice(0, 3)
+    .map((message) => ({
+      ...message,
+      content: compactMultiline(message.content, 12000),
+    }));
   const requests = summarizeOriginalRequests(messages);
   const toolHistory = summarizeToolHistory(messages);
   const snapshotSummary = {
@@ -472,6 +484,10 @@ function isModelTimeoutError(error) {
   return error?.name === "ModelTimeoutError" || /timed out after \d+ms/i.test(String(error?.message || ""));
 }
 
+function isLocalContextBudgetError(error) {
+  return error?.name === "LocalContextBudgetError" || error?.code === "LOCALLLM_CONTEXT_BUDGET_EXCEEDED";
+}
+
 export function repairModelMessageHistory(state, config = {}) {
   if (!Array.isArray(state?.messages)) {
     return {
@@ -3438,39 +3454,83 @@ export async function runAgent(config) {
         response = await requestNextStep(client, config, state.messages);
       } catch (error) {
         const retryKey = `step-${step}`;
-        const retriedSteps = state.meta.modelTimeoutRetries || {};
-        if (!isModelTimeoutError(error) || retriedSteps[retryKey]) throw error;
+        const contextRetriedSteps = state.meta.localContextBudgetRetries || {};
+        if (isLocalContextBudgetError(error) && !contextRetriedSteps[retryKey]) {
+          const compactMessages = buildContextBudgetCompactionMessages(
+            state,
+            config,
+            snapshot,
+            step,
+            {
+              reason: redactSensitiveText(
+                error instanceof Error ? error.message : String(error)
+              ),
+            }
+          );
+          const detail = {
+            step,
+            provider: config.provider,
+            model: config.model,
+            messageCharsBefore: countMessageChars(state.messages),
+            messageCharsAfter: countMessageChars(compactMessages),
+            messageTokensBefore: estimateMessageTokens(state.messages),
+            messageTokensAfter: estimateMessageTokens(compactMessages),
+            error: redactSensitiveText(
+              error instanceof Error ? error.message : String(error)
+            ),
+          };
+          state.messages = compactMessages;
+          state.meta.localContextBudgetRetries = {
+            ...contextRetriedSteps,
+            [retryKey]: true,
+          };
+          state.meta.lastLocalContextBudgetRecovery = detail;
+          await store.appendEvent("model.local_context_budget_exceeded", detail);
+          await store.appendEvent("history.compacted_for_local_context_retry", detail);
+          observers.event("model.local_context_budget_exceeded", detail);
+          observers.event("history.compacted_for_local_context_retry", detail);
+          emitConsole(
+            config,
+            `Local provider context exceeded its configured window at step ${step}; compacted authoritative context and retrying once.`,
+            { kind: "meta" }
+          );
+          await store.saveState(state);
+          response = await requestNextStep(client, config, state.messages);
+        } else {
+          const retriedSteps = state.meta.modelTimeoutRetries || {};
+          if (!isModelTimeoutError(error) || retriedSteps[retryKey]) throw error;
 
-        const timeoutMs = modelTimeoutMsForConfig(config);
-        const retryTimeoutMs = Math.max(timeoutMs * 2, 180000);
-        const compactMessages = buildModelTimeoutRetryMessages(state, config, snapshot, step, error);
-        const detail = {
-          step,
-          provider: config.provider,
-          model: config.model,
-          timeoutMs,
-          retryTimeoutMs,
-          messageCharsBefore: countMessageChars(state.messages),
-          messageCharsAfter: countMessageChars(compactMessages),
-          error: redactSensitiveText(error instanceof Error ? error.message : String(error)),
-        };
-        state.messages = compactMessages;
-        state.meta.modelTimeoutRetries = {
-          ...retriedSteps,
-          [retryKey]: true,
-        };
-        state.meta.lastModelTimeout = detail;
-        await store.appendEvent("model.timeout", detail);
-        await store.appendEvent("history.compacted_for_model_retry", detail);
-        observers.event("model.timeout", detail);
-        observers.event("history.compacted_for_model_retry", detail);
-        emitConsole(
-          config,
-          `Model request timed out after ${timeoutMs}ms; compacted history and retrying once with ${retryTimeoutMs}ms.`,
-          { kind: "meta" }
-        );
-        await store.saveState(state);
-        response = await requestNextStep(client, { ...config, modelTimeoutMs: retryTimeoutMs }, state.messages);
+          const timeoutMs = modelTimeoutMsForConfig(config);
+          const retryTimeoutMs = Math.max(timeoutMs * 2, 180000);
+          const compactMessages = buildModelTimeoutRetryMessages(state, config, snapshot, step, error);
+          const detail = {
+            step,
+            provider: config.provider,
+            model: config.model,
+            timeoutMs,
+            retryTimeoutMs,
+            messageCharsBefore: countMessageChars(state.messages),
+            messageCharsAfter: countMessageChars(compactMessages),
+            error: redactSensitiveText(error instanceof Error ? error.message : String(error)),
+          };
+          state.messages = compactMessages;
+          state.meta.modelTimeoutRetries = {
+            ...retriedSteps,
+            [retryKey]: true,
+          };
+          state.meta.lastModelTimeout = detail;
+          await store.appendEvent("model.timeout", detail);
+          await store.appendEvent("history.compacted_for_model_retry", detail);
+          observers.event("model.timeout", detail);
+          observers.event("history.compacted_for_model_retry", detail);
+          emitConsole(
+            config,
+            `Model request timed out after ${timeoutMs}ms; compacted history and retrying once with ${retryTimeoutMs}ms.`,
+            { kind: "meta" }
+          );
+          await store.saveState(state);
+          response = await requestNextStep(client, { ...config, modelTimeoutMs: retryTimeoutMs }, state.messages);
+        }
       }
       const assistantMessage = response.choices[0]?.message;
       if (!assistantMessage) {

package/src/cli.js

@@ -2398,7 +2398,12 @@ export async function main(argv = process.argv.slice(2)) {
     const optionArgv = runArgv.filter((arg) => !["--stdin", "--json"].includes(arg));
     const parsedRunArgs = parseArgs(optionArgv);
     exitOnUnknownOptions(parsedRunArgs);
-    const prompt = stdinFlag || !process.stdin.isTTY ? await readStdin() : parsedRunArgs.goal;
+    let prompt = parsedRunArgs.goal;
+    if (stdinFlag) {
+      prompt = await readStdin();
+    } else if (!prompt && !process.stdin.isTTY) {
+      prompt = await readStdin();
+    }
     if (!prompt) {
       if (jsonFlag) {
         console.log(JSON.stringify({ ok: false, result: "", reason: "empty_prompt" }));

package/src/context-budget-controller.js

@@ -49,6 +49,37 @@ export function estimateTextTokens(value = "") {
   return Math.ceil(ascii / 3) + Math.ceil(nonAscii * 1.5);
 }
 
+export function compactTextForTokenBudget(value = "", maxTokens = 0, options = {}) {
+  const text = String(value ?? "");
+  const budget = positiveInteger(maxTokens, 0);
+  if (!budget || estimateTextTokens(text) <= budget) return text;
+
+  const headFraction = Math.min(0.8, Math.max(0.2, Number(options.headFraction ?? 0.35)));
+  const buildCandidate = (keptChars) => {
+    const kept = Math.max(0, Math.min(text.length, Math.floor(keptChars)));
+    const headChars = Math.floor(kept * headFraction);
+    const tailChars = Math.max(0, kept - headChars);
+    const omitted = Math.max(0, text.length - headChars - tailChars);
+    const marker = `\n\n[... ${omitted} chars omitted to fit the provider context ...]\n\n`;
+    return `${text.slice(0, headChars).trimEnd()}${marker}${text.slice(text.length - tailChars).trimStart()}`;
+  };
+
+  let low = 0;
+  let high = text.length;
+  let best = "[... content omitted to fit the provider context ...]";
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const candidate = buildCandidate(middle);
+    if (estimateTextTokens(candidate) <= budget) {
+      best = candidate;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return best;
+}
+
 export function estimateMessageTokens(messages = []) {
   return (Array.isArray(messages) ? messages : []).reduce((total, message) => {
     let count = 6 + estimateTextTokens(message?.role || "") + estimateTextTokens(message?.content || "");

package/src/model-client.js

@@ -19,7 +19,11 @@ import {
   providerSupportsReasoningEffort,
 } from "./provider-contract.js";
 import { selectProgressiveTools } from "./progressive-tool-selection.js";
-import { estimateMessageTokens, estimateToolSchemaTokens } from "./context-budget-controller.js";
+import {
+  compactTextForTokenBudget,
+  estimateMessageTokens,
+  estimateToolSchemaTokens,
+} from "./context-budget-controller.js";
 import { attachToolContract } from "./tool-contract.js";
 
 export function createClient(config) {
@@ -834,6 +838,14 @@ export async function createPlan(client, config, state) {
   const planMaxTokens = normalizeProviderId(config.provider, "") === "localllm"
     ? Math.min(2048, Number(config.maxOutputTokens || 2048))
     : 0;
+  const localContextWindow = Number(config.contextWindowTokens || 32768);
+  const planGoal = planMaxTokens > 0
+    ? compactTextForTokenBudget(
+        state.goal,
+        Math.max(2048, Math.min(8192, Math.floor(localContextWindow * 0.3))),
+        { headFraction: 0.3 }
+      )
+    : state.goal;
   const planPayload = {
       model: config.model,
       temperature: 0,
@@ -846,7 +858,7 @@ export async function createPlan(client, config, state) {
       {
         role: "user",
         content: [
-          `Goal: ${state.goal}`,
+          `Goal: ${planGoal}`,
           state.startUrl ? `Suggested start URL: ${state.startUrl}` : "",
           config.allowedDomains.length > 0 ? `Allowed domains: ${config.allowedDomains.join(", ")}` : "",
           config.allowShellTool
@@ -912,9 +924,33 @@ export async function createPlan(client, config, state) {
       },
       ],
       ...(planMaxTokens > 0 ? { max_tokens: planMaxTokens } : {}),
-    };
+  };
   const planConfig = planMaxTokens > 0 ? { ...config, maxOutputTokens: planMaxTokens } : config;
-  assertLocalRequestWithinContext(planPayload, planConfig, "plan request");
+  try {
+    assertLocalRequestWithinContext(planPayload, planConfig, "plan request");
+  } catch (error) {
+    if (error?.name !== "LocalContextBudgetError") throw error;
+    const minimalGoal = compactTextForTokenBudget(state.goal, 4096, { headFraction: 0.3 });
+    planPayload.messages = [
+      {
+        role: "system",
+        content:
+          "Plan one exact agent task in 3 to 6 concise steps. Use the established project routines and tools; do not redesign a mature workflow. Preserve current intent, later interruptions, safety gates, and requested artifacts.",
+      },
+      {
+        role: "user",
+        content: [
+          `Goal: ${minimalGoal}`,
+          `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
+          projectInstructions?.exists
+            ? `Project instructions are available at ${projectInstructions.path}; read them when executing.`
+            : "Read AGENTS.md/README and the exact routine contract when present.",
+          "Return a numbered plan only.",
+        ].join("\n"),
+      },
+    ];
+    assertLocalRequestWithinContext(planPayload, planConfig, "compacted plan request");
+  }
   const response = await createChatCompletion(client, planPayload, planConfig, "plan request");
 
   return redactSensitiveText(response.choices[0]?.message?.content?.trim() || "1. Inspect the page.\n2. Use the smallest safe action.\n3. Finish with a concise answer.");

package/src/scs-evidence.js

@@ -495,29 +495,48 @@ function stripForbiddenLanguage(goal = "") {
     .replace(/禁止([^。\n；]+)/g, "");
 }
 
+function scopedChatopsEvidenceGoal(goal = "", taskProfile = "") {
+  if (String(taskProfile || "").trim().toLowerCase() !== "chatops") return String(goal || "");
+  const match = String(goal || "").match(/^AGINTI_EVIDENCE_SCOPE_JSON:\s*(\{[^\n]+\})\s*$/m);
+  if (!match) return String(goal || "");
+  try {
+    const payload = JSON.parse(match[1]);
+    if (!payload || typeof payload !== "object") return String(goal || "");
+    const mode = String(payload.mode || "").trim().toLowerCase();
+    if (mode === "chat-response") {
+      return "Answer the current chat turn directly without external execution.";
+    }
+    const request = String(payload.request || "").trim();
+    return request || String(goal || "");
+  } catch {
+    return String(goal || "");
+  }
+}
+
 export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceCriteria = [] } = {}) {
-  const requirementCategories = inferRequirementCategories(goal, taskProfile, acceptanceCriteria);
-  const requiredToolCalls = inferRequiredToolCalls(goal);
-  const requiresExternalEvidence = requirementCategories.length > 0 || requiredToolCalls.length > 0 || goalRequiresEvidence(goal, taskProfile);
+  const evidenceGoal = scopedChatopsEvidenceGoal(goal, taskProfile);
+  const requirementCategories = inferRequirementCategories(evidenceGoal, taskProfile, acceptanceCriteria);
+  const requiredToolCalls = inferRequiredToolCalls(evidenceGoal);
+  const requiresExternalEvidence = requirementCategories.length > 0 || requiredToolCalls.length > 0 || goalRequiresEvidence(evidenceGoal, taskProfile);
   const requiredEvidence = requirementCategories.map((category) => ({
     id: category,
     category,
     description: CATEGORY_LABELS[category] || category,
   }));
-  const exactOutputPaths = inferExactOutputPaths(goal);
-  const exactInputPaths = inferExactInputPaths(goal).filter((item) => !exactOutputPaths.includes(item));
+  const exactOutputPaths = inferExactOutputPaths(evidenceGoal);
+  const exactInputPaths = inferExactInputPaths(evidenceGoal).filter((item) => !exactOutputPaths.includes(item));
   return {
     version: 1,
-    outcome: compact(goal || "Complete the requested task.", 500),
+    outcome: compact(evidenceGoal || "Complete the requested task.", 500),
     taskProfile: String(taskProfile || "auto"),
     requiresExternalEvidence,
     requiredEvidence,
-    forbiddenActions: inferForbiddenActions(goal),
+    forbiddenActions: inferForbiddenActions(evidenceGoal),
     exactOutputPaths,
     exactInputPaths,
     requiredToolCalls,
-    requiredTextTerms: inferRequiredTextTerms(goal),
-    forbiddenTextTerms: inferForbiddenTextTerms(goal),
+    requiredTextTerms: inferRequiredTextTerms(evidenceGoal),
+    forbiddenTextTerms: inferForbiddenTextTerms(evidenceGoal),
     successCriteria: unique(acceptanceCriteria).slice(0, 10),
   };
 }

package/src/session-index.js

@@ -6,6 +6,11 @@ import { loadDatabaseSync } from "./sqlite.js";
 export const PROJECT_SESSIONS_DIR_NAME = ".aginti-sessions";
 export const LEGACY_PROJECT_SESSIONS_DIR_NAME = ".sessions";
 
+const SESSION_COLUMNS = `session_id AS sessionId, project_root AS projectRoot, command_cwd AS commandCwd, project_sessions_dir AS projectSessionsDir,
+  session_dir AS sessionDir, provider, model, goal, title, status,
+  created_at AS createdAt, updated_at AS updatedAt, ended_at AS endedAt, result, error`;
+const indexDbConnections = new Map();
+
 export function agintiflowHome() {
   return path.resolve(process.env.AGINTIFLOW_HOME || path.join(os.homedir(), ".agintiflow"));
 }
@@ -29,34 +34,106 @@ export function isSafeSessionId(sessionId) {
 
 function ensureIndexDb() {
   const paths = globalSessionPaths();
+  if (indexDbConnections.has(paths.indexDbPath)) return indexDbConnections.get(paths.indexDbPath);
   fs.mkdirSync(paths.sessionsDir, { recursive: true });
   const DatabaseSync = loadDatabaseSync({ optional: true });
-  if (!DatabaseSync) return null;
+  if (!DatabaseSync) {
+    indexDbConnections.set(paths.indexDbPath, null);
+    return null;
+  }
   const db = new DatabaseSync(paths.indexDbPath);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS sessions (
-      session_id TEXT PRIMARY KEY,
-      project_root TEXT NOT NULL DEFAULT '',
-      command_cwd TEXT NOT NULL DEFAULT '',
-      project_sessions_dir TEXT NOT NULL DEFAULT '',
-      session_dir TEXT NOT NULL DEFAULT '',
-      provider TEXT NOT NULL DEFAULT '',
-      model TEXT NOT NULL DEFAULT '',
-      goal TEXT NOT NULL DEFAULT '',
-      title TEXT NOT NULL DEFAULT '',
-      status TEXT NOT NULL DEFAULT '',
-      created_at TEXT NOT NULL DEFAULT '',
-      updated_at TEXT NOT NULL DEFAULT '',
-      ended_at TEXT,
-      result TEXT NOT NULL DEFAULT '',
-      error TEXT NOT NULL DEFAULT ''
-    );
-  `);
-  const existingColumns = db.prepare("PRAGMA table_info(sessions)").all();
-  if (!existingColumns.some((column) => column.name === "command_cwd")) {
-    db.exec("ALTER TABLE sessions ADD COLUMN command_cwd TEXT NOT NULL DEFAULT ''");
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        project_root TEXT NOT NULL DEFAULT '',
+        command_cwd TEXT NOT NULL DEFAULT '',
+        project_sessions_dir TEXT NOT NULL DEFAULT '',
+        session_dir TEXT NOT NULL DEFAULT '',
+        provider TEXT NOT NULL DEFAULT '',
+        model TEXT NOT NULL DEFAULT '',
+        goal TEXT NOT NULL DEFAULT '',
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL DEFAULT '',
+        ended_at TEXT,
+        result TEXT NOT NULL DEFAULT '',
+        error TEXT NOT NULL DEFAULT ''
+      );
+    `);
+    const existingColumns = db.prepare("PRAGMA table_info(sessions)").all();
+    if (!existingColumns.some((column) => column.name === "command_cwd")) {
+      try {
+        db.exec("ALTER TABLE sessions ADD COLUMN command_cwd TEXT NOT NULL DEFAULT ''");
+      } catch (error) {
+        const migratedColumns = db.prepare("PRAGMA table_info(sessions)").all();
+        if (!migratedColumns.some((column) => column.name === "command_cwd")) throw error;
+      }
+    }
+
+    const connection = {
+      db,
+      upsert: db.prepare(
+        `INSERT INTO sessions (
+           session_id, project_root, command_cwd, project_sessions_dir, session_dir,
+           provider, model, goal, title, status, created_at, updated_at, ended_at, result, error
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(session_id) DO UPDATE SET
+           project_root = CASE WHEN excluded.project_root != '' THEN excluded.project_root ELSE sessions.project_root END,
+           command_cwd = CASE WHEN excluded.command_cwd != '' THEN excluded.command_cwd ELSE sessions.command_cwd END,
+           project_sessions_dir = CASE WHEN excluded.project_sessions_dir != '' THEN excluded.project_sessions_dir ELSE sessions.project_sessions_dir END,
+           session_dir = CASE WHEN excluded.session_dir != '' THEN excluded.session_dir ELSE sessions.session_dir END,
+           provider = CASE WHEN excluded.provider != '' THEN excluded.provider ELSE sessions.provider END,
+           model = CASE WHEN excluded.model != '' THEN excluded.model ELSE sessions.model END,
+           goal = CASE WHEN excluded.goal != '' THEN excluded.goal ELSE sessions.goal END,
+           title = CASE WHEN excluded.title != '' THEN excluded.title ELSE sessions.title END,
+           status = CASE WHEN excluded.status != '' THEN excluded.status ELSE sessions.status END,
+           updated_at = excluded.updated_at,
+           ended_at = excluded.ended_at,
+           result = CASE WHEN excluded.result != '' THEN excluded.result ELSE sessions.result END,
+           error = CASE WHEN excluded.error != '' THEN excluded.error ELSE sessions.error END`
+      ),
+      rename: db.prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE session_id = ?"),
+      remove: db.prepare("DELETE FROM sessions WHERE session_id = ?"),
+      listAll: db.prepare(`SELECT ${SESSION_COLUMNS} FROM sessions ORDER BY updated_at DESC LIMIT ?`),
+      listByProjectRoot: db.prepare(
+        `SELECT ${SESSION_COLUMNS} FROM sessions WHERE project_root = ? ORDER BY updated_at DESC LIMIT ?`
+      ),
+      listByCommandCwd: db.prepare(
+        `SELECT ${SESSION_COLUMNS} FROM sessions WHERE command_cwd = ? ORDER BY updated_at DESC LIMIT ?`
+      ),
+      listByProjectAndCwd: db.prepare(
+        `SELECT ${SESSION_COLUMNS} FROM sessions WHERE project_root = ? AND command_cwd = ? ORDER BY updated_at DESC LIMIT ?`
+      ),
+    };
+    indexDbConnections.set(paths.indexDbPath, connection);
+    return connection;
+  } catch (error) {
+    try {
+      db.close();
+    } catch {
+      // Preserve the initialization error.
+    }
+    throw error;
+  }
+}
+
+export function sessionIndexConnectionCount() {
+  return [...indexDbConnections.values()].filter(Boolean).length;
+}
+
+export function closeSessionIndexConnections() {
+  for (const connection of indexDbConnections.values()) {
+    try {
+      connection?.db.close();
+    } catch {
+      // Closing is best effort during tests and process shutdown.
+    }
   }
-  return db;
+  indexDbConnections.clear();
 }
 
 function emptyIndexState() {
@@ -115,9 +192,9 @@ function normalizeIndexRecord(record = {}, sessionId = "") {
 export function upsertSessionIndex(record = {}) {
   const sessionId = String(record.sessionId || record.session_id || "").trim();
   if (!isSafeSessionId(sessionId)) return false;
-  const db = ensureIndexDb();
+  const index = ensureIndexDb();
   const normalized = normalizeIndexRecord(record, sessionId);
-  if (!db) {
+  if (!index) {
     const state = readIndexJson();
     const previous = state.sessions[sessionId] || {};
     state.sessions[sessionId] = {
@@ -139,26 +216,7 @@ export function upsertSessionIndex(record = {}) {
     return true;
   }
   const paths = globalSessionPaths(sessionId);
-  db.prepare(
-    `INSERT INTO sessions (
-       session_id, project_root, command_cwd, project_sessions_dir, session_dir,
-       provider, model, goal, title, status, created_at, updated_at, ended_at, result, error
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(session_id) DO UPDATE SET
-       project_root = CASE WHEN excluded.project_root != '' THEN excluded.project_root ELSE sessions.project_root END,
-       command_cwd = CASE WHEN excluded.command_cwd != '' THEN excluded.command_cwd ELSE sessions.command_cwd END,
-       project_sessions_dir = CASE WHEN excluded.project_sessions_dir != '' THEN excluded.project_sessions_dir ELSE sessions.project_sessions_dir END,
-       session_dir = CASE WHEN excluded.session_dir != '' THEN excluded.session_dir ELSE sessions.session_dir END,
-       provider = CASE WHEN excluded.provider != '' THEN excluded.provider ELSE sessions.provider END,
-       model = CASE WHEN excluded.model != '' THEN excluded.model ELSE sessions.model END,
-       goal = CASE WHEN excluded.goal != '' THEN excluded.goal ELSE sessions.goal END,
-       title = CASE WHEN excluded.title != '' THEN excluded.title ELSE sessions.title END,
-       status = CASE WHEN excluded.status != '' THEN excluded.status ELSE sessions.status END,
-       updated_at = excluded.updated_at,
-       ended_at = excluded.ended_at,
-       result = CASE WHEN excluded.result != '' THEN excluded.result ELSE sessions.result END,
-       error = CASE WHEN excluded.error != '' THEN excluded.error ELSE sessions.error END`
-  ).run(
+  index.upsert.run(
     sessionId,
     normalized.projectRoot,
     normalized.commandCwd,
@@ -180,8 +238,8 @@ export function upsertSessionIndex(record = {}) {
 
 export function renameSessionIndex(sessionId, title) {
   if (!isSafeSessionId(sessionId)) return false;
-  const db = ensureIndexDb();
-  if (!db) {
+  const index = ensureIndexDb();
+  if (!index) {
     const state = readIndexJson();
     if (!state.sessions[sessionId]) return false;
     state.sessions[sessionId].title = String(title || "").trim();
@@ -189,30 +247,28 @@ export function renameSessionIndex(sessionId, title) {
     writeIndexJson(state);
     return true;
   }
-  const result = db
-    .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE session_id = ?")
-    .run(String(title || "").trim(), new Date().toISOString(), sessionId);
+  const result = index.rename.run(String(title || "").trim(), new Date().toISOString(), sessionId);
   return result.changes > 0;
 }
 
 export function deleteSessionIndex(sessionId) {
   if (!isSafeSessionId(sessionId)) return false;
-  const db = ensureIndexDb();
-  if (!db) {
+  const index = ensureIndexDb();
+  if (!index) {
     const state = readIndexJson();
     if (!state.sessions[sessionId]) return false;
     delete state.sessions[sessionId];
     writeIndexJson(state);
     return true;
   }
-  const result = db.prepare("DELETE FROM sessions WHERE session_id = ?").run(sessionId);
+  const result = index.remove.run(sessionId);
   return result.changes > 0;
 }
 
 export function listSessionIndex({ projectRoot = "", commandCwd = "", limit = 100 } = {}) {
-  const db = ensureIndexDb();
+  const index = ensureIndexDb();
   const maxRows = Math.min(Math.max(Number(limit) || 100, 1), 1000);
-  if (!db) {
+  if (!index) {
     const resolvedProjectRoot = projectRoot ? path.resolve(projectRoot) : "";
     const resolvedCommandCwd = commandCwd ? path.resolve(commandCwd) : "";
     return Object.values(readIndexJson().sessions)
@@ -224,23 +280,12 @@ export function listSessionIndex({ projectRoot = "", commandCwd = "", limit = 10
       .sort((left, right) => String(right.updatedAt || "").localeCompare(String(left.updatedAt || "")))
       .slice(0, maxRows);
   }
-  const columns = `session_id AS sessionId, project_root AS projectRoot, command_cwd AS commandCwd, project_sessions_dir AS projectSessionsDir,
-    session_dir AS sessionDir, provider, model, goal, title, status,
-    created_at AS createdAt, updated_at AS updatedAt, ended_at AS endedAt, result, error`;
-  const clauses = [];
-  const params = [];
-  if (projectRoot) {
-    clauses.push("project_root = ?");
-    params.push(path.resolve(projectRoot));
-  }
-  if (commandCwd) {
-    clauses.push("command_cwd = ?");
-    params.push(path.resolve(commandCwd));
-  }
-  if (clauses.length > 0) {
-    return db
-      .prepare(`SELECT ${columns} FROM sessions WHERE ${clauses.join(" AND ")} ORDER BY updated_at DESC LIMIT ?`)
-      .all(...params, maxRows);
+  const resolvedProjectRoot = projectRoot ? path.resolve(projectRoot) : "";
+  const resolvedCommandCwd = commandCwd ? path.resolve(commandCwd) : "";
+  if (resolvedProjectRoot && resolvedCommandCwd) {
+    return index.listByProjectAndCwd.all(resolvedProjectRoot, resolvedCommandCwd, maxRows);
   }
-  return db.prepare(`SELECT ${columns} FROM sessions ORDER BY updated_at DESC LIMIT ?`).all(maxRows);
+  if (resolvedProjectRoot) return index.listByProjectRoot.all(resolvedProjectRoot, maxRows);
+  if (resolvedCommandCwd) return index.listByCommandCwd.all(resolvedCommandCwd, maxRows);
+  return index.listAll.all(maxRows);
 }

package/src/session-store.js

@@ -75,6 +75,26 @@ async function appendDurably(filePath, content) {
   if (!existed) await syncDirectory(directoryPath);
 }
 
+async function loadStateFile(filePath) {
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const corruptionError = new Error(`Session state is not valid JSON: ${filePath}`);
+    corruptionError.name = "SessionStateCorruptionError";
+    corruptionError.code = "SESSION_STATE_CORRUPT";
+    corruptionError.cause = error;
+    throw corruptionError;
+  }
+}
+
 function inboxItemKey(item = {}) {
   const id = String(item.id || "").trim();
   if (id) return `id:${id}`;
@@ -167,11 +187,23 @@ export class SessionStore {
       DEFAULT_INBOX_COMPACTION_BYTE_THRESHOLD
     );
     this.inboxLockTimeoutMs = positiveInteger(options.inboxLockTimeoutMs, DEFAULT_INBOX_LOCK_TIMEOUT_MS);
+    this.ensurePromise = null;
+    this.eventAppendTail = Promise.resolve();
   }
 
   async ensure() {
-    await fs.mkdir(this.artifactsDir, { recursive: true });
-    await this.writePointer().catch(() => {});
+    if (!this.ensurePromise) {
+      this.ensurePromise = (async () => {
+        await fs.mkdir(this.artifactsDir, { recursive: true });
+        await this.writePointer().catch(() => {});
+      })();
+    }
+    try {
+      await this.ensurePromise;
+    } catch (error) {
+      this.ensurePromise = null;
+      throw error;
+    }
   }
 
   async writePointer(state = {}) {
@@ -196,20 +228,10 @@ export class SessionStore {
   }
 
   async loadState() {
-    try {
-      const raw = await fs.readFile(this.statePath, "utf8");
-      return JSON.parse(raw);
-    } catch {
-      if (this.legacySessionDir) {
-        try {
-          const raw = await fs.readFile(path.join(this.legacySessionDir, "state.json"), "utf8");
-          return JSON.parse(raw);
-        } catch {
-          return null;
-        }
-      }
-      return null;
-    }
+    const currentState = await loadStateFile(this.statePath);
+    if (currentState !== null) return currentState;
+    if (!this.legacySessionDir) return null;
+    return loadStateFile(path.join(this.legacySessionDir, "state.json"));
   }
 
   async saveState(state) {
@@ -248,20 +270,24 @@ export class SessionStore {
   }
 
   async appendEvent(type, data = {}) {
-    await this.ensure();
-    const event = {
-      timestamp: new Date().toISOString(),
-      type,
-      data,
-    };
-    const line = JSON.stringify(event);
-    await fs.appendFile(this.eventsPath, `${line}\n`, "utf8");
-    enqueueHousekeepingEvent({
-      sessionId: this.sessionId,
-      projectRoot: this.projectRoot,
-      commandCwd: this.commandCwd,
-      event,
+    const operation = this.eventAppendTail.then(async () => {
+      await this.ensure();
+      const event = {
+        timestamp: new Date().toISOString(),
+        type,
+        data,
+      };
+      const line = JSON.stringify(event);
+      await fs.appendFile(this.eventsPath, `${line}\n`, "utf8");
+      enqueueHousekeepingEvent({
+        sessionId: this.sessionId,
+        projectRoot: this.projectRoot,
+        commandCwd: this.commandCwd,
+        event,
+      });
     });
+    this.eventAppendTail = operation.catch(() => {});
+    return operation;
   }
 
   async loadEvents() {
@@ -681,8 +707,11 @@ export class SessionStore {
   }
 
   async remove() {
+    await this.eventAppendTail.catch(() => {});
     await fs.rm(this.sessionDir, { recursive: true, force: true });
     if (this.pointerDir) await fs.rm(this.pointerDir, { recursive: true, force: true }).catch(() => {});
     deleteSessionIndex(this.sessionId);
+    this.ensurePromise = null;
+    this.eventAppendTail = Promise.resolve();
   }
 }