maka-agent 0.2.2-dev.92.20261019 → 0.2.2-dev.98.20261024

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

@@ -0,0 +1,253 @@
+/*
+ * 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 { randomUUID } from 'node:crypto';
+import { assertObservedEventWaitTransition, decodeObservedEventWaitRecord, eventWaitDeliveryKey, } from '@maka/core/event-wait';
+import { conditionId, normalizeCondition, parseConditionResult, } from './condition.js';
+/** Shares Matter's DB transaction: settlement, wait installation and wake delivery are atomic. */
+export class MatterConditions {
+    db;
+    now;
+    transaction;
+    matter;
+    deliver;
+    constructor(db, now, transaction, matter, deliver) {
+        this.db = db;
+        this.now = now;
+        this.transaction = transaction;
+        this.matter = matter;
+        this.deliver = deliver;
+        db.exec(`CREATE TABLE IF NOT EXISTS matter_checkers(id TEXT PRIMARY KEY, matter_id TEXT NOT NULL, payload TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS matter_conditions(id TEXT PRIMARY KEY, matter_id TEXT NOT NULL, revision INTEGER NOT NULL, payload TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS matter_conditions_owner ON matter_conditions(matter_id);
+      CREATE TABLE IF NOT EXISTS matter_condition_sources(id TEXT PRIMARY KEY, cooldown INTEGER NOT NULL DEFAULT 0, token TEXT, reserved_until INTEGER NOT NULL DEFAULT 0);`);
+    }
+    saveTest(matterId, definition, result) {
+        const captured = normalizeCondition(definition);
+        const checked = parseConditionResult(result);
+        const record = {
+            id: conditionId(matterId, captured),
+            matterId,
+            definition: captured,
+            testedAt: this.now(),
+            result: checked,
+        };
+        this.db
+            .prepare('INSERT INTO matter_checkers(id,matter_id,payload) VALUES(?,?,?) ON CONFLICT(id) DO UPDATE SET payload=excluded.payload')
+            .run(record.id, matterId, JSON.stringify(record));
+        return record;
+    }
+    checker(id, matterId) {
+        const row = this.db
+            .prepare('SELECT payload FROM matter_checkers WHERE id=? AND matter_id=?')
+            .get(id, matterId);
+        if (!row)
+            throw new Error('Checker must be successfully tested in this matter first');
+        return JSON.parse(String(row.payload));
+    }
+    /** Called only inside the settlement transaction. Testing alone never starts observation. */
+    install(m, checkerId, intervalMs, submittedAt) {
+        if (!Number.isSafeInteger(intervalMs) || intervalMs < 1000 || intervalMs > 86400000)
+            throw new Error('Condition intervalMs must be 1000–86400000');
+        this.checker(checkerId, m.id);
+        const id = randomUUID();
+        const record = decodeObservedEventWaitRecord({
+            schemaVersion: 1,
+            waitId: id,
+            sessionId: m.sessionId,
+            sourceTurnId: m.activation.turnId,
+            sourceToolCallId: m.activation.id,
+            resource: {
+                providerId: 'matter',
+                connectionId: m.sessionId,
+                resourceType: 'checker',
+                resourceId: m.id,
+            },
+            condition: { typeId: 'code', version: 1, parameters: { checkerId, intervalMs } },
+            deliveryKey: eventWaitDeliveryKey(id),
+            createdAt: submittedAt,
+            updatedAt: submittedAt,
+            deadlineAt: Math.min(...m.wakes.map((w) => w.at)),
+            status: 'waiting',
+        });
+        this.db
+            .prepare('INSERT INTO matter_conditions(id,matter_id,revision,payload) VALUES(?,?,1,?)')
+            .run(id, m.id, JSON.stringify(record));
+        m.conditionWaitId = id;
+    }
+    read(id) {
+        const row = this.db
+            .prepare('SELECT revision,payload FROM matter_conditions WHERE id=?')
+            .get(id);
+        return row
+            ? {
+                authorityRevision: Number(row.revision),
+                record: decodeObservedEventWaitRecord(JSON.parse(String(row.payload))),
+            }
+            : null;
+    }
+    /** The caller is already inside a Matter transaction; retirement also clears the time fallback. */
+    retire(m, reason) {
+        if (!m.conditionWaitId)
+            return;
+        const snapshot = this.read(m.conditionWaitId);
+        if (snapshot?.record.status === 'waiting') {
+            const record = {
+                ...snapshot.record,
+                status: 'cancelled',
+                reason,
+                updatedAt: Math.max(this.now(), snapshot.record.updatedAt),
+                cancelledAt: Math.max(this.now(), snapshot.record.updatedAt),
+            };
+            this.write(snapshot, record);
+        }
+        m.conditionWaitId = null;
+        m.wakes = [];
+    }
+    /** Called by the existing time scanner, independent of source availability. */
+    expire(m) {
+        if (!m.conditionWaitId)
+            return false;
+        const snapshot = this.read(m.conditionWaitId);
+        if (snapshot?.record.status === 'waiting' && this.now() >= snapshot.record.deadlineAt) {
+            const record = {
+                ...snapshot.record,
+                status: 'expired',
+                expiredAt: this.now(),
+                updatedAt: this.now(),
+            };
+            this.write(snapshot, record);
+            this.deliver(m, record);
+        }
+        return true;
+    }
+    write(before, record) {
+        assertObservedEventWaitTransition(before.record, record);
+        const snapshot = { authorityRevision: before.authorityRevision + 1, record };
+        this.db
+            .prepare('UPDATE matter_conditions SET revision=?,payload=? WHERE id=?')
+            .run(snapshot.authorityRevision, JSON.stringify(record), record.waitId);
+        return snapshot;
+    }
+    eligible(r) {
+        const m = this.matter(r.resource.resourceId);
+        return m.conditionWaitId === r.waitId && m.status === 'waiting' && !m.activation;
+    }
+    assertLease(owner) {
+        const row = this.db.prepare('SELECT owner,until_ms FROM plugin_lease WHERE id=1').get();
+        if (!row || row.owner !== owner || Number(row.until_ms) <= this.now())
+            throw new Error('Matter observation lease lost');
+    }
+    observationStore(owner) {
+        const sourceId = (x) => JSON.stringify([x.providerId, x.connectionId]);
+        const source = (x) => {
+            const id = sourceId(x);
+            this.db.prepare('INSERT OR IGNORE INTO matter_condition_sources(id) VALUES(?)').run(id);
+            return this.db.prepare('SELECT * FROM matter_condition_sources WHERE id=?').get(id);
+        };
+        const guarded = (fn) => this.transaction(() => {
+            this.assertLease(owner);
+            return fn();
+        });
+        const waits = () => this.db
+            .prepare(`SELECT c.id FROM matter_conditions c JOIN matters m ON m.id=c.matter_id
+      WHERE json_extract(m.payload,'$.conditionWaitId')=c.id
+        AND json_extract(m.payload,'$.status')='waiting'
+        AND json_extract(m.payload,'$.activation') IS NULL ORDER BY c.id`)
+            .all()
+            .map((row) => this.read(String(row.id)))
+            .filter((s) => this.eligible(s.record));
+        return {
+            read: async ({ sessionId, waitId }) => guarded(() => {
+                const s = this.read(waitId);
+                return s?.record.sessionId === sessionId ? s : null;
+            }),
+            listByStatus: async ({ status, afterWaitId, limit }) => guarded(() => {
+                const all = waits().filter((s) => s.record.status === status && (!afterWaitId || s.record.waitId > afterWaitId));
+                const items = all.slice(0, limit);
+                return { items, nextCursor: all.length > limit ? items.at(-1).record.waitId : null };
+            }),
+            listForObservation: async (input) => guarded(() => {
+                const excluded = new Set(input.excludedWaitIds), sources = new Set(input.excludedSources?.map(sourceId));
+                const items = waits().filter(({ record: r }) => r.status === 'waiting' &&
+                    !excluded.has(r.waitId) &&
+                    !sources.has(sourceId(r.resource)) &&
+                    (!input.scan?.afterWaitId || r.waitId > input.scan.afterWaitId) &&
+                    input.now >= (r.observation?.nextPollAt ?? r.createdAt));
+                if (!input.scan)
+                    items.sort((a, b) => (a.record.observation?.lastAttemptAt ?? 0) -
+                        (b.record.observation?.lastAttemptAt ?? 0));
+                return items.slice(0, input.limit);
+            }),
+            commit: async (input) => guarded(() => {
+                const before = this.read(input.waitId);
+                if (!before || before.authorityRevision !== input.expectedAuthorityRevision)
+                    return {
+                        kind: 'revision_conflict',
+                        actualAuthorityRevision: before?.authorityRevision ?? null,
+                    };
+                if (before.record.sessionId !== input.sessionId || !this.eligible(before.record))
+                    return { kind: 'session_unavailable' };
+                let record = decodeObservedEventWaitRecord(input.record);
+                if (record.status === 'waiting' && record.observation?.outcome === 'pending') {
+                    const next = (record.observation.lastObservedAt ?? record.observation.lastAttemptAt) +
+                        Number(record.condition.parameters.intervalMs);
+                    record = {
+                        ...record,
+                        observation: { ...record.observation, nextObserveAt: next, nextPollAt: next },
+                    };
+                }
+                const snapshot = this.write(before, record);
+                if (record.status !== 'waiting') {
+                    // Source revocation/cancellation must be visible to the worker too, not silently forgotten.
+                    this.deliver(this.matter(record.resource.resourceId), record);
+                }
+                return { kind: 'committed', snapshot };
+            }),
+            readSourceCooldown: async (x) => guarded(() => {
+                const r = source(x);
+                return Math.max(Number(r.cooldown), Number(r.reserved_until)) || null;
+            }),
+            extendSourceCooldown: async (x) => guarded(() => {
+                const until = Math.max(Number(source(x).cooldown), x.until);
+                this.db
+                    .prepare('UPDATE matter_condition_sources SET cooldown=? WHERE id=?')
+                    .run(until, sourceId(x));
+                return until;
+            }),
+            reserveSourceDispatch: async (x) => guarded(() => {
+                const r = source(x);
+                if (Math.max(Number(r.cooldown), Number(r.reserved_until)) > x.observedAt)
+                    return false;
+                this.db
+                    .prepare('UPDATE matter_condition_sources SET token=?,reserved_until=? WHERE id=?')
+                    .run(x.token, x.until, sourceId(x));
+                return true;
+            }),
+            completeSourceDispatch: async (x) => guarded(() => {
+                const r = source(x);
+                if (r.token === x.token)
+                    this.db
+                        .prepare('UPDATE matter_condition_sources SET token=NULL,reserved_until=0,cooldown=? WHERE id=?')
+                        .run(Math.max(Number(r.cooldown), x.until), sourceId(x));
+                const current = source(x);
+                return Math.max(Number(current.cooldown), Number(current.reserved_until));
+            }),
+        };
+    }
+}

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

