maka-agent 0.2.0-dev.64.20260929 → 0.2.0-dev.67.20261002

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -584,35 +584,20 @@ export class SessionManager {
         return this.recoverInterruptedSessionsWithPolicy({ kind: 'strict', stores });
     }
     async recoverInterruptedSessionsWithPolicy(policy, scope) {
-        const profileEnabled = process.env.MAKA_STARTUP_PROFILE === '1';
-        const profileTotals = new Map();
-        const profileCalls = new Map();
-        const measure = async (label, operation) => {
-            if (!profileEnabled)
-                return operation();
-            const started = performance.now();
-            try {
-                return await operation();
-            }
-            finally {
-                profileTotals.set(label, (profileTotals.get(label) ?? 0) + performance.now() - started);
-                profileCalls.set(label, (profileCalls.get(label) ?? 0) + 1);
-            }
-        };
-        const interrupted = (await measure('list-sessions', () => listSessionsForRecovery(this.deps.store, policy))).filter((session) => !session.isArchived && (scope === undefined || scope.has(session.id)));
-        const recoveryCandidateSet = async (label, operation) => {
+        const interrupted = (await listSessionsForRecovery(this.deps.store, policy)).filter((session) => !session.isArchived && (scope === undefined || scope.has(session.id)));
+        const recoveryCandidateSet = async (operation) => {
             if (!operation)
                 return undefined;
-            const sessionIds = await measure(label, () => recoverOr(policy, operation, undefined));
+            const sessionIds = await recoverOr(policy, operation, undefined);
             return sessionIds ? new Set(sessionIds) : undefined;
         };
         const continuationAuthority = runtimeContinuationAuthority(this.deps.runtimeEventStore);
         const [shellRecoverySessions, unsettledContinuationClaims, planRecoverySessions] = await Promise.all([
-            recoveryCandidateSet('shell-inventory', this.deps.shellRuns ? () => this.deps.shellRuns.listRecoverySessionIds() : undefined),
+            recoveryCandidateSet(this.deps.shellRuns ? () => this.deps.shellRuns.listRecoverySessionIds() : undefined),
             continuationAuthority?.listUnsettledContinuationClaimsForRecovery
-                ? measure('continuation-inventory', () => recoverOr(policy, () => continuationAuthority.listUnsettledContinuationClaimsForRecovery(interrupted.map((session) => session.id)), undefined))
+                ? recoverOr(policy, () => continuationAuthority.listUnsettledContinuationClaimsForRecovery(interrupted.map((session) => session.id)), undefined)
                 : Promise.resolve(undefined),
-            recoveryCandidateSet('plan-inventory', this.deps.planStore?.listPlanRecoverySessionIds
+            recoveryCandidateSet(this.deps.planStore?.listPlanRecoverySessionIds
                 ? () => this.deps.planStore.listPlanRecoverySessionIds()
                 : undefined),
         ]);
@@ -643,7 +628,7 @@ export class SessionManager {
             }
             if (this.deps.shellRuns &&
                 (!shellRecoverySessions || shellRecoverySessions.has(session.id))) {
-                const recoveredShellRuns = await measure('shell', () => recoverOr(policy, () => this.deps.shellRuns.recoverOrphanedSession(session.id), 0));
+                const recoveredShellRuns = await recoverOr(policy, () => this.deps.shellRuns.recoverOrphanedSession(session.id), 0);
                 if (recoveredShellRuns > 0)
                     recovered.add(session.id);
             }
@@ -658,7 +643,7 @@ export class SessionManager {
                 (!continuationClaimsBySession ||
                     unsettledClaims?.some((state) => state.startEventId === undefined || state.startKind === 'claim_repair'))) {
                 try {
-                    continuationClaimRecovered = await measure('continuation', () => this.recoverContinuationClaimsBeforeProvider(session.id, continuationAuthority, policy, unsettledClaims));
+                    continuationClaimRecovered = await this.recoverContinuationClaimsBeforeProvider(session.id, continuationAuthority, policy, unsettledClaims);
                 }
                 catch (error) {
                     if (policy.kind === 'strict')
@@ -676,9 +661,9 @@ export class SessionManager {
                 // Plan events are the domain authority for whether there is a Plan
                 // obligation at all. Runtime evidence is needed only to decide whether
                 // an existing active Plan belongs to a pending handoff and must survive.
-                const planState = await measure('plan-state', () => recoverOr(policy, () => this.deps.planStore.readState(session.id), undefined));
+                const planState = await recoverOr(policy, () => this.deps.planStore.readState(session.id), undefined);
                 if (planState?.activeExecutionId) {
-                    const preservesHandoff = await measure('plan-handoff', () => recoverOr(policy, async () => {
+                    const preservesHandoff = await recoverOr(policy, async () => {
                         if (!continuationAuthority)
                             return false;
                         const latest = latestInvocation((await this.listInvocations(session.id)).filter((run) => isSessionInlineInvocation(run.opening)));
@@ -688,9 +673,9 @@ export class SessionManager {
                         // Read after claim repair: an abandoned successor now has a real failure.
                         return Boolean((await readLogicalRuntimeExecutionForRun(continuationAuthority, latest))
                             ?.pendingHandoff);
-                    }, false));
+                    }, false);
                     if (!preservesHandoff) {
-                        const planRecovery = await measure('plan-interrupt', () => recoverOr(policy, () => this.deps.planStore.interruptActiveExecution(session.id, 'runtime_recovery'), null));
+                        const planRecovery = await recoverOr(policy, () => this.deps.planStore.interruptActiveExecution(session.id, 'runtime_recovery'), null);
                         if (planRecovery)
                             recovered.add(session.id);
                     }
@@ -711,7 +696,7 @@ export class SessionManager {
             this.deps.runtimeEventStore?.listInvocationRecoveryInventory &&
             runRecoveryQueue.length > 0) {
             try {
-                const inventory = await measure('run-inventory', () => this.deps.runtimeEventStore.listInvocationRecoveryInventory(runRecoveryQueue.map(({ session }) => session.id)));
+                const inventory = await this.deps.runtimeEventStore.listInvocationRecoveryInventory(runRecoveryQueue.map(({ session }) => session.id));
                 const mutable = new Map();
                 for (const entry of inventory) {
                     const entries = mutable.get(entry.sessionId) ?? [];
@@ -727,7 +712,7 @@ export class SessionManager {
         }
         for (const { session, continuationClaimRecovered, claimOwnedUnsettledRunIds, } of runRecoveryQueue) {
             if (this.deps.runStore) {
-                const runRecovery = await measure('runs', () => recoverOr(policy, () => this.recoverAgentRunsFromLedger(session.id, policy, inventoryBySession ? (inventoryBySession.get(session.id) ?? []) : undefined, claimOwnedUnsettledRunIds), undefined));
+                const runRecovery = await recoverOr(policy, () => this.recoverAgentRunsFromLedger(session.id, policy, inventoryBySession ? (inventoryBySession.get(session.id) ?? []) : undefined, claimOwnedUnsettledRunIds), undefined);
                 if (runRecovery?.hasLedger) {
                     if (runRecovery.recovered || continuationClaimRecovered) {
                         await recoverOr(policy, () => this.updateStatus(session.id, 'active'), undefined);
@@ -751,15 +736,6 @@ export class SessionManager {
                 recovered.add(session.id);
             }
         }
-        if (profileEnabled) {
-            console.error(`[startup-profile] session-recovery ${JSON.stringify({
-                sessions: interrupted.length,
-                totals: Object.fromEntries([...profileTotals].map(([label, ms]) => [
-                    label,
-                    { calls: profileCalls.get(label) ?? 0, ms },
-                ])),
-            })}`);
-        }
         return [...recovered];
     }
     async setSessionStatus(sessionId, status, blockedReason) {
@@ -3273,9 +3249,13 @@ export class SessionManager {
         return { hasLedger: true, recovered };
     }
     classifyRuntimeEventRecovery(inspected) {
-        if (!inspected.terminalRuntimeFact)
+        const fact = inspected.terminalRuntimeFact;
+        // A handed-off run ended on purpose; its continuation is owned by the
+        // handoff claim saga, and generic restart repair must not manufacture an
+        // outcome for it.
+        if (!fact || fact.runStatus === 'handed_off')
             return undefined;
-        return runtimeTerminalFactToRecoveryDecision(inspected.invocation, inspected.terminalRuntimeFact);
+        return runtimeTerminalFactToRecoveryDecision(inspected.invocation, fact);
     }
     async applyAgentRunRecovery(sessionId, decision, inspected, policy = { kind: 'best_effort' }, unsettledOperationIds = []) {
         if (!this.deps.runStore || !this.deps.runtimeEventStore)
@@ -3723,6 +3703,11 @@ function diagnosticRecoveryReason(diagnostic) {
         : 'agent_run_recovery';
 }
 function runtimeTerminalFactToRecoveryDecision(invocation, fact) {
+    // classifyRuntimeEventRecovery filters handed-off runs before this; the
+    // guard keeps the recovery status type honest at the boundary.
+    if (fact.runStatus === 'handed_off') {
+        throw new Error('A handed-off run has no recovery decision');
+    }
     return {
         runId: fact.runId,
         turnId: fact.turnId,

package/node_modules/@maka/runtime/dist/stream-graph-coordinator.js

@@ -18,7 +18,7 @@
  */
 import { AGENT_GRAPH_CLIENT_PROJECTION_SCHEMA_VERSION, AgentGraphClientProjectionConflictError, AgentGraphClientTerminalCursorError, } from '@maka/core/agent-graph-client-projection';
 import { decodeAgentGraphIntentClaim } from '@maka/core/agent-graph-control';
-import { readCommittedAgentGraphProjection, } from './stream-graph-projection.js';
+import { AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS, readCommittedAgentGraphProjection, } from './stream-graph-projection.js';
 import { hydrateAgentGraphInputHandoffs, renderAgentGraphScheduledWorkPrompt, } from './stream-graph-handoff.js';
 import { buildAgentGraphReadinessSnapshot as buildReadinessSnapshot } from './stream-graph-readiness.js';
 import { reconcileAgentGraphSchedule, } from './stream-graph-schedule-reconcile.js';
@@ -30,6 +30,7 @@ import { isAgentGraphSupervisorMilestone } from './agent-graph-supervisor-wake.j
 import { buildAgentSwarmStatusTool, projectAgentSwarmStatus } from './agent-swarm-status-tool.js';
 const DEFAULT_MAX_NEW_ACTIVATIONS = 32;
 const MAX_CLIENT_PROJECTION_COMMIT_ATTEMPTS = 4;
+const OUTPUT_DELTA_PROJECTION_INTERVAL_MS = 100;
 export class AgentGraphClientOperationError extends Error {
     code;
     name = 'AgentGraphClientOperationError';
@@ -606,7 +607,10 @@ export class AgentGraphCoordinator {
                     if (event.event.type === 'complete' || event.event.type === 'abort') {
                         driver.runtimeFailureRunIds.delete(event.claim.targetRunId);
                     }
-                    if (isMaterializedGraphClientEvent(event.event.type)) {
+                    if (event.event.type === 'text_delta') {
+                        this.#queueOutputDelta(driver, event, activationHadError);
+                    }
+                    else if (isMaterializedGraphClientEvent(event.event.type)) {
                         this.#queueClientProjectionUpdate(driver, async () => {
                             const advancement = await this.#advanceClientProjection(driver, event, activationHadError);
                             if (advancement &&
@@ -823,8 +827,67 @@ export class AgentGraphCoordinator {
             }
         });
     }
+    #queueOutputDelta(driver, event, activationHadError) {
+        const operatorId = event.claim.targetOperatorId;
+        const pending = driver.pendingOutputDeltas.get(operatorId);
+        if (pending && pending.event.event.type === 'text_delta' && event.event.type === 'text_delta') {
+            const previous = pending.event.event;
+            const current = event.event;
+            if (pending.event.claim.targetRunId === event.claim.targetRunId &&
+                previous.messageId === current.messageId &&
+                ((previous.startOffset === undefined && current.startOffset === undefined) ||
+                    (previous.startOffset !== undefined &&
+                        current.startOffset === previous.startOffset + previous.text.length))) {
+                const joined = Array.from(previous.text + current.text);
+                const truncated = joined.length > AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS + 1;
+                pending.event = {
+                    ...event,
+                    event: {
+                        ...current,
+                        text: truncated
+                            ? joined.slice(-(AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS + 1)).join('')
+                            : joined.join(''),
+                        startOffset: truncated ? undefined : previous.startOffset,
+                    },
+                };
+            }
+            else {
+                pending.event = event;
+                pending.sampleStartedAt = event.event.ts;
+            }
+            pending.activationHadError ||= activationHadError;
+            return;
+        }
+        const next = { event, activationHadError, sampleStartedAt: event.event.ts };
+        driver.pendingOutputDeltas.set(operatorId, next);
+        this.#scheduleOutputProjectionFlush(driver);
+    }
+    #scheduleOutputProjectionFlush(driver) {
+        if (driver.outputProjectionFlushScheduled)
+            return;
+        driver.outputProjectionFlushScheduled = true;
+        this.#queueClientProjectionUpdate(driver, async () => {
+            try {
+                await new Promise((resolve) => {
+                    setTimeout(resolve, OUTPUT_DELTA_PROJECTION_INTERVAL_MS);
+                });
+                const pending = [...driver.pendingOutputDeltas.values()];
+                driver.pendingOutputDeltas.clear();
+                for (const delta of pending) {
+                    await this.#advanceClientProjection(driver, delta.event, delta.activationHadError, delta.sampleStartedAt);
+                }
+            }
+            finally {
+                driver.outputProjectionFlushScheduled = false;
+                if (driver.pendingOutputDeltas.size > 0) {
+                    this.#scheduleOutputProjectionFlush(driver);
+                }
+            }
+        });
+    }
     async #waitForClientProjectionUpdates(driver) {
-        await driver.clientProjectionTask?.catch(() => {
+        const task = driver.clientProjectionTask;
+        await task?.catch(() => {
             // A best-effort repair or later durable observation may repair this
             // derived read side; graph authority never depends on it.
         });
@@ -840,7 +903,7 @@ export class AgentGraphCoordinator {
             await notify(this.#input.onError, driver.rootSessionId, error);
         }
     }
-    async #advanceClientProjection(driver, event, activationHadError) {
+    async #advanceClientProjection(driver, event, activationHadError, sampleStartedAt) {
         for (let attempt = 0; attempt < MAX_CLIENT_PROJECTION_COMMIT_ATTEMPTS; attempt += 1) {
             const graph = await this.#input.controlStore.readAgentGraphClientProjection(driver.graphId);
             const operator = await this.#input.controlStore.readAgentGraphClientOperatorProjection(driver.graphId, event.claim.targetOperatorId);
@@ -858,7 +921,7 @@ export class AgentGraphCoordinator {
                 operatorId: event.claim.targetOperatorId,
                 snapshotVersion: operator.snapshotVersion,
             });
-            const advanced = advanceMaterializedAgentGraphClientProjection(snapshot, inspection, event, activationHadError);
+            const advanced = advanceMaterializedAgentGraphClientProjection(snapshot, inspection, event, activationHadError, sampleStartedAt);
             if (!advanced)
                 return undefined;
             try {
@@ -881,13 +944,15 @@ export class AgentGraphCoordinator {
                     // stop race). Only the authoritative RuntimeEvent fold populates the
                     // immutable terminal-history table.
                     terminalActivities: [],
-                    activityRecords: [
-                        {
-                            recordId: advanced.activity.recordId,
-                            eventTime: advanced.activity.eventTime,
-                        },
-                    ],
-                    incrementalRecordId: advanced.activity.recordId,
+                    activityRecords: advanced.activity
+                        ? [
+                            {
+                                recordId: advanced.activity.recordId,
+                                eventTime: advanced.activity.eventTime,
+                            },
+                        ]
+                        : [],
+                    ...(advanced.activity ? { incrementalRecordId: advanced.activity.recordId } : {}),
                 });
                 if (committed.snapshotVersion === advanced.snapshot.snapshotVersion) {
                     this.#notifyClientChanged(driver, 'runtime_activity');
@@ -1151,6 +1216,8 @@ export class AgentGraphCoordinator {
             closed: false,
             reconciliationReaders: 0,
             clientProjectionDirty: false,
+            outputProjectionFlushScheduled: false,
+            pendingOutputDeltas: new Map(),
             runtimeFailureRunIds: new Set(),
             yieldWaiters: new Set(),
         };
@@ -1327,7 +1394,6 @@ function requireRootSessionId(rootSessionId) {
 }
 function isMaterializedGraphClientEvent(type) {
     return ![
-        'text_delta',
         'thinking_delta',
         'tool_output_delta',
         'tool_progress',

package/node_modules/@maka/runtime/dist/stream-graph-projection.js

@@ -21,6 +21,7 @@ import { isSessionInlineInvocation } from '@maka/core/runtime-invocation';
 import { stableHash, stableStringify } from './request-shape.js';
 import { compareAgentGraphIdentity } from './stream-graph-identity.js';
 export const AGENT_GRAPH_RECORD_SCHEMA_VERSION = 1;
+export const AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS = 280;
 export const AGENT_GRAPH_RECORD_FACETS = [
     'message',
     'thinking',
@@ -79,9 +80,72 @@ export async function readCommittedAgentGraphProjectionWithRuns(input) {
             records: projected.records,
             supervisorMetaStream: projected.supervisorMetaStream,
             state,
+            operatorOutputs: projectOperatorOutputs(streams),
         },
     };
 }
+function projectOperatorOutputs(streams) {
+    const latestByOperator = new Map();
+    for (const stream of streams) {
+        const current = latestByOperator.get(stream.operator.operatorId);
+        if (!current ||
+            stream.run.openedAt > current.run.openedAt ||
+            (stream.run.openedAt === current.run.openedAt &&
+                compareAgentGraphIdentity(stream.run.runId, current.run.runId) > 0)) {
+            latestByOperator.set(stream.operator.operatorId, stream);
+        }
+    }
+    return [...latestByOperator.values()]
+        .map(projectOperatorOutput)
+        .filter((output) => output !== undefined)
+        .sort((left, right) => compareAgentGraphIdentity(left.operatorId, right.operatorId));
+}
+function projectOperatorOutput(stream) {
+    const orderedEvents = stream.events
+        .slice()
+        .sort((left, right) => left.ts - right.ts || compareAgentGraphIdentity(left.id, right.id));
+    const events = orderedEvents.filter((event) => !event.partial);
+    const textEvents = events.filter((event) => event.role === 'model' && event.content?.kind === 'text');
+    const latestText = textEvents.at(-1);
+    if (!latestText || latestText.content?.kind !== 'text')
+        return undefined;
+    const preview = boundOutputPreview(latestText.content.text);
+    if (!preview.text)
+        return undefined;
+    const usageEvents = events.filter((event) => event.actions?.tokenUsage !== undefined);
+    const latestUsage = usageEvents.at(-1);
+    const outputTokens = latestUsage?.actions?.tokenUsage?.output;
+    const usageEndedAt = latestUsage?.ts;
+    const sampleStartedAt = orderedEvents.find((event) => event.role === 'model' && event.content?.kind === 'text').ts;
+    const sampleDurationMs = outputTokens !== undefined && outputTokens > 0 && usageEndedAt !== undefined
+        ? Math.max(0, usageEndedAt - sampleStartedAt)
+        : undefined;
+    const tokensPerSecond = outputTokens !== undefined && sampleDurationMs !== undefined && sampleDurationMs > 0
+        ? Math.round((outputTokens * 10_000) / sampleDurationMs) / 10
+        : undefined;
+    return {
+        operatorId: stream.operator.operatorId,
+        activationId: stream.run.runId,
+        preview: preview.text,
+        previewTruncated: preview.truncated,
+        phase: runtimeInvocationOutcome(stream.run) ? 'completed' : 'streaming',
+        previewUpdatedAt: latestText.ts,
+        sourceEventId: latestText.id,
+        ...(latestText.refs?.providerEventId ? { messageId: latestText.refs.providerEventId } : {}),
+        sampleStartedAt,
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(sampleDurationMs !== undefined ? { sampleDurationMs } : {}),
+        ...(tokensPerSecond !== undefined ? { tokensPerSecond } : {}),
+    };
+}
+function boundOutputPreview(text) {
+    const codePoints = Array.from(text);
+    if (codePoints.length <= AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS) {
+        return { text: codePoints.join(''), truncated: false };
+    }
+    const visible = codePoints.slice(-AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS);
+    return { text: visible.join(''), truncated: true };
+}
 export function projectAgentGraphRecords(input) {
     const operators = uniqueBindings(input.streams.map((stream) => stream.operator));
     assertGraphIdentity(input.graphId, operators);

package/node_modules/@maka/runtime/dist/stream-graph-read-model.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { failureClassFromCompleteStopReason } from '@maka/core/events';
+import { AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS } from './stream-graph-projection.js';
 import { projectAgentGraphSchedule, } from './stream-graph-supervisor-tools.js';
 import { stableHash } from './request-shape.js';
 export const AGENT_GRAPH_CLIENT_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -43,8 +44,9 @@ const MAX_INSTRUCTION_PREVIEW_CHARS = 500;
 /**
  * Durable, bounded graph-facing projection for untrusted presentation clients.
  *
- * Payloads remain in Session/Runtime stores. This surface carries only
- * identities, lifecycle state, wait reasons, and bounded instruction previews.
+ * Full payloads remain in Session/Runtime stores. This surface carries only
+ * identities, lifecycle state, wait reasons, bounded instruction/output
+ * previews, and provider-reported usage-derived throughput.
  */
 export function buildAgentGraphClientSnapshot(input, options = {}) {
     const model = buildReadModel(input);
@@ -64,9 +66,10 @@ export function materializeAgentGraphClientProjection(input) {
  * Advance the bounded materialized client view from one already-durable
  * SessionEvent without replaying the RuntimeEvent ledger.
  */
-export function advanceMaterializedAgentGraphClientProjection(snapshotInput, inspectionInput, runtime, activationHadError) {
+export function advanceMaterializedAgentGraphClientProjection(snapshotInput, inspectionInput, runtime, activationHadError, sampleStartedAt) {
     const projected = projectClientSessionEvent(runtime.event, activationHadError);
-    if (!projected)
+    const output = advanceClientOperatorOutput(inspectionInput.operator.output, runtime.event, runtime.claim.targetRunId, ['completed', 'failed', 'aborted', 'cancelled'].includes(inspectionInput.operator.status), sampleStartedAt, inspectionInput.operator.currentActivation?.activationId);
+    if (!projected && !output)
         return undefined;
     if (snapshotInput.graphId !== runtime.intent.graphId ||
         inspectionInput.graphId !== runtime.intent.graphId ||
@@ -74,21 +77,34 @@ export function advanceMaterializedAgentGraphClientProjection(snapshotInput, ins
         inspectionInput.operator.childSessionId !== runtime.claim.targetSessionId) {
         throw new Error('Agent graph runtime activity does not match its materialized projection');
     }
-    const activity = {
-        recordId: clientRuntimeRecordId(runtime),
-        operatorId: runtime.claim.targetOperatorId,
-        activationId: runtime.claim.targetRunId,
-        eventTime: runtime.event.ts,
-        facets: projected.facets,
-        signals: projected.signals,
-        run: {
-            sessionId: runtime.claim.targetSessionId,
-            agentRunId: runtime.claim.targetRunId,
-            turnId: runtime.claim.targetTurnId,
-        },
-    };
+    const activity = projected
+        ? {
+            recordId: clientRuntimeRecordId(runtime),
+            operatorId: runtime.claim.targetOperatorId,
+            activationId: runtime.claim.targetRunId,
+            eventTime: runtime.event.ts,
+            facets: projected.facets,
+            signals: projected.signals,
+            run: {
+                sessionId: runtime.claim.targetSessionId,
+                agentRunId: runtime.claim.targetRunId,
+                turnId: runtime.claim.targetTurnId,
+            },
+        }
+        : undefined;
     const snapshot = structuredClone(snapshotInput);
     const inspection = structuredClone(inspectionInput);
+    if (output)
+        inspection.operator.output = output;
+    const visibleOperatorIndex = snapshot.operators.findIndex((operator) => operator.operatorId === inspection.operator.operatorId);
+    if (visibleOperatorIndex >= 0 && output) {
+        snapshot.operators[visibleOperatorIndex] = structuredClone(inspection.operator);
+    }
+    if (!projected || !activity) {
+        snapshot.snapshotVersion = clientSnapshotVersion(snapshot);
+        inspection.snapshotVersion = snapshot.snapshotVersion;
+        return { snapshot, operator: inspection };
+    }
     if (snapshot.recentActivity.some((record) => record.recordId === activity.recordId) ||
         inspection.recentRecords.some((record) => record.recordId === activity.recordId)) {
         return undefined;
@@ -178,7 +194,6 @@ export function advanceMaterializedAgentGraphClientProjection(snapshotInput, ins
         .sort(compareClientActivity)
         .slice(-MAX_OPERATOR_INSPECTION_RECORDS);
     inspection.omitted.records = Math.max(0, inspectionRecordCount - inspection.recentRecords.length);
-    const visibleOperatorIndex = snapshot.operators.findIndex((operator) => operator.operatorId === inspection.operator.operatorId);
     if (visibleOperatorIndex >= 0) {
         snapshot.operators[visibleOperatorIndex] = structuredClone(inspection.operator);
     }
@@ -320,6 +335,10 @@ function buildReadModel(input) {
         .map(clientActivity)
         .sort(compareClientActivity);
     const work = schedule.work.map(clientWork);
+    const outputByOperator = new Map((input.observation.projection.operatorOutputs ?? []).map((output) => [
+        output.operatorId,
+        output,
+    ]));
     const operators = input.observation.projection.operators.map((binding) => {
         const provision = provisionByOperator.get(binding.operatorId);
         if (!provision || provision.targetSessionId !== binding.sessionId) {
@@ -336,6 +355,7 @@ function buildReadModel(input) {
         const readiness = allReadiness.slice(0, MAX_OPERATOR_READINESS);
         const state = input.observation.projection.state.operators[binding.operatorId];
         const currentActivation = state?.activations[state.currentActivationId];
+        const output = outputByOperator.get(binding.operatorId);
         const currentClaim = currentActivation
             ? claims.find((claim) => claim.operatorId === binding.operatorId &&
                 claim.run.agentRunId === currentActivation.agentRunId)
@@ -392,6 +412,9 @@ function buildReadModel(input) {
                     },
                 }
                 : {}),
+            ...(currentActivation && output?.activationId === currentActivation.activationId
+                ? { output: clientOperatorOutput(output) }
+                : {}),
         };
     });
     const stoppedTargets = schedule.stoppedTargets.map(clientStoppedTarget);
@@ -432,6 +455,98 @@ function buildReadModel(input) {
         ])),
     };
 }
+function clientOperatorOutput(output) {
+    return {
+        activationId: output.activationId,
+        preview: output.preview,
+        previewTruncated: output.previewTruncated,
+        phase: output.phase,
+        previewUpdatedAt: output.previewUpdatedAt,
+        sourceEventId: output.sourceEventId,
+        ...(output.messageId ? { messageId: output.messageId } : {}),
+        sampleStartedAt: output.sampleStartedAt,
+        ...(output.outputTokens !== undefined ? { outputTokens: output.outputTokens } : {}),
+        ...(output.sampleDurationMs !== undefined ? { sampleDurationMs: output.sampleDurationMs } : {}),
+        ...(output.tokensPerSecond !== undefined ? { tokensPerSecond: output.tokensPerSecond } : {}),
+    };
+}
+function advanceClientOperatorOutput(current, event, activationId, operatorSettled, sampleStartedAt, currentActivationId) {
+    if (currentActivationId && currentActivationId !== activationId)
+        return undefined;
+    if (current?.activationId === activationId && current.sourceEventId === event.id) {
+        return undefined;
+    }
+    const existing = current?.activationId === activationId ? current : undefined;
+    if (existing &&
+        (event.type === 'text_delta' || event.type === 'text_complete') &&
+        event.ts < existing.previewUpdatedAt) {
+        return undefined;
+    }
+    if (event.type === 'text_delta' || event.type === 'text_complete') {
+        const sameMessage = existing?.messageId === event.messageId;
+        if (event.type === 'text_delta' && sameMessage && existing.phase === 'completed') {
+            return undefined;
+        }
+        const append = event.type === 'text_delta' && sameMessage;
+        const discontinuous = event.type === 'text_delta' &&
+            event.startOffset !== undefined &&
+            event.startOffset >
+                (sameMessage && existing && !existing.previewTruncated ? existing.preview.length : 0);
+        const text = append ? foldClientOutputDelta(existing, event) : event.text;
+        const preview = boundClientOutputPreview(text);
+        if (!preview.text)
+            return undefined;
+        return {
+            activationId,
+            preview: preview.text,
+            previewTruncated: preview.truncated || discontinuous || (append && existing.previewTruncated),
+            phase: operatorSettled || existing?.phase === 'completed' ? 'completed' : 'streaming',
+            previewUpdatedAt: event.ts,
+            sourceEventId: event.id,
+            ...(event.messageId ? { messageId: event.messageId } : {}),
+            sampleStartedAt: existing?.sampleStartedAt ?? sampleStartedAt ?? event.ts,
+            ...(existing?.outputTokens !== undefined ? { outputTokens: existing.outputTokens } : {}),
+            ...(existing?.sampleDurationMs !== undefined
+                ? { sampleDurationMs: existing.sampleDurationMs }
+                : {}),
+            ...(existing?.tokensPerSecond !== undefined
+                ? { tokensPerSecond: existing.tokensPerSecond }
+                : {}),
+        };
+    }
+    if (event.type === 'token_usage' && existing) {
+        const sampleDurationMs = Math.max(0, event.ts - existing.sampleStartedAt);
+        return {
+            ...existing,
+            outputTokens: event.output,
+            sampleDurationMs,
+            ...(sampleDurationMs > 0
+                ? { tokensPerSecond: Math.round((event.output * 10_000) / sampleDurationMs) / 10 }
+                : {}),
+        };
+    }
+    if ((event.type === 'complete' || event.type === 'abort') && existing) {
+        return { ...existing, phase: 'completed' };
+    }
+    return undefined;
+}
+function foldClientOutputDelta(existing, event) {
+    if (event.startOffset === undefined || existing.previewTruncated) {
+        return `${existing.preview}${event.text}`;
+    }
+    if (event.startOffset <= existing.preview.length) {
+        return `${existing.preview.slice(0, event.startOffset)}${event.text}`;
+    }
+    return event.text;
+}
+function boundClientOutputPreview(text) {
+    const codePoints = Array.from(text);
+    if (codePoints.length <= AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS) {
+        return { text: codePoints.join(''), truncated: false };
+    }
+    const visible = codePoints.slice(-AGENT_GRAPH_OUTPUT_PREVIEW_MAX_CODE_POINTS);
+    return { text: visible.join(''), truncated: true };
+}
 function operatorStatus(runtimeStatus, readiness, currentRecord) {
     if (runtimeStatus === 'running') {
         return currentRecord?.signals.some((signal) => signal.kind === 'attention')
@@ -884,8 +999,11 @@ function compareClientActivity(a, b) {
     return compareActivityKey(a.eventTime, a.recordId, b.eventTime, b.recordId);
 }
 function clientSnapshotVersion(snapshot) {
-    const { snapshotVersion: _snapshotVersion, terminalHistory: _terminalHistory, ...boundedContent } = snapshot;
-    return stableHash(boundedContent);
+    const { snapshotVersion: _snapshotVersion, terminalHistory: _terminalHistory, operators, ...boundedContent } = snapshot;
+    return stableHash({
+        ...boundedContent,
+        operators: operators.map(({ output: _output, ...operator }) => operator),
+    });
 }
 function normalizeReconciliationFailures(failures) {
     const byWorkId = new Map();

package/node_modules/@maka/runtime/dist/tool-availability.js

@@ -94,6 +94,15 @@ export function toolAvailabilityHash(config) {
 function compareExactString(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
+function searchableToolNames(tools, config) {
+    if (config === undefined)
+        return new Set();
+    return new Set(tools.map(({ name }) => name).filter((name) => !DIRECT_TOOL_NAMES.has(name)));
+}
+/** Returns the synthetic connector names injected by ToolAvailabilityRuntime. */
+export function toolAvailabilityConnectorNames(tools, config) {
+    return searchableToolNames(tools, config).size > 0 ? [TOOL_SEARCH_NAME] : [];
+}
 /**
  * Immutable, backend-scoped bound-tool inventory and MiniSearch index.
  *
@@ -122,9 +131,7 @@ export class ToolAvailabilityRuntime {
         this.toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
         this.activationKeysByName = new Map(tools.map((tool) => [tool.name, toolActivationKey(tool)]));
         const known = new Set(this.toolsByName.keys());
-        const searchable = config === undefined
-            ? new Set()
-            : new Set([...known].filter((name) => !DIRECT_TOOL_NAMES.has(name)));
+        const searchable = searchableToolNames(this.tools, config);
         const claimed = new Set();
         const groups = [];
         for (const group of config?.groups ?? []) {

package/node_modules/@maka/runtime-host/dist/candidate-entry.js

@@ -74,6 +74,21 @@ export async function runExecutionCandidateEntry(argv, entrypointUrl, hooks = {}
         process.exit(candidateStartupFailureExitCode(failure));
     }
     if (result.kind === 'loser') {
+        // Losing the launch election is a normal outcome the replacement loop
+        // relies on, but a silent exit left no trace on disk — during replacement
+        // storms every loss was invisible (issue #5843). Leave the same startup
+        // diagnostic the failure paths write before exiting.
+        if (rootId && startupAttemptId) {
+            await import('./control/startup-diagnostic.js')
+                .then(({ writeCandidateStartupDiagnostic }) => writeCandidateStartupDiagnostic({
+                rootId,
+                startupAttemptId,
+                failure: { reason: 'launch_election_lost' },
+                error: new Error('Lost the Runtime Host launch election: another candidate owns this workspace'),
+                logs: runtimeHostLogBuffer.snapshot(),
+            }))
+                .catch(() => undefined);
+        }
         await launchOwnerGuard?.dispose();
         process.exit(2);
     }