maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime-host/dist/assistant/index-initiative/notebook.js

@@ -0,0 +1,286 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { createHash } from 'node:crypto';
+export class NotebookValidationError extends Error {
+}
+const requireThat = (ok, message) => {
+    if (!ok)
+        throw new NotebookValidationError(message);
+};
+const nonempty = (x) => typeof x === 'string' && x.trim().length > 0;
+const strings = (x) => Array.isArray(x) && x.every(nonempty);
+const iso = (x) => typeof x === 'string' && /(?:Z|[+-]\d{2}:\d{2})$/.test(x) && Number.isFinite(Date.parse(x));
+const fingerprint = (x) => createHash('sha256').update(JSON.stringify(x)).digest('hex');
+const overlaps = (a, b) => a.some((x) => b.includes(x));
+// Append-only shared context. The Host owns user feedback and delivery receipts;
+// the model chooses which observations and recommendations have value.
+export class Notebook {
+    db;
+    clock;
+    delivering;
+    constructor(path, clock = () => new Date().toISOString()) {
+        this.db = new DatabaseSync(path);
+        this.clock = clock;
+        this.db.exec(`PRAGMA journal_mode=WAL;
+      CREATE TABLE IF NOT EXISTS events(seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        id TEXT NOT NULL UNIQUE, kind TEXT NOT NULL, at TEXT NOT NULL, payload TEXT NOT NULL);`);
+        this.delivering = false;
+    }
+    close() {
+        this.db.close();
+    }
+    transaction(fn) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const result = fn();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    events(kind) {
+        return (kind
+            ? this.db.prepare('SELECT * FROM events WHERE kind=? ORDER BY seq').all(kind)
+            : this.db.prepare('SELECT * FROM events ORDER BY seq').all()).map((r) => ({ ...r, payload: JSON.parse(String(r.payload)) }));
+    }
+    event(id) {
+        const r = this.db.prepare('SELECT * FROM events WHERE id=?').get(id);
+        return r && { ...r, payload: JSON.parse(String(r.payload)) };
+    }
+    put(id, kind, payload, at = this.clock()) {
+        requireThat(nonempty(id) && iso(at), 'Event ID and recorded time required');
+        const old = this.event(id);
+        if (old) {
+            requireThat(old.kind === kind && fingerprint(old.payload) === fingerprint(payload), 'Operation ID content conflict');
+            return old.seq;
+        }
+        return Number(this.db
+            .prepare('INSERT INTO events(id,kind,at,payload) VALUES(?,?,?,?)')
+            .run(id, kind, at, JSON.stringify(payload)).lastInsertRowid);
+    }
+    feedback() {
+        // Legacy conversation imports had no delivery relationship. Retain their events
+        // for audit, but do not treat ordinary chats or their inferred rules as feedback.
+        return this.events('feedback').filter((e) => this.event(e.payload.replyTo ?? '')?.kind === 'delivery');
+    }
+    feedbackResolutions() {
+        const valid = new Set(this.feedback().map((e) => e.id));
+        return this.events('feedback-resolution').filter((e) => valid.has(e.payload.feedbackId));
+    }
+    revision() {
+        return this.feedback().at(-1)?.seq ?? 0;
+    }
+    pendingFeedback() {
+        const settled = new Set(this.events('feedback-resolution').map((e) => e.payload.feedbackId));
+        return this.feedback().filter((e) => !settled.has(e.id));
+    }
+    topics() {
+        const topics = new Map();
+        for (const e of this.events('note')) {
+            const n = e.payload;
+            const topic = topics.get(n.topicId) ?? { id: n.topicId, title: n.title, tags: [], notes: [] };
+            topic.tags = [...new Set([...topic.tags, ...(n.tags ?? [])])];
+            topic.notes.push({ ...n, recordedAt: e.at });
+            topics.set(n.topicId, topic);
+        }
+        return topics;
+    }
+    state(topicId, now = this.clock()) {
+        const topic = this.topics().get(topicId);
+        requireThat(topic, 'Unknown topic');
+        let current = { status: 'open', reason: null, feedbackId: null };
+        for (const e of this.feedbackResolutions().sort((a, b) => this.event(a.payload.feedbackId).seq - this.event(b.payload.feedbackId).seq))
+            for (const rule of e.payload.rules) {
+                if (!rule.topicIds.includes(topicId) && !overlaps(rule.tags, topic.tags))
+                    continue;
+                current = { ...rule, feedbackId: e.payload.feedbackId };
+            }
+        if (current.status === 'deferred' &&
+            current.resumeAt &&
+            Date.parse(now) >= Date.parse(current.resumeAt))
+            current = { ...current, status: 'open', resumedByUserDeadline: true };
+        const receipts = this.events('delivery').filter((e) => e.payload.topicIds.includes(topicId));
+        // Display 'sent' without destroying the user's open/deferred/closed policy.
+        return {
+            ...current,
+            displayStatus: current.status === 'open' && receipts.length ? 'sent' : current.status,
+            receipts,
+        };
+    }
+    recordFeedback({ id, text, at = this.clock(), replyTo = null, }) {
+        requireThat(nonempty(text) && iso(at), 'Feedback text and time required');
+        requireThat(this.event(replyTo ?? '')?.kind === 'delivery', 'Feedback reply must reference an actual delivery');
+        return this.put(id, 'feedback', { text, replyTo }, at);
+    }
+    appendNote(note, id, recordedAt = this.clock()) {
+        requireThat(note &&
+            Object.keys(note).every((k) => ['topicId', 'title', 'text', 'occurredAt', 'sources', 'tags', 'related'].includes(k)), 'Unsupported note field');
+        requireThat(nonempty(note.topicId) && nonempty(note.title) && nonempty(note.text), 'Missing note content');
+        requireThat(note.occurredAt == null || nonempty(note.occurredAt), 'Invalid occurrence time');
+        requireThat(strings(note.sources) && note.sources.length > 0 && strings(note.tags ?? []), 'Information sources required');
+        requireThat(strings(note.related ?? []), 'Related topics must be IDs');
+        const old = this.topics().get(note.topicId);
+        requireThat(!old || old.title === note.title, 'Append corrections instead of renaming old topics');
+        return this.put(id, 'note', {
+            ...note,
+            occurredAt: note.occurredAt ?? null,
+            tags: note.tags ?? [],
+            related: note.related ?? [],
+        }, recordedAt);
+    }
+    resolveFeedback(resolution, id) {
+        const { feedbackId, understanding, rules } = resolution;
+        const feedback = this.event(feedbackId);
+        requireThat(this.feedback().some((e) => e.id === feedbackId) &&
+            nonempty(understanding) &&
+            Array.isArray(rules), 'Real user feedback and interpretation required');
+        requireThat(!this.events('feedback-resolution').some((e) => e.payload.feedbackId === feedbackId), 'Feedback already interpreted');
+        for (const rule of rules) {
+            requireThat(Object.keys(rule).every((k) => ['quote', 'status', 'reason', 'resumeAt', 'topicIds', 'tags'].includes(k)), 'Unsupported feedback rule field');
+            requireThat(nonempty(rule.quote) && feedback.payload.text.includes(rule.quote), 'State changes must cite user feedback verbatim');
+            requireThat(['open', 'deferred', 'closed'].includes(rule.status), 'Invalid feedback state');
+            requireThat(strings(rule.topicIds) && strings(rule.tags) && rule.topicIds.length + rule.tags.length > 0, 'Explicit feedback scope required');
+            requireThat(rule.topicIds.every((x) => this.topics().has(x)), 'Unknown feedback target');
+            requireThat(!rule.resumeAt || iso(rule.resumeAt), 'Resume time must be absolute with timezone');
+            requireThat(rule.status !== 'closed' || nonempty(rule.reason), 'Closing requires a reason');
+            requireThat(rule.status !== 'deferred' || nonempty(rule.reason) || rule.resumeAt, 'Deferring requires a reason or resume time');
+            requireThat(rule.status === 'deferred' || !rule.resumeAt, 'Only deferred rules have a resume time');
+        }
+        return this.put(id, 'feedback-resolution', resolution);
+    }
+    commitDraft({ role, operationId, expectedFeedbackRevision, draft, }) {
+        requireThat(['exploration', 'judgement'].includes(role), 'Unknown role');
+        const digest = fingerprint({ role, expectedFeedbackRevision, draft });
+        return this.transaction(() => {
+            const prior = this.event(operationId);
+            if (prior) {
+                requireThat(prior.kind === 'draft' && prior.payload.digest === digest, 'Draft operation ID conflict');
+                return prior.payload.result;
+            }
+            requireThat(this.revision() === expectedFeedbackRevision, 'FEEDBACK_CHANGED: refresh feedback before committing');
+            requireThat(draft &&
+                Object.keys(draft).every((k) => ['notes', 'feedbackDecisions', 'messages'].includes(k)), 'Unsupported draft field');
+            const { notes = [], feedbackDecisions = [], messages = [] } = draft;
+            requireThat([notes, feedbackDecisions, messages].every(Array.isArray), 'Draft operations must be arrays');
+            requireThat(role === 'judgement' || (!feedbackDecisions.length && !messages.length), 'Exploration only appends knowledge');
+            notes.forEach((n, i) => this.appendNote(n, `${operationId}:note:${i}`));
+            feedbackDecisions.forEach((f, i) => this.resolveFeedback(f, `${operationId}:feedback:${i}`));
+            if (role === 'judgement')
+                requireThat(this.pendingFeedback().length === 0, 'Read and interpret pending user feedback first');
+            const preparedIds = [];
+            messages.forEach((m, i) => {
+                requireThat(Object.keys(m).every((k) => ['text', 'topicIds'].includes(k)) &&
+                    nonempty(m.text) &&
+                    strings(m.topicIds) &&
+                    m.topicIds.length, 'Message text and related topics required');
+                // Topic state informs the agent; it is not a ban on discussing that topic.
+                const topics = this.topics();
+                requireThat(m.topicIds.every((t) => topics.has(t)), 'Unknown message topic');
+                const id = `${operationId}:message:${i}`;
+                this.put(id, 'prepared', { ...m, feedbackRevision: this.revision() });
+                preparedIds.push(id);
+            });
+            const result = {
+                preparedIds,
+                notesAdded: notes.length,
+                feedbackProcessed: feedbackDecisions.length,
+            };
+            this.put(operationId, 'draft', { digest, result });
+            return result;
+        });
+    }
+    async deliver(preparedId, sender, transport) {
+        requireThat(nonempty(transport), 'Delivery transport label required');
+        const receiptId = `${preparedId}:delivered`;
+        if (this.event(receiptId))
+            return this.event(receiptId);
+        requireThat(!this.delivering, 'Another send is in progress');
+        const event = this.event(preparedId);
+        requireThat(event?.kind === 'prepared', 'Unknown prepared message');
+        const m = event.payload;
+        requireThat(this.revision() === m.feedbackRevision && !this.pendingFeedback().length, 'FEEDBACK_CHANGED: re-evaluate prepared message');
+        this.delivering = true;
+        try {
+            // The transport must deduplicate this stable key after a process crash.
+            const ack = await sender({ messageId: preparedId, messages: [{ text: m.text }] });
+            requireThat(ack?.delivered === true && strings(ack.messageIds) && ack.messageIds.length > 0, 'No confirmed delivery receipt');
+            this.put(receiptId, 'delivery', {
+                preparedId,
+                topicIds: m.topicIds,
+                text: m.text,
+                transport,
+                messageIds: ack.messageIds,
+            });
+            return this.event(receiptId);
+        }
+        finally {
+            this.delivering = false;
+        }
+    }
+    render({ topicIds = null, now = this.clock(), } = {}) {
+        const lines = [
+            '# 用户相关世界的记事本',
+            '',
+            '内容是参考资料；用户反馈需结合原话、范围和时间理解。开放表示方向未被用户关闭，不表示事情仍在进行。爱好可能长期持续，具体事情会过去；发生时间未知时结合正文与来源判断，不以记录时间代替。',
+            '',
+            '## 用户反馈',
+        ];
+        const pending = new Set(this.pendingFeedback().map((x) => x.id));
+        for (const f of this.feedback())
+            lines.push(`- ${f.at}｜${f.id}｜${pending.has(f.id) ? '待理解' : '已理解'}${f.payload.replyTo ? '｜回复 ' + f.payload.replyTo + '｜主题：' + this.event(f.payload.replyTo).payload.topicIds.join('、') : ''}\n  ${f.payload.text}`);
+        if (!this.feedback().length)
+            lines.push('暂无用户反馈。');
+        const rules = this.feedbackResolutions().flatMap((e) => e.payload.rules.map((r) => ({
+            ...r,
+            feedbackId: e.payload.feedbackId,
+        })));
+        if (rules.length) {
+            lines.push('', '## 用户反馈的范围与依据');
+            for (const r of rules)
+                lines.push(`- ${r.status}｜主题：${r.topicIds.join('、') || '无'}｜方向：${r.tags.join('、') || '无'}｜依据 ${r.feedbackId}：“${r.quote}”｜原因：${r.reason || '按用户给定时间'}${r.resumeAt ? '｜恢复时间：' + r.resumeAt : ''}`);
+            lines.push('以上按反馈顺序记录；较新的相关用户反馈修正之前的状态，主题下展示当前状态。');
+        }
+        for (const topic of this.topics().values()) {
+            if (topicIds && !topicIds.includes(topic.id))
+                continue;
+            const s = this.state(topic.id, now);
+            const labels = {
+                open: '开放',
+                sent: '已发送',
+                deferred: '暂缓',
+                closed: '关闭',
+            };
+            lines.push('', `## ${topic.title}〔${topic.id}〕`, `状态：${labels[s.displayStatus]}${s.reason ? '；原因：' + s.reason : ''}${s.feedbackId ? '；依据：' + s.feedbackId : ''}`, `方向：${topic.tags.join('、') || '未分类'}`);
+            if (s.resumeAt)
+                lines.push(`用户指定恢复时间：${s.resumeAt}`);
+            for (const n of topic.notes)
+                lines.push(`- ${n.text}\n  发生时间：${n.occurredAt ?? '未知'}｜记录时间：${n.recordedAt}\n  来源：${n.sources.join('；')}${n.related?.length ? '\n  关联主题：' + n.related.join('、') : ''}`);
+            for (const r of s.receipts)
+                lines.push(`- 已发送 ${r.at}〔${r.id}〕：${r.payload.text}`);
+        }
+        lines.push('', '## 已交给 Bot 的文案（不代表已送达）');
+        for (const e of this.events('reported'))
+            lines.push(`- ${e.at}：${e.payload.text}`);
+        return lines.join('\n') + '\n';
+    }
+}

