happy-imou-cloud 2.0.20 → 2.0.21

package/dist/{registerKillSessionHandler-DJMH-gar.mjs → registerKillSessionHandler-DsHTZDsU.mjs}

@@ -1,8 +1,8 @@
-import { i as initialMachineMetadata, e as projectPath, R as RuntimeShell, h as resolveCanonicalToolNameV2, f as formatDisplayMessage } from './index-Bg4KLXYY.mjs';
-import { readSettings } from './persistence-BCkHc68b.mjs';
+import { i as initialMachineMetadata, e as projectPath, R as RuntimeShell, h as resolveCanonicalToolNameV2, f as formatDisplayMessage } from './index-CHXCgpwi.mjs';
+import { readSettings } from './persistence-CkP90vEt.mjs';
 import os from 'node:os';
 import { resolve } from 'node:path';
-import { c as configuration, p as packageJson, l as logger } from './api-_Y2kzqZL.mjs';
+import { c as configuration, p as packageJson, H as HAPPY_ORG_TURN_REPORT_TAG, d as HAPPY_ORG_REPEAT_THRESHOLD, l as logger } from './api-DJe9WP9M.mjs';
 import { randomUUID } from 'node:crypto';
 import { createHash } from 'crypto';
 import 'axios';
@@ -351,6 +351,356 @@ async function syncControlledByUserState(sessionClient, controlledByUser) {
   });
 }
 
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function cloneHappyOrgMetadata(happyOrg) {
+  return {
+    taskContext: happyOrg?.taskContext ? { ...happyOrg.taskContext } : void 0,
+    runtime: happyOrg?.runtime ? { ...happyOrg.runtime } : void 0,
+    activeOwner: happyOrg?.activeOwner ? { ...happyOrg.activeOwner } : null,
+    repeat: happyOrg?.repeat ? {
+      threshold: happyOrg.repeat.threshold,
+      fingerprints: Object.fromEntries(
+        Object.entries(happyOrg.repeat.fingerprints ?? {}).map(([fingerprint, entry]) => [
+          fingerprint,
+          { ...entry }
+        ])
+      )
+    } : void 0,
+    lastTurnReport: happyOrg?.lastTurnReport ? { ...happyOrg.lastTurnReport } : void 0
+  };
+}
+function normalizeHappyOrgMetadata(metadata) {
+  const happyOrg = cloneHappyOrgMetadata(metadata?.happyOrg);
+  return {
+    ...happyOrg,
+    runtime: happyOrg.runtime ?? {
+      status: "active",
+      reason: null
+    },
+    repeat: happyOrg.repeat ?? {
+      threshold: HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
+    }
+  };
+}
+function withHappyOrgMetadata(metadata, happyOrg) {
+  return {
+    ...metadata,
+    happyOrg
+  };
+}
+function resetHappyOrgRuntimeForTask(taskContext) {
+  return {
+    taskContext,
+    runtime: {
+      status: "active",
+      reason: null
+    },
+    activeOwner: null,
+    repeat: {
+      threshold: HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
+    }
+  };
+}
+function buildTerminatedStatusMessage(taskId) {
+  return `Task ${taskId} is terminated. Reopen it with new context, a new decision, or a new resource before continuing.`;
+}
+function buildOwnerConflictStatusMessage(taskId, ownerAgentId) {
+  return `Task ${taskId} is already active under owner ${ownerAgentId}. This turn must exit without continuing token usage.`;
+}
+function inferInterventionType(draft) {
+  if (draft?.interventionType === "none" || draft?.interventionType === "review_needed" || draft?.interventionType === "blocker" || draft?.interventionType === "decision_needed") {
+    return draft.interventionType;
+  }
+  if (normalizeOptionalText(draft?.decisionNeeded)) {
+    return "decision_needed";
+  }
+  if (normalizeOptionalText(draft?.blockerCode)) {
+    return "blocker";
+  }
+  return "none";
+}
+function buildFallbackSummary(text, turnStatus) {
+  const trimmed = text.trim();
+  if (trimmed) {
+    return trimmed.replace(/\s+/g, " ").slice(0, 160);
+  }
+  return turnStatus === "turn_aborted" ? "Turn aborted before completion." : "Turn completed without a textual summary.";
+}
+function normalizeTurnReportDraft(draft) {
+  return {
+    summary: normalizeOptionalText(draft?.summary)?.replace(/\s+/g, " ").slice(0, 160) ?? null,
+    interventionType: inferInterventionType(draft),
+    blockerCode: normalizeOptionalText(draft?.blockerCode),
+    decisionNeeded: normalizeOptionalText(draft?.decisionNeeded),
+    targetArtifact: normalizeOptionalText(draft?.targetArtifact)
+  };
+}
+function stripCodeFence(text) {
+  return text.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+}
+function extractTaggedTurnReport(text) {
+  const matcher = new RegExp(
+    `<${HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "gi"
+  );
+  let lastMatch = null;
+  for (let match = matcher.exec(text); match; match = matcher.exec(text)) {
+    lastMatch = match;
+  }
+  if (!lastMatch) {
+    return {
+      cleanedText: text.trim(),
+      draft: null
+    };
+  }
+  const rawBlock = stripCodeFence(lastMatch[1] ?? "");
+  let draft = null;
+  try {
+    const parsed = JSON.parse(rawBlock);
+    draft = {
+      summary: normalizeOptionalText(parsed.summary),
+      interventionType: normalizeOptionalText(parsed.interventionType),
+      blockerCode: normalizeOptionalText(parsed.blockerCode),
+      decisionNeeded: normalizeOptionalText(parsed.decisionNeeded),
+      targetArtifact: normalizeOptionalText(parsed.targetArtifact)
+    };
+  } catch {
+    draft = null;
+  }
+  const cleanedText = `${text.slice(0, lastMatch.index)}${text.slice(lastMatch.index + lastMatch[0].length)}`.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    cleanedText,
+    draft
+  };
+}
+function buildRepeatFingerprint(context, blockerCode, targetArtifact) {
+  if (!blockerCode) {
+    return null;
+  }
+  return [
+    context.taskId,
+    context.memberAgentId,
+    blockerCode,
+    targetArtifact ?? ""
+  ].join("::");
+}
+function buildHappyOrgTurnPrompt(prompt, turn) {
+  const reopenLines = turn.reopenContext ? [
+    "",
+    "This task was explicitly reopened for this turn with the following new inputs:",
+    turn.reopenContext.newContext ? `- newContext: ${turn.reopenContext.newContext}` : null,
+    turn.reopenContext.newDecision ? `- newDecision: ${turn.reopenContext.newDecision}` : null,
+    turn.reopenContext.newResource ? `- newResource: ${turn.reopenContext.newResource}` : null
+  ].filter(Boolean) : [];
+  const header = [
+    "[HAPPY_ORG_TASK_CONTEXT]",
+    `taskId=${turn.context.taskId}`,
+    `organizationId=${turn.context.organizationId}`,
+    `memberAgentId=${turn.context.memberAgentId}`,
+    `supervisorAgentId=${turn.context.supervisorAgentId}`,
+    "Stay on this exact task for the whole turn.",
+    "End your response with exactly one raw JSON block inside these tags and do not wrap it in a markdown code fence:",
+    `<${HAPPY_ORG_TURN_REPORT_TAG}>{"summary":"short factual summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null}</${HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "Allowed interventionType values: none, review_needed, blocker, decision_needed.",
+    "summary must read like a CEO todo card title: short, actionable, and without long process logs.",
+    "Use blocker only for problems the organization may still solve internally.",
+    "Use decision_needed only when a CEO or user decision is required.",
+    "Use review_needed when supervisor review is needed but the work is not blocked.",
+    ...reopenLines,
+    "[/HAPPY_ORG_TASK_CONTEXT]",
+    "",
+    prompt
+  ];
+  return header.join("\n");
+}
+function resolveHappyOrgQueuedTurn(opts) {
+  const metadata = opts.metadata ?? null;
+  if (!metadata) {
+    return {
+      nextMetadata: null,
+      queuedTurn: null,
+      blocked: false
+    };
+  }
+  const currentHappyOrg = normalizeHappyOrgMetadata(metadata);
+  let nextHappyOrg = cloneHappyOrgMetadata(currentHappyOrg);
+  const messageHappyOrg = opts.message.meta?.happyOrg;
+  const now = opts.now?.() ?? Date.now();
+  const createRunId = opts.createRunId ?? ((taskContext2, currentNow) => `${taskContext2.taskId}:${taskContext2.memberAgentId}:${currentNow}`);
+  if (messageHappyOrg?.taskContext) {
+    const currentTaskId = currentHappyOrg.taskContext?.taskId ?? null;
+    if (currentTaskId !== messageHappyOrg.taskContext.taskId) {
+      nextHappyOrg = resetHappyOrgRuntimeForTask(messageHappyOrg.taskContext);
+    } else {
+      nextHappyOrg.taskContext = { ...messageHappyOrg.taskContext };
+    }
+  }
+  const taskContext = nextHappyOrg.taskContext ?? null;
+  if (!taskContext) {
+    return {
+      nextMetadata: metadata,
+      queuedTurn: null,
+      blocked: false
+    };
+  }
+  const control = messageHappyOrg?.control;
+  if (control?.action === "terminate") {
+    nextHappyOrg.runtime = {
+      status: "terminated",
+      reason: normalizeOptionalText(control.reason) ?? "terminated_by_supervisor",
+      terminatedAt: now
+    };
+    nextHappyOrg.activeOwner = null;
+    return {
+      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+      queuedTurn: null,
+      blocked: true,
+      statusMessage: buildTerminatedStatusMessage(taskContext.taskId)
+    };
+  }
+  const hasReopenInputs = Boolean(
+    normalizeOptionalText(control?.newContext) || normalizeOptionalText(control?.newDecision) || normalizeOptionalText(control?.newResource)
+  );
+  if (nextHappyOrg.runtime?.status === "terminated") {
+    if (control?.action !== "reopen") {
+      return {
+        nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+        queuedTurn: null,
+        blocked: true,
+        statusMessage: buildTerminatedStatusMessage(taskContext.taskId)
+      };
+    }
+    if (!hasReopenInputs) {
+      return {
+        nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+        queuedTurn: null,
+        blocked: true,
+        statusMessage: `Task ${taskContext.taskId} can only reopen with new context, a new decision, or a new resource.`
+      };
+    }
+  }
+  const reopenContext = control?.action === "reopen" && hasReopenInputs ? {
+    newContext: normalizeOptionalText(control.newContext),
+    newDecision: normalizeOptionalText(control.newDecision),
+    newResource: normalizeOptionalText(control.newResource)
+  } : void 0;
+  if (reopenContext) {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null,
+      reopenedAt: now
+    };
+  } else if (!nextHappyOrg.runtime) {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null
+    };
+  }
+  if (!nextHappyOrg.activeOwner) {
+    nextHappyOrg.activeOwner = {
+      ownerAgentId: taskContext.memberAgentId,
+      ownerRunId: createRunId(taskContext, now),
+      claimedAt: now
+    };
+  } else if (nextHappyOrg.activeOwner.ownerAgentId !== taskContext.memberAgentId) {
+    return {
+      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+      queuedTurn: null,
+      blocked: true,
+      statusMessage: buildOwnerConflictStatusMessage(
+        taskContext.taskId,
+        nextHappyOrg.activeOwner.ownerAgentId
+      )
+    };
+  }
+  return {
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    queuedTurn: {
+      context: taskContext,
+      ...reopenContext ? { reopenContext } : {}
+    },
+    blocked: false
+  };
+}
+function finalizeHappyOrgTurn(opts) {
+  const metadata = opts.metadata ?? null;
+  const queuedTurn = opts.queuedTurn ?? null;
+  const { cleanedText, draft } = extractTaggedTurnReport(opts.responseText);
+  if (!metadata || !queuedTurn) {
+    return {
+      cleanedText,
+      report: null,
+      nextMetadata: metadata
+    };
+  }
+  const now = opts.now?.() ?? Date.now();
+  const normalizedDraft = normalizeTurnReportDraft(draft);
+  const report = {
+    ...queuedTurn.context,
+    turnStatus: opts.turnStatus,
+    interventionType: normalizedDraft.interventionType ?? "none",
+    summary: normalizedDraft.summary ?? buildFallbackSummary(cleanedText, opts.turnStatus),
+    blockerCode: normalizedDraft.blockerCode ?? null,
+    decisionNeeded: normalizedDraft.decisionNeeded ?? null,
+    targetArtifact: normalizedDraft.targetArtifact ?? null,
+    repeatFingerprint: buildRepeatFingerprint(
+      queuedTurn.context,
+      normalizedDraft.blockerCode ?? null,
+      normalizedDraft.targetArtifact ?? null
+    )
+  };
+  const nextHappyOrg = normalizeHappyOrgMetadata(metadata);
+  nextHappyOrg.taskContext = { ...queuedTurn.context };
+  nextHappyOrg.lastTurnReport = report;
+  nextHappyOrg.activeOwner = null;
+  nextHappyOrg.repeat = nextHappyOrg.repeat ?? {
+    threshold: HAPPY_ORG_REPEAT_THRESHOLD,
+    fingerprints: {}
+  };
+  let terminateMessage;
+  if (report.repeatFingerprint) {
+    const currentEntry = nextHappyOrg.repeat.fingerprints[report.repeatFingerprint] ?? {
+      count: 0};
+    const nextCount = currentEntry.count + 1;
+    nextHappyOrg.repeat.fingerprints[report.repeatFingerprint] = {
+      count: nextCount,
+      lastSeenAt: now
+    };
+    if (nextCount >= nextHappyOrg.repeat.threshold) {
+      nextHappyOrg.runtime = {
+        status: "terminated",
+        reason: `repeat_fingerprint:${report.repeatFingerprint}`,
+        terminatedAt: now
+      };
+      terminateMessage = `Task ${queuedTurn.context.taskId} hit repeat threshold for ${report.repeatFingerprint} and is now terminated until reopen.`;
+    } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "terminated") {
+      nextHappyOrg.runtime = {
+        status: "active",
+        reason: null
+      };
+    }
+  } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "terminated") {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null
+    };
+  }
+  return {
+    cleanedText,
+    report,
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    terminateMessage
+  };
+}
+
 const DEFAULT_MAX_MESSAGES = 200;
 const DEFAULT_MAX_CHARACTERS = 1e5;
 const DEFAULT_MAX_MESSAGE_CHARACTERS = 8e3;
