agent-loft 0.2.86 → 0.2.88

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -91,7 +91,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
91
91
  只勾联网搜索、读网页的 Claude 专家就是以前聊天模式的效果。专家改了,用它的对话下一条消息起生效;专家删了,用它的对话还能看、不能再发消息,用它的定时任务暂停。以前的聊天模式取消了:升级后聊天模式的旧对话不再保留,聊天模式的定时任务暂停,选个专家再启用。
92
92
  - **MCP**:设置 → MCP,每人管自己的:本机进程(命令 + 参数 + 环境变量)或 HTTP 地址(+ 请求头),值可以标成密钥(网页上不回显,只交给 MCP 进程或请求头,不进提示词)。可以设「调用前询问」,不设就直接用。自定义专家加载各自勾选的服务;内置专家在「设置 → Agent → 对应 Agent 卡片 → 默认加载」里选择,支持个人 MCP、管理员可选的机器 MCP,也可全部取消;不指定时管理员沿用机器配置。
93
93
  - **记忆**:像 ChatGPT 的记忆,设置 → 记忆(默认关)。「关于我」加上一条条记住的事,每次对话都带上;agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条(回复里会说),记错了用 `forget` 删。**自动整理**:把上次整理之后新说的话交给模型(不留会话记录的一次性调用),补充、更新或删掉过时的记忆,用户自己加的条目它不动。什么时候整理每个人自己定:每天一次(默认凌晨 2 点,把当天的对话合起来一次整理,最省)/每段对话聊完后(停多久可选,改了什么会在对话里说一声)/只在点「现在整理」时/不整理;整理哪些对话也能选:全部/只整理选中专家的对话;用哪个 agent 的哪个模型也能选,默认 Claude Haiku,没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**:agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话(关键词搜索,只有你自己的、没被删掉的对话)。聊天记录索引不开记忆也会记(侧栏的「搜索」也用它),升级后会把已有对话收录进来一次;没开记忆时记进来的不拿去整理。两项都能在设置里单独关。每个用户一份,Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里:你的 Web 对话,以及绑定了飞书账号后和机器人的私聊;飞书群聊不用。别人(包括管理员)看不到你的记忆,管理员只能清空它;删用户时记忆一起删,不转给管理员。
94
- - **定时任务**:像 ChatGPT 的 Tasks,侧栏的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选专家和目录),或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。
94
+ - **定时任务**:像 ChatGPT 的 Tasks,侧栏的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选专家和目录;可以设成不携带上下文,每次运行都换新会话,之前的结果还留在对话里,只是 agent 看不到),在专用对话右上角的「更多」里可以直接编辑任务、立即运行,或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。
95
95
  - **技能(skills)**:设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md(可以带脚本和资料),由 agent-loft 按人管理,两个 agent 都能用。**来源**:在页面上写、上传技能包(`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹),或者在对话里让 agent「把刚才的做法存成技能」(agent 用 `create_skill` / `update_skill`,先弹授权卡)。**共享**:新建、编辑时选择「仅自己可见」「指定用户」或「所有人可见」,也可在自己技能的「更多 → 共享」里调整;默认仅自己可见。其他用户在「共享技能」中查看正文和附带文件、安装;安装后出现在「我的技能」,可停用、卸载或重新安装。安装的是作者的同一份技能,更新自动跟随;作者撤回共享后,范围外用户不再可用。只有作者能编辑,管理员可下架自己看得到的共享技能。共享不包含作者填写的变量和密钥,每人使用自己的配置。**使用**:内置专家默认使用你启用的全部技能,也可以在「设置 → Agent」中分别指定 Claude Code / Codex 加载哪些技能;自定义专家只用它选中的;agent 遇到对得上的事自己用。**变量**:技能可以声明要用的环境变量(接口地址、密钥),每个人填自己的值,只注入自己的会话;密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量,agent 看不到值,只能用 `skill_request` 工具让 agent-loft 代发请求(在地址、请求头、请求体里写 `{{变量名}}`),只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉;作者后来改了地址,要你再确认一次才放行。**机器上原有的技能**(`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的)只给管理员:成员的会话里看不到、调不了(Claude 用技能白名单,`/技能名` 也会被拦下;Codex 关掉它自己的技能清单),管理员在「设置 → 技能 → 本机技能」里能看到。
