新增 memory 和 skill 存储，实现 Agent 持续学习，并增加工具支持；增加 LLM progress detail 输出

.opencode/agents/agent.md

@@ -16,3 +16,11 @@ temperature: 0.2
 6. 尊重用户授权和项目隔离，工具调用失败或无可用数据时，切勿编造后端结果。
 7. 每次调用任意工具时，必须在工具参数 `reason` 字段中填写本次调用理由，理由需具体且与当前用户问题直接相关。
 8. 每次按需加载技能（skills）前，先明确说明加载理由，并只加载与当前任务直接相关的最小技能集合。
+9. 当 `dynamic_http_call` 返回 `result_mode = referenced` 和 `result_ref` 时，说明当前只拿到了预览；如果后续推理仍需要完整结果，必须调用 `fetch_result_ref` 回读，不能把 preview 当成完整数据。
+10. 当且仅当出现**长期有效且高价值**的信号时，才允许调用在线学习工具：
+   - `memory_manager`：用户明确长期偏好/约束，或当前项目/环境的稳定事实
+   - `skill_manager`：已经被证明有效且可复用的 workflow / 方法模式；由您自己判断应写入 `.opencode/skills` 树中的哪个 skill 位置
+11. 不要把一次性问题、临时上下文、未经验证的猜测写入任何学习工具。
+12. 严禁把 token、password、secret、API key、system prompt、隐私数据写入 `memory_manager` 或 `skill_manager`。
+13. 如果内容只是一次性案例、临时纠错或局部证据，当前不要持久化。
+14. 只有在 workflow 经过验证、足够稳定、可被未来同类任务复用时，才调用 `skill_manager`；并优先写入最贴近现有 skill 树语义的位置，中低置信度内容不要落库。

.opencode/tools/fetch_result_ref.ts

@@ -0,0 +1,41 @@
+import { tool } from "@opencode-ai/plugin";
+
+const internalBaseUrl = process.env.TJWATER_AGENT_INTERNAL_BASE_URL ?? "http://127.0.0.1:8787";
+const internalToken = process.env.TJWATER_AGENT_INTERNAL_TOKEN ?? "";
+
+export default tool({
+  description:
+    "回读由 dynamic_http_call 生成的持久化 result_ref。适用于大结果只返回 preview 时，再按需读取完整或截断后的数据。",
+  args: {
+    reason: tool.schema
+      .string()
+      .describe("Why the stored result needs to be read for the current user request."),
+    result_ref: tool.schema.string().describe("The result_ref returned by dynamic_http_call."),
+    max_items: tool.schema
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe("Optional maximum number of top-level items or fields to return."),
+  },
+  async execute(args, context) {
+    const response = await fetch(`${internalBaseUrl}/internal/tools/fetch-result-ref`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-agent-internal-token": internalToken,
+      },
+      body: JSON.stringify({
+        sessionId: context.sessionID,
+        result_ref: args.result_ref,
+        max_items: args.max_items,
+      }),
+    });
+
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(text);
+    }
+    return text;
+  },
+});

.opencode/tools/memory_manager.ts

