feat(memory): M1 会话收口——4h 空闲自动下班 + 定时即下班(brief 模板碎片)

微信通道拟人化第二里程碑:会话=工作台,收口=下班记日记。

- 空闲收口:扫描器扩为会话闲置双阶段(sweepIdleSessions)——30min held 归档(原有)
  + 4h(memory.wrap_idle_ms 可配,0=关)无更新且未收口的 held/completed 会话,
  后台异步 journalFragment 摘要落碎片(fire-and-forget 不阻塞消息路径),
  顺手归档 + 删 channel_sessions 绑定行——微信下条消息经 ensureSession 自然新建
  工作台;用户抢先复活(active)则不撤台。updated_at 门槛越过即永远成立,
  「不重复收口」靠 sessions.journaled_at 物理标记(防陈年 completed 每轮烧 LLM)。
- 定时即下班:schedule 工具 create 新增 brief 参数(一句话任务人话描述,进 schema),
  scheduler.createTask 落库;工具只打 run.taskWrap 标记,收口在 finalize done 广播后
  (attachBus 监听已同步捕获绑定入队投递,删绑定不影响本次回复送达)——
  brief 纯模板碎片零 LLM 落收口当日条目 + journaled 占坑(任务会话从此退出 4h 流程,
  任务执行痕迹不落日记,「任务是什么+成果文件」即可回溯全貌)+ 解绑退位。
- 碎片时间线定稿:入【收口当日】而非会话创建日(长跨度会话不会落进已裁掉的旧日期)。
- 网页/微信统一碎片(用户级共享),解绑只对通道会话生效(网页无绑定行 DELETE 空操作)。
  /new /switch /clear 不产碎片;/clear 重置 journaled(清空=撕掉作业,可再收口)。
- 记忆关闭(retain_days=0)时定时收口整体不执行:没有日记的下班没有意义,不抽工作台。

