happy-imou-cloud 2.1.41 → 2.1.43

package/dist/{api-C_Tnx4UG.cjs → api-zMic8QXq.cjs}

@@ -38,7 +38,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "happy-imou-cloud";
-var version = "2.1.41";
+var version = "2.1.43";
 var description = "hicloud - Imou 企业定制版。关键是 happy！移动端远程 AI 编程工具，支持 Claude Code、Codex 和 Gemini CLI";
 var author = "long.zhu";
 var license = "MIT";
@@ -1677,12 +1677,29 @@ const UserMessageSchema = z.z.object({
   // Mobile messages include this
   meta: MessageMetaSchema.optional()
 });
+const AgentProviderSchema = z.z.enum(["gemini", "codex", "claude", "opencode"]);
 const AgentMessageSchema = z.z.object({
   role: z.z.literal("agent"),
-  content: z.z.object({
-    type: z.z.literal("output"),
-    data: z.z.any()
-  }),
+  content: z.z.union([
+    z.z.object({
+      type: z.z.literal("output"),
+      data: z.z.unknown()
+    }),
+    z.z.object({
+      type: z.z.literal("codex"),
+      data: z.z.unknown()
+    }),
+    z.z.object({
+      type: z.z.literal("acp"),
+      provider: AgentProviderSchema,
+      data: z.z.unknown()
+    }),
+    z.z.object({
+      type: z.z.literal("event"),
+      id: z.z.string().optional(),
+      data: z.z.unknown()
+    })
+  ]),
   meta: MessageMetaSchema.optional()
 });
 const MessageContentSchema = z.z.union([UserMessageSchema, AgentMessageSchema]);
@@ -1702,6 +1719,59 @@ function isNeedsHandoffTask(task) {
   }
   return false;
 }