@@ -1176,4 +1526,4 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
   });
 }
 
-export { BasePermissionHandler as B, ConversationHistory$1 as C, INTERACTION_SUPERSEDED_ERROR as I, MissingMachineIdError as M, INTERACTION_TIMED_OUT_ERROR as a, MessageQueue2 as b, createSessionMetadata as c, MessageBuffer as d, ensureManagedProviderMachine as e, closeProviderSession as f, getPendingInteractionTimeoutMs as g, hashObject as h, inferToolResultError as i, forwardAgentMessageToProviderSession as j, launchRuntimeHandleWithFactoryResult as l, registerKillSessionHandler as r, syncControlledByUserState as s, waitForResponseCompleteWithAbort as w };
+export { BasePermissionHandler as B, ConversationHistory$1 as C, INTERACTION_SUPERSEDED_ERROR as I, MissingMachineIdError as M, INTERACTION_TIMED_OUT_ERROR as a, MessageQueue2 as b, createSessionMetadata as c, MessageBuffer as d, ensureManagedProviderMachine as e, registerKillSessionHandler as f, getPendingInteractionTimeoutMs as g, hashObject as h, buildHappyOrgTurnPrompt as i, finalizeHappyOrgTurn as j, closeProviderSession as k, launchRuntimeHandleWithFactoryResult as l, inferToolResultError as m, forwardAgentMessageToProviderSession as n, resolveHappyOrgQueuedTurn as r, syncControlledByUserState as s, waitForResponseCompleteWithAbort as w };