@@ -0,0 +1,133 @@
+/*
+ * 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 { z } from 'zod';
+import { executeCodeCell } from '@maka/runtime/code-mode';
+const json = z.record(z.string(), z.json());
+export const conditionInput = z.object({
+    code: z
+        .string()
+        .min(1)
+        .max(24000)
+        .optional()
+        .describe('Async JavaScript body. Read input and checkpoint; call only tools.SourceList({}), SourceQuery({source,query}), SourceRead({source,object}), SessionRead({source,id,query}). Return {status:"pending"|"triggered",reason,evidence?:string[],checkpoint?:JSON object}. No Node, shell or unrestricted network. Verify the result against real evidence before waiting.'),
+    preset: z
+        .enum(['source-appeared', 'session-revision'])
+        .optional()
+        .describe('Use instead of code. source-appeared: input {source,query}, triggers when the narrowed query returns any object. session-revision: input {source?,id,revision}, triggers when the session history revision changes. Inspect the test result to verify scope.'),
+    input: json.default({}),
+});
+const presets = {
+    'source-appeared': `const page = await tools.SourceQuery({source:input.source,query:input.query});
+return {status:page.items.length ? "triggered" : "pending",reason:page.items.length ? "Source query found matching objects" : "No matching objects",evidence:page.items.slice(0,7).map(item => item.id)};`,
+    'session-revision': `const snapshot = await tools.SessionRead({source:input.source ?? "maka",id:input.id,query:{limit:1}});
+if (!snapshot || typeof snapshot.session.historyRevision !== "string" || typeof input.revision !== "string") throw Error("Session and baseline must expose a history revision");
+return {status:snapshot.session.historyRevision !== input.revision ? "triggered" : "pending",reason:"Session history revision compared with the supplied baseline",evidence:[input.id]};`,
+};
+export function normalizeCondition(value) {
+    const input = conditionInput.parse(value);
+    if (Boolean(input.code) === Boolean(input.preset))
+        throw new Error('Supply either code or preset');
+    return { code: input.code ?? presets[input.preset], input: input.input };
+}
+export const conditionResult = z
+    .object({
+    status: z.enum(['pending', 'triggered']),
+    reason: z.string().min(1).max(1000),
+    evidence: z.array(z.string().min(1).max(512)).max(7).default([]),
+    checkpoint: json.optional(),
+})
+    .strict();
+export function conditionId(matterId, definition) {
+    return createHash('sha256')
+        .update(JSON.stringify([matterId, definition]))
+        .digest('hex');
+}
+export function parseConditionResult(value) {
+    const result = conditionResult.parse(value);
+    // Fits the observation engine's durable cursor, including UTF-8 and JSON escaping.
+    if (Buffer.byteLength(JSON.stringify(result.checkpoint ?? {})) > 1800)
+        throw new Error('Checker checkpoint exceeds 1800 bytes; keep only a bounded cursor.');
+    if ([result.reason, ...result.evidence].some((value) => Buffer.byteLength(value) > 1024))
+        throw new Error('Checker evidence or reason exceeds 1024 bytes');
+    if ([result.reason, ...result.evidence].some((value) => /[\u0000-\u001f\u007f-\u009f\ud800-\udfff]/u.test(value)))
+        throw new Error('Checker reason and evidence must be single-line valid Unicode text');
+    if (Buffer.byteLength(JSON.stringify([result.reason, ...result.evidence])) > 5000)
+        throw new Error('Checker evidence exceeds the wake event budget');
+    return result;
+}
+const names = ['SourceList', 'SourceQuery', 'SourceRead', 'SessionRead'];
+export async function runCondition(definition, checkpoint, read, signal) {
+    const result = await executeCodeCell({
+        code: `const input = ${JSON.stringify(definition.input)}; const checkpoint = ${JSON.stringify(checkpoint ?? null)};\n${definition.code}`,
+        tools: names.map((name) => ({ name })),
+        callTool: async (name, args, signal) => {
+            if (!names.includes(name))
+                throw new Error('Read-only checker capability unavailable');
+            return read(name, args, signal);
+        },
+        isFatalToolError: () => true,
+        signal,
+    });
+    if (!result.ok)
+        throw new Error(`Checker ${result.error.kind}: ${result.error.message}`);
+    return parseConditionResult(result.value);
+}
+/** The same scoped read bridge is used for the Agent's test and background observations. */
+export function conditionReader(ctx, invocation) {
+    return (name, value, signal) => ctx.agents.withInvocation({
+        ...invocation,
+        abortSignal: signal,
+        emitOutput: () => { },
+    }, async () => {
+        signal.throwIfAborted();
+        const args = z.record(z.string(), z.unknown()).parse(value ?? {});
+        switch (name) {
+            case 'SourceList':
+                return ctx.sources.list();
+            case 'SourceQuery': {
+                const source = z.string().parse(args.source);
+                const page = await ctx.sources.query(source, z.record(z.string(), z.unknown()).parse(args.query ?? {}));
+                const allowed = new Set(await ctx.sources.authorize(source, page.items));
+                if (page.items.some((item) => !allowed.has(item.id)))
+                    throw new Error('Source read permission denied');
+                return page;
+            }
+            case 'SourceRead': {
+                const object = z
+                    .object({
+                    id: z.string(),
+                    revision: z.string(),
+                    kind: z.string(),
+                    locator: z.record(z.string(), z.unknown()),
+                })
+                    .passthrough()
+                    .parse(args.object);
+                const result = await ctx.sources.read(z.string().parse(args.source), object);
+                if (result.status === 'unavailable' || result.status === 'version_unavailable')
+                    throw new Error(`Source ${result.status}`);
+                return result;
+            }
+            case 'SessionRead':
+                return ctx.sessionQuery.sourceQuery(z.string().parse(args.source ?? 'maka'), z.string().parse(args.id), z.record(z.string(), z.unknown()).parse(args.query ?? {}));
+            default:
+                throw new Error('Unsupported checker read');
+        }
+    });
+}

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

