minimal-agent 0.11.0 → 0.12.0

package/src/session/runTurn.js

@@ -20,7 +20,7 @@
  */
 import { loadContext, saveContext } from '../context/persistContext.js';
 import { acquireContextLock } from '../context/contextLock.js';
-import { episodicMemoryService } from '../memory/episodicMemory.js';
+import { startTurnJournal } from '../memory/turnJournal.js';
 import { runWithPlugins } from '../plugins/pluginRunner.js';
 /**
  * 已有历史时，用调用方新算好的 systemPrompt（含当前日期/实时扫描的 skills·plugins 清单/
@@ -55,23 +55,14 @@ export async function* runTurn(opts) {
     const loaded = opts.initialHistory ?? (persist ? await loadContext(opts.sessionFile) : null);
     const history = buildInitialHistory(loaded, opts.systemPrompt);
     const historyStart = history.length;
-    const memoryContext = opts.memoryContext;
-    const journalContext = memoryContext?.access !== 'denied'
-        && memoryContext?.workspaceId
-        && memoryContext?.sessionId
-        ? {
-            workspaceId: memoryContext.workspaceId,
-            sessionId: memoryContext.sessionId,
-        }
-        : null;
-    if (journalContext) {
-        await episodicMemoryService.append({
-            ...journalContext,
-            role: 'user',
-            content: opts.userInput,
-            messageId: opts.userMessageId,
-        }).catch(() => undefined);
-    }
+    // 会话原文记账：实现在 src/memory/turnJournal.ts（TUI 的 useChat 用同一份），
+    // 刻意不下沉到 runQuery —— 子 Agent 与 workflow 步也调 runQuery，记在那里会把
+    // 子任务提示词当成"用户说的话"污染历史检索。
+    const journal = await startTurnJournal({
+        memoryContext: opts.memoryContext,
+        userInput: opts.userInput,
+        ...(opts.userMessageId ? { userMessageId: opts.userMessageId } : {}),
+    });
     try {
         yield* runWithPlugins(opts.userInput, {
             provider: opts.provider,
@@ -83,6 +74,7 @@ export async function* runTurn(opts) {
             sessionState: opts.sessionState,
             chat: opts.chat,
             executeTool: opts.executeTool,
+            commitFormalDelivery: opts.commitFormalDelivery,
             toolGate: opts.toolGate,
             transientContext: opts.transientContext,
             transientBundle: opts.transientBundle,
@@ -102,17 +94,7 @@ export async function* runTurn(opts) {
     }
     finally {
         try {
-            if (journalContext) {
-                const assistant = lastAssistantMessage(history, historyStart);
-                const content = assistant ? messageText(assistant) : '';
-                if (content) {
-                    await episodicMemoryService.append({
-                        ...journalContext,
-                        role: 'assistant',
-                        content,
-                    }).catch(() => undefined);
-                }
-            }
+            await journal?.finish(history, historyStart);
             if (persist)
                 await saveContext(history, opts.sessionFile);
         }
@@ -121,20 +103,3 @@ export async function* runTurn(opts) {
         }
     }
 }
-function messageText(message) {
-    if (typeof message.content === 'string')
-        return message.content;
-    if (!Array.isArray(message.content))
-        return '';
-    return message.content
-        .filter((part) => part.type === 'text')
-        .map((part) => part.text)
-        .join('\n');
-}
-function lastAssistantMessage(messages, start) {
-    for (let index = messages.length - 1; index >= start; index -= 1) {
-        if (messages[index]?.role === 'assistant')
-            return messages[index];
-    }
-    return undefined;
-}

package/src/session/runTurn.ts

@@ -21,7 +21,7 @@
 
 import { loadContext, saveContext } from '../context/persistContext.js';
 import { acquireContextLock } from '../context/contextLock.js';
-import { episodicMemoryService } from '../memory/episodicMemory.js';
+import { startTurnJournal } from '../memory/turnJournal.js';
 import type { PluginEvent } from '../plugins/pluginApi.js';
 import { runWithPlugins } from '../plugins/pluginRunner.js';
 import type {
@@ -49,6 +49,7 @@ export interface RunTurnOptions {
    *  让测试用显式注入替代 mock.module(loop.js)——后者会全局泄漏污染其它测试文件。 */
   chat?: import('../plugins/pluginRunner.js').PluginRunnerOptions['chat'];
   executeTool?: import('../plugins/pluginRunner.js').PluginRunnerOptions['executeTool'];
