maka-agent 0.2.0-dev.24.20260907 → 0.2.0-dev.26.20260909

package/node_modules/@maka/runtime-host/dist/server/daily-review-coordinator.js

@@ -41,11 +41,15 @@ export class HostDailyReviewCoordinator {
     #setInterval;
     #clearInterval;
     #inFlight = new Map();
-    #abortControllers = new Set();
+    #shutdown = new AbortController();
     #prepared = false;
     #started = false;
     #schedulerEnabled = false;
-    #draining = false;
+    #handoffHeld = false;
+    #schedulerTask;
+    get #draining() {
+        return this.#shutdown.signal.aborted;
+    }
     #timer;
     #residency;
     #closeTask;
@@ -92,16 +96,50 @@ export class HostDailyReviewCoordinator {
     beginDrain() {
         if (this.#draining)
             return;
-        this.#draining = true;
+        this.#shutdown.abort(new DOMException('Runtime Host is draining', 'AbortError'));
         this.#stopScheduler();
-        for (const controller of this.#abortControllers) {
-            controller.abort(new DOMException('Runtime Host is draining', 'AbortError'));
-        }
+    }
+    holdForHandoff() {
+        if (this.#draining || this.#handoffHeld)
+            return undefined;
+        this.#handoffHeld = true;
+        this.#stopTimer();
+        let released = false;
+        return {
+            settled: async () => {
+                // Include scheduler reads as well as generation: a tick may still be
+                // checking configuration or an archive when the hold is acquired.
+                while (this.#schedulerTask || this.#inFlight.size > 0) {
+                    await Promise.allSettled([
+                        this.#schedulerTask,
+                        ...[...this.#inFlight.values()].map((entry) => entry.promise),
+                    ]);
+                }
+            },
+            residencies: () => {
+                if (released || this.#draining || this.#schedulerTask || this.#inFlight.size > 0)
+                    return undefined;
+                return this.#residency ? [this.#residency] : [];
+            },
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.#handoffHeld = false;
+                if (this.#draining)
+                    return;
+                this.#reconcileScheduler(this.#schedulerEnabled);
+                void this.#tickScheduler().catch((error) => this.#handleSchedulerError(error));
+            },
+        };
     }
     close() {
         this.#closeTask ??= (async () => {
             this.beginDrain();
-            await Promise.allSettled([...this.#inFlight.values()].map((entry) => entry.promise));
+            await Promise.allSettled([
+                this.#schedulerTask,
+                ...[...this.#inFlight.values()].map((entry) => entry.promise),
+            ]);
         })();
         return this.#closeTask;
     }
@@ -238,6 +276,10 @@ export class HostDailyReviewCoordinator {
             await inFlight.promise.catch(() => undefined);
             return this.#run(input);
         }
+        // Keep actual generation distinct from the idle scheduler hold. Besides
+        // protecting a run when scheduling is disabled, its release tells handoff
+        // observers that work finished after a bounded safe-pause attempt timed out.
+        const residency = this.#acquireResidency();
         const pending = this.#generateArchive(archiveId, day, now, modelKeyOverride, input);
         const entry = {
             modelKeyOverride,
@@ -252,14 +294,18 @@ export class HostDailyReviewCoordinator {
         finally {
             if (this.#inFlight.get(archiveId) === entry)
                 this.#inFlight.delete(archiveId);
+            residency.release();
         }
     }
     async #generateArchive(archiveId, day, now, modelKeyOverride, input) {
+        const signal = this.#shutdown.signal;
+        signal.throwIfAborted();
         const summary = await this.#buildSummary(day, now);
         const existing = await this.#store.getArchive(archiveId);
         if (existing && !input.replaceExisting)
             return existing;
         const config = await this.#store.readConfig();
+        signal.throwIfAborted();
         const modelKey = modelKeyOverride || config.config.modelKey;
         const base = {
             id: archiveId,
@@ -278,56 +324,50 @@ export class HostDailyReviewCoordinator {
                 errorMessage: 'No local activity data was available for this review.',
             });
         }
-        const controller = new AbortController();
-        this.#abortControllers.add(controller);
-        try {
-            const result = await this.#model.generate({
-                modelKey,
-                prompt: buildModelPrompt(summary, input.range),
-                abortSignal: controller.signal,
-            });
-            if (!result.ok) {
-                if (result.errorClass === 'aborted') {
-                    throw (controller.signal.reason ?? new DOMException('Daily Review was aborted', 'AbortError'));
-                }
-                if (result.errorClass === 'persistence') {
-                    this.#requestDrain();
-                    throw new Error('Daily Review model accounting failed');
-                }
-                return this.#publish({
-                    ...base,
-                    status: result.errorClass === 'configuration' ? 'no_model' : 'failed',
-                    sections: buildRuleBasedSections(summary, input.range),
-                    errorMessage: result.errorClass === 'configuration'
-                        ? 'No executable analysis model is configured.'
-                        : result.errorClass === 'timeout'
-                            ? 'The analysis model timed out while generating this review.'
-                            : 'The analysis model failed to generate this review.',
-                });
-            }
-            let sections;
-            try {
-                sections = parseSections(result.text);
+        const result = await this.#model.generate({
+            modelKey,
+            prompt: buildModelPrompt(summary, input.range),
+            abortSignal: signal,
+        });
+        signal.throwIfAborted();
+        if (!result.ok) {
+            if (result.errorClass === 'aborted') {
+                throw signal.reason ?? new DOMException('Daily Review was aborted', 'AbortError');
             }
-            catch {
-                return this.#publish({
-                    ...base,
-                    modelKey: result.modelKey,
-                    status: 'failed',
-                    sections: buildRuleBasedSections(summary, input.range),
-                    errorMessage: 'The analysis model returned an invalid review.',
-                });
+            if (result.errorClass === 'persistence') {
+                this.#requestDrain();
+                throw new Error('Daily Review model accounting failed');
             }
             return this.#publish({
                 ...base,
-                modelKey: result.modelKey,
-                status: 'ok',
-                sections,
+                status: result.errorClass === 'configuration' ? 'no_model' : 'failed',
+                sections: buildRuleBasedSections(summary, input.range),
+                errorMessage: result.errorClass === 'configuration'
+                    ? 'No executable analysis model is configured.'
+                    : result.errorClass === 'timeout'
+                        ? 'The analysis model timed out while generating this review.'
+                        : 'The analysis model failed to generate this review.',
             });
         }