@@ -16,8 +16,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { matterInput } from './settlement-context.js';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
+import { isPendingActivationTurnId } from './matter.js';
 import { buildMatterPrompt, buildMatterStepContext } from './prompt.js';
 import { awaitingUser, executionFailure } from '../execution-outcome.js';
 /** Owns enrolled follow-up work. It restores authority only for sessions explicitly enrolled in its DB. */
@@ -65,7 +67,7 @@ export class MatterController {
         return this.ctx.agents.withInvocation({
             sessionId,
             cwd,
-            turnId: `matter-host:${this.owner}`,
+            turnId: `matter-host-${this.owner}`,
             toolCallId: `matter-host:${randomUUID()}`,
             abortSignal: this.stopping.signal,
             emitOutput: () => { },
@@ -94,6 +96,13 @@ export class MatterController {
             this.store.recover();
             this.ready = true;
         }
+        try {
+            await this.options.observer?.start();
+        }
+        catch (error) {
+            // Observation failure must not block time fallbacks or unrelated Matter work.
+            this.lastError = String(error);
+        }
         this.store.enqueueDue();
         for (const m of this.store.list()) {
             if (!this.active || this.runs.size >= 15)
@@ -142,7 +151,7 @@ export class MatterController {
                 if (result.disposition === 'turn_started') {
                     const latest = this.store.get(m.id).matter;
                     if (latest.activation?.id === activationId &&
-                        latest.activation.turnId.startsWith('pending:'))
+                        isPendingActivationTurnId(latest.activation.turnId))
                         this.store.bindTurn(m.id, activationId, result.turnId);
                 }
                 else if (result.disposition === 'followup')
@@ -153,7 +162,7 @@ export class MatterController {
             // A queued wake binds via MatterRead(activationId). Never re-submit an uncertain wake.
             const completion = async () => {
                 if (queued) {
-                    while (this.store.get(m.id).matter.activation?.turnId.startsWith('pending:')) {
+                    while (isPendingActivationTurnId(this.store.get(m.id).matter.activation?.turnId)) {
                         await delay(25, undefined, { signal: this.stopping.signal });
                     }
                 }
@@ -184,7 +193,7 @@ export class MatterController {
             // A live activation has no wall-clock deadline. Runtime failures and explicit
             // user/Host cancellation still end it through the ordinary completion path.
             await completion();
-            if (this.store.get(m.id).matter.activation?.turnId.startsWith('pending:'))
+            if (isPendingActivationTurnId(this.store.get(m.id).matter.activation?.turnId))
                 throw new Error('Queued wake ended without claiming its activation; inspect conversation before resuming');
             this.store.finish(m.id, activationId);
         }
@@ -192,7 +201,7 @@ export class MatterController {
             this.lastError = String(e);
             const live = this.store.get(m.id).matter;
             if (live.activation?.id === activationId &&
-                live.activation.turnId.startsWith('pending:') &&
+                isPendingActivationTurnId(live.activation.turnId) &&
                 /Runtime Host is not ready for Plugin Agent messages/.test(String(e))) {
                 this.store.deferAdmission(m.id, activationId, String(e));
                 return;
@@ -271,17 +280,20 @@ export class MatterController {
         const m = this.store.forSession(sessionId);
         if (!m || ['completed', 'cancelled'].includes(m.status))
             return undefined;
-        const clock = buildMatterStepContext();
-        if (!m.activation || m.activation.turnId !== turnId || m.activation.settled)
-            return clock;
+        return buildMatterStepContext();
+    }
+    stepInboxContext(sessionId, turnId) {
+        const m = this.store.forSession(sessionId);
+        if (!m ||
+            ['completed', 'cancelled'].includes(m.status) ||
+            !m.activation ||
+            m.activation.turnId !== turnId ||
+            m.activation.settled)
+            return undefined;
         const snapshot = this.store.get(m.id);
         const workspace = this.store.workspace(m.id, m.activation.id);
-        return `${clock}\nCurrent task inbox (persisted inputs, not a new delegation; refreshed before every model request). User entries are user requirements; coordinator entries are assistant-authored amendments and bot_clarification entries are coordinator answers; both are coordinator context, not new user authorization. Reassess your next action against these inputs. Read MatterRead before submitting so its revision and observed input boundary are current. Rendering this context does not acknowledge or consume inputs.\n${JSON.stringify({
-            matterId: m.id,
-            activationId: m.activation.id,
-            revision: m.revision,
-            events: snapshot.events,
-            pendingEventCount: snapshot.pendingEventCount,
+        return `Current task inbox (persisted inputs, not a new delegation; refreshed before every model request). User entries are user requirements; coordinator entries are assistant-authored amendments and bot_clarification entries are coordinator answers; both are coordinator context, not new user authorization. Reassess your next action against these inputs. Settlement checks the exact delivered input boundary automatically. Rendering this context does not acknowledge or consume inputs.\n${JSON.stringify({
+            ...matterInput(snapshot),
             inboxFile: workspace.files.inbox,
         })}`;
     }
@@ -319,6 +331,7 @@ export class MatterController {
         this.active = false;
         clearTimeout(this.timer);
         await this.ticking;
+        await this.options.observer?.close();
         // Fence writes before retiring this service’s run observers.
         for (const id of this.runs.keys()) {
             const m = this.store.get(id).matter;

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

@@ -23,6 +23,7 @@ import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { taskDelivery } from './delivery.js';
+import { workerTools } from './settlement-context.js';
 /** Parent chat owns delegation; each work item retains its existing Matter Session. */
 export function registerDelegation(ctx, directory, store, controller) {
     const db = new DatabaseSync(join(directory, 'delegations.sqlite'));
@@ -31,6 +32,9 @@ export function registerDelegation(ctx, directory, store, controller) {
       owner TEXT NOT NULL, task_key TEXT NOT NULL, session TEXT NOT NULL UNIQUE,
       title TEXT NOT NULL, request TEXT NOT NULL, PRIMARY KEY(owner,task_key));`);
     ctx.onClose(() => db.close());
+    ctx.tools.filter?.((sessionId, tools) => db.prepare('SELECT 1 FROM delegations WHERE session=?').get(sessionId)
+        ? workerTools(tools)
+        : tools);
     ctx.backgroundSessions?.register(() => db
         .prepare('SELECT session FROM delegations')
         .all()
@@ -54,6 +58,22 @@ export function registerDelegation(ctx, directory, store, controller) {
         state: m.stateText,
         waitingFor: m.waitingFor,
         wakes: m.wakes,
+        condition: m.conditionWaitId
+            ? (() => {
+                const wait = store.conditions.read(m.conditionWaitId)?.record;
+                return wait
+                    ? {
+                        waitId: wait.waitId,
+                        status: wait.status,
+                        intervalMs: wait.condition.parameters.intervalMs,
+                        attempts: wait.observation?.attempts ?? 0,
+                        nextCheckAt: wait.observation?.nextPollAt ?? wait.createdAt,
+                        lastObservedAt: wait.observation?.lastObservedAt ?? null,
+                        diagnostic: wait.observation?.reason ?? null,
+                    }
+                    : null;
+            })()
+            : null,
         retryAt: m.retryAt,
         revision: m.revision,
         lastError: m.lastError,
@@ -64,6 +84,16 @@ export function registerDelegation(ctx, directory, store, controller) {
             .slice(0, 10)
             .map(({ id, text, createdAt }) => ({ id, text, createdAt })),
     });
+    // UI polling must not transport working notes, requests or report history.
+    const preview = (m) => ({
+        id: m.id,
+        sessionId: m.sessionId,
+        title: m.title,
+        status: m.status,
+        summary: m.progressSummary ?? '',
+        updatedAt: m.updatedAt,
+        retryAt: m.retryAt ?? null,
+    });
     const creating = new Set();
     const creationLabel = (row) => `matter-creation:${String(row.session).slice(9)}`;
     const recover = async (row, call) => {
@@ -92,10 +122,10 @@ export function registerDelegation(ctx, directory, store, controller) {
                 continue;
             try {
                 const snapshot = (await (await controller.agent(m.sessionId)).snapshot());
-                items.push({ ...describe(m), runtimeStatus: snapshot?.agent?.status });
+                items.push({ ...preview(m), runtimeStatus: snapshot?.agent?.status });
             }
-            catch (error) {
-                items.push({ ...describe(m), runtimeError: String(error) });
+            catch {
+                items.push({ ...preview(m), runtimeError: true });
             }
         }
         return items;
@@ -114,7 +144,7 @@ export function registerDelegation(ctx, directory, store, controller) {
             return JSON.parse(JSON.stringify(await impl(parameters.parse(input), call)));
         },
     });
-    register('MatterOverview', 'Read this conversation tasks, feedback status and unassigned legacy tasks. Does not adopt or change anything.', z.object({}), false, async (_, call) => {
+    register('MatterOverview', 'Read this conversation tasks, feedback status and unassigned legacy tasks as a compact directory with AI-authored progress summaries (at most 30 characters). Full task content is available through MatterTasks with an ID. Does not adopt or change anything.', z.object({}), false, async (_, call) => {
         const owner = call.sessionId;
         const rows = db.prepare('SELECT * FROM delegations').all();
         return {
@@ -123,7 +153,7 @@ export function registerDelegation(ctx, directory, store, controller) {
             legacy: store
                 .list()
                 .filter((m) => !rows.some((r) => r.session === m.sessionId))
-                .map(describe),
+                .map(preview),
             notifications: delivery.status(owner),
         };
     });

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

@@ -154,7 +154,7 @@ export function taskDelivery(ctx, db, store, controller) {
                 const agent = await ctx.agents.withInvocation({
                     sessionId: n.owner,
                     cwd,
-                    turnId: `task-notification:${n.id}`,
+                    turnId: `task-notification-${n.id}`,
                     toolCallId: randomUUID(),
                     abortSignal: abort.signal,
                 }, () => ctx.agents.resume({ sessionId: n.owner }));

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

@@ -22,6 +22,9 @@ import { z } from 'zod';
 import { createMatterStore } from './store.js';
 import { MatterController } from './controller.js';
 import { buildMatterTools } from './tools.js';
+import { createMatterObserver } from './condition-observer.js';
+import { conditionReader, runCondition } from './condition.js';
+import { deliveredMatterInput } from './settlement-context.js';
 import { MATTER_INSTRUCTIONS } from './prompt.js';
 const startInput = z.object({
     title: z.string().trim().min(1).max(120),
@@ -41,6 +44,9 @@ export async function initializeMatters(ctx, directory, config = {}) {
     const controller = new MatterController(ctx, store, {
         tickMs: config.tickMs ?? 5000,
     });
+    controller.options.observer = createMatterObserver(ctx, store, controller.owner, (error) => {
+        controller.lastError = String(error);
+    });
     ctx.onClose(() => store.close());
     const activate = () => {
         controller.start();
@@ -54,10 +60,11 @@ export async function initializeMatters(ctx, directory, config = {}) {
             throw new Error('This session has no follow-up');
         return m;
     };
+    ctx.tools.registerSessionAccess?.((sessionId) => store.isAuthorizedSession(sessionId) || !!store.forSession(sessionId));
     registerDelegation(ctx, location.value, store, controller);
     ctx.tools.register({
         name: 'MatterStart',
-        description: 'Start durable follow-up only in a session opened from the long-task dialog. Read returned file paths, work normally, then write draft.md and MatterSettle. One follow-up per conversation.',
+        description: 'Start durable follow-up only in a session opened from the long-task dialog. Read returned file paths, work normally, then call MatterSettle with the result. One follow-up per conversation.',
         parameters: startInput,
         categoryHint: 'file_write',
         executionSemantics: 'exclusive_step',
@@ -65,6 +72,8 @@ export async function initializeMatters(ctx, directory, config = {}) {
     });
     for (const tool of buildMatterTools({
         store,
+        deliveredInput: async (call) => deliveredMatterInput((await ctx.readRuntimeEvents?.(call.sessionId, call.runId)) ?? [], call),
+        testCondition: (definition, call) => runCondition(definition, null, conditionReader(ctx, call), AbortSignal.any([call.abortSignal, AbortSignal.timeout(30_000)])),
         review: (submission) => reviewMatter(ctx, submission),
         changed() { },
         authorize() {
@@ -111,7 +120,7 @@ export async function initializeMatters(ctx, directory, config = {}) {
                 return { allow: true };
             return {
                 allow: false,
-                feedback: 'This follow-up turn has no exit decision yet. Keep doing useful work, or write draft.md and call MatterSettle with continue, wait (a concrete waitingFor condition and future check time), or complete.',
+                feedback: 'This follow-up turn has no exit decision yet. Keep doing useful work, or call MatterSettle with continue, wait (a concrete waitingFor condition and future check time), or complete.',
             };
         },
     });
@@ -120,6 +129,11 @@ export async function initializeMatters(ctx, directory, config = {}) {
         order: 800,
         text: ({ sessionId, turnId }) => controller.stepContext(sessionId, turnId),
     });
+    ctx.systemPrompt.context({
+        name: 'proactive-matters.inbox',
+        order: 801,
+        text: ({ sessionId, turnId }) => controller.stepInboxContext(sessionId, turnId),
+    });
     // Internal service operations. Desktop protocol exposes only the assistant's owner-bound API.
     ctx.api.register('matters.list', () => controller.snapshot());
     ctx.api.register('matters.authorize-session', (input) => {