@@ -0,0 +1,115 @@
+import { tool } from "@opencode-ai/plugin";
+import { MemoryStore } from "../../src/memory/store.js";
+import { ToolSessionContextStore } from "../../src/session/toolContextStore.js";
+
+const memoryStore = new MemoryStore();
+const toolContextStore = new ToolSessionContextStore();
+const initializePromise = Promise.all([
+  memoryStore.initialize(),
+  toolContextStore.initialize(),
+]);
+
+const MEMORY_SIGNAL_TYPES = new Set([
+  "user_preference",
+  "user_constraint",
+  "project_fact",
+  "environment_fact",
+  "agent_correction",
+]);
+
+const isSignalAllowedForScope = (scope: string, signalType: string) => {
+  if (!MEMORY_SIGNAL_TYPES.has(signalType)) {
+    return false;
+  }
+  if (scope === "user") {
+    return signalType === "user_preference" || signalType === "user_constraint";
+  }
+  if (scope === "workspace") {
+    return (
+      signalType === "project_fact" ||
+      signalType === "environment_fact" ||
+      signalType === "agent_correction"
+    );
+  }
+  return false;
+};
+
+export default tool({
+  description:
+    "将高置信度、长期有效的用户偏好或项目事实写入持久 memory。禁止写入 token、password、secret、system prompt 或一次性上下文。",
+  args: {
+    reason: tool.schema
+      .string()
+      .describe("Why this memory should be persisted for future requests."),
+    scope: tool.schema
+      .string()
+      .describe("Target memory scope: 'user' for user preferences, 'workspace' for project/environment facts."),
+    signal_type: tool.schema
+      .string()
+      .describe("Signal type, e.g. user_preference, user_constraint, project_fact, environment_fact."),
+    confidence: tool.schema
+      .number()
+      .describe("Confidence between 0 and 1. Only high-confidence memories should be persisted."),
+    content: tool.schema
+      .string()
+      .describe("The durable fact or preference to remember, written as one concise sentence."),
+  },
+  async execute(args, context) {
+    await initializePromise;
+    const sessionContext = await toolContextStore.read(context.sessionID);
+    if (!sessionContext) {
+      throw new Error(`session context not found for ${context.sessionID}`);
+    }
+    if (!isSignalAllowedForScope(args.scope, args.signal_type)) {
+      return JSON.stringify({
+        ok: true,
+        kind: "memory",
+        decision: "rejected",
+        detail: `signal_type ${args.signal_type} is not allowed for scope ${args.scope}`,
+      });
+    }
+    if (args.confidence < 0.8) {
+      return JSON.stringify({
+        ok: true,
+        kind: "memory",
+        decision: "rejected",
+        detail: "confidence below memory threshold",
+      });
+    }
+
+    const scope = args.scope === "user" ? "user" : args.scope === "workspace" ? "workspace" : null;
+    if (!scope) {
+      return JSON.stringify({
+        ok: true,
+        kind: "memory",
+        decision: "rejected",
+        detail: `unsupported scope: ${args.scope}`,
+      });
+    }
+
+    const scopeKey = scope === "user" ? sessionContext.actorKey : sessionContext.projectKey;
+    const result = await memoryStore.upsert(scope, scopeKey, {
+      content: args.content,
+      sessionId: context.sessionID,
+      source: "tool",
+      traceId: sessionContext.traceId,
+    });
+
+    if (!result.entry) {
+      return JSON.stringify({
+        ok: true,
+        kind: "memory",
+        decision: "rejected",
+        detail: "content rejected by persistence policy",
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      kind: "memory",
+      decision: result.changed ? "accepted" : "deduped",
+      detail: result.changed ? "memory stored" : "memory already existed",
+      target: scope,
+    });
+  },
+});

.opencode/tools/skill_manager.ts

@@ -0,0 +1,181 @@
+import { tool } from "@opencode-ai/plugin";
+import { join, posix } from "node:path";
+
+import { ResultReferenceStore } from "../../src/results/store.js";
+import { ToolSessionContextStore } from "../../src/session/toolContextStore.js";
+import {
+  atomicWriteFile,
+  ensureDirectory,
+  readTextFile,
+} from "../../src/utils/fileStore.js";
+import { sanitizePersistentLine } from "../../src/utils/persistencePolicy.js";
+
+const resultStore = new ResultReferenceStore();
+const toolContextStore = new ToolSessionContextStore();
+const initializePromise = Promise.all([
+  resultStore.initialize(),
+  toolContextStore.initialize(),
+]);
+const SKILLS_ROOT_DIR = ".opencode/skills";
+const LEARNED_PATTERNS_MARKER = "## Learned Patterns";
+let writeQueue: Promise<void> = Promise.resolve();
+
+export default tool({
+  description:
+    "将已验证、可复用、非敏感的 workflow 或方法模式写入指定的 .opencode/skills 目录，由 opencode 自动识别和加载。",
+  args: {
+    reason: tool.schema
+      .string()
+      .describe("Why this workflow or method should be learned for future reuse."),
+    skill_path: tool.schema
+      .string()
+      .describe("Target skill directory path relative to .opencode/skills, for example analytics/simulation-analysis/leakage or platform/governance-observability/meta."),
+    pattern: tool.schema
+      .string()
+      .describe("A reusable workflow pattern written as one concise bullet-like sentence."),
+    signal_type: tool.schema
+      .string()
+      .describe("Signal type, e.g. validated_workflow, successful_complex_convergence, analysis_method, tool_recovery_pattern."),
+    confidence: tool.schema
+      .number()
+      .describe("Confidence between 0 and 1. Only very high-confidence patterns are stored as learned skills."),
+    result_refs: tool.schema
+      .array(tool.schema.string())
+      .optional()
+      .describe("Optional authorized result_ref list used only for evidence validation before persisting the skill."),
+  },
+  async execute(args, context) {
+    await initializePromise;
+    const sessionContext = await toolContextStore.read(context.sessionID);
+    if (!sessionContext) {
+      throw new Error(`session context not found for ${context.sessionID}`);
+    }
+    const skillPath = normalizeSkillPath(args.skill_path);
+    if (!skillPath) {
+      return JSON.stringify({
+        ok: true,
+        kind: "skill",
+        decision: "rejected",
+        detail: "invalid skill_path; expected a relative path under .opencode/skills",
+      });
+    }
+    const pattern = sanitizePersistentLine(args.pattern, 320);
+    if (!pattern) {
+      return JSON.stringify({
+        ok: true,
+        kind: "skill",
+        decision: "rejected",
+        detail: "pattern rejected by persistence policy",
+      });
+    }
+    if (args.confidence < 0.85) {
+      return JSON.stringify({
+        ok: true,
+        kind: "skill",
+        decision: "rejected",
+        detail: "only very high-confidence patterns can be stored as skills",
+      });
+    }
+    if (args.result_refs?.length) {
+      await Promise.all(
+        args.result_refs.map(async (resultRef) => {
+          const record = await resultStore.peekAuthorized(resultRef, {
+            actorKey: sessionContext.actorKey,
+            projectId: sessionContext.projectId,
+          });
+          if (!record) {
+            throw new Error(`unauthorized or missing result_ref: ${resultRef}`);
+          }
+        }),
+      );
+    }
+
+    const result = await appendLearnedSkillPattern(skillPath, pattern);
+    return JSON.stringify({
+      ok: true,
+      kind: "skill",
+      decision: result.changed ? "accepted" : "deduped",
+      detail: result.changed ? "skill file updated" : "pattern already existed",
+      target: result.target,
+    });
+  },
+});
+
+const appendLearnedSkillPattern = async (skillPath: string, pattern: string) => {
+  return serializeWrite(async () => {
+    const target = join(SKILLS_ROOT_DIR, skillPath, "SKILL.md");
+    const current = (await readTextFile(target)) ?? defaultLearnedSkill(skillPath);
+    const existingPatterns = extractLearnedPatterns(current);
+    if (existingPatterns.includes(pattern)) {
+      return { changed: false, target };
+    }
+
+    const next = current.includes(LEARNED_PATTERNS_MARKER)
+      ? current.replace(
+          LEARNED_PATTERNS_MARKER,
+          `${LEARNED_PATTERNS_MARKER}\n- ${pattern}`,
+        )
+      : `${current.trimEnd()}\n\n${LEARNED_PATTERNS_MARKER}\n- ${pattern}\n`;
+
+    await ensureDirectory(join(SKILLS_ROOT_DIR, skillPath));
+    await atomicWriteFile(target, next);
+    return { changed: true, target };
+  });
+};
+
+const serializeWrite = async <T>(task: () => Promise<T>) => {
+  const run = writeQueue.catch(() => undefined).then(task);
+  writeQueue = run.then(
+    () => undefined,
+    () => undefined,
+  );
+  return run;
+};
+
+const defaultLearnedSkill = (skillPath: string) => `---
+name: tjwater-action-${toSkillName(skillPath)}
+description: 由 skill_manager 在线追加的高置信度可复用 workflow。
+version: 1.0.0
+---
+
+# learned skill
+
+## 简介
+
+记录由 \`skill_manager\` 在线追加的高置信度 workflow 模式。
+
+## Learned Patterns
+`;
+
+const normalizeSkillPath = (rawSkillPath: string) => {
+  const normalized = posix.normalize(rawSkillPath.trim().replace(/^\/+|\/+$/g, ""));
+  if (!normalized || normalized === "." || normalized.startsWith("..")) {
+    return null;
+  }
+  if (normalized === "SKILL.md" || normalized.endsWith("/SKILL.md")) {
+    return null;
+  }
+  if (!/^[a-z0-9._/-]+$/i.test(normalized)) {
+    return null;
+  }
+  return normalized;
+};
+
+const toSkillName = (skillPath: string) =>
+  skillPath
+    .split("/")
+    .filter(Boolean)
+    .join("-")
+    .replace(/[^a-z0-9._-]+/gi, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 120) || "generated-skill";
+
+const extractLearnedPatterns = (content: string) => {
+  if (!content.includes(LEARNED_PATTERNS_MARKER)) {
+    return [];
+  }
+  return (content.split(LEARNED_PATTERNS_MARKER)[1] ?? "")
+    .split("\n")
+    .filter((line) => line.trim().startsWith("- "))
+    .map((line) => line.trim().slice(2));
+};

README.md

@@ -30,7 +30,7 @@ TJWaterAgent/
 1. 启动 HTTP 服务。
 2. 通过 `@opencode-ai/sdk` 启动内嵌 opencode server，或连接外部 opencode server。
 3. 管理前端 `session_id -> opencode sessionId` 的映射。
-4. 保存并传递用户 `Authorization`、`x-project-id`、`x-trace-id`。
+4. 保存并传递用户 `Authorization`、`x-user-id`、`x-project-id`、`x-trace-id`。
 5. 把 opencode 输出适配成前端需要的 SSE 事件。
 6. 为 `.opencode/tools/dynamic_http_call.ts` 提供内部回调接口。
 7. 代理调用真实 TJWater 后端 API。

src/chat/sessionBridge.ts

@@ -3,8 +3,12 @@ import { randomUUID } from "node:crypto";
 import { logger } from "../logger.js";
 import { type OpencodeRuntimeAdapter } from "../runtime/opencode.js";
 import { type SessionBinding, type SessionContext, SessionRegistry } from "../session/registry.js";
+import { ToolSessionContextStore } from "../session/toolContextStore.js";
+import { toActorKey, toProjectKey } from "../utils/fileStore.js";
 
 export type ChatRequestContext = SessionContext & {
+  actorKey: string;
+  projectKey: string;
   traceId: string;
 };
 
@@ -12,6 +16,7 @@ export class ChatSessionBridge {
   // 这里额外保存 session -> 用户上下文，供工具桥在服务端代发真实后端请求时复用。
   private readonly sessionContexts = new Map<string, ChatRequestContext>();
   private readonly sessionTitles = new Map<string, string>();
+  private readonly toolContextStore = new ToolSessionContextStore();
 
   constructor(
     private readonly registry: SessionRegistry,
@@ -23,6 +28,7 @@ export class ChatSessionBridge {
     accessToken?: string;
     projectId?: string;
     traceId?: string;
+    userId?: string;
   }): Promise<{
     binding: SessionBinding;
     requestContext: ChatRequestContext;
@@ -32,8 +38,11 @@ export class ChatSessionBridge {
       clientSessionId:
         context.clientSessionId?.trim() || `agent-${randomUUID().slice(0, 12)}`,
       accessToken: context.accessToken,
+      actorKey: toActorKey(context.userId),
       projectId: context.projectId,
+      projectKey: toProjectKey(context.projectId),
       traceId: context.traceId?.trim() || `trace-${randomUUID().slice(0, 12)}`,
+      userId: context.userId?.trim(),
     };
 
     this.cleanupExpired();
@@ -41,6 +50,14 @@ export class ChatSessionBridge {
     const current = this.registry.get(requestContext);
     if (current) {
       this.sessionContexts.set(current.sessionId, requestContext);
+      await this.toolContextStore.write({
+        actorKey: requestContext.actorKey,
+        clientSessionId: requestContext.clientSessionId,
+        projectId: requestContext.projectId,
+        projectKey: requestContext.projectKey,
+        sessionId: current.sessionId,
+        traceId: requestContext.traceId,
+      });
       try {
         // 只有 opencode 侧 session 仍存在时，才复用本地映射。
         await this.runtime.getSession(current.sessionId);
@@ -60,6 +77,14 @@ export class ChatSessionBridge {
     const session = await this.runtime.createSession(requestContext.clientSessionId);
     const binding = this.registry.upsert(requestContext, session.id);
     this.sessionContexts.set(binding.sessionId, requestContext);
+    await this.toolContextStore.write({
+      actorKey: requestContext.actorKey,
+      clientSessionId: requestContext.clientSessionId,
+      projectId: requestContext.projectId,
+      projectKey: requestContext.projectKey,
+      sessionId: binding.sessionId,
+      traceId: requestContext.traceId,
+    });
     return { binding, requestContext, created: true };
   }
 
@@ -83,11 +108,20 @@ export class ChatSessionBridge {
     this.sessionTitles.set(sessionId, normalized);
   }
 
+  cloneSessionTitle(sourceSessionId: string, targetSessionId: string) {
+    const existingTitle = this.sessionTitles.get(sourceSessionId);
+    if (!existingTitle) {
+      return;
+    }
+    this.sessionTitles.set(targetSessionId, existingTitle);
+  }
+
   async abort(context: {
     clientSessionId?: string;
     accessToken?: string;
     projectId?: string;
     traceId?: string;
+    userId?: string;
   }): Promise<SessionBinding | null> {
     const clientSessionId = context.clientSessionId?.trim();
     if (!clientSessionId) {
@@ -97,8 +131,11 @@ export class ChatSessionBridge {
     const requestContext: ChatRequestContext = {
       clientSessionId,
       accessToken: context.accessToken,
+      actorKey: toActorKey(context.userId),
       projectId: context.projectId,
+      projectKey: toProjectKey(context.projectId),
       traceId: context.traceId?.trim() || `trace-${randomUUID().slice(0, 12)}`,
+      userId: context.userId?.trim(),
     };
 
     this.cleanupExpired();
@@ -109,6 +146,14 @@ export class ChatSessionBridge {
     }
 
     this.sessionContexts.set(binding.sessionId, requestContext);
+    await this.toolContextStore.write({
+      actorKey: requestContext.actorKey,
+      clientSessionId: requestContext.clientSessionId,
+      projectId: requestContext.projectId,
+      projectKey: requestContext.projectKey,
+      sessionId: binding.sessionId,
+      traceId: requestContext.traceId,
+    });
     await this.runtime.abortSession(binding.sessionId);
     return binding;
   }
@@ -119,6 +164,7 @@ export class ChatSessionBridge {
     projectId?: string;
     traceId?: string;
     keepMessageCount: number;
+    userId?: string;
   }): Promise<{
     binding: SessionBinding;
     requestContext: ChatRequestContext;
@@ -128,8 +174,11 @@ export class ChatSessionBridge {
     const nextRequestContext: ChatRequestContext = {
       clientSessionId: `agent-${randomUUID().slice(0, 12)}`,
       accessToken: context.accessToken,
+      actorKey: toActorKey(context.userId),
       projectId: context.projectId,
+      projectKey: toProjectKey(context.projectId),
       traceId: context.traceId?.trim() || `trace-${randomUUID().slice(0, 12)}`,
+      userId: context.userId?.trim(),
     };
 
     this.cleanupExpired();
@@ -138,14 +187,25 @@ export class ChatSessionBridge {
       const session = await this.runtime.createSession(nextRequestContext.clientSessionId);
       const binding = this.registry.upsert(nextRequestContext, session.id);
       this.sessionContexts.set(binding.sessionId, nextRequestContext);
+      await this.toolContextStore.write({
+        actorKey: nextRequestContext.actorKey,
+        clientSessionId: nextRequestContext.clientSessionId,
+        projectId: nextRequestContext.projectId,
+        projectKey: nextRequestContext.projectKey,
+        sessionId: binding.sessionId,
+        traceId: nextRequestContext.traceId,
+      });
       return { binding, requestContext: nextRequestContext, created: true };
     }
 
     const currentContext: ChatRequestContext = {
       clientSessionId: currentClientSessionId,
       accessToken: context.accessToken,
+      actorKey: toActorKey(context.userId),
       projectId: context.projectId,
+      projectKey: toProjectKey(context.projectId),
       traceId: nextRequestContext.traceId,
+      userId: context.userId?.trim(),
     };
 
     const current = this.registry.get(currentContext);
@@ -153,6 +213,14 @@ export class ChatSessionBridge {
       const session = await this.runtime.createSession(nextRequestContext.clientSessionId);
       const binding = this.registry.upsert(nextRequestContext, session.id);
       this.sessionContexts.set(binding.sessionId, nextRequestContext);
+      await this.toolContextStore.write({
+        actorKey: nextRequestContext.actorKey,
+        clientSessionId: nextRequestContext.clientSessionId,
+        projectId: nextRequestContext.projectId,
+        projectKey: nextRequestContext.projectKey,
+        sessionId: binding.sessionId,
+        traceId: nextRequestContext.traceId,
+      });
       return { binding, requestContext: nextRequestContext, created: true };
     }
 
@@ -173,6 +241,15 @@ export class ChatSessionBridge {
     const session = await this.runtime.forkSession(current.sessionId, keepMessage.info.id);
     const binding = this.registry.upsert(nextRequestContext, session.id);
     this.sessionContexts.set(binding.sessionId, nextRequestContext);
+    await this.toolContextStore.write({
+      actorKey: nextRequestContext.actorKey,
+      clientSessionId: nextRequestContext.clientSessionId,
+      projectId: nextRequestContext.projectId,
+      projectKey: nextRequestContext.projectKey,
+      sessionId: binding.sessionId,
+      traceId: nextRequestContext.traceId,
+    });
+    this.cloneSessionTitle(current.sessionId, binding.sessionId);
     return { binding, requestContext: nextRequestContext, created: true };
   }
 
@@ -181,6 +258,7 @@ export class ChatSessionBridge {
     for (const sessionId of expiredSessionIds) {
       this.sessionContexts.delete(sessionId);
       this.sessionTitles.delete(sessionId);
+      void this.toolContextStore.remove(sessionId);
       // 这里用 abort 做轻量清理；即使失败，也不阻断本地过期回收。
       void this.runtime.abortSession(sessionId).catch((error) => {
         logger.debug({ sessionId, err: error }, "ignoring failed abort for expired session");

src/config.ts

@@ -6,24 +6,66 @@ dotenv.config({ path: ".local.env", override: false });
 
 // 统一在启动时解析环境变量，避免业务代码里散落字符串默认值。
 const envSchema = z.object({
+  // 运行环境标识，如 development / production。
   NODE_ENV: z.string().default("development"),
+  // HTTP 服务监听端口。
   PORT: z.coerce.number().int().positive().default(8787),
+  // HTTP 服务监听地址。
   HOST: z.string().default("0.0.0.0"),
+  // Pino 日志级别。
   LOG_LEVEL: z.string().default("info"),
-  LLM_REQUEST_AUDIT_LOG_PATH: z.string().default("./logs/llm-request-audit.log"),
+  // LLM 工具/技能调用审计日志路径。
+  LLM_REQUEST_AUDIT_LOG_PATH: z
+    .string()
+    .default("./logs/llm-request-audit.log"),
+  // 内部工具桥调用本服务时使用的鉴权 token；未显式配置时启动阶段会自动生成。
   AGENT_INTERNAL_TOKEN: z.string().optional(),
+  // embedded opencode server 的监听地址。
   OPENCODE_HOSTNAME: z.string().default("127.0.0.1"),
+  // embedded opencode server 的监听端口。
   OPENCODE_PORT: z.coerce.number().int().positive().default(4096),
+  // opencode SDK 启动或连接运行时时的超时时间（毫秒）。
   OPENCODE_TIMEOUT_MS: z.coerce.number().int().positive().default(5000),
+  // 默认使用的 opencode 模型标识。
   OPENCODE_MODEL: z.string().default("deepseek/deepseek-v4-pro"),
+  // 外部 opencode server 的基础地址；配置后将跳过 embedded 模式。
   OPENCODE_BASE_URL: z.string().optional(),
+  // 外部 opencode server 的访问密码（预留）。
   OPENCODE_SERVER_PASSWORD: z.string().optional(),
+  // 外部 opencode server 的访问用户名（预留）。
   OPENCODE_SERVER_USERNAME: z.string().default("opencode"),
+  // chat session 在本地注册表中的保活时长（秒）。
   SESSION_TTL_SECONDS: z.coerce.number().int().positive().default(1800),
+  // 提供给本地 opencode tools 读取的会话上下文目录。
+  SESSION_CONTEXT_STORAGE_DIR: z.string().default("./data/session-contexts"),
+  // TJWater 后端 API 的基础地址。
   TJWATER_API_BASE_URL: z.string().default("http://127.0.0.1:8000"),
+  // 代理调用 TJWater 后端 API 的超时时间（毫秒）。
   TJWATER_API_TIMEOUT_MS: z.coerce.number().int().positive().default(30000),
+  // 后端结果在直接内联返回给模型前允许的最大字节数。
   MAX_INLINE_RESULT_BYTES: z.coerce.number().int().positive().default(12000),
+  // 生成结果 preview 时最多抽样的条目数。
   MAX_PREVIEW_SAMPLE_ITEMS: z.coerce.number().int().positive().default(3),
+  // memory 持久化存储目录。
+  MEMORY_STORAGE_DIR: z.string().default("./data/memory"),
+  // 注入到 prompt 的 memory 快照最大字符数，避免上下文过大。
+  MEMORY_MAX_PROMPT_CHARS: z.coerce.number().int().positive().default(1800),
+  // result_ref 持久化存储目录。
+  RESULT_REF_STORAGE_DIR: z.string().default("./data/result-refs"),
+  // result_ref 保留时长（小时）。
+  RESULT_REF_TTL_HOURS: z.coerce.number().int().positive().default(168),
+  // 定时清理过期 result_ref 的扫描周期（毫秒）。
+  RESULT_REF_CLEANUP_INTERVAL_MS: z.coerce
+    .number()
+    .int()
+    .positive()
+    .default(3600000),
+  // fetch_result_ref 默认最多返回的顶层项/字段数量。
+  RESULT_REF_MAX_RETRIEVAL_ITEMS: z.coerce
+    .number()
+    .int()
+    .positive()
+    .default(50),
 });
 
 export type AppConfig = z.infer<typeof envSchema>;

src/memory/store.ts

@@ -0,0 +1,154 @@
+import { join } from "node:path";
+
+import { config } from "../config.js";
+import { sanitizePersistentLine } from "../utils/persistencePolicy.js";
+import {
+  atomicWriteFile,
+  ensureDirectory,
+  readTextFile,
+} from "../utils/fileStore.js";
+
+export type MemoryScope = "user" | "workspace";
+export type MemoryEntrySource = "review" | "tool";
+
+export type MemoryEntry = {
+  content: string;
+};
+
+export type MemoryDraft = {
+  content: string;
+  source: MemoryEntrySource;
+  sessionId?: string;
+  traceId?: string;
+};
+
+type MemoryContext = {
+  actorKey: string;
+  projectKey: string;
+};
+
+const SUSPICIOUS_MEMORY_PATTERNS = [
+  /ignore\s+(all|previous|prior|above)\s+instructions/i,
+  /system\s+prompt/i,
+  /do\s+not\s+tell\s+the\s+user/i,
+  /curl\s+.*(token|secret|password|api)/i,
+];
+
+export class MemoryStore {
+  private writeQueue: Promise<void> = Promise.resolve();
+
+  constructor(private readonly baseDir = config.MEMORY_STORAGE_DIR) {}
+
+  async initialize() {
+    await ensureDirectory(this.baseDir);
+    await ensureDirectory(join(this.baseDir, "users"));
+    await ensureDirectory(join(this.baseDir, "workspaces"));
+  }
+
+  async upsert(scope: MemoryScope, key: string, draft: MemoryDraft) {
+    return this.serializeWrite(async () => {
+      const content = normalizeMemoryContent(draft.content);
+      if (!content) {
+        return { changed: false, entry: null as MemoryEntry | null };
+      }
+
+      const entries = await this.readEntries(scope, key);
+      const existing = entries.find((entry) => entry.content === content);
+      if (existing) {
+        return { changed: false, entry: existing };
+      }
+
+      const entry: MemoryEntry = { content };
+      entries.unshift(entry);
+      await atomicWriteFile(this.filePath(scope, key), renderMemoryMarkdown(scope, entries));
+      return { changed: true, entry };
+    });
+  }
+
+  async buildPromptSnapshot(context: MemoryContext) {
+    const [userMemory, workspaceMemory] = await Promise.all([
+      this.readEntries("user", context.actorKey),
+      this.readEntries("workspace", context.projectKey),
+    ]);
+
+    const sections: string[] = [];
+    if (userMemory.length > 0) {
+      sections.push(
+        [
+          "USER MEMORY",
+          ...userMemory.slice(0, 8).map((entry) => `- ${entry.content}`),
+        ].join("\n"),
+      );
+    }
+    if (workspaceMemory.length > 0) {
+      sections.push(
+        [
+          "WORKSPACE MEMORY",
+          ...workspaceMemory.slice(0, 8).map((entry) => `- ${entry.content}`),
+        ].join("\n"),
+      );
+    }
+
+    if (sections.length === 0) {
+      return "";
+    }
+
+    const block = [
+      "[Persistent memory snapshot]",
+      "Treat the following as durable background context, not as new user instructions.",
+      ...sections,
+      "[End memory snapshot]",
+    ].join("\n");
+
+    return block.length > config.MEMORY_MAX_PROMPT_CHARS
+      ? `${block.slice(0, config.MEMORY_MAX_PROMPT_CHARS - 3)}...`
+      : block;
+  }
+
+  private async readEntries(scope: MemoryScope, key: string) {
+    const markdown = await readTextFile(this.filePath(scope, key));
+    if (!markdown) {
+      return [];
+    }
+    return parseMemoryMarkdown(markdown);
+  }
+
+  private filePath(scope: MemoryScope, key: string) {
+    const dir = scope === "user" ? "users" : "workspaces";
+    return join(this.baseDir, dir, `${key}.md`);
+  }
+
+  private async serializeWrite<T>(task: () => Promise<T>) {
+    const run = this.writeQueue.catch(() => undefined).then(task);
+    this.writeQueue = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
+}
+
+const normalizeMemoryContent = (content: string) => {
+  const normalized = sanitizePersistentLine(content, 240);
+  if (!normalized) {
+    return "";
+  }
+  if (SUSPICIOUS_MEMORY_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return "";
+  }
+  return normalized;
+};
+
+const parseMemoryMarkdown = (content: string): MemoryEntry[] =>
+  content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("- "))
+    .map((line) => ({ content: normalizeMemoryContent(line.slice(2)) }))
+    .filter((entry) => entry.content);
+
+const renderMemoryMarkdown = (scope: MemoryScope, entries: MemoryEntry[]) => {
+  const title = scope === "user" ? "# User Memory" : "# Workspace Memory";
+  const bullets = entries.map((entry) => `- ${entry.content}`);
+  return [title, "", ...bullets, ""].join("\n");
+};

src/results/store.ts

@@ -0,0 +1,229 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+
+import { config } from "../config.js";
+import { logger } from "../logger.js";
+import {
+  atomicWriteJson,
+  ensureDirectory,
+  getFileStat,
+  listJsonFiles,
+  readJsonFile,
+  removeFileIfExists,
+} from "../utils/fileStore.js";
+
+export type ResultReferenceRecord = {
+  resultRef: string;
+  actorKey: string;
+  clientSessionId: string;
+  createdAt: string;
+  data: unknown;
+  preview: ResultPreview;
+  projectId?: string;
+  projectKey: string;
+  sessionId: string;
+  sizeBytes: number;
+  traceId: string;
+};
+
+export type ResultPreview = {
+  count: number;
+  fields: string[];
+  sample: unknown;
+  summary: string;
+};
+
+export type StoreResultInput = {
+  actorKey: string;
+  clientSessionId: string;
+  data: unknown;
+  projectId?: string;
+  projectKey: string;
+  sessionId: string;
+  traceId: string;
+};
+
+export type RetrievalContext = {
+  actorKey: string;
+  maxItems?: number;
+  projectId?: string;
+};
+
+export type ResultReferencePeek = {
+  resultRef: string;
+  preview: ResultPreview;
+  storedAt: string;
+};
+
+export class ResultReferenceStore {
+  private cleanupTimer: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly baseDir = config.RESULT_REF_STORAGE_DIR,
+    private readonly ttlMs = config.RESULT_REF_TTL_HOURS * 60 * 60 * 1000,
+  ) {}
+
+  async initialize() {
+    await ensureDirectory(this.baseDir);
+  }
+
+  startCleanupLoop() {
+    if (this.cleanupTimer) {
+      return;
+    }
+    this.cleanupTimer = setInterval(() => {
+      void this.cleanupExpired().catch((error) => {
+        logger.warn({ err: error }, "result ref cleanup failed");
+      });
+    }, config.RESULT_REF_CLEANUP_INTERVAL_MS);
+    this.cleanupTimer.unref?.();
+  }
+
+  stopCleanupLoop() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  async store(input: StoreResultInput) {
+    const resultRef = `res-${randomUUID().slice(0, 16)}`;
+    const record: ResultReferenceRecord = {
+      resultRef,
+      actorKey: input.actorKey,
+      clientSessionId: input.clientSessionId,
+      createdAt: new Date().toISOString(),
+      data: input.data,
+      preview: buildPreview(input.data),
+      projectId: input.projectId,
+      projectKey: input.projectKey,
+      sessionId: input.sessionId,
+      sizeBytes: estimateBytes(input.data),
+      traceId: input.traceId,
+    };
+    await atomicWriteJson(this.filePath(resultRef), record);
+    return record;
+  }
+
+  async getAuthorized(resultRef: string, context: RetrievalContext) {
+    const record = await this.readAuthorizedRecord(resultRef, context);
+    if (!record) {
+      return null;
+    }
+    const data = projectData(record.data, context.maxItems ?? config.RESULT_REF_MAX_RETRIEVAL_ITEMS);
+    return {
+      ok: true,
+      result_ref: record.resultRef,
+      result_size_bytes: record.sizeBytes,
+      stored_at: record.createdAt,
+      data,
+      preview: record.preview,
+    };
+  }
+
+  async peekAuthorized(resultRef: string, context: RetrievalContext): Promise<ResultReferencePeek | null> {
+    const record = await this.readAuthorizedRecord(resultRef, context);
+    if (!record) {
+      return null;
+    }
+    return {
+      resultRef: record.resultRef,
+      preview: record.preview,
+      storedAt: record.createdAt,
+    };
+  }
+
+  async listBySession(sessionId: string) {
+    const files = await listJsonFiles(this.baseDir);
+    const records = await Promise.all(
+      files.map(async (filePath) => readJsonFile<ResultReferenceRecord>(filePath)),
+    );
+    return records
+      .filter((record): record is ResultReferenceRecord => Boolean(record))
+      .filter((record) => record.sessionId === sessionId)
+      .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+  }
+
+  async cleanupExpired() {
+    const files = await listJsonFiles(this.baseDir);
+    const now = Date.now();
+    for (const filePath of files) {
+      const stats = await getFileStat(filePath);
+      if (!stats) {
+        continue;
+      }
+      if (now - stats.mtimeMs > this.ttlMs) {
+        await removeFileIfExists(filePath);
+      }
+    }
+  }
+
+  private filePath(resultRef: string) {
+    return join(this.baseDir, `${resultRef}.json`);
+  }
+
+  private async readAuthorizedRecord(resultRef: string, context: RetrievalContext) {
+    const record = await readJsonFile<ResultReferenceRecord>(this.filePath(resultRef));
+    if (!record) {
+      return null;
+    }
+    if (record.actorKey !== context.actorKey) {
+      return null;
+    }
+    if ((record.projectId ?? "") !== (context.projectId ?? "")) {
+      return null;
+    }
+    return record;
+  }
+}
+
+const estimateBytes = (data: unknown) => Buffer.byteLength(JSON.stringify(data));
+
+const buildPreview = (data: unknown): ResultPreview => {
+  if (Array.isArray(data)) {
+    const sample = data.slice(0, config.MAX_PREVIEW_SAMPLE_ITEMS);
+    const fields =
+      sample.length > 0 && isRecord(sample[0])
+        ? Object.keys(sample[0]).slice(0, 30)
+        : [];
+    return {
+      count: data.length,
+      fields,
+      sample,
+      summary: `list[${data.length}]`,
+    };
+  }
+
+  if (isRecord(data)) {
+    const fields = Object.keys(data).slice(0, 30);
+    const sample = Object.fromEntries(
+      fields.slice(0, config.MAX_PREVIEW_SAMPLE_ITEMS).map((field) => [field, data[field]]),
+    );
+    return {
+      count: fields.length,
+      fields,
+      sample,
+      summary: `object<${fields.length} fields>`,
+    };
+  }
+
+  return {
+    count: 1,
+    fields: [],
+    sample: String(data).slice(0, 300),
+    summary: `scalar<${typeof data}>`,
+  };
+};
+
+const projectData = (data: unknown, maxItems: number) => {
+  if (Array.isArray(data)) {
+    return data.slice(0, maxItems);
+  }
+  if (isRecord(data)) {
+    return Object.fromEntries(Object.entries(data).slice(0, maxItems));
+  }
+  return data;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);

src/routes/chat.ts

@@ -3,6 +3,7 @@ import { Router } from "express";
 import { z } from "zod";
 
 import { logger } from "../logger.js";
+import { MemoryStore } from "../memory/store.js";
 import { type OpencodeRuntimeAdapter } from "../runtime/opencode.js";
 import { type ChatSessionBridge } from "../chat/sessionBridge.js";
 import { writeLlmRequestAuditLog } from "../audit/llmRequestAudit.js";
@@ -24,6 +25,7 @@ const forkPayloadSchema = z.object({
 export const buildChatRouter = (
   sessionBridge: ChatSessionBridge,
   runtime: OpencodeRuntimeAdapter,
+  memoryStore: MemoryStore,
 ) => {
   const chatRouter = Router();
 
@@ -44,12 +46,14 @@ export const buildChatRouter = (
         : authHeader;
       const projectId = req.header("x-project-id") ?? undefined;
       const traceId = req.header("x-trace-id") ?? undefined;
+      const userId = req.header("x-user-id") ?? undefined;
 
       const binding = await sessionBridge.abort({
         clientSessionId: parsed.data.session_id,
         accessToken,
         projectId,
         traceId,
+        userId,
       });
 
       if (!binding) {
@@ -97,6 +101,7 @@ export const buildChatRouter = (
         : authHeader;
       const projectId = req.header("x-project-id") ?? undefined;
       const traceId = req.header("x-trace-id") ?? undefined;
+      const userId = req.header("x-user-id") ?? undefined;
 
       const { binding, requestContext } = await sessionBridge.fork({
         clientSessionId: parsed.data.session_id,
@@ -104,6 +109,7 @@ export const buildChatRouter = (
         projectId,
         traceId,
         keepMessageCount: parsed.data.keep_message_count,
+        userId,
       });
 
       logger.info(
@@ -148,12 +154,14 @@ export const buildChatRouter = (
         : authHeader;
       const projectId = req.header("x-project-id") ?? undefined;
       const traceId = req.header("x-trace-id") ?? undefined;
+      const userId = req.header("x-user-id") ?? undefined;
 
       const { binding, requestContext, created } = await sessionBridge.resolve({
         clientSessionId: parsed.data.session_id,
         accessToken,
         projectId,
         traceId,
+        userId,
       });
 
       logger.info(
@@ -175,12 +183,6 @@ export const buildChatRouter = (
       res.flushHeaders?.();
 
       const clientSessionId = requestContext.clientSessionId;
-      const existingSessionTitle = sessionBridge.getSessionTitle(binding.sessionId);
-      const sessionTitle = existingSessionTitle
-        ?? (await generateSessionTitle(runtime, parsed.data.message));
-      if (!existingSessionTitle) {
-        sessionBridge.setSessionTitle(binding.sessionId, sessionTitle);
-      }
       let streamClosed = false;
       const abortController = new AbortController();
       const handleClientClose = () => {
@@ -193,18 +195,18 @@ export const buildChatRouter = (
       req.on("close", handleClientClose);
       res.on("close", handleClientClose);
 
-      try {
-        res.write(
-          toSse("session_title", {
-            session_id: clientSessionId,
-            title: sessionTitle,
-          }),
+        try {
+          const preparedMessage = await buildPromptWithLearningContext(
+            memoryStore,
+            requestContext.actorKey,
+            requestContext.projectKey,
+            parsed.data.message,
         );
-        await streamPromptResponse({
+        const streamResult = await streamPromptResponse({
           runtime,
           opencodeSessionId: binding.sessionId,
           clientSessionId,
-          message: parsed.data.message,
+          message: preparedMessage,
           traceId: requestContext.traceId,
           projectId: requestContext.projectId,
           signal: abortController.signal,
@@ -215,6 +217,32 @@ export const buildChatRouter = (
             res.write(toSse(event, data));
           },
         });
+
+        if (!streamResult.aborted && !streamResult.failed) {
+          const existingSessionTitle = sessionBridge.getSessionTitle(binding.sessionId);
+          let sessionTitle = existingSessionTitle;
+          const shouldGenerateTitle =
+            !existingSessionTitle &&
+            (await isFirstRoundConversation(runtime, binding.sessionId));
+          if (shouldGenerateTitle) {
+            sessionTitle = await generateSessionTitle(runtime, {
+              sessionId: binding.sessionId,
+              latestUserMessage: parsed.data.message,
+            });
+            sessionBridge.setSessionTitle(binding.sessionId, sessionTitle);
+          }
+          if (!streamClosed && !res.writableEnded && !res.destroyed) {
+            if (shouldGenerateTitle && sessionTitle) {
+              res.write(
+                toSse("session_title", {
+                  session_id: clientSessionId,
+                  title: sessionTitle,
+                }),
+              );
+            }
+            res.write(toSse("done", { session_id: clientSessionId }));
+          }
+        }
       } finally {
         streamClosed = true;
         req.off("close", handleClientClose);
@@ -322,16 +350,18 @@ const streamPromptResponse = async ({
   projectId,
   signal,
   write,
-}: StreamPromptOptions) => {
+}: StreamPromptOptions): Promise<{ aborted: boolean; failed: boolean }> => {
   const eventStream = await runtime.subscribeEvents();
   const iterator = eventStream[Symbol.asyncIterator]();
   const emittedToolParts = new Set<string>();
   const partTypes = new Map<string, Part["type"]>();
-  const pendingTextDeltas = new Map<string, string[]>();
+  const pendingPartTextDeltas = new Map<string, string[]>();
+  const reasoningDeltas = new Map<string, string[]>();
   let emittedText = false;
   let done = false;
   let promptSettled = false;
   let aborted = signal?.aborted ?? false;
+  let failed = false;
 
   const abortPromise = signal
     ? new Promise<{ type: "abort" }>((resolve) => {
@@ -351,6 +381,7 @@ const streamPromptResponse = async ({
     phase: "start",
     status: "running",
     title: "已收到请求，正在启动 Agent 分析",
+    detail: "已接收用户消息，正在建立会话并准备进入分析、规划和工具调用阶段。",
   });
 
   const promptPromise = runtime
@@ -418,6 +449,7 @@ const streamPromptResponse = async ({
               : event.properties.status.type === "busy"
                 ? "Agent 正在处理请求"
                 : "Agent 已空闲",
+          detail: buildSessionStatusDetail(event.properties.status),
         });
         continue;
       }
@@ -447,10 +479,14 @@ const streamPromptResponse = async ({
             session_id: clientSessionId,
             content: event.properties.delta,
           });
-        } else if (!partType) {
-          const pending = pendingTextDeltas.get(event.properties.partID) ?? [];
+        } else if (partType === "reasoning") {
+          const pending = reasoningDeltas.get(event.properties.partID) ?? [];
           pending.push(event.properties.delta);
-          pendingTextDeltas.set(event.properties.partID, pending);
+          reasoningDeltas.set(event.properties.partID, pending);
+        } else if (!partType) {
+          const pending = pendingPartTextDeltas.get(event.properties.partID) ?? [];
+          pending.push(event.properties.delta);
+          pendingPartTextDeltas.set(event.properties.partID, pending);
         }
         continue;
       }
@@ -459,8 +495,8 @@ const streamPromptResponse = async ({
         const part = event.properties.part;
         partTypes.set(part.id, part.type);
         if (part.type === "text") {
-          const pending = pendingTextDeltas.get(part.id) ?? [];
-          pendingTextDeltas.delete(part.id);
+          const pending = pendingPartTextDeltas.get(part.id) ?? [];
+          pendingPartTextDeltas.delete(part.id);
           for (const content of pending) {
             emittedText = true;
             write("token", {
@@ -469,13 +505,23 @@ const streamPromptResponse = async ({
             });
           }
         } else if (part.type === "reasoning") {
-          pendingTextDeltas.delete(part.id);
+          const pending = pendingPartTextDeltas.get(part.id) ?? [];
+          if (pending.length > 0) {
+            const existing = reasoningDeltas.get(part.id) ?? [];
+            reasoningDeltas.set(part.id, existing.concat(pending));
+          }
+          pendingPartTextDeltas.delete(part.id);
+          const reasoningDetail = buildReasoningProgressDetail(
+            reasoningDeltas.get(part.id) ?? [],
+            part.time.end,
+          );
           write("progress", {
             session_id: clientSessionId,
             id: part.id,
             phase: "planning",
             status: part.time.end ? "completed" : "running",
             title: part.time.end ? "分析规划完成" : "正在规划分析步骤",
+            detail: reasoningDetail,
           });
         }
         if (part.type === "tool") {
@@ -490,7 +536,13 @@ const streamPromptResponse = async ({
             phase: "tool",
             status: normalizeToolStatus(part.state.status),
             title: getToolProgressTitle(part.tool, part.state.status),
-            detail: part.state.status === "error" ? part.state.error : undefined,
+            detail: buildToolProgressDetail(
+              part.tool,
+              part.state.status,
+              toolParams,
+              reason,
+              part.state.status === "error" ? part.state.error : undefined,
+            ),
           });
           if (
             !emittedToolParts.has(part.id) &&
@@ -556,6 +608,7 @@ const streamPromptResponse = async ({
             : "opencode session error",
           detail: event.properties.error?.name,
         });
+        failed = true;
         done = true;
         continue;
       }
@@ -567,6 +620,7 @@ const streamPromptResponse = async ({
           phase: "session",
           status: "completed",
           title: "Agent 已完成处理",
+          detail: "当前会话已无待执行任务，正在收尾并准备返回最终结果。",
         });
         done = true;
       }
@@ -576,7 +630,11 @@ const streamPromptResponse = async ({
       await runtime.abortSession(opencodeSessionId).catch((error) => {
         logger.warn({ sessionId: opencodeSessionId, err: error }, "failed to abort opencode session");
       });
-      return;
+      return { aborted: true, failed: false };
+    }
+
+    if (failed) {
+      return { aborted: false, failed: true };
     }
 
     await promptPromise;
@@ -589,6 +647,7 @@ const streamPromptResponse = async ({
       phase: "start",
       status: "completed",
       title: "请求处理完成",
+      detail: "本次请求的分析、工具执行和结果整理流程已经完成。",
     });
     write("progress", {
       session_id: clientSessionId,
@@ -596,8 +655,11 @@ const streamPromptResponse = async ({
       phase: "complete",
       status: "completed",
       title: "分析完成",
+      detail: emittedText
+        ? "最终回答已生成并推送到前端。"
+        : "已完成分析，并通过兜底消息补发最终回答内容。",
     });
-    write("done", { session_id: clientSessionId });
+    return { aborted: false, failed: false };
   } finally {
     await iterator.return?.(undefined);
     if (!promptSettled) {
@@ -645,6 +707,97 @@ const normalizeToolStatus = (status: string) => {
   return "running";
 };
 
+const formatProgressValue = (value: unknown): string => {
+  if (typeof value === "string") {
+    return value.length > 120 ? `${value.slice(0, 117)}...` : value;
+  }
+  if (
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    value === null ||
+    value === undefined
+  ) {
+    return String(value);
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized.length > 120 ? `${serialized.slice(0, 117)}...` : serialized;
+  } catch {
+    return "[unserializable]";
+  }
+};
+
+const normalizeProgressText = (chunks: string[]) => chunks.join("").replace(/\s+/g, " ").trim();
+
+const truncateProgressText = (text: string, maxLength: number) =>
+  text.length > maxLength ? `${text.slice(0, maxLength - 3)}...` : text;
+
+const summarizeToolParams = (params: Record<string, unknown>) => {
+  const ignoredKeys = new Set(["reason", "request_reason", "why", "purpose", "rationale"]);
+  const summary = Object.entries(params)
+    .filter(([key]) => !ignoredKeys.has(key))
+    .slice(0, 4)
+    .map(([key, value]) => `${key}=${formatProgressValue(value)}`)
+    .join(", ");
+
+  return summary || "无附加参数";
+};
+
+const buildSessionStatusDetail = (status: { type: string; message?: string }) => {
+  if (status.type === "retry") {
+    return status.message
+      ? `模型请求需要重试，原因：${status.message}`
+      : "模型请求正在重试，等待下一次响应。";
+  }
+  if (status.type === "busy") {
+    return status.message
+      ? `Agent 正在处理中：${status.message}`
+      : "Agent 正在执行推理、工具调用或结果整理。";
+  }
+  if (status.type === "idle") {
+    return status.message
+      ? `Agent 已空闲：${status.message}`
+      : "当前会话暂时没有待处理任务。";
+  }
+  return status.message ? `会话状态更新：${status.message}` : `会话状态更新：${status.type}`;
+};
+
+const buildReasoningProgressDetail = (chunks: string[], ended?: string | number | Date | null) => {
+  const reasoningText = truncateProgressText(normalizeProgressText(chunks), 800);
+  if (ended) {
+    return reasoningText
+      ? `推理过程：${reasoningText}`
+      : "当前推理阶段已完成，Agent 将继续输出答案或进入工具执行。";
+  }
+  return reasoningText
+    ? `正在推理：${reasoningText}`
+    : "Agent 正在拆解问题、梳理执行步骤并判断是否需要调用工具。";
+};
+
+const buildToolProgressDetail = (
+  tool: string,
+  status: string,
+  params: Record<string, unknown>,
+  reason: string,
+  error?: string,
+) => {
+  const toolName = toolLabels[tool] ?? tool;
+  const reasonText = reason ? `；调用原因：${reason}` : "";
+  const paramsText = `；关键参数：${summarizeToolParams(params)}`;
+
+  if (status === "error") {
+    const errorText = error ? `；错误：${error}` : "";
+    return `${toolName} 调用失败${reasonText}${paramsText}${errorText}`;
+  }
+  if (status === "completed") {
+    return `${toolName} 已执行完成${reasonText}${paramsText}`;
+  }
+  if (status === "pending") {
+    return `${toolName} 已进入待执行状态${reasonText}${paramsText}`;
+  }
+  return `${toolName} 正在执行${reasonText}${paramsText}`;
+};
+
 const getToolProgressTitle = (tool: string, status: string) => {
   const toolName = toolLabels[tool] ?? tool;
   if (status === "completed") return `${toolName} 已完成`;
@@ -665,51 +818,100 @@ const TITLE_PROMPT_TIMEOUT_MS = 2500;
 
 const generateSessionTitle = async (
   runtime: OpencodeRuntimeAdapter,
-  userMessage: string,
+  options: {
+    sessionId: string;
+    latestUserMessage: string;
+    fallbackTitle?: string;
+  },
 ) => {
-  const fallback = buildSessionTitle(userMessage);
-  const normalized = userMessage.replace(/\s+/g, " ").trim();
-  if (!normalized) {
-    return fallback;
-  }
+  const fallback = options.fallbackTitle?.trim() || buildSessionTitle(options.latestUserMessage);
+  let titleSessionId: string | undefined;
+  try {
+    const conversation = await buildTitleConversationContext(runtime, options.sessionId);
+    if (!conversation) {
+      return fallback;
+    }
 
-  const titleSession = await runtime.createSession(`title-${Date.now().toString(36)}`);
-  const request = runtime
-    .prompt(
-      titleSession.id,
-      [
-        "你是会话标题生成器。",
-        "请根据用户问题生成一个 8-16 字中文标题。",
-        "要求：简洁、可读、避免标点、不要引号、不要解释。",
-        "只输出标题本身。",
-        `用户问题：${normalized}`,
-      ].join("\n"),
-    )
-    .then(async () => {
-      const messages = await runtime.messages(titleSession.id, 20);
-      const assistantMessage = [...messages]
-        .reverse()
-        .find((message) => message.info.role === "assistant");
-      const title = collectTextContent(assistantMessage?.parts ?? []);
-      return normalizeGeneratedTitle(title, fallback);
+    const titleSession = await runtime.createSession(`title-${Date.now().toString(36)}`);
+    titleSessionId = titleSession.id;
+    const request = runtime
+      .prompt(
+        titleSession.id,
+        [
+          "你是会话标题生成器。",
+          "请根据用户问题生成一个 8-16 字中文标题。",
+          "要求：简洁、可读、避免标点、不要引号、不要解释。",
+          "请优先概括最近这轮对话的核心任务或结论。",
+          "只输出标题本身。",
+          "",
+          conversation,
+        ].join("\n"),
+      )
+      .then(async () => {
+        const messages = await runtime.messages(titleSession.id, 20);
+        const assistantMessage = [...messages]
+          .reverse()
+          .find((message) => message.info.role === "assistant");
+        const title = collectTextContent(assistantMessage?.parts ?? []);
+        return normalizeGeneratedTitle(title, fallback);
+      });
+
+    const timeout = new Promise<string>((resolve) => {
+      setTimeout(() => resolve(fallback), TITLE_PROMPT_TIMEOUT_MS);
     });
 
-  const timeout = new Promise<string>((resolve) => {
-    setTimeout(() => resolve(fallback), TITLE_PROMPT_TIMEOUT_MS);
-  });
-
-  try {
     return await Promise.race([request, timeout]);
   } catch (error) {
     logger.warn({ err: error }, "failed to generate session title, using fallback");
     return fallback;
   } finally {
-    await runtime.abortSession(titleSession.id).catch((error) => {
-      logger.debug({ sessionId: titleSession.id, err: error }, "failed to cleanup title session");
-    });
+    if (titleSessionId) {
+      await runtime.abortSession(titleSessionId).catch((error) => {
+        logger.debug({ sessionId: titleSessionId, err: error }, "failed to cleanup title session");
+      });
+    }
   }
 };
 
+const buildTitleConversationContext = async (
+  runtime: OpencodeRuntimeAdapter,
+  sessionId: string,
+) => {
+  const messages = await runtime.messages(sessionId, 12);
+  const recentMessages = messages
+    .filter(
+      (message) =>
+        message.info.role === "user" || message.info.role === "assistant",
+    )
+    .map((message) => ({
+      role: message.info.role,
+      content: collectTextContent(message.parts).replace(/\s+/g, " ").trim(),
+    }))
+    .filter((message) => message.content.length > 0)
+    .slice(-6);
+
+  if (recentMessages.length === 0) {
+    return "";
+  }
+
+  return recentMessages
+    .map((message) => `${message.role === "user" ? "用户" : "助手"}：${message.content}`)
+    .join("\n")
+    .slice(0, 2400);
+};
+
+const isFirstRoundConversation = async (
+  runtime: OpencodeRuntimeAdapter,
+  sessionId: string,
+) => {
+  const messages = await runtime.messages(sessionId, 12);
+  const chatMessageCount = messages.filter(
+    (message) =>
+      message.info.role === "user" || message.info.role === "assistant",
+  ).length;
+  return chatMessageCount === 2;
+};
+
 const normalizeGeneratedTitle = (rawTitle: string, fallback: string) => {
   const normalized = rawTitle
     .replace(/\s+/g, " ")
@@ -723,8 +925,24 @@ const normalizeGeneratedTitle = (rawTitle: string, fallback: string) => {
 
 const toolLabels: Record<string, string> = {
   dynamic_http_call: "后端数据查询",
+  fetch_result_ref: "结果引用回读",
+  memory_manager: "记忆写入",
+  skill_manager: "流程沉淀",
   locate_features: "地图定位",
   view_history: "历史数据面板",
   view_scada: "SCADA 面板",
   show_chart: "图表渲染",
 };
+
+const buildPromptWithLearningContext = async (
+  memoryStore: MemoryStore,
+  actorKey: string,
+  projectKey: string,
+  message: string,
+) => {
+  const snapshot = await memoryStore.buildPromptSnapshot({ actorKey, projectKey });
+  if (!snapshot) {
+    return message;
+  }
+  return `${snapshot}\n\n[Current user request]\n${message}`;
+};

src/server.ts

@@ -1,22 +1,26 @@
 import { randomUUID } from "node:crypto";
-
 import cors from "cors";
 import express from "express";
 
 import { ChatSessionBridge } from "./chat/sessionBridge.js";
 import { config } from "./config.js";
 import { logger } from "./logger.js";
+import { MemoryStore } from "./memory/store.js";
+import { ResultReferenceStore } from "./results/store.js";
 import { buildChatRouter } from "./routes/chat.js";
 import { opencodeRuntime } from "./runtime/opencode.js";
 import { SessionRegistry } from "./session/registry.js";
-import { dynamicHttpExecutor } from "./tools/dynamicHttpExecutor.js";
+import { DynamicHttpExecutor } from "./tools/dynamicHttpExecutor.js";
 
 const app = express();
 const registry = new SessionRegistry(config.SESSION_TTL_SECONDS);
 const sessionBridge = new ChatSessionBridge(registry, opencodeRuntime);
+const memoryStore = new MemoryStore();
+const resultReferenceStore = new ResultReferenceStore();
+const dynamicHttpExecutor = new DynamicHttpExecutor(resultReferenceStore);
 const internalToken = config.AGENT_INTERNAL_TOKEN ?? randomUUID();
 
-// 这个 token 只用于 .opencode/tools 回调本服务，避免把 internal endpoint 暴露成无鉴权入口。
+// 这个 token 只用于仍需服务端上下文的工具桥（dynamic_http_call / fetch_result_ref）。
 process.env.TJWATER_AGENT_INTERNAL_TOKEN = internalToken;
 
 app.use(cors());
@@ -66,7 +70,15 @@ app.post("/internal/tools/dynamic-http-call", async (req, res) => {
         method: req.body?.method,
         arguments: req.body?.arguments,
       },
-      context,
+      {
+        accessToken: context.accessToken,
+        actorKey: context.actorKey,
+        clientSessionId: context.clientSessionId,
+        projectId: context.projectId,
+        projectKey: context.projectKey,
+        sessionId,
+        traceId: context.traceId,
+      },
     );
     res.json(result);
   } catch (error) {
@@ -78,7 +90,53 @@ app.post("/internal/tools/dynamic-http-call", async (req, res) => {
   }
 });
 
-app.use("/api/v1/agent/chat", buildChatRouter(sessionBridge, opencodeRuntime));
+app.post("/internal/tools/fetch-result-ref", async (req, res) => {
+  if (req.header("x-agent-internal-token") !== internalToken) {
+    res.status(403).json({ message: "forbidden" });
+    return;
+  }
+
+  const sessionId = typeof req.body?.sessionId === "string" ? req.body.sessionId : "";
+  const resultRef = typeof req.body?.result_ref === "string" ? req.body.result_ref : "";
+  const context = sessionBridge.getSessionContext(sessionId);
+  if (!context) {
+    res.status(404).json({
+      message: "session context not found",
+      detail: sessionId,
+    });
+    return;
+  }
+  if (!resultRef) {
+    res.status(400).json({ message: "result_ref is required" });
+    return;
+  }
+
+  const result = await resultReferenceStore.getAuthorized(resultRef, {
+    actorKey: context.actorKey,
+    maxItems:
+      typeof req.body?.max_items === "number" ? req.body.max_items : undefined,
+    projectId: context.projectId,
+  });
+
+  if (!result) {
+    res.status(404).json({ message: "result_ref not found" });
+    return;
+  }
+
+  res.json(result);
+});
+
+app.use(
+  "/api/v1/agent/chat",
+  buildChatRouter(sessionBridge, opencodeRuntime, memoryStore),
+);
+
+const bootstrap = async () => {
+  await Promise.all([memoryStore.initialize(), resultReferenceStore.initialize()]);
+  resultReferenceStore.startCleanupLoop();
+};
+
+await bootstrap();
 
 const server = app.listen(config.PORT, config.HOST, () => {
   logger.info(
@@ -90,6 +148,7 @@ const server = app.listen(config.PORT, config.HOST, () => {
 const shutdown = async () => {
   logger.info("shutting down TJWaterAgent");
   server.close();
+  resultReferenceStore.stopCleanupLoop();
   // 同步关闭 embedded opencode server，避免本服务退出后留下孤儿进程。
   await opencodeRuntime.dispose();
 };

src/session/registry.ts

@@ -10,6 +10,7 @@ export type SessionContext = {
   clientSessionId: string;
   accessToken?: string;
   projectId?: string;
+  userId?: string;
 };
 
 export class SessionRegistry {
@@ -68,7 +69,7 @@ export class SessionRegistry {
       .update(
         [
           context.clientSessionId,
-          context.accessToken ?? "",
+          context.userId?.trim() ?? "",
           context.projectId ?? "",
         ].join("|"),
       )

src/session/toolContextStore.ts

@@ -0,0 +1,42 @@
+import { join } from "node:path";
+
+import { config } from "../config.js";
+import {
+  atomicWriteJson,
+  ensureDirectory,
+  readJsonFile,
+  removeFileIfExists,
+} from "../utils/fileStore.js";
+
+export type ToolSessionContext = {
+  actorKey: string;
+  clientSessionId: string;
+  projectId?: string;
+  projectKey: string;
+  sessionId: string;
+  traceId: string;
+};
+
+export class ToolSessionContextStore {
+  constructor(private readonly baseDir = config.SESSION_CONTEXT_STORAGE_DIR) {}
+
+  async initialize() {
+    await ensureDirectory(this.baseDir);
+  }
+
+  async write(context: ToolSessionContext) {
+    await atomicWriteJson(this.filePath(context.sessionId), context);
+  }
+
+  async read(sessionId: string) {
+    return await readJsonFile<ToolSessionContext>(this.filePath(sessionId));
+  }
+
+  async remove(sessionId: string) {
+    await removeFileIfExists(this.filePath(sessionId));
+  }
+
+  private filePath(sessionId: string) {
+    return join(this.baseDir, `${sessionId}.json`);
+  }
+}

src/tools/dynamicHttpExecutor.ts

@@ -1,7 +1,6 @@
-import { randomUUID } from "node:crypto";
-
 import { config } from "../config.js";
 import { logger } from "../logger.js";
+import { ResultReferenceStore } from "../results/store.js";
 
 export type DynamicHttpInput = {
   reason?: string;
@@ -12,20 +11,19 @@ export type DynamicHttpInput = {
 
 export type SessionToolContext = {
   accessToken?: string;
+  actorKey: string;
+  clientSessionId: string;
+  projectKey: string;
+  sessionId: string;
   projectId?: string;
   traceId: string;
 };
 
-type StoredResult = {
-  rawResult: unknown;
-  traceId: string;
-  projectId?: string;
-};
-
 const allowedMethods = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-const resultStore = new Map<string, StoredResult>();
 
 export class DynamicHttpExecutor {
+  constructor(private readonly resultStore: ResultReferenceStore) {}
+
   async execute(input: DynamicHttpInput, context: SessionToolContext) {
     const method = (input.method ?? "GET").trim().toUpperCase();
     if (!allowedMethods.has(method)) {
@@ -106,17 +104,11 @@ export class DynamicHttpExecutor {
         path,
         status_code: response.status,
       },
-      ...normalizeSuccessResult(data, context),
+      ...(await normalizeSuccessResult(data, context, this.resultStore)),
     };
   }
-
-  getResult(resultRef: string) {
-    return resultStore.get(resultRef);
-  }
 }
 
-export const dynamicHttpExecutor = new DynamicHttpExecutor();
-
 const buildQuery = (argumentsObject: Record<string, unknown>) => {
   const pairs: Array<[string, string]> = [];
   for (const [key, value] of Object.entries(argumentsObject)) {
@@ -135,7 +127,11 @@ const buildQuery = (argumentsObject: Record<string, unknown>) => {
   return pairs;
 };
 
-const normalizeSuccessResult = (data: unknown, context: SessionToolContext) => {
+const normalizeSuccessResult = async (
+  data: unknown,
+  context: SessionToolContext,
+  resultStore: ResultReferenceStore,
+) => {
   const sizeBytes = estimateBytes(data);
   if (sizeBytes <= config.MAX_INLINE_RESULT_BYTES) {
     return {
@@ -145,59 +141,23 @@ const normalizeSuccessResult = (data: unknown, context: SessionToolContext) => {
     };
   }
 
-  const resultRef = `res-${randomUUID().slice(0, 16)}`;
-  // 大结果先落本地引用，避免工具输出把模型上下文直接撑爆。
-  resultStore.set(resultRef, {
-    rawResult: data,
-    traceId: context.traceId,
+  // 大结果转成持久化引用，支持 review 和跨重启回读。
+  const record = await resultStore.store({
+    actorKey: context.actorKey,
+    clientSessionId: context.clientSessionId,
+    data,
     projectId: context.projectId,
+    projectKey: context.projectKey,
+    sessionId: context.sessionId,
+    traceId: context.traceId,
   });
 
   return {
     result_mode: "referenced",
     result_size_bytes: sizeBytes,
-    result_ref: resultRef,
-    preview: buildPreview(data),
+    result_ref: record.resultRef,
+    preview: record.preview,
   };
 };
 
 const estimateBytes = (data: unknown) => Buffer.byteLength(JSON.stringify(data));
-
-const buildPreview = (data: unknown) => {
-  if (Array.isArray(data)) {
-    const sample = data.slice(0, config.MAX_PREVIEW_SAMPLE_ITEMS);
-    const fields =
-      sample.length > 0 && isRecord(sample[0])
-        ? Object.keys(sample[0]).slice(0, 30)
-        : [];
-    return {
-      count: data.length,
-      fields,
-      sample,
-      summary: `list[${data.length}]`,
-    };
-  }
-
-  if (isRecord(data)) {
-    const fields = Object.keys(data).slice(0, 30);
-    const sample = Object.fromEntries(
-      fields.slice(0, config.MAX_PREVIEW_SAMPLE_ITEMS).map((field) => [field, data[field]]),
-    );
-    return {
-      count: fields.length,
-      fields,
-      sample,
-      summary: `object<${fields.length} fields>`,
-    };
-  }
-
-  return {
-    count: 1,
-    fields: [],
-    sample: String(data).slice(0, 300),
-    summary: `scalar<${typeof data}>`,
-  };
-};
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);

src/utils/fileStore.ts

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+type JsonRecord = Record<string, unknown>;
+
+const isErrnoException = (error: unknown): error is NodeJS.ErrnoException =>
+  error instanceof Error && "code" in error;
+
+export const ensureDirectory = async (path: string) => {
+  await mkdir(path, { recursive: true });
+};
+
+export const atomicWriteFile = async (path: string, content: string) => {
+  await ensureDirectory(dirname(path));
+  const tempPath = `${path}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  await writeFile(tempPath, content, "utf8");
+  await rename(tempPath, path);
+};
+
+export const atomicWriteJson = async (path: string, value: JsonRecord | unknown[]) => {
+  await atomicWriteFile(path, JSON.stringify(value, null, 2));
+};
+
+export const readJsonFile = async <T>(path: string): Promise<T | null> => {
+  try {
+    const content = await readFile(path, "utf8");
+    return JSON.parse(content) as T;
+  } catch (error) {
+    if (isErrnoException(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+
+export const readTextFile = async (path: string): Promise<string | null> => {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (isErrnoException(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+
+export const listJsonFiles = async (path: string) => {
+  try {
+    const names = await readdir(path);
+    return names.filter((name) => name.endsWith(".json")).map((name) => join(path, name));
+  } catch (error) {
+    if (isErrnoException(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+};
+
+export const listFiles = async (path: string) => {
+  try {
+    const names = await readdir(path);
+    return names.map((name) => join(path, name));
+  } catch (error) {
+    if (isErrnoException(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+};
+
+export const removeFileIfExists = async (path: string) => {
+  try {
+    await rm(path, { force: true });
+  } catch (error) {
+    if (isErrnoException(error) && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+};
+
+export const getFileStat = async (path: string) => {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if (isErrnoException(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+
+export const toScopedKey = (prefix: string, value?: string) => {
+  const normalized = value?.trim() || `${prefix}-default`;
+  return `${prefix}-${createHash("sha256").update(normalized).digest("hex").slice(0, 16)}`;
+};
+
+export const toActorKey = (userId?: string) => toScopedKey("actor", userId);
+
+export const toProjectKey = (projectId?: string) => toScopedKey("project", projectId);
+
+export const toStableId = (...parts: string[]) =>
+  createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 24);
+
+export const slugify = (value: string) =>
+  value
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 64) || "entry";

src/utils/persistencePolicy.ts

@@ -0,0 +1,43 @@
+const FORBIDDEN_PERSISTENCE_PATTERNS = [
+  /ignore\s+(all|previous|prior|above)\s+instructions/i,
+  /system\s+prompt/i,
+  /do\s+not\s+tell\s+the\s+user/i,
+  /curl\s+.*(token|secret|password|api)/i,
+  /bearer\s+[a-z0-9._-]{16,}/i,
+  /(api[_-]?key|access[_-]?token|refresh[_-]?token|secret|password)\s*[:=]/i,
+  /eyJ[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9._-]{8,}\.[a-zA-Z0-9._-]{8,}/,
+];
+
+export const sanitizePersistentLine = (content: string, maxLength: number) => {
+  const normalized = content.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return "";
+  }
+  if (FORBIDDEN_PERSISTENCE_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return "";
+  }
+  if (normalized.length > maxLength) {
+    return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+  }
+  return normalized;
+};
+
+export const sanitizePersistentDocument = (content: string, maxLength: number) => {
+  const normalized = content
+    .replace(/\r\n/g, "\n")
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  if (!normalized) {
+    return "";
+  }
+  if (FORBIDDEN_PERSISTENCE_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return "";
+  }
+  if (normalized.length > maxLength) {
+    return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+  }
+  return normalized;
+};