-        finally {
-            this.#abortControllers.delete(controller);
+        let sections;
+        try {
+            sections = parseSections(result.text);
         }
+        catch {
+            return this.#publish({
+                ...base,
+                modelKey: result.modelKey,
+                status: 'failed',
+                sections: buildRuleBasedSections(summary, input.range),
+                errorMessage: 'The analysis model returned an invalid review.',
+            });
+        }
+        return this.#publish({
+            ...base,
+            modelKey: result.modelKey,
+            status: 'ok',
+            sections,
+        });
     }
     async #publish(archive) {
         const encodedBytes = Buffer.byteLength(JSON.stringify(archive), 'utf8');
@@ -337,27 +377,41 @@ export class HostDailyReviewCoordinator {
         return this.#store.publishArchive(archive, ARCHIVE_LIMIT);
     }
     #reconcileScheduler(enabled) {
+        this.#schedulerEnabled = enabled;
         if (!enabled || this.#draining) {
             this.#stopScheduler();
             return;
         }
-        this.#residency ??= this.#acquireResidency();
+        if (this.#handoffHeld)
+            return;
+        this.#residency ??= this.#acquireResidency('idle');
         this.#timer ??= this.#setInterval(() => {
             void this.#tickScheduler().catch((error) => this.#handleSchedulerError(error));
         }, SCHEDULER_INTERVAL_MS);
     }
     #stopScheduler() {
+        this.#stopTimer();
+        this.#residency?.release();
+        this.#residency = undefined;
+    }
+    #stopTimer() {
         if (this.#timer !== undefined) {
             this.#clearInterval(this.#timer);
             this.#timer = undefined;
         }
-        this.#residency?.release();
-        this.#residency = undefined;
     }
-    async #tickScheduler() {
-        if (!this.#prepared || this.#draining)
-            return;
+    #tickScheduler() {
+        if (!this.#prepared || this.#draining || this.#handoffHeld)
+            return Promise.resolve();
+        this.#schedulerTask ??= this.#runScheduler().finally(() => {
+            this.#schedulerTask = undefined;
+        });
+        return this.#schedulerTask;
+    }
+    async #runScheduler() {
         const { config } = await this.#store.readConfig();