package/dist/{runClaude-BUhD2jR2.cjs → runClaude-BGSgcyUp.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var api = require('./api-BKnzORe4.cjs');
+var api = require('./api-MGlKcEf3.cjs');
 require('cross-spawn');
 require('@agentclientprotocol/sdk');
-var index = require('./index-0TIyXMQu.cjs');
+var index = require('./index-CgVjDJpt.cjs');
 require('ps-list');
 require('fs');
 require('path');
@@ -15,7 +15,7 @@ var path = require('node:path');
 var os = require('node:os');
 var node_child_process = require('node:child_process');
 require('node:readline');
-require('./persistence-D5uolhHo.cjs');
+require('./persistence-DLFUNI9q.cjs');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 require('crypto');
@@ -26,9 +26,9 @@ require('tweetnacl');
 require('open');
 var React = require('react');
 var ink = require('ink');
-var ProviderSelectionHandler = require('./ProviderSelectionHandler-DUBEXkmo.cjs');
+var ProviderSelectionHandler = require('./ProviderSelectionHandler-Bafuy28L.cjs');
 var types = require('./types-DVk3crez.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-BMUE5Oaj.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-Cs_INk4A.cjs');
 require('socket.io-client');
 require('expo-server-sdk');
 var node_util = require('node:util');
@@ -1040,6 +1040,13 @@ async function claudeAcpRemoteLauncher(session) {
       message
     });
   };
