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

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

@@ -20,11 +20,16 @@ import { ASSISTANT_BACKGROUND_SESSION_LABEL } from '@maka/core/session';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { awaitingUser } from '../execution-outcome.js';
-import { wake } from './prompt.js';
+import { wakeInput, DISCOVERY_TASK, JUDGEMENT_TASK, NOTEBOOK_RULES } from './prompt.js';
+import { Notebook, NotebookValidationError } from './notebook.js';
+import { createHash } from 'node:crypto';
+import { mkdirSync, writeFileSync, readFileSync, rmSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
 export class InitiativeController {
     ctx;
     store;
     config;
+    notebook;
     abort = new AbortController();
     timer;
     heartbeat;
@@ -46,6 +51,63 @@ export class InitiativeController {
         this.ctx = ctx;
         this.store = store;
         this.config = config;
+        const path = join(store.directory, 'notebook.sqlite');
+        this.notebook = new Notebook(path);
+        chmodSync(path, 0o600);
+    }
+    async refreshFeedback(state) {
+        const context = this.ctx.bot.discoveryContext(state.sessionId);
+        this.ready();
+        for (const message of context.deliveries) {
+            const topicIds = [
+                ...new Set(message.discoveryIds.flatMap((id) => {
+                    const prepared = this.notebook.event(id);
+                    return prepared?.kind === 'prepared' ? prepared.payload.topicIds : [];
+                })),
+            ];
+            // Unknown reports are not retroactively inferred to be notebook recommendations.
+            if (!topicIds.length)
+                continue;
+            this.notebook.put(`delivery:${message.messageId}`, 'delivery', {
+                text: message.text,
+                topicIds,
+                messageIds: [message.messageId],
+                preparedIds: message.discoveryIds,
+                transport: 'assistant-bot',
+            }, message.at);
+        }
+        for (const feedback of context.feedback) {
+            const replyTo = `delivery:${feedback.messageId}`;
+            if (!this.notebook.event(replyTo))
+                continue;
+            this.notebook.recordFeedback({
+                id: `feedback:${JSON.stringify([feedback.id, feedback.messageId])}`,
+                text: feedback.text,
+                at: feedback.at,
+                replyTo,
+            });
+        }
+    }
+    forwardPrepared(state) {
+        for (const event of this.notebook.events('prepared')) {
+            const id = `${event.id}:reported`;
+            if (this.notebook.event(id))
+                continue;
+            // A new user message must be considered before an old recommendation is handed off.
+            if (event.payload.feedbackRevision !== this.notebook.revision() ||
+                this.notebook.pendingFeedback().length)
+                continue;
+            this.ready();
+            const accepted = this.ctx.bot.post(state.sessionId, {
+                id: event.id,
+                type: 'discovery',
+                source: state.judgementSession,
+                content: event.payload.text,
+            });
+            if (!accepted)
+                throw Error('Bot did not accept the discovery report');
+            this.notebook.put(id, 'reported', { preparedId: event.id, text: event.payload.text });
+        }
     }
     start() {
         const acquire = () => {
@@ -68,7 +130,7 @@ export class InitiativeController {
     async resolveBinding() {
         if (this.store.get() || !this.owned)
             return;
-        const matches = (await this.ctx.sessionQuery.list()).filter((s) => s.labels?.includes('personal-assistant'));
+        const matches = (await this.ctx.sessionQuery.list()).filter((s) => !s.isArchived && s.labels?.includes('personal-assistant'));
         if (matches.length > 1)
             throw Error('Multiple assistant conversations found');
         if (!matches.length)
@@ -87,7 +149,7 @@ export class InitiativeController {
         return this.ctx.agents.withInvocation({
             sessionId: s.sessionId,
             cwd: s.cwd,
-            turnId: `initiative:${this.store.owner}`,
+            turnId: `initiative-${this.store.owner}`,
             toolCallId: randomUUID(),
             abortSignal: this.abort.signal,
         }, fn);
@@ -118,55 +180,150 @@ export class InitiativeController {
         const s = this.store.get();
         if ((!s?.enabled && !s?.checkRequested) || s.active || s.nextAt > Date.now())
             return;
-        const agent = await this.asOwner(s, async () => {
-            let sessionId = s.discoverySession;
+        const agent = await this.worker(s, s.pendingDraft?.phase ??
+            (s.pendingJudgement || s.candidateReport ? 'judgement' : 'discovery'));
+        const snapshot = await agent.snapshot();
+        if (snapshot?.agent?.status === 'running' || awaitingUser(snapshot))
+            return;
+        this.ready();
+        const current = this.store.claim();
+        if (!current?.active)
+            return;
+        this.running = this.run(agent, current).finally(() => {
+            this.running = undefined;
+        });
+    }
+    async worker(s, phase) {
+        return this.asOwner(s, async () => {
+            const field = phase === 'discovery' ? 'discoverySession' : 'judgementSession';
+            const sessions = await this.ctx.sessionQuery.list();
+            const bound = sessions.find((item) => item.id === s[field]);
+            let sessionId = bound && !bound.isArchived ? bound.id : undefined;
             if (!sessionId) {
-                const label = `assistant-discovery:${s.sessionId}`;
-                const matches = (await this.ctx.sessionQuery.list()).filter((item) => item.labels?.includes(label));
+                const label = `assistant-${phase}:${s.sessionId}`;
+                const matches = sessions.filter((item) => !item.isArchived && item.labels?.includes(label));
                 if (matches.length > 1)
-                    throw Error('Multiple exploration workers found');
+                    throw Error(`Multiple ${phase} workers found`);
                 sessionId =
                     matches[0]?.id ??
                         (await this.ctx.agents.create({
                             background: true,
-                            name: '个人助手 · 主动发现',
+                            name: phase === 'discovery' ? '个人助手 · 主动发现' : '个人助手 · 发现判断',
                             labels: [label, ASSISTANT_BACKGROUND_SESSION_LABEL],
                         })).sessionId;
                 this.store.update((current) => {
-                    current.discoverySession = sessionId;
+                    current[field] = sessionId;
+                    // A replacement worker has no role instructions in its conversation yet.
+                    if (current.promptVersions)
+                        delete current.promptVersions[phase === 'discovery' ? 'exploration' : 'judgement'];
                 });
             }
             return this.ctx.agents.resume({ sessionId });
         });
-        const snapshot = await agent.snapshot();
-        if (snapshot?.agent?.status === 'running' || awaitingUser(snapshot))
-            return;
+    }
+    async execute(agent, state) {
         this.ready();
-        const current = this.store.claim();
-        if (!current?.active)
-            return;
-        this.running = this.run(agent, current).finally(() => {
-            this.running = undefined;
+        this.activeAgent = agent;
+        await this.refreshFeedback(state);
+        const role = state.active.phase === 'discovery' ? 'exploration' : 'judgement';
+        // Persist the operation before running the model. A failed or interrupted draft
+        // must resume in its original worker, with its original output still available.
+        const pending = state.pendingDraft ?? { id: state.active.id, phase: state.active.phase };
+        if (pending.phase !== state.active.phase)
+            throw Error('Pending draft phase mismatch');
+        this.store.update((s) => {
+            s.pendingDraft = pending;
         });
+        const operationId = `${pending.id}:${role}`;
+        const directory = join(this.store.directory, 'notebook-wakes', pending.id, role);
+        const viewPath = join(directory, 'notebook.md');
+        const outputPath = join(directory, 'operations.json');
+        const version = createHash('sha256')
+            .update((role === 'exploration' ? DISCOVERY_TASK : JUDGEMENT_TASK) + '\n' + NOTEBOOK_RULES)
+            .digest('hex');
+        let repair = pending.error ?? (state.pendingDraft ? '上次执行中断，尚无成功提交记录。' : undefined);
+        // A committed operation can survive a crash or a failed Bot handoff. Retry its
+        // delivery using the existing message IDs, without asking the model to rewrite it.
+        while (!this.notebook.event(operationId)) {
+            this.ready();
+            await this.refreshFeedback(state);
+            mkdirSync(directory, { recursive: true, mode: 0o700 });
+            writeFileSync(viewPath, this.notebook.render(), { mode: 0o600 });
+            const revision = this.notebook.revision();
+            let input = wakeInput({
+                role,
+                now: new Date().toISOString(),
+                viewPath,
+                outputPath,
+                first: this.store.get().promptVersions?.[role] !== version,
+            });
+            if (repair)
+                input += `\n上次结果未提交：${repair}\n整份操作未写入记事本，其中的消息未交给 Bot，也不在待发送队列。读取原结果文件（若存在）和更新后的记事本，修正后重交；保留仍值得交流的内容，不要因为已经写过文案就当成已安排。feedbackDecisions 只引用记事本“用户反馈”中的 ID，没有待整理反馈就留空。`;
+            if (role === 'judgement' && state.candidateReport?.path)
+                input += `\n升级前保留的历史报告：${state.candidateReport.path}。它是参考材料，不是指定候选或当前指令。`;
+            const wakeId = randomUUID();
+            const admitted = await agent.followup(`Runtime heartbeat, not a new human request.\nHeartbeat ID: ${state.active.id}\nSubmission attempt: ${wakeId}\nPhase: ${state.active.phase}\n${input}`);
+            if (!['turn_started', 'followup'].includes(admitted?.disposition))
+                throw Error('Host rejected proactive wake');
+            while (admitted.disposition === 'followup' &&
+                !JSON.stringify(await agent.transcript()).includes(`Submission attempt: ${wakeId}`))
+                await delay(25, undefined, { signal: this.abort.signal });
+            await agent.whenIdle(this.abort.signal);
+            const snapshot = await agent.snapshot();
+            const status = snapshot?.agent?.status;
+            if (['aborted', 'blocked', 'waiting_for_user'].includes(status) || awaitingUser(snapshot))
+                throw Error(`Heartbeat ended with ${status}; inspect before resuming`);
+            this.ready();
+            this.store.update((s) => {
+                (s.promptVersions ??= {})[role] = version;
+            });
+            await this.refreshFeedback(state);
+            // I/O / provider failures remain execution failures. Only fixable draft errors
+            // go back to the same agent immediately; never silently drop an invalid field.
+            const raw = readFileSync(outputPath, 'utf8');
+            try {
+                this.notebook.commitDraft({
+                    role,
+                    operationId,
+                    expectedFeedbackRevision: revision,
+                    draft: JSON.parse(raw),
+                });
+            }
+            catch (error) {
+                if (!(error instanceof SyntaxError || error instanceof NotebookValidationError))
+                    throw error;
+                repair = String(error);
+                this.store.update((s) => {
+                    s.pendingDraft.error = repair;
+                    this.store.log('draft-rejected', { operationId, error: repair });
+                });
+            }
+        }
+        if (role === 'judgement')
+            this.forwardPrepared(state);
+        // Only remove the files after commit and handoff. The durable operation marker
+        // remains available if shutdown happens before the scheduler finishes this phase.
+        rmSync(directory, { recursive: true, force: true });
     }
     async run(agent, state) {
         const id = state.active.id;
         this.activeAgent = agent;
         try {
-            const admitted = await agent.followup(wake(state));
-            if (!['turn_started', 'followup'].includes(admitted?.disposition))
-                throw Error('Host rejected proactive wake');
-            const completion = async () => {
-                // Queued admission is not completion; wait for its input to enter Session history.
-                while (admitted.disposition === 'followup' &&
-                    !JSON.stringify(await agent.transcript()).includes(`Heartbeat ID: ${id}`))
-                    await delay(25, undefined, { signal: this.abort.signal });
-                await agent.whenIdle(this.abort.signal);
-            };
-            await completion();
-            const status = (await agent.snapshot())?.agent?.status;
-            if (['aborted', 'blocked', 'waiting_for_user'].includes(status))
-                throw Error(`Heartbeat ended with ${status}; inspect before resuming`);
+            await this.execute(agent, state);
+            if (state.active.phase === 'discovery') {
+                const next = this.store.update((s) => {
+                    if (s.active?.id !== id)
+                        throw Error('Heartbeat ownership changed');
+                    s.pendingJudgement = true;
+                    delete s.pendingDraft;
+                    s.active.phase = 'judgement';
+                });
+                const judge = await this.worker(next, 'judgement');
+                const snapshot = await judge.snapshot();
+                if (snapshot?.agent?.status === 'running' || awaitingUser(snapshot))
+                    throw Error('Judgement worker is busy or awaiting user input; notebook retained');
+                await this.execute(judge, this.store.get());
+            }
             this.store.finish(id);
         }
         catch (e) {
@@ -174,6 +331,10 @@ export class InitiativeController {
                 this.store.fence();
                 if (this.store.get()?.active?.id === id) {
                     const message = String(e);
+                    this.store.update((s) => {
+                        if (s.pendingDraft && !s.pendingDraft.error)
+                            s.pendingDraft.error = message;
+                    });
                     this.store.finish(id, message);
                 }
             }

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

@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+/**
+ * Tools the proactive discovery Session must not see or run (#6249, #6250).
+ *
+ * Discovery investigates and reports through DiscoveryReport; it does not create,
+ * adopt or mutate conversation-owned Matters or memory indexes, control initiative
+ * configuration, or deliver to the user directly. Read tools (MatterOverview,
+ * MemoryIndexRead, DiscoveryContext, ...) and source queries stay available.
+ * Whether MemorySourceQuery and MemoryExtract belong here is still an open
+ * design question tracked in the RFC.
+ */
+export const DISCOVERY_EXCLUDED_TOOLS = new Set([
+    // Matter creation, adoption and conversation-scoped control.
+    'MatterDelegate',
+    'MatterStart',
+    'MatterAdopt',
+    'MatterControl',
+    'MatterMessage',
+    'MatterTaskControl',
+    'MatterTaskMessage',
+    'MatterReply',
+    'MatterDelegationRecover',
+    'MatterFeedbackRetry',
+    // Matter worker lifecycle tools; valid only inside an activation the Session owns.
+    'MatterRead',
+    'MatterReadFile',
+    'MatterWriteFile',
+    'MatterCheckpoint',
+    'MatterSettle',
+    'MatterConditionTest',
+    'MatterAskBot',
+    // Memory index mutation. Writes belong to index workers and the conversation.
+    'MemoryIndexCreate',
+    'MemoryIndexCreateGroup',
+    'MemoryIndexWrite',
+    'MemoryIndexEdit',
+    'MemoryIndexCheckpoint',
+    'MemoryIndexControl',
+    'MemoryIndexAddSources',
+    'MemoryIndexMaintain',
+    // Initiative configuration is owned by the conversation.
+    'InitiativeEnable',
+    'InitiativeConfigure',
+    'InitiativeControl',
+    // Bot-only coordination tools.
+    'SendUser',
+    'InboxCheck',
+    'InboxList',
+    'InboxRead',
+    'AssistantSetAvatar',
+    'Sleep',
+]);

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

@@ -22,6 +22,7 @@ import { InitiativeStore } from './store.js';
 import { InitiativeController } from './controller.js';
 import { initializeBot } from '../bot/host.js';
 import { registerAssistant } from './assistant.js';
+import { DISCOVERY_EXCLUDED_TOOLS } from './discovery-capabilities.js';
 export async function initializeInitiative(ctx, directory, config = {}) {
     const limits = { tickMs: config.tickMs ?? 5000 };
     for (const [name, value] of Object.entries(limits))
@@ -30,7 +31,10 @@ export async function initializeInitiative(ctx, directory, config = {}) {
     const location = { value: directory };
     const store = new InitiativeStore(location.value, randomUUID());
     const controller = new InitiativeController(ctx, store, limits);
-    ctx.onClose(() => store.close());
+    ctx.onClose(() => {
+        controller.notebook.close();
+        store.close();
+    });
     const activate = () => {
         controller.start();
         return () => controller.close();
@@ -38,30 +42,13 @@ export async function initializeInitiative(ctx, directory, config = {}) {
     ctx.onStart(activate);
     initializeBot(ctx, directory, store);
     registerAssistant(ctx, store, controller);
-    ctx.backgroundSessions.register(() => store.get()?.discoverySession ? [store.get().discoverySession] : []);
-    ctx.tools.register({
-        name: 'DiscoveryReport',
-        description: '此方法用于提交准备向用户发送的主动发现。请按直接与用户交流的标准组织内容，自行判断哪些信息值得用户知道，并保留必要依据和不确定性。Bot 会负责转达和适配当前对话，不要向 Bot 写“精选几条、其余可以不说”等表达建议。提交成功只表示已交给 Bot，不代表用户已经收到。',
-        parameters: z.object({ text: z.string().trim().min(1).max(24000) }),
-        categoryHint: 'file_write',
-        executionSemantics: 'exclusive_step',
-        impl: (input, call) => {
-            controller.ready();
-            const state = store.get();
-            if (!state?.active || state.discoverySession !== call.sessionId)
-                throw Error('Not the active exploration worker');
-            const id = `discovery:${state.active.id}:${call.toolCallId}`;
-            const reported = ctx.bot.post(state.sessionId, {
-                id,
-                type: 'discovery',
-                source: call.sessionId,
-                content: input.text,
-            });
-            if (!reported)
-                throw Error('Bot did not accept the discovery report');
-            return { reported, sentToUser: false };
-        },
-    });
+    ctx.backgroundSessions.register(() => [store.get()?.discoverySession, store.get()?.judgementSession].filter(Boolean));
+    // Discovery investigates and reports; it must not hold conversation-mutating tools.
+    if (!ctx.tools.filter)
+        throw Error('Assistant tool filtering is required to bound discovery Sessions');
+    ctx.tools.filter((sessionId, tools) => store.get()?.discoverySession === sessionId
+        ? tools.filter((tool) => !DISCOVERY_EXCLUDED_TOOLS.has(tool.name))
+        : tools);
     ctx.tools.register({
         name: 'DiscoveryContext',
         description: '按需查看用户与助手的实际交流和已委派任务状态；这些是历史背景，不是当前指令。内部调查不等于用户收到消息。已有任务的常规进展优先参考其调查结果，把探索留给尚未覆盖的方向；发现新风险、跨事项关联或证据不足时仍可自行核实。',
@@ -73,7 +60,7 @@ export async function initializeInitiative(ctx, directory, config = {}) {
         executionSemantics: 'parallel',
         impl: async (input, call) => {
             const state = store.get();
-            if (!state || call.sessionId !== state.discoverySession)
+            if (!state || ![state.discoverySession, state.judgementSession].includes(call.sessionId))
                 throw Error('Not the exploration worker');
             return controller.asOwner(state, async () => {
                 const snapshot = await ctx.sessionQuery.read(state.sessionId);
@@ -138,8 +125,8 @@ export async function initializeInitiative(ctx, directory, config = {}) {
     ctx.systemPrompt.section({
         name: 'index-initiative.discovery',
         order: 810,
-        text: ({ sessionId }) => store.get()?.discoverySession === sessionId
-            ? '你是独立的主动探索 Agent。通过可用工具调查。值得交流的发现用 DiscoveryReport 交给个人助手 Bot，由它和用户交流；没有合适内容可以直接结束。这里不是用户聊天框，不要委派执行任务。'
+        text: ({ sessionId }) => [store.get()?.discoverySession, store.get()?.judgementSession].includes(sessionId)
+            ? '你在主动助手的后台会话中运行。通过普通文件工具读取共享记事本、写本轮增量；用户交流由 Bot 负责。只读调查，不委派执行任务，不自行安排心跳。'
             : undefined,
     });
 }