+        if (this.#draining || this.#handoffHeld)
+            return;
         this.#reconcileScheduler(config.enabled);
         const now = this.#now();
         if (!config.enabled || !scheduledTimeHasPassed(now, config.executeTime))
@@ -368,6 +422,8 @@ export class HostDailyReviewCoordinator {
         const archiveId = dailyReviewArchiveId(day, 1);
         if (await this.#store.getArchive(archiveId))
             return;
+        if (this.#draining || this.#handoffHeld)
+            return;
         await this.#run({
             range: 1,
             offsetDays: -1,

package/node_modules/@maka/runtime-host/dist/server/execution-artifacts.js

@@ -22,7 +22,7 @@ import { isAbsolute, resolve } from 'node:path';
 import { MAX_ATTACHMENT_BYTES } from '@maka/core/attachments';
 import { createToolResultArchiveCapability, } from '@maka/runtime/tool-result-archive-capability';
 import { isPathInside } from '@maka/runtime/path-containment';
-import { stableToolResultArchiveArtifactId } from '@maka/runtime/tool-result-archive';
+import { createLedgerArchivePreparer, createLedgerArchiveResourceReader, createLedgerToolResultArchiveReader, } from '@maka/runtime/ledger-tool-result-archive-reader';
 export function createHostExecutionArtifactServices(input) {
     const runWrite = async (operation) => {
         try {
@@ -58,6 +58,30 @@ export function createHostExecutionArtifactServices(input) {
             });
         }
     };
+    const prepareLedger = input.archiveEvidence
+        ? createLedgerArchivePreparer(input.archiveEvidence)
+        : undefined;
+    const readLedger = input.archiveEvidence
+        ? createLedgerToolResultArchiveReader(input.archiveEvidence)
+        : undefined;
+    const readLedgerResource = input.archiveEvidence
+        ? createLedgerArchiveResourceReader(input.archiveEvidence)
+        : undefined;
+    const prepareLedgerForCommit = async (event) => {
+        const accepted = { ...event };
+        if (!prepareLedger || !(await prepareLedger(accepted)))
+            return;
+        return {
+            ledger: true,
+            commitTransition: (transition, persist) => input.sessionAdmission.runOrJoin(accepted.sessionId, async () => {
+                if ((await input.sessions.probeSessionRemoval(accepted.sessionId)).kind !== 'present' ||
+                    !(await prepareLedger(accepted)))
+                    return false;
+                await persist(transition);
+                return true;
+            }),
+        };
+    };
     const services = {
         recordToolArtifacts,
         publishChildWorkspacePatch: async ({ sessionId, turnId, binding, patch }) => {
@@ -77,37 +101,13 @@ export function createHostExecutionArtifactServices(input) {
             return artifact;
         },
         toolResultArchive: createToolResultArchiveCapability({
-            archiveToolResult: (event) => runWrite(async () => {
-                const artifactId = stableToolResultArchiveArtifactId(event);
-                const existing = await input.artifacts.getInSession(event.sessionId, artifactId);
-                if (existing.record) {
-                    const read = await readArchive(input.artifacts, {
-                        artifactId,
-                        sessionId: event.sessionId,
-                        bodySha256: event.bodySha256,
-                        originalBytes: event.originalBytes,
-                        maxBytes: event.originalBytes,
-                    });
-                    if (!read.ok) {
-                        throw new Error(`Tool result archive identity conflict: ${read.reason}`);
-                    }
-                    return { artifactId };
-                }
-                const artifact = await input.artifacts.create({
-                    id: artifactId,
-                    sessionId: event.sessionId,
-                    turnId: event.turnId,
-                    name: `archived-${event.toolName}-${event.runtimeEventId}.json`,
-                    kind: 'file',
-                    content: event.serializedResult,
-                    mimeType: 'application/json',
-                    source: 'tool_result_archive',
-                    summary: `Archived ${event.toolName} tool result for context budget replay`,
-                });
-                return { artifactId: artifact.id };
-            }),
-            readToolResultArchive: (event) => readArchive(input.artifacts, event),
-            readArchivedToolResultResource: (event) => readArchive(input.artifacts, event),
+            archiveToolResult: prepareLedgerForCommit,
+            readToolResultArchive: (event) => event.rewriteVersion === 2
+                ? (readLedger?.(event) ?? { ok: false, reason: 'read_failed' })
+                : readArchive(input.artifacts, event),
+            readArchivedToolResultResource: (event) => event.storage === 'ledger'
+                ? (readLedgerResource?.(event) ?? { ok: false, reason: 'read_failed' })
+                : readArchive(input.artifacts, event),
         }),
     };
     return Object.freeze(services);