@jungjaehoon/mama-os 0.40.0 → 0.42.0

package/dist/cli/commands/start.js

@@ -45,7 +45,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPERATOR_REPORT_TOOL_POLICY = exports.WORKORDER_TOOL_POLICIES = void 0;
+exports.OPERATOR_REPORT_TOOL_POLICY = exports.TURN_KIND_BLOCKED_TOOLS = exports.SCHEDULED_TURN_BLOCKED_TOOLS = exports.TURN_KIND_REQUIRED_TOOLS = exports.ADMINISTRATION_TOOLS = exports.ONE_AGENT_TURN_POLICY = void 0;
 exports.workOrderActivityDetails = workOrderActivityDetails;
 exports.createCorePrincipalRegistry = createCorePrincipalRegistry;
 exports.createCorePrincipalResolver = createCorePrincipalResolver;
@@ -60,14 +60,13 @@ exports.causeEventIdsFromPayload = causeEventIdsFromPayload;
 exports.workOrderEnvelopeScope = workOrderEnvelopeScope;
 exports.temporalTaskBinding = temporalTaskBinding;
 exports.buildOperatorReportAgentPolicy = buildOperatorReportAgentPolicy;
-exports.buildWorkOrderAgentPolicy = buildWorkOrderAgentPolicy;
+exports.isOutboundToolName = isOutboundToolName;
+exports.buildTurnAgentPolicy = buildTurnAgentPolicy;
 exports.bindCodeActParentModelRun = bindCodeActParentModelRun;
 exports.finalizeCodeActParentModelRun = finalizeCodeActParentModelRun;
 exports.failCodeActParentModelRun = failCodeActParentModelRun;
 exports.buildSystemAgentProcessDefaults = buildSystemAgentProcessDefaults;
-exports.buildOwnerEventBoardRefreshRuntime = buildOwnerEventBoardRefreshRuntime;
 exports.resolveOwnerEventTerminalReceipt = resolveOwnerEventTerminalReceipt;
-exports.buildOwnerWorkOrderRequestHandler = buildOwnerWorkOrderRequestHandler;
 exports.startCommand = startCommand;
 exports.buildStartOnboardingOutput = buildStartOnboardingOutput;
 exports.runAgentLoop = runAgentLoop;
@@ -135,11 +134,12 @@ const query_tools_js_1 = require("../../connectors/trello/query-tools.js");
 const console_brief_js_1 = require("../../operator/console-brief.js");
 const task_ledger_js_1 = require("../../operator/task-ledger.js");
 const board_refresh_gate_js_1 = require("../../operator/board-refresh-gate.js");
-const workorder_publishers_js_1 = require("../../operator/workorder-publishers.js");
 const owner_event_inbox_js_1 = require("../../operator/owner-event-inbox.js");
 const owner_event_effects_js_1 = require("../../operator/owner-event-effects.js");
-const owner_event_board_refresh_js_1 = require("../../operator/owner-event-board-refresh.js");
 const owner_event_loop_js_1 = require("../../operator/owner-event-loop.js");
+const board_pipeline_render_js_1 = require("../../operator/board-pipeline-render.js");
+const learning_context_js_1 = require("../../operator/learning-context.js");
+const learning_read_js_1 = require("../../operator/learning-read.js");
 const owner_event_prompt_js_1 = require("../../operator/owner-event-prompt.js");
 const owner_event_policy_js_1 = require("../../operator/owner-event-policy.js");
 const leg_cadence_js_1 = require("../../operator/leg-cadence.js");
@@ -156,7 +156,6 @@ const principalRegistryLogger = new DebugLogger('PrincipalRegistry');
 function workOrderActivityDetails(event) {
     return event.briefHash ? { brief_hash: event.briefHash } : undefined;
 }
-const ownerWorkOrderLogger = new DebugLogger('OwnerWorkOrder');
 const DISABLED_PRIVATE_CONNECTOR_POLICY = (0, private_connector_policy_js_1.resolvePrivateConnectorPolicy)({
     ok: true,
     config: {},
@@ -393,12 +392,18 @@ function causeEventIdsFromPayload(payload) {
 }
 function workOrderEnvelopeScope(input) {
     const isTemporal = input.workKind === 'temporal';
-    const surface = (0, private_connector_policy_js_1.resolveWorkOrderPrivateSurface)(input.workKind);
+    // One principal for every turn; what differs per kind is WHICH connectors the run
+    // may read, and that is data: a recheck reads its task's connector or nothing, a
+    // wiki turn reads no PRIVATE connector (personal channels never feed public pages),
+    // the board and curation turns keep the lane's configured connectors.
+    const surface = exports.ONE_AGENT_TURN_POLICY.roleName;
     const candidateConnectors = isTemporal
         ? input.temporalBinding
             ? [input.temporalBinding.connector]
             : []
-        : input.laneConnectors;
+        : input.workKind === 'wiki'
+            ? input.laneConnectors.filter((name) => !input.privateConnectorPolicy.enabledPrivateConnectors.includes(name))
+            : input.laneConnectors;
     return {
         project_refs: [{ kind: 'project', id: input.projectId }],
         // A temporal run reads its task's connector or nothing. Every other lane keeps the
@@ -426,6 +431,11 @@ function workOrderEnvelopeScope(input) {
                     },
                 ]
                 : []),
+            // Same rule for a board reconcile: the run is bound to the channel whose delta it
+            // judges, and connector memories are scoped by the canonical channel key.
+            ...(input.workKind === 'board' && input.reconcileChannelKey
+                ? [{ kind: 'channel', id: input.reconcileChannelKey }]
+                : []),
         ],
         allowed_destinations: [],
     };
