@jungjaehoon/mama-os 0.20.0 → 0.21.0

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

@@ -54,6 +54,7 @@ const os_1 = require("os");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
+const mama_core_1 = require("@jungjaehoon/mama-core");
 const security_monitor_js_1 = require("../security/security-monitor.js");
 const scope_context_js_1 = require("../memory/scope-context.js");
 const types_js_1 = require("./types.js");
@@ -67,6 +68,7 @@ const managed_agent_runtime_sync_js_1 = require("./managed-agent-runtime-sync.js
 const managed_agent_validation_js_1 = require("./managed-agent-validation.js");
 const delegation_executor_js_1 = require("./delegation-executor.js");
 const index_js_1 = require("../envelope/index.js");
+const wiki_publish_adapter_js_1 = require("../wiki-artifacts/wiki-publish-adapter.js");
 const { DebugLogger } = debugLogger;
 const securityLogger = new DebugLogger('SecurityAudit');
 const TRUTHY_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
@@ -79,24 +81,153 @@ const AGENT_DETAIL_TABS = new Set([
     'validation',
     'history',
 ]);
+const RECALL_TEXT_REDACTION_PATTERNS = [
+    /MAMA_SYNTHETIC_[A-Z0-9_]+_DO_NOT_LEAK/g,
+    /synthetic:\/\/raw[^\s"']*/g,
+    /raw:[^\s"']*/g,
+    /\bhttps?:\/\/[^\s"'<>()]+/gi,
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi,
+    /\b(?:Bearer|Token|Authorization)\s*[:=]?\s*[A-Za-z0-9._~+/=-]{8,}/gi,
+    /\b(?:api[_-]?key|token|secret|password)\s*[:=]\s*[^\s"']{8,}/gi,
+    /(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{8,}\b/g,
+    /xox[baprs]-[A-Za-z0-9-]{10,}\b/g,
+    /sk-[A-Za-z0-9_-]{20,}\b/g,
+    /\b[CU][A-Z0-9]{8,}\b/g,
+    /\b[0-9]{17,20}\b/g,
+    /(?:\/Users|\/home|\/tmp)\/[^\s"']*/g,
+    /[A-Za-z]:\\Users\\[^\s"']*/g,
+];
+const MAX_RECALL_TEXT_LENGTH = 280;
+const RECALL_TEXT_REDACTION_SCAN_LIMIT = MAX_RECALL_TEXT_LENGTH + 2048;
 const managedAgentMutationTails = new Map();
 const MEMORY_SCOPE_AUDIT_TOOLS = new Set([
     'mama_save',
     'mama_search',
     'mama_recall',
+    'context_compile',
     'mama_update',
     'mama_add',
     'mama_ingest',
 ]);
 const MEMORY_READ_PERMISSION_BEFORE_ENVELOPE_TOOLS = new Set([
+    'mama_save',
     'mama_search',
     'mama_recall',
+    'context_compile',
 ]);
 const ENVELOPE_REQUIRED_SURFACES = new Set([
     'model_tool',
     'reactive_internal',
     'code_act',
 ]);
+class ContextPacketProvenanceError extends Error {
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function stringField(record, field) {
+    const value = record[field];
+    return typeof value === 'string' ? value : undefined;
+}
+function numberField(record, field) {
+    const value = record[field];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function sanitizeRecallText(value) {
+    if (!value) {
+        return undefined;
+    }
+    let sanitized = value.length > RECALL_TEXT_REDACTION_SCAN_LIMIT
+        ? value.slice(0, RECALL_TEXT_REDACTION_SCAN_LIMIT)
+        : value;
+    for (const pattern of RECALL_TEXT_REDACTION_PATTERNS) {
+        sanitized = sanitized.replace(pattern, '[redacted]');
+    }
+    const wasTruncated = value.length > MAX_RECALL_TEXT_LENGTH || sanitized.length > MAX_RECALL_TEXT_LENGTH;
+    if (sanitized.length > MAX_RECALL_TEXT_LENGTH) {
+        sanitized = sanitized.slice(0, MAX_RECALL_TEXT_LENGTH);
+    }
+    if (wasTruncated) {
+        sanitized = `${sanitized} [truncated]`;
+    }
+    return sanitized;
+}
+function sanitizeRecallMemory(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const safe = {};
+    const topic = sanitizeRecallText(stringField(record, 'topic'));
+    const kind = sanitizeRecallText(stringField(record, 'kind'));
+    const summary = sanitizeRecallText(stringField(record, 'summary'));
+    const status = sanitizeRecallText(stringField(record, 'status'));
+    const confidence = numberField(record, 'confidence');
+    if (topic) {
+        safe.topic = topic;
+    }
+    if (kind) {
+        safe.kind = kind;
+    }
+    if (summary) {
+        safe.summary = summary;
+    }
+    if (status) {
+        safe.status = status;
+    }
+    if (confidence !== undefined) {
+        safe.confidence = confidence;
+    }
+    return Object.keys(safe).length > 0 ? safe : null;
+}
+function sanitizeRecallMemories(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((memory) => sanitizeRecallMemory(memory))
+        .filter((memory) => memory !== null);
+}
+function sanitizeProfileEvidence(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => {
+        const record = asRecord(item);
+        if (!record) {
+            return null;
+        }
+        const evidence = {};
+        const topic = sanitizeRecallText(stringField(record, 'topic'));
+        if (topic) {
+            evidence.topic = topic;
+        }
+        return Object.keys(evidence).length > 0 ? evidence : null;
+    })
+        .filter((evidence) => evidence !== null);
+}
+function sanitizeMamaRecallBundle(bundle) {
+    const record = asRecord(bundle) ?? {};
+    const profile = asRecord(record.profile) ?? {};
+    const graphContext = asRecord(record.graph_context) ?? {};
+    const edges = Array.isArray(graphContext.edges) ? graphContext.edges : [];
+    return {
+        profile: {
+            static: sanitizeRecallMemories(profile.static),
+            dynamic: sanitizeRecallMemories(profile.dynamic),
+            evidence: sanitizeProfileEvidence(profile.evidence),
+        },
+        memories: sanitizeRecallMemories(record.memories),
+        graph_context: {
+            primary: sanitizeRecallMemories(graphContext.primary),
+            expanded: sanitizeRecallMemories(graphContext.expanded),
+            edge_count: edges.length,
+        },
+    };
+}
 async function withManagedAgentMutationLock(agentId, fn) {
     const previous = managedAgentMutationTails.get(agentId) ?? Promise.resolve();
     let release;
@@ -147,6 +278,7 @@ class GatewayToolExecutor {
     envelopeEnforcer = new index_js_1.EnvelopeEnforcer();
     envelopeIssuanceMode;
     metricsStore;
+    contextCompileService;
     currentContext = null;
     memoryAgentProcessManager = null;
     agentProcessManager = null;
@@ -157,9 +289,12 @@ class GatewayToolExecutor {
     disallowedGatewayTools = new Set();
     reportPublisher = null;
     wikiPublisher = null;
+    wikiPublishAdapter = null;
     obsidianVaultPath = null;
-    setObsidianVaultPath(vaultPath) {
+    obsidianVaultName = null;
+    setObsidianVaultPath(vaultPath, vaultName) {
         this.obsidianVaultPath = vaultPath;
+        this.obsidianVaultName = vaultName ?? null;
     }
     agentEventBus = null;
     setAgentEventBus(bus) {
@@ -387,6 +522,9 @@ class GatewayToolExecutor {
     setWikiPublisher(fn) {
         this.wikiPublisher = fn;
     }
+    setWikiPublishAdapter(adapter) {
+        this.wikiPublishAdapter = adapter;
+    }
     /** Check if a memory agent is available for routing memory writes. */
     hasMemoryAgent() {
         return this.memoryAgentProcessManager !== null;
@@ -423,6 +561,8 @@ class GatewayToolExecutor {
         this.sessionStore = options.sessionStore;
         this.envelopeIssuanceMode = options.envelopeIssuanceMode ?? 'enabled';
         this.metricsStore = options.metricsStore ?? null;
+        this.contextCompileService = options.contextCompileService;
+        this.wikiPublishAdapter = options.wikiPublishAdapter ?? null;
         this.browserTool = (0, browser_tool_js_1.getBrowserTool)({
             screenshotDir: (0, path_1.join)(process.env.HOME || '', '.mama', 'workspace', 'media', 'outbound'),
         });
@@ -474,6 +614,9 @@ class GatewayToolExecutor {
     setTelegramGateway(gateway) {
         this.telegramGateway = gateway;
     }
+    setContextCompileService(service) {
+        this.contextCompileService = service;
+    }
     /**
      * Initialize the MAMA API by importing from mcp-server package
      * Called lazily on first tool execution if not provided in constructor
@@ -818,6 +961,9 @@ class GatewayToolExecutor {
             return { requestedScopes, envelopeScopesSnapshot, mismatch: 0 };
         }
         if (!requestedScopes || requestedScopes.length === 0) {
+            if (toolName === 'context_compile' && Array.isArray(input.scopes)) {
+                return { requestedScopes, envelopeScopesSnapshot, mismatch: 0 };
+            }
             return {
                 requestedScopes,
                 envelopeScopesSnapshot,
@@ -836,7 +982,9 @@ class GatewayToolExecutor {
         if (toolName === 'mama_save') {
             return normalizeMemoryScopes(input.scopes);
         }
-        if (toolName === 'mama_search' || toolName === 'mama_recall') {
+        if (toolName === 'mama_search' ||
+            toolName === 'mama_recall' ||
+            toolName === 'context_compile') {
             return normalizeMemoryScopes(input.scopes);
         }
         if (toolName === 'mama_update') {
@@ -867,6 +1015,52 @@ class GatewayToolExecutor {
             projectId: process.env.MAMA_WORKSPACE || process.cwd(),
         });
     }
+    resolveMamaRecallScopes(input) {
+        const ctx = this.getExecutionState();
+        const requestedScopes = normalizeMemoryScopes(input.scopes);
+        const callerProvidedScopes = input.scopes !== undefined;
+        const allowedScopes = ctx.envelope?.scope.memory_scopes ?? this.deriveMemoryScopesFromActiveContext(ctx) ?? [];
+        const hasActiveScopeBoundary = Boolean(ctx.envelope || ctx.agentContext);
+        if (callerProvidedScopes && !requestedScopes) {
+            return {
+                scopes: [],
+                denial: {
+                    success: false,
+                    code: 'memory_scope_invalid',
+                    error: 'mama_recall scopes must be valid memory scope objects.',
+                },
+            };
+        }
+        if (!hasActiveScopeBoundary) {
+            if (callerProvidedScopes) {
+                return {
+                    scopes: [],
+                    denial: {
+                        success: false,
+                        code: 'memory_scope_denied',
+                        error: 'mama_recall requires an active session or envelope for caller-supplied scopes.',
+                    },
+                };
+            }
+            return { scopes: [] };
+        }
+        if (!requestedScopes || requestedScopes.length === 0) {
+            return { scopes: allowedScopes };
+        }
+        const allowedScopeKeys = new Set(allowedScopes.map(memoryScopeKey));
+        const hasUnauthorizedScope = requestedScopes.some((scope) => !allowedScopeKeys.has(memoryScopeKey(scope)));
+        if (hasUnauthorizedScope) {
+            return {
+                scopes: [],
+                denial: {
+                    success: false,
+                    code: 'memory_scope_denied',
+                    error: 'mama_recall requested scopes outside the active session or envelope.',
+                },
+            };
+        }
+        return { scopes: requestedScopes };
+    }
     applyEnvelopeScopedReadDefaults(toolName, input, ctx) {
         // Memory read tools must inherit envelope scopes consistently when the
         // caller omits scopes. Otherwise recall can fall back to active-context
@@ -875,8 +1069,15 @@ class GatewayToolExecutor {
             return input;
         }
         const scopedInput = input;
+        if (toolName === 'mama_save' && hasContextPacketIdInput(scopedInput)) {
+            // Invalid context_packet_id values are rejected later in the mama_save
+            // handler. Skip default-scope injection for any present value so that
+            // subsequent validation can return context_packet_denied without being
+            // masked by envelope-scope defaults.
+            return input;
+        }
         const hasCallerScopes = Array.isArray(scopedInput.scopes)
-            ? scopedInput.scopes.length > 0
+            ? toolName === 'context_compile' || scopedInput.scopes.length > 0
             : scopedInput.scopes !== undefined;
         if (hasCallerScopes) {
             return input;
@@ -886,25 +1087,69 @@ class GatewayToolExecutor {
             scopes: ctx.envelope.scope.memory_scopes,
         };
     }
-    buildTrustedMemoryWriteOptions(toolName, gatewayCallId) {
+    async buildTrustedMemoryWriteOptions(toolName, gatewayCallId, input) {
         const ctx = this.mergeWithFallbackExecutionContext(this.executionContextStorage.getStore());
         const capability = getTrustedProvenanceRuntime().createTrustedProvenanceCapability();
+        const contextPacketId = getContextPacketIdForTrustedProvenance(input);
+        const packetSourceRefs = [];
+        let contextPacketScopes;
+        if (contextPacketId) {
+            if (!ctx?.envelope) {
+                throw new ContextPacketProvenanceError('context_packet_id requires an active worker envelope.');
+            }
+            if (!ctx.modelRunId) {
+                throw new ContextPacketProvenanceError('context_packet_id requires an active caller model run.');
+            }
+            let packet;
+            try {
+                packet = (0, mama_core_1.getContextPacketForTrustedUse)(await getContextPacketLookupAdapter(), {
+                    packetId: contextPacketId,
+                    envelopeHash: ctx.envelope.envelope_hash,
+                    callerModelRunId: ctx.modelRunId,
+                });
+            }
+            catch (error) {
+                throw new ContextPacketProvenanceError(error instanceof Error ? error.message : String(error));
+            }
+            if (!packet) {
+                throw new ContextPacketProvenanceError(`Context packet not found: ${contextPacketId}`);
+            }
+            packetSourceRefs.push(...packet.source_refs.map(mama_core_1.serializeContextRefForProvenance));
+            contextPacketScopes = packet.scopes.map((scope) => ({ kind: scope.kind, id: scope.id }));
+            if (contextPacketScopes.length === 0) {
+                throw new ContextPacketProvenanceError('Trusted context packet has no memory scopes.');
+            }
+            const requestedScopeValue = input.scopes;
+            if (Array.isArray(requestedScopeValue) && requestedScopeValue.length === 0) {
+                throw new ContextPacketProvenanceError('Requested save scope is outside the trusted context packet scope.');
+            }
+            const requestedScopes = normalizeMemoryScopes(requestedScopeValue);
+            if (requestedScopes &&
+                !requestedScopes.every((scope) => contextPacketScopes?.some((allowed) => memoryScopeKey(allowed) === memoryScopeKey(scope)))) {
+                throw new ContextPacketProvenanceError('Requested save scope is outside the trusted context packet scope.');
+            }
+        }
         return {
-            capability,
-            provenance: {
-                actor: ctx?.agentContext?.roleName === 'memory_agent' ? 'memory_agent' : 'main_agent',
-                agent_id: ctx?.agentId,
-                model_run_id: ctx?.modelRunId ?? undefined,
-                envelope_hash: ctx?.envelope?.envelope_hash,
-                tool_name: toolName,
-                gateway_call_id: gatewayCallId,
-                source_turn_id: ctx?.sourceTurnId,
-                source_message_ref: ctx?.sourceMessageRef,
-                source_refs: [
-                    ...(ctx?.envelope?.envelope_hash ? [`envelope:${ctx.envelope.envelope_hash}`] : []),
-                    ...(ctx?.sourceMessageRef ? [`message:${ctx.sourceMessageRef}`] : []),
-                ],
+            options: {
+                capability,
+                provenance: {
+                    actor: ctx?.agentContext?.roleName === 'memory_agent' ? 'memory_agent' : 'main_agent',
+                    agent_id: ctx?.agentId,
+                    model_run_id: ctx?.modelRunId ?? undefined,
+                    envelope_hash: ctx?.envelope?.envelope_hash,
+                    tool_name: toolName,
+                    gateway_call_id: gatewayCallId,
+                    ...(contextPacketId ? { context_packet_id: contextPacketId } : {}),
+                    source_turn_id: ctx?.sourceTurnId,
+                    source_message_ref: ctx?.sourceMessageRef,
+                    source_refs: dedupeSourceRefs([
+                        ...(ctx?.envelope?.envelope_hash ? [`envelope:${ctx.envelope.envelope_hash}`] : []),
+                        ...(ctx?.sourceMessageRef ? [`message:${ctx.sourceMessageRef}`] : []),
+                        ...packetSourceRefs,
+                    ]),
+                },
             },
+            contextPacketScopes,
         };
     }
     supportsTrustedIngest(api) {
@@ -987,27 +1232,6 @@ class GatewayToolExecutor {
             // Audit warnings must never affect tool execution.
         }
     }
-    auditedAutoSave(parentToolName, input) {
-        const parentContext = this.executionContextStorage.getStore();
-        const task = (async () => {
-            try {
-                if (parentContext) {
-                    const autosaveContext = {
-                        ...parentContext,
-                        parentToolName,
-                    };
-                    await this.executionContextStorage.run(autosaveContext, () => this.execute('mama_save', input));
-                    return;
-                }
-                await this.execute('mama_save', input);
-            }
-            catch {
-                // Autosave is intentionally non-fatal for report/wiki publish tools.
-            }
-        })();
-        parentContext?.backgroundTasks?.register(task);
-        void task;
-    }
     async executeWithEnvelopeAndPermissions(toolName, input, gatewayCallId) {
         if (!VALID_TOOLS.includes(toolName)) {
             throw new types_js_1.AgentError(`Unknown tool: ${toolName}. Valid tools: ${VALID_TOOLS.join(', ')}`, 'UNKNOWN_TOOL', undefined, false);
@@ -1318,16 +1542,72 @@ class GatewayToolExecutor {
                 case 'mama_save': {
                     const saveInput = input;
                     const api = await getApi();
-                    return await (0, mama_tool_handlers_js_1.handleSave)(api, saveInput, this.sessionStore?.getHistory
+                    let trustedOptions;
+                    let effectiveSaveInput = saveInput;
+                    let hasContextPacketId;
+                    try {
+                        hasContextPacketId = getContextPacketIdForTrustedProvenance(saveInput) !== null;
+                    }
+                    catch (error) {
+                        if (error instanceof ContextPacketProvenanceError) {
+                            return {
+                                success: false,
+                                code: 'context_packet_denied',
+                                error: error.message,
+                            };
+                        }
+                        throw error;
+                    }
+                    if (hasContextPacketId && !this.isMemoryDecisionSaveInput(saveInput)) {
+                        return {
+                            success: false,
+                            code: 'context_packet_denied',
+                            error: 'context_packet_id is only supported for trusted decision saves.',
+                        };
+                    }
+                    if (this.isMemoryDecisionSaveInput(saveInput) && hasContextPacketId) {
+                        if (!this.supportsTrustedSave(api)) {
+                            return {
+                                success: false,
+                                code: 'context_packet_denied',
+                                error: 'context_packet_id requires trusted save support.',
+                            };
+                        }
+                        try {
+                            const trustedBuild = await this.buildTrustedMemoryWriteOptions('mama_save', gatewayCallId, saveInput);
+                            trustedOptions = trustedBuild.options;
+                            if (!Array.isArray(saveInput.scopes) && trustedBuild.contextPacketScopes) {
+                                effectiveSaveInput = {
+                                    ...saveInput,
+                                    scopes: trustedBuild.contextPacketScopes,
+                                };
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof ContextPacketProvenanceError) {
+                                return {
+                                    success: false,
+                                    code: 'context_packet_denied',
+                                    error: error.message,
+                                };
+                            }
+                            throw error;
+                        }
+                    }
+                    else if (this.isMemoryDecisionSaveInput(saveInput) && this.supportsTrustedSave(api)) {
+                        trustedOptions = (await this.buildTrustedMemoryWriteOptions('mama_save', gatewayCallId))
+                            .options;
+                    }
+                    return await (0, mama_tool_handlers_js_1.handleSave)(api, effectiveSaveInput, this.sessionStore?.getHistory
                         ? () => this.sessionStore.getHistory('current')
-                        : undefined, this.isMemoryDecisionSaveInput(saveInput) && this.supportsTrustedSave(api)
-                        ? this.buildTrustedMemoryWriteOptions('mama_save', gatewayCallId)
-                        : undefined);
+                        : undefined, trustedOptions);
                 }
                 case 'mama_search':
                     return await (0, mama_tool_handlers_js_1.handleSearch)(await getApi(), input);
                 case 'mama_recall':
                     return await this.handleMamaRecall(input);
+                case 'context_compile':
+                    return await this.handleContextCompile(input);
                 case 'mama_update':
                     return await (0, mama_tool_handlers_js_1.handleUpdate)(await getApi(), input);
                 case 'mama_load_checkpoint':
@@ -1335,13 +1615,13 @@ class GatewayToolExecutor {
                 case 'mama_add': {
                     const api = await getApi();
                     return await this.handleMamaAdd(input, this.supportsTrustedIngest(api)
-                        ? this.buildTrustedMemoryWriteOptions('mama_add', gatewayCallId)
+                        ? (await this.buildTrustedMemoryWriteOptions('mama_add', gatewayCallId)).options
                         : undefined);
                 }
                 case 'mama_ingest': {
                     const api = await getApi();
                     return await this.handleMamaIngest(input, this.supportsTrustedIngest(api)
-                        ? this.buildTrustedMemoryWriteOptions('mama_ingest', gatewayCallId)
+                        ? (await this.buildTrustedMemoryWriteOptions('mama_ingest', gatewayCallId)).options
                         : undefined);
                 }
                 case 'report_publish': {
@@ -1352,20 +1632,6 @@ class GatewayToolExecutor {
                     if (this.reportPublisher) {
                         this.reportPublisher(slotsInput);
                         const slotNames = Object.keys(slotsInput);
-                        // Persist report summary to mama memory for Conductor querying
-                        const slotValues = Object.values(slotsInput).join(' ');
-                        const textSummary = slotValues
-                            .replace(/<[^>]+>/g, ' ')
-                            .replace(/\s+/g, ' ')
-                            .trim();
-                        const truncated = textSummary.length > 1500 ? textSummary.substring(0, 1500) + '...' : textSummary;
-                        this.auditedAutoSave('report_publish', {
-                            type: 'decision',
-                            topic: 'dashboard_briefing',
-                            decision: `Dashboard briefing (${new Date().toISOString().split('T')[0]}): ${truncated}`,
-                            reasoning: 'Auto-saved by dashboard agent after report_publish',
-                            scopes: [{ kind: 'global', id: 'system' }],
-                        });
                         return {
                             success: true,
                             message: `Dashboard updated: ${slotNames.join(', ')} (${slotNames.length} slots)`,
@@ -1378,37 +1644,21 @@ class GatewayToolExecutor {
                     if (!pagesInput || !Array.isArray(pagesInput)) {
                         throw new types_js_1.AgentError('wiki_publish requires pages array', 'TOOL_ERROR', undefined, false);
                     }
-                    if (this.wikiPublisher) {
-                        const now = new Date().toISOString();
-                        const wikiPages = pagesInput.map((p) => ({
-                            path: p.path,
-                            title: p.title,
-                            type: p.type || 'entity',
-                            content: p.content,
-                            sourceIds: [],
-                            compiledAt: now,
-                            confidence: p.confidence || 'medium',
-                        }));
-                        this.wikiPublisher(wikiPages);
-                        // Persist wiki compilation summary to mama memory for Conductor querying
-                        const pageSummary = pagesInput
-                            .slice(0, 20)
-                            .map((p) => `- ${p.title || p.path} (${p.type || 'page'})`)
-                            .join('\n');
-                        const wikiSummary = `Wiki compilation (${now.split('T')[0]}): ${pagesInput.length} pages\n${pageSummary}`;
-                        this.auditedAutoSave('wiki_publish', {
-                            type: 'decision',
-                            topic: 'wiki_compilation',
-                            decision: wikiSummary,
-                            reasoning: 'Auto-saved by wiki agent after wiki_publish',
-                            scopes: [{ kind: 'global', id: 'system' }],
+                    const adapter = this.wikiPublishAdapter ??
+                        (0, wiki_publish_adapter_js_1.createWikiPublishAdapter)({
+                            publisher: this.wikiPublisher,
                         });
+                    try {
+                        const publishResult = adapter.publish({ pages: pagesInput });
                         return {
                             success: true,
-                            message: `Wiki published: ${wikiPages.length} pages`,
+                            message: `Wiki published: ${publishResult.pagesPublished} pages`,
+                            artifactsStored: publishResult.artifactsStored,
                         };
                     }
-                    throw new types_js_1.AgentError('Wiki publisher not configured', 'TOOL_ERROR', undefined, false);
+                    catch (error) {
+                        throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Wiki publish failed', 'TOOL_ERROR', undefined, false);
+                    }
                 }
                 // Kagemusha query tools — progressive business data exploration
                 case 'kagemusha_overview': {
@@ -2565,8 +2815,12 @@ class GatewayToolExecutor {
             };
         }
         // Obsidian CLI syntax: obsidian <command> key=value ... [flags]
-        // Vault is not passed as path — Obsidian uses the default/focused vault
+        // Without vault=<name> the CLI targets the FOCUSED vault, so wiki writes
+        // could land in whatever vault the owner has open. Pin it when configured.
         const cliArgs = [command];
+        if (this.obsidianVaultName) {
+            cliArgs.push(`vault=${this.obsidianVaultName}`);
+        }
         for (const [key, value] of Object.entries(args || {})) {
             if (value === 'true' && ['silent', 'overwrite', 'total'].includes(key)) {
                 cliArgs.push(key);
@@ -2600,13 +2854,95 @@ class GatewayToolExecutor {
             };
         }
     }
+    resolveCodeActSandboxRole(input, activeRole, registryNames) {
+        const allowedResolution = this.normalizeCodeActToolPatterns(input.allowedTools, 'allowedTools', registryNames);
+        if (allowedResolution.error) {
+            return { error: allowedResolution.error };
+        }
+        const blockedResolution = this.normalizeCodeActToolPatterns(input.blockedTools, 'blockedTools', registryNames);
+        if (blockedResolution.error) {
+            return { error: blockedResolution.error };
+        }
+        if (!activeRole && !allowedResolution.patterns && !blockedResolution.patterns) {
+            return {};
+        }
+        let effectiveToolNames = activeRole
+            ? registryNames.filter((toolName) => this.roleManager.isToolAllowed(activeRole, toolName))
+            : [...registryNames];
+        const allowedPatterns = allowedResolution.patterns;
+        if (allowedPatterns) {
+            effectiveToolNames = effectiveToolNames.filter((toolName) => this.matchesAnyCodeActToolPattern(toolName, allowedPatterns));
+        }
+        const blockedPatterns = blockedResolution.patterns;
+        if (blockedPatterns) {
+            effectiveToolNames = effectiveToolNames.filter((toolName) => !this.matchesAnyCodeActToolPattern(toolName, blockedPatterns));
+        }
+        return {
+            role: {
+                ...activeRole,
+                allowedTools: effectiveToolNames,
+                blockedTools: undefined,
+                allowedPaths: activeRole?.allowedPaths ?? [],
+                systemControl: activeRole?.systemControl ?? false,
+                sensitiveAccess: activeRole?.sensitiveAccess ?? false,
+            },
+        };
+    }
+    normalizeCodeActToolPatterns(value, fieldName, registryNames) {
+        if (value === undefined) {
+            return {};
+        }
+        if (!Array.isArray(value)) {
+            return { error: `${fieldName} must be an array of gateway tool names.` };
+        }
+        const patterns = [];
+        const seen = new Set();
+        for (const item of value) {
+            if (typeof item !== 'string' || item.trim().length === 0) {
+                return { error: `${fieldName} must contain non-empty gateway tool names.` };
+            }
+            const pattern = item.trim();
+            if (seen.has(pattern)) {
+                continue;
+            }
+            if (!this.isKnownCodeActToolPattern(pattern, registryNames)) {
+                return { error: `Unknown Code-Act tool pattern in ${fieldName}: ${pattern}` };
+            }
+            seen.add(pattern);
+            patterns.push(pattern);
+        }
+        return { patterns };
+    }
+    isKnownCodeActToolPattern(pattern, registryNames) {
+        return (pattern === '*' ||
+            registryNames.some((toolName) => this.matchesCodeActToolPattern(toolName, pattern)));
+    }
+    matchesAnyCodeActToolPattern(toolName, patterns) {
+        return patterns.some((pattern) => this.matchesCodeActToolPattern(toolName, pattern));
+    }
+    matchesCodeActToolPattern(toolName, pattern) {
+        return this.roleManager.isToolAllowed({
+            allowedTools: [pattern],
+            allowedPaths: [],
+            systemControl: false,
+            sensitiveAccess: false,
+        }, toolName);
+    }
     async executeCodeAct(input) {
         const { CodeActSandbox, HostBridge } = await import('./code-act/index.js');
         const sandbox = new CodeActSandbox();
-        const bridge = new HostBridge(this);
         const context = this.getActiveContext();
         const tier = (context?.tier ?? 1);
-        bridge.injectInto(sandbox, tier, context?.role);
+        const registryNames = HostBridge.getToolRegistry().map((meta) => meta.name);
+        const sandboxRole = this.resolveCodeActSandboxRole(input, context?.role, registryNames);
+        if (sandboxRole.error) {
+            return {
+                success: false,
+                error: sandboxRole.error,
+            };
+        }
+        const bridge = new HostBridge(this, this.roleManager);
+        bridge.injectInto(sandbox, tier, sandboxRole.role);
         const result = await sandbox.execute(input.code);
         return {
             success: result.success,
@@ -2659,15 +2995,19 @@ class GatewayToolExecutor {
                     error: 'Memory ingest API not available.',
                 };
             }
-            const context = this.getActiveContext();
-            const fallbackScopes = context
-                ? (0, scope_context_js_1.deriveMemoryScopes)({
-                    source: context.source,
-                    channelId: context.session.channelId,
-                    userId: context.session.userId,
-                    projectId: process.env.MAMA_WORKSPACE || process.cwd(),
-                })
-                : [];
+            const activeState = this.getExecutionState();
+            const context = activeState.agentContext;
+            const envelopeScopes = activeState.envelope?.scope.memory_scopes ?? null;
+            const fallbackScopes = envelopeScopes && envelopeScopes.length > 0
+                ? envelopeScopes
+                : context
+                    ? (0, scope_context_js_1.deriveMemoryScopes)({
+                        source: context.source,
+                        channelId: context.session.channelId,
+                        userId: context.session.userId,
+                        projectId: process.env.MAMA_WORKSPACE || process.cwd(),
+                    })
+                    : [];
             let scopes = fallbackScopes;
             if (Array.isArray(input.scopes) && input.scopes.length > 0) {
                 const derivedIds = new Set(fallbackScopes.map((s) => `${s.kind}:${s.id}`));
@@ -2714,17 +3054,11 @@ class GatewayToolExecutor {
                 error: 'query is required and recallMemory API must be available',
             };
         }
-        const context = this.getActiveContext();
-        const fallbackScopes = context
-            ? (0, scope_context_js_1.deriveMemoryScopes)({
-                source: context.source,
-                channelId: context.session.channelId,
-                userId: context.session.userId,
-                projectId: process.env.MAMA_WORKSPACE || process.cwd(),
-            })
-            : [];
-        const inputScopes = Array.isArray(input.scopes) ? input.scopes : [];
-        const scopes = inputScopes.length > 0 ? inputScopes : fallbackScopes;
+        const scopeResolution = this.resolveMamaRecallScopes(input);
+        if (scopeResolution.denial) {
+            return scopeResolution.denial;
+        }
+        const scopes = scopeResolution.scopes;
         if (scopes.length === 0) {
             return {
                 success: false,
@@ -2736,7 +3070,7 @@ class GatewayToolExecutor {
                 scopes,
                 includeProfile: true,
             });
-            return { success: true, bundle };
+            return { success: true, bundle: sanitizeMamaRecallBundle(bundle) };
         }
         catch (err) {
             return {
@@ -2754,6 +3088,57 @@ class GatewayToolExecutor {
     static isValidTool(toolName) {
         return VALID_TOOLS.includes(toolName);
     }
+    async handleContextCompile(input) {
+        if (!this.contextCompileService) {
+            return {
+                success: false,
+                code: 'context_compile_unavailable',
+                error: 'context_compile service is not available.',
+            };
+        }
+        const ctx = this.mergeWithFallbackExecutionContext(this.executionContextStorage.getStore());
+        // Fail closed: a Tier-3 designation in either source must block the call,
+        // otherwise a non-Tier-3 fallback could mask a Tier-3 envelope.
+        if (ctx?.agentContext?.tier === 3 || ctx?.envelope?.tier === 3) {
+            return {
+                success: false,
+                code: 'permission_denied_tier3',
+                error: 'context_compile is not allowed for Tier 3 agents.',
+            };
+        }
+        if (!ctx?.envelope) {
+            return {
+                success: false,
+                code: 'envelope_missing',
+                error: 'context_compile requires an active worker envelope.',
+            };
+        }
+        try {
+            const result = await this.contextCompileService.compileAndPersistContext({
+                caller: 'gateway',
+                envelope: ctx.envelope,
+                modelRunId: ctx.modelRunId ?? null,
+                input,
+            });
+            return {
+                success: true,
+                packet: result.packet,
+                packet_id: result.packet.packet_id,
+                model_run_id: result.modelRunId,
+                parent_model_run_id: result.parentModelRunId,
+            };
+        }
+        catch (err) {
+            const errorRecord = err && typeof err === 'object' ? err : undefined;
+            const code = typeof errorRecord?.code === 'string' ? errorRecord.code : 'context_compile_failed';
+            return {
+                success: false,
+                code,
+                error: `context_compile failed: ${err instanceof Error ? err.message : String(err)}`,
+                ...(errorRecord && 'details' in errorRecord ? { details: errorRecord.details } : {}),
+            };
+        }
+    }
 }
 exports.GatewayToolExecutor = GatewayToolExecutor;
 function isTruthyEnv(name) {
@@ -2799,6 +3184,51 @@ function getTrustedProvenanceRuntime() {
     }
     throw new types_js_1.AgentError(`Trusted provenance runtime unavailable: ${lastError instanceof Error ? lastError.message : String(lastError)}`, 'TOOL_ERROR', lastError instanceof Error ? lastError : undefined, false);
 }
+async function getContextPacketLookupAdapter() {
+    try {
+        const dbManager = (await import('@jungjaehoon/mama-core/db-manager'));
+        try {
+            return dbManager.getAdapter();
+        }
+        catch (error) {
+            if (typeof dbManager.initDB !== 'function') {
+                throw error;
+            }
+            await dbManager.initDB();
+            return dbManager.getAdapter();
+        }
+    }
+    catch (error) {
+        throw new ContextPacketProvenanceError(`Context packet store unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function hasContextPacketIdInput(input) {
+    if (!input || !('context_packet_id' in input)) {
+        return false;
+    }
+    const value = input.context_packet_id;
+    return value !== undefined && value !== null;
+}
+function getContextPacketIdForTrustedProvenance(input) {
+    if (!input || !('context_packet_id' in input)) {
+        return null;
+    }
+    const value = input.context_packet_id;
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        throw new ContextPacketProvenanceError('context_packet_id must be a string when provided.');
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new ContextPacketProvenanceError('context_packet_id must not be empty when provided.');
+    }
+    return trimmed;
+}
+function dedupeSourceRefs(refs) {
+    return [...new Set(refs)];
+}
 function normalizeMemoryScopes(value) {
     if (!Array.isArray(value) || value.length === 0) {
         return null;