@jungjaehoon/mama-os 0.47.1 → 0.48.1

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

@@ -49,6 +49,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayToolExecutor = void 0;
+exports.serializeCodeActModelResult = serializeCodeActModelResult;
 const fs_1 = require("fs");
 const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
@@ -73,6 +74,7 @@ const attachment_text_extractor_js_1 = require("./attachment-text-extractor.js")
 const untrusted_content_js_1 = require("../utils/untrusted-content.js");
 const types_js_1 = require("./types.js");
 const external_lifecycle_candidates_js_1 = require("../operator/external-lifecycle-candidates.js");
+const task_ledger_js_1 = require("../operator/task-ledger.js");
 const sqlite_js_1 = __importDefault(require("../sqlite.js"));
 const mama_tool_handlers_js_1 = require("./mama-tool-handlers.js");
 const role_manager_js_1 = require("./role-manager.js");
@@ -81,6 +83,8 @@ 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 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 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");
@@ -93,19 +97,6 @@ const DEFAULT_PRIVATE_CONNECTOR_POLICY = (0, private_connector_policy_js_1.resol
 function isReportPublishResult(value) {
     return value !== undefined && !Array.isArray(value);
 }
-function serializeTaskToolRecord(task) {
-    return {
-        ...task,
-        due_at: task.dueAt === null ? null : new Date(task.dueAt).toISOString(),
-        deadline_offset_minutes: task.deadlineOffsetMinutes,
-        temporal_epoch: task.temporalEpoch,
-        temporal_reconciled_occurrence_key: task.temporalReconciledOccurrenceKey,
-        last_temporal_checked_at: task.lastTemporalCheckedAt,
-        next_temporal_check_at: task.nextTemporalCheckAt,
-        last_temporal_attempt_id: task.lastTemporalAttemptId,
-        temporal_state: task.temporalState,
-    };
-}
 function temporalContextPacketBinding(context) {
     return `temporal:${context.taskId}:${context.generationKey}`;
 }
@@ -206,6 +197,7 @@ const TEMPORAL_WRITE_TOOLS = new Set([
     'obsidian',
     'task_create',
     'task_update',
+    'task_reclassify',
     'contract_no_update',
     'task_temporal_reconcile',
     'Write',
@@ -229,8 +221,31 @@ const TASK_UPDATE_PUBLIC_FIELDS = [
     'expected_revision',
     'context_packet_id',
     'review_anchor_ref',
+    'completion_criteria',
 ];
 const TASK_UPDATE_PUBLIC_FIELD_SET = new Set(TASK_UPDATE_PUBLIC_FIELDS);
+/**
+ * Records and tasks are separate. `completion_criteria` is REQUIRED here (not in
+ * the ledger) so the public agent boundary refuses a title-only row while
+ * internal/system seeding stays backward compatible.
+ */
+const TASK_CREATE_PUBLIC_FIELDS = [
+    'title',
+    'completion_criteria',
+    'status',
+    'priority',
+    'assignee',
+    'deadline',
+    'due_at',
+    'source_channel',
+    'source_event_id',
+    'latest_event',
+    'confirmed',
+    'expected_revision',
+];
+const TASK_CREATE_PUBLIC_FIELD_SET = new Set(TASK_CREATE_PUBLIC_FIELDS);
+const TASK_RECLASSIFY_PUBLIC_FIELDS = ['id', 'disposition', 'reason', 'expected_revision'];
+const TASK_RECLASSIFY_PUBLIC_FIELD_SET = new Set(TASK_RECLASSIFY_PUBLIC_FIELDS);
 const MEMORY_READ_PERMISSION_BEFORE_ENVELOPE_TOOLS = new Set([
     'mama_save',
     'mama_search',
@@ -255,6 +270,30 @@ const OWNER_CONSOLE_MEMBER_TOOLS = new Set([
 ]);
 class ContextPacketProvenanceError extends Error {
 }
+/**
+ * Compact model boundary for Code-Act; internal receipts retain the richer result object.
+ * The JSON root (success, audit ledger, terminal codes) stays machine-readable; when the run
+ * read external evidence only the value/logs payload is fenced as untrusted data.
+ */
+function serializeCodeActModelResult(result) {
+    const record = result;
+    const { message, untrustedExternalEvidence, value, logs, ...modelResult } = record;
+    if (typeof message === 'string' && value === undefined && typeof modelResult.error !== 'string') {
+        modelResult.message = message;
+    }
+    const payload = {
+        ...(value !== undefined ? { value } : {}),
+        ...(logs !== undefined ? { logs } : {}),
+    };
+    if (untrustedExternalEvidence === true) {
+        return JSON.stringify({
+            ...modelResult,
+            untrustedExternalEvidence: true,
+            payload: (0, untrusted_content_js_1.wrapUntrustedContent)('external-evidence-code-act', JSON.stringify(payload)),
+        });
+    }
+    return JSON.stringify({ ...modelResult, ...payload });
+}
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -2522,8 +2561,9 @@ class GatewayToolExecutor {
                             error: 'Report store not wired (board_read requires the API server report store).',
                         };
                     }
-                    const slots = this.reportReader();
-                    return { success: true, slots };
+                    // Default returns slot descriptors only; a named slot pages its text/html
+                    // by code points so a long slot is fully reachable, never silently sliced.
+                    return (0, board_read_views_js_1.readBoardView)(input, this.reportReader());
                 }
                 case 'audit_findings_read': {
                     const auditStatePath = (0, path_1.join)(process.env.HOME || (0, os_1.homedir)(), '.mama', 'state', 'audit-findings.json');
@@ -2618,14 +2658,17 @@ class GatewayToolExecutor {
                 // kagemusha_*: state questions read the source live, never the
                 // connector change-log projection (2026-07-24 incident chain).
                 case 'trello_search': {
-                    const { searchTrelloCards } = await import('../connectors/trello/query-tools.js');
+                    const { searchTrelloBoardCards } = await import('../connectors/trello/query-tools.js');
                     const searchInput = input;
                     try {
-                        const cards = await searchTrelloCards({
+                        // Progressive: honest full match total + continuation + per-board coverage,
+                        // not a hidden 20-result cap. Paged over the cached board snapshot.
+                        const page = await searchTrelloBoardCards({
                             query: searchInput.query ?? '',
                             limit: searchInput.limit,
+                            cursor: searchInput.cursor,
                         });
-                        return { success: true, cards };
+                        return { success: true, ...page };
                     }
                     catch (err) {
                         return {
@@ -2636,10 +2679,19 @@ class GatewayToolExecutor {
                     }
                 }
                 case 'trello_card': {
-                    const { getTrelloCard } = await import('../connectors/trello/query-tools.js');
+                    const { getTrelloCardDetail } = await import('../connectors/trello/query-tools.js');
                     const cardInput = input;
                     try {
-                        const card = await getTrelloCard({ cardId: cardInput.cardId ?? '' });
+                        // Sectioned detail (summary|description|checklists|checklist_items) with
+                        // explicit continuation; the board allowlist is enforced before any field.
+                        const card = await getTrelloCardDetail({
+                            cardId: cardInput.cardId ?? '',
+                            section: cardInput.section,
+                            offset: cardInput.offset,
+                            limit: cardInput.limit,
+                            checklistId: cardInput.checklistId,
+                            readVersion: cardInput.readVersion,
+                        });
                         return { success: true, card };
                     }
                     catch (err) {
@@ -2651,16 +2703,23 @@ class GatewayToolExecutor {
                     }
                 }
                 case 'trello_kanban': {
-                    const { getTrelloKanban } = await import('../connectors/trello/query-tools.js');
+                    const { getTrelloBoardsOverview, getTrelloListCards } = await import('../connectors/trello/query-tools.js');
                     const kanbanInput = input;
                     try {
-                        // Coverage rides alongside the data: `complete`/`boards`/`truncated`/
-                        // `observedAt` are what let a caller tell a truly empty board from one it
-                        // failed to read, and a whole column from a sliced one.
-                        const snapshot = await getTrelloKanban({
-                            maxCardsPerList: kanbanInput.maxCardsPerList,
-                        });
-                        return { success: true, ...snapshot };
+                        // Default returns the board/list overview with counts and coverage - NO
+                        // card arrays. A named (boardId, listId) pages that list's open cards
+                        // beyond the old kanban ceiling, cursor pinned to the read snapshot.
+                        if (kanbanInput.boardId !== undefined || kanbanInput.listId !== undefined) {
+                            const cards = await getTrelloListCards({
+                                boardId: kanbanInput.boardId ?? '',
+                                listId: kanbanInput.listId ?? '',
+                                limit: kanbanInput.limit,
+                                cursor: kanbanInput.cursor,
+                            });
+                            return { success: true, ...cards };
+                        }
+                        const overview = await getTrelloBoardsOverview();
+                        return { success: true, ...overview };
                     }
                     catch (err) {
                         return {
@@ -2671,12 +2730,14 @@ class GatewayToolExecutor {
                     }
                 }
                 case 'kagemusha_messages': {
-                    const { queryMessages } = await import('../connectors/kagemusha/query-tools.js');
+                    const { queryMessagesPage } = await import('../connectors/kagemusha/query-tools.js');
                     const msgInput = input;
                     if (!msgInput.channelId) {
                         throw new types_js_1.AgentError('kagemusha_messages requires channelId', 'TOOL_ERROR', undefined, false);
                     }
-                    return { success: true, messages: queryMessages(msgInput) };
+                    // Progressive: (created_at,id) keyset over an append-only asOf bound with
+                    // total/returned/nextCursor; an unknown channel is a loud missing-source error.
+                    return { success: true, ...queryMessagesPage(msgInput) };
                 }
                 case 'changes_read': {
                     if (!this.taskLedger) {
@@ -2692,37 +2753,23 @@ class GatewayToolExecutor {
                     if (!this.taskLedger) {
                         return { success: false, error: 'Task ledger not configured' };
                     }
+                    // Under a Temporal work context the universe is exactly the one host-bound
+                    // owner task; the views observe/count only it and treat every other id as
+                    // generic missing. Fetch it here so an unavailable bound task stays the same
+                    // superseded signal it was before the progressive views.
                     const temporalContext = this.getExecutionState().temporalWorkContext;
+                    let boundTask;
                     if (temporalContext) {
-                        const boundTask = this.taskLedger.getById(temporalContext.taskId);
-                        if (!boundTask) {
+                        const found = this.taskLedger.getById(temporalContext.taskId);
+                        if (!found) {
                             throw new types_js_1.AgentError('Host-bound temporal owner task is unavailable', 'WORKORDER_SUPERSEDED', undefined, false);
                         }
-                        return {
-                            success: true,
-                            tasks: [serializeTaskToolRecord(boundTask)],
-                        };
+                        boundTask = found;
                     }
-                    const listInput = input;
-                    // total/returned/nextCursor ride with the rows: a read with a caller-passed
-                    // limit is otherwise indistinguishable from the whole board, and a report
-                    // that says "the open items are..." from one page states more than it read.
-                    const page = this.taskLedger.listPage({
-                        status: listInput.status,
-                        includeTerminal: listInput.include_terminal,
-                        channel: listInput.channel,
-                        search: listInput.search,
-                        limit: listInput.limit,
-                        order: listInput.order ?? 'deadline_priority',
-                        cursor: listInput.cursor,
+                    return (0, task_list_views_js_1.runTaskListView)(input, {
+                        ledger: this.taskLedger,
+                        boundTask,
                     });
-                    return {
-                        success: true,
-                        tasks: page.tasks.map(serializeTaskToolRecord),
-                        total: page.total,
-                        returned: page.returned,
-                        nextCursor: page.nextCursor,
-                    };
                 }
                 case 'task_external_correlation': {
                     if (!this.taskLedger) {
@@ -2867,9 +2914,27 @@ class GatewayToolExecutor {
                     if (!this.taskLedger) {
                         return { success: false, error: 'Task ledger not configured' };
                     }
+                    const rawTaskCreate = input;
+                    const unsupportedCreateFields = Object.keys(rawTaskCreate).filter((field) => !TASK_CREATE_PUBLIC_FIELD_SET.has(field));
+                    if (unsupportedCreateFields.length > 0) {
+                        throw new types_js_1.AgentError(`task_create unsupported field(s): ${unsupportedCreateFields.join(', ')}. ` +
+                            `Supported fields: ${TASK_CREATE_PUBLIC_FIELDS.join(', ')}.`, 'TOOL_ERROR', undefined, false);
+                    }
+                    // The records-vs-tasks boundary. A row without a concrete, finite
+                    // completion condition is a RECORD, and a record must not become a task.
+                    const completionCriteria = rawTaskCreate.completion_criteria;
+                    if (typeof completionCriteria !== 'string' || completionCriteria.trim().length === 0) {
+                        throw new types_js_1.AgentError('task_create requires a non-empty completion_criteria: name the concrete, finite ' +
+                            'condition under which this is finished. Observations, lessons, principles, ' +
+                            'aspirations and open questions are records or memory, not tasks - do not create ' +
+                            'a row for them.', 'TOOL_ERROR', undefined, false);
+                    }
+                    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: serializeTaskToolRecord(
+                        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.
@@ -2882,6 +2947,46 @@ class GatewayToolExecutor {
                         })),
                     };
                 }
+                case 'task_reclassify': {
+                    if (!this.taskLedger) {
+                        return { success: false, error: 'Task ledger not configured' };
+                    }
+                    const rawReclassify = input;
+                    const unsupportedReclassifyFields = Object.keys(rawReclassify).filter((field) => !TASK_RECLASSIFY_PUBLIC_FIELD_SET.has(field));
+                    if (unsupportedReclassifyFields.length > 0) {
+                        throw new types_js_1.AgentError(`task_reclassify unsupported field(s): ${unsupportedReclassifyFields.join(', ')}. ` +
+                            `Supported fields: ${TASK_RECLASSIFY_PUBLIC_FIELDS.join(', ')}.`, 'TOOL_ERROR', undefined, false);
+                    }
+                    const rawReclassifyId = rawReclassify.id;
+                    const reclassifyId = typeof rawReclassifyId === 'string'
+                        ? Number(rawReclassifyId.trim())
+                        : rawReclassifyId;
+                    if (!Number.isInteger(reclassifyId) || reclassifyId <= 0) {
+                        throw new types_js_1.AgentError(`task_reclassify requires a numeric id, got: ${String(rawReclassifyId)}`, 'TOOL_ERROR', undefined, false);
+                    }
+                    try {
+                        return {
+                            success: true,
+                            task: (0, task_list_views_js_1.serializeTaskToolRecord)(this.taskLedger.reclassify(reclassifyId, {
+                                disposition: rawReclassify.disposition,
+                                reason: rawReclassify.reason,
+                                expected_revision: rawReclassify.expected_revision,
+                            }, {
+                                // Same trusted-identity rule as task_update: the run and the
+                                // board attempt come from execution state, never the tool call.
+                                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',
+                                reclassificationCauseBound: this.getExecutionState().source === 'owner-event',
+                            })),
+                        };
+                    }
+                    catch (error) {
+                        throw new types_js_1.AgentError(error instanceof Error ? error.message : 'task_reclassify failed', 'TOOL_ERROR', error instanceof Error ? error : undefined, false);
+                    }
+                }
                 case 'task_update': {
                     if (!this.taskLedger) {
                         return { success: false, error: 'Task ledger not configured' };
@@ -2902,6 +3007,17 @@ class GatewayToolExecutor {
                             `Supported fields: ${TASK_UPDATE_PUBLIC_FIELDS.join(', ')}. ` +
                             '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 ||
+                            criteria.trim().length > task_ledger_js_1.TASK_COMPLETION_CRITERIA_MAX_LENGTH) {
+                            throw new types_js_1.AgentError(`task_update completion_criteria must be a non-empty string of at most ${task_ledger_js_1.TASK_COMPLETION_CRITERIA_MAX_LENGTH} characters`, 'TOOL_ERROR', undefined, false);
+                        }
+                    }
                     const { id: rawId, context_packet_id: contextPacketId, review_anchor_ref: reviewAnchorRef, ...patch } = rawTaskUpdate;
                     // Agents routinely pass "12"; coerce, reject non-numeric with a typed error.
                     const id = typeof rawId === 'string' ? Number(rawId.trim()) : rawId;
@@ -2976,7 +3092,7 @@ class GatewayToolExecutor {
                         causeKind: this.getExecutionState().source === 'operator' ? 'clock' : 'owner_message',
                         ...(verifiedReviewEvidence ? { verifiedReviewEvidence } : {}),
                     });
-                    return { success: true, task: serializeTaskToolRecord(updated) };
+                    return { success: true, task: (0, task_list_views_js_1.serializeTaskToolRecord)(updated) };
                 }
                 case 'task_temporal_reconcile': {
                     if (!this.taskLedger) {
@@ -3908,7 +4024,7 @@ class GatewayToolExecutor {
                 usedUntrustedExternalEvidence = true;
             }
         };
-        bridge.injectInto(sandbox, policy.names);
+        bridge.injectInto(sandbox, policy);
         const result = await sandbox.execute(input.code, { signal: state.signal });
         const terminalMutationCodes = new Set([
             CODE_ACT_MUTATION_COMMITTED_AFTER_ABORT,
@@ -3943,6 +4059,7 @@ class GatewayToolExecutor {
             metrics: result.metrics,
             hostToolExecutions,
             hostToolsInvoked,
+            ...(usedUntrustedExternalEvidence ? { untrustedExternalEvidence: true } : {}),
             message: result.success
                 ? usedUntrustedExternalEvidence
                     ? (0, untrusted_content_js_1.wrapUntrustedContent)('external-evidence-code-act', successfulMessage)