@downcity/agent 1.1.73 → 1.1.79

package/src/agent/remote/transports/HttpRemoteAgentTransport.ts

@@ -0,0 +1,347 @@
+/**
+ * RemoteAgent HTTP transport。
+ *
+ * 关键点（中文）
+ * - 只适配 Town Agent HTTP gateway 的 SDK routes。
+ * - 不处理 RemoteSession 的 turn lifecycle，避免 transport 与 actor 逻辑混在一起。
+ */
+
+import type {
+  AgentCreateSessionInput,
+  AgentListSessionsInput,
+  AgentSessionForkInput,
+  AgentSessionHistoryInput,
+  AgentSessionHistoryPage,
+  AgentSessionInfo,
+  AgentSessionSummaryPage,
+  AgentSessionSystemSnapshot,
+} from "@/types/agent/AgentTypes.js";
+import type { AgentSessionEvent } from "@/types/sdk/AgentSessionEvent.js";
+import type { AgentSessionPromptInput } from "@/types/sdk/AgentSessionPrompt.js";
+import type {
+  RemoteAgentTransport,
+  TransportSubscription,
+} from "@/agent/remote/RemoteTransport.js";
+
+type SdkEventsReadyFrame = {
+  /** SDK HTTP events 连接内部 ready 标记。 */
+  type: "sdk-events-ready";
+};
+
+/**
+ * Town HTTP gateway transport。
+ */
+export class HttpRemoteAgentTransport implements RemoteAgentTransport {
+  private readonly base_url: string;
+  private readonly token: string;
+
+  constructor(url: string, token?: string) {
+    this.base_url = url.replace(/\/+$/, "");
+    this.token = String(token || "").trim();
+  }
+
+  private headers(input?: Record<string, string>): Headers {
+    const headers = new Headers(input);
+    if (this.token) {
+      headers.set("Authorization", `Bearer ${this.token}`);
+    }
+    return headers;
+  }
+
+  async create_session(input?: AgentCreateSessionInput): Promise<AgentSessionInfo> {
+    const payload = await read_http_json<{
+      success?: boolean;
+      error?: string;
+      session?: AgentSessionInfo;
+    }>(`${this.base_url}/api/sdk/sessions`, {
+      method: "POST",
+      headers: this.headers({
+        "Content-Type": "application/json",
+      }),
+      body: JSON.stringify({
+        ...(input?.sessionId ? { sessionId: input.sessionId } : {}),
+      }),
+    });
+    if (!payload.success || !payload.session?.sessionId) {
+      throw new Error(String(payload.error || "Remote session create failed"));
+    }
+    return payload.session;
+  }
+
+  async get_info(session_id: string): Promise<AgentSessionInfo> {
+    const payload = await read_http_json<{
+      success?: boolean;
+      error?: string;
+      session?: AgentSessionInfo;
+    }>(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}`, {
+      headers: this.headers(),
+    });
+    if (!payload.success || !payload.session?.sessionId) {
+      throw new Error(String(payload.error || "Remote session info failed"));
+    }
+    return payload.session;
+  }
+
+  async prompt(
+    session_id: string,
+    input: AgentSessionPromptInput,
+  ): Promise<{ id: string }> {
+    const payload = await read_http_json<{
+      success?: boolean;
+      error?: string;
+      turn?: {
+        id?: string;
+      };
+    }>(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/prompt`, {
+      method: "POST",
+      headers: this.headers({
+        "Content-Type": "application/json",
+      }),
+      body: JSON.stringify({
+        query: input.query,
+      }),
+    });
+    const id = String(payload.turn?.id || "").trim();
+    if (!payload.success || !id) {
+      throw new Error(String(payload.error || "Remote session prompt failed"));
+    }
+    return { id };
+  }
+
+  async subscribe(params: {
+    session_id: string;
+    on_ready: () => void;
+    on_event: (event: AgentSessionEvent) => void;
+  }): Promise<TransportSubscription> {
+    const abort_controller = new AbortController();
+    let resolve_ready!: () => void;
+    let reject_ready!: (error: unknown) => void;
+    const ready_promise = new Promise<void>((resolve, reject) => {
+      resolve_ready = resolve;
+      reject_ready = reject;
+    });
+    const response = await fetch(
+      `${this.base_url}/api/sdk/sessions/${encodeURIComponent(params.session_id)}/events`,
+      {
+        headers: this.headers(),
+        signal: abort_controller.signal,
+      },
+    );
+    if (!response.ok || !response.body) {
+      const text = await response.text().catch(() => "");
+      throw new Error(text || `Remote session events failed (${response.status})`);
+    }
+    void consume_http_event_stream({
+      body: response.body,
+      abort_controller,
+      on_ready: () => {
+        params.on_ready();
+        resolve_ready();
+      },
+      on_ready_error: (error) => {
+        reject_ready(error);
+      },
+      on_event: params.on_event,
+    });
+    await ready_promise;
+    return {
+      close: async () => {
+        abort_controller.abort();
+      },
+    };
+  }
+
+  async history(
+    session_id: string,
+    input?: AgentSessionHistoryInput,
+  ): Promise<AgentSessionHistoryPage> {
+    const query = new URLSearchParams();
+    if (input?.limit !== undefined) query.set("limit", String(input.limit));
+    if (input?.cursor) query.set("cursor", input.cursor);
+    if (input?.order) query.set("order", input.order);
+    if (input?.view) query.set("view", input.view);
+    const payload = await read_http_json<{
+      success?: boolean;
+      error?: string;
+      history?: AgentSessionHistoryPage;
+    }>(
+      `${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/history${
+        query.size > 0 ? `?${query.toString()}` : ""
+      }`,
+      {
+        headers: this.headers(),
+      },
+    );
+    if (!payload.success || !payload.history || !Array.isArray(payload.history.items)) {
+      throw new Error(String(payload.error || "Remote session history failed"));
+    }
+    return payload.history;
+  }
+
+  async system(session_id: string): Promise<AgentSessionSystemSnapshot> {
+    const payload = await read_http_json<{
+      success?: boolean;
+      error?: string;
+      system?: AgentSessionSystemSnapshot;
+    }>(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/system`, {
+      headers: this.headers(),
+    });
+    if (!payload.success || !payload.system || !Array.isArray(payload.system.blocks)) {
+      throw new Error(String(payload.error || "Remote session system failed"));
+    }
+    return payload.system;
+  }
+
+  async fork(
+    session_id: string,
+    input?: AgentSessionForkInput | string,
+  ): Promise<AgentSessionInfo> {
+    const message_id =
+      typeof input === "string"
+        ? String(input || "").trim() || undefined
+        : String(input?.messageId || "").trim() || undefined;
+    const payload = await read_http_json<{
+      success?: boolean;
+      error?: string;
+      session?: AgentSessionInfo;
+    }>(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/fork`, {
+      method: "POST",
+      headers: this.headers({
+        "Content-Type": "application/json",
+      }),
+      body: JSON.stringify({
+        ...(message_id ? { messageId: message_id } : {}),
+      }),
+    });
+    if (!payload.success || !payload.session?.sessionId) {
+      throw new Error(String(payload.error || "Remote session fork failed"));
+    }
+    return payload.session;
+  }
+
+  async list_sessions(input?: AgentListSessionsInput): Promise<AgentSessionSummaryPage> {
+    const query = new URLSearchParams();
+    if (input?.limit !== undefined) query.set("limit", String(input.limit));
+    if (input?.cursor) query.set("cursor", input.cursor);
+    if (input?.query) query.set("query", input.query);
+    const payload = await read_http_json<{
+      success?: boolean;
+      error?: string;
+      page?: AgentSessionSummaryPage;
+    }>(
+      `${this.base_url}/api/sdk/sessions${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        headers: this.headers(),
+      },
+    );
+    if (!payload.success || !payload.page) {
+      throw new Error(String(payload.error || "Remote sessions list failed"));
+    }
+    return payload.page;
+  }
+}
+
+async function read_http_json<T>(input: string, init?: RequestInit): Promise<T> {
+  const response = await fetch(input, init);
+  const payload = (await response.json().catch(() => ({}))) as T;
+  if (!response.ok) {
+    const message = extract_error_message(payload);
+    throw new Error(message || `HTTP ${response.status}`);
+  }
+  return payload;
+}
+
+async function consume_http_event_stream(params: {
+  body: ReadableStream<Uint8Array>;
+  abort_controller: AbortController;
+  on_ready: () => void;
+  on_ready_error: (error: unknown) => void;
+  on_event: (event: AgentSessionEvent) => void;
+}): Promise<void> {
+  const decoder = new TextDecoder();
+  const reader = params.body.getReader();
+  let buffered = "";
+  let ready_resolved = false;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      let newline_index = buffered.indexOf("\n");
+      while (newline_index >= 0) {
+        const line = buffered.slice(0, newline_index).trim();
+        buffered = buffered.slice(newline_index + 1);
+        if (line) {
+          const value = JSON.parse(line) as unknown;
+          if (is_sdk_events_ready_frame(value)) {
+            ready_resolved = true;
+            params.on_ready();
+          } else {
+            params.on_event(value as AgentSessionEvent);
+          }
+        }
+        newline_index = buffered.indexOf("\n");
+      }
+    }
+
+    const tail = buffered.trim();
+    if (tail) {
+      const value = JSON.parse(tail) as unknown;
+      if (is_sdk_events_ready_frame(value)) {
+        ready_resolved = true;
+        params.on_ready();
+      } else {
+        params.on_event(value as AgentSessionEvent);
+      }
+    }
+
+    if (!params.abort_controller.signal.aborted) {
+      if (!ready_resolved) {
+        const error = new Error("Remote session events connection closed before ready");
+        params.on_ready_error(error);
+        throw error;
+      }
+      params.on_event({
+        type: "error",
+        message: "Remote session events connection closed",
+      });
+    }
+  } catch (error) {
+    if (!params.abort_controller.signal.aborted) {
+      if (!ready_resolved) {
+        params.on_ready_error(error);
+      }
+      params.on_event({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function extract_error_message(payload: unknown): string {
+  if (!payload || typeof payload !== "object") return "";
+  if ("error" in payload && typeof payload.error === "string") {
+    return payload.error;
+  }
+  if ("message" in payload && typeof payload.message === "string") {
+    return payload.message;
+  }
+  return "";
+}
+
+function is_sdk_events_ready_frame(value: unknown): value is SdkEventsReadyFrame {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "type" in value &&
+    (value as { type?: unknown }).type === "sdk-events-ready"
+  );
+}

package/src/agent/remote/transports/RpcRemoteAgentTransport.ts

@@ -0,0 +1,107 @@
+/**
+ * RemoteAgent RPC transport。
+ *
+ * 关键点（中文）
+ * - 只把 RemoteAgent 的 session actor 方法映射到 RpcClient。
+ * - 长连接生命周期由 RpcClient 管理。
+ */
+
+import type {
+  AgentCreateSessionInput,
+  AgentListSessionsInput,
+  AgentSessionForkInput,
+  AgentSessionHistoryInput,
+  AgentSessionHistoryPage,
+  AgentSessionInfo,
+  AgentSessionSummaryPage,
+  AgentSessionSystemSnapshot,
+} from "@/types/agent/AgentTypes.js";
+import type { AgentSessionEvent } from "@/types/sdk/AgentSessionEvent.js";
+import type { AgentSessionPromptInput } from "@/types/sdk/AgentSessionPrompt.js";
+import { RpcClient, parse_rpc_url } from "@/rpc/Client.js";
+import type {
+  RemoteAgentTransport,
+  TransportSubscription,
+} from "@/agent/remote/RemoteTransport.js";
+
+/**
+ * 本机 RPC transport。
+ */
+export class RpcRemoteAgentTransport implements RemoteAgentTransport {
+  private readonly client: RpcClient;
+
+  constructor(url: string) {
+    this.client = new RpcClient(parse_rpc_url(url));
+  }
+
+  async create_session(input?: AgentCreateSessionInput): Promise<AgentSessionInfo> {
+    return await this.client.create_session(input);
+  }
+
+  async get_info(session_id: string): Promise<AgentSessionInfo> {
+    return await this.client.get_session(session_id);
+  }
+
+  async prompt(
+    session_id: string,
+    input: AgentSessionPromptInput,
+  ): Promise<{ id: string }> {
+    return await this.client.prompt_session({
+      session_id,
+      input,
+    });
+  }
+
+  async subscribe(params: {
+    session_id: string;
+    on_ready: () => void;
+    on_event: (event: AgentSessionEvent) => void;
+  }): Promise<TransportSubscription> {
+    const subscription = await this.client.subscribe_session({
+      session_id: params.session_id,
+      on_ready: params.on_ready,
+      on_event: params.on_event,
+    });
+    return {
+      close: async () => {
+        await subscription.unsubscribe();
+      },
+    };
+  }
+
+  async history(
+    session_id: string,
+    input?: AgentSessionHistoryInput,
+  ): Promise<AgentSessionHistoryPage> {
+    return await this.client.get_session_history({
+      session_id,
+      input,
+    });
+  }
+
+  async system(session_id: string): Promise<AgentSessionSystemSnapshot> {
+    return await this.client.get_session_system(session_id);
+  }
+
+  async fork(
+    session_id: string,
+    input?: AgentSessionForkInput | string,
+  ): Promise<AgentSessionInfo> {
+    const message_id =
+      typeof input === "string"
+        ? String(input || "").trim() || undefined
+        : String(input?.messageId || "").trim() || undefined;
+    return await this.client.fork_session({
+      session_id,
+      ...(message_id ? { message_id } : {}),
+    });
+  }
+
+  async list_sessions(input?: AgentListSessionsInput): Promise<AgentSessionSummaryPage> {
+    return await this.client.list_sessions(input);
+  }
+
+  async close(): Promise<void> {
+    await this.client.close();
+  }
+}

package/src/config/AgentInitializer.ts

@@ -7,7 +7,7 @@
  * - 负责把用户在创建阶段提供的最小执行配置与渠道配置写入项目。
  *
  * 边界说明（中文）
- * - 这里只处理“初始化一个新项目”所需的静态文件与目录，不处理 daemon 启停。
+ * - 这里只处理“初始化一个新项目”所需的静态文件与目录，不处理 Town 托管进程启停。
  * - 这里只校验项目创建阶段依赖的最小平台条件，不承担后续运行时配置合并职责。
  */
 

package/src/executor/Executor.ts

@@ -13,7 +13,7 @@ import type { SessionHistoryComposer } from "@executor/composer/history/SessionH
 import type { SessionHistoryStore } from "@/executor/store/history/SessionHistoryStore.js";
 import { withSessionRunScope } from "@executor/SessionRunScope.js";
 import type { SessionRunScope } from "@executor/SessionRunScope.js";
-import { buildSessionStepEventMessages } from "@executor/messages/SessionStepEventMapper.js";
+import { buildSessionStepParts } from "@executor/messages/SessionStepEventMapper.js";
 import { JsonlSessionCompactionComposer } from "@executor/composer/compaction/jsonl/JsonlSessionCompactionComposer.js";
 import { LocalSessionContextComposer } from "@executor/composer/context/LocalSessionContextComposer.js";
 import type { SessionCompactionComposer } from "@executor/composer/compaction/SessionCompactionComposer.js";
@@ -55,6 +55,7 @@ import type {
   SessionRunInput,
   SessionRunResult,
 } from "@/executor/types/SessionRun.js";
+import { generateId } from "@/utils/Id.js";
 
 /**
  * 可压缩错误的最大重试次数。
@@ -226,6 +227,56 @@ export class Executor implements SessionExecutor {
     await this.historyWriter.appendAssistantMessage(params);
   }
 
+  /**
+   * 把 step/tool 过程增量写入当前运行中的 assistant 快照。
+   */
+  private async appendAssistantStepPartsToInflight(
+    parts: SessionMessageV1["parts"],
+  ): Promise<void> {
+    const normalized_parts = Array.isArray(parts)
+      ? parts.filter((part) => part && typeof part === "object")
+      : [];
+    if (normalized_parts.length === 0) return;
+
+    const current_inflight = await this.historyStore.readInflight();
+    const next_message: SessionMessageV1 = current_inflight
+      ? {
+          ...current_inflight,
+          metadata: {
+            ...(current_inflight.metadata || {
+              v: 1 as const,
+              ts: Date.now(),
+              sessionId: this.sessionId,
+            }),
+            ts: Date.now(),
+            sessionId: this.sessionId,
+            source: "egress",
+            kind: "normal",
+          },
+          parts: [
+            ...(Array.isArray(current_inflight.parts)
+              ? current_inflight.parts
+              : []),
+            ...normalized_parts,
+          ],
+        }
+      : {
+          id: `a:${this.sessionId}:${generateId()}`,
+          role: "assistant",
+          metadata: {
+            v: 1,
+            ts: Date.now(),
+            sessionId: this.sessionId,
+            source: "egress",
+            kind: "normal",
+          },
+          parts: normalized_parts,
+        };
+
+    await this.historyStore.writeInflight(next_message);
+    await this.afterSessionUpdatedAsync();
+  }
+
   /**
    * 运行当前 session 的一次请求。
    *
@@ -256,7 +307,6 @@ export class Executor implements SessionExecutor {
         ? { onUiMessageChunkCallback: params.onUiMessageChunkCallback }
         : {}),
     };
-    let persistedAssistantStepCount = 0;
     const providedOnAssistantStepCallback =
       sessionRunScope.onAssistantStepCallback;
 
@@ -266,20 +316,14 @@ export class Executor implements SessionExecutor {
       visibility?: "visible" | "internal";
       stepResult?: unknown;
     }): Promise<void> => {
-      const stepMessages = buildSessionStepEventMessages({
-        sessionId: this.sessionId,
+      const step_parts = buildSessionStepParts({
         stepIndex: step.stepIndex,
         stepResult: step.stepResult,
         text: step.text,
         visibility: step.visibility,
       });
-      if (stepMessages.length > 0) {
-        for (const stepMessage of stepMessages) {
-          await this.appendAssistantMessage({
-            message: stepMessage,
-          });
-          persistedAssistantStepCount += 1;
-        }
+      if (step_parts.length > 0) {
+        await this.appendAssistantStepPartsToInflight(step_parts);
       }
 
       if (typeof providedOnAssistantStepCallback === "function") {
@@ -298,32 +342,7 @@ export class Executor implements SessionExecutor {
         },
         () => this.runWithRetry({ query }),
       );
-      if (persistedAssistantStepCount <= 0) return result;
-
-      return {
-        ...result,
-        assistantMessage: {
-          ...result.assistantMessage,
-          metadata: {
-            ...(result.assistantMessage.metadata || {
-              v: 1 as const,
-              ts: Date.now(),
-              sessionId: this.sessionId,
-            }),
-            extra: {
-              ...(
-                result.assistantMessage.metadata?.extra &&
-                  typeof result.assistantMessage.metadata.extra === "object" &&
-                  !Array.isArray(result.assistantMessage.metadata.extra)
-                  ? result.assistantMessage.metadata.extra
-                  : {}
-              ),
-              assistantStepMessagesPersisted: true,
-              assistantStepCount: persistedAssistantStepCount,
-            },
-          },
-        },
-      };
+      return result;
     } finally {
       this.resetRunState();
       this.executing = false;

package/src/executor/composer/history/SessionHistoryWriter.ts

@@ -104,7 +104,7 @@ export class SessionHistoryWriter {
     try {
       const historyStore = this.getHistoryStore();
       if (params.message && typeof params.message === "object") {
-        await historyStore.append(params.message);
+        await historyStore.finalizeInflight(params.message);
         void this.afterSessionUpdatedAsync();
         return;
       }
@@ -112,7 +112,7 @@ export class SessionHistoryWriter {
       const fallbackText = String(params.fallbackText || "").trim();
       if (!fallbackText) return;
 
-      await historyStore.append(
+      await historyStore.finalizeInflight(
         historyStore.assistantText({
           text: fallbackText,
           metadata: {

package/src/executor/composer/system/default/assets/core.prompt.ts

@@ -4,6 +4,6 @@
  */
 
 // Source: src/executor/composer/system/default/assets/core.prompt.ts.txt
-const TEXT_MODULE_CONTENT = "你拥有且仅拥有当前项目 {{project_path}} 的使用权和修改权。当前年份是 {{current_year}} 年。\n1. `.downcity/` 是 Downcity 的运行时数据目录（通常不需要你手动读取/修改；系统会自动写入与注入）。结构与逻辑如下：\n   - `.downcity/agents/<agentId>/sessions/` 是会话消息。\n   - `.downcity/memory/` 是中长期记忆。\n   - `.downcity/profile/Primary.md`、`.downcity/profile/other.md`：全局 profile 记忆；存在时会自动作为 system prompt 注入。\n   - `.downcity/public/`：对外静态资源目录，通过 `GET /downcity/public/<path>` 访问；用于给外部访问的路径。不要存放敏感信息，Town Agent HTTP gateway 会把 `.downcity/public/` 暴露为 HTTP 静态资源：`GET /downcity/public/<path>`，你可以把该 URL 发给用户用于下载/查看生成的文件（注意不要暴露敏感信息）。\n   - `.downcity/logs/<YYYY-MM-DD>.jsonl`：运行日志（JSONL）；用于排查问题，避免把原始日志整段贴给用户。\n   - `.downcity/.cache/`：幂等/去重缓存（ingress/egress）；不要手动改。\n   - `.downcity/.debug/`：调试产物（daemon pid/log/meta、适配器事件抓取等）；仅在排查问题时查看。\n   - `.downcity/data/`：小型持久化数据（预留）。\n   - `.downcity/task/`：Task 目录。\n2. PROFILE.md + SOUL.md + downcity.json 是你的一些配置文件，你不需要读取。\n\n# 最重要\n【关于命令执行工具】（重要）\n- 短命令、一次性命令优先使用 `shell_exec`。\n- 长任务、需要中途查状态、需要 stdin 交互时，使用 `shell_start` / `shell_status` / `shell_read` / `shell_write` / `shell_wait` / `shell_close`。\n- 先用 `shell_start` 启动命令并拿到 `shell_id`。\n- `shell_id` 是 shell 会话标识；它不是 chat `session_id`。\n- 长任务期间，优先使用 `shell_status` 查询进度，或使用 `shell_wait` 等待状态变化；不要自己写高频空轮询循环。\n- 只有在确实需要原始增量输出时，才使用 `shell_read` 按 `from_cursor` 继续读取。\n- 需要向进程 stdin 输入内容时，使用 `shell_write`。\n- 命令会话完成后若不再需要，使用 `shell_close` 主动释放资源。\n- 不要把原始超长 shell 输出直接转发给用户，应先总结。\n\n# 默认决策与澄清\n- 默认先执行，再沟通：对低风险、可回滚、用户意图已经足够明显的请求，优先基于当前日期、时区、聊天上下文与常见默认值直接执行，不要在事件标题、默认平台、显然的时间表达上反复追问。\n- 只有当“缺失信息会实质改变结果”时才追问；例如：会影响日期/对象/金额/账户/发送目标，或会触发不可逆、高风险、涉隐私操作。\n- 处理时间表达时，优先使用当前环境提供的 `current_date`、`current_time` 与 `timezone`；如果入站 `<info>` 明确提供了 `user_timezone`，则优先按 `user_timezone` 解析，否则按 runtime clock 的 `timezone` 解析。像“今天/明天/下午两点/提前两小时”这类表达，应先解析为绝对时间，再执行，并在回复里明确写出绝对日期时间。\n- 当任务依赖外部权限、系统能力或第三方连接（如日历、提醒事项、聊天渠道、系统授权）时，先探测可用性，再决定是否承诺“我来创建/发送/写入”。\n- 如果探测结果显示被系统权限、宿主环境或连接状态阻塞，要直接说明真实阻塞点和下一步，而不是先给出“可以，我来做”的承诺后再多轮追问。\n- 若已经有足够信息可以一次完成多个低风险默认动作，应直接完成，并在结果里简短说明采用了哪些默认假设。\n\n# 很重要\n\n安全与边界\n- 不要执行破坏性命令（如 `rm -rf`、`git reset --hard`）除非用户明确要求。\n- 遇到 API Key、Token、Secret、环境变量、bot 凭据等密钥管理问题时，优先指导用户使用 Console（如 `Global / Env`、`Global / Channel Accounts`）维护，不要要求用户把密钥明文直接发送到当前聊天里。\n- `town keys` 只能列出已配置的 key 名与描述，不会返回密钥值。不要让用户把密钥“发给你自己”或继续尝试通过 `town keys` 获取明文。\n";
+const TEXT_MODULE_CONTENT = "你拥有且仅拥有当前项目 {{project_path}} 的使用权和修改权。当前年份是 {{current_year}} 年。\n1. `.downcity/` 是 Downcity 的运行时数据目录（通常不需要你手动读取/修改；系统会自动写入与注入）。结构与逻辑如下：\n   - `.downcity/agents/<agentId>/sessions/` 是会话消息。\n   - `.downcity/memory/` 是中长期记忆。\n   - `.downcity/profile/Primary.md`、`.downcity/profile/other.md`：全局 profile 记忆；存在时会自动作为 system prompt 注入。\n   - `.downcity/public/`：对外静态资源目录，通过 `GET /downcity/public/<path>` 访问；用于给外部访问的路径。不要存放敏感信息，Town Agent HTTP gateway 会把 `.downcity/public/` 暴露为 HTTP 静态资源：`GET /downcity/public/<path>`，你可以把该 URL 发给用户用于下载/查看生成的文件（注意不要暴露敏感信息）。\n   - `.downcity/logs/<YYYY-MM-DD>.jsonl`：运行日志（JSONL）；用于排查问题，避免把原始日志整段贴给用户。\n   - `.downcity/.cache/`：幂等/去重缓存（ingress/egress）；不要手动改。\n   - `.downcity/.debug/`：调试产物（Town 托管进程 pid/log/meta、适配器事件抓取等）；仅在排查问题时查看。\n   - `.downcity/data/`：小型持久化数据（预留）。\n   - `.downcity/task/`：Task 目录。\n2. PROFILE.md + SOUL.md + downcity.json 是你的一些配置文件，你不需要读取。\n\n# 最重要\n【关于命令执行工具】（重要）\n- 短命令、一次性命令优先使用 `shell_exec`。\n- 长任务、需要中途查状态、需要 stdin 交互时，使用 `shell_start` / `shell_status` / `shell_read` / `shell_write` / `shell_wait` / `shell_close`。\n- 先用 `shell_start` 启动命令并拿到 `shell_id`。\n- `shell_id` 是 shell 会话标识；它不是 chat `session_id`。\n- 长任务期间，优先使用 `shell_status` 查询进度，或使用 `shell_wait` 等待状态变化；不要自己写高频空轮询循环。\n- 只有在确实需要原始增量输出时，才使用 `shell_read` 按 `from_cursor` 继续读取。\n- 需要向进程 stdin 输入内容时，使用 `shell_write`。\n- 命令会话完成后若不再需要，使用 `shell_close` 主动释放资源。\n- 不要把原始超长 shell 输出直接转发给用户，应先总结。\n\n# 默认决策与澄清\n- 默认先执行，再沟通：对低风险、可回滚、用户意图已经足够明显的请求，优先基于当前日期、时区、聊天上下文与常见默认值直接执行，不要在事件标题、默认平台、显然的时间表达上反复追问。\n- 只有当“缺失信息会实质改变结果”时才追问；例如：会影响日期/对象/金额/账户/发送目标，或会触发不可逆、高风险、涉隐私操作。\n- 处理时间表达时，优先使用当前环境提供的 `current_date`、`current_time` 与 `timezone`；如果入站 `<info>` 明确提供了 `user_timezone`，则优先按 `user_timezone` 解析，否则按 runtime clock 的 `timezone` 解析。像“今天/明天/下午两点/提前两小时”这类表达，应先解析为绝对时间，再执行，并在回复里明确写出绝对日期时间。\n- 当任务依赖外部权限、系统能力或第三方连接（如日历、提醒事项、聊天渠道、系统授权）时，先探测可用性，再决定是否承诺“我来创建/发送/写入”。\n- 如果探测结果显示被系统权限、宿主环境或连接状态阻塞，要直接说明真实阻塞点和下一步，而不是先给出“可以，我来做”的承诺后再多轮追问。\n- 若已经有足够信息可以一次完成多个低风险默认动作，应直接完成，并在结果里简短说明采用了哪些默认假设。\n\n# 很重要\n\n安全与边界\n- 不要执行破坏性命令（如 `rm -rf`、`git reset --hard`）除非用户明确要求。\n- 遇到 API Key、Token、Secret、环境变量、bot 凭据等密钥管理问题时，优先指导用户使用 Console（如 `Global / Env`、`Global / Channel Accounts`）维护，不要要求用户把密钥明文直接发送到当前聊天里。\n- `town keys` 只能列出已配置的 key 名与描述，不会返回密钥值。不要让用户把密钥“发给你自己”或继续尝试通过 `town keys` 获取明文。\n";
 
 export default TEXT_MODULE_CONTENT;

package/src/executor/composer/system/default/assets/core.prompt.ts.txt

@@ -6,7 +6,7 @@
    - `.downcity/public/`：对外静态资源目录，通过 `GET /downcity/public/<path>` 访问；用于给外部访问的路径。不要存放敏感信息，Town Agent HTTP gateway 会把 `.downcity/public/` 暴露为 HTTP 静态资源：`GET /downcity/public/<path>`，你可以把该 URL 发给用户用于下载/查看生成的文件（注意不要暴露敏感信息）。
    - `.downcity/logs/<YYYY-MM-DD>.jsonl`：运行日志（JSONL）；用于排查问题，避免把原始日志整段贴给用户。
    - `.downcity/.cache/`：幂等/去重缓存（ingress/egress）；不要手动改。
-   - `.downcity/.debug/`：调试产物（daemon pid/log/meta、适配器事件抓取等）；仅在排查问题时查看。
+   - `.downcity/.debug/`：调试产物（Town 托管进程 pid/log/meta、适配器事件抓取等）；仅在排查问题时查看。
    - `.downcity/data/`：小型持久化数据（预留）。
    - `.downcity/task/`：Task 目录。
 2. PROFILE.md + SOUL.md + downcity.json 是你的一些配置文件，你不需要读取。