maka-agent 0.2.2-dev.101.20261026 → 0.2.2-dev.106.20261030

package/THIRD_PARTY_NOTICES.txt

@@ -6673,7 +6673,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ================================================================================
 
-Package: qs@6.16.0
+Package: qs@6.17.0
 Declared license: BSD-3-Clause
 Selected license: BSD-3-Clause
 Repository: https://github.com/ljharb/qs.git
@@ -7361,7 +7361,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ================================================================================
 
-Package: systeminformation@5.33.13
+Package: systeminformation@5.33.18
 Declared license: MIT
 Selected license: MIT
 Repository: git+https://github.com/sebhildebrandt/systeminformation.git

package/node_modules/@maka/core/dist/runtime-policy/connection-catalog-codec.js

@@ -446,6 +446,7 @@ export function decodeConnectionModel(value) {
         'description',
         'apiProtocol',
         'contextWindow',
+        'codexCompactionHash',
         'inputLimit',
         'maxOutputTokens',
         'knowledgeCutoff',
@@ -492,6 +493,11 @@ export function decodeConnectionModel(value) {
             : {
                 contextWindow: integerValue(item.contextWindow, 'model context window', 1, Number.MAX_SAFE_INTEGER),
             }),
+        ...(item.codexCompactionHash === undefined
+            ? {}
+            : {
+                codexCompactionHash: nonEmptyStringValue(item.codexCompactionHash, 'Codex compaction hash', 128),
+            }),
         ...(item.inputLimit === undefined
             ? {}
             : {

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -230,27 +230,41 @@ function mergeTextProviderOptions(current, next, textOffset) {
 function projectToolModePlan(plan, toolMode, execTool) {
     if (toolMode === 'direct')
         return plan;
+    const directTools = plan.providerTools.filter((tool) => tool.nesting === 'direct_only');
+    const directNames = new Set(directTools.map((tool) => tool.name));
+    const projectActive = (names) => [
+        execTool.name,
+        ...names.filter((name) => directNames.has(name)),
+    ];
+    const projectBaseActive = plan.projectActiveTools;
     return {
         ...plan,
         providerTools: [
             execTool,
+            ...directTools,
             ...plan.providerTools.filter((tool) => tool.name === INVALID_TOOL_NAME),
         ],
-        activeTools: [execTool.name],
-        ...(plan.projectActiveTools
-            ? { projectActiveTools: () => ({ activeTools: [execTool.name] }) }
+        activeTools: projectActive(plan.activeTools),
+        ...(projectBaseActive
+            ? {
+                projectActiveTools: (options) => ({
+                    activeTools: projectActive(projectBaseActive(options).activeTools),
+                }),
+            }
             : {}),
-        currentRepairToolNames: () => [execTool.name],
+        currentRepairToolNames: () => projectActive(plan.currentRepairToolNames()),
         diagnostics: () => undefined,
     };
 }
-function renderCodeModeCatalogPrompt(nested) {
+function renderCodeModeCatalogPrompt(nested, directNames) {
     // The aggregate catalog can exceed the evidence codec's bound for one tool
     // description. Keep exec's schema fixed; requestSystemPrompt and its hash
     // carry this step's exact, refreshable nested surface instead.
     const catalog = requestCompositionToolSchemas([...nested.values()], [...nested.keys()]);
     return [
-        'Code Mode: exec is the only callable tool. Call the following tools from inside exec.',
+        directNames.length
+            ? `Code Mode: call the tools in the following catalog from inside exec. Call these control tools directly, never from exec: ${directNames.join(', ')}.`
+            : 'Code Mode: exec is the only callable tool. Call the following tools from inside exec.',
         'After tool_search, return its result and use the refreshed catalog in the next exec call.',
         JSON.stringify(catalog),
     ].join('\n');
@@ -1196,7 +1210,7 @@ export class AiSdkTurn {
                     const codeModeCatalogPrompt = toolMode === 'code_mode'
                         ? renderCodeModeCatalogPrompt(toolRuntime.hasSandboxBoundaryDenial()
                             ? new Map([...nestedTools].filter(([name]) => name !== REQUEST_SANDBOX_BOUNDARY_TOOL_NAME))
-                            : nestedTools)
+                            : nestedTools, boundaryAwareToolNames(plan.currentRepairToolNames()).filter((name) => name !== codeModeExecTool.name))
                         : undefined;
                     const resolveDispatch = (active) => {
                         const activeTools = finalChildSummaryStep || sandboxBoundaryFinalizationStep

package/node_modules/@maka/runtime/dist/history-compact-checkpoint.js

@@ -204,13 +204,36 @@ export function isProviderHistoryCompactCheckpoint(checkpoint) {
 export function isTextHistoryCompactCheckpoint(checkpoint) {
     return checkpoint.version === 2;
 }
+/** Bound the age of provider compatibility claims, including long-lived backends. */
+export const CODEX_COMPACTION_METADATA_MAX_AGE_MS = 5 * 60 * 1000;
+export function freshCodexCompactionHash(connection, modelId, now = Date.now()) {
+    const fetchedAt = connection.codexCompactionMetadataFetchedAt;
+    if (connection.providerType !== 'openai-codex' ||
+        fetchedAt === undefined ||
+        !Number.isSafeInteger(fetchedAt) ||
+        fetchedAt < 0 ||
+        !Number.isFinite(now) ||
+        fetchedAt > now ||
+        now - fetchedAt >= CODEX_COMPACTION_METADATA_MAX_AGE_MS)
+        return undefined;
+    return connection.models?.find((model) => model.id === modelId)?.codexCompactionHash;
+}
 export function canReplayHistoryCompactCheckpointForModel(checkpoint, connection, connectionId, modelId) {
     if (!isProviderHistoryCompactCheckpoint(checkpoint))
         return true;
-    return (connection.providerType === 'openai-codex' &&
-        connectionId !== undefined &&
-        checkpoint.providerState.connectionId === connectionId &&
-        checkpoint.providerState.modelId === modelId);
+    const state = checkpoint.providerState;
+    if (connection.providerType !== 'openai-codex' ||
+        connectionId === undefined ||
+        state.connectionId !== connectionId)
+        return false;
+    const targetHash = freshCodexCompactionHash(connection, modelId);
+    // Legacy checkpoints remain usable on their original model. Never infer a
+    // legacy checkpoint's original hash from today's mutable model catalog.
+    if (state.modelId === modelId && (!state.codexCompactionHash || !targetHash))
+        return true;
+    return (nonEmpty(state.codexCompactionHash) &&
+        nonEmpty(targetHash) &&
+        state.codexCompactionHash === targetHash);
 }
 /** Whether this model's configured compactor can roll forward from this checkpoint value. */
 export function canContinueHistoryCompactCheckpointForModel(checkpoint, connection, connectionId, modelId) {
@@ -582,6 +605,11 @@ function validHistoryCompactProviderState(value) {
     return (state.kind === 'openai_codex_remote_v2' &&
         nonEmpty(state.connectionId) &&
         nonEmpty(state.modelId) &&
+        (state.codexCompactionHash === undefined ||
+            (nonEmpty(state.codexCompactionHash) &&
+                state.codexCompactionHash.length <= 128 &&
+                state.codexCompactionHash.trim() === state.codexCompactionHash &&
+                !/[\u0000-\u001f\u007f]/.test(state.codexCompactionHash))) &&
         nonEmpty(state.itemId) &&
         nonEmpty(state.encryptedContent));
 }

package/node_modules/@maka/runtime/dist/model-fetcher.js

@@ -300,6 +300,13 @@ async function fetchOpenAiCodexModels(baseUrl, accessToken, fetchFn) {
         const contextWindow = providerTokenLimit(model.context_window);
         if (contextWindow !== undefined)
             entry.contextWindow = contextWindow;
+        if (typeof model.comp_hash === 'string' &&
+            model.comp_hash.length > 0 &&
+            model.comp_hash.length <= 128 &&
+            model.comp_hash.trim() === model.comp_hash &&
+            !/[\u0000-\u001f\u007f]/.test(model.comp_hash)) {
+            entry.codexCompactionHash = model.comp_hash;
+        }
         return entry;
     });
 }

package/node_modules/@maka/runtime/dist/openai-codex-history-compactor.js

@@ -18,7 +18,7 @@
  */
 import { HistoryCompactSummarizerError } from './history-compact-error.js';
 import { nonEmpty } from './context-budget-helpers.js';
-import { canContinueHistoryCompactCheckpointForModel, historyCompactCheckpointToModelMessage, isProviderHistoryCompactCheckpoint, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
+import { canContinueHistoryCompactCheckpointForModel, freshCodexCompactionHash, historyCompactCheckpointToModelMessage, isProviderHistoryCompactCheckpoint, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { admitProviderReasoningReplayItems, buildRuntimeEventModelReplayPlan, buildRuntimeEventReplayTimeline, compatibleProviderReasoningReplayEventIds, } from './model-history.js';
 import { withProviderStreamTracking } from './provider-request-telemetry.js';
 import { effectiveReplayToolResultOutput } from './durable-tool-result-projection.js';
@@ -40,7 +40,11 @@ export function buildOpenAiCodexHistoryCompactor(options) {
         try {
             const previous = input.previousCheckpoint;
             const canContinuePrevious = previous &&
-                canContinueHistoryCompactCheckpointForModel(previous, { providerType: 'openai-codex' }, options.connectionId, options.modelId);
+                canContinueHistoryCompactCheckpointForModel(previous, {
+                    providerType: 'openai-codex',
+                    models: options.models,
+                    codexCompactionMetadataFetchedAt: options.codexCompactionMetadataFetchedAt,
+                }, options.connectionId, options.modelId);
             const events = canContinuePrevious
                 ? (input.newlyFoldedRuntimeEvents ?? [])
                 : input.source.foldedRuntimeEvents;
@@ -92,7 +96,11 @@ export function buildOpenAiCodexHistoryCompactor(options) {
             }
             if (streamError)
                 throw streamError;
-            const state = extractOpenAiCodexCompactionState(content, options.connectionId, options.modelId);
+            const state = extractOpenAiCodexCompactionState(content, options.connectionId, options.modelId, freshCodexCompactionHash({
+                providerType: 'openai-codex',
+                models: options.models,
+                codexCompactionMetadataFetchedAt: options.codexCompactionMetadataFetchedAt,
+            }, options.modelId));
             if (!state)
                 throw new HistoryCompactSummarizerError('invalid_provider_state');
             return state;
@@ -256,7 +264,7 @@ function openAiCodexCompactionMessages(events, providerReasoningReplayEventIds)
     }
     return messages;
 }
-export function extractOpenAiCodexCompactionState(content, connectionId, modelId) {
+export function extractOpenAiCodexCompactionState(content, connectionId, modelId, codexCompactionHash) {
     const parts = (content ?? []).filter(isOpenAiCompactionPart);
     if (parts.length !== 1)
         return undefined;
@@ -267,6 +275,7 @@ export function extractOpenAiCodexCompactionState(content, connectionId, modelId
         kind: 'openai_codex_remote_v2',
         connectionId,
         modelId,
+        ...(codexCompactionHash ? { codexCompactionHash } : {}),
         itemId: metadata.itemId,
         encryptedContent: metadata.encryptedContent,
     };

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

@@ -92,6 +92,9 @@ export function registerAssistant(ctx, store, controller) {
             },
             ...(includeMemory ? { memory: memoryState } : {}),
             tasks: taskState,
+            // What background discovery and Matter activations cost and whether they reported
+            // (#6309). Observability only: nothing in the scheduler reads it.
+            cost: ctx.runCost?.summary() ?? null,
             hostRequired: true,
         };
     };

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

@@ -315,9 +315,23 @@ export class InitiativeController {
     }
     async run(agent, state) {
         const id = state.active.id;
+        const startedAt = state.active.startedAt ?? Date.now();
+        // Each Session the heartbeat drives and the window it was driven in, so the
+        // run's cost can be read back from the Usage ledger afterwards (#6309).
+        const segments = [];
+        const measured = async (worker, work) => {
+            const from = Date.now();
+            try {
+                await work();
+            }
+            finally {
+                segments.push({ sessionId: worker.sessionId, from, to: Date.now() });
+            }
+        };
+        let outcome = 'failed';
         this.activeAgent = agent;
         try {
-            await this.execute(agent, state);
+            await measured(agent, () => this.execute(agent, state));
             if (state.active.phase === 'discovery') {
                 const next = this.store.update((s) => {
                     if (s.active?.id !== id)
@@ -330,8 +344,10 @@ export class InitiativeController {
                 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());
+                await measured(judge, () => this.execute(judge, this.store.get()));
             }
+            // The signal the run's `lastRun` outcome is derived from: the Bot accepted a report.
+            outcome = this.store.get()?.active?.reported ? 'reported' : 'no_report';
             this.store.finish(id);
         }
         catch (e) {
@@ -352,6 +368,15 @@ export class InitiativeController {
         }
         finally {
             this.activeAgent = undefined;
+            // Observation only: the ledger swallows its own failures and nothing reads it back.
+            await this.ctx.runCost?.record({
+                kind: 'discovery',
+                runId: id,
+                startedAt,
+                endedAt: Date.now(),
+                outcome,
+                segments,
+            });
         }
     }
     async enable(input, call) {

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

@@ -110,21 +110,44 @@ export class Notebook {
         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) {
+            for (const [ruleIndex, rule] of e.payload.rules.entries()) {
                 if (!rule.topicIds.includes(topicId) && !overlaps(rule.tags, topic.tags))
                     continue;
-                current = { ...rule, feedbackId: e.payload.feedbackId };
+                current = { ...rule, feedbackId: e.payload.feedbackId, ruleIndex };
             }
+        if (current.feedbackId && ['closed', 'deferred'].includes(current.status)) {
+            const governing = this.event(current.feedbackId).seq;
+            // A reopening answers one specific rule. Topics gain tags over time, so the
+            // rule that governs a topic can change with no new feedback event: a later
+            // rule may start to match. Apply only a reopening the model judged against
+            // the rule that governs now; a different rule was never judged.
+            const reopen = this.events('reopen')
+                .filter((e) => e.payload.topicId === topicId &&
+                e.seq > governing &&
+                e.payload.feedbackId === current.feedbackId &&
+                e.payload.ruleIndex === current.ruleIndex)
+                .at(-1);
+            if (reopen)
+                current = {
+                    status: 'open',
+                    reason: reopen.payload.reason,
+                    feedbackId: current.feedbackId,
+                    ruleIndex: current.ruleIndex,
+                    reopenedByChange: true,
+                };
+        }
         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));
+        const withheld = this.events('withheld').filter((e) => e.payload.topicId === topicId);
         // Display 'sent' without destroying the user's open/deferred/closed policy.
         return {
             ...current,
             displayStatus: current.status === 'open' && receipts.length ? 'sent' : current.status,
             receipts,
+            withheld,
         };
     }
     recordFeedback({ id, text, at = this.clock(), replyTo = null, }) {
@@ -168,6 +191,42 @@ export class Notebook {
         }
         return this.put(id, 'feedback-resolution', resolution);
     }
+    /**
+     * The judgement looked into a topic and chose not to tell the user. This is
+     * neither "investigated" (notes) nor "told" (delivery receipts), and it is not
+     * a ban: a later message about the topic is still allowed.
+     */
+    recordWithheld(entry, id) {
+        requireThat(entry &&
+            Object.keys(entry).every((k) => ['topicId', 'reason'].includes(k)) &&
+            nonempty(entry.topicId) &&
+            nonempty(entry.reason), 'Withheld needs a topic and a reason');
+        requireThat(this.topics().has(entry.topicId), 'Unknown withheld topic');
+        return this.put(id, 'withheld', entry);
+    }
+    /**
+     * A closed or deferred topic becomes open again because its underlying
+     * information changed, not because the user said so. The change must be in the
+     * notebook: a note on this topic recorded after the user feedback that governs
+     * it. The user's own later feedback still overrides this.
+     */
+    reopenTopic(entry, id) {
+        requireThat(entry &&
+            Object.keys(entry).every((k) => ['topicId', 'reason'].includes(k)) &&
+            nonempty(entry.topicId) &&
+            nonempty(entry.reason), 'Reopening needs a topic and a reason');
+        requireThat(this.topics().has(entry.topicId), 'Unknown reopened topic');
+        const current = this.state(entry.topicId);
+        requireThat(current.feedbackId && ['closed', 'deferred'].includes(current.status), 'Only a topic the user closed or deferred can be reopened');
+        const governing = this.event(current.feedbackId).seq;
+        requireThat(this.events('note').some((e) => e.payload.topicId === entry.topicId && e.seq > governing), 'Reopening needs a note on this topic recorded after the user feedback');
+        // Bind the reopening to the rule it was validated against (see state()).
+        return this.put(id, 'reopen', {
+            ...entry,
+            feedbackId: current.feedbackId,
+            ruleIndex: current.ruleIndex,
+        });
+    }
     commitDraft({ role, operationId, expectedFeedbackRevision, draft, }) {
         requireThat(['exploration', 'judgement'].includes(role), 'Unknown role');
         const digest = fingerprint({ role, expectedFeedbackRevision, draft });
@@ -179,14 +238,17 @@ export class Notebook {
             }
             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');
+                Object.keys(draft).every((k) => ['notes', 'feedbackDecisions', 'messages', 'withheld', 'reopened'].includes(k)), 'Unsupported draft field');
+            const { notes = [], feedbackDecisions = [], messages = [], withheld = [], reopened = [], } = draft;
+            requireThat([notes, feedbackDecisions, messages, withheld, reopened].every(Array.isArray), 'Draft operations must be arrays');
+            requireThat(role === 'judgement' ||
+                (!feedbackDecisions.length && !messages.length && !withheld.length && !reopened.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');
+            withheld.forEach((w, i) => this.recordWithheld(w, `${operationId}:withheld:${i}`));
+            reopened.forEach((r, i) => this.reopenTopic(r, `${operationId}:reopened:${i}`));
             const preparedIds = [];
             messages.forEach((m, i) => {
                 requireThat(Object.keys(m).every((k) => ['text', 'topicIds'].includes(k)) &&
@@ -204,6 +266,8 @@ export class Notebook {
                 preparedIds,
                 notesAdded: notes.length,
                 feedbackProcessed: feedbackDecisions.length,
+                withheldRecorded: withheld.length,
+                topicsReopened: reopened.length,
             };
             this.put(operationId, 'draft', { digest, result });
             return result;
@@ -270,13 +334,15 @@ export class Notebook {
                 deferred: '暂缓',
                 closed: '关闭',
             };
-            lines.push('', `## ${topic.title}〔${topic.id}〕`, `状态：${labels[s.displayStatus]}${s.reason ? '；原因：' + s.reason : ''}${s.feedbackId ? '；依据：' + s.feedbackId : ''}`, `方向：${topic.tags.join('、') || '未分类'}`);
+            lines.push('', `## ${topic.title}〔${topic.id}〕`, `状态：${labels[s.displayStatus]}${s.reopenedByChange ? '（因信息出现重大变化，经判断重新开放）' : ''}${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}`);
+            for (const w of s.withheld)
+                lines.push(`- 已调查但未告知用户 ${w.at}〔${w.id}〕：${w.payload.reason}`);
         }
         const quickDeliveries = this.events('delivery').filter((e) => e.payload.origin === 'quick-discovery' && !e.payload.topicIds.length);
         if (quickDeliveries.length) {

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

@@ -46,8 +46,8 @@ 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，否则记理解和有价值的信息即可。关闭方向可能涉及多个主题，方向标签可同时作用于以后相关主题。'}
+{"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":["涉及主题"]}],"withheld":[{"topicId":"已调查但决定不告知用户的主题ID","reason":"不告知的原因"}],"reopened":[{"topicId":"用户已关闭或暂缓的主题ID","reason":"信息出现了什么重大变化"}]}。
+occurredAt可写已知的发生时间或范围，不知道就null。无需填满各数组；输出只包含本次增量，不复制整本笔记。主题和方向标签可按内容新增，相关用户反馈仍需考虑。${role === 'exploration' ? '只填写notes，其余数组留空。' : '没有待整理反馈时feedbackDecisions留空；只有用户明确表达状态变化才写rules，否则记理解和有价值的信息即可。关闭方向可能涉及多个主题，方向标签可同时作用于以后相关主题。调查过某主题但决定不告知时写withheld，与已告知分开记录；只有当用户已关闭或暂缓的主题出现重大变化（先把变化按记事本规则追加为该主题的新笔记）时才写reopened，没有重大变化就保持用户的决定。'}
 提交与送达以当前记事本记录为准，写过结果文件不代表已提交或已发送。最终回复结果文件路径。`;
     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/quick.js

@@ -350,9 +350,14 @@ export class QuickDiscoveryController {
     }
     async run(agent, state) {
         const active = state.active;
+        // Observation only (#6309): the model window of this attempt, when it ran one.
+        const startedAt = Date.now();
+        let modelFrom;
+        let outcome = 'failed';
         try {
             this.forward();
             if (!active.executionCompleted) {
+                modelFrom = Date.now();
                 this.parent.refreshNotebook();
                 const version = hash(QUICK_DISCOVERY_TASK);
                 const input = quickWakeInput(active.from, active.to, this.state().promptVersion !== version);
@@ -381,6 +386,7 @@ export class QuickDiscoveryController {
                 });
             }
             this.forward();
+            outcome = this.state()?.active?.reports?.length ? 'reported' : 'no_report';
             this.store.update((s) => {
                 if (s.active?.id !== active.id)
                     throw Error('Quick wake ownership changed');
@@ -410,6 +416,16 @@ export class QuickDiscoveryController {
         }
         finally {
             this.agent = undefined;
+            // A retry that only redelivers an earlier report ran no model: not a run.
+            if (modelFrom !== undefined)
+                await this.ctx.runCost?.record({
+                    kind: 'quick_discovery',
+                    runId: active.id,
+                    startedAt,
+                    endedAt: Date.now(),
+                    outcome,
+                    segments: [{ sessionId: agent.sessionId, from: modelFrom, to: Date.now() }],
+                });
         }
     }
     async close() {

package/node_modules/@maka/runtime-host/dist/assistant/proactive-matters/controller.js

@@ -141,11 +141,16 @@ export class MatterController {
         const activationId = m.activation.id;
         let queued = false;
         let failureKind;
+        // Observation only (#6309): undefined means no model execution was admitted.
+        const startedAt = m.activation.startedAt;
+        let outcome = 'failed';
+        let retried = false;
         try {
             if (!alreadyStarted) {
                 const result = await agent.followup(buildMatterPrompt(this.store.workspace(m.id, activationId)));
                 if (result.disposition === 'blocked') {
                     this.store.deferAdmission(m.id, activationId, 'Host 暂未接收唤醒，将自动重试。');
+                    outcome = undefined;
                     return;
                 }
                 if (result.disposition === 'turn_started') {
@@ -180,6 +185,8 @@ export class MatterController {
                             failureKind = failure?.kind;
                             if (failure?.retryable) {
                                 this.store.retryExecution(m.id, activationId, failure);
+                                outcome = 'retried';
+                                retried = true;
                                 return;
                             }
                             throw Error(failure?.message ??
@@ -195,6 +202,11 @@ export class MatterController {
             await completion();
             if (isPendingActivationTurnId(this.store.get(m.id).matter.activation?.turnId))
                 throw new Error('Queued wake ended without claiming its activation; inspect conversation before resuming');
+            const live = this.store.get(m.id).matter.activation;
+            // A retry already decided the outcome: it cleared the activation on purpose,
+            // so do not read that as the user interrupting the run.
+            if (!retried)
+                outcome = live?.id !== activationId ? 'interrupted' : live.settled ? 'completed' : 'failed';
             this.store.finish(m.id, activationId);
         }
         catch (e) {
@@ -204,6 +216,7 @@ export class MatterController {
                 isPendingActivationTurnId(live.activation.turnId) &&
                 /Runtime Host is not ready for Plugin Agent messages/.test(String(e))) {
                 this.store.deferAdmission(m.id, activationId, String(e));
+                outcome = undefined;
                 return;
             }
             if (live.activation?.id === activationId) {
@@ -212,6 +225,19 @@ export class MatterController {
                 await agent.cancel().catch(() => { });
             }
         }
+        finally {
+            // The ledger swallows its own failures and nothing reads it back.
+            if (outcome)
+                await this.ctx.runCost?.record({
+                    kind: 'matter_activation',
+                    runId: activationId,
+                    matterId: m.id,
+                    startedAt,
+                    endedAt: Date.now(),
+                    outcome,
+                    segments: [{ sessionId: m.sessionId, from: startedAt, to: Date.now() }],
+                });
+        }
     }
     async enroll(input, call) {
         this.assertReady();