上电探针 6 项全过(brief 落库/钩子标记/journaled 占坑/归档/当日条目/解绑),探针已清理。
M2(新会话注入日记)下一棒。
This commit is contained in:
2026-09-29 11:18:16 +08:00
parent 8acc1bf508
commit 01ec42a197
8 changed files with 135 additions and 39 deletions
+2 -1
View File
@@ -52,9 +52,10 @@ agent:
auto_compress_tokens: 60000 # In token 超此值弹「自动压缩」提议;0=关
auto_complete_ms: 1800000 # 保持中(held)超此时长自动收口为已完成;0=关(纯状态动作,历史/模型绑定不动)
# 长期记忆(日记,memory.js):会话轮换时写当日事件碎片;新会话开场注入近 retain_days 天日记;0=关
# 长期记忆(日记,memory.js):会话收口时写当日事件碎片;新会话开场注入近 retain_days 天日记;0=关
memory:
retain_days: 7 # 保留窗,硬帽 30 天
wrap_idle_ms: 14400000 # 空闲超此时长自动收口(碎片+归档+微信解绑);0=关
upload:
image_compress_threshold_kb: 1536 # 大图压缩提示阈值(KB)
+4 -2
View File
@@ -87,10 +87,12 @@ const DEFAULTS = {
upload: { image_compress_threshold_kb: 1536, image_max_dim: 2000, image_quality: 0.85, confirm_size_mb: 10 },
// 技能根目录:留空取 workspace_root 同级 skills(/workspace/tasks → /workspace/skills)。
skills: { skills_root: '', timeout_ms: 120000 },
// 长期记忆(日记,memory.js):会话轮换(换工作台)时把该次工作写成当日事件碎片,
// 长期记忆(日记,memory.js):会话收口(下班)时把该次工作写成当日事件碎片,
// 新会话开场注入近几天日记(微信通道拟人化工程 M0-M2)。retain_days = 保留窗(默认 7 天,
// 硬帽 30 超限截断,见 memory.MAX_RETAIN);0 = 整体关闭(不写不读不裁)。
memory: { retain_days: 7 },
// wrap_idle_ms = 空闲收口阈值:held/completed 且超过此时长无更新 → 后台 LLM 摘要生成碎片、
// 归档、微信通道解绑退位(下次消息自然新工作台);0 = 关。设定定时任务是显式收口事件,不受此开关影响。
memory: { retain_days: 7, wrap_idle_ms: 14400000 },
// 【已废弃】旧版模型保持租约(held 到期自动释放)。调度已改为「key 共享并发 + 优先级选择」(见 engine.chooseKey),
// 不再有任何到期逻辑;字段保留仅为旧 config.yml 兼容(解析不报错),运行期无人读取。
model_hold: { idle_release_ms: 180000, active_max_ms: 1800000, sweep_ms: 10000 },
+8 -1
View File
@@ -117,7 +117,7 @@ function initDb(dbPath) {
);
-- 长期记忆(日记,memory.js):一行 (用户, 天),content = 当天累积的日记碎片块。
-- 碎片在会话轮换(换工作台)时生成,按【来源会话创建日】入当日条目;保留窗外即裁(appendFragment 顺带 + 启动兑底)。
-- 碎片在会话收口(下班)时生成,按【收口当日】入条目;保留窗外即裁(appendFragment 顺带 + 启动兑底)。
-- 故意不建外键:记忆是用户级的,删会话不能抹掉它已记入的日记(与 channel_sessions 的懒解析同理)。
CREATE TABLE IF NOT EXISTS memory_entries (
user TEXT NOT NULL,
@@ -174,6 +174,13 @@ function initDb(dbPath) {
// 升级老库:旧库补 held_at 列(进入 held 的时刻;现仅展示/自动压缩校验用,租约到期逻辑已随「key 不独占」一并移除)
const cols = db.prepare('PRAGMA table_info(sessions)').all();
if (!cols.some(c => c.name === 'held_at')) db.exec('ALTER TABLE sessions ADD COLUMN held_at INTEGER');
// 迁移:长期记忆收口时刻(memory/engine):每会话唯一碎片的物理标记,兼做 4h 空闲扫描的预排除
//(updated_at 门槛一旦越过就永远成立,没有这个标记陈年会话会被每轮扫描重复摘要)。
if (!cols.some(c => c.name === 'journaled_at')) db.exec('ALTER TABLE sessions ADD COLUMN journaled_at INTEGER');
// 升级老库:scheduled_tasks 补 brief 列(人话描述「这个任务干什么」,AI 创建时必填;设定任务即下班,
// brief 直接充当会话的日记碎片底子,零 LLM 成本)。默认空串:存量任务无 brief,其下班碎片降级用 prompt 首行。
const schedCols = db.prepare('PRAGMA table_info(scheduled_tasks)').all();
if (!schedCols.some(c => c.name === 'brief')) db.exec("ALTER TABLE scheduled_tasks ADD COLUMN brief TEXT NOT NULL DEFAULT ''");
// 迁移:model_slot 记会话粘住的具体池 key 槽位(「平台#key下标」,key 为共享资源不再独占),
// 跨结版/重启保持(只有手动换绑或模型失效改选会动),model_id 存模型 id 供展示/统计(见 engine.applyBinding)。
if (!cols.some(c => c.name === 'model_slot')) db.exec('ALTER TABLE sessions ADD COLUMN model_slot TEXT');
+89 -19
View File
@@ -168,27 +168,38 @@ function syncModelPool() {
startHeldSweeper();
}
// ---------- held 自动收口(保持中 → 已完成) ----------
// held 自「key 共享非独占」后不再持有任何资源(旧 model_hold 租约已废弃,见 config.js 注释),
// 只是给用户留着「还能追问」的视觉信号;但长期挂着会显得会话永不收口,出口只剩手动「断开」。
// 超时翻 completed 是零行为影响的纯状态动作:历史与模型绑定都不动,用户再发言走
// postUserMessage 的 completed 分支照常原模型续跑。
// 护栏:阈值远大于 AUTO_COMPRESS_GRACE_MS,不会挤掉自动压缩提议的确认窗口(提议弹出后用户随时可确认,
// 收口不拦 /summarize);判据只看 status(held 定义上不在输出中,抢先发言已把状态翻离 held,不会误收);
// held_at 为 NULL(无从判时长的存量数据)跳过;agent.auto_complete_ms = 0 关闭。
// 扫描间隔随阈值自适应:生产默认 30 分钟封顶 60s;测试把阈值调小即可获得分钟级以下的扫描节奏。
// 运行期改了 auto_complete_ms 不会重调间隔,重启生效(阈值本身每次 tick 重读,支持热关/热改)。
// ---------- 会话闲置处理(30min held 归档 + 4h 记忆收口) ----------
// 阶段一 held 自动收口:held 自「key 共享非独占」后不再持有任何资源(旧 model_hold 租约已废弃,见 config.js 注释),
// 只是给用户留着「还能追问」的视觉信号;但长期挂着会显得会话永不收口。超时翻 completed 是零行为影响的纯状态动作:
// 历史与模型绑定都不动,用户再发言走 postUserMessage 的 completed 分支照常原模型续跑。
// 阶段二 记忆收口(长期日记):从未收口(journaled_at 空)且静默超 memory.wrap_idle_ms(默认 4h)的
// held/completed 会话 → 后台异步 journalFragment 摘要落碎片(fire-and-forget,绝不阻塞消息路径),
// 落地即占坑不再二次收口;顺手归档 held、删 channel_sessions 绑定行——微信下条消息经 ensureSession
// 自然新建工作台(网页无绑定行,DELETE 空操作;用户抢先复活旧会话则不撤台,只丢记忆不再补)。
// 共用护栏:阈值远大于 AUTO_COMPRESS_GRACE_MS,不挤掉自动压缩提议确认窗口;判据只看 status
//(held/completed 定义上不在输出中,抢先发言已把状态翻离);held_at 为 NULL 的阶段一存量跳过;
// agent.auto_complete_ms / memory.wrap_idle_ms 各自 0 = 关对应阶段;updated_at 门槛越过即永远成立,
// 「不重复收口」全靠 journaled_at 物理标记(防陈年 completed 会话每轮扫描重复烧摘要 LLM)。
// 扫描间隔随两阈值较小者自适应:生产封顶 60s,测试调小阈值即得分钟以下节奏;
// 运行期改阈值不重调间隔,重启生效(阈值每次 tick 重读,支持热关/热改)。
const HOLD_SWEEP_MIN_MS = 1000, HOLD_SWEEP_MAX_MS = 60000;
const WRAP_SWEEP_BATCH = 5; // 收口单轮上限:摘要要发 LLM,服务重启后存量陈年会话分批消化,不成风暴
let holdSweeper = null;
function startHeldSweeper() {
if (holdSweeper) return; // init 重复调用幂等
const th = Math.floor(Number((cfg.agent || {}).auto_complete_ms) || 0);
if (th <= 0) return; // 关闭态不建定时器
const interval = Math.max(HOLD_SWEEP_MIN_MS, Math.min(HOLD_SWEEP_MAX_MS, Math.floor(th / 4)));
holdSweeper = setInterval(sweepHeldTimeouts, interval);
const wh = Math.floor(Number((cfg.memory || {}).wrap_idle_ms) || 0);
if (th <= 0 && wh <= 0) return; // 两阶段全关不建定时器
const step = Math.min(th > 0 ? th : Infinity, wh > 0 ? wh : Infinity);
const interval = Math.max(HOLD_SWEEP_MIN_MS, Math.min(HOLD_SWEEP_MAX_MS, Math.floor(step / 4)));
holdSweeper = setInterval(sweepIdleSessions, interval);
if (holdSweeper.unref) holdSweeper.unref(); // 同 scheduler:常驻轮询不阻止进程退出
}
function sweepHeldTimeouts() {
function sweepIdleSessions() {
sweepAutoComplete();
sweepJournalWrap();
}
function sweepAutoComplete() {
try {
const ms = Math.floor(Number((cfg.agent || {}).auto_complete_ms) || 0);
if (ms <= 0) return;
@@ -203,6 +214,29 @@ function sweepHeldTimeouts() {
log.warn('engine', 'held 收口扫描异常: ' + (e && e.message || e));
}
}
function sweepJournalWrap() {
try {
const ms = Math.floor(Number((cfg.memory || {}).wrap_idle_ms) || 0);
if (ms <= 0) return;
const rows = db.prepare(
"SELECT id FROM sessions WHERE journaled_at IS NULL AND status IN ('held','completed') AND updated_at <= ?"
+ ' ORDER BY updated_at LIMIT ?'
).all(now() - ms, WRAP_SWEEP_BATCH);
for (const r of rows) {
// 摘要落地(新增或去重命中)才解绑归档;生成中抢先发言(active)则本次撤台跳过,不打扰用户当下工作台。
journalFragment(r.id).then(landed => {
if (!landed) return;
const s = getSession(r.id);
if (!s || s.status === 'active') return;
if (s.status === 'held') { try { releaseHold(r.id); } catch (_) { /* 并发断开/删除,忽略 */ } }
db.prepare('DELETE FROM channel_sessions WHERE session_id = ?').run(r.id);
log.info('memory', r.id + ' 空闲收口:碎片已入日记,通道解绑退位(阈值 ' + ms + 'ms)');
});
}
} catch (e) {
log.warn('memory', '空闲收口扫描异常: ' + (e && e.message || e));
}
}
// ---------- 模型池调度(优先级选择,无排队、无独占) ----------
// key 是共享资源:同一个 key 可同时服务多个 looping 会话(上游 key 本身支持多并发),
@@ -517,6 +551,9 @@ function finalize(sessionId, run) {
bus.emit(sessionId, 'done', { status: 'held' });
emitStatus(sessionId);
maybeGenerateTitle(sessionId, s);
// 定时即下班:本回合创建过定时任务 → done 广播后收口(attachBus 监听已在 done 回调里同步捕获绑定入队投递,
// 此时删绑定不影响微信本次回复送达)。
if (run.taskWrap) taskClockOut(sessionId);
}
// 首次交互结束后自动生成会话标题:fire-and-forget,不阻塞回合收尾。
@@ -735,7 +772,9 @@ async function runLoopInner(sessionId, run) {
isError = true;
} else {
try {
output = await executeTool({ sessionId, taskDir: taskDirOf(sessionId), run, cfg, db, vision },
output = await executeTool({ sessionId, taskDir: taskDirOf(sessionId), run, cfg, db, vision,
onTaskCreated: () => { run.taskWrap = true; } }, // 定时即下班:工具只打标记,收口在 finalize(回合结束后才能解绑归档)
tc.function.name, chk.args);
} catch (err) {
output = 'Error: ' + (err && err.message || String(err));
@@ -1224,15 +1263,18 @@ function journalFragment(sessionId) {
if (!memory.isEnabled(cfg)) return done(false);
if (journaling.has(sessionId)) return done(false);
const s = getSession(sessionId);
if (!s) return done(false);
const day = memory.dayString(s.created_at);
if (!s || s.journaled_at) return done(false); // 已收口的会话不二次碎片(每会话唯一碎片的入口保证)
const day = memory.dayString(now()); // 时间线跟「下班那天」走,不跟建会话那天(定稿):
// 长跨度会话的碎片若入创建日,可能落进已被裁掉的旧条目里永远看不见。
const files = listTaskTopFiles(sessionId);
// 无论成败都落一条:模型不可用/空回时降级为「标题 + 成果文件清单」,日记不断档。
const finish = body => {
journaling.delete(sessionId);
const text = '【' + (s.title || '未命名会话') + ' · ' + s.id + '】\n'
+ (body || '- 本次工作未能生成摘要(模型不可用);成果文件:' + (files.length ? files.join('、') : '无'));
return memory.appendFragment(db, cfg, s.user, day, text, s.id);
const r = memory.appendFragment(db, cfg, s.user, day, text, s.id);
if (r === 'added' || r === 'dupe') memory.markJournaled(db, sessionId, now()); // dupe 也算收口,不重试
return r === 'added' || r === 'dupe';
};
if (!s.model_id) return done(finish(null)); // 未绑定:不跑模型,直接记降级版
journaling.add(sessionId);
@@ -1250,6 +1292,33 @@ function journalFragment(sessionId) {
});
}
// 定时即下班(定稿):创建定时任务 = 本工作台会话收口,碎片用任务 brief 纯模板,零 LLM。
// 由 finalize 在回合 done 广播后调用(时序安全:attachBus 监听在 done 回调里已同步捕获绑定并入队投递,
// 删 channel_sessions 不影响本次微信回复;投递只依赖 wechat_bindings 表)。
// 收口三件套:碎片入创建日条目 + journaled 占坑(本会话从此退出 4h 空闲流程,任务执行痕迹不落日记,
// 用户拿「任务是什么 + 成果文件」即可回溯全貌)+ 顺手归档 + 解绑退位。
// 记忆整体关闭(retain_days=0)时不收口也不解绑:没有日记的下班毫无意义,别把用户工作台抽了。
// 回合内任务又被删的边缘:查无任务即放弃,退回 4h 空闲轨道。
function taskClockOut(sessionId) {
try {
if (!memory.isEnabled(cfg)) return;
const s = getSession(sessionId);
if (!s || s.journaled_at) return; // 空闲收口抢先落地过,不重复
const t = db.prepare('SELECT cron_expr, prompt, brief FROM scheduled_tasks WHERE session_id = ?').get(sessionId);
if (!t) return;
const what = String(t.brief || t.prompt || '').replace(/\s+/g, ' ').trim().slice(0, 80);
const text = '【设定周期任务 · ' + s.id + '】\n- 用户让我设了个闹钟:' + what
+ '(频率 ' + t.cron_expr + ',到点自动执行,本会话是该任务的专柜)';
const r = memory.appendFragment(db, cfg, s.user, memory.dayString(now()), text, s.id); // 碎片入「下班当天」
if (r === 'added' || r === 'dupe') memory.markJournaled(db, sessionId, now());
if (s.status === 'held') { try { releaseHold(sessionId); } catch (_) { /* 并发归档 */ } }
const un = db.prepare('DELETE FROM channel_sessions WHERE session_id = ?').run(sessionId);
log.info('memory', sessionId + ' 定时即下班:闹钟碎片入日记' + (un.changes ? ',通道解绑退位' : ''));
} catch (e) {
log.warn('memory', sessionId + ' 定时收口异常: ' + (e && e.message || e));
}
}
// 会话级 /tmp 的宿主机实体:<任务目录>/.tmp(executor wrapper 把它 bind 进容器 /tmp,HOME/TMPDIR 也指这里,
// 跨 /exec 保留)。清空对话时一并抹掉:临时产物不该带进新一轮;删了下次执行 executor 懒重建,无副作用。
// 尽力而为:不存在不动;符号链接只断不跟进;失败只记日志不阻断清空。
@@ -1290,7 +1359,8 @@ function clearSessionMessages(sessionId) {
autoCompressProposed.delete(sessionId); // 历史清零,恢复自动压缩提议额度
// 标题随历史一并清零:旧标题描述的是已删除的对话,留着会让新对话文不对题;
// 新一轮交互结束后 maybeGenerateTitle 见 title 为空会自动重新生成。
touch(sessionId, { status: 'completed', completed_at: now(), cancelled_at: null, held_at: null, title: null, title_locked: 0, phase: 'advising' });
// journaled_at 清零:清空 = 这单作业被撕掉,旧碎片随对话作废,新一轮将来可再收口。
touch(sessionId, { status: 'completed', completed_at: now(), cancelled_at: null, held_at: null, title: null, title_locked: 0, phase: 'advising', journaled_at: null });
profile.freezeSnapshot(db, sessionId); // 回 advising 重新规划:画像快照随新一轮重新冻结
bus.emit(sessionId, 'done', { status: 'completed' });
bus.emit(sessionId, 'title', { title: null }); // 供其他打开同一会话的窗口同步清掉旧标题
+17 -8
View File
@@ -3,9 +3,9 @@
// 与 profile(user-profile.js)分工:profile 记「用户是什么样的人」(语义记忆、稳定特质),
// 日记记「我近几天帮他做过什么」(事件记忆、按天条目),两类记忆互不混。
// 规则:
// - (user, day) 一行;碎片 = 会话轮换(下班换工作台)时生成的一小段第一人称记录,
// 按【来源会话创建日】追加进当日条目;同日多碎片按到达顺序拼接,不做 LLM 二次合并
// (确定性、零成本,每片本身已是条目化短文本);
// - (user, day) 一行;碎片 = 会话收口(下班)时生成的一小段第一人称记录,
// 按【收口当日】入条目(时间线跟下班日走,长跨度会话不会把记忆落进已裁掉的旧日期);
// 同日多碎片按到达顺序拼接,不做 LLM 二次合并(确定性、零成本,每片本身已是条目化短文本);
// - sid 去重:同一会话向同一天的条目只贡献一次碎片(防轮换竞态双写;代价:同一会话
// 被 /switch 捡回再离开时第二片同样被挡——M0 接受的简化,粒度留到轮换触发接线时复盘);
// - memory.retain_days = 保留窗口(默认 7 天,硬帽 MAX_RETAIN);0 = 整体关闭(不写不读不裁)。
@@ -36,14 +36,16 @@ function recentDays(cfg, refMs) {
// ---------- 写:碎片追加进对应天条目 ----------
// sid 三重角色:去重标记 / 条目里的下钻索引(M3 回忆按它取旧会话详情与成果文件)/ 溯源。
// 返回值三态:'added' 新落 / 'dupe' 该会话已有碎片(去重命中)/ 'off' 功能关闭或空文。
// 调用方(engine 收口链路)把 added 与 dupe 都视为「已收口」落 journaled 标记,不重试不重复摘要。
function appendFragment(db, cfg, user, day, text, sid) {
if (!isEnabled(cfg) || !day) return false;
if (!isEnabled(cfg) || !day) return 'off';
const frag = String(text || '').replace(/\r/g, '').trim().slice(0, FRAG_MAX);
if (!frag) return false;
if (!frag) return 'off';
const key = String(user || '');
const row = db.prepare('SELECT content FROM memory_entries WHERE user = ? AND day = ?').get(key, day);
const base = row ? String(row.content) : '';
if (sid && base.includes(String(sid))) return false; // 本会话已入当天日记
if (sid && base.includes(String(sid))) return 'dupe'; // 本会话已入当天日记
let next = base ? base + '\n\n' + frag : frag;
if (next.length > DAY_MAX) next = next.slice(next.length - DAY_MAX);
db.prepare(
@@ -51,7 +53,14 @@ function appendFragment(db, cfg, user, day, text, sid) {
+ ' ON CONFLICT(user, day) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at'
).run(key, day, next, Date.now());
prune(db, cfg); // 裁剪就一条廉价 DELETE,每次追加顺带做,表恒在保留窗内
return true;
return 'added';
}
// 收口标记:每会话唯一碎片的物理保证(空闲/任务收口落地后置位;之后会话被再激活也不补碎片——
// 记忆稳定性优先于完备,新工作值得新工作台)。
function markJournaled(db, sessionId, ms) {
db.prepare('UPDATE sessions SET journaled_at = ? WHERE id = ? AND journaled_at IS NULL')
.run(Number(ms) || Date.now(), String(sessionId));
}
// ---------- 读:渲染成可注入会话上下文的日记文本(M2 的数据源) ----------
@@ -82,6 +91,6 @@ function prune(db, cfg) {
module.exports = {
isEnabled, retainDays, dayString, recentDays,
appendFragment, journalFor, prune,
appendFragment, markJournaled, journalFor, prune,
MAX_RETAIN, DAY_MAX, FRAG_MAX,
};
+3 -3
View File
@@ -50,15 +50,15 @@ function validateCron(cronExpr) {
// sessionId 由调用方从工具 ctx 取(AI 无法指定别的会话)。校验顺序:
// validateCron → 本会话尚无任务 → INSERT(主键冲突兜底)。
function createTask(db, sessionId, cronExpr, prompt) {
function createTask(db, sessionId, cronExpr, prompt, brief) {
if (prompt.length > PROMPT_MAX_LEN) throw new Error('prompt 过长(上限 ' + PROMPT_MAX_LEN + ' 字符)');
const first = validateCron(cronExpr);
const exist = db.prepare('SELECT cron_expr FROM scheduled_tasks WHERE session_id = ?').get(sessionId);
if (exist) throw new Error('本会话已有定时任务(' + exist.cron_expr + ')。改频次或提示词用 op=update;确要换新任务先 op=delete 再 op=create');
try {
db.prepare(
'INSERT INTO scheduled_tasks (session_id, cron_expr, prompt, next_run_at, created_at) VALUES (?,?,?,?,?)'
).run(sessionId, cronExpr, prompt, first, Date.now());
'INSERT INTO scheduled_tasks (session_id, cron_expr, prompt, brief, next_run_at, created_at) VALUES (?,?,?,?,?,?)'
).run(sessionId, cronExpr, prompt, String(brief || '').slice(0, 80), first, Date.now());
} catch (_) {
// 单进程同步 API 下正常到不了这里(上一步已查重),仅作主键约束重复报错的兜底
const ex = db.prepare('SELECT cron_expr FROM scheduled_tasks WHERE session_id = ?').get(sessionId);
+5 -1
View File
@@ -235,7 +235,7 @@
"type": "function",
"function": {
"name": "schedule",
"description": "Manage the recurring scheduled task bound to the CURRENT session. At most one task per session; it is deleted together with the session. At each trigger, the prompt is sent to this session as a new user message. Schedule times are interpreted in Asia/Shanghai (UTC+8). Call this ONLY when the user explicitly asks for something to run periodically or at a specific time.\n\nop=get No arguments.\nop=create Requires cron_expr and prompt.\nop=update Requires at least one of cron_expr, prompt; only the given fields change.\nop=delete No arguments.",
"description": "Manage the recurring scheduled task bound to the CURRENT session. At most one task per session; it is deleted together with the session. At each trigger, the prompt is sent to this session as a new user message. Schedule times are interpreted in Asia/Shanghai (UTC+8). Call this ONLY when the user explicitly asks for something to run periodically or at a specific time.\n\nop=get No arguments.\nop=create Requires cron_expr, prompt and brief.\nop=update Requires at least one of cron_expr, prompt; only the given fields change.\nop=delete No arguments.",
"parameters": {
"type": "object",
"required": [
@@ -259,6 +259,10 @@
"prompt": {
"type": "string",
"description": "The message to send to this session at each trigger. Write it as a self-contained instruction: previous conversation history is archived before each run, so this prompt is the only input the model will see. The output stays in this session for the user to view; if it must reach the user proactively, state how in the prompt (e.g. via a skill or webhook). Required with op=create; optional with op=update."
},
"brief": {
"type": "string",
"description": "One short plain-language line (<= 40 chars) saying what this task actually accomplishes, e.g. 'collect and produce a daily news PDF report'. It is written into the assistant's long-term memory diary so the recurring job can be recalled later. Required with op=create."
}
}
}
+7 -4
View File
@@ -776,16 +776,19 @@ function toolScheduleTask(ctx, args) {
const last = t.last_run_at
? scheduler.fmtTime(t.last_run_at) + '(状态 ' + (t.last_status || '-') + (t.last_note ? ',' + t.last_note : '') + ')'
: '尚未执行';
return '本会话定时任务:cron=' + t.cron_expr + '(Asia/Shanghai),下次执行 ' +
return '本会话定时任务' + (t.brief ? '「' + t.brief + '」' : '') + ':cron=' + t.cron_expr + '(Asia/Shanghai),下次执行 ' +
scheduler.fmtTime(t.next_run_at) + ',上次执行 ' + last + '。提示词:' + t.prompt;
}
case 'create': {
if (!cronExpr) throw new Error('op=create 缺少必填参数 cron_expr');
if (!prompt) throw new Error('op=create 缺少必填参数 prompt');
const t = scheduler.createTask(db, ctx.sessionId, cronExpr, prompt);
const brief = String(args.brief || '').replace(/\s+/g, ' ').trim().slice(0, 80);
const t = scheduler.createTask(db, ctx.sessionId, cronExpr, prompt, brief);
// 定时即下班:标记本回合收尾时由 engine 收口(brief 碎片 + 归档 + 通道解绑,见 engine.taskClockOut)。
if (ctx.onTaskCreated) ctx.onTaskCreated();
return '定时任务已创建:' + t.cron_expr + ',下次执行 ' + t.next_text + '(Asia/Shanghai)。' +
'注意:每次触发前本会话的历史消息会被存档(AI 只看到任务 prompt),因此 prompt 需自包含;' +
'后续改动用 op=update,取消用 op=delete。';
'后续改动用 op=update,取消用 op=delete。' + (brief ? '' : '(下次创建记得带 brief:一句话说明任务干什么,它会写进你的长期记忆。)');
}
case 'update': {
if (!cronExpr && !prompt) throw new Error('op=update 需要 cron_expr 和 prompt 至少提供一个');
@@ -800,7 +803,7 @@ function toolScheduleTask(ctx, args) {
return '定时任务已删除(原定 ' + old + ')。要建新任务用 op=create。';
}
default:
throw new Error('未知的 op:"' + op + '"。可用:get / create(需 cron_expr、prompt)/ update(需 cron_expr、prompt 至少一个)/ delete');
throw new Error('未知的 op:"' + op + '"。可用:get / create(需 cron_expr、prompt、brief)/ update(需 cron_expr、prompt 至少一个)/ delete');
}
}