@jungjaehoon/mama-os 0.49.3 → 0.50.0

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

@@ -87,6 +87,8 @@ 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 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 +115,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 +123,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 +228,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 +498,7 @@ class GatewayToolExecutor {
     telegramGateway = null;
     roleManager;
     privateConnectorPolicy;
+    connectorEventAdapter;
     executionContextStorage = new async_hooks_1.AsyncLocalStorage();
     envelopeEnforcer = new index_js_1.EnvelopeEnforcer();
     channelGrantProvider;
@@ -539,6 +537,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 +852,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 +884,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 +1427,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 +2038,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 +2266,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 +2308,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 +2353,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 +2475,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 +2815,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 +2843,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 +2855,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 +3141,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 +3214,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 +3277,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 +3362,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 +3397,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 +3530,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 +3659,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 +3743,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 +3863,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 +3890,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 +3905,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 +3923,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 +3936,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 +3960,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 +3971,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 +4013,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 +4240,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 +4257,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 +4270,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 {
@@ -4063,28 +4413,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 +4828,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 +4897,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) {