96
96
  - **资料库**:像 ChatGPT 的资料库,侧栏的「资料库」。对话里发过的附件、agent 回复里给出的、这一轮新写出来的图片 / 文档 / 音视频(复制一份收进来,之后原文件改了删了不影响)都汇总在这里:按图片 / 文档 / 音视频筛、按文件名搜,点开看大图或下载,「在新对话里用」,单个或批量删除(文件从磁盘上删掉)。从资料库拿到对话里的文件硬链接进那条对话的上传目录,不占双份空间,agent 照常能读。按人隔离,规则同对话:自己的;没主人的对话(飞书群聊等)的归管理员。上传了一直没发出去的一天后清掉;删除会话时立即清理该会话的上传文件和资料库记录,删除原件也会清理复用到其他会话的副本。agent 侧的会话记录仍保留,恢复会话不会恢复已删除的文件。
97
97
  - **远程控制**:侧栏「定时任务」下面的「远程控制」,直接操作这台机器的**桌面**和**终端**,上面一键切换;切回对话时连接留在后台(侧栏入口上亮个小绿点),再进来接着用。这台机器没有图形桌面(服务器、NAS)时只有终端。
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "agent-loft",
3
- "version": "0.2.86",
3
+ "version": "0.2.88",
4
4
  "type": "module",
5
5
  "description": "多个 agent 的工作台:把本机 Claude Code / Codex 放到一处统一管理,用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
6
6
  "keywords": [
package/src/core/hub.ts CHANGED
@@ -59,6 +59,7 @@ import { mcpEvents } from "./mcp.js";
59
59
  import { isMachineCommand, sessionSkills } from "./skill-runtime.js";
60
60
  import { skillEvents } from "./skills.js";
61
61
  import { isSilentReply } from "./task-prompt.js";
62
+ import { findTask } from "./tasks.js";
62
63
  import { patchWeixinAccount } from "./weixin-accounts.js";
63
64
 
64
65
  // ---------- 事件 ----------
@@ -103,7 +104,11 @@ export type ConvEvent =
103
104
  | { type: "meta" };
104
105
 
105
106
  /** 定时任务发起的一轮(见 core/task-runner.ts) */
106
- export type TaskTurn = { taskId: string; runId: string; title: string; smart: boolean };
107
+ /** fresh:这一轮不带之前的上下文,发出去之前先换新会话 */
108
+ export type TaskTurn = { taskId: string; runId: string; title: string; smart: boolean; fresh?: boolean };
109
+
110
+ /** 每条对话最多接着显示这么多条旧会话:每次打开对话都要全读一遍,不能无限长 */
111
+ const PAST_SESSIONS_KEPT = 50;
107
112
 
108
113
  /** 定时任务的一轮结束了 */
109
114
  export type TaskTurnEnd = TaskTurn & { key: string; status: "notified" | "silent" | "error" | "interrupted"; text: string };
@@ -1107,6 +1112,15 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1107
1112
  // 清理要等旧会话 dispose,期间可能又点了停止
1108
1113
  if (cancelled()) return dropped();
1109
1114
  }
1115
+ if (task?.fresh) {
1116
+ // 换会话会丢掉进行中的那一轮:到点时核对过不忙,但排队期间可能有人刚发了消息,这次就不跑了
1117
+ if (this.isBusy(key)) return gone("对话正在回复,这次没有运行");
1118
+ await this.drop(key, "定时任务开始新一次运行");
1119
+ this.archiveSession(key);
1120
+ this.emitEvent(key, { type: "meta" });
1121
+ if (waiting.cancelled) return;
1122
+ if (cancelled()) return gone("没有发出(停止了或者会话被切换了)");
1123
+ }
1110
1124
  const blocked = await this.blockedSlash(key, input.text);
1111
1125
  if (waiting.cancelled) return;