+  commitFormalDelivery?: import('../plugins/pluginRunner.js').PluginRunnerOptions['commitFormalDelivery'];
   /** 工具执行闸门（生产用）：透传给 runWithPlugins→runQuery。见 src/toolGate.ts。 */
   toolGate?: import('../plugins/pluginRunner.js').PluginRunnerOptions['toolGate'];
   /** 只对本次模型回合可见，不写入 session。 */
@@ -111,24 +112,14 @@ export async function* runTurn(
   const loaded = opts.initialHistory ?? (persist ? await loadContext(opts.sessionFile) : null);
   const history: Message[] = buildInitialHistory(loaded, opts.systemPrompt);
   const historyStart = history.length;
-  const memoryContext = opts.memoryContext;
-  const journalContext = memoryContext?.access !== 'denied'
-    && memoryContext?.workspaceId
-    && memoryContext?.sessionId
-    ? {
-        workspaceId: memoryContext.workspaceId,
-        sessionId: memoryContext.sessionId,
-      }
-    : null;
-
-  if (journalContext) {
-    await episodicMemoryService.append({
-      ...journalContext,
-      role: 'user',
-      content: opts.userInput,
-      messageId: opts.userMessageId,
-    }).catch(() => undefined);
-  }
+  // 会话原文记账：实现在 src/memory/turnJournal.ts（TUI 的 useChat 用同一份），
+  // 刻意不下沉到 runQuery —— 子 Agent 与 workflow 步也调 runQuery，记在那里会把
+  // 子任务提示词当成"用户说的话"污染历史检索。
+  const journal = await startTurnJournal({
+    memoryContext: opts.memoryContext,
+    userInput: opts.userInput,
+    ...(opts.userMessageId ? { userMessageId: opts.userMessageId } : {}),
+  });
 
   try {
     yield* runWithPlugins(opts.userInput, {
@@ -141,6 +132,7 @@ export async function* runTurn(
       sessionState: opts.sessionState,
       chat: opts.chat,
       executeTool: opts.executeTool,
+      commitFormalDelivery: opts.commitFormalDelivery,
       toolGate: opts.toolGate,
       transientContext: opts.transientContext,
       transientBundle: opts.transientBundle,
@@ -159,36 +151,10 @@ export async function* runTurn(
     });
   } finally {
     try {
-      if (journalContext) {
-        const assistant = lastAssistantMessage(history, historyStart);
-        const content = assistant ? messageText(assistant) : '';
-        if (content) {
-          await episodicMemoryService.append({
-            ...journalContext,
-            role: 'assistant',
-            content,
-          }).catch(() => undefined);
-        }
-      }
+      await journal?.finish(history, historyStart);
       if (persist) await saveContext(history, opts.sessionFile);
     } finally {
       await release();
     }
   }
 }
-
-function messageText(message: Message): string {
-  if (typeof message.content === 'string') return message.content;
-  if (!Array.isArray(message.content)) return '';
-  return message.content
-    .filter((part): part is Extract<typeof part, { type: 'text' }> => part.type === 'text')
-    .map((part) => part.text)
-    .join('\n');
-}
-
-function lastAssistantMessage(messages: Message[], start: number): Message | undefined {
-  for (let index = messages.length - 1; index >= start; index -= 1) {
-    if (messages[index]?.role === 'assistant') return messages[index];
-  }
-  return undefined;
-}

package/src/session/runtimeStore.js

@@ -0,0 +1,149 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, readdir, rename, rm, stat, } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { agentStateDir } from '../context/agentHome.js';
+function segment(value, fallback) {
+    return ((value ?? fallback).replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 120) ||
+        fallback);
+}
+export function sessionRuntimeDir(identity) {
+    return join(agentStateDir(), 'runtime', segment(identity.workspaceId, 'local'), segment(identity.sessionId, 'local'));
+}
+const queues = new Map();
+export async function withRuntimeFileLock(path, work) {
+    const key = resolve(path);
+    const previous = queues.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((done) => {
+        release = done;
+    });
+    const tail = previous.then(() => current);
+    queues.set(key, tail);
+    await previous.catch(() => undefined);
+    let lockHandle;
+    const lockPath = `${path}.lock`;
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    try {
+        const deadline = Date.now() + 10_000;
+        while (!lockHandle) {
+            try {
+                lockHandle = await open(lockPath, 'wx', 0o600);
+                await lockHandle.writeFile(`${process.pid}\n${Date.now()}\n`);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                const age = Date.now() -
+                    (await stat(lockPath).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
+                if (age > 30_000)
+                    await rm(lockPath, { force: true });
+                else if (Date.now() >= deadline)
+                    throw new Error(`runtime lock timeout: ${path}`);
+                else
+                    await new Promise((r) => setTimeout(r, 25));
+            }
+        }
+        return await work();
+    }
+    finally {
+        await lockHandle?.close().catch(() => undefined);
+        if (lockHandle)
+            await rm(lockPath, { force: true }).catch(() => undefined);
+        release();
+        if (queues.get(key) === tail)
+            queues.delete(key);
+    }
+}
+export async function readRuntimeJson(path, fallback) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function writeRuntimeJson(path, value) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temp = `${path}.${randomUUID()}.tmp`;
+    try {
+        const handle = await open(temp, 'wx', 0o600);
+        try {
+            await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, 'utf8');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temp, path);
+    }
+    finally {
+        await rm(temp, { force: true }).catch(() => undefined);
+    }
+}
+export async function mutateRuntimeJson(path, fallback, mutate) {
+    return withRuntimeFileLock(path, async () => {
+        const next = await mutate(await readRuntimeJson(path, fallback));
+        await writeRuntimeJson(path, next);
+        return next;
+    });
+}
+export async function removeManagedPath(path, expectedRoot) {
+    const target = resolve(path);
+    const root = resolve(expectedRoot);
+    const rel = target.slice(root.length);
+    if (target === root || !target.startsWith(`${root}/`) || rel.includes('\0')) {
+        throw new Error(`拒绝清理托管根目录之外的路径：${target}`);
+    }
+    await rm(target, { recursive: true, force: true });
+}
+export async function runtimeFileVersion(path) {
+    const info = await stat(path);
+    return `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}`;
+}
+const activeOutputs = new Set();
+const OUTPUT_RETENTION_MS = 7 * 24 * 60 * 60_000;
+const OUTPUT_GLOBAL_LIMIT = 5 * 1024 * 1024 * 1024;
+let pruneOutputsPromise;
+export function registerRuntimeOutput(path) {
+    activeOutputs.add(resolve(path));
+}
+export function unregisterRuntimeOutput(path) {
+    activeOutputs.delete(resolve(path));
+}
+export function pruneRuntimeOutputs() {
+    pruneOutputsPromise ??= (async () => {
+        const root = join(agentStateDir(), 'runtime');
+        const files = [];
+        for (const workspace of await readdir(root).catch(() => [])) {
+            const workspaceDir = join(root, workspace);
+            for (const session of await readdir(workspaceDir).catch(() => [])) {
+                const outputDir = join(workspaceDir, session, 'outputs');
+                const sessionFiles = [];
+                for (const name of await readdir(outputDir).catch(() => [])) {
+                    const path = join(outputDir, name);
+                    const info = await stat(path).catch(() => undefined);
+                    if (info?.isFile() && !activeOutputs.has(resolve(path))) {
+                        sessionFiles.push({ path, size: info.size, mtimeMs: info.mtimeMs });
+                    }
+                }
+                sessionFiles.sort((left, right) => right.mtimeMs - left.mtimeMs);
+                await Promise.all(sessionFiles
+                    .slice(50)
+                    .map((file) => rm(file.path, { force: true }).catch(() => undefined)));
+                files.push(...sessionFiles.slice(0, 50));
+            }
+        }
+        files.sort((left, right) => right.mtimeMs - left.mtimeMs);
+        let retainedBytes = 0;
+        const cutoff = Date.now() - OUTPUT_RETENTION_MS;
+        for (const file of files) {
+            retainedBytes += file.size;
+            if (file.mtimeMs < cutoff || retainedBytes > OUTPUT_GLOBAL_LIMIT) {
+                await rm(file.path, { force: true }).catch(() => undefined);
+            }
+        }
+    })().finally(() => {
+        pruneOutputsPromise = undefined;
+    });
+    return pruneOutputsPromise;
+}

