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

package/node_modules/@maka/runtime-host/dist/assistant/memory-network/controller.js

@@ -80,7 +80,7 @@ export class MemoryController {
                     error: worker.lastError ?? null,
                     rangeId: work?.id ?? null,
                     coveredCursor: this.store.boundary(id),
-                    nextCheckAt: worker.nextCheckAt ?? null,
+                    nextCheckAt: this.nextCheck(id),
                 };
             });
             const id = `memory:${runId}:${owner}`;
@@ -732,24 +732,57 @@ export class MemoryController {
             throw result.reason;
         return result.value;
     }
-    interval(indexId) {
-        return this.store.worker(indexId)?.intervalMs ?? this.config.intervalMs ?? 43200000;
+    schedule() {
+        const row = this.store.db
+            .prepare("SELECT value FROM memory_meta WHERE key='maintenance-schedule'")
+            .get();
+        if (row)
+            return JSON.parse(String(row.value));
+        // Adopt the earliest existing deadline once; future rounds use only this clock.
+        const due = this.store
+            .list()
+            .filter((x) => this.enabled(x.id))
+            .map((x) => this.store.worker(x.id)?.nextCheckAt)
+            .filter((x) => typeof x === 'number');
+        const schedule = {
+            intervalMs: this.config.intervalMs ?? 43200000,
+            nextCheckAt: due.length
+                ? Math.min(...due)
+                : Date.now() + (this.config.intervalMs ?? 43200000),
+        };
+        this.saveSchedule(schedule);
+        return schedule;
+    }
+    scheduleInfo() {
+        const { intervalMs, nextCheckAt, retryAt } = this.schedule();
+        return { scope: 'global', intervalMs, nextCheckAt, retryAt: retryAt ?? null };
+    }
+    saveSchedule(value) {
+        this.store.db
+            .prepare("INSERT INTO memory_meta(key,value) VALUES('maintenance-schedule',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value")
+            .run(JSON.stringify(value));
+    }
+    configureSchedule(intervalMs) {
+        this.assertOwner();
+        if (!Number.isSafeInteger(intervalMs) || intervalMs < 1 || intervalMs > 2147483647)
+            throw Error('Invalid intervalMs');
+        this.saveSchedule({ ...this.schedule(), intervalMs, nextCheckAt: Date.now() + intervalMs });
+    }
+    interval(_indexId) {
+        return this.schedule().intervalMs;
     }
     enabled(indexId) {
         const w = this.store.worker(indexId);
         return w?.protocol === 'cursor-v1' && w.maintenanceEnabled !== false && !w.continuationStopped;
     }
     nextCheck(indexId) {
-        const w = this.store.worker(indexId);
-        return this.enabled(indexId)
-            ? (w.nextCheckAt ?? (w.lastCheckedAt || w.lastSuccess || Date.now()) + this.interval(indexId))
-            : null;
+        return this.enabled(indexId) ? this.schedule().nextCheckAt : null;
     }
     retryState(indexId) {
         const failures = (this.store.worker(indexId)?.failures ?? 0) + 1;
         return {
             failures,
-            nextCheckAt: Date.now() +
+            retryAt: Date.now() +
                 Math.min(3600000, (this.config.retryMs ?? 60000) * 2 ** Math.min(failures - 1, 6)),
         };
     }
@@ -787,6 +820,7 @@ export class MemoryController {
             startStatus: w?.startStatus ?? null,
             continuationStopReason: w?.continuationStopReason ?? null,
             retryFailures: w?.failures ?? 0,
+            scheduleScope: 'global',
             intervalMs: this.interval(indexId),
             nextCheckAt: this.nextCheck(indexId),
             notice: (coveredCursor === null
@@ -802,7 +836,10 @@ export class MemoryController {
     async control(indexId, action, intervalMs) {
         if (action === 'stop') {
             this.assertOwner();
-            const members = this.store.worker(indexId)?.groupIndexIds ?? [indexId];
+            const active = this.runs.get(indexId);
+            const members = active
+                ? [...this.runs].filter(([, run]) => run === active).map(([id]) => id)
+                : (this.store.worker(indexId)?.groupIndexIds ?? [indexId]);
             for (const id of members)
                 await this.control(id, 'pause');
             const running = members.find((id) => this.runs.has(id));
@@ -819,15 +856,16 @@ export class MemoryController {
         if (intervalMs !== undefined &&
             (!Number.isSafeInteger(intervalMs) || intervalMs < 1 || intervalMs > 2147483647))
             throw Error('Invalid intervalMs');
+        if (intervalMs !== undefined)
+            this.configureSchedule(intervalMs);
         this.store.saveWorker(indexId, {
             ...w,
-            ...(intervalMs === undefined ? {} : { intervalMs }),
             ...(action === 'pause'
                 ? {
                     maintenanceEnabled: false,
                     continuationStopped: true,
                     continuationStopReason: 'Maintenance paused',
-                    nextCheckAt: null,
+                    retryAt: null,
                 }
                 : {}),
             ...(action === 'resume'
@@ -837,9 +875,6 @@ export class MemoryController {
                     continuationStopReason: undefined,
                 }
                 : {}),
-            ...(action !== 'pause'
-                ? { nextCheckAt: Date.now() + (intervalMs ?? this.interval(indexId)) }
-                : {}),
         });
     }
     summary(indexId, visible, running = this.runs.has(indexId)) {
@@ -879,6 +914,7 @@ export class MemoryController {
                         : null,
                     protocol: worker.protocol ?? 'legacy-paused',
                     enabled: this.enabled(indexId),
+                    scheduleScope: 'global',
                     intervalMs: this.interval(indexId),
                     nextCheckAt: this.nextCheck(indexId),
                     lastCheckedAt: worker.lastCheckedAt ?? null,
@@ -907,7 +943,6 @@ export class MemoryController {
             lastSuccess: 0,
             protocol: 'cursor-v1',
             maintenanceEnabled: true,
-            nextCheckAt: Date.now() + (this.config.intervalMs ?? 43200000),
             latestCursor: this.store.work(indexId)?.to,
             lastCheckedAt: this.store.checkedAt(this.store.work(indexId)?.to ?? null),
         });
@@ -919,7 +954,7 @@ export class MemoryController {
         return this.ctx.agents.withInvocation({
             sessionId: w.ownerSessionId,
             cwd: w.cwd,
-            turnId: `memory:${this.owner}`,
+            turnId: `memory-${this.owner}`,
             toolCallId: randomUUID(),
             abortSignal: this.abort.signal,
         }, fn);
@@ -954,35 +989,80 @@ export class MemoryController {
             return this.ticking ?? Promise.resolve();
         this.ticking = (async () => {
             this.flushNotifications();
-            for (const index of this.store.list()) {
-                if (this.abort.signal.aborted ||
-                    new Set(this.runs.values()).size >= (this.config.maxConcurrentJobs ?? 5))
-                    break;
-                if (!this.enabled(index.id) ||
-                    this.runs.has(index.id) ||
-                    this.store.worker(index.id)?.startStatus === 'capacity')
-                    continue;
-                const binding = this.store.worker(index.id);
-                // Persist a due time for old workers without scheduling metadata; do not scan on each tick.
-                if (binding.nextCheckAt == null) {
-                    this.store.saveWorker(index.id, {
-                        ...binding,
-                        nextCheckAt: this.nextCheck(index.id),
-                    });
-                    continue;
+            const schedule = this.schedule();
+            if (this.runs.size)
+                return;
+            if (!schedule.remainingIds?.length) {
+                if (Date.now() < schedule.nextCheckAt)
+                    return;
+                schedule.remainingIds = this.store
+                    .list()
+                    .filter((index) => this.enabled(index.id) && this.store.worker(index.id)?.startStatus !== 'capacity')
+                    .map((index) => index.id);
+                schedule.ranges = {};
+                schedule.retryAt = null;
+                schedule.nextCheckAt = Date.now() + schedule.intervalMs;
+                this.saveSchedule(schedule);
+            }
+            const eligible = schedule.remainingIds.filter((id) => this.enabled(id));
+            if (!eligible.length) {
+                this.saveSchedule({ ...schedule, remainingIds: [], ranges: {}, retryAt: null });
+                return;
+            }
+            // Permission/ownership boundaries remain separate; within one owner all
+            // participating indexes are handed to one Agent, not one Agent per index.
+            const owner = this.store.worker(eligible[0]).ownerSessionId;
+            const selected = eligible.filter((id) => this.store.worker(id).ownerSessionId === owner);
+            schedule.sessions ??= {};
+            if (!schedule.sessions[owner]) {
+                let agent;
+                try {
+                    agent = await this.inOwner(selected[0], () => this.ctx.agents.create({
+                        background: true,
+                        name: 'Memory maintenance',
+                        labels: [ASSISTANT_BACKGROUND_SESSION_LABEL],
+                    }));
                 }
-                if (Date.now() < binding.nextCheckAt)
-                    continue;
-                this.launch(index.id, true);
+                catch (error) {
+                    for (const id of selected)
+                        this.store.saveWorker(id, {
+                            ...this.store.worker(id),
+                            lastError: String(error),
+                            ...this.retryState(id),
+                        });
+                    this.finishScheduledMembers(selected);
+                    this.reportRun(selected, randomUUID());
+                    return;
+                }
+                schedule.sessions[owner] = agent.sessionId;
+                this.store.db
+                    .prepare('INSERT OR IGNORE INTO memory_worker_sessions VALUES(?)')
+                    .run(agent.sessionId);
             }
+            this.saveSchedule({ ...this.schedule(), sessions: schedule.sessions });
+            this.launch(selected[0], true, selected, schedule.sessions[owner]);
         })().finally(() => {
             this.ticking = undefined;
         });
         return this.ticking;
     }
-    launch(indexId, scheduled = false) {
+    finishScheduledMembers(ids) {
+        const schedule = this.schedule();
+        const attempted = new Set(ids);
+        // Failure ends this attempt, not the shared clock. Retain each index's work
+        // and checkpoint for the next round, without holding healthy indexes back.
+        this.saveSchedule({
+            ...schedule,
+            remainingIds: (schedule.remainingIds ?? []).filter((id) => !attempted.has(id)),
+            retryAt: null,
+        });
+        for (const id of ids)
+            this.store.saveWorker(id, { ...this.store.worker(id), retryAt: null });
+    }
+    launch(indexId, scheduled = false, scheduledMembers, sessionId) {
         this.assertOwner();
-        const members = this.store.worker(indexId)?.groupIndexIds ?? [indexId];
+        const members = scheduledMembers ??
+            this.store.worker(indexId)?.groupIndexIds ?? [indexId];
         // All members name the same job, even when a scheduled round excludes paused members.
         for (const id of members)
             if (this.runs.has(id))
@@ -1007,7 +1087,9 @@ export class MemoryController {
         const cancellation = new AbortController();
         const signal = AbortSignal.any([this.abort.signal, cancellation.signal]);
         const run = Promise.resolve()
-            .then(() => this.inOwner(indexId, () => selected.length > 1 ? this.runGroup(selected, signal) : this.run(selected[0], signal)))
+            .then(() => this.inOwner(indexId, () => selected.length > 1 || scheduled
+            ? this.runGroup(selected, signal, scheduled, sessionId)
+            : this.run(selected[0], signal)))
             .catch((error) => {
             for (const id of selected)
                 this.store.saveWorker(id, {
@@ -1025,11 +1107,13 @@ export class MemoryController {
                 if (cancellation.signal.aborted)
                     this.store.saveWorker(id, {
                         ...this.store.worker(id),
-                        nextCheckAt: null,
+                        retryAt: null,
                         lastError: null,
                         startStatus: 'stopped',
                     });
             }
+            if (scheduled)
+                this.finishScheduledMembers(selected);
             this.reportRun(selected, runId, cancellation.signal.aborted);
         });
         for (const id of selected) {
@@ -1069,7 +1153,6 @@ export class MemoryController {
                     ownerSessionId: call.sessionId,
                     cwd: call.cwd,
                     maintenanceEnabled: true,
-                    nextCheckAt: Date.now() + (this.config.intervalMs ?? 43200000),
                     ...this.store.worker(id),
                     sessionId: agent.sessionId,
                     groupIndexIds: ids,
@@ -1079,37 +1162,71 @@ export class MemoryController {
     timeContext() {
         return `Current UTC: ${new Date().toISOString()}. Reevaluate the user's criterion against current time, including rolling windows, even when the source delta is empty. Read existing entries and revisit older originals as needed; remove or revise expired entries and links as required by the criterion. No full rescan or content rewrite is required when the index remains valid. Source cursor capture time is not the current time.`;
     }
-    async runGroup(ids, signal) {
+    async runGroup(ids, signal, scheduled = false, sessionId) {
         const resuming = ids.some((id) => {
             const w = this.store.work(id);
             return w && !w.completed;
         });
         const pending = [];
+        const failed = new Set();
         let agent;
         try {
+            const needsRange = ids.filter((id) => {
+                const work = this.store.work(id);
+                if (work && !work.completed)
+                    return false;
+                return !(work?.completed && (scheduled ? this.schedule().ranges?.[id] === work.id : resuming));
+            });
+            const observations = new Map(needsRange.map((id, i) => [id, i]));
+            const observed = await this.observeMany(needsRange);
             for (const id of ids) {
-                if (resuming && this.store.work(id)?.completed)
+                if (this.store.work(id)?.completed &&
+                    (scheduled ? this.schedule().ranges?.[id] === this.store.work(id)?.id : resuming))
                     continue;
-                const index = this.store.index(id);
-                const existing = this.store.work(id);
-                const cursor = existing && !existing.completed
-                    ? this.store.cursor(existing.to)
-                    : await this.capture(index.sources ?? ['maka'], index.sessions, id);
-                const visible = await this.indexVisible(id);
-                const work = this.store.work(id);
-                pending.push({
-                    id,
-                    work: work && !work.completed ? work : this.store.begin(id, cursor.id, visible),
-                    visible,
-                });
-                this.store.saveWorker(id, {
-                    ...this.store.worker(id),
-                    lastAttempt: Date.now(),
-                    lastError: null,
-                });
+                try {
+                    const existing = this.store.work(id);
+                    const result = observations.has(id) ? observed[observations.get(id)] : undefined;
+                    if (result?.status === 'rejected')
+                        throw result.reason;
+                    if (result && this.store.worker(id)?.lastCheckError)
+                        throw Error(this.store.worker(id).lastCheckError);
+                    const cursor = this.store.cursor(existing && !existing.completed ? existing.to : this.store.worker(id).latestCursor);
+                    const visible = await this.indexVisible(id);
+                    const work = this.store.work(id);
+                    pending.push({
+                        id,
+                        work: work && !work.completed ? work : this.store.begin(id, cursor.id, visible),
+                        visible,
+                    });
+                    if (scheduled) {
+                        const schedule = this.schedule();
+                        this.saveSchedule({
+                            ...schedule,
+                            ranges: { ...schedule.ranges, [id]: pending.at(-1).work.id },
+                        });
+                    }
+                    this.store.saveWorker(id, {
+                        ...this.store.worker(id),
+                        lastAttempt: Date.now(),
+                        lastError: null,
+                    });
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        throw error;
+                    failed.add(id);
+                    this.store.saveWorker(id, {
+                        ...this.store.worker(id),
+                        lastAttempt: Date.now(),
+                        lastError: String(error),
+                        ...this.retryState(id),
+                    });
+                }
             }
             if (pending.length) {
-                agent = await this.ctx.agents.resume({ sessionId: this.store.worker(ids[0]).sessionId });
+                agent = await this.ctx.agents.resume({
+                    sessionId: sessionId ?? this.store.worker(ids[0]).sessionId,
+                });
                 for (;;) {
                     this.assertOwner();
                     const remaining = pending.filter((x) => !this.store.work(x.id)?.completed);
@@ -1118,7 +1235,7 @@ export class MemoryController {
                     await agent.whenIdle(signal);
                     signal.throwIfAborted();
                     const before = remaining.map((x) => this.store.latestCheckpoint(x.id, x.work.id, agent.sessionId)?.id ?? 0);
-                    const result = await agent.followup(`Organize these independent indexes in this one Session. Choose the order and reuse reads. Preserve completed members. Each criterion and exact range must be finished separately; save incomplete progress with complete=false and continue. ${this.timeContext()}\n${JSON.stringify(remaining.map((x) => ({ indexId: x.id, number: this.store.worker(x.id).groupNumber, criterion: this.store.index(x.id).instructions, range: this.store.describe(x.work.from, x.work.to, x.visible), rangeId: x.work.id, notes: this.store.notes(x.id) })))}`);
+                    const result = await agent.followup(`${ids.length === 1 ? `Organize index ${ids[0]}. ` : ''}Organize these independent indexes in this one Session. Decide which indexes need changes and whether to organize several together; choose the order and reuse reads. Valid unchanged indexes need only a checkpoint explaining that judgment. Preserve completed members. Each criterion and exact range must be finished separately; save incomplete progress with complete=false and continue. ${this.timeContext()}\n${JSON.stringify(remaining.map((x) => ({ indexId: x.id, number: this.store.worker(x.id).groupNumber, criterion: this.store.index(x.id).instructions, range: this.store.describe(x.work.from, x.work.to, x.visible), rangeId: x.work.id, notes: this.store.notes(x.id) })))}`);
                     if (!['turn_started', 'followup'].includes(result?.disposition))
                         throw Error('Host rejected group maintenance');
                     await agent.whenIdle(signal);
@@ -1139,7 +1256,7 @@ export class MemoryController {
                         throw Error('Group stopped without checkpoint; retry retained work');
                 }
             }
-            for (const id of ids)
+            for (const id of ids.filter((id) => !failed.has(id)))
                 this.store.saveWorker(id, {
                     ...this.store.worker(id),
                     lastSuccess: pending.some((x) => x.id === id)
@@ -1147,23 +1264,38 @@ export class MemoryController {
                         : this.store.worker(id).lastSuccess,
                     lastError: null,
                     failures: 0,
-                    nextCheckAt: Date.now() + this.interval(id),
+                    retryAt: null,
                 });
         }
         catch (error) {
             if (signal.aborted)
                 await agent?.cancel().catch(() => { });
-            for (const id of ids)
+            for (const id of ids) {
+                if (failed.has(id))
+                    continue;
+                const work = this.store.work(id);
+                const completed = work?.completed && pending.some((x) => x.id === id && x.work.id === work.id);
                 this.store.saveWorker(id, {
                     ...this.store.worker(id),
-                    lastError: String(error),
-                    ...this.retryState(id),
+                    ...(completed
+                        ? { lastError: null, failures: 0, retryAt: null, lastSuccess: Date.now() }
+                        : { lastError: String(error), ...this.retryState(id) }),
                 });
+            }
         }
-        return {
-            members: await Promise.all(ids.map(async (id) => this.summary(id, await this.indexVisible(id), false))),
-            backgroundFinished: true,
-        };
+        const members = await Promise.all(ids.map(async (id) => {
+            try {
+                return this.summary(id, await this.indexVisible(id), false);
+            }
+            catch (error) {
+                // A member's access failure must not overwrite the other members' results.
+                this.store.saveWorker(id, { ...this.store.worker(id), lastError: String(error) });
+                return { indexId: id, status: 'failed', error: String(error) };
+            }
+        }));
+        return scheduled && ids.length === 1
+            ? { ...members[0], backgroundFinished: true }
+            : { members, backgroundFinished: true };
     }
     async wait(indexId, callerSignal) {
         const run = this.maintain(indexId);
@@ -1247,7 +1379,7 @@ Range ID: ${work.id}. Update existing entries and links when new evidence change
                 lastSuccess: Date.now(),
                 lastError: undefined,
                 failures: 0,
-                nextCheckAt: Date.now() + this.interval(indexId),
+                retryAt: null,
             });
         }
         catch (error) {

package/node_modules/@maka/runtime-host/dist/assistant/memory-network/host.js

@@ -179,7 +179,7 @@ export async function initializeMemory(ctx, directory, config = {}) {
         }
         return results;
     }, false, 'direct');
-    register('MemoryIndexCreate', 'Create an index from the user’s organizing requirements and a source-range cursor from MemoryRange. Starts a background organizing job by default; returns its identity and admission/progress, not a guarantee of completion. The index Agent chooses how to read and organize. New indexes enable maintenance every 12 hours by default; MemoryIndexControl changes that index’s schedule. Completion/failure feedback goes to the owning assistant. background=false waits for the result.', z.object({
+    register('MemoryIndexCreate', 'Create an index from the user’s organizing requirements and a source-range cursor from MemoryRange. Starts a background organizing job by default; returns its identity and admission/progress, not a guarantee of completion. The index Agent chooses how to read and organize. New indexes join the shared maintenance schedule (12 hours by default). All participating indexes are maintained by one Agent per owner, which decides what needs changing; MemoryIndexControl configure changes the shared interval. Completion/failure feedback goes to the owning assistant. background=false waits for the result.', z.object({
         name: z.string().min(1).max(160),
         instructions: z.string().min(1).max(8000),
         cursor: id,
@@ -210,7 +210,7 @@ export async function initializeMemory(ctx, directory, config = {}) {
         }
         return controller.wait(index.id, call.abortSignal);
     }, true);
-    register('MemoryIndexCreateGroup', 'Create or continue several numbered indexes in one organizing job. Each index retains its own requirements, content and coverage; existing members use number/indexId. Returns member IDs and job admission; capacity rejection includes unstarted IDs for retry. Background by default. New indexes enable 12-hour maintenance. Completion/failure feedback goes to the owning assistant; one member completing does not complete the group.', z.object({
+    register('MemoryIndexCreateGroup', 'Create or continue several numbered indexes in one organizing job. Each index retains its own requirements, content and coverage; existing members use number/indexId. Returns member IDs and job admission; capacity rejection includes unstarted IDs for retry. Background by default. New indexes join the shared maintenance schedule (12 hours by default). Completion/failure feedback goes to the owning assistant; one member completing does not complete the group.', z.object({
         cursor: id,
         indexes: z
             .array(z.object({
@@ -294,18 +294,34 @@ export async function initializeMemory(ctx, directory, config = {}) {
         }
         return controller.wait(input.indexId, call.abortSignal);
     }, true);
-    register('MemoryIndexControl', 'Control maintenance of the specified index. configure changes its interval without enabling a paused index; pause stops future rounds but lets an active round finish; resume schedules the next round. stop cancels the shared organizing job and disables maintenance for ALL its member indexes. Contents and checkpoints are preserved. Returns affected state; it does not create a separate follow-up or user reminder. Use MemoryIndexMaintain for one immediate round.', z.object({
-        indexId: id,
+    register('MemoryIndexControl', 'Configure the GLOBAL index maintenance interval with action=configure and intervalMs (indexId optional); this affects all indexes and does not enable paused indexes. One shared timer hands participating indexes to one organizing Agent, which decides what needs updating or can be handled together. With indexId, pause excludes that index from future rounds but lets active work finish; resume rejoins the shared schedule without resetting its clock. stop requires indexId, cancels its active shared organizing job and disables maintenance for ALL indexes in that job (or its creation group if idle). Contents and checkpoints are preserved. Returns affected state; it does not create a separate follow-up or user reminder. Use MemoryIndexMaintain for one immediate round.', z.object({
+        indexId: id.optional(),
         action: z.enum(['pause', 'resume', 'configure', 'stop']),
         intervalMs: z.number().int().min(1).max(2147483647).optional(),
     }), async (input, call) => {
+        if (!input.indexId) {
+            if (input.action !== 'configure' || input.intervalMs === undefined)
+                throw Error('Without indexId, use configure with intervalMs for the shared schedule');
+            for (const index of store.list())
+                store.assertIndexVisible(index.id, await visible(index.id));
+            controller.configureSchedule(input.intervalMs);
+            return {
+                schedule: controller.scheduleInfo(),
+                effect: { target: 'global_index_maintenance', action: 'configure' },
+            };
+        }
         const allowed = await visible(input.indexId);
         store.assertIndexVisible(input.indexId, allowed);
         await controller.attach(input.indexId, call);
         await controller.control(input.indexId, input.action, input.intervalMs);
         return {
             ...controller.summary(input.indexId, allowed),
-            effect: { target: 'index_maintenance', action: input.action, indexId: input.indexId },
+            schedule: controller.scheduleInfo(),
+            effect: {
+                target: input.intervalMs !== undefined ? 'global_index_maintenance' : 'index_maintenance',
+                action: input.action,
+                indexId: input.indexId,
+            },
         };
     }, true);
     register('MemoryIndexContent', 'Read index documents: key for one full document; keys for a batch; view=full for full texts across the index; default view=directory only lists ALL matching keys/titles/sizes, not document bodies. Optional query is case-insensitive literal search in keys and bodies. after/limit select document pages; maxChars optionally budgets full documents, never silently truncates a document. No limit means all matches. Navigate associated entries with MemoryIndexLinks; verify original evidence with MemoryOriginal. Automatically refreshes source observations before returning, updating freshness/knownPending; does not organize the index or advance coveredCursor.', z.object({

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

@@ -0,0 +1,94 @@
+/*
+ * 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 { createHash } from 'node:crypto';
+import { EventWaitAdapterRegistry } from '../../server/event-wait-adapter.js';
+import { HostEventWaitObserver } from '../../server/event-wait-manager.js';
+import { conditionReader, runCondition } from './condition.js';
+/** Observation never runs an Agent/model; it only executes an already tested read-only cell. */
+export function createMatterObserver(ctx, store, owner, onError, options = {}) {
+    return new HostEventWaitObserver({
+        store: store.conditions.observationStore(owner),
+        policy: { maxLifetimeMs: 366 * 86400000, maxAttempts: 1_000_000, ...options.policy },
+        ...(options.clock ? { clock: options.clock } : {}),
+        onError,
+        authorize: async (wait) => {
+            const m = store.get(wait.resource.resourceId).matter;
+            return m.conditionWaitId === wait.waitId && m.status === 'waiting' && !m.activation
+                ? { kind: 'allowed', context: null }
+                : { kind: 'revoked', reason: 'matter_wait_superseded' };
+        },
+        adapters: new EventWaitAdapterRegistry([
+            {
+                providerId: 'matter',
+                resourceType: 'checker',
+                conditionType: 'code',
+                conditionVersion: 1,
+                reconciliation: 'snapshot',
+                validate(wait) {
+                    store.conditions.checker(String(wait.condition.parameters.checkerId), wait.resource.resourceId);
+                },
+                async read({ wait, cursor, signal }) {
+                    if ((wait.observation?.consecutiveErrors ?? 0) >= 3)
+                        return {
+                            kind: 'source_unavailable',
+                            receiptKey: `checker-errors:${wait.waitId}`,
+                            evidenceRefs: [
+                                'Checker repeatedly failed or timed out. Retest its code and source permissions.',
+                            ],
+                        };
+                    const checker = store.conditions.checker(String(wait.condition.parameters.checkerId), wait.resource.resourceId);
+                    const cwd = store.binding(wait.sessionId);
+                    if (!cwd)
+                        throw new Error('Matter session is unavailable');
+                    const reader = options.reader?.(wait.sessionId) ??
+                        conditionReader(ctx, {
+                            sessionId: wait.sessionId,
+                            cwd,
+                            turnId: wait.sourceTurnId,
+                            toolCallId: `condition:${wait.waitId}`,
+                        });
+                    try {
+                        const result = await runCondition(checker.definition, cursor ? JSON.parse(cursor) : null, reader, signal);
+                        signal.throwIfAborted();
+                        if (result.status === 'pending')
+                            return { kind: 'pending', cursor: JSON.stringify(result.checkpoint ?? {}) };
+                        return {
+                            kind: 'satisfied',
+                            receiptKey: createHash('sha256').update(JSON.stringify(result)).digest('hex'),
+                            evidenceRefs: [result.reason, ...result.evidence],
+                        };
+                    }
+                    catch (error) {
+                        signal.throwIfAborted();
+                        // A broken checker wakes the owner for repair; it never pauses or completes the task.
+                        if ((wait.observation?.consecutiveErrors ?? 0) >= 2)
+                            return {
+                                kind: 'source_unavailable',
+                                receiptKey: `checker-errors:${wait.waitId}`,
+                                evidenceRefs: [
+                                    'Checker failed repeatedly. Retest the checker and its source permissions before waiting again.',
+                                ],
+                            };
+                        return { kind: 'unknown', reason: 'checker_failed' };
+                    }
+                },
+            },
+        ]),
+    });
+}