1112
1126
  if (blocked) {
@@ -1160,13 +1174,41 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1160
1174
  if (!conv || !(agentBinding(conv).sessionId || agentBinding(conv).forkFrom)) return;
1161
1175
  console.log(`[会话] ${key} 闲置超过 ${config().sessionTtlMs / 3600000} 小时,开新会话`);
1162
1176
  await this.drop(key, "会话已闲置过期");
1163
- updateAgentBinding(key, conv.agent, { sessionId: undefined, forkFrom: undefined, model: undefined, effort: undefined });
1177
+ // 「不携带上下文」的任务对话:运行记录要一直留在对话里,模型也是任务定的,都不能清
1178
+ if (conv.taskId && findTask(conv.taskId)?.freshContext) this.archiveSession(key);
1179
+ else updateAgentBinding(key, conv.agent, { sessionId: undefined, forkFrom: undefined, model: undefined, effort: undefined });
1164
1180
  // 不清上传目录:本次和排在后面的消息可能都带着刚上传的附件。
1165
1181
  // 旧附件留到 /new 或下次启动的清扫时再删。
1166
1182
  this.emitEvent(key, { type: "notice", text: "上次的会话闲置太久,已自动开新会话。" });
1167
1183
  this.emitEvent(key, { type: "meta" });
1168
1184
  }
1169
1185
 
1186
+ /** 当前会话不再续用,但记录留在对话里接着显示。下一条消息会开新会话 */
1187
+ private archiveSession(key: string): void {
1188
+ const conv = getConversation(key);
1189
+ if (!conv) return;
1190
+ const { sessionId, pastSessions = [] } = agentBinding(conv);
1191
+ updateAgentBinding(key, conv.agent, {
1192
+ sessionId: undefined,
1193
+ forkFrom: undefined,
1194
+ ...(sessionId ? { pastSessions: [...pastSessions, sessionId].slice(-PAST_SESSIONS_KEPT) } : {}),
1195
+ });
1196
+ }
1197
+
1198
+ /** 旧会话的记录。不带 anchor:它们已经不是当前会话,不能从这里回退或分叉 */
1199
+ private async pastHistory(conv: Conversation): Promise<HistoryMessage[]> {
1200
+ const driver = this.requireDriver(conv.agent);
1201
+ const out: HistoryMessage[] = [];
1202
+ for (const id of agentBinding(conv).pastSessions ?? []) {
1203
+ try {
1204
+ for (const { anchor: _anchor, ...m } of attachFooters(id, await driver.readHistory(id, conv.cwd))) out.push(m);
1205
+ } catch (err) {
1206
+ console.error(`[历史] 读取旧会话 ${id} 失败:`, err);
1207
+ }
1208
+ }
1209
+ return out;
1210
+ }
1211
+
1170
1212
  /** msg:页面上那条消息的编号和收到时是否排队(见 send 里的 shown) */