+function resolveRuntimeSessionId(task) {
+  return task.specialistHomeSessionId ?? null;
+}
+function resolveMachineId(task) {
+  return task.specialistHomeMachineId ?? null;
+}
+function resolveTaskMergeState(task) {
+  const runtimeSessionId = resolveRuntimeSessionId(task);
+  const machineId = resolveMachineId(task);
+  if (task.accessChannelState === "runtime_replaced") {
+    return "conflict";
+  }
+  if (task.activeOwnerAgentId && task.activeOwnerAgentId !== task.ownerAgentId) {
+    return "conflict";
+  }
+  if (task.accessChannelState === "reattach_required") {
+    return "merge_pending";
+  }
+  if (task.hasActiveOwner === false && task.status !== "done" && task.status !== "terminated") {
+    return "merge_pending";
+  }
+  if ((task.status === "active" || task.status === "waiting_close") && (!runtimeSessionId || !machineId)) {
+    return "merge_pending";
+  }
+  return "stable";
+}
+function resolveTaskMergeStateSummary(task, mergeState, runtimeSessionId, machineId) {
+  if (mergeState === "conflict") {
+    if (task.accessChannelState === "runtime_replaced") {
+      return "runtime was replaced before the merge view stabilized";
+    }
+    if (task.activeOwnerAgentId && task.activeOwnerAgentId !== task.ownerAgentId) {
+      return `active owner moved to ${task.activeOwnerAgentId}`;
+    }
+    return "merge conflict needs owner review";
+  }
+  if (mergeState === "merge_pending") {
+    if (task.accessChannelState === "reattach_required") {
+      return "runtime reattach required before merge becomes stable";
+    }
+    if (task.hasActiveOwner === false) {
+      return "no active owner is attached to the task yet";
+    }
+    if (!runtimeSessionId || !machineId) {
+      return "runtime or machine attribution is still missing";
+    }
+    return "merge visibility is still pending";
+  }
+  if (runtimeSessionId && machineId) {
+    return `runtime ${runtimeSessionId} on machine ${machineId}`;
+  }
+  return "merge is stable";
+}
 function classifyHappyOrgTaskBoardSection(task) {
   if (task.status === "done") {
     return "closed";
@@ -1715,8 +1785,12 @@ function classifyHappyOrgTaskBoardSection(task) {
   return "in_progress";
 }
 function buildHappyOrgTaskBoardView(tasks) {
+  const organizationManifestId = tasks.find((task) => task.organizationManifestId)?.organizationManifestId ?? null;
   const items = [...tasks].filter((task) => task.status !== "terminated").sort((left, right) => right.updatedAt - left.updatedAt || left.taskId.localeCompare(right.taskId)).map((task) => {
     const sectionKey = classifyHappyOrgTaskBoardSection(task);
+    const runtimeSessionId = resolveRuntimeSessionId(task);
+    const machineId = resolveMachineId(task);
+    const mergeState = resolveTaskMergeState(task);
     return {
       taskId: task.taskId,
       title: task.title,
@@ -1725,8 +1799,15 @@ function buildHappyOrgTaskBoardView(tasks) {
       lane: sectionKey,
       ownerAgentId: task.ownerAgentId,
       ownerName: task.ownerName,
+      organizationManifestId: task.organizationManifestId ?? null,
+      positionId: task.positionId ?? null,
       responsibilityId: task.responsibilityId ?? null,
       responsibilityLabel: task.responsibilityLabel ?? null,
+      runtimeSessionId,
+      machineId,
+      accessChannelState: task.accessChannelState ?? null,
+      mergeState,
+      mergeStateSummary: resolveTaskMergeStateSummary(task, mergeState, runtimeSessionId, machineId),
       currentProgress: task.positionStatus || task.summary || null,
       latestResult: task.latestUserVisibleResult || task.reviewSummary || task.resultSummary || null,
       blockerOrDecision: task.blockerSummary || task.blocker || task.decisionNeeded || task.adviceSummary || task.ceoWriteNextStep || null,
@@ -1750,6 +1831,7 @@ function buildHappyOrgTaskBoardView(tasks) {
     { key: "closed", count: buckets.closed.length, items: buckets.closed }
   ];
   return {
+    organizationManifestId,
     totalCount: items.length,
     inProgressCount: sections[0].count,
     handoffCount: sections[1].count,
@@ -1760,6 +1842,49 @@ function buildHappyOrgTaskBoardView(tasks) {
   };
 }
 
+const HTTP_URL_PATTERN = /^https?:\/\//i;
+const FILE_URL_PATTERN = /^file:\/\//i;
+const FILE_EXTENSION_PATTERN = /\.[A-Za-z0-9_-]{1,16}$/;
+const SPECIAL_FILE_NAME_PATTERN = /(^|[\\/])(Dockerfile|Makefile|README(?:\.[A-Za-z0-9_-]+)?)$/i;
+function isLikelyPreviewableArtifactTarget(target) {
+  const trimmed = typeof target === "string" ? target.trim() : "";
+  if (!trimmed) {
+    return false;
+  }
+  if (HTTP_URL_PATTERN.test(trimmed) || FILE_URL_PATTERN.test(trimmed)) {
+    return true;
+  }
+  const stripped = trimmed.split(/[?#]/)[0] ?? trimmed;
+  const basename = stripped.split(/[\\/]/).pop() ?? stripped;
+  if (!basename) {
+    return false;
+  }
+  return FILE_EXTENSION_PATTERN.test(basename) || SPECIAL_FILE_NAME_PATTERN.test(basename);
+}
+function resolveArtifactTarget(target) {
+  const trimmed = typeof target === "string" ? target.trim() : "";
+  if (!trimmed || !isLikelyPreviewableArtifactTarget(trimmed)) {
+    return {
+      kind: "unknown",
+      target: trimmed
+    };
+  }
+  if (HTTP_URL_PATTERN.test(trimmed) || FILE_URL_PATTERN.test(trimmed)) {
+    return {
+      kind: "external",
+      target: trimmed
+    };
+  }
+  return {
+    kind: "path",
+    target: trimmed
+  };
+}
+function normalizePreviewableArtifactTarget(target) {
+  const resolved = resolveArtifactTarget(target);
+  return resolved.kind === "unknown" ? null : resolved.target;
+}
+
 const HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION = "1.7.3-local-repo-v1";
 const HAPPY_ORG_WRITER_LOCK_SCHEMA_VERSION = "1.7.3-writer-lock-v1";
 const WRITER_LOCK_LEASE_DURATION_SECONDS = 900;
@@ -1801,6 +1926,12 @@ const GoalSchema = z.z.object({
   approvedBy: z.z.string().nullable(),
   updatedAt: z.z.number()
 });
+const OrganizationValueSchema = z.z.object({
+  name: z.z.string(),
+  slug: z.z.string().min(1),
+  summary: z.z.string().nullable(),
+  createdAt: z.z.number()
+});
 const TaskUpdatePayloadSchema = z.z.object({
   taskId: z.z.string().min(1),
   status: TaskStatusSchema,
@@ -2028,6 +2159,7 @@ const LogValueSchema = z.z.object({
   taskId: z.z.string(),
   entries: z.z.array(LogEntrySchema)
 });
+const OrganizationEnvelopeSchema = RevisionEnvelopeSchema(OrganizationValueSchema);
 const GoalEnvelopeSchema = RevisionEnvelopeSchema(GoalSchema);
 const PositionEnvelopeSchema = RevisionEnvelopeSchema(PositionValueSchema);
 const WorkspaceEnvelopeSchema = RevisionEnvelopeSchema(WorkspaceValueSchema);
@@ -2324,20 +2456,31 @@ async function readHappyOrgDispatchTruthSnapshot(rootPath) {
   };
 }
 async function readHappyOrgRepoTaskBoard(rootPath) {
-  const [taskIds, positions, responsibilities] = await Promise.all([
+  const [taskIds, positions, responsibilities, organization] = await Promise.all([
     listTaskIds(rootPath),
     listPositionEnvelopes(rootPath),
-    readResponsibilities(rootPath)
+    readResponsibilities(rootPath),
+    readEnvelope(path.join(rootPath, "ORGANIZATION.json"), OrganizationEnvelopeSchema)
   ]);
+  const organizationManifestId = organization?.value.slug ?? null;
   const responsibilityLabelById = /* @__PURE__ */ new Map();
+  const responsibilityPositionIdById = /* @__PURE__ */ new Map();
+  const positionIdByAgentId = /* @__PURE__ */ new Map();
   for (const responsibility of responsibilities?.value ?? []) {
     responsibilityLabelById.set(responsibility.responsibilityId, responsibility.title);
+    responsibilityPositionIdById.set(responsibility.responsibilityId, responsibility.positionId);
   }
   for (const position of positions) {
     const fallbackResponsibilityId = position.value.responsibilityIds[0] ?? buildResponsibilityId(position.value.slug);
     if (!responsibilityLabelById.has(fallbackResponsibilityId)) {
       responsibilityLabelById.set(fallbackResponsibilityId, position.value.label || position.value.agentName || position.value.slug);
     }
+    if (!responsibilityPositionIdById.has(fallbackResponsibilityId)) {
+      responsibilityPositionIdById.set(fallbackResponsibilityId, position.value.positionId);
+    }
+    if (position.value.agentId) {
+      positionIdByAgentId.set(position.value.agentId, position.value.positionId);
+    }
   }
   const tasks = await Promise.all(taskIds.map(async (taskId) => {
     const bundle = await loadTaskEnvelope(rootPath, taskId);
@@ -2345,6 +2488,8 @@ async function readHappyOrgRepoTaskBoard(rootPath) {
   }));
   return buildHappyOrgTaskBoardView(tasks.filter((task) => task !== null).map((task) => ({
     ...task,
+    organizationManifestId,
+    positionId: (task.responsibilityId ? responsibilityPositionIdById.get(task.responsibilityId) ?? null : null) ?? positionIdByAgentId.get(task.activeOwnerAgentId ?? "") ?? positionIdByAgentId.get(task.ownerAgentId) ?? null,
     responsibilityLabel: task.responsibilityLabel ?? (task.responsibilityId ? responsibilityLabelById.get(task.responsibilityId) ?? null : null)
   })));
 }
@@ -3037,6 +3182,10 @@ async function recordHappyOrgTurnReport(options) {
     }
     const now = Date.now();
     const nextStatus = nextStatusFromTurnReport(options.report);
+    const artifactReference = normalizePreviewableArtifactTarget(options.report.targetArtifact);
+    const artifactTarget = resolveArtifactTarget(options.report.targetArtifact);
+    const nextPath = artifactTarget.kind === "path" ? artifactTarget.target : bundle.task.value.path;
+    const nextPortablePath = artifactTarget.kind === "path" ? normalizePortablePath(artifactTarget.target) : bundle.task.value.portablePath;
     const nextTaskValue = {
       ...bundle.task.value,
       status: nextStatus,
@@ -3064,8 +3213,8 @@ async function recordHappyOrgTurnReport(options) {
       blockerSummary: options.report.acceptanceHandoff?.blockerSummary ?? bundle.task.value.blockerSummary ?? null,
       acceptanceState: options.report.acceptanceHandoff?.acceptanceState ?? bundle.task.value.acceptanceState ?? null,
       ceoWriteNextStep: options.report.acceptanceHandoff?.ceoWriteNextStep ?? bundle.task.value.ceoWriteNextStep ?? null,
-      path: options.report.targetArtifact ?? bundle.task.value.path,
-      portablePath: normalizePortablePath(options.report.targetArtifact ?? bundle.task.value.path)
+      path: nextPath,
+      portablePath: nextPortablePath
     };
     const taskRoot = buildTaskRoot(options.rootPath, options.report.taskId);
     await writeEnvelope(path.join(taskRoot, "TASK.json"), {
@@ -3104,7 +3253,7 @@ async function recordHappyOrgTurnReport(options) {
         reviewSummary: bundle.result?.value.reviewSummary ?? null,
         assetCaptureStatus: bundle.result?.value.assetCaptureStatus ?? null,
         assetCaptureSummary: bundle.result?.value.assetCaptureSummary ?? null,
-        assetReference: options.report.targetArtifact ?? bundle.result?.value.assetReference ?? null,
+        assetReference: artifactReference ?? bundle.result?.value.assetReference ?? null,
         closedAt: nextStatus === "waiting_close" ? now : bundle.result?.value.closedAt ?? null,
         updatedAt: now,
         updatedBy: options.report.memberAgentId
@@ -3535,6 +3684,12 @@ async function runShellCommand(opts) {
   });
 }
 
+function quoteShellArgument(value) {
+  if (value.length === 0) {
+    return "''";
+  }
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
 function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
   rpcHandlerManager.registerHandler("bash", async (data) => {
     logger.debug("Shell command request:", data.command);
@@ -3580,6 +3735,52 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       return result;
     }
   });
+  rpcHandlerManager.registerHandler("ripgrep", async (data) => {
+    logger.debug("Ripgrep request:", data.args);
+    if (data.cwd) {
+      const validation = validatePath(data.cwd, workingDirectory);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+    }
+    try {
+      const cwd = data.cwd || workingDirectory;
+      const command = ["rg", ...data.args.map(quoteShellArgument)].join(" ");
+      logger.debug("Ripgrep executing...", {
+        cwd,
+        timeout: data.timeout || 3e4,
+        args: data.args
+      });
+      const result = await runShellCommand({
+        command,
+        cwd,
+        timeoutMs: data.timeout || 3e4
+      });
+      logger.debug("Ripgrep finished:", {
+        success: result.success,
+        exitCode: result.exitCode,
+        error: result.error,
+        stdoutLen: result.stdout.length,
+        stderrLen: result.stderr.length
+      });
+      return result;
+    } catch (error) {
+      const result = {
+        success: false,
+        stdout: "",
+        stderr: "",
+        exitCode: 1,
+        error: error instanceof Error ? error.message : "Ripgrep failed"
+      };
+      logger.debug("Ripgrep failed before execution completed:", {
+        cwd: data.cwd || workingDirectory,
+        success: false,
+        exitCode: result.exitCode,
+        error: result.error
+      });
+      return result;
+    }
+  });
   rpcHandlerManager.registerHandler("readFile", async (data) => {
     logger.debug("Read file request:", data.path);
     const validation = validatePath(data.path, workingDirectory);
@@ -4142,9 +4343,95 @@ function isTransientMessageStreamDelta(body) {
   return record.type === "message" && record.phase === "delta";
 }
 
+function deterministicStringify(obj, options = {}) {
+  const {
+    undefinedBehavior = "omit",
+    sortArrays = false,
+    replacer,
+    includeSymbols = false
+  } = options;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function processValue(value, key) {
+    if (replacer && key !== void 0) {
+      value = replacer(key, value);
+    }
+    if (value === null) return null;
+    if (value === void 0) {
+      switch (undefinedBehavior) {
+        case "omit":
+          return void 0;
+        case "null":
+          return null;
+        case "throw":
+          throw new Error(`Undefined value at key: ${key}`);
+      }
+    }
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (typeof value === "function") {
+      return void 0;
+    }
+    if (typeof value === "symbol") {
+      return includeSymbols ? value.toString() : void 0;
+    }
+    if (typeof value === "bigint") {
+      return value.toString() + "n";
+    }
+    if (seen.has(value)) {
+      throw new Error("Circular reference detected");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const processed2 = value.map((item, index) => processValue(item, String(index))).filter((item) => item !== void 0);
+      if (sortArrays) {
+        processed2.sort((a, b) => {
+          const aStr = JSON.stringify(processValue(a));
+          const bStr = JSON.stringify(processValue(b));
+          return aStr.localeCompare(bStr);
+        });
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    if (value.constructor === Object || value.constructor === void 0) {
+      const processed2 = {};
+      const keys = Object.keys(value).sort();
+      for (const k of keys) {
+        const processedValue = processValue(value[k], k);
+        if (processedValue !== void 0) {
+          processed2[k] = processedValue;
+        }
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    try {
+      const plain = { ...value };
+      seen.delete(value);
+      return processValue(plain, key);
+    } catch {
+      seen.delete(value);
+      return String(value);
+    }
+  }
+  const processed = processValue(obj);
+  return JSON.stringify(processed);
+}
+function hashObject(obj, options, encoding = "hex") {
+  const jsonString = deterministicStringify(obj, options);
+  return crypto.createHash("sha256").update(jsonString).digest(encoding);
+}
+
 const MAX_PENDING_RELIABLE_SESSION_MESSAGES = 200;
 const MAX_PENDING_RELIABLE_SESSION_MESSAGE_BYTES = 512 * 1024;
-const PROTOCOL_V3_INITIAL_SNAPSHOT_LIMIT = 150;
+const PROTOCOL_V3_INITIAL_SNAPSHOT_LIMIT = 300;
 const PROTOCOL_V3_CHANGES_PAGE_LIMIT = 200;
 const PROTOCOL_V3_CAPABILITIES_WAIT_MS = 250;
 const COMMITTED_SESSION_WRITE_ACK_TIMEOUT_MS = 5e3;
@@ -4277,8 +4564,11 @@ class ApiSessionClient extends node_events.EventEmitter {
   agentState;
   agentStateVersion;
   socket;
+  initialSessionSeq;
   pendingMessages = [];
   pendingMessageCallback = null;
+  pendingSessionMessages = [];
+  pendingSessionMessageCallback = null;
   rpcHandlerManager;
   agentStateLock = new AsyncLock();
   metadataLock = new AsyncLock();
@@ -4318,6 +4608,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     this.agentStateVersion = session.agentStateVersion;
     this.encryptionKey = session.encryptionKey;
     this.encryptionVariant = session.encryptionVariant;
+    this.initialSessionSeq = session.seq;
     this.lastChangeSeq = session.seq;
     this.committedSessionWriteAckMode = this.credentials.signing ? "unknown" : "unsupported";
     for (const [dispatchId, ack] of Object.entries(session.metadata?.happyOrg?.dispatchAcks ?? {})) {
@@ -4432,6 +4723,12 @@ class ApiSessionClient extends node_events.EventEmitter {
       callback(this.pendingMessages.shift());
     }
   }
+  onSessionMessage(callback) {
+    this.pendingSessionMessageCallback = callback;
+    while (this.pendingSessionMessages.length > 0) {
+      callback(this.pendingSessionMessages.shift());
+    }
+  }
   configureProtocolV3Sync(options) {
     this.invalidateProtocolV3SessionSync();
     this.protocolV3SessionSync = options;
@@ -4458,6 +4755,13 @@ class ApiSessionClient extends node_events.EventEmitter {
     }
     return preserveSessionRuntimeMetadata(this.metadata, next);
   }
+  didSessionValueChange(current, next) {
+    try {
+      return deterministicStringify(current ?? null) !== deterministicStringify(next ?? null);
+    } catch {
+      return true;
+    }
+  }
   async waitForMetadataUpdate(signal) {
     if (signal?.aborted) {
       throw createAbortError();
@@ -4710,7 +5014,10 @@ class ApiSessionClient extends node_events.EventEmitter {
   updateMetadata(handler) {
     this.trackPendingBackgroundTask(this.metadataLock.inLock(async () => {
       await backoff(async () => {
-        let updated = this.mergeRuntimeMetadata(handler(this.metadata));
+        const updated = this.mergeRuntimeMetadata(handler(this.metadata));
+        if (!this.didSessionValueChange(this.metadata, updated)) {
+          return;
+        }
         const sessionIndex = buildSessionRuntimeIndex(updated);
         const answer = await this.socket.emitWithAck("update-metadata", {
           sid: this.sessionId,
@@ -4756,7 +5063,10 @@ class ApiSessionClient extends node_events.EventEmitter {
     logger.debugLargeJson("Updating agent state", this.agentState);
     this.trackPendingBackgroundTask(this.agentStateLock.inLock(async () => {
       await backoff(async () => {
-        let updated = handler(this.agentState || {});
+        const updated = handler(this.agentState || {});
+        if (!this.didSessionValueChange(this.agentState, updated)) {
+          return;
+        }
         const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, updated)) : null });
         if (answer.result === "success") {
           this.agentState = answer.agentState ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.agentState)) : null;
@@ -4838,7 +5148,10 @@ class ApiSessionClient extends node_events.EventEmitter {
       if (messageSeq !== null && messageSeq <= this.lastChangeSeq) {
         return;
       }
-      this.dispatchPlaintextSessionMessage(data.body.message.content.p);
+      this.dispatchPlaintextSessionMessage(data.body.message.content.p, {
+        source: "live",
+        seq: messageSeq
+      });
       if (messageSeq !== null) {
         this.lastChangeSeq = Math.max(this.lastChangeSeq, messageSeq);
       }
@@ -4849,7 +5162,10 @@ class ApiSessionClient extends node_events.EventEmitter {
       if (messageSeq !== null && messageSeq <= this.lastChangeSeq) {
         return;
       }
-      this.dispatchEncryptedSessionMessage(data.body.message.content.c);
+      this.dispatchEncryptedSessionMessage(data.body.message.content.c, {
+        source: "live",
+        seq: messageSeq
+      });
       if (messageSeq !== null) {
         this.lastChangeSeq = Math.max(this.lastChangeSeq, messageSeq);
       }
@@ -4894,18 +5210,25 @@ class ApiSessionClient extends node_events.EventEmitter {
     }
     this.emit("message", data.body);
   }
-  dispatchEncryptedSessionMessage(encryptedMessage) {
+  dispatchEncryptedSessionMessage(encryptedMessage, options) {
     const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(encryptedMessage));
     logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
     const parsedBody = body ?? buildHappyOrgFallbackUserMessage(encryptedMessage);
-    const userResult = UserMessageSchema.safeParse(parsedBody);
-    if (userResult.success) {
-      this.maybeAutoAcknowledgeHappyOrgDispatch(userResult.data);
-      if (this.pendingMessageCallback) {
-        this.pendingMessageCallback(userResult.data);
-      } else {
-        this.pendingMessages.push(userResult.data);
+    const messageResult = MessageContentSchema.safeParse(parsedBody);
+    if (messageResult.success) {
+      const queuesPendingInput = this.dispatchSessionTranscriptMessage(messageResult.data, options);
+      if (messageResult.data.role === "user") {
+        if (queuesPendingInput) {
+          this.maybeAutoAcknowledgeHappyOrgDispatch(messageResult.data);
+          if (this.pendingMessageCallback) {
+            this.pendingMessageCallback(messageResult.data);
+          } else {
+            this.pendingMessages.push(messageResult.data);
+          }
+        }
+        return;
       }
+      this.emit("message", messageResult.data);
       return;
     }
     this.emit("message", parsedBody);
@@ -4914,7 +5237,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    * Dispatch a plaintext session message (AES mode: server already decrypted).
    * The plaintext JSON is parsed and validated as a UserMessage.
    */
-  dispatchPlaintextSessionMessage(plaintextJson) {
+  dispatchPlaintextSessionMessage(plaintextJson, options) {
     logger.debug("[SOCKET] [UPDATE] [PLAINTEXT] Received plaintext message");
     let parsedBody = null;
     try {
@@ -4923,19 +5246,41 @@ class ApiSessionClient extends node_events.EventEmitter {
       logger.debug("[SOCKET] [UPDATE] [PLAINTEXT] Failed to parse plaintext JSON, ignoring");
       return;
     }
-    const userResult = UserMessageSchema.safeParse(parsedBody);
-    if (userResult.success) {
-      this.maybeAutoAcknowledgeHappyOrgDispatch(userResult.data);
-      if (this.pendingMessageCallback) {
-        this.pendingMessageCallback(userResult.data);
-      } else {
-        this.pendingMessages.push(userResult.data);
+    const messageResult = MessageContentSchema.safeParse(parsedBody);
+    if (messageResult.success) {
+      const queuesPendingInput = this.dispatchSessionTranscriptMessage(messageResult.data, options);
+      if (messageResult.data.role === "user") {
+        if (queuesPendingInput) {
+          this.maybeAutoAcknowledgeHappyOrgDispatch(messageResult.data);
+          if (this.pendingMessageCallback) {
+            this.pendingMessageCallback(messageResult.data);
+          } else {
+            this.pendingMessages.push(messageResult.data);
+          }
+        }
+        return;
       }
+      this.emit("message", messageResult.data);
       return;
     }
-    logger.debug("[SOCKET] [UPDATE] [PLAINTEXT] Message did not match UserMessageSchema, emitting generic event");
+    logger.debug("[SOCKET] [UPDATE] [PLAINTEXT] Message did not match MessageContentSchema, emitting generic event");
     this.emit("message", parsedBody);
   }
+  dispatchSessionTranscriptMessage(message, options) {
+    const queuesPendingInput = message.role === "user" && (options.source === "live" || this.initialSessionSeq === 0);
+    const transcriptMessage = {
+      source: options.source,
+      seq: typeof options.seq === "number" ? options.seq : null,
+      message,
+      queuesPendingInput
+    };
+    if (this.pendingSessionMessageCallback) {
+      this.pendingSessionMessageCallback(transcriptMessage);
+    } else {
+      this.pendingSessionMessages.push(transcriptMessage);
+    }
+    return queuesPendingInput;
+  }
   maybeAutoAcknowledgeHappyOrgDispatch(message) {
     const candidate = this.resolveHappyOrgDispatchBusinessAckCandidate(message);
     if (!candidate) {
@@ -5240,7 +5585,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         sessionId: this.sessionId,
         lastChangeSeq: this.lastChangeSeq
       });
-      if (!this.initialProtocolV3SnapshotComplete && this.lastChangeSeq === 0 && (!this.protocolV3Descriptor || this.supportsKnownProtocolCapability("session_snapshot_v3"))) {
+      if (!this.initialProtocolV3SnapshotComplete && (!this.protocolV3Descriptor || this.supportsKnownProtocolCapability("session_snapshot_v3"))) {
         const snapshot = await this.protocolV3SessionSync.getSessionSnapshot(
           this.sessionId,
           this.protocolV3SessionSync.snapshotLimit ?? PROTOCOL_V3_INITIAL_SNAPSHOT_LIMIT
@@ -5297,13 +5642,16 @@ class ApiSessionClient extends node_events.EventEmitter {
   applyProtocolV3Snapshot(snapshot) {
     this.applyProtocolV3SessionOverlay(snapshot.session);
     for (const message of snapshot.snapshot.messages) {
-      if (message.seq <= this.lastChangeSeq) {
-        continue;
-      }
       if (message.content.t === "plaintext") {
-        this.dispatchPlaintextSessionMessage(message.content.p);
+        this.dispatchPlaintextSessionMessage(message.content.p, {
+          source: "snapshot",
+          seq: message.seq
+        });
       } else if (message.content.t === "encrypted") {
-        this.dispatchEncryptedSessionMessage(message.content.c);
+        this.dispatchEncryptedSessionMessage(message.content.c, {
+          source: "snapshot",
+          seq: message.seq
+        });
       }
       this.lastChangeSeq = Math.max(this.lastChangeSeq, message.seq);
     }
@@ -5332,11 +5680,18 @@ class ApiSessionClient extends node_events.EventEmitter {
       case "message.created": {
         const message = payload.message;
         if (message && typeof message === "object") {
+          const messageSeq = typeof message.seq === "number" ? message.seq : null;
           const content = message.content;
           if (content && typeof content === "object" && content.t === "plaintext" && typeof content.p === "string") {
-            this.dispatchPlaintextSessionMessage(content.p);
+            this.dispatchPlaintextSessionMessage(content.p, {
+              source: "live",
+              seq: messageSeq ?? change.changeSeq
+            });
           } else if (content && typeof content === "object" && content.t === "encrypted" && typeof content.c === "string") {
-            this.dispatchEncryptedSessionMessage(content.c);
+            this.dispatchEncryptedSessionMessage(content.c, {
+              source: "live",
+              seq: messageSeq ?? change.changeSeq
+            });
           }
         }
         break;
@@ -5757,12 +6112,12 @@ class ApiMachineClient {
     requestShutdown
   }) {
     this.rpcHandlerManager.registerHandler("spawn-happy-session", async (params) => {
-      const { directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, environmentVariables } = params || {};
+      const { directory, sessionId, machineId, managedSessionTag, approvedNewDirectoryCreation, agent, token, resume, environmentVariables } = params || {};
       logger.debug(`[API MACHINE] Spawning session with params: ${JSON.stringify(params)}`);
       if (!directory) {
         throw new Error("Directory is required");
       }
-      const result = await spawnSession({ directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, environmentVariables });
+      const result = await spawnSession({ directory, sessionId, machineId, managedSessionTag, approvedNewDirectoryCreation, agent, token, resume, environmentVariables });
       switch (result.type) {
         case "success":
           logger.debug(`[API MACHINE] Spawned session ${result.sessionId}`);
@@ -6968,8 +7323,10 @@ exports.encrypt = encrypt;
 exports.ensureSigningCredentials = ensureSigningCredentials;
 exports.getLatestDaemonLog = getLatestDaemonLog;
 exports.getProfileEnvironmentVariables = getProfileEnvironmentVariables;
+exports.hashObject = hashObject;
 exports.isAuthenticationRequiredError = isAuthenticationRequiredError;
 exports.logger = logger;
+exports.normalizePreviewableArtifactTarget = normalizePreviewableArtifactTarget;
 exports.packageJson = packageJson;
 exports.persistence = persistence;
 exports.preserveSessionRuntimeMetadata = preserveSessionRuntimeMetadata;