package/src/session/runtimeStore.ts

@@ -0,0 +1,197 @@
+import { randomUUID } from 'node:crypto';
+import {
+  mkdir,
+  open,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  stat,
+} from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+
+import { agentStateDir } from '../context/agentHome.js';
+
+export interface RuntimeIdentity {
+  workspaceId?: string;
+  sessionId?: string;
+}
+
+function segment(value: string | undefined, fallback: string): string {
+  return (
+    (value ?? fallback).replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 120) ||
+    fallback
+  );
+}
+
+export function sessionRuntimeDir(identity: RuntimeIdentity): string {
+  return join(
+    agentStateDir(),
+    'runtime',
+    segment(identity.workspaceId, 'local'),
+    segment(identity.sessionId, 'local'),
+  );
+}
+
+const queues = new Map<string, Promise<unknown>>();
+export async function withRuntimeFileLock<T>(
+  path: string,
+  work: () => Promise<T>,
+): Promise<T> {
+  const key = resolve(path);
+  const previous = queues.get(key) ?? Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((done) => {
+    release = done;
+  });
+  const tail = previous.then(() => current);
+  queues.set(key, tail);
+  await previous.catch(() => undefined);
+  let lockHandle: Awaited<ReturnType<typeof open>> | undefined;
+  const lockPath = `${path}.lock`;
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  try {
+    const deadline = Date.now() + 10_000;
+    while (!lockHandle) {
+      try {
+        lockHandle = await open(lockPath, 'wx', 0o600);
+        await lockHandle.writeFile(`${process.pid}\n${Date.now()}\n`);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+        const age =
+          Date.now() -
+          (await stat(lockPath).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
+        if (age > 30_000) await rm(lockPath, { force: true });
+        else if (Date.now() >= deadline)
+          throw new Error(`runtime lock timeout: ${path}`);
+        else await new Promise((r) => setTimeout(r, 25));
+      }
+    }
+    return await work();
+  } finally {
+    await lockHandle?.close().catch(() => undefined);
+    if (lockHandle) await rm(lockPath, { force: true }).catch(() => undefined);
+    release();
+    if (queues.get(key) === tail) queues.delete(key);
+  }
+}
+
+export async function readRuntimeJson<T>(
+  path: string,
+  fallback: T,
+): Promise<T> {
+  try {
+    return JSON.parse(await readFile(path, 'utf8')) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+export async function writeRuntimeJson(
+  path: string,
+  value: unknown,
+): Promise<void> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temp = `${path}.${randomUUID()}.tmp`;
+  try {
+    const handle = await open(temp, 'wx', 0o600);
+    try {
+      await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, 'utf8');
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(temp, path);
+  } finally {
+    await rm(temp, { force: true }).catch(() => undefined);
+  }
+}
+
+export async function mutateRuntimeJson<T>(
+  path: string,
+  fallback: T,
+  mutate: (value: T) => T | Promise<T>,
+): Promise<T> {
+  return withRuntimeFileLock(path, async () => {
+    const next = await mutate(await readRuntimeJson(path, fallback));
+    await writeRuntimeJson(path, next);
+    return next;
+  });
+}
+
+export async function removeManagedPath(
+  path: string,
+  expectedRoot: string,
+): Promise<void> {
+  const target = resolve(path);
+  const root = resolve(expectedRoot);
+  const rel = target.slice(root.length);
+  if (target === root || !target.startsWith(`${root}/`) || rel.includes('\0')) {
+    throw new Error(`拒绝清理托管根目录之外的路径：${target}`);
+  }
+  await rm(target, { recursive: true, force: true });
+}
+
+export async function runtimeFileVersion(path: string): Promise<string> {
+  const info = await stat(path);
+  return `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}`;
+}
+
+const activeOutputs = new Set<string>();
+const OUTPUT_RETENTION_MS = 7 * 24 * 60 * 60_000;
+const OUTPUT_GLOBAL_LIMIT = 5 * 1024 * 1024 * 1024;
+let pruneOutputsPromise: Promise<void> | undefined;
+
+export function registerRuntimeOutput(path: string): void {
+  activeOutputs.add(resolve(path));
+}
+
+export function unregisterRuntimeOutput(path: string): void {
+  activeOutputs.delete(resolve(path));
+}
+
+export function pruneRuntimeOutputs(): Promise<void> {
+  pruneOutputsPromise ??= (async () => {
+    const root = join(agentStateDir(), 'runtime');
+    const files: Array<{ path: string; size: number; mtimeMs: number }> = [];
+    for (const workspace of await readdir(root).catch(() => [])) {
+      const workspaceDir = join(root, workspace);
+      for (const session of await readdir(workspaceDir).catch(() => [])) {
+        const outputDir = join(workspaceDir, session, 'outputs');
+        const sessionFiles: Array<{
+          path: string;
+          size: number;
+          mtimeMs: number;
+        }> = [];
+        for (const name of await readdir(outputDir).catch(() => [])) {
+          const path = join(outputDir, name);
+          const info = await stat(path).catch(() => undefined);
+          if (info?.isFile() && !activeOutputs.has(resolve(path))) {
+            sessionFiles.push({ path, size: info.size, mtimeMs: info.mtimeMs });
+          }
+        }
+        sessionFiles.sort((left, right) => right.mtimeMs - left.mtimeMs);
+        await Promise.all(
+          sessionFiles
+            .slice(50)
+            .map((file) =>
+              rm(file.path, { force: true }).catch(() => undefined),
+            ),
+        );
+        files.push(...sessionFiles.slice(0, 50));
+      }
+    }
+    files.sort((left, right) => right.mtimeMs - left.mtimeMs);
+    let retainedBytes = 0;
+    const cutoff = Date.now() - OUTPUT_RETENTION_MS;
+    for (const file of files) {
+      retainedBytes += file.size;
+      if (file.mtimeMs < cutoff || retainedBytes > OUTPUT_GLOBAL_LIMIT) {
+        await rm(file.path, { force: true }).catch(() => undefined);
+      }
+    }
+  })().finally(() => {
+    pruneOutputsPromise = undefined;
+  });
+  return pruneOutputsPromise;
+}

package/src/session/sessionState.js

@@ -12,12 +12,14 @@ import { createMicroCompactState, } from '../context/microCompactLite.js';
 import { createReactiveCompactState, } from '../context/reactiveCompact.js';
 import { createFileReadState } from '../tools/shared/fileState.js';
 import { createBackgroundTaskState, disposeBackgroundTaskState, } from '../tools/tasks/backgroundTaskService.js';
+import { createAgentTaskState, stopAllAgentTasks } from '../tools/agent/agentTaskService.js';
 export function createSessionState() {
     return {
         reactive: createReactiveCompactState(),
         microCompact: createMicroCompactState(),
         fileReads: createFileReadState(),
         backgroundTasks: createBackgroundTaskState(),
+        agentTasks: createAgentTaskState(),
     };
 }
 const persistentStates = new Map();
@@ -56,6 +58,7 @@ export async function disposeSessionState(key) {
         return;
     persistentStates.delete(key);
     await disposeBackgroundTaskState(entry.state.backgroundTasks);
+    await stopAllAgentTasks(entry.state.agentTasks);
     entry.state.fileReads.entries.clear();
 }
 export async function disposeAllSessionStates() {
@@ -63,11 +66,13 @@ export async function disposeAllSessionStates() {
     persistentStates.clear();
     await Promise.all(entries.map(async ({ state }) => {
         await disposeBackgroundTaskState(state.backgroundTasks);
+        await stopAllAgentTasks(state.agentTasks);
         state.fileReads.entries.clear();
     }));
 }
 export async function disposeDetachedSessionState(state) {
     await disposeBackgroundTaskState(state.backgroundTasks);
+    await stopAllAgentTasks(state.agentTasks);
     state.fileReads.entries.clear();
 }
 function prunePersistentStates(now, keepKey) {

package/src/session/sessionState.ts

@@ -23,12 +23,22 @@ import {
   disposeBackgroundTaskState,
   type BackgroundTaskState,
 } from '../tools/tasks/backgroundTaskService.js';
+import { createAgentTaskState, stopAllAgentTasks, type AgentTaskState } from '../tools/agent/agentTaskService.js';
 
 export interface SessionState {
   reactive: ReactiveCompactState;
   microCompact: MicroCompactState;
   fileReads: FileReadState;
   backgroundTasks: BackgroundTaskState;
+  agentTasks: AgentTaskState;
+  /** Main-agent worktree changes the effective cwd without changing workspace identity. */
+  activeWorktree?: {
+    id: string;
+    path: string;
+    branch: string;
+    baseSha: string;
+    gitRoot: string;
+  };
 }
 
 export function createSessionState(): SessionState {
@@ -37,6 +47,7 @@ export function createSessionState(): SessionState {
     microCompact: createMicroCompactState(),
     fileReads: createFileReadState(),
     backgroundTasks: createBackgroundTaskState(),
+    agentTasks: createAgentTaskState(),
   };
 }
 
@@ -84,6 +95,7 @@ export async function disposeSessionState(key: string): Promise<void> {
   if (!entry) return;
   persistentStates.delete(key);
   await disposeBackgroundTaskState(entry.state.backgroundTasks);
+  await stopAllAgentTasks(entry.state.agentTasks);
   entry.state.fileReads.entries.clear();
 }
 
@@ -92,12 +104,14 @@ export async function disposeAllSessionStates(): Promise<void> {
   persistentStates.clear();
   await Promise.all(entries.map(async ({ state }) => {
     await disposeBackgroundTaskState(state.backgroundTasks);
+    await stopAllAgentTasks(state.agentTasks);
     state.fileReads.entries.clear();
   }));
 }
 
 export async function disposeDetachedSessionState(state: SessionState): Promise<void> {
   await disposeBackgroundTaskState(state.backgroundTasks);
+  await stopAllAgentTasks(state.agentTasks);
   state.fileReads.entries.clear();
 }