@@ -453,48 +463,115 @@ function buildCodeActRole(policy) {
         sensitiveAccess: false,
     };
 }
-// Stage-2 workers are short-lived operator jobs, not standing multi-agent
-// personas. Their permissions must therefore be complete on a default install
-// and must not vary with optional legacy agent configuration.
-exports.WORKORDER_TOOL_POLICIES = {
-    board: {
-        roleName: 'workorder-board',
-        allowedTools: [
-            'agent_notices',
-            'changes_read',
-            'context_compile',
-            'contract_no_update',
-            'mama_search',
-            'report_publish',
-            'task_create',
-            'task_external_correlation',
-            'task_external_bind',
-            'task_lifecycle_reconcile',
-            'task_list',
-            'task_update',
-            'trello_card',
-            'trello_kanban',
-            'trello_search',
-        ],
-    },
-    wiki: {
-        roleName: 'workorder-wiki',
-        allowedTools: ['agent_notices', 'context_compile', 'mama_search', 'obsidian', 'wiki_publish'],
-    },
-    'memory-curation': {
-        roleName: 'workorder-memory-curation',
-        allowedTools: ['agent_notices', 'mama_save', 'mama_search'],
-    },
-    temporal: {
-        roleName: 'workorder-temporal',
-        allowedTools: [
-            'agent_notices',
-            'context_compile',
-            'schedule_upcoming',
-            'task_list',
-            'task_temporal_reconcile',
-        ],
-    },
+/**
+ * One MAMA: every scheduled turn runs as the SAME principal the owner console and the
+ * event turn use. `roleName` is not a label - resolvePrivatePrincipalSurface switches on
+ * it and falls through to 'multi-agent-generic' for anything it does not know, which
+ * splits the advertised catalog from the execution envelope.
+ */
+exports.ONE_AGENT_TURN_POLICY = { roleName: 'owner_console' };
+/** Owner-authored chat only: administration never runs unattended. */
+exports.ADMINISTRATION_TOOLS = new Set([
+    'member_register',
+    'member_suspend',
+    'member_offboard',
+    'member_scope_grant',
+    'member_scope_revoke',
+    'console_brief_update',
+    'report_request',
+]);
+/**
+ * Per-turn-kind artifact tools, projected by the HOST. These exist only for scheduled
+ * turns and are deliberately absent from the chat grant: a chat turn never publishes a
+ * board slot or a wiki page and never files a temporal receipt. They are the tools the
+ * turn-kind section instructs the turn to use, so grant and instruction cannot drift.
+ */
+exports.TURN_KIND_REQUIRED_TOOLS = {
+    board: [
+        'agent_notices',
+        'contract_no_update',
+        'report_publish',
+        'task_external_correlation',
+        'task_external_bind',
+        'task_lifecycle_reconcile',
+    ],
+    wiki: ['agent_notices', 'contract_no_update', 'wiki_publish'],
+    'memory-curation': ['agent_notices', 'contract_no_update'],
+    temporal: ['agent_notices', 'contract_no_update', 'task_temporal_reconcile'],
+};
+/**
+ * Blocked on EVERY unattended turn. Deliverable, image and Drive tools belong to the
+ * owner conversation, and the tier-2 Code-Act projection refuses them anyway - a tool
+ * that is advertised but never injected is a hallucinated-call generator. Member data and
+ * workspace file reads are owner-conversation material with no use in a scheduled turn.
+ */
+exports.SCHEDULED_TURN_BLOCKED_TOOLS = new Set([
+    // workspace file reads are an owner-conversation tool; no turn section instructs one
+    'Read',
+    // every outbound channel, not only Telegram: the grant is derived from the owner's
+    // (editable) role config, so a send tool added there must still never run unattended
+    'telegram_send',
+    'discord_send',
+    'slack_send',
+    'webchat_send',
+    'drive_upload',
+    'drive_list_drives',
+    'drive_browse',
+    'drive_find_folder',
+    'drive_download',
+    'ocr_image',
+    'create_fb_overlay',
+    'translate_conti',
+    'drive_translate_conti',
+    'member_candidates',
+    'member_list',
+    'member_scope_list',
+]);
+/**
+ * Per-turn-kind blocked lists, projected by the HOST. One principal and one brief do
+ * not mean one grant for every trigger: an unattended board or wiki turn has no owner
+ * in the loop, so it never holds a send, an upload, or a mutation outside its own
+ * artifact. Each entry names the artifact it protects.
+ */
+exports.TURN_KIND_BLOCKED_TOOLS = {
+    // board writes judgment slots and task lifecycle (reconcile mode creates rows for new
+    // items, which the action verifier's obligated set expects); it does not touch memory
+    // or the vault (obsidian is the wiki lane's write path)
+    board: new Set([
+        'wiki_publish',
+        'obsidian',
+        'mama_save',
+        'mama_update',
+        'task_temporal_reconcile',
+    ]),
+    // wiki writes pages; the ledger, the board and memory are not its artifact
+    wiki: new Set([
+        'report_publish',
+        'mama_save',
+        'mama_update',
+        'task_create',
+        'task_update',
+        'task_temporal_reconcile',
+    ]),
+    // curation writes memory; nothing else
+    'memory-curation': new Set([
+        'report_publish',
+        'wiki_publish',
+        'task_create',
+        'task_update',
+        'task_temporal_reconcile',
+        'obsidian',
+    ]),
+    // recheck resolves ONE task through task_temporal_reconcile; generic mutation is out
+    temporal: new Set([
+        'report_publish',
+        'wiki_publish',
+        'mama_save',
+        'mama_update',
+        'task_create',
+        'task_update',
+        'obsidian',
+    ]),
 };
 /**
  * Packet-only reports receive no gateway tools. The host compiles current bounded authorities
@@ -563,27 +640,42 @@ function buildOperatorReportAgentPolicy(model, backend, privateConnectorPolicy)
         briefProjectionPolicy: requiredPrivatePolicy,
     };
 }
-function buildWorkOrderAgentPolicy(kind, model, backend, privateConnectorPolicy, rawConnectorScope) {
+/** Outbound effect by name: sends to a channel or uploads to a shared store. */
+function isOutboundToolName(tool) {
+    return /(^|_)(send|upload)(_|$)/.test(tool);
+}
+function buildTurnAgentPolicy(kind, model, backend, privateConnectorPolicy, rawConnectorScope, ownerRole = types_js_1.DEFAULT_ROLES.definitions.owner_console) {
     const requiredPrivatePolicy = requirePrivateConnectorPolicy(privateConnectorPolicy);
     if (!rawConnectorScope) {
         throw new Error('rawConnectorScope is required');
     }
-    const policy = exports.WORKORDER_TOOL_POLICIES[kind];
-    if (!policy) {
-        throw new Error(`Missing built-in workorder tool policy for '${kind}'`);
+    const kindBlocked = exports.TURN_KIND_BLOCKED_TOOLS[kind];
+    if (!kindBlocked) {
+        throw new Error(`Missing turn-kind blocked list for '${kind}'`);
     }
-    const surface = (0, private_connector_policy_js_1.resolveWorkOrderPrivateSurface)(kind);
+    // Same downgrade the event turn applies: a run with no private binding advertises
+    // no private connector tools and gets the disabled brief projection.
     const scopedSurface = requiredPrivatePolicy.enabledPrivateConnectors.some((name) => rawConnectorScope.includes(name))
-        ? surface
+        ? exports.ONE_AGENT_TURN_POLICY.roleName
         : 'multi-agent-generic';
-    const projectedRole = buildProjectedLaneRole(scopedSurface, policy.allowedTools, requiredPrivatePolicy);
-    const blockedTools = [...(projectedRole.blockedTools ?? [])];
-    const innerTools = uniqueToolList(projectedRole.allowedTools);
+    const blockedSet = new Set([
+        ...exports.ADMINISTRATION_TOOLS,
+        ...exports.SCHEDULED_TURN_BLOCKED_TOOLS,
+        ...kindBlocked,
+        ...(ownerRole.blockedTools ?? []),
+        // Shape rule on top of the named lists: the role config is owner-editable, so a
+        // send or upload tool that appears there tomorrow is still never unattended.
+        ...ownerRole.allowedTools.filter((tool) => isOutboundToolName(tool)),
+    ]);
+    const projectedRole = buildProjectedLaneRole(scopedSurface, uniqueToolList([...ownerRole.allowedTools, ...exports.TURN_KIND_REQUIRED_TOOLS[kind]]).filter((tool) => !blockedSet.has(tool)), requiredPrivatePolicy);
+    const blockedTools = [...new Set([...(projectedRole.blockedTools ?? []), ...blockedSet])];
+    // code_act is the transport, re-added at the front below; it is never an inner tool.
+    const innerTools = uniqueToolList(projectedRole.allowedTools).filter((tool) => !blockedSet.has(tool) && tool !== 'code_act');
     const allowedTools = uniqueToolList(['code_act', ...innerTools]);
     const agentContext = {
         source: 'operator',
         platform: 'cli',
-        roleName: policy.roleName,
+        roleName: exports.ONE_AGENT_TURN_POLICY.roleName,
         role: { ...projectedRole, allowedTools, blockedTools, model },
         session: {
             sessionId: `operator:worker:${kind}`,
@@ -655,104 +747,27 @@ function buildSystemAgentProcessDefaults(config) {
         dangerouslySkipPermissions: config.multi_agent?.dangerouslySkipPermissions ?? true,
     };
 }
-const OWNER_BOARD_FULL_REPAIR_CHANNEL = 'host:owner-workorder:board-full';
-function buildOwnerEventBoardRefreshRuntime(operatorDb, taskLedger, now = Date.now) {
-    const ownerEventBoardRefreshLedger = new owner_event_board_refresh_js_1.OwnerEventBoardRefreshLedger(operatorDb, taskLedger, now);
-    const initialGeneration = (0, owner_event_board_refresh_js_1.resolveInitialBoardRepairGeneration)(now(), ownerEventBoardRefreshLedger.maxPendingGeneration());
-    return {
-        ownerEventBoardRefreshLedger,
-        boardRefreshGate: new board_refresh_gate_js_1.BoardRefreshGate({ initialGeneration }),
-    };
-}
 function resolveOwnerEventTerminalReceipt(batch, deps) {
-    const confirmedEffects = deps.ownerEventEffectLedger.confirmedKinds(batch.id);
-    if (confirmedEffects.length > 0) {
-        return { status: 'acted', tools: confirmedEffects };
-    }
-    const acceptedWorkOrder = deps.ownerEventBoardRefreshLedger.findAcceptance(batch.id) ??
-        deps.taskLedger.findWorkOrderByOccurrence('board', (0, workorder_publishers_js_1.boardBatchKey)(batch.eventIds)) ??
-        deps.taskLedger.findWorkOrderByOccurrence('wiki', (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('wiki', batch.eventIds)) ??
-        deps.taskLedger.findWorkOrderByOccurrence('memory-curation', (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('memory-curation', batch.eventIds));
-    if (acceptedWorkOrder) {
-        return { status: 'delegated', tools: ['workorder_request'] };
+    // Crash-recovery mirror of classifyOwnerEventOutcome. A ledger write that
+    // named this batch's events as its cause (evidence_effects) or a confirmed
+    // deliverable (drive_upload) is a durable outcome even if the run died after
+    // it - without this, a task created before a transport error is created again
+    // on retry. A confirmed telegram_send alone is not a receipt, and the effect
+    // ledger's (batch, action_key) idempotency makes that retry safe from a second
+    // send. A persisted Board acceptance is no longer a receipt.
+    const ledgerEffects = deps.taskLedger.effectsCausedBy(batch.eventIds, batch.createdAt);
+    const confirmedEffects = deps.ownerEventEffectLedger
+        .confirmedKinds(batch.id)
+        .filter((kind) => kind !== 'telegram_send');
+    const durable = [...new Set([...ledgerEffects, ...confirmedEffects])];
+    if (durable.length > 0) {
+        return { status: 'acted', tools: durable, ownerDecisionRequested: false };
     }
     if (deps.taskLedger.maxNoUpdateId(`owner-event:${batch.id}`) > 0) {
         return { status: 'no_update', tools: [] };
     }
     return null;
 }
-/** Build the enqueue-and-ack handler shared by owner chat and owner-event turns. */
-function buildOwnerWorkOrderRequestHandler(deps) {
-    const now = deps.now ?? Date.now;
-    const log = deps.log ?? ((line) => ownerWorkOrderLogger.info(line));
-    const logError = deps.logError ?? ((line, detail) => ownerWorkOrderLogger.error(line, detail));
-    return (kind, origin = { kind: 'owner_manual' }) => {
-        try {
-            const requestedAt = now();
-            let idempotencyKey;
-            let payload;
-            if (kind === 'board') {
-                if (!deps.boardRefreshGate) {
-                    throw new Error('Board refresh gate is unavailable');
-                }
-                if (origin.kind === 'owner_event') {
-                    if (!deps.ownerEventBoardRefreshLedger) {
-                        throw new Error('Owner-event Board refresh ledger is unavailable');
-                    }
-                    const existing = deps.ownerEventBoardRefreshLedger.findAcceptance(origin.batchId);
-                    if (existing) {
-                        log(`[stage2] owner workorder already accepted: board#${existing.workOrderId}`);
-                        return { accepted: true };
-                    }
-                    deps.boardRefreshGate.markChannelDirty(OWNER_BOARD_FULL_REPAIR_CHANNEL);
-                    const accepted = deps.ownerEventBoardRefreshLedger.accept({
-                        batchId: origin.batchId,
-                        eventIds: origin.eventIds,
-                        repair: deps.boardRefreshGate.captureFullRepair(),
-                    });
-                    log(`[stage2] owner workorder accepted: board#${accepted.workOrderId}`);
-                    return { accepted: true };
-                }
-                // TG-06: host dirt is recorded before validation or enqueue can fail.
-                // The fixed synthetic channel never trusts model/event identifiers.
-                deps.boardRefreshGate.markChannelDirty(OWNER_BOARD_FULL_REPAIR_CHANNEL);
-                const repair = deps.boardRefreshGate.captureFullRepair();
-                idempotencyKey = (0, workorder_publishers_js_1.boardManualKey)(requestedAt);
-                payload = { mode: 'full', force: true, ...repair };
-            }
-            else if (kind === 'wiki') {
-                if (origin.kind === 'owner_event') {
-                    idempotencyKey = (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('wiki', origin.eventIds);
-                    payload = { batchId: idempotencyKey, events: [...origin.eventIds] };
-                }
-                else {
-                    idempotencyKey = (0, workorder_publishers_js_1.wikiBatchKey)('manual', requestedAt);
-                    payload = { batchId: `${requestedAt}-manual`, events: ['manual'] };
-                }
-            }
-            else {
-                idempotencyKey =
-                    origin.kind === 'owner_event'
-                        ? (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('memory-curation', origin.eventIds)
-                        : (0, workorder_publishers_js_1.promotionManualKey)(requestedAt);
-                payload = { scheduledAt: new Date(requestedAt).toISOString() };
-            }
-            (0, workorder_publishers_js_1.validateWorkOrderPayload)(kind, payload);
-            const wo = deps.taskLedger.enqueueWorkOrder({
-                workKind: kind,
-                idempotencyKey,
-                input: payload,
-                priority: 'high',
-            });
-            log(`[stage2] owner workorder enqueued: ${kind}#${wo.id}`);
-            return { accepted: true };
-        }
-        catch (err) {
-            logError(`[stage2] owner workorder enqueue failed (${kind}):`, err instanceof Error ? err.message : err);
-            return { accepted: false, reason: 'enqueue-failed' };
-        }
-    };
-}
 /**
  * Execute start command
  */
@@ -864,8 +879,10 @@ async function runAgentLoop(config, options = {}) {
     const temporalStartup = (0, temporal_runtime_js_1.preflightTemporalStartup)(process.env);
     const runtimeBackend = requireRuntimeBackend(config.agent.backend);
     const { connectorConfigLoadResult, privateConnectorPolicy } = (0, connector_bootstrap_js_1.resolveRuntimeConnectorBootstrap)((0, config_loader_js_1.loadConnectorConfig)());
+    // ONE owner role for every model turn: chat, event, and scheduled.
+    const ownerRole = config.roles?.definitions.owner_console ?? types_js_1.DEFAULT_ROLES.definitions.owner_console;
     const temporalPolicy = temporalStartup.temporalFlag === 'on'
-        ? buildWorkOrderAgentPolicy('temporal', config.agent.model, runtimeBackend, privateConnectorPolicy, [])
+        ? buildTurnAgentPolicy('temporal', config.agent.model, runtimeBackend, privateConnectorPolicy, [], ownerRole)
         : null;
     const temporalEffectiveTools = temporalPolicy
         ? (0, tool_policy_js_1.projectCodeActToolPolicy)({
@@ -1316,7 +1333,9 @@ async function runAgentLoop(config, options = {}) {
     // delta reconcile scheduling; exact owner-event Board acceptance, boot
     // recovery, manual refresh, and full verification share this runtime in all
     // configurations.
-    const { ownerEventBoardRefreshLedger, boardRefreshGate } = buildOwnerEventBoardRefreshRuntime(operatorDb, taskLedger);
+    // Host-owned Board repair gate. Generations are wall time: with the owner-event
+    // intent ledger gone there is no persisted pending generation to seed above.
+    const boardRefreshGate = new board_refresh_gate_js_1.BoardRefreshGate({ initialGeneration: Date.now() });
     const ownerEventEffectLedger = new owner_event_effects_js_1.OwnerEventEffectLedger(operatorDb);
     toolExecutor.setOwnerEventEffectLedger(ownerEventEffectLedger);
     let stopOwnerEventRuntime = null;
@@ -1366,6 +1385,10 @@ async function runAgentLoop(config, options = {}) {
     resolveWorkerRequestTimeoutMs();
     let workOrderConsumer = null;
     const boardRepairNudge = { current: null };
+    const pipelineSlotPublisher = {
+        current: null,
+    };
+    const learningBlockRef = { current: null };
     let temporalRuntime = null;
     gateways.push({
         stop: async () => {
@@ -1388,10 +1411,8 @@ async function runAgentLoop(config, options = {}) {
     });
     {
         const { WorkOrderConsumer } = await import('../../operator/workorder-consumer.js');
-        const { loadBrief, ensureBriefs } = await import('../../operator/briefs.js');
-        // Seed missing default briefs (user edits win) BEFORE the consumer exists -
+        // Seed the ONE operating brief (user edits win) BEFORE the consumer exists -
         // a normal install must never hit the brief-missing fail path.
-        ensureBriefs();
         (0, console_brief_js_1.ensureConsoleBrief)();
         const { logActivity: logWorkOrderActivity } = await import('../../db/agent-store.js');
         // Ops alarm sink (plan D4/E1/G8): constructed OUTSIDE any trigger-loop
@@ -1423,7 +1444,42 @@ async function runAgentLoop(config, options = {}) {
         workOrderConsumer = new WorkOrderConsumer({
             ledger: taskLedger,
             runner: workerRunner,
-            loadBrief: (kind) => loadBrief(kind),
+            loadOwnerBrief: () => (0, console_brief_js_1.loadConsoleBrief)(),
+            // Host-rendered pipeline: the ledger's own deadline_priority page, published through
+            // the SAME report publisher report_publish uses (bound after the API routes exist).
+            buildLearningBlock: async (wo) => {
+                const build = learningBlockRef.current;
+                if (!build) {
+                    return '';
+                }
+                const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
+                // Same binding the run's envelope gets: a recheck's lessons live under its task's channel.
+                const temporalBinding = wo.workKind === 'temporal'
+                    ? temporalTaskBinding(taskLedger, (0, temporal_worker_js_1.buildTemporalWorkerContext)(taskLedger, wo).taskId)
+                    : null;
+                const scope = workOrderEnvelopeScope({
+                    workKind: wo.workKind,
+                    projectId,
+                    laneConnectors: codeActRawConnectors,
+                    temporalBinding,
+                    reconcileChannelKey: wo.workKind === 'board' && typeof wo.payload.channelKey === 'string'
+                        ? wo.payload.channelKey
+                        : null,
+                    privateConnectorPolicy,
+                });
+                return build(wo.workKind, scope.memory_scopes, wo.workKind);
+            },
+            publishPipelineSlot: () => {
+                const publish = pipelineSlotPublisher.current;
+                if (!publish)
+                    throw new Error('pipeline slot publisher is not bound yet');
+                const page = taskLedger.listPage({
+                    includeTerminal: false,
+                    order: 'deadline_priority',
+                    limit: board_pipeline_render_js_1.PIPELINE_SLOT_ROWS,
+                });
+                publish({ pipeline: (0, board_pipeline_render_js_1.renderPipelineSlot)(page.tasks, Date.now(), page.total) });
+            },
             noticeOwner: (summary) => messageRouter.enqueueOperatorNotice(summary),
             opsAlarm,
             runOptionsFor: async (wo) => {
@@ -1439,11 +1495,17 @@ async function runAgentLoop(config, options = {}) {
                     temporalBinding = temporalTaskBinding(taskLedger, temporalContext.taskId);
                 }
                 const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
+                const reconcileChannelKey = wo.workKind === 'board' &&
+                    wo.payload.mode === 'reconcile' &&
+                    typeof wo.payload.channelKey === 'string'
+                    ? wo.payload.channelKey
+                    : null;
                 const workOrderScope = workOrderEnvelopeScope({
                     workKind: wo.workKind,
                     projectId,
                     laneConnectors: codeActRawConnectors,
                     temporalBinding,
+                    reconcileChannelKey,
                     privateConnectorPolicy,
                 });
                 // Worker prompt selects the provider's supported tool path: Claude's
@@ -1451,7 +1513,7 @@ async function runAgentLoop(config, options = {}) {
                 // spawn-default code-act path, where per-run envelope/capture overrides
                 // cannot reach (shadow-gate §8.2).
                 const { buildWorkerSystemPrompt } = await import('../../operator/worker-run.js');
-                const workOrderPolicy = buildWorkOrderAgentPolicy(wo.workKind, config.agent.model, runtimeBackend, privateConnectorPolicy, workOrderScope.raw_connectors);
+                const workOrderPolicy = buildTurnAgentPolicy(wo.workKind, config.agent.model, runtimeBackend, privateConnectorPolicy, workOrderScope.raw_connectors, ownerRole);
                 const runOptions = attachWorkOrderAttemptContext({
                     systemPrompt: buildWorkerSystemPrompt(workOrderPolicy.gatewayToolsPrompt, runtimeBackend, wo.workKind),
                     agentContext: workOrderPolicy.agentContext,
@@ -1489,7 +1551,7 @@ async function runAgentLoop(config, options = {}) {
                 if (envelopeBootstrap.envelopeAuthority && envelopeBootstrap.metadata.issuance !== 'off') {
                     const wallSeconds = Math.min(Math.max(Number(process.env.MAMA_REPORT_WALL_SECONDS) || 900, 60), 1800);
                     runOptions.envelope = await envelopeBootstrap.envelopeAuthority.buildAndPersist({
-                        agent_id: `workorder-${wo.workKind}`,
+                        agent_id: 'mama-owner',
                         instance_id: (0, node_crypto_1.randomUUID)(),
                         // 'watch' = daemon-internal issuing source (closed EnvelopeSource
                         // union; enforcement authorizes on scope, never on source).
@@ -1511,7 +1573,7 @@ async function runAgentLoop(config, options = {}) {
                 // keeps the operational trace queryable.
                 try {
                     logWorkOrderActivity(db, {
-                        agent_id: `workorder-${event.workKind}`,
+                        agent_id: 'mama-owner',
                         agent_version: 0,
                         type: `workorder_${event.type}`,
                         input_summary: `#${event.workOrderId}`,
@@ -1528,21 +1590,9 @@ async function runAgentLoop(config, options = {}) {
                 catch {
                     /* telemetry only */
                 }
-                if (event.type === 'complete' &&
-                    event.workKind === 'board' &&
-                    ownerEventBoardRefreshLedger.consumePostTerminalFollowup(event.workOrderId)) {
-                    boardRepairNudge.current?.();
-                }
             },
         });
         // (Consumer stop is folded into the operator-DB gateway above - ordering.)
-        // Owner-issued workorders (workorder_request tool): enqueue+ack only.
-        // Wired here - NOT inside any trigger-loop block (plan C11 class).
-        toolExecutor.setWorkOrderRequestHandler(buildOwnerWorkOrderRequestHandler({
-            taskLedger,
-            boardRefreshGate,
-            ownerEventBoardRefreshLedger,
-        }));
     }
     const temporalTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     const temporalAssembly = (0, temporal_init_js_1.assembleDaemonTemporalRuntime)({
@@ -1571,6 +1621,25 @@ async function runAgentLoop(config, options = {}) {
     if (connectorSchedulerStop) {
         gateways.push({ stop: () => Promise.resolve(connectorSchedulerStop()) });
     }
+    // Owner policy and lessons: bound BEFORE the consumer starts (bootAfterRoutes) and
+    // independent of the trigger loop, so scheduled turns carry the block even when
+    // MAMA_TRIGGER_LOOP=0.
+    // Owner policy and lessons for a turn: one bounded read path for event, scheduled
+    // and (via MamaApiClient) chat turns. Returns the rendered block or ''.
+    const learningReader = (0, learning_read_js_1.cappedLearningReader)((params) => mamaCore.queryRelevantTruth({ query: params.query, scopes: params.scopes }), (line) => console.log(line));
+    const buildLearningBlockFor = async (turn, scopes, query) => {
+        try {
+            const context = await (0, learning_context_js_1.buildLearningContext)({ scopes, query, readClaims: learningReader });
+            const channelScopeId = scopes.find((scope) => scope.kind === 'channel')?.id ?? null;
+            console.log((0, learning_context_js_1.formatLearningAuditLine)(turn, channelScopeId, context));
+            return context.promptBlock;
+        }
+        catch (error) {
+            console.error(`[learning] ${turn} block failed: ${error instanceof Error ? error.message : String(error)}`);
+            return '';
+        }
+    };
+    learningBlockRef.current = buildLearningBlockFor;
     // ── Trigger loop (M1, default-on): agent-evolved triggers on the live stream ──
     // MAMA_TRIGGER_LOOP=0 is the explicit opt-out. Placed after initConnectors (which feeds
     // connector_event_index) and after mama-core initDB. Read-only: recall/surface/log.
@@ -1661,6 +1730,21 @@ async function runAgentLoop(config, options = {}) {
                 issuance: envelopeBootstrap.metadata.issuance,
                 hasAuthority: ownerEventEnvelopeAuthority !== undefined,
             });
+            // Scope-independent packet readers, shared by the report leg and the event turn.
+            const reportContextDeps = {
+                listTaskPage: (input) => taskLedger.listPage(input),
+                readClaims: (scope) => mamaCore.queryRelevantTruth({ query: '', scopes: scope.memoryScopes }),
+                readTrello: async (scope) => {
+                    if (!scope.rawConnectors.includes('trello')) {
+                        throw new Error('Trello is outside the owner-report read scope');
+                    }
+                    return (0, query_tools_js_1.getTrelloKanban)({ maxCardsPerList: 100 });
+                },
+                buildProvenanceLookup: provenance_lookup_js_1.buildProvenanceLookup,
+                correlate: external_correlation_js_1.correlateTasksWithExternalItems,
+                readChanges: (_scope, input, nowMs) => (0, changes_projection_js_1.readChanges)(taskLedger, input, nowMs),
+                now: Date.now,
+            };
             const triggerLoop = new OperatorTriggerLoop({
                 backend: runtimeBackend,
                 delta: new ConnectorDeltaRepo(getAdapter(), (0, config_manager_js_1.expandPath)('~/.mama/operator/trigger-loop-cursors.json')),
@@ -1726,20 +1810,7 @@ async function runAgentLoop(config, options = {}) {
                         ],
                     };
                 })(),
-                compileFullReportContext: async ({ readScope, windowEvidence, since }) => (0, report_context_js_1.compileOwnerReportContext)({ readScope, windowEvidence, since }, {
-                    listTaskPage: (input) => taskLedger.listPage(input),
-                    readClaims: (scope) => mamaCore.queryRelevantTruth({ query: '', scopes: scope.memoryScopes }),
-                    readTrello: async (scope) => {
-                        if (!scope.rawConnectors.includes('trello')) {
-                            throw new Error('Trello is outside the owner-report read scope');
-                        }
-                        return (0, query_tools_js_1.getTrelloKanban)({ maxCardsPerList: 100 });
-                    },
-                    buildProvenanceLookup: provenance_lookup_js_1.buildProvenanceLookup,
-                    correlate: external_correlation_js_1.correlateTasksWithExternalItems,
-                    readChanges: (_scope, input, nowMs) => (0, changes_projection_js_1.readChanges)(taskLedger, input, nowMs),
-                    now: Date.now,
-                }),
+                compileFullReportContext: async ({ readScope, windowEvidence, since }) => (0, report_context_js_1.compileOwnerReportContext)({ readScope, windowEvidence, since }, reportContextDeps),
                 // TG-06: composition supplies provenance immediately to the prepared
                 // delivery; this callback receives that durable artifact only after send success.
                 fullReportProvenance: () => lastReportProvenance,
@@ -1792,7 +1863,6 @@ async function runAgentLoop(config, options = {}) {
                 // MAMA itself owns connector events. This is the same AgentLoop and
                 // owner operating policy as the owner console, on a durable per-channel
                 // background session. There is no separate Conductor persona.
-                const ownerRole = config.roles?.definitions.owner_console ?? types_js_1.DEFAULT_ROLES.definitions.owner_console;
                 const ownerEventContext = (0, owner_event_policy_js_1.buildOwnerEventAgentContext)({
                     backend: runtimeBackend,
                     model: config.agent.model,
@@ -1800,8 +1870,24 @@ async function runAgentLoop(config, options = {}) {
                     privateConnectorPolicy,
                 });
                 const ownerEventPromptEnhancer = new prompt_enhancer_js_1.PromptEnhancer();
-                const ownerEventIssueEnvelope = async (batch) => {
+                // ONE expression for what an event turn may read: the envelope and the
+                // packet are both built from it, so they can never disagree.
+                const ownerEventReadScope = (batch) => {
                     const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
+                    return {
+                        projectRefs: [{ kind: 'project', id: projectId }],
+                        rawConnectors: [
+                            ...privateConnectorPolicy.projectRawConnectors('owner_console', codeActRawConnectors),
+                        ],
+                        memoryScopes: uniqueMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({
+                            source: 'owner-event',
+                            channelId: batch.channelKey,
+                            projectId,
+                        })),
+                    };
+                };
+                const ownerEventIssueEnvelope = async (batch) => {
+                    const readScope = ownerEventReadScope(batch);
                     const wallSeconds = 300;
                     return ownerEventEnvelopeAuthority.buildAndPersist({
                         agent_id: 'mama-owner',
@@ -1810,15 +1896,9 @@ async function runAgentLoop(config, options = {}) {
                         channel_id: batch.channelKey,
                         trigger_context: { user_text: '<MAMA owner event turn>' },
                         scope: {
-                            project_refs: [{ kind: 'project', id: projectId }],
-                            raw_connectors: [
-                                ...privateConnectorPolicy.projectRawConnectors('owner_console', codeActRawConnectors),
-                            ],
-                            memory_scopes: uniqueMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({
-                                source: 'owner-event',
-                                channelId: batch.channelKey,
-                                projectId,
-                            })),
+                            project_refs: readScope.projectRefs,
+                            raw_connectors: readScope.rawConnectors,
+                            memory_scopes: readScope.memoryScopes,
                             allowed_destinations: reportChatId
                                 ? [{ kind: 'telegram', id: reportChatId }]
                                 : [],
@@ -1832,8 +1912,16 @@ async function runAgentLoop(config, options = {}) {
                     inbox: ownerEventInbox,
                     runner: agentLoop,
                     agentContext: ownerEventContext,
-                    buildPrompt: async (batch) => (0, owner_event_prompt_js_1.buildOwnerEventPrompt)({
+                    compilePacket: async (batch) => (0, report_context_js_1.serializeOwnerReportContext)(await (0, report_context_js_1.compileChannelPacket)({
+                        readScope: ownerEventReadScope(batch),
+                        channelKey: batch.channelKey,
+                        eventIds: batch.eventIds,
+                        since: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+                    }, reportContextDeps)),
+                    buildPrompt: async (batch, packet) => (0, owner_event_prompt_js_1.buildOwnerEventPrompt)({
                         batch,
+                        packet,
+                        learning: await buildLearningBlockFor('event', ownerEventReadScope(batch).memoryScopes, batch.lines.join('\n').slice(0, 500)),
                         ownerBrief: (0, console_brief_js_1.projectConsoleBriefForPrompt)((0, console_brief_js_1.loadConsoleBrief)(), privateConnectorPolicy),
                         skillContent: await ownerEventPromptEnhancer.detectSkillMatch(batch.lines.join('\n')),
                         ownerTelegramChatId: reportChatId,
@@ -1842,7 +1930,6 @@ async function runAgentLoop(config, options = {}) {
                     getNoUpdateMaxId: (scope) => taskLedger.maxNoUpdateId(scope),
                     getTerminalReceipt: (batch) => resolveOwnerEventTerminalReceipt(batch, {
                         ownerEventEffectLedger,
-                        ownerEventBoardRefreshLedger,
                         taskLedger,
                     }),
                     recordTriggerOutcome: (triggerId, outcome) => triggerRegistry.recordOutcome(triggerId, outcome),
@@ -1926,15 +2013,18 @@ async function runAgentLoop(config, options = {}) {
         getAdapter,
         privateConnectorPolicy,
         rawConnectorScope: [
-            ...privateConnectorPolicy.projectRawConnectors('workorder-board', codeActRawConnectors),
+            ...privateConnectorPolicy.projectRawConnectors(exports.ONE_AGENT_TURN_POLICY.roleName, codeActRawConnectors),
         ],
         sessionsDb: db,
         workOrderConsumer: workOrderConsumer ?? undefined,
         boardRefreshGate,
-        ownerEventBoardRefreshLedger,
         requestFullReport: () => triggerLoopFullReport.current?.() ?? { accepted: false, reason: 'unavailable' },
     });
     boardRepairNudge.current = apiRoutesHandle.requestBoardRepair;
+    {
+        const { createReportPublisher } = await import('../../api/report-handler.js');
+        pipelineSlotPublisher.current = createReportPublisher(apiServer.reportStore, apiServer.reportSseClients);
+    }
     gateways.push({ stop: async () => apiRoutesHandle.stop() });
     // ── Stage-2 boot pass (plan S2-T3): runtime assembly registered hooks;
     // recovery/cleanup run after routes are ready, then the consumer starts.