1171
1213
  private sendNow(key: string, input: UserInput, tag: TaskTurn | null, msg: { id: string; queued: boolean }): void {
1172
1214
  const fail = (err: unknown) => {
@@ -1255,7 +1297,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1255
1297
  this.markSwitched(key, op.seq);
1256
1298
  const next = this.nextWeixinConversation(conv);
1257
1299
  this.clearFullPermission(next.key);
1258
- updateAgentBinding(next.key, next.agent, { sessionId: undefined, forkFrom: undefined, model: model || undefined, effort: undefined });
1300
+ updateAgentBinding(next.key, next.agent, { sessionId: undefined, forkFrom: undefined, pastSessions: undefined, model: model || undefined, effort: undefined });
1259
1301
  this.emitEvent(next.key, { type: "meta" });
1260
1302
  const runtime = await this.runtimeNow(next.key);
1261
1303
  return `已开新会话(${this.label(conv.agent)},模型 ${runtime.model ?? "默认"}${
@@ -1634,6 +1676,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1634
1676
  if (index < 0 && !firstUnwritten) throw new Error("在会话记录里找不到这条消息,请稍后刷新重试");
1635
1677
  const message = index >= 0 ? history[index]! : { text: live!.type === "user" ? live!.text : "", attachments: live!.type === "user" ? live!.files : [] };
1636
1678
  const kept = index >= 0 ? history.slice(0, index) : [];
1679
+ const past = await this.pastHistory(conv);
1637
1680
  await this.drop(key, "对话已回退");
1638
1681
  const sessionId = index > 0 && source && anchor ? await withTimeout(driver.rewindTo(source, conv.cwd, anchor), "回退会话") : undefined;
1639
1682
  this.markSwitched(key, op.seq);
@@ -1643,7 +1686,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1643
1686
  for (const m of kept) if (m.footer) recordFooter(sessionId, m.text, m.footer);
1644
1687
  }
1645
1688
  const owner = memoryOwnerOf(conv);
1646
- if (owner) replaceConversationRecords(owner, key, kept.flatMap((m) => {
1689
+ if (owner) replaceConversationRecords(owner, key, [...past, ...kept].flatMap((m) => {
1647
1690
  if (m.role === "question") return [];
1648
1691
  const text = [m.text, m.attachments?.length ? `(附件:${m.attachments.map((a) => a.name).join("、")})` : ""].filter(Boolean).join("\n");
1649
1692
  return text.trim() ? [{ k: key, a: conv.agent, r: m.role === "user" ? "u" as const : "a" as const, t: text, ts: m.ts ?? conv.createdAt }] : [];
@@ -1758,14 +1801,16 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1758
1801
  async history(key: string): Promise<HistoryMessage[]> {
1759
1802
  const conv = getConversation(key);
1760
1803
  if (!conv) return [];
1761
- const sessionId = agentBinding(conv).sessionId;
1762
- if (!sessionId) return [];
1804
+ const { sessionId, pastSessions } = agentBinding(conv);
1805
+ if (!sessionId && !pastSessions?.length) return [];
1763
1806
  const driver = this.requireDriver(conv.agent);
1807
+ const past = await this.pastHistory(conv);
1808
+ if (!sessionId) return past;
1764
1809
  try {
1765
- return attachFooters(sessionId, await driver.readHistory(sessionId, conv.cwd));
1810
+ return [...past, ...attachFooters(sessionId, await driver.readHistory(sessionId, conv.cwd))];
1766
1811
  } catch (err) {
1767
1812
  console.error(`[历史] 读取 ${key} 失败:`, err);
1768
- return [];
1813
+ return past;
1769
1814
  }
1770
1815
  }
1771
1816
 
package/src/core/store.ts CHANGED
@@ -20,6 +20,11 @@ export type AgentBinding = {
20
20
  * 拿到不同于它的新会话 id 后清掉。
21
21
  */
22
22
  forkFrom?: string;
23
+ /**
24
+ * 这条对话以前用过、已经不再续用的会话(旧的在前):只用来在页面上接着显示,不进 agent 的上下文。
25
+ * 「不携带上下文」的定时任务每次运行都换新会话,靠它把之前的运行结果留在对话里。
26
+ */
27
+ pastSessions?: string[];
23
28
  };
24
29
 
25
30
  export type Conversation = {
@@ -19,18 +19,20 @@ export function stripSilentMark(text: string): string {
19
19
 
20
20
  export function taskMessage(
21
21
  task: { title: string; prompt: string; notify: "smart" | "always" },
22
- opts: { now?: number; manual?: boolean; version?: string } = {},
22
+ opts: { now?: number; manual?: boolean; version?: string; fresh?: boolean } = {},
23
23
  ): string {
24
24
  const now = opts.now ?? Date.now();
25
25
  const lines = [
26
26
  `这条消息是定时任务「${task.title}」${opts.manual ? "(用户刚才手动点了「立即运行」)" : "到点自动发来的"},现在是 ${formatDateTime(now)}(${serverTimeZone()})。${opts.manual ? "" : "用户此刻多半不在屏幕前,不要向他提问、等他回答。"}`,
27
27
  ...(opts.version ? [`agent-loft 服务端当前版本:${opts.version}。`] : []),
28
- "按上面的要求做;这条对话里以前运行的结果可以拿来对比(比如「和上次比有没有变化」)。",
28
+ opts.fresh
29
+ ? "按上面的要求做;这个任务设置了每次运行都不带之前的上下文,你看不到以前运行的结果,不要假设有过上一次。"
30
+ : "按上面的要求做;这条对话里以前运行的结果可以拿来对比(比如「和上次比有没有变化」)。",
29
31
  ];
30
32
  if (task.notify === "smart") {
31
33
  lines.push(
32
34
  "",
33
- `用户希望只在有需要时才被提醒:如果按上面的要求,这次没有需要告诉他的事(比如没有更新、没有变化、条件没满足),回复的第一行只写 ${SILENT_MARK},后面用一两句话记下这次检查的结果(下次可以对比),他就不会收到通知。`,
35
+ `用户希望只在有需要时才被提醒:如果按上面的要求,这次没有需要告诉他的事(比如没有更新、没有变化、条件没满足),回复的第一行只写 ${SILENT_MARK},后面用一两句话记下这次检查的结果${opts.fresh ? "" : "(下次可以对比)"},他就不会收到通知。`,
34
36
  `有需要告诉他的事时正常回复,开头直接说结论,不要写 ${SILENT_MARK}。`,
35
37
  );
36
38
  }
@@ -148,15 +148,16 @@ function fire(task: Task, manual: boolean, now = Date.now()): string | undefined
148
148
  const permission = task.target.kind === "dedicated" ? hub.applyTaskPermission(key, task.permission) : undefined;
149
149
  const capped = task.target.kind === "dedicated" && task.permission && permission !== task.permission ? `权限只能到「${PERMISSION_LABEL[permission ?? "ask"]}」,按这一级运行` : "";
150
150
  const note = [manual ? "手动运行" : "", capped].filter(Boolean).join(";");
151
+ const fresh = task.target.kind === "dedicated" && !!task.freshContext;
151
152
  const run = pushRun(task, { id: runId(), at: now, status: "running", convKey: key, ...(note ? { note } : {}) });
152
153
  running.set(task.id, { runId: run.id, key, at: now });
153
154
  console.log(`[定时任务] ${task.id}「${task.title}」${manual ? "手动运行" : "到点运行"},发到 ${key}`);
154
155
  hub.send(
155
156
  key,
156
- { text: taskMessage(task, { now, manual, version: RUNNING_VERSION }), attachments: [] },
157
+ { text: taskMessage(task, { now, manual, version: RUNNING_VERSION, fresh }), attachments: [] },
157
158
  { channel: "task", channelId: task.id, name: `定时任务「${task.title}」` },
158
159
  undefined,
159
- { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart" } },
160
+ { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart", ...(fresh ? { fresh } : {}) } },
160
161
  );
161
162
  return undefined;
162
163
  }
@@ -56,6 +56,7 @@ function describeTask(task: Task, convKey: string): string {
56
56
  task.enabled && task.nextRunAt ? `下次 ${formatDateTime(task.nextRunAt)}` : "已暂停",
57
57
  task.notify === "smart" ? "有需要才提醒" : "每次都提醒",
58
58
  `结果发到${whereText(task, convKey)}`,
59
+ ...(task.target.kind === "dedicated" && task.freshContext ? ["每次运行不带之前的上下文"] : []),
59
60
  ...(last ? [`最近一次 ${formatDateTime(last.at)} ${STATUS[last.status] ?? last.status}${last.preview ? `:${last.preview}` : last.note ? `(${last.note})` : ""}`] : []),
60
61
  ].join(" · ") + `\n 提示词:${task.prompt.replace(/\s+/g, " ").slice(0, 200)}`;
61
62
  }
package/src/core/tasks.ts CHANGED
@@ -51,6 +51,8 @@ export type Task = {
51
51
  effort?: string;
52
52
  /** 专用对话的权限级别(见 permission.ts):只有用户在页面上能设。没有就是引擎默认 */
53
53
  permission?: PermissionLevel;
54
+ /** 专用对话每次运行都不带之前的上下文:结果还留在这条对话里,只是 agent 看不到。发到已有对话的不用它 */
55
+ freshContext?: boolean;
54
56
  enabled: boolean;
55
57
  createdAt: number;
56
58
  updatedAt: number;
@@ -145,6 +147,7 @@ export type TaskInput = {
145
147
  effort?: unknown;
146
148
  /** 只有网页接口会给:agent 的工具(tasks-bridge.ts)不开放这个参数,免得 agent 给自己提权 */
147
149
  permission?: unknown;
150
+ freshContext?: unknown;
148
151
  enabled?: unknown;
149
152
  };
150
153
 
@@ -204,6 +207,7 @@ export function createTask(owner: string, input: TaskInput, by: "user" | "agent"
204
207
  ...(str(input.model) ? { model: str(input.model) } : {}),
205
208
  ...(str(input.effort) ? { effort: str(input.effort) } : {}),
206
209
  ...(permission ? { permission } : {}),
210
+ ...(input.freshContext === true ? { freshContext: true } : {}),
207
211
  enabled: input.enabled !== false,
208
212
  createdAt: now,
209
213
  updatedAt: now,
@@ -247,6 +251,10 @@ export function updateTask(owner: string, id: string, patch: TaskInput, now = Da
247
251
  if (permission) next.permission = permission;
248
252
  else delete next.permission;
249
253
  }
254
+ if (patch.freshContext !== undefined) {
255
+ if (patch.freshContext === true) next.freshContext = true;
256
+ else delete next.freshContext;
257
+ }
250
258
  if (patch.enabled !== undefined) next.enabled = patch.enabled !== false;
251
259
  // 专用对话的专家 / 目录变了:旧的那条对话对不上了(对话中途不能换专家),下次新开一条
252
260
  if (
package/web/lib/dom.js CHANGED
@@ -32,6 +32,7 @@ export const ICON = {
32
32
  compose: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H6a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5"/><path d="M18.4 2.6a2 2 0 0 1 2.9 2.9L12.5 14.3 9 15l.7-3.5Z"/></svg>',
33
33
  send: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"><path d="M12 19V5M5 12l7-7 7 7"/></svg>',
34
34
  stop: '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="7" y="7" width="10" height="10" rx="1.5"/></svg>',
35
+ play: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M7 5v14l11-7Z"/></svg>',
35
36
  clip: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m21.4 11.6-9.2 9.2a6 6 0 0 1-8.5-8.5l9.2-9.2a4 4 0 0 1 5.7 5.7l-9.2 9.2a2 2 0 0 1-2.8-2.8l8.5-8.5"/></svg>',
36
37
  mic: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="2" width="6" height="12" rx="3"/><path d="M5 10a7 7 0 0 0 14 0M12 17v5"/></svg>',
37
38
  more: '<svg viewBox="0 0 24 24" fill="currentColor"><circle cx="5" cy="12" r="1.8"/><circle cx="12" cy="12" r="1.8"/><circle cx="19" cy="12" r="1.8"/></svg>',
@@ -165,8 +165,8 @@ export async function boot() {
165
165
  else void loadQuota();
166
166
  if (srv && srv !== HOME) routeToServer(srv, decodeURIComponent(landing.hash.slice(1)));
167
167
  const fromHash = decodeURIComponent(location.hash.slice(1));
168
- // 地址里带了会话就打开它;否则打开「最近」里最近活跃的那个对话,一个都没有才进新对话页
169
- const latest = latestConversation();
168
+ // 地址里带了会话就打开它;否则打开最近活跃的 Web 对话,没有才进新对话页
169
+ const latest = latestConversation("web");
170
170
  if (fromHash === "tasks") openTasksView();
171
171
  else if (fromHash === "library") openLibraryView();
172
172
  else if (fromHash === "new") newDraft({ inheritLatest: true });
@@ -63,8 +63,8 @@ function leaveTasksView() {
63
63
  document.dispatchEvent(new Event("aim:leave-view"));
64
64
  }
65
65
 
66
- export function latestConversation() {
67
- return [...S.convs.values()].filter((c) => !c.hidden).sort((a, b) => b.activeAt - a.activeAt)[0];
66
+ export function latestConversation(channel) {
67
+ return [...S.convs.values()].filter((c) => !c.hidden && (!channel || c.channel === channel)).sort((a, b) => b.activeAt - a.activeAt)[0];
68
68
  }
69
69
 
70
70
  export function newDraft({ inheritLatest = false } = {}) {
@@ -238,6 +238,7 @@ function taskCard(t) {
238
238
  h("span", {}, state),
239
239
  h("span", {}, t.notify === "smart" ? "有需要才提醒" : "每次都提醒"),
240
240
  h("span", {}, where),
241
+ t.target.kind === "dedicated" && t.freshContext ? h("span", {}, "不带上下文") : null,
241
242
  t.target.kind === "dedicated" && t.permission ? h("span", { class: t.permission === "full" ? "task-perm-full" : "" }, PERMISSIONS[t.permission].label) : null,
242
243
  t.target.kind === "conv" && t.convPermission === "full" ? h("span", { class: "task-perm-full" }, "跟随对话:完全允许") : null,
243
244
  ),
@@ -259,6 +260,23 @@ async function runNow(t) {
259
260
  }
260
261
  }
261
262
 
263
+ /** 对话页的「更多」菜单:先现拉一遍任务(这时任务页可能还没打开过),改完留在对话里 */
264
+ export async function editTaskById(id) {
265
+ try {
266
+ const data = await api("/api/tasks");
267
+ T.tz = data.tz;
268
+ const task = data.tasks.find((t) => t.id === id);
269
+ if (!task) return toast("这个任务不存在了");
270
+ openTaskForm(task);
271
+ } catch (err) {
272
+ toast(err.message);
273
+ }
274
+ }
275
+
276
+ export function runTaskById(id) {
277
+ return runNow({ id });
278
+ }
279
+
262
280
  async function removeTask(t) {
263
281
  const sure = await confirmDialog({
264
282
  title: `删除「${t.title}」?`,
@@ -421,7 +439,15 @@ export function openTaskForm(task, preset) {
421
439
  permissionValue = permission.value;
422
440
  syncPermission();
423
441
  };
424
- const dedicatedBox = h("div", { class: "task-dedicated" }, field("专家", expert, "到点由这个专家来做。要联网、读文件还是跑命令,看专家的权限(设置 → 专家)。"), cwdField, permissionField);
442
+ // ---- 上下文(只有专用对话有:发到已有对话的要接着你们的聊天)----
443
+ const context = h(
444
+ "select",
445
+ {},
446
+ h("option", { value: "keep", selected: !src.freshContext }, "携带(能看到之前几次运行的内容)"),
447
+ h("option", { value: "fresh", selected: !!src.freshContext }, "不携带(每次都从头开始)"),
448
+ );
449
+ const contextField = field("上下文", context, "不携带时结果还留在这条对话里,只是 agent 看不到,没法和上次对比,也更省 token。");
450
+ const dedicatedBox = h("div", { class: "task-dedicated" }, field("专家", expert, "到点由这个专家来做。要联网、读文件还是跑命令,看专家的权限(设置 → 专家)。"), cwdField, permissionField, contextField);
425
451
  const followField = convTarget
426
452
  ? field("权限", h("div", { class: "task-static" }, `跟随这条对话(现在是「${task.convPermission ? PERMISSIONS[task.convPermission].label : "默认"}」)`), "要单独设权限,把结果改发到专用对话。")
427
453
  : null;
@@ -487,7 +513,7 @@ export function openTaskForm(task, preset) {
487
513
  schedule,
488
514
  notify: notify.value,
489
515
  target: dedicated ? { kind: "dedicated" } : { kind: "conv", key: task.target.key },
490
- ...(dedicated ? { expert: expert.value, cwd: findExpert(expert.value)?.access === "web" ? "" : cwd, permission: level } : {}),
516
+ ...(dedicated ? { expert: expert.value, cwd: findExpert(expert.value)?.access === "web" ? "" : cwd, permission: level, freshContext: context.value === "fresh" } : {}),
491
517
  };
492
518
  save.disabled = true;
493
519
  try {
@@ -496,7 +522,7 @@ export function openTaskForm(task, preset) {
496
522
  close();
497
523
  toast(task ? "已保存" : "已创建");
498
524
  if (S.view === "tasks") void reload();
499
- else void openTasks();
525
+ else if (!task) void openTasks();
500
526
  } catch (err) {
501
527
  save.disabled = false;
502
528
  toast(err.message);
@@ -488,11 +488,22 @@ export function updateCtxVisibility() {
488
488
  if (ui.ctxBar) ui.ctxBar.hidden = !!S.current && (S.items.length > 0 || sentKeys.has(S.current));
489
489
  }
490
490
 
491
+ /** 定时任务页是按需加载的(见 layout.js 的 openTasksView) */
492
+ function withTasks(fn) {
493
+ return import("./tasks.js").then(fn, (err) => toast(`定时任务页加载失败,刷新页面再试:${err.message}`));
494
+ }
495
+
491
496
  /** 顶栏和侧栏共用的会话操作,显示条件和行为保持一致。 */
492
497
  function convMenuItems(key) {
493
498
  const c = S.convs.get(key);
494
499
  if (!c) return [];
495
500
  return [
501
+ ...(c.taskId
502
+ ? [
503
+ { id: "task-edit", label: "编辑定时任务", icon: "edit", onclick: () => withTasks((m) => m.editTaskById(c.taskId)) },
504
+ { id: "task-run", label: "立即运行", icon: "play", onclick: () => withTasks((m) => m.runTaskById(c.taskId)) },
505
+ ]
506
+ : []),
496
507
  {
497
508
  id: "fork",
498
509
  label: "分叉",