@jungjaehoon/mama-os 0.49.3 → 0.51.0

package/dist/agent/gateway-tool-executor.js

@@ -86,7 +86,10 @@ const obsidian_cli_args_js_1 = require("./obsidian-cli-args.js");
 const wiki_read_js_1 = require("../wiki/wiki-read.js");
 const changes_projection_js_1 = require("../operator/changes-projection.js");
 const task_list_views_js_1 = require("../operator/task-list-views.js");
+const temporal_reconcile_js_1 = require("../operator/temporal-reconcile.js");
 const board_read_views_js_1 = require("../operator/board-read-views.js");
+const owner_action_effects_js_1 = require("../operator/owner-action-effects.js");
+const external_lifecycle_discovery_js_1 = require("../operator/external-lifecycle-discovery.js");
 const read_js_1 = require("../evidence/read.js");
 const private_connector_policy_js_1 = require("../connectors/private-connector-policy.js");
 const member_candidate_store_js_1 = require("../gateways/member-candidate-store.js");
@@ -113,7 +116,7 @@ function bindTemporalContextPacketTask(context, task) {
 function temporalIdentifierRef(value) {
     return `sha256:${(0, crypto_1.createHash)('sha256').update(value).digest('hex')}`;
 }
-function temporalPacketRawSourcesWithinBoundSource(context, sourceRefs, reviewWindow) {
+function temporalPacketRawSourcesWithinBoundSource(context, sourceRefs, reviewWindow, additionalVisible = () => false) {
     const rawRefs = sourceRefs.filter((value) => typeof value === 'object' &&
         value !== null &&
         !Array.isArray(value) &&
@@ -121,29 +124,23 @@ function temporalPacketRawSourcesWithinBoundSource(context, sourceRefs, reviewWi
     if (!context.sourceChannel) {
         return rawRefs.length === 0;
     }
-    const anchorMatches = (ref) => Boolean(context.sourceEventId &&
-        [ref.raw_id, ref.source_id].some((value) => typeof value === 'string' && temporalIdentifierRef(value) === context.sourceEventId));
-    const allWithinBoundChannel = rawRefs.every((ref) => {
-        const eventMatches = reviewWindow !== undefined || !context.sourceEventId || anchorMatches(ref);
-        const channelMatches = !context.sourceChannel ||
-            (typeof ref.connector === 'string' &&
-                typeof ref.channel_id === 'string' &&
-                temporalIdentifierRef(`${ref.connector}:${ref.channel_id}`) === context.sourceChannel);
-        return eventMatches && channelMatches;
-    });
-    return (allWithinBoundChannel &&
-        (reviewWindow === undefined || rawRefs.some((ref) => anchorMatches(ref))));
+    const channelMatches = (ref) => typeof ref.connector === 'string' &&
+        typeof ref.channel_id === 'string' &&
+        temporalIdentifierRef(`${ref.connector}:${ref.channel_id}`) === context.sourceChannel;
+    const anchorMatches = (ref) => channelMatches(ref) &&
+        Boolean(context.sourceEventId &&
+            [ref.raw_id, ref.source_id].some((value) => typeof value === 'string' && temporalIdentifierRef(value) === context.sourceEventId));
+    return (rawRefs.every((ref) => (channelMatches(ref) &&
+        (reviewWindow !== undefined || !context.sourceEventId || anchorMatches(ref))) ||
+        additionalVisible(ref)) &&
+        ((rawRefs.length === 0 && reviewWindow === undefined) ||
+            !context.sourceEventId ||
+            rawRefs.some(anchorMatches)));
 }
-function temporalPacketReferencesBoundSource(context, sourceRefs, reviewWindow) {
-    const hasRawReference = sourceRefs.some((value) => typeof value === 'object' &&
-        value !== null &&
-        !Array.isArray(value) &&
-        value.kind === 'raw');
-    if (context.sourceEventId || context.sourceChannel) {
-        return (hasRawReference &&
-            temporalPacketRawSourcesWithinBoundSource(context, sourceRefs, reviewWindow));
-    }
-    return temporalPacketRawSourcesWithinBoundSource(context, sourceRefs, reviewWindow);
+function temporalPacketReferencesBoundSource(context, sourceRefs, reviewWindow, additionalVisible) {
+    const hasRaw = sourceRefs.some((ref) => typeof ref === 'object' && ref !== null && ref.kind === 'raw');
+    return ((!(context.sourceEventId || context.sourceChannel) || hasRaw) &&
+        temporalPacketRawSourcesWithinBoundSource(context, sourceRefs, reviewWindow, additionalVisible));
 }
 function temporalPacketHasExactReviewWindow(packetJson, reviewWindow) {
     try {
@@ -232,6 +229,7 @@ const TASK_UPDATE_PUBLIC_FIELD_SET = new Set(TASK_UPDATE_PUBLIC_FIELDS);
  */
 const TASK_CREATE_PUBLIC_FIELDS = [
     'title',
+    'creation_key',
     'completion_criteria',
     'status',
     'priority',
@@ -501,6 +499,7 @@ class GatewayToolExecutor {
     telegramGateway = null;
     roleManager;
     privateConnectorPolicy;
+    connectorEventAdapter;
     executionContextStorage = new async_hooks_1.AsyncLocalStorage();
     envelopeEnforcer = new index_js_1.EnvelopeEnforcer();
     channelGrantProvider;
@@ -539,6 +538,95 @@ class GatewayToolExecutor {
     }
     taskLedger = null;
     ownerEventEffectLedger = null;
+    ownerActionEffectLedger = null;
+    createNativeEffectObserver(state) {
+        const ledger = this.ownerActionEffectLedger;
+        if (!ledger || !state?.envelope || !state.modelRunId || state.memberScopeRequired) {
+            return undefined;
+        }
+        const attempt = state.workorderAttemptId === undefined
+            ? null
+            : this.taskLedger?.getWorkOrderById(state.workorderAttemptId);
+        const occurrenceKey = attempt ? `workorder:${attempt.idempotencyKey}` : state.sourceMessageRef;
+        if (!occurrenceKey) {
+            throw new Error('Native effect observation needs an owner occurrence');
+        }
+        const context = {
+            ownerScope: state.agentContext?.principalId ?? 'owner:runtime',
+            occurrenceKey,
+            modelRunId: state.modelRunId,
+            envelopeHash: state.envelope.envelope_hash,
+            ...(attempt ? { workOrderAttemptId: attempt.id } : {}),
+        };
+        if (ledger.hasUnsafeReplayEffects(occurrenceKey)) {
+            throw new types_js_1.AgentError('Owner occurrence needs effect reconciliation before replay', 'CODE_ACT_MUTATION_OUTCOME_UNKNOWN', undefined, false);
+        }
+        const admissionKey = `native-run:${(0, crypto_1.createHash)('sha256').update(context.modelRunId).digest('hex')}`;
+        ledger.begin(context, admissionKey, 'native_run', { admitted: true });
+        let sequence = 0;
+        const pending = new Map();
+        return {
+            started: (name, input) => {
+                const id = typeof input.nativeToolUseId === 'string'
+                    ? input.nativeToolUseId
+                    : `observed:${++sequence}`;
+                const key = `native:${(0, crypto_1.createHash)('sha256').update(`${context.modelRunId}:${id}`).digest('hex')}`;
+                const reservation = ledger.begin(context, key, 'native_tool', { toolName: name });
+                if (reservation.state !== 'execute') {
+                    throw new types_js_1.AgentError('Native effect already observed', 'CODE_ACT_MUTATION_OUTCOME_UNKNOWN', undefined, false);
+                }
+                pending.set(id, { key, name });
+            },
+            settled: (name, id, isError) => {
+                const match = pending.get(id) ?? [...pending.values()].find((entry) => entry.name === name);
+                if (!match) {
+                    // Completion may be the first provider observation after reconnect.
+                    const key = `native:${(0, crypto_1.createHash)('sha256').update(`${context.modelRunId}:${id}`).digest('hex')}`;
+                    ledger.begin(context, key, 'native_tool', { toolName: name });
+                    ledger.markUnknown(context, key, 'native_tool', 'completion observed without matching start');
+                    return;
+                }
+                if (isError) {
+                    ledger.markUnknown(context, match.key, 'native_tool', 'native tool reported failure');
+                }
+                else {
+                    ledger.confirm(context, match.key, 'native_tool', { success: true });
+                }
+                for (const [pendingId, entry] of pending) {
+                    if (entry === match) {
+                        pending.delete(pendingId);
+                    }
+                }
+            },
+            finished: () => {
+                if (pending.size > 0) {
+                    throw new types_js_1.AgentError('Native effects did not settle before final response', 'CODE_ACT_MUTATION_OUTCOME_UNKNOWN', undefined, false);
+                }
+                ledger.confirm(context, admissionKey, 'native_run', { completed: true });
+            },
+            interrupted: () => {
+                ledger.markUnknown(context, admissionKey, 'native_run', 'native turn did not finish cleanly');
+                for (const { key } of pending.values()) {
+                    ledger.markUnknown(context, key, 'native_tool', 'native run interrupted');
+                }
+            },
+        };
+    }
+    setOwnerActionEffectLedger(ledger) {
+        this.ownerActionEffectLedger = ledger;
+    }
+    ownerEffectPort(context) {
+        const ledger = this.ownerActionEffectLedger;
+        if (!ledger) {
+            throw new Error('Owner action effect ledger is not configured');
+        }
+        return {
+            begin: (_batch, key, kind, intent) => ledger.begin(context, key, kind, intent),
+            inspect: (_batch, key, kind) => ledger.inspect(context, key, kind),
+            confirm: (_batch, key, kind, result) => ledger.confirm(context, key, kind, result),
+            markUnknown: (_batch, key, kind, error) => ledger.markUnknown(context, key, kind, error),
+        };
+    }
     setTaskLedger(ledger) {
         this.taskLedger = ledger;
     }
@@ -765,7 +853,10 @@ class GatewayToolExecutor {
     constructor(options = {}) {
         this.channelGrantProvider = options.channelGrantProvider ?? read_js_1.liveBoundaryChannels;
         const privateWorkspaceRoot = (0, path_1.resolve)(process.env.MAMA_WORKSPACE || (0, path_1.join)((0, os_1.homedir)(), '.mama', 'workspace'));
-        this.driveTools = new drive_tools_js_1.DriveToolService({ workspaceRoot: privateWorkspaceRoot });
+        this.driveTools = new drive_tools_js_1.DriveToolService({
+            workspaceRoot: privateWorkspaceRoot,
+            runGws: options.driveGwsRunner,
+        });
         this.imageTranslationTools = new image_translation_tools_js_1.ImageTranslationToolService({
             workspaceRoot: privateWorkspaceRoot,
         });
@@ -794,6 +885,7 @@ class GatewayToolExecutor {
         this.roleManager = (0, role_manager_js_1.getRoleManager)(options.rolesConfig ? { rolesConfig: options.rolesConfig } : undefined);
         this.privateConnectorPolicy =
             options.privateConnectorPolicy ?? DEFAULT_PRIVATE_CONNECTOR_POLICY;
+        this.connectorEventAdapter = options.connectorEventAdapter;
         if (options.mamaApi) {
             this.mamaApi = options.mamaApi;
         }
@@ -1336,6 +1428,75 @@ class GatewayToolExecutor {
         }
         return modelRunId;
     }
+    async requireOwnerActionContext() {
+        const state = this.getExecutionState();
+        const envelope = state.envelope;
+        if (!envelope || !state.modelRunId || state.memberScopeRequired) {
+            throw new types_js_1.AgentError('Owner action requires the current authenticated owner envelope and model run', 'WORKORDER_SUPERSEDED', undefined, false);
+        }
+        const api = await this.initializeMAMAApi();
+        const run = await api.getModelRun?.(state.modelRunId);
+        if (!run || run.status !== 'running' || run.envelope_hash !== envelope.envelope_hash) {
+            throw new Error('Owner action model run is no longer current for this envelope');
+        }
+        const attempt = state.workorderAttemptId === undefined
+            ? null
+            : this.taskLedger?.getWorkOrderById(state.workorderAttemptId);
+        if (state.workorderAttemptId !== undefined &&
+            (!attempt ||
+                attempt.status !== 'in_progress' ||
+                run.input_refs?.workorderAttemptId !== attempt.id)) {
+            throw new Error('Owner action workorder attempt is no longer active');
+        }
+        const occurrenceKey = attempt ? `workorder:${attempt.idempotencyKey}` : state.sourceMessageRef;
+        if (!occurrenceKey) {
+            throw new Error('Owner action is missing its host-issued occurrence identity');
+        }
+        return {
+            ownerScope: state.agentContext?.principalId ?? 'owner:runtime',
+            occurrenceKey,
+            modelRunId: state.modelRunId,
+            envelopeHash: envelope.envelope_hash,
+            ...(attempt ? { workOrderAttemptId: attempt.id } : {}),
+        };
+    }
+    temporalCorroborationVisible = (ref) => {
+        if (typeof ref.connector !== 'string' || typeof ref.channel_id !== 'string') {
+            return false;
+        }
+        return this.currentOwnerPartitionVisibility()({
+            connector: ref.connector,
+            channel: ref.channel_id,
+        });
+    };
+    currentOwnerPartitionVisibility() {
+        const state = this.getExecutionState();
+        if (!state.envelope || state.memberScopeRequired) {
+            throw new Error('Owner source visibility requires an owner envelope');
+        }
+        const channels = (0, read_js_1.narrowGrantToEnvelope)(snapshotChannelGrant(this.channelGrantProvider), {
+            connectors: state.envelope.scope.raw_connectors,
+            scopes: state.envelope.scope.memory_scopes,
+        });
+        return ({ connector, channel }) => channels[connector]?.includes(channel) === true;
+    }
+    async externalCandidateSource(candidateId) {
+        const attemptId = this.getExecutionState().workorderAttemptId;
+        if (attemptId !== undefined &&
+            this.taskLedger?.getWorkOrderById(attemptId)?.workKind === 'board') {
+            await this.requireExternalLifecycleModelRun(attemptId);
+            if (this.getExecutionState().envelope) {
+                const context = await this.requireOwnerActionContext();
+                if (this.taskLedger
+                    .listOwnerActionCandidates(context)
+                    .some((candidate) => candidate.candidateId === candidateId)) {
+                    return { kind: 'owner_run', context };
+                }
+            }
+            return { kind: 'board', attemptId };
+        }
+        return { kind: 'owner_run', context: await this.requireOwnerActionContext() };
+    }
     async beginTraceIfNeeded(ctx, gatewayCallId) {
         if (ctx.modelRunId) {
             const api = await this.initializeMAMAApi();
@@ -1878,9 +2039,9 @@ class GatewayToolExecutor {
                 case 'Bash':
                     return await this.executeBash(input);
                 case 'discord_send':
-                    return await this.executeDiscordSend(input);
+                    return await this.executeOwnerWorkspaceEffect('discord_send', input, () => this.executeDiscordSend(input));
                 case 'slack_send':
-                    return await this.executeSlackSend(input);
+                    return await this.executeOwnerWorkspaceEffect('slack_send', input, () => this.executeSlackSend(input));
                 case 'telegram_send':
                     return await this.executeTelegramSend(input);
                 case 'ocr_image': {
@@ -2106,16 +2267,35 @@ class GatewayToolExecutor {
                     const uploadInput = input;
                     const state = this.getExecutionState();
                     const sourceMessageRef = state.sourceMessageRef;
-                    if (!sourceMessageRef?.startsWith('owner-event:')) {
+                    const legacyOwnerEvent = sourceMessageRef?.startsWith('owner-event:') === true;
+                    if (!legacyOwnerEvent && !this.ownerActionEffectLedger) {
                         return {
                             success: true,
                             result: (0, drive_tools_js_1.asUntrustedDriveEvidence)(await this.driveTools.upload(uploadInput)),
                         };
                     }
-                    const effect = this.requireOwnerEventEffect(uploadInput.effect_key, 'drive_upload');
-                    const ledger = this.requireOwnerEventEffectLedger();
-                    const occurrence = `${sourceMessageRef}:drive:${effect.actionKey}`;
+                    const requestSha256 = (0, crypto_1.createHash)('sha256')
+                        .update(JSON.stringify([
+                        uploadInput.localPath,
+                        uploadInput.folderId,
+                        uploadInput.fileName ?? null,
+                        uploadInput.destinationCapability ?? null,
+                    ]))
+                        .digest('hex');
+                    const context = legacyOwnerEvent ? null : await this.requireOwnerActionContext();
+                    const effect = legacyOwnerEvent
+                        ? this.requireOwnerEventEffect(uploadInput.effect_key, 'drive_upload')
+                        : { batchId: 0, actionKey: `drive:${uploadInput.effect_key ?? requestSha256}` };
+                    const ledger = context
+                        ? this.ownerEffectPort(context)
+                        : this.requireOwnerEventEffectLedger();
+                    const occurrence = context
+                        ? `${context.ownerScope}:${context.occurrenceKey}:drive:${effect.actionKey}`
+                        : `${sourceMessageRef}:drive:${effect.actionKey}`;
                     let reservation = ledger.inspect(effect.batchId, effect.actionKey, 'drive_upload');
+                    if (context && reservation && reservation.intent.requestSha256 !== requestSha256) {
+                        throw new Error('Drive action key was already reserved for a different upload request');
+                    }
                     if (reservation?.state === 'confirmed') {
                         if (!reservation.result) {
                             throw new Error('Confirmed Drive upload is missing its durable result');
@@ -2129,6 +2309,7 @@ class GatewayToolExecutor {
                         reservation = ledger.begin(effect.batchId, effect.actionKey, 'drive_upload', {
                             folderId: preparation.prepared.folderId,
                             fileName: preparation.prepared.fileName,
+                            ...(context ? { requestSha256 } : {}),
                         });
                         if (reservation.state === 'confirmed') {
                             if (!reservation.result) {
@@ -2173,8 +2354,7 @@ class GatewayToolExecutor {
                 case 'os_get_config':
                     return await this.executeGetConfig(input);
                 case 'webchat_send':
-                    return await this.executeWebchatSend(input // session_id omitted: all files use shared outbound dir
-                    );
+                    return await this.executeOwnerWorkspaceEffect('webchat_send', input, () => this.executeWebchatSend(input));
                 // Code-Act sandbox execution
                 case 'code_act':
                     return await this.executeCodeAct(input);
@@ -2296,16 +2476,20 @@ class GatewayToolExecutor {
                     if (!slotsInput || typeof slotsInput !== 'object') {
                         throw new types_js_1.AgentError('report_publish requires slots object', 'TOOL_ERROR', undefined, false);
                     }
-                    if (this.getExecutionState().temporalWorkContext) {
-                        const slotNames = Object.keys(slotsInput);
-                        if (slotNames.length !== 1 ||
-                            slotNames[0] !== 'pipeline' ||
-                            typeof slotsInput.pipeline !== 'string') {
-                            throw new types_js_1.AgentError('Temporal report_publish accepts exactly the host-derived pipeline slot', 'TOOL_ERROR', undefined, false);
-                        }
+                    const basisRevision = input.basis_revision;
+                    if (basisRevision !== undefined &&
+                        basisRevision !== null &&
+                        (typeof basisRevision !== 'string' ||
+                            !basisRevision.trim() ||
+                            basisRevision !== basisRevision.trim())) {
+                        throw new types_js_1.AgentError('report_publish basis_revision must be a canonical task basis from board_read', 'TOOL_ERROR', undefined, false);
                     }
                     if (this.reportPublisher) {
-                        const publication = this.reportPublisher(slotsInput);
+                        const publication = basisRevision === undefined
+                            ? this.reportPublisher(slotsInput)
+                            : this.reportPublisher(slotsInput, {
+                                basisRevision: basisRevision,
+                            });
                         // Backward compatibility: older injected publishers return void
                         // or the exact changed slot array. Production distinguishes slots
                         // accepted as present from slots whose HTML actually changed.
@@ -2632,13 +2816,23 @@ class GatewayToolExecutor {
                 }
                 case 'wiki_read': {
                     const wikiAuthority = this.getExecutionState().wikiTaskRange;
-                    if (!wikiAuthority || wikiAuthority.ownerDate === null) {
-                        throw new types_js_1.AgentError('wiki_read requires a host-issued wiki workorder ownerDate', 'WORKORDER_SUPERSEDED', undefined, false);
-                    }
                     if (!this.obsidianVaultPath) {
                         throw new types_js_1.AgentError('Wiki vault path not configured', 'TOOL_ERROR', undefined, false);
                     }
                     try {
+                        if (!wikiAuthority) {
+                            const readInput = input;
+                            return {
+                                success: true,
+                                ...(0, wiki_read_js_1.readWikiPages)({
+                                    root: this.obsidianVaultPath,
+                                    paths: readInput.paths,
+                                    contentOffset: readInput.content_offset,
+                                    contentLimit: readInput.content_limit,
+                                    contentVersions: readInput.content_versions,
+                                }),
+                            };
+                        }
                         const attemptId = this.getExecutionState().workorderAttemptId;
                         if (!Number.isSafeInteger(attemptId) || attemptId < 1) {
                             throw new Error('wiki_read requires a host-issued workorder attempt');
@@ -2650,7 +2844,7 @@ class GatewayToolExecutor {
                         }
                         const paths = Array.isArray(readInput.paths) ? readInput.paths : [];
                         for (const rawPath of paths) {
-                            const path = (0, wiki_read_js_1.assertAllowedWikiWorkorderPath)(rawPath, wikiAuthority.ownerDate);
+                            const path = (0, wiki_read_js_1.normalizeWikiRelativePath)(rawPath);
                             const key = this.wikiReadCoverageKey(attemptId, path);
                             const prior = this.wikiReadCoverage.get(key);
                             if (requestedOffset === 0) {
@@ -2662,10 +2856,17 @@ class GatewayToolExecutor {
                         }
                         const result = (0, wiki_read_js_1.readWikiPages)({
                             root: this.obsidianVaultPath,
-                            ownerDate: wikiAuthority.ownerDate,
                             paths: readInput.paths,
                             contentOffset: readInput.content_offset,
                             contentLimit: readInput.content_limit,
+                            contentVersions: Object.fromEntries(paths.map((rawPath) => {
+                                const path = (0, wiki_read_js_1.normalizeWikiRelativePath)(rawPath);
+                                return [
+                                    path,
+                                    this.wikiReadCoverage.get(this.wikiReadCoverageKey(attemptId, path))
+                                        ?.contentVersion ?? null,
+                                ];
+                            })),
                         });
                         for (const page of result.pages) {
                             const key = this.wikiReadCoverageKey(attemptId, page.path);
@@ -2941,32 +3142,62 @@ class GatewayToolExecutor {
                         };
                     }
                 }
+                case 'task_external_candidates': {
+                    if (!this.taskLedger) {
+                        throw new Error('Task ledger not configured');
+                    }
+                    const raw = input;
+                    if (!Array.isArray(raw.event_ids) ||
+                        raw.event_ids.length < 1 ||
+                        raw.event_ids.length > 20 ||
+                        raw.event_ids.some((id) => typeof id !== 'string' || !id.trim() || id !== id.trim())) {
+                        throw new Error('task_external_candidates requires 1-20 observed event_ids');
+                    }
+                    const context = await this.requireOwnerActionContext();
+                    const adapter = this.connectorEventAdapter ?? (await getContextPacketLookupAdapter());
+                    const result = (0, external_lifecycle_discovery_js_1.attestOwnerExternalLifecycleCandidates)({
+                        eventIds: raw.event_ids,
+                        context,
+                        ledger: this.taskLedger,
+                        getAdapter: () => adapter,
+                        privateConnectorPolicy: this.privateConnectorPolicy,
+                        rawConnectorScope: this.getExecutionState().envelope.scope.raw_connectors,
+                        isPartitionVisible: this.currentOwnerPartitionVisibility(),
+                    });
+                    return { success: true, ...result };
+                }
                 case 'task_external_bind': {
                     if (!this.taskLedger) {
                         return { success: false, error: 'Task ledger not configured' };
                     }
-                    const state = this.getExecutionState();
-                    const attemptId = state.workorderAttemptId;
-                    if (attemptId === undefined || !Number.isSafeInteger(attemptId) || attemptId <= 0) {
-                        throw new types_js_1.AgentError('task_external_bind requires a trusted claimed board attempt', 'WORKORDER_SUPERSEDED', undefined, false);
-                    }
                     try {
                         (0, external_lifecycle_candidates_js_1.validateExternalLifecycleDecision)('binding', input);
                     }
                     catch (error) {
                         throw new types_js_1.AgentError(error instanceof Error ? error.message : 'task_external_bind input is invalid', 'TOOL_ERROR', error instanceof Error ? error : undefined, false);
                     }
-                    const modelRunId = await this.requireExternalLifecycleModelRun(attemptId);
+                    const source = await this.externalCandidateSource(input.candidate_id);
+                    const attemptId = source.kind === 'board' ? source.attemptId : source.context.workOrderAttemptId;
+                    const modelRunId = source.kind === 'owner_run'
+                        ? source.context.modelRunId
+                        : this.getExecutionState().modelRunId;
                     let candidate;
                     try {
-                        candidate = this.taskLedger.loadBoardCandidate(attemptId, input.candidate_id, 'binding');
+                        candidate = this.taskLedger.loadExternalCandidate(source, input.candidate_id, 'binding');
                     }
                     catch (error) {
                         throw new types_js_1.AgentError(error instanceof Error
                             ? error.message
                             : 'task_external_bind candidate is unavailable', 'WORKORDER_SUPERSEDED', error instanceof Error ? error : undefined, false);
                     }
-                    const receipt = this.taskLedger.applyExternalBindingDecision(attemptId, input, {
+                    if (this.getExecutionState().envelope &&
+                        !this.currentOwnerPartitionVisibility()({
+                            connector: candidate.connector,
+                            channel: candidate.channelPartition,
+                        })) {
+                        throw new Error('External candidate source is no longer visible under the current owner grant');
+                    }
+                    const receipt = this.taskLedger.applyExternalBindingDecision(source, input, {
                         runId: modelRunId,
                         workOrderAttemptId: attemptId,
                         causeEventIds: [candidate.eventId],
@@ -2984,28 +3215,34 @@ class GatewayToolExecutor {
                     if (!this.taskLedger) {
                         return { success: false, error: 'Task ledger not configured' };
                     }
-                    const state = this.getExecutionState();
-                    const attemptId = state.workorderAttemptId;
-                    if (attemptId === undefined || !Number.isSafeInteger(attemptId) || attemptId <= 0) {
-                        throw new types_js_1.AgentError('task_lifecycle_reconcile requires a trusted claimed board attempt', 'WORKORDER_SUPERSEDED', undefined, false);
-                    }
                     try {
                         (0, external_lifecycle_candidates_js_1.validateExternalLifecycleDecision)('lifecycle', input);
                     }
                     catch (error) {
                         throw new types_js_1.AgentError(error instanceof Error ? error.message : 'task_lifecycle_reconcile input is invalid', 'TOOL_ERROR', error instanceof Error ? error : undefined, false);
                     }
-                    const modelRunId = await this.requireExternalLifecycleModelRun(attemptId);
+                    const source = await this.externalCandidateSource(input.candidate_id);
+                    const attemptId = source.kind === 'board' ? source.attemptId : source.context.workOrderAttemptId;
+                    const modelRunId = source.kind === 'owner_run'
+                        ? source.context.modelRunId
+                        : this.getExecutionState().modelRunId;
                     let candidate;
                     try {
-                        candidate = this.taskLedger.loadBoardCandidate(attemptId, input.candidate_id, 'lifecycle');
+                        candidate = this.taskLedger.loadExternalCandidate(source, input.candidate_id, 'lifecycle');
                     }
                     catch (error) {
                         throw new types_js_1.AgentError(error instanceof Error
                             ? error.message
                             : 'task_lifecycle_reconcile candidate is unavailable', 'WORKORDER_SUPERSEDED', error instanceof Error ? error : undefined, false);
                     }
-                    const receipt = this.taskLedger.applyExternalLifecycleDecision(attemptId, input, {
+                    if (this.getExecutionState().envelope &&
+                        !this.currentOwnerPartitionVisibility()({
+                            connector: candidate.connector,
+                            channel: candidate.channelPartition,
+                        })) {
+                        throw new Error('External candidate source is no longer visible under the current owner grant');
+                    }
+                    const receipt = this.taskLedger.applyExternalLifecycleDecision(source, input, {
                         runId: modelRunId,
                         workOrderAttemptId: attemptId,
                         causeEventIds: [candidate.eventId],
@@ -3041,20 +3278,29 @@ class GatewayToolExecutor {
                     if (completionCriteria.trim().length > task_ledger_js_1.TASK_COMPLETION_CRITERIA_MAX_LENGTH) {
                         throw new types_js_1.AgentError(`task_create completion_criteria must be at most ${task_ledger_js_1.TASK_COMPLETION_CRITERIA_MAX_LENGTH} characters`, 'TOOL_ERROR', undefined, false);
                     }
-                    return {
-                        success: true,
-                        task: (0, task_list_views_js_1.serializeTaskToolRecord)(
-                        // The run id comes from trusted execution state, never from the tool call:
-                        // an agent that can name its own run in the effect ledger can sign someone
-                        // else's work with it.
-                        this.taskLedger.create(input, {
-                            runId: this.getExecutionState().modelRunId ?? null,
-                            workOrderAttemptId: this.getExecutionState().workorderAttemptId,
-                            requiresExpectedRevision: this.getExecutionState().workorderAttemptId !== undefined,
-                            causeEventIds: this.getExecutionState().causeEventIds,
-                            causeKind: this.getExecutionState().source === 'operator' ? 'clock' : 'owner_message',
-                        })),
-                    };
+                    const { creation_key: creationKey, ...taskInput } = rawTaskCreate;
+                    const create = () => this.taskLedger.create(taskInput, {
+                        runId: this.getExecutionState().modelRunId ?? null,
+                        workOrderAttemptId: this.getExecutionState().workorderAttemptId,
+                        requiresExpectedRevision: this.getExecutionState().workorderAttemptId !== undefined,
+                        causeEventIds: this.getExecutionState().causeEventIds,
+                        causeKind: this.getExecutionState().source === 'operator' ? 'clock' : 'owner_message',
+                    });
+                    if (this.ownerActionEffectLedger) {
+                        if (typeof creationKey !== 'string' ||
+                            !creationKey.trim() ||
+                            creationKey.length > 200) {
+                            throw new types_js_1.AgentError('task_create requires creation_key: a stable name for this logical task within the occurrence; reuse it on retry.', 'TOOL_ERROR', undefined, false);
+                        }
+                        const context = await this.requireOwnerActionContext();
+                        const receipt = this.ownerActionEffectLedger.atomic(context, `task:${creationKey}`, 'task_create', taskInput, () => ({ taskId: create().id }));
+                        const task = this.taskLedger.getById(Number(receipt.taskId));
+                        if (!task) {
+                            throw new Error('Created task receipt references a missing task');
+                        }
+                        return { success: true, task: (0, task_list_views_js_1.serializeTaskToolRecord)(task) };
+                    }
+                    return { success: true, task: (0, task_list_views_js_1.serializeTaskToolRecord)(create()) };
                 }
                 case 'task_reclassify': {
                     if (!this.taskLedger) {
@@ -3117,9 +3363,6 @@ class GatewayToolExecutor {
                             'Use latest_event for input; responses return latestEvent.', 'TOOL_ERROR', undefined, false);
                     }
                     if (Object.prototype.hasOwnProperty.call(rawTaskUpdate, 'completion_criteria')) {
-                        if (this.getExecutionState().source === 'owner-event') {
-                            throw new types_js_1.AgentError('task_update completion_criteria is unavailable on owner-event turns; full Board maintenance or the owner conversation owns qualification', 'TOOL_ERROR', undefined, false);
-                        }
                         const criteria = rawTaskUpdate.completion_criteria;
                         if (typeof criteria !== 'string' ||
                             criteria.trim().length === 0 ||
@@ -3155,23 +3398,47 @@ class GatewayToolExecutor {
                         }
                         const parsed = JSON.parse(packet.packet_json);
                         const selectedRaw = parsed.selected_evidence?.find((item) => item.ref?.kind === 'raw' && item.ref.raw_id === reviewAnchorRef)?.ref;
+                        if (!selectedRaw) {
+                            return {
+                                success: false,
+                                code: 'review_anchor_not_selected',
+                                error: 'The review anchor is not raw evidence selected in this context packet.',
+                                next_action: 'Read relevant raw evidence progressively and use a context packet that selects its actual raw_id. Do not guess an event ID or retry the same packet.',
+                            };
+                        }
                         const task = this.taskLedger.getById(id);
                         const connector = selectedRaw?.connector;
                         const channelId = selectedRaw?.channel_id;
                         const sourceChannel = typeof connector === 'string' && typeof channelId === 'string'
                             ? `${connector}:${channelId}`
                             : null;
-                        if (!task || !sourceChannel || task.sourceChannel !== sourceChannel) {
-                            throw new types_js_1.AgentError('task_update review anchor is outside the task source boundary', 'TOOL_ERROR', undefined, false);
+                        if (!task || !sourceChannel) {
+                            throw new types_js_1.AgentError('task_update review anchor has no verified source identity', 'TOOL_ERROR', undefined, false);
+                        }
+                        const visible = this.currentOwnerPartitionVisibility();
+                        const taskSourceSeparator = task.sourceChannel?.indexOf(':') ?? -1;
+                        if (!visible({ connector: connector, channel: channelId }) ||
+                            (task.sourceChannel &&
+                                (taskSourceSeparator < 1 ||
+                                    !visible({
+                                        connector: task.sourceChannel.slice(0, taskSourceSeparator),
+                                        channel: task.sourceChannel.slice(taskSourceSeparator + 1),
+                                    })))) {
+                            return {
+                                success: false,
+                                code: 'review_source_not_authorized',
+                                error: 'Current owner grants do not authorize the task source and review evidence source.',
+                            };
                         }
-                        const adapter = (await getContextPacketLookupAdapter());
+                        const adapter = (this.connectorEventAdapter ??
+                            (await getContextPacketLookupAdapter()));
                         const anchor = adapter
                             .prepare(`SELECT source_connector, channel,
                         COALESCE(event_datetime, source_timestamp_ms) AS source_timestamp_ms
                    FROM connector_event_index
                   WHERE event_index_id = ?
                   LIMIT 1`)
-                            .get(reviewAnchorRef);
+                            .all(reviewAnchorRef)[0];
                         if (!anchor ||
                             anchor.source_connector !== connector ||
                             anchor.channel !== channelId ||
@@ -3264,8 +3531,8 @@ class GatewayToolExecutor {
                         (effectInput.outcome === 'deferred'
                             ? Array.isArray(packet.source_refs) &&
                                 packet.source_refs.length > 0 &&
-                                !temporalPacketReferencesBoundSource(context, packet.source_refs, reviewWindow)
-                            : !temporalPacketReferencesBoundSource(context, packet.source_refs, reviewWindow))) {
+                                !temporalPacketReferencesBoundSource(context, packet.source_refs, reviewWindow, this.temporalCorroborationVisible)
+                            : !temporalPacketReferencesBoundSource(context, packet.source_refs, reviewWindow, this.temporalCorroborationVisible))) {
                         throw new types_js_1.AgentError('task_temporal_reconcile context packet is not bound to the active task source', 'TOOL_ERROR', undefined, false);
                     }
                     const evidence = {
@@ -3393,6 +3660,61 @@ class GatewayToolExecutor {
             return { success: false, error: 'Failed to read file: attachment extraction failed' };
         }
     }
+    async executeOwnerWorkspaceEffect(kind, intent, execute) {
+        const ledger = this.ownerActionEffectLedger;
+        if (!ledger) {
+            try {
+                const { effectStarted: _notStarted, ...result } = await execute();
+                return result;
+            }
+            catch (error) {
+                return { success: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        const context = await this.requireOwnerActionContext();
+        const digest = (0, crypto_1.createHash)('sha256').update((0, owner_action_effects_js_1.canonicalOwnerActionJson)(intent)).digest('hex');
+        const actionKey = `${kind}:${digest}`;
+        const reserved = ledger.begin(context, actionKey, kind, { inputSha256: digest });
+        if (reserved.state === 'confirmed') {
+            return {
+                success: true,
+                output: 'This exact action already completed in this occurrence; it was not executed again.',
+            };
+        }
+        if (reserved.state !== 'execute') {
+            throw new types_js_1.AgentError('Prior workspace effect needs reconciliation before replay', 'CODE_ACT_MUTATION_OUTCOME_UNKNOWN', undefined, false);
+        }
+        try {
+            const result = await execute();
+            if (!result.success && result.effectStarted === false) {
+                ledger.releaseUnstarted(context, actionKey, kind);
+                const { effectStarted: _notStarted, ...failure } = result;
+                return failure;
+            }
+            if (!result.success) {
+                throw new Error('Workspace effect returned failure; partial effects may exist');
+            }
+            ledger.confirm(context, actionKey, kind, { success: true });
+            return result;
+        }
+        catch (error) {
+            // A spawn failure proves the child never ran. A nonzero exit does NOT:
+            // a command may write data before exiting with an error.
+            const spawnError = error;
+            if ((kind === 'Bash' || kind === 'obsidian') &&
+                spawnError.code === 'ENOENT' &&
+                typeof spawnError.syscall === 'string' &&
+                spawnError.syscall.startsWith('spawn')) {
+                ledger.releaseUnstarted(context, actionKey, kind);
+                return {
+                    success: false,
+                    error: 'Executable or working directory is unavailable; no process started.',
+                };
+            }
+            ledger.markUnknown(context, actionKey, kind, 'workspace effect did not settle successfully');
+            throw new types_js_1.AgentError('Workspace effect outcome requires reconciliation', 'CODE_ACT_MUTATION_OUTCOME_UNKNOWN', error instanceof Error ? error : undefined, false);
+        }
+    }
     /**
      * Execute Write tool - Write content to a file
      * Checks path permissions based on current AgentContext
@@ -3422,15 +3744,12 @@ class GatewayToolExecutor {
                 return { success: false, error: `Access denied: Can only write files to ${mamaDir}` };
             }
         }
-        try {
+        return this.executeOwnerWorkspaceEffect('Write', { path: (0, path_1.resolve)(expandedPath), content }, async () => {
             const dir = (0, path_1.dirname)(expandedPath);
             (0, fs_1.mkdirSync)(dir, { recursive: true });
             (0, fs_1.writeFileSync)(expandedPath, content, 'utf-8');
             return { success: true };
-        }
-        catch (err) {
-            return { success: false, error: `Failed to write file: ${err}` };
-        }
+        });
     }
     /**
      * Execute Bash tool - Execute bash command
@@ -3545,36 +3864,25 @@ class GatewayToolExecutor {
                 };
             }
         }
-        // Handle restart: deferred restart (agent survives to respond, service restarts after 3s)
-        const restartPattern = /systemctl\s+--user\s+restart\s+mama-os/i;
-        if (restartPattern.test(command)) {
-            const child = (0, child_process_1.spawn)('bash', ['-c', 'sleep 3 && systemctl --user restart mama-os'], {
-                detached: true,
-                stdio: 'ignore',
-            });
-            child.unref();
-            return {
-                success: true,
-                output: 'mama-os restart will execute in 3 seconds. Current session will be terminated.',
-            };
-        }
-        try {
+        return this.executeOwnerWorkspaceEffect('Bash', { command, cwd: (0, path_1.resolve)(cwd) }, async () => {
+            // A deferred restart is still a non-replayable shell effect.
+            const restartPattern = /systemctl\s+--user\s+restart\s+mama-os/i;
+            if (restartPattern.test(command)) {
+                const child = (0, child_process_1.spawn)('bash', ['-c', 'sleep 3 && systemctl --user restart mama-os'], {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+                child.unref();
+                return { success: true, output: 'mama-os restart will execute in 3 seconds.' };
+            }
             const output = (0, child_process_1.execSync)(command, {
-                cwd: workdir || process.env.MAMA_WORKSPACE || (0, path_1.join)((0, os_1.homedir)(), '.mama', 'workspace'),
+                cwd,
                 encoding: 'utf-8',
                 maxBuffer: 10 * 1024 * 1024,
                 timeout: 60000,
             });
             return { success: true, output };
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: `Command failed: ${err.message}`,
-                output: err.stdout || err.stderr,
-            };
-        }
+        });
     }
     /**
      * Execute discord_send tool - Send message/file to Discord channel
@@ -3583,10 +3891,10 @@ class GatewayToolExecutor {
     async executeDiscordSend(input) {
         const { channel_id, message, image_path, file_path } = input;
         if (!channel_id) {
-            return { success: false, error: 'channel_id is required' };
+            return { success: false, effectStarted: false, error: 'channel_id is required' };
         }
         if (!this.discordGateway) {
-            return { success: false, error: 'Discord gateway not configured' };
+            return { success: false, effectStarted: false, error: 'Discord gateway not configured' };
         }
         try {
             // file_path takes precedence, fallback to image_path for backwards compatibility
@@ -3598,7 +3906,11 @@ class GatewayToolExecutor {
                 await this.discordGateway.sendMessage(channel_id, message);
             }
             else {
-                return { success: false, error: 'Either message, file_path, or image_path is required' };
+                return {
+                    success: false,
+                    effectStarted: false,
+                    error: 'Either message, file_path, or image_path is required',
+                };
             }
             return { success: true };
         }
@@ -3612,10 +3924,10 @@ class GatewayToolExecutor {
     async executeSlackSend(input) {
         const { channel_id, message, file_path } = input;
         if (!channel_id) {
-            return { success: false, error: 'channel_id is required' };
+            return { success: false, effectStarted: false, error: 'channel_id is required' };
         }
         if (!this.slackGateway) {
-            return { success: false, error: 'Slack gateway not configured' };
+            return { success: false, effectStarted: false, error: 'Slack gateway not configured' };
         }
         try {
             if (file_path) {
@@ -3625,7 +3937,11 @@ class GatewayToolExecutor {
                 await this.slackGateway.sendMessage(channel_id, message);
             }
             else {
-                return { success: false, error: 'Either message or file_path is required' };
+                return {
+                    success: false,
+                    effectStarted: false,
+                    error: 'Either message or file_path is required',
+                };
             }
             return { success: true };
         }
@@ -3645,7 +3961,8 @@ class GatewayToolExecutor {
             return { success: false, error: 'Telegram gateway not configured' };
         }
         const sourceMessageRef = this.getExecutionState().sourceMessageRef;
-        const ownerEvent = sourceMessageRef?.startsWith('owner-event:') === true;
+        const legacyOwnerEvent = sourceMessageRef?.startsWith('owner-event:') === true;
+        const ownerEvent = legacyOwnerEvent || this.ownerActionEffectLedger !== null;
         let ownerEffect = null;
         let ownerLedger = null;
         let ownerIntent = null;
@@ -3655,9 +3972,27 @@ class GatewayToolExecutor {
         //                      `-> error/missing receipt -> unknown -> reconcile-only
         try {
             if (ownerEvent) {
-                ownerEffect = this.requireOwnerEventEffect(delivery_key, 'telegram_send');
-                ownerLedger = this.requireOwnerEventEffectLedger();
-                idempotencyKey = `${sourceMessageRef}:telegram:${delivery_key}`;
+                if (legacyOwnerEvent) {
+                    ownerEffect = this.requireOwnerEventEffect(delivery_key, 'telegram_send');
+                    ownerLedger = this.requireOwnerEventEffectLedger();
+                    idempotencyKey = `${sourceMessageRef}:telegram:${delivery_key}`;
+                }
+                else {
+                    const context = await this.requireOwnerActionContext();
+                    const identity = [
+                        sourceMessageRef ?? context.occurrenceKey,
+                        chat_id,
+                        message ?? null,
+                        file_path ?? null,
+                        sticker_emotion ?? null,
+                    ];
+                    if (delivery_key !== undefined) {
+                        identity.push(delivery_key);
+                    }
+                    idempotencyKey = (0, crypto_1.createHash)('sha256').update(JSON.stringify(identity)).digest('hex');
+                    ownerEffect = { batchId: 0, actionKey: `telegram:${delivery_key ?? idempotencyKey}` };
+                    ownerLedger = this.ownerEffectPort(context);
+                }
                 const existing = ownerLedger.inspect(ownerEffect.batchId, ownerEffect.actionKey, 'telegram_send');
                 if (existing && !(0, owner_event_effects_js_1.isOwnerEventTelegramIntentV1)(existing.intent)) {
                     return existing.state === 'confirmed'
@@ -3679,9 +4014,20 @@ class GatewayToolExecutor {
                 if (reservation.state === 'confirmed')
                     return { success: true };
                 if (reservation.state === 'reconcile') {
+                    const variants = ownerIntent.variant === 'image' ? ['image', 'file'] : [ownerIntent.variant];
+                    for (const variant of variants) {
+                        const receipt = this.telegramGateway.readOutboundDeliveryReceipt?.(idempotencyKey, variant);
+                        if (isExactTelegramDeliveryReceipt(receipt, idempotencyKey, variant)) {
+                            ownerLedger.confirm(ownerEffect.batchId, ownerEffect.actionKey, 'telegram_send', {
+                                version: 1,
+                                ...receipt,
+                            });
+                            return { success: true };
+                        }
+                    }
                     return {
                         success: false,
-                        error: 'owner-event Telegram effect is reconcile-only; automatic replay is disabled',
+                        error: 'Telegram delivery outcome is unconfirmed; reconcile the existing delivery before sending again.',
                     };
                 }
             }
@@ -3895,11 +4241,14 @@ class GatewayToolExecutor {
     async executeWebchatSend(input) {
         const { message, file_path } = input;
         if (!message && !file_path) {
-            return { success: false, error: 'Either message or file_path is required' };
+            return {
+                success: false,
+                effectStarted: false,
+                error: 'Either message or file_path is required',
+            };
         }
         try {
             const outboundDir = (0, path_1.join)((0, os_1.homedir)(), '.mama', 'workspace', 'media', 'outbound');
-            (0, fs_1.mkdirSync)(outboundDir, { recursive: true });
             if (file_path) {
                 // Expand ~ to home directory
                 const homeDir = (0, os_1.homedir)();
@@ -3909,7 +4258,7 @@ class GatewayToolExecutor {
                 // Check path permission based on role
                 const pathPermission = this.checkPathPermission(expandedPath);
                 if (!pathPermission.allowed) {
-                    return { success: false, error: pathPermission.error };
+                    return { success: false, effectStarted: false, error: pathPermission.error };
                 }
                 // Fallback security for contexts without path restrictions:
                 // Only allow reading from ~/.mama/ directory
@@ -3922,17 +4271,19 @@ class GatewayToolExecutor {
                     if (rel.startsWith('..') || (0, path_1.isAbsolute)(rel)) {
                         return {
                             success: false,
+                            effectStarted: false,
                             error: `Access denied: Can only copy files from ${mamaDir}`,
                         };
                     }
                 }
                 if (!(0, fs_1.existsSync)(expandedPath)) {
-                    return { success: false, error: `File not found: ${expandedPath}` };
+                    return { success: false, effectStarted: false, error: `File not found: ${expandedPath}` };
                 }
                 // Copy file to outbound directory with timestamp prefix
                 const baseName = (0, path_1.basename)(expandedPath) || 'file';
                 const outName = `${Date.now()}_${baseName}`;
                 const outPath = (0, path_1.join)(outboundDir, outName);
+                (0, fs_1.mkdirSync)(outboundDir, { recursive: true });
                 (0, fs_1.copyFileSync)(expandedPath, outPath);
                 const viewerPath = `~/.mama/workspace/media/outbound/${outName}`;
                 return {
@@ -3956,10 +4307,8 @@ class GatewayToolExecutor {
     }
     /**
      * schedule_upcoming (M8 P4): read the calendar connector's raw store and
-     * return events in [now, now+days] plus a compact text digest. Lazy readonly
-     * open (operator-handler pattern); prefers metadata JSON start when present.
-     * v1 limits (documented in the tool description): no recurrence expansion,
-     * no cancellation tracking.
+     * return intervals overlapping [now, now+days] plus a compact text digest.
+     * Reads a bounded page from the local snapshot and never calls the upstream API.
      */
     scheduleDb = null;
     executeScheduleUpcoming(input) {
@@ -3978,17 +4327,178 @@ class GatewayToolExecutor {
             this.scheduleDb = new sqlite_js_1.default(dbPath);
             this.scheduleDb.prepare('PRAGMA busy_timeout = 5000').get();
         }
-        const now = Date.now();
+        let offset = 0;
+        let now = Date.now();
+        let cursorReadVersion;
+        if (input.cursor) {
+            try {
+                const decoded = JSON.parse(Buffer.from(input.cursor, 'base64url').toString('utf8'));
+                if (!Number.isInteger(decoded.offset) ||
+                    typeof decoded.offset !== 'number' ||
+                    decoded.offset < 1 ||
+                    decoded.days !== days ||
+                    typeof decoded.now !== 'number' ||
+                    typeof decoded.readVersion !== 'string') {
+                    throw new Error('invalid fields');
+                }
+                offset = decoded.offset;
+                now = decoded.now;
+                cursorReadVersion = decoded.readVersion;
+            }
+            catch {
+                return { success: false, error: 'Invalid schedule cursor; restart from page one' };
+            }
+        }
         const until = now + days * 86_400_000;
-        let rows;
         try {
-            rows = this.scheduleDb
-                .prepare(`SELECT source_id, channel, content, timestamp, metadata
-           FROM raw_items
-           WHERE timestamp >= ? AND timestamp <= ?
-           ORDER BY timestamp ASC
-           LIMIT 50`)
-                .all(now, until);
+            const readSnapshot = this.scheduleDb.transaction(() => {
+                const latestRows = this.scheduleDb.prepare(`WITH ranked AS (
+               SELECT id, source_id, channel, content, timestamp, metadata, source_cursor, created_at,
+                      ROW_NUMBER() OVER (
+                        PARTITION BY COALESCE(json_extract(metadata, '$.eventId'), source_id)
+                        ORDER BY CASE
+                                   WHEN json_extract(metadata, '$.eventId') IS NOT NULL THEN 1
+                                   ELSE 0
+                                 END DESC,
+                                 COALESCE((julianday(source_cursor) - 2440587.5) * 86400000,
+                                          (julianday(json_extract(metadata, '$.observedAt')) - 2440587.5) * 86400000,
+                                          created_at) DESC,
+                                 id DESC
+                      ) AS observation_rank
+               FROM raw_items
+               WHERE source = 'calendar'
+             )
+             SELECT id, source_id, channel, content, timestamp, metadata, source_cursor, created_at
+             FROM ranked
+             WHERE observation_rank = 1`).all();
+                const selected = latestRows.flatMap((row) => {
+                    let metadata = {};
+                    try {
+                        metadata = row.metadata ? JSON.parse(row.metadata) : {};
+                    }
+                    catch {
+                        metadata = {};
+                    }
+                    const metaStart = metadata.start ?? metadata.startTime ?? metadata.start_time;
+                    const metaEnd = metadata.end ?? metadata.endTime ?? metadata.end_time;
+                    const allDay = metadata.allDay === true;
+                    const timeZone = typeof metadata.timeZone === 'string' ? metadata.timeZone : 'UTC';
+                    // Contain a bad all-day date to this row: startOfTaskDate throws on an unresolvable value,
+                    // and inside flatMap that would abort the whole schedule_upcoming read and clear scheduleDb.
+                    // NaN lets the finite-number guard below skip only this row.
+                    const dayStart = (value) => {
+                        try {
+                            return (0, temporal_reconcile_js_1.startOfTaskDate)(value, null, timeZone);
+                        }
+                        catch {
+                            return Number.NaN;
+                        }
+                    };
+                    const startMs = allDay && typeof metaStart === 'string'
+                        ? dayStart(metaStart)
+                        : typeof metaStart === 'string' || typeof metaStart === 'number'
+                            ? new Date(metaStart).getTime()
+                            : row.timestamp;
+                    const endMs = allDay && typeof metaEnd === 'string'
+                        ? dayStart(metaEnd)
+                        : typeof metaEnd === 'string' || typeof metaEnd === 'number'
+                            ? new Date(metaEnd).getTime()
+                            : startMs;
+                    if (metadata.status === 'cancelled' ||
+                        !Number.isFinite(startMs) ||
+                        !Number.isFinite(endMs) ||
+                        startMs > until ||
+                        endMs <= now) {
+                        return [];
+                    }
+                    const eventId = typeof metadata.eventId === 'string' ? metadata.eventId : row.source_id;
+                    const observedAt = typeof row.source_cursor === 'string' && Number.isFinite(Date.parse(row.source_cursor))
+                        ? row.source_cursor
+                        : typeof metadata.observedAt === 'string' &&
+                            Number.isFinite(Date.parse(metadata.observedAt))
+                            ? metadata.observedAt
+                            : null;
+                    const event = {
+                        sourceId: eventId,
+                        title: typeof metadata.summary === 'string'
+                            ? metadata.summary.slice(0, 120)
+                            : ((row.content ?? '').split('\n')[0]?.slice(0, 120) ?? ''),
+                        start: new Date(Number.isFinite(startMs) ? startMs : row.timestamp).toISOString(),
+                        end: typeof metaEnd === 'string' ? metaEnd : null,
+                        status: typeof metadata.status === 'string' ? metadata.status : 'unknown',
+                        channel: row.channel,
+                        ...(allDay && typeof metaStart === 'string' && typeof metaEnd === 'string'
+                            ? {
+                                allDay: true,
+                                startDate: metaStart,
+                                endDateExclusive: metaEnd,
+                                timeZone,
+                            }
+                            : {}),
+                    };
+                    return [{ row, event, observedAt, startMs }];
+                });
+                selected.sort((left, right) => left.startMs - right.startMs || left.event.sourceId.localeCompare(right.event.sourceId));
+                const readVersion = (0, crypto_1.createHash)('sha256')
+                    .update(JSON.stringify(selected.map(({ row, event }) => ({
+                    id: row.id,
+                    sourceId: row.source_id,
+                    content: row.content,
+                    metadata: row.metadata,
+                    sourceCursor: row.source_cursor,
+                    timestamp: row.timestamp,
+                    event,
+                }))))
+                    .digest('hex');
+                const observedTimes = selected
+                    .map(({ observedAt }) => (observedAt === null ? Number.NaN : Date.parse(observedAt)))
+                    .filter(Number.isFinite);
+                const insertedTimes = selected.map(({ row }) => row.created_at).filter(Number.isFinite);
+                return {
+                    total: selected.length,
+                    rows: selected.slice(offset, offset + 50),
+                    readVersion,
+                    observedAt: observedTimes.length > 0 ? Math.max(...observedTimes) : null,
+                    insertedAt: insertedTimes.length > 0 ? Math.max(...insertedTimes) : null,
+                };
+            })();
+            if (cursorReadVersion && cursorReadVersion !== readSnapshot.readVersion) {
+                return { success: false, error: 'Schedule snapshot changed; restart from page one' };
+            }
+            const events = readSnapshot.rows.map(({ event }) => event);
+            const nextOffset = offset + events.length;
+            const nextCursor = nextOffset < readSnapshot.total
+                ? Buffer.from(JSON.stringify({
+                    offset: nextOffset,
+                    days,
+                    now,
+                    readVersion: readSnapshot.readVersion,
+                }), 'utf8').toString('base64url')
+                : null;
+            const text = events.length === 0
+                ? `(no calendar events in the next ${days} days)`
+                : events
+                    .map((event) => `- ${event.start.slice(0, 16)} ${event.title} (${event.channel})`)
+                    .join('\n');
+            return {
+                success: true,
+                events,
+                text,
+                total: readSnapshot.total,
+                returned: events.length,
+                nextCursor,
+                observedAt: readSnapshot.observedAt === null ? null : new Date(readSnapshot.observedAt).toISOString(),
+                insertedAt: readSnapshot.insertedAt === null ? null : new Date(readSnapshot.insertedAt).toISOString(),
+                cacheAgeMs: readSnapshot.observedAt === null
+                    ? null
+                    : Math.max(0, Date.now() - readSnapshot.observedAt),
+                readVersion: readSnapshot.readVersion,
+                coverage: {
+                    complete: nextCursor === null,
+                    source: 'local_snapshot',
+                    upstreamComplete: 'unknown',
+                },
+            };
         }
         catch (err) {
             // Corrupt/locked store or missing table: fail closed with a readable
@@ -3999,30 +4509,6 @@ class GatewayToolExecutor {
                 error: `Calendar raw store unreadable: ${err instanceof Error ? err.message : String(err)}`,
             };
         }
-        const events = rows.map((row) => {
-            let start = row.timestamp;
-            try {
-                const meta = row.metadata ? JSON.parse(row.metadata) : null;
-                const metaStart = meta?.start ?? meta?.startTime ?? meta?.start_time;
-                if (typeof metaStart === 'string' || typeof metaStart === 'number') {
-                    const parsed = new Date(metaStart).getTime();
-                    if (Number.isFinite(parsed))
-                        start = parsed;
-                }
-            }
-            catch {
-                /* metadata is best-effort */
-            }
-            return {
-                title: (row.content ?? '').split('\n')[0]?.slice(0, 120) ?? '',
-                start: new Date(start).toISOString(),
-                channel: row.channel,
-            };
-        });
-        const text = events.length === 0
-            ? `(no calendar events in the next ${days} days)`
-            : events.map((e) => `- ${e.start.slice(0, 16)} ${e.title} (${e.channel})`).join('\n');
-        return { success: true, events, text };
     }
     /**
      * Execute Obsidian CLI command on the wiki vault.
@@ -4063,28 +4549,45 @@ class GatewayToolExecutor {
         catch (error) {
             throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Invalid Obsidian CLI arguments', 'TOOL_ERROR', undefined, false);
         }
-        try {
+        const invoke = async () => {
             const { stdout } = await execFileAsync('obsidian', cliArgs, {
                 timeout: 15000,
                 encoding: 'utf-8',
                 maxBuffer: 1024 * 1024,
             });
-            return {
-                success: true,
-                data: { output: stdout.trim() },
-            };
+            return { success: true, output: stdout.trim() };
+        };
+        const readCommands = new Set([
+            'read',
+            'daily:read',
+            'search',
+            'search:context',
+            'files',
+            'folders',
+            'vault',
+            'vaults',
+            'links',
+            'backlinks',
+            'properties',
+            'property:read',
+            'aliases',
+            'tags',
+        ]);
+        try {
+            const result = readCommands.has(command)
+                ? await invoke()
+                : await this.executeOwnerWorkspaceEffect('obsidian', { command, args: args ?? {}, vault: this.obsidianVaultPath }, invoke);
+            return result.success
+                ? { success: true, data: { output: result.output } }
+                : result;
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg.includes('not enabled') || msg.includes('ENOENT') || msg.includes('not running')) {
-                return {
-                    success: false,
-                    error: 'Obsidian CLI unavailable (app not running). Use wiki_publish fallback.',
-                };
+        catch (error) {
+            if (error instanceof types_js_1.AgentError) {
+                throw error;
             }
             return {
                 success: false,
-                error: `Obsidian CLI error: ${msg.substring(0, 500)}`,
+                error: 'Obsidian CLI unavailable or command failed; inspect the configured vault before retrying.',
             };
         }
     }
@@ -4461,7 +4964,9 @@ class GatewayToolExecutor {
             // prefix and causeEventIds: the agent never restates what the host knows.
             if (temporalContext && this.taskLedger) {
                 const boundTask = this.taskLedger.getById(temporalContext.taskId);
-                const rawChannel = boundTask?.sourceChannel ?? null;
+                const rawChannel = (boundTask?.status === 'review'
+                    ? (boundTask.reviewAnchorSourceChannel ?? boundTask.sourceChannel)
+                    : boundTask?.sourceChannel) ?? null;
                 // Trimmed: a whitespace-only event id is truthy but fails ref
                 // normalization downstream - which would fail the WHOLE compile,
                 // exactly what "strictly additive" forbids.
@@ -4528,7 +5033,7 @@ class GatewayToolExecutor {
                     : undefined,
             });
             if (temporalContext &&
-                !temporalPacketRawSourcesWithinBoundSource(temporalContext, result.packet.source_refs, reviewWindow)) {
+                !temporalPacketRawSourcesWithinBoundSource(temporalContext, result.packet.source_refs, reviewWindow, this.temporalCorroborationVisible)) {
                 throw new Error('context_compile packet exceeds the active temporal task source');
             }
             if (wikiAuthority) {