+  const emitTurnReport = (report) => {
+    session.client.sendAgentMessage("claude", {
+      type: "turn-report",
+      id: node_crypto.randomUUID(),
+      report
+    });
+  };
   const resetTurnState = () => {
     accumulatedResponse = "";
     isResponseInProgress = false;
@@ -1048,13 +1055,16 @@ async function claudeAcpRemoteLauncher(session) {
     currentThinkingMessageId = null;
     session.onThinkingChange(false);
   };
-  const emitFinalAssistantMessage = () => {
-    const finalMessage = accumulatedResponse.trim();
+  const emitFinalAssistantMessage = (finalMessageText) => {
+    const finalMessage = (finalMessageText ?? accumulatedResponse).trim();
     if (!finalMessage) {
       accumulatedResponse = "";
       isResponseInProgress = false;
       return;
     }
+    if (currentAssistantMessageId) {
+      messageBuffer.updateMessage(currentAssistantMessageId, finalMessage, { mode: "replace" });
+    }
     conversationHistory.addAssistantMessage(finalMessage);
     session.client.sendAgentMessage("claude", {
       type: "message",
@@ -1366,6 +1376,7 @@ ${systemPrompt}` : systemPrompt,
       permissionHandler.setPermissionMode(message.mode.permissionMode);
       messageBuffer.addMessage(message.message, "user");
       let shouldClearHistoryAfterTurn = false;
+      let turnStatus = "task_complete";
       try {
         const activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
         let promptToSend = message.message;
@@ -1376,6 +1387,9 @@ ${systemPrompt}` : systemPrompt,
           promptToSend = historyContext + promptToSend;
           api.logger.debug(`[ClaudeACP] Injected conversation history context (${historyContext.length} chars)`);
         }
+        if (message.mode.happyOrg) {
+          promptToSend = registerKillSessionHandler.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
+        }
         if (specialCommand.type === "compact") {
           emitStatusMessage("Compaction started");
         }
@@ -1389,6 +1403,7 @@ ${systemPrompt}` : systemPrompt,
         const isAbortError = error instanceof Error && error.name === "AbortError";
         const isExpectedInterruption = isAbortError || abortController.signal.aborted || shouldExit;
         if (isExpectedInterruption) {
+          turnStatus = "turn_aborted";
           session.client.sendAgentMessage("claude", {
             type: "turn_aborted",
             id: node_crypto.randomUUID()
@@ -1405,7 +1420,23 @@ ${systemPrompt}` : systemPrompt,
           currentModeHash = null;
         }
       } finally {
-        emitFinalAssistantMessage();
+        const finalizedTurn = registerKillSessionHandler.finalizeHappyOrgTurn({
+          metadata: session.client.getMetadataSnapshot?.() ?? null,
+          queuedTurn: message.mode.happyOrg,
+          responseText: accumulatedResponse,
+          turnStatus
+        });
+        if (finalizedTurn.nextMetadata && typeof session.client.updateMetadata === "function") {
+          session.client.updateMetadata(() => finalizedTurn.nextMetadata);
+        }
+        if (finalizedTurn.report) {
+          emitTurnReport(finalizedTurn.report);
+        }
+        if (finalizedTurn.terminateMessage) {
+          emitStatusMessage(finalizedTurn.terminateMessage);
+        }
+        accumulatedResponse = finalizedTurn.cleanedText;
+        emitFinalAssistantMessage(finalizedTurn.cleanedText);
         if (shouldClearHistoryAfterTurn) {
           conversationHistory.clear();
           emitStatusMessage("Compaction completed");
@@ -3130,8 +3161,28 @@ function resolveClaudeQueuedMessage(message, currentState) {
 function bindClaudeUserMessageQueue(opts) {
   let currentState = { ...opts.initialState };
   opts.session.onUserMessage((message) => {
+    const happyOrgResult = opts.happyOrg ? registerKillSessionHandler.resolveHappyOrgQueuedTurn({
+      metadata: opts.happyOrg.getMetadata(),
+      message
+    }) : {
+      nextMetadata: null,
+      queuedTurn: null,
+      blocked: false,
+      statusMessage: void 0
+    };
+    if (opts.happyOrg && happyOrgResult.nextMetadata) {
+      opts.happyOrg.updateMetadata(() => happyOrgResult.nextMetadata);
+    }
+    if (happyOrgResult.blocked) {
+      if (happyOrgResult.statusMessage) {
+        opts.happyOrg?.emitStatusMessage(happyOrgResult.statusMessage);
+      }
+      api.logger.debugLargeJson("[claude] User message blocked by Happy Org runtime:", message);
+      return;
+    }
     const { nextState, queuedMessage } = resolveClaudeQueuedMessage(message, currentState);
     currentState = nextState;
+    queuedMessage.mode.happyOrg = happyOrgResult.queuedTurn;
     if (queuedMessage.isolate) {
       api.logger.debug(`[claude] Queuing isolated special command: ${queuedMessage.specialCommand}`);
       opts.messageQueue.pushIsolateAndClear(queuedMessage.text, queuedMessage.mode);
@@ -3236,7 +3287,14 @@ async function runClaude(credentials, options = {}) {
     customSystemPrompt: mode.customSystemPrompt,
     appendSystemPrompt: mode.appendSystemPrompt,
     allowedTools: mode.allowedTools,
-    disallowedTools: mode.disallowedTools
+    disallowedTools: mode.disallowedTools,
+    happyOrg: mode.happyOrg ? {
+      taskId: mode.happyOrg.context.taskId,
+      organizationId: mode.happyOrg.context.organizationId,
+      memberAgentId: mode.happyOrg.context.memberAgentId,
+      supervisorAgentId: mode.happyOrg.context.supervisorAgentId,
+      reopenContext: mode.happyOrg.reopenContext ?? null
+    } : null
   }));
   bindClaudeUserMessageQueue({
     session,
@@ -3244,6 +3302,11 @@ async function runClaude(credentials, options = {}) {
     initialState: {
       permissionMode: options.permissionMode,
       model: options.model
+    },
+    happyOrg: {
+      getMetadata: () => session.getMetadataSnapshot(),
+      updateMetadata: (handler) => session.updateMetadata(handler),
+      emitStatusMessage: (message) => session.sendSessionEvent({ type: "message", message })
     }
   });
   const cleanup = async () => {