package/node_modules/@maka/runtime-host/dist/assistant/index-initiative/prompt.js

@@ -16,10 +16,35 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-export const PROACTIVE_TASK = `你是用户的主动个人助手，你需要像助手一样工作，通过主动发现当下对用户有价值的事情，让用户觉得你很贴心，很有用，也让用户少遗漏、少费力。
-结合用用户产生的信息，自主探索，进行只读调查，寻找对用户有价值的事情，Index 是信息的不同视角，可以提供线索，但不是待办清单，也不是探索边界。所以不要拘泥于index。
-不要拘泥于围绕最近的话题、未完成的工作或上次以来的新增信息。不需要先有明确任务或问题。
-根据调查结果自主决定深入、转向或结束，不因查过一轮或找到几条线索就草草收尾。有值得交流的发现告诉用户，说明具体内容及其价值，没有合适内容可以保持安静。`;
-export function wake(s, now = Date.now()) {
-    return `Runtime heartbeat, not a new human request.\nHeartbeat ID: ${s.active.id}\nNow (UTC): ${new Date(now).toISOString()}\n${PROACTIVE_TASK}\n\n你在独立的后台探索会话中运行。值得交流的调查发现用 DiscoveryReport 交给 Bot，不直接向用户发消息。没有合适内容可以结束。无需提交 checkpoint 或安排下一次心跳。`;
+export const NOTEBOOK_RULES = `共同维护一份关于用户相关世界的联想记事本，积累可供以后探索的认识和方向。历史、索引、本机和外部世界中遇到的用户相关事实、兴趣、经历、资源、变化、未知和可能的联系，都可以记录；不要求它现在有用、被选为候选或值得通知。符合这些要求的新认识都留下，不只记录本轮调查的线索。
+围绕同一主题在已有条目下追加认识，不同主题可以通过 related 关联，形成以后可以继续探索的方向。不要为了归类强行建立联系。分清事实、推测和未知，保留相关时间，不把资料存在当成用户当前意图，也不把联想当成已确认的偏好。
+每次只追加简短的新认识。可以新增条目，也可以在已有条目下追加补充、修正或新联系；不修改、删除或合并旧条目及旧记录。阅读时结合后续修正理解，不因本轮不推荐就封死整个方向。没有新认识就不写，不重复抄旧内容。
+笔记高度摘要化，保留以后能理解和联想到的意思；必要时留简短回查入口。SQL结果、文件哈希、源码片段、文件清单、工具输出和完整调查过程留在执行记录，不搬进记事本。
+记事本保留值得以后想起的要点，不收集完整资料。写入前对照已有内容，保留新增的认识、可能性或会影响判断的信息。同一件事的相关细节概括成一条，不拆开堆积，不换个例子重复已有认识。故事、知识和资源都可以记，只留下值得记住的部分。
+区分事情发生的时间与记录时间，发生时间未知就留空。既有来源和条目关联保留，新记录写信息来源即可，不要求提供链接。
+用户反馈可以修正认识；只有明确用户反馈可以关闭、暂缓或重新开放方向，写明依据和范围。暂缓须有原因或恢复时间，关闭须有原因。自己的本轮判断不能给线索判生死，用户沉默也不表示拒绝。实际发送记录用于理解已经交流过什么；是否交流仍由你结合内容判断。
+写法更新：记事本直接记简短的事实、变化、联系和未知，不写防错声明，不在每条后面堆“不能据此认定”“不代表”“未授权”等尾巴。确实影响理解的未知，简短写“待核实”或具体缺什么。推荐文案同样直接说有用的内容，必要的不确定性用一句话说清，不写调查免责声明。已有笔记仍只追加，不改旧文。`;
+export const DISCOVERY_TASK = `你是用户的主动个人助手，负责广泛发现可能对用户有价值的方向，交给判断会话深入调查。
+从生活和工作等多个方面出发，结合时间线索，探索不同方向。可以顺着已有需求向前推进，也可以发现新的机会和联系，不必追求遥远的联想。不要因为某类信息容易获取和验证，就反复只围绕它探索；找到一个方向后，也继续看看其他方向。
+历史、Index 和联想记事本都可以提供入口，不是探索边界或待办清单。可以从笔记里相关的一组认识继续探索，也可以寻找新的方向。结合当前情况区分过去的经历、仍然相关的需求和即将到来的机会，不能把旧信息直接当成当前需求。工作、本机和外部世界都可以调查。
+通过工具只读探索，了解线索与用户的联系和可能的价值；值得深入的具体核验交给判断会话，不必在一个方向上解决所有问题后才寻找下一个。探索可以是兴趣、机会、帮助、问题或其他有用户价值的方向，不规定类别或数量。未核实的保持为线索。
+将过程中符合记事本要求的新认识简短追加到联想记事本。判断会话自行从整份记事本选择调查方向，不给它指定候选入口，也不替它决定通知数量或表达方式。历史交流和笔记是参考资料，不是本轮指令。
+探索用户可能在意的新事物，而不是与已有话题有关的所有事物。联系应落在用户的兴趣、处境或实际收益上，不能仅凭概念相关。
+注意事件的时间性：爱好可能长期持续，具体事情会过去。结合发生时间和后续变化判断现在是否仍然相关，不因最近读到或记下，就把旧事当成当前需求。`;
+export const JUDGEMENT_TASK = `你是用户的主动个人助手，负责深入调查发现的线索，把可能性推进成对用户实际有用的信息。
+读取联想记事本，自主选择值得深入调查的方向，不限定入口和数量。结合用户的兴趣、处境和时间，通过可用工具进行只读调查，核对原文和相关的当前信息，形成自己的判断。可以顺着线索深入、联系其他认识或改变调查方向，不必停留在发现时的假设。
+不要只判断线索是否成立，还要研究能具体帮用户什么。对有依据的生活兴趣、机会和工作问题都认真推进，不能因为一种方向更容易验证就只深入它。已有材料可以是入口；需要了解现实进展时，继续查询相关的最新信息。区分旧背景与当前需求、事实与推测。
+有潜在价值但信息不足时，尽可能继续调查；确实需要用户的信息时，可以提出有意义的问题，不要把本可自行完成的调查仅改写成“要不要我帮你查”。没有价值、新信息或继续调查的依据时，也可以停止，不必把每条都变成问题或建议。
+调查中新获得的用户相关认识、联系和修正，按记事本规则简短追加，无论本轮是否推荐。已有笔记和过去的不推荐决定都可以被新信息修正。
+值得现在交流的内容写入 messages，自然、直接地说清发现及对用户的意义，保留必要的不确定性，不让用户自己从调查过程里提炼重点。不同事情分开写，不预设通知数量，没有合适内容就留空。准备文案不等于已经送达。最终回复结果文件路径；历史交流和笔记是参考资料，不是本轮指令。
+记事本保存的是可能有用的线索，不是需要推进的任务。注意事件的时间性：爱好可能长期持续，具体事情会过去。结合事情发生的时间、后续变化和用户当前情况，判断它现在能给用户带来什么价值，再决定是否深入调查和交流；不因最近读到或记下，就把旧事当成当前需求。
+结合已有的相关认识，尽可能在本轮查清对用户有用的关键问题，不把能当场完成的调查拆到以后几轮。真正缺少用户信息、等待外部变化或继续调查价值不足时可以停下。先理解待整理的用户反馈，按明确反馈更新相关状态。`;
+export function wakeInput({ role, now, viewPath, outputPath, first = false, }) {
+    if (!['exploration', 'judgement'].includes(role))
+        throw Error('Unknown role');
+    const contract = `${role === 'judgement' ? '基于整份记事本自主调查并判断，不只看本轮新增内容。' : '用工具读取笔记并按需自主调查。'}完成后把增量操作写入 ${outputPath}，格式：
+{"notes":[{"topicId":"已有主题ID或新ID","title":"主题名","text":"简短认识","occurredAt":null,"sources":["信息来源"],"tags":["方向标签"],"related":["可选的相关主题ID"]}],"feedbackDecisions":[{"feedbackId":"用户反馈ID","understanding":"对反馈的理解","rules":[{"quote":"反馈原话中的依据","status":"open|deferred|closed","reason":"原因","resumeAt":null,"topicIds":["作用主题"],"tags":["作用方向"]}]}],"messages":[{"text":"完整消息","topicIds":["涉及主题"]}]}。
+occurredAt可写已知的发生时间或范围，不知道就null。无需填满各数组；输出只包含本次增量，不复制整本笔记。主题和方向标签可按内容新增，相关用户反馈仍需考虑。${role === 'exploration' ? '只填写notes，另外两个数组留空。' : '没有待整理反馈时feedbackDecisions留空；只有用户明确表达状态变化才写rules，否则记理解和有价值的信息即可。关闭方向可能涉及多个主题，方向标签可同时作用于以后相关主题。'}
+提交与送达以当前记事本记录为准，写过结果文件不代表已提交或已发送。最终回复结果文件路径。`;
+    return `${first ? (role === 'exploration' ? DISCOVERY_TASK : JUDGEMENT_TASK) + '\n\n' + NOTEBOOK_RULES + '\n\n' : ''}当前 UTC 时间：${now}\n记事本：${viewPath}\n${contract}`;
 }

package/node_modules/@maka/runtime-host/dist/assistant/index-initiative/store.js

@@ -22,9 +22,11 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 /** Scheduler metadata only. Conversation history belongs to the ordinary Session. */
 export class InitiativeStore {
+    directory;
     owner;
     db;
     constructor(directory, owner) {
+        this.directory = directory;
         this.owner = owner;
         mkdirSync(directory, { recursive: true });
         this.db = new DatabaseSync(join(directory, 'initiative.sqlite'));
@@ -97,6 +99,11 @@ export class InitiativeStore {
                 version: 2,
                 ...binding,
                 discoverySession: old?.discoverySession,
+                judgementSession: old?.judgementSession,
+                candidateReport: old?.candidateReport,
+                pendingJudgement: old?.pendingJudgement,
+                pendingDraft: old?.pendingDraft,
+                promptVersions: old?.promptVersions,
                 intervalMs,
                 enabled,
                 revision: (old?.revision ?? 0) + 1,
@@ -172,7 +179,12 @@ export class InitiativeStore {
         return this.update((s) => {
             if ((!s?.enabled && !s?.checkRequested) || s.active || s.nextAt > Date.now())
                 return;
-            s.active = { id: randomUUID(), startedAt: Date.now() };
+            s.active = {
+                id: randomUUID(),
+                startedAt: Date.now(),
+                phase: s.pendingDraft?.phase ??
+                    (s.pendingJudgement || s.candidateReport ? 'judgement' : 'discovery'),
+            };
             s.revision++;
             this.log('heartbeat', { id: s.active.id });
         });
@@ -182,6 +194,11 @@ export class InitiativeStore {
             if (s?.active?.id !== id)
                 return;
             s.active = null;
+            if (!error) {
+                delete s.candidateReport;
+                delete s.pendingJudgement;
+                delete s.pendingDraft;
+            }
             s.revision++;
             s.lastError = error ?? null;
             s.nextAt = Date.now() + s.intervalMs; // host cadence; never model-selected