@jungjaehoon/mama-os 0.48.2 → 0.48.3

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

@@ -82,6 +82,8 @@ const config_manager_js_1 = require("../cli/config/config-manager.js");
 const agent_store_js_1 = require("../db/agent-store.js");
 const index_js_1 = require("../envelope/index.js");
 const wiki_publish_adapter_js_1 = require("../wiki-artifacts/wiki-publish-adapter.js");
+const obsidian_cli_args_js_1 = require("./obsidian-cli-args.js");
+const wiki_read_js_1 = require("../wiki/wiki-read.js");
 const changes_projection_js_1 = require("../operator/changes-projection.js");
 const task_list_views_js_1 = require("../operator/task-list-views.js");
 const board_read_views_js_1 = require("../operator/board-read-views.js");
@@ -526,9 +528,18 @@ class GatewayToolExecutor {
     wikiPublishAdapter = null;
     obsidianVaultPath = null;
     obsidianVaultName = null;
+    obsidianVaultVerified = false;
+    wikiReadCoverage = new Map();
+    wikiSourceCoverage = new Map();
     setObsidianVaultPath(vaultPath, vaultName) {
         this.obsidianVaultPath = vaultPath;
         this.obsidianVaultName = vaultName ?? null;
+        this.obsidianVaultVerified = false;
+    }
+    releaseWikiAttemptCoverage(workorderAttemptId) {
+        if (Number.isSafeInteger(workorderAttemptId) && workorderAttemptId > 0) {
+            this.clearWikiAttemptCoverage(workorderAttemptId);
+        }
     }
     taskLedger = null;
     ownerEventEffectLedger = null;
@@ -2616,12 +2627,50 @@ class GatewayToolExecutor {
                     if (!pagesInput || !Array.isArray(pagesInput)) {
                         throw new types_js_1.AgentError('wiki_publish requires pages array', 'TOOL_ERROR', undefined, false);
                     }
+                    const wikiAuthority = this.getExecutionState().wikiTaskRange;
+                    if (wikiAuthority) {
+                        if (!this.obsidianVaultPath) {
+                            throw new types_js_1.AgentError('Wiki vault path not configured', 'TOOL_ERROR', undefined, false);
+                        }
+                        if (wikiAuthority.ownerDate === null) {
+                            throw new types_js_1.AgentError('wiki_publish is unavailable for legacy input without a host-issued ownerDate', 'WORKORDER_SUPERSEDED', undefined, false);
+                        }
+                        try {
+                            (0, wiki_read_js_1.assertWikiWorkorderPublish)({
+                                root: this.obsidianVaultPath,
+                                ownerDate: wikiAuthority.ownerDate,
+                                pages: pagesInput,
+                            });
+                            const attemptId = this.getExecutionState().workorderAttemptId;
+                            if (!Number.isSafeInteger(attemptId) || attemptId < 1) {
+                                throw new Error('wiki_publish requires a host-issued workorder attempt');
+                            }
+                            for (const page of pagesInput) {
+                                const path = (0, wiki_read_js_1.assertAllowedWikiWorkorderPath)(page.path, wikiAuthority.ownerDate);
+                                const coverage = this.wikiReadCoverage.get(this.wikiReadCoverageKey(attemptId, path));
+                                if (!coverage?.complete ||
+                                    coverage.contentVersion !== page.expectedContentVersion) {
+                                    throw new Error(`wiki_publish page ${path} requires a complete contiguous wiki_read at the expected content version`);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Wiki publication authority failed', 'TOOL_ERROR', undefined, false);
+                        }
+                    }
+                    const publishPages = wikiAuthority
+                        ? pagesInput
+                        : pagesInput.map(({ expectedContentVersion: _ignored, ...page }) => page);
                     const adapter = this.wikiPublishAdapter ??
                         (0, wiki_publish_adapter_js_1.createWikiPublishAdapter)({
                             publisher: this.wikiPublisher,
                         });
                     try {
-                        const publishResult = adapter.publish({ pages: pagesInput });
+                        const publishResult = adapter.publish({ pages: publishPages });
+                        if (wikiAuthority) {
+                            const attemptId = this.getExecutionState().workorderAttemptId;
+                            this.clearWikiAttemptCoverage(attemptId);
+                        }
                         return {
                             success: true,
                             message: `Wiki published: ${publishResult.pagesPublished} pages`,
@@ -2632,6 +2681,66 @@ class GatewayToolExecutor {
                         throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Wiki publish failed', 'TOOL_ERROR', undefined, false);
                     }
                 }
+                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 {
+                        const attemptId = this.getExecutionState().workorderAttemptId;
+                        if (!Number.isSafeInteger(attemptId) || attemptId < 1) {
+                            throw new Error('wiki_read requires a host-issued workorder attempt');
+                        }
+                        const readInput = input;
+                        const requestedOffset = readInput.content_offset ?? 0;
+                        if (!Number.isSafeInteger(requestedOffset) || requestedOffset < 0) {
+                            throw new Error('wiki_read content_offset must be a non-negative safe integer');
+                        }
+                        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 key = this.wikiReadCoverageKey(attemptId, path);
+                            const prior = this.wikiReadCoverage.get(key);
+                            if (requestedOffset === 0) {
+                                this.wikiReadCoverage.delete(key);
+                            }
+                            else if (!prior || prior.complete || prior.nextOffset !== requestedOffset) {
+                                throw new Error(`wiki_read page ${path} must continue from the host-issued nextContentOffset`);
+                            }
+                        }
+                        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,
+                        });
+                        for (const page of result.pages) {
+                            const key = this.wikiReadCoverageKey(attemptId, page.path);
+                            const prior = this.wikiReadCoverage.get(key);
+                            if (requestedOffset > 0 &&
+                                prior?.contentVersion !== page.contentVersion) {
+                                this.wikiReadCoverage.delete(key);
+                                throw new Error(`wiki_read page ${page.path} changed; restart from offset 0`);
+                            }
+                            this.wikiReadCoverage.set(key, {
+                                contentVersion: page.contentVersion,
+                                nextOffset: page.nextContentOffset,
+                                complete: page.nextContentOffset === null,
+                            });
+                        }
+                        return {
+                            success: true,
+                            ...result,
+                        };
+                    }
+                    catch (error) {
+                        throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Wiki read failed', 'TOOL_ERROR', undefined, false);
+                    }
+                }
                 // Kagemusha query tools — progressive business data exploration
                 case 'kagemusha_overview': {
                     const { getOverview } = await import('../connectors/kagemusha/query-tools.js');
@@ -2761,6 +2870,7 @@ class GatewayToolExecutor {
                     // superseded signal it was before the progressive views.
                     const temporalContext = this.getExecutionState().temporalWorkContext;
                     const wikiTaskRange = this.getExecutionState().wikiTaskRange;
+                    let taskListInput = input;
                     if (wikiTaskRange) {
                         const taskInput = input !== null && typeof input === 'object' && !Array.isArray(input)
                             ? input
@@ -2768,11 +2878,38 @@ class GatewayToolExecutor {
                         if (wikiTaskRange.updatedSince === null || wikiTaskRange.updatedBefore === null) {
                             throw new types_js_1.AgentError('Wiki task_list is unavailable for legacy input without a host-issued range', 'WORKORDER_SUPERSEDED', undefined, false);
                         }
-                        if ((taskInput.view !== undefined && taskInput.view !== 'items') ||
-                            taskInput.updated_since !== wikiTaskRange.updatedSince ||
-                            taskInput.updated_before !== wikiTaskRange.updatedBefore) {
-                            throw new types_js_1.AgentError('Wiki task_list requires view items and the exact host-issued updated_since/updated_before range', 'TOOL_ERROR', undefined, false);
+                        if (taskInput.view !== undefined && taskInput.view !== 'items') {
+                            throw new types_js_1.AgentError('Wiki task_list requires view items', 'TOOL_ERROR', undefined, false);
+                        }
+                        const allowedFields = new Set([
+                            'view',
+                            'cursor',
+                            'limit',
+                            'updated_since',
+                            'updated_before',
+                        ]);
+                        const narrowingFields = Object.keys(taskInput).filter((field) => !allowedFields.has(field));
+                        if (narrowingFields.length > 0) {
+                            throw new types_js_1.AgentError(`Wiki task_list cannot narrow the host-issued range with: ${narrowingFields.join(', ')}`, 'TOOL_ERROR', undefined, false);
+                        }
+                        if ((taskInput.updated_since !== undefined &&
+                            taskInput.updated_since !== wikiTaskRange.updatedSince) ||
+                            (taskInput.updated_before !== undefined &&
+                                taskInput.updated_before !== wikiTaskRange.updatedBefore)) {
+                            throw new types_js_1.AgentError('Wiki task_list parameters contradict the host-issued updated_since/updated_before range', 'TOOL_ERROR', undefined, false);
+                        }
+                        const normalizedInput = { ...taskInput };
+                        if (normalizedInput.cursor === null) {
+                            delete normalizedInput.cursor;
                         }
+                        taskListInput = {
+                            ...normalizedInput,
+                            view: 'items',
+                            include_terminal: true,
+                            order: 'updated',
+                            updated_since: wikiTaskRange.updatedSince,
+                            updated_before: wikiTaskRange.updatedBefore,
+                        };
                     }
                     let boundTask;
                     if (temporalContext) {
@@ -2782,10 +2919,17 @@ class GatewayToolExecutor {
                         }
                         boundTask = found;
                     }
-                    return (0, task_list_views_js_1.runTaskListView)(input, {
+                    const taskListResult = (0, task_list_views_js_1.runTaskListView)(taskListInput, {
                         ledger: this.taskLedger,
                         boundTask,
                     });
+                    if (wikiTaskRange && taskListResult.success === true) {
+                        const nextCursor = taskListResult.nextCursor;
+                        if (nextCursor === null || nextCursor === undefined) {
+                            this.markWikiSourceCoverage('task_list');
+                        }
+                    }
+                    return taskListResult;
                 }
                 case 'task_external_correlation': {
                     if (!this.taskLedger) {
@@ -3197,7 +3341,30 @@ class GatewayToolExecutor {
                     if (!reason || !scope) {
                         throw new types_js_1.AgentError('contract_no_update requires both reason and scope', 'TOOL_ERROR', undefined, false);
                     }
-                    return { success: true, note: this.taskLedger.recordNoUpdate(scope, reason) };
+                    const wikiAuthority = this.getExecutionState().wikiTaskRange;
+                    if (wikiAuthority) {
+                        if (wikiAuthority.noUpdateScope === null) {
+                            throw new types_js_1.AgentError('contract_no_update is unavailable for legacy wiki input without a host-issued scope', 'WORKORDER_SUPERSEDED', undefined, false);
+                        }
+                        if (scope !== wikiAuthority.noUpdateScope) {
+                            throw new types_js_1.AgentError('Wiki contract_no_update scope must match the exact host-issued scope', 'TOOL_ERROR', undefined, false);
+                        }
+                        const attemptId = this.getExecutionState().workorderAttemptId;
+                        if (!Number.isSafeInteger(attemptId) || attemptId < 1) {
+                            throw new types_js_1.AgentError('Wiki contract_no_update requires a host-issued workorder attempt', 'WORKORDER_SUPERSEDED', undefined, false);
+                        }
+                        try {
+                            this.assertWikiNoUpdateCoverage(attemptId, wikiAuthority);
+                        }
+                        catch (error) {
+                            throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Wiki source coverage is incomplete', 'TOOL_ERROR', undefined, false);
+                        }
+                    }
+                    const note = this.taskLedger.recordNoUpdate(scope, reason);
+                    if (wikiAuthority) {
+                        this.clearWikiAttemptCoverage(this.getExecutionState().workorderAttemptId);
+                    }
+                    return { success: true, note };
                 }
                 case 'agent_notices': {
                     const rawLimit = Number(input.limit);
@@ -3919,20 +4086,33 @@ class GatewayToolExecutor {
                 error: 'Wiki vault path not configured',
             };
         }
+        if (this.obsidianVaultName && !this.obsidianVaultVerified) {
+            try {
+                const { stdout } = await execFileAsync('obsidian', (0, obsidian_cli_args_js_1.buildObsidianCliArgs)('vault', undefined, this.obsidianVaultName), {
+                    timeout: 15000,
+                    encoding: 'utf-8',
+                    maxBuffer: 1024 * 1024,
+                });
+                const configuredPath = (0, fs_1.realpathSync)(this.obsidianVaultPath);
+                const selectedPath = (0, fs_1.realpathSync)((0, obsidian_cli_args_js_1.parseObsidianVaultPath)(stdout));
+                if (selectedPath !== configuredPath) {
+                    throw new Error(`Obsidian CLI selected ${selectedPath}, expected configured wiki vault ${configuredPath}`);
+                }
+                this.obsidianVaultVerified = true;
+            }
+            catch (error) {
+                throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Obsidian vault target verification failed', 'TOOL_ERROR', undefined, false);
+            }
+        }
         // Obsidian CLI syntax: obsidian <command> key=value ... [flags]
         // 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}`);
+        let cliArgs;
+        try {
+            cliArgs = (0, obsidian_cli_args_js_1.buildObsidianCliArgs)(command, args, this.obsidianVaultName);
         }
-        for (const [key, value] of Object.entries(args || {})) {
-            if (value === 'true' && ['silent', 'overwrite', 'total'].includes(key)) {
-                cliArgs.push(key);
-            }
-            else {
-                cliArgs.push(`${key}=${value}`);
-            }
+        catch (error) {
+            throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Invalid Obsidian CLI arguments', 'TOOL_ERROR', undefined, false);
         }
         try {
             const { stdout } = await execFileAsync('obsidian', cliArgs, {
@@ -3959,6 +4139,47 @@ class GatewayToolExecutor {
             };
         }
     }
+    wikiReadCoverageKey(attemptId, path) {
+        return `${attemptId}:${path}`;
+    }
+    markWikiSourceCoverage(source) {
+        const attemptId = this.getExecutionState().workorderAttemptId;
+        if (!Number.isSafeInteger(attemptId) || attemptId < 1) {
+            return;
+        }
+        const current = this.wikiSourceCoverage.get(attemptId) ?? {
+            contextCompileComplete: false,
+            taskListComplete: false,
+        };
+        this.wikiSourceCoverage.set(attemptId, {
+            contextCompileComplete: current.contextCompileComplete || source === 'context_compile',
+            taskListComplete: current.taskListComplete || source === 'task_list',
+        });
+    }
+    assertWikiNoUpdateCoverage(attemptId, authority) {
+        if (authority.ownerDate === null) {
+            throw new Error('Wiki no-update coverage requires a host-issued ownerDate');
+        }
+        const sources = this.wikiSourceCoverage.get(attemptId);
+        if (!sources?.contextCompileComplete || !sources.taskListComplete) {
+            throw new Error('Wiki contract_no_update requires completed context_compile and all bounded task_list pages');
+        }
+        for (const path of ['Home.md', `daily/${authority.ownerDate}.md`]) {
+            const read = this.wikiReadCoverage.get(this.wikiReadCoverageKey(attemptId, path));
+            if (!read?.complete) {
+                throw new Error('Wiki contract_no_update requires complete wiki_read coverage for Home.md and the bound daily page');
+            }
+        }
+    }
+    clearWikiAttemptCoverage(attemptId) {
+        this.wikiSourceCoverage.delete(attemptId);
+        const prefix = `${attemptId}:`;
+        for (const key of this.wikiReadCoverage.keys()) {
+            if (key.startsWith(prefix)) {
+                this.wikiReadCoverage.delete(key);
+            }
+        }
+    }
     async executeCodeAct(input) {
         const { CodeActSandbox, CodeActToolPolicyValidationError, CODE_ACT_MUTATION_COMMITTED_AFTER_ABORT, CODE_ACT_MUTATION_OUTCOME_UNKNOWN, HostBridge, projectCodeActToolPolicy, } = await import('./code-act/index.js');
         const sandbox = new CodeActSandbox();
@@ -4254,6 +4475,36 @@ class GatewayToolExecutor {
             let effectiveInput = temporalContext
                 ? { ...input, task: bindTemporalContextPacketTask(temporalContext, input.task) }
                 : input;
+            const wikiAuthority = ctx.wikiTaskRange;
+            if (wikiAuthority) {
+                if (wikiAuthority.rangeStartMs === null ||
+                    wikiAuthority.rangeEndMs === null ||
+                    wikiAuthority.connectors === null) {
+                    throw new Error('context_compile is unavailable for legacy wiki input');
+                }
+                const providedRange = input.range;
+                if (providedRange !== undefined &&
+                    (providedRange.start_ms !== wikiAuthority.rangeStartMs ||
+                        providedRange.end_ms !== wikiAuthority.rangeEndMs)) {
+                    throw new Error('context_compile range contradicts the host-issued wiki range');
+                }
+                if (input.connectors !== undefined) {
+                    const providedConnectors = [...input.connectors].sort();
+                    const allowedConnectors = [...wikiAuthority.connectors].sort();
+                    if (providedConnectors.length !== allowedConnectors.length ||
+                        providedConnectors.some((connector, index) => connector !== allowedConnectors[index])) {
+                        throw new Error('context_compile connectors contradict the host-issued wiki connector scope');
+                    }
+                }
+                effectiveInput = {
+                    ...effectiveInput,
+                    range: {
+                        start_ms: wikiAuthority.rangeStartMs,
+                        end_ms: wikiAuthority.rangeEndMs,
+                    },
+                    connectors: [...wikiAuthority.connectors],
+                };
+            }
             // (d)-by-construction (S2 measurement: 94% of reconcile rejections were
             // packets carrying only recalled memories). The HOST knows the bound
             // source - the task row holds it raw; the context carries only hashes -
@@ -4331,6 +4582,9 @@ class GatewayToolExecutor {
                 !temporalPacketRawSourcesWithinBoundSource(temporalContext, result.packet.source_refs, reviewWindow)) {
                 throw new Error('context_compile packet exceeds the active temporal task source');
             }
+            if (wikiAuthority) {
+                this.markWikiSourceCoverage('context_compile');
+            }
             return {
                 success: true,
                 packet: result.packet,