happy-imou-cloud 2.1.24 → 2.1.26

package/dist/{index-DA3m13mn.mjs → index-hj-qbq8Y.mjs}

@@ -1,5 +1,5 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, j as encodeBase64, c as configuration, k as readCredentials, m as ensureSigningCredentials, r as readSettings, u as updateSettings, n as encodeBase64Url, g as delay, o as buildClientHeaders, q as decodeBase64, w as writeCredentialsLegacy, t as writeCredentialsDataKey, v as readDaemonState, x as HAPPY_CLOUD_DAEMON_PORT, y as clearDaemonState, z as packageJson, i as isAuthenticationRequiredError, B as acquireDaemonLock, C as writeDaemonState, A as ApiClient, D as releaseDaemonLock, E as validateProfileForAgent, F as getProfileEnvironmentVariables, G as clearCredentials, I as clearMachineId, M as MessageContentSchema, J as buildSocketAuth, K as encrypt, L as HeadTailPreviewBuffer, N as getLatestDaemonLog } from './api-DZeS3vrX.mjs';
+import { l as logger, j as encodeBase64, c as configuration, k as readCredentials, m as ensureSigningCredentials, r as readSettings, u as updateSettings, n as encodeBase64Url, g as delay, o as buildClientHeaders, q as decodeBase64, w as writeCredentialsLegacy, t as writeCredentialsDataKey, v as readDaemonState, x as HAPPY_CLOUD_DAEMON_PORT, y as clearDaemonState, z as packageJson, i as isAuthenticationRequiredError, B as acquireDaemonLock, C as writeDaemonState, A as ApiClient, D as releaseDaemonLock, E as validateProfileForAgent, F as getProfileEnvironmentVariables, G as clearCredentials, I as clearMachineId, M as MessageContentSchema, J as buildSocketAuth, K as encrypt, L as HeadTailPreviewBuffer, N as getLatestDaemonLog } from './api-DugHuNd4.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os$1, { homedir } from 'os';
@@ -11,7 +11,7 @@ import qrcode from 'qrcode-terminal';
 import { writeFile, unlink, readdir, readFile, mkdir } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import os, { tmpdir, homedir as homedir$1 } from 'node:os';
-import path, { join, resolve as resolve$1, isAbsolute, delimiter, basename, normalize, dirname as dirname$1 } from 'node:path';
+import path, { join, resolve as resolve$1, isAbsolute, delimiter, normalize, dirname as dirname$1, basename } from 'node:path';
 import open from 'open';
 import React, { useState } from 'react';
 import { useInput, Box, Text, render } from 'ink';
@@ -5313,6 +5313,70 @@ function parseAgentSendArgs(args) {
   };
 }
 
+const defaultDeps = {
+  listDaemonSessions,
+  stopDaemonSession,
+  log: (message) => console.log(message),
+  error: (message) => console.error(message)
+};
+function renderSessionCommandHelp() {
+  return [
+    "Usage: hicloud session <command>",
+    "",
+    "Commands:",
+    "  list                 List active sessions tracked by the daemon",
+    "  kill <session|pid>   Stop a tracked session by session ID or PID"
+  ].join("\n");
+}
+async function resolveSessionIdFromTarget(target, deps) {
+  if (!/^\d+$/.test(target)) {
+    return target;
+  }
+  const sessions = await deps.listDaemonSessions();
+  const match = sessions.find((session) => String(session.pid) === target);
+  return match?.happySessionId ?? null;
+}
+async function handleSessionCommand(args, deps = defaultDeps) {
+  const subcommand = args[0];
+  if (subcommand === "list") {
+    try {
+      const sessions = await deps.listDaemonSessions();
+      if (sessions.length === 0) {
+        deps.log("No active sessions this daemon is aware of");
+        return 0;
+      }
+      deps.log("Active sessions:");
+      deps.log(JSON.stringify(sessions, null, 2));
+      return 0;
+    } catch {
+      deps.log("No daemon running");
+      return 0;
+    }
+  }
+  if (subcommand === "kill") {
+    const target = args[1];
+    if (!target) {
+      deps.error("Session ID or PID required");
+      return 1;
+    }
+    try {
+      const sessionId = await resolveSessionIdFromTarget(target, deps);
+      if (!sessionId) {
+        deps.error(`No tracked session found for PID ${target}`);
+        return 1;
+      }
+      const success = await deps.stopDaemonSession(sessionId);
+      deps.log(success ? "Session stopped" : "Failed to stop session");
+      return success ? 0 : 1;
+    } catch {
+      deps.error("No daemon running");
+      return 1;
+    }
+  }
+  deps.log(renderSessionCommandHelp());
+  return 0;
+}
+
 function getProjectPath(workingDirectory, claudeConfigDirOverride) {
   const projectId = resolve$1(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
   const claudeConfigDirRaw = process.env.CLAUDE_CONFIG_DIR ?? "";
@@ -6411,8 +6475,6 @@ const DEFAULT_IDLE_TIMEOUT_MS = 500;
 const DEFAULT_TOOL_CALL_TIMEOUT_MS = 10 * 6e4;
 const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_HEAD_BYTES = 2e3;
 const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_TAIL_BYTES = 4e3;
-const CONTENTLESS_FETCH_INPUT_NOTE = "ACP runtime did not provide fetch arguments.";
-const CONTENTLESS_FETCH_RESULT_TEXT = "Fetch completed, but the ACP runtime did not provide structured output.";
 function parseArgsFromContent(content) {
   if (Array.isArray(content)) {
     return { items: content };
@@ -6422,26 +6484,104 @@ function parseArgsFromContent(content) {
   }
   return {};
 }
-function isContentlessFetchTool(toolKind, content, locations) {
-  if (toolKind !== "fetch") {
+function buildToolCallArgs(_toolKind, content, locations) {
+  const args = parseArgsFromContent(content);
+  if (Array.isArray(locations)) {
+    args.locations = locations;
+  }
+  return args;
+}
+const MAX_TOOL_OUTPUT_OVERLAP_CHARS = 4096;
+const MAX_TRACKED_TOOL_OUTPUT_EXACT_CHARS = 16384;
+const MAX_TRACKED_TOOL_OUTPUT_HEAD_CHARS = 2048;
+const MAX_TRACKED_TOOL_OUTPUT_TAIL_CHARS = MAX_TOOL_OUTPUT_OVERLAP_CHARS;
+const MAX_TRACKED_TOOL_OUTPUT_SUFFIX_CHARS = 65536;
+function findTrailingNewlineTrimmedLength(text) {
+  let trimmedLength = text.length;
+  while (trimmedLength > 0) {
+    const charCode = text.charCodeAt(trimmedLength - 1);
+    if (charCode !== 10 && charCode !== 13) {
+      break;
+    }
+    trimmedLength--;
+  }
+  return trimmedLength;
+}
+function sliceSnapshotHead(text, length) {
+  return text.slice(0, Math.min(length, MAX_TRACKED_TOOL_OUTPUT_HEAD_CHARS));
+}
+function sliceSnapshotTail(text, length) {
+  const tailLength = Math.min(length, MAX_TRACKED_TOOL_OUTPUT_TAIL_CHARS);
+  return text.slice(Math.max(0, length - tailLength), length);
+}
+function sliceSnapshotSuffixWindow(text, length) {
+  const suffixLength = Math.min(length, MAX_TRACKED_TOOL_OUTPUT_SUFFIX_CHARS);
+  return text.slice(Math.max(0, length - suffixLength), length);
+}
+function buildToolOutputSnapshot(text) {
+  const length = text.length;
+  const trimmedLength = findTrailingNewlineTrimmedLength(text);
+  return {
+    length,
+    exact: length <= MAX_TRACKED_TOOL_OUTPUT_EXACT_CHARS ? text : void 0,
+    head: sliceSnapshotHead(text, length),
+    tail: sliceSnapshotTail(text, length),
+    suffixWindow: sliceSnapshotSuffixWindow(text, length),
+    trimmedLength,
+    trimmedExact: trimmedLength <= MAX_TRACKED_TOOL_OUTPUT_EXACT_CHARS ? text.slice(0, trimmedLength) : void 0,
+    trimmedHead: sliceSnapshotHead(text, trimmedLength),
+    trimmedTail: sliceSnapshotTail(text, trimmedLength),
+    trimmedSuffixWindow: sliceSnapshotSuffixWindow(text, trimmedLength)
+  };
+}
+function snapshotMatchesEdges(next, snapshotLength, snapshotHead, snapshotTail) {
+  if (next.length < snapshotLength) {
     return false;
   }
-  if (hasMeaningfulContent(content)) {
+  if (snapshotHead.length > 0 && !next.startsWith(snapshotHead)) {
     return false;
   }
-  return !Array.isArray(locations) || locations.length === 0;
+  if (snapshotTail.length === 0) {
+    return true;
+  }
+  const tailStart = snapshotLength - snapshotTail.length;
+  return next.slice(tailStart, tailStart + snapshotTail.length) === snapshotTail;
 }
-function buildToolCallArgs(toolKind, content, locations) {
-  const args = parseArgsFromContent(content);
-  if (Array.isArray(locations)) {
-    args.locations = locations;
+function snapshotMatchesText(snapshot, next, useTrimmedSnapshot = false) {
+  const snapshotLength = useTrimmedSnapshot ? snapshot.trimmedLength : snapshot.length;
+  if (next.length !== snapshotLength) {
+    return false;
   }
-  if (isContentlessFetchTool(toolKind, content, locations)) {
-    args.note = CONTENTLESS_FETCH_INPUT_NOTE;
+  const snapshotExact = useTrimmedSnapshot ? snapshot.trimmedExact : snapshot.exact;
+  if (snapshotExact !== void 0) {
+    return next === snapshotExact;
   }
-  return args;
+  const snapshotHead = useTrimmedSnapshot ? snapshot.trimmedHead : snapshot.head;
+  const snapshotTail = useTrimmedSnapshot ? snapshot.trimmedTail : snapshot.tail;
+  return snapshotMatchesEdges(next, snapshotLength, snapshotHead, snapshotTail);
+}
+function snapshotIsPrefixOfText(snapshot, next, useTrimmedSnapshot = false) {
+  const snapshotLength = useTrimmedSnapshot ? snapshot.trimmedLength : snapshot.length;
+  if (next.length < snapshotLength) {
+    return false;
+  }
+  const snapshotExact = useTrimmedSnapshot ? snapshot.trimmedExact : snapshot.exact;
+  if (snapshotExact !== void 0) {
+    return next.startsWith(snapshotExact);
+  }
+  const snapshotHead = useTrimmedSnapshot ? snapshot.trimmedHead : snapshot.head;
+  const snapshotTail = useTrimmedSnapshot ? snapshot.trimmedTail : snapshot.tail;
+  return snapshotMatchesEdges(next, snapshotLength, snapshotHead, snapshotTail);
+}
+function snapshotEndsWithText(snapshot, next) {
+  if (next.length === 0) {
+    return true;
+  }
+  if (snapshot.exact !== void 0) {
+    return snapshot.exact.endsWith(next);
+  }
+  return next.length <= snapshot.suffixWindow.length && snapshot.suffixWindow.endsWith(next);
 }
-const MAX_TOOL_OUTPUT_OVERLAP_CHARS = 4096;
 function findToolOutputOverlap(previous, next) {
   const maxOverlap = Math.min(previous.length, next.length, MAX_TOOL_OUTPUT_OVERLAP_CHARS);
   if (maxOverlap === 0) {
@@ -6460,27 +6600,27 @@ function getToolOutputDelta(previous, next) {
   if (!previous || previous.length === 0) {
     return next;
   }
-  if (next === previous || previous.endsWith(next)) {
+  if (snapshotMatchesText(previous, next) || snapshotEndsWithText(previous, next)) {
     return "";
   }
-  if (next.startsWith(previous)) {
+  if (snapshotIsPrefixOfText(previous, next)) {
     return next.slice(previous.length);
   }
-  const overlap = findToolOutputOverlap(previous, next);
+  const overlapSource = previous.exact ?? previous.tail;
+  const overlap = findToolOutputOverlap(overlapSource, next);
   return overlap > 0 ? next.slice(overlap) : next;
 }
 function shouldReplaceToolOutput(previous, next) {
   if (!previous || previous.length === 0) {
     return false;
   }
-  if (next.startsWith(previous)) {
+  if (snapshotIsPrefixOfText(previous, next)) {
     return false;
   }
-  const previousWithoutTrailingNewlines = previous.replace(/[\r\n]+$/g, "");
-  if (previousWithoutTrailingNewlines.length === previous.length) {
+  if (previous.trimmedLength === previous.length) {
     return false;
   }
-  return next.startsWith(previousWithoutTrailingNewlines);
+  return snapshotIsPrefixOfText(previous, next, true);
 }
 function appendToolOutput(existing, next) {
   const shouldReplace = shouldReplaceToolOutput(existing?.lastRawText, next);
@@ -6498,7 +6638,10 @@ function appendToolOutput(existing, next) {
   }
   return {
     preview,
-    lastRawText: next,
+    // ACP runtimes sometimes resend the entire cumulative stdout snapshot.
+    // Keep only a bounded summary for dedupe so long tool runs cannot retain
+    // every historical snapshot in memory.
+    lastRawText: buildToolOutputSnapshot(next),
     updateCount: (existing?.updateCount ?? 0) + 1
   };
 }
@@ -6633,15 +6776,8 @@ function mergeStreamedOutputWithResult(content, streamedOutput) {
   }
   return content;
 }
-function buildCompletedToolResult(toolKind, content, streamedOutput) {
-  const merged = mergeStreamedOutputWithResult(content, streamedOutput);
-  if (toolKind === "fetch" && !hasMeaningfulContent(merged)) {
-    return {
-      text: CONTENTLESS_FETCH_RESULT_TEXT,
-      status: "completed"
-    };
-  }
-  return merged;
+function buildCompletedToolResult(_toolKind, content, streamedOutput) {
+  return mergeStreamedOutputWithResult(content, streamedOutput);
 }
 function extractErrorDetail(content) {
   if (!content) return void 0;
@@ -6958,12 +7094,11 @@ ${line.slice(-tailChars)}`;
 }
 function createAcpFilteredStdoutReadable(params) {
   const maxMultilineBytes = typeof params.maxMultilineBytes === "number" && Number.isFinite(params.maxMultilineBytes) && params.maxMultilineBytes > 0 ? Math.trunc(params.maxMultilineBytes) : 1e6;
-  const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   return new ReadableStream({
     async start(controller) {
       const reader = params.readable.getReader();
-      let buffer = "";
+      let buffer = Buffer.alloc(0);
       let multiline = null;
       let discardingOversizedLine = false;
       let controllerErrored = false;
@@ -6976,14 +7111,16 @@ function createAcpFilteredStdoutReadable(params) {
         }
         const filtered = params.transport.filterStdoutLine?.(line);
         if (filtered === void 0) {
-          controller.enqueue(encoder.encode(line + "\n"));
+          controller.enqueue(encoder.encode(`${line}
+`));
           return;
         }
         if (filtered === null) {
           drop("transport_filter_null", line);
           return;
         }
-        controller.enqueue(encoder.encode(filtered + "\n"));
+        controller.enqueue(encoder.encode(`${filtered}
+`));
       };
       const tryFlushMultiline = (candidate) => {
         const trimmed = candidate.trim();
@@ -7004,6 +7141,46 @@ function createAcpFilteredStdoutReadable(params) {
           return false;
         }
       };
+      const consumeLine = (line, lineBytes) => {
+        if (multiline) {
+          const nextBuf = multiline.buf.length > 0 ? `${multiline.buf}
+${line}` : line;
+          const nextBytes = multiline.bytes + lineBytes + 1;
+          if (nextBytes > maxMultilineBytes) {
+            drop("multiline_overflow", multiline.buf);
+            multiline = null;
+            if (lineBytes > maxMultilineBytes) {
+              drop("multiline_overflow", line);
+              return;
+            }
+            enqueueLine(line);
+            return;
+          }
+          multiline = { buf: nextBuf, bytes: nextBytes };
+          if (tryFlushMultiline(multiline.buf)) {
+            multiline = null;
+          }
+          return;
+        }
+        if (lineBytes > maxMultilineBytes) {
+          drop("multiline_overflow", line);
+          return;
+        }
+        const trimmed = line.trim();
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+          try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed === "object" && parsed !== null) {
+              enqueueLine(line);
+              return;
+            }
+          } catch {
+            multiline = { buf: line, bytes: lineBytes };
+            return;
+          }
+        }
+        enqueueLine(line);
+      };
       try {
         while (true) {
           const { value, done } = await reader.read();
@@ -7013,73 +7190,54 @@ function createAcpFilteredStdoutReadable(params) {
           if (!value) {
             continue;
           }
-          let decodedChunk = decoder.decode(value, { stream: true });
+          let chunkBuffer = Buffer.from(value);
           if (discardingOversizedLine) {
-            const newlineIndex = decodedChunk.indexOf("\n");
-            if (newlineIndex === -1) {
+            const newlineIndex2 = chunkBuffer.indexOf(10);
+            if (newlineIndex2 === -1) {
               continue;
             }
-            decodedChunk = decodedChunk.slice(newlineIndex + 1);
+            chunkBuffer = chunkBuffer.subarray(newlineIndex2 + 1);
             discardingOversizedLine = false;
           }
-          buffer += decodedChunk;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (multiline) {
-              const nextBuf = multiline.buf.length > 0 ? `${multiline.buf}
-${line}` : line;
-              const nextBytes = multiline.bytes + line.length + 1;
-              if (nextBytes > maxMultilineBytes) {
-                drop("multiline_overflow", multiline.buf);
-                multiline = null;
-                if (line.length > maxMultilineBytes) {
-                  drop("multiline_overflow", line);
-                  continue;
-                }
-                enqueueLine(line);
-                continue;
-              }
-              multiline = { buf: nextBuf, bytes: nextBytes };
-              if (tryFlushMultiline(multiline.buf)) {
-                multiline = null;
-              }
-              continue;
-            }
-            if (line.length > maxMultilineBytes) {
-              drop("multiline_overflow", line);
-              continue;
-            }
-            const trimmed = line.trim();
-            if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-              try {
-                const parsed = JSON.parse(trimmed);
-                if (typeof parsed === "object" && parsed !== null) {
-                  enqueueLine(line);
-                  continue;
-                }
-              } catch {
-                multiline = { buf: line, bytes: line.length };
-                continue;
-              }
-            }
-            enqueueLine(line);
+          if (chunkBuffer.length === 0) {
+            continue;
+          }
+          buffer = buffer.length === 0 ? chunkBuffer : Buffer.concat([buffer, chunkBuffer]);
+          let newlineIndex = buffer.indexOf(10);
+          while (newlineIndex !== -1) {
+            const rawLine = buffer.subarray(0, newlineIndex);
+            buffer = buffer.subarray(newlineIndex + 1);
+            const lineBuffer = rawLine.at(-1) === 13 ? rawLine.subarray(0, rawLine.length - 1) : rawLine;
+            const line = lineBuffer.toString("utf8");
+            consumeLine(line, lineBuffer.length);
+            newlineIndex = buffer.indexOf(10);
           }
           if (buffer.length > maxMultilineBytes) {
-            drop("multiline_overflow", buffer);
-            buffer = "";
+            drop("multiline_overflow", buffer.toString("utf8"));
+            buffer = Buffer.alloc(0);
             discardingOversizedLine = true;
           }
         }
-        if (multiline) {
-          if (!tryFlushMultiline(multiline.buf)) {
-            drop("multiline_incomplete", multiline.buf);
+        if (buffer.length > 0) {
+          const trailingLine = buffer.toString("utf8");
+          const pendingMultiline = multiline;
+          if (pendingMultiline) {
+            const nextBuf = pendingMultiline.buf.length > 0 ? `${pendingMultiline.buf}
+${trailingLine}` : trailingLine;
+            if (!tryFlushMultiline(nextBuf)) {
+              drop("multiline_incomplete", nextBuf);
+            }
+            multiline = null;
+          } else if (trailingLine.trim()) {
+            drop("multiline_incomplete", trailingLine);
           }
-          multiline = null;
         }
-        const trailing = buffer.trim();
-        if (trailing) {
-          drop("multiline_incomplete", buffer);
+        const remainingMultiline = multiline;
+        if (remainingMultiline) {
+          if (!tryFlushMultiline(remainingMultiline.buf)) {
+            drop("multiline_incomplete", remainingMultiline.buf);
+          }
+          multiline = null;
         }
       } catch (error) {
         controllerErrored = true;
@@ -7178,6 +7336,7 @@ const RETRY_CONFIG = {
   maxDelayMs: 5e3
 };
 const DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS = 2 * 6e4;
+const MAX_DROPPED_STDOUT_LINE_SAMPLES = 5;
 function readPositiveIntegerEnv(name) {
   const raw = typeof process.env[name] === "string" ? process.env[name].trim() : "";
   if (!raw) {
@@ -7273,6 +7432,12 @@ function isSelectionPermissionRequest(params) {
   }
   return !options.every((option) => isApprovalOption(option));
 }
+function appendDroppedStdoutLineSummary(summary, entry) {
+  summary.count += 1;
+  if (summary.samples.length < MAX_DROPPED_STDOUT_LINE_SAMPLES) {
+    summary.samples.push(entry);
+  }
+}
 function nodeToWebStreams(stdin, stdout) {
   const writable = new WritableStream({
     write(chunk) {
@@ -7915,19 +8080,22 @@ ${recentStderrExcerpt}`);
       );
       const writable = streams.writable;
       const readable = streams.readable;
-      const droppedStdoutLines = [];
+      const droppedStdoutSummary = {
+        count: 0,
+        samples: []
+      };
       const filteredReadable = createAcpFilteredStdoutReadable({
         readable,
         transport: this.transport,
         onDroppedLine: (entry) => {
-          droppedStdoutLines.push(entry);
+          appendDroppedStdoutLineSummary(droppedStdoutSummary, entry);
           this.handleDroppedStdoutLine(entry);
         },
         onDone: () => {
-          if (droppedStdoutLines.length > 0) {
+          if (droppedStdoutSummary.count > 0) {
             logger.debug(
-              `[AcpBackend] Filtered out ${droppedStdoutLines.length} stdout lines from ${this.transport.agentName}`,
-              droppedStdoutLines.slice(0, 5)
+              `[AcpBackend] Filtered out ${droppedStdoutSummary.count} stdout lines from ${this.transport.agentName}`,
+              droppedStdoutSummary.samples
             );
           }
         }
@@ -9171,7 +9339,7 @@ function copyCodexHomeEntry(sourcePath, destPath) {
   });
 }
 function normalizePathForComparison(path, platform) {
-  const normalizedPath = normalize(path).replace(/[\\/]+$/, "");
+  const normalizedPath = normalize(path).replace(/[\\/]+/g, "/").replace(/\/+$/, "");
   return platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
 }
 function isManagedTemporaryCodexHomePath(path, platform) {
@@ -9179,13 +9347,13 @@ function isManagedTemporaryCodexHomePath(path, platform) {
   if (!trimmedPath) {
     return false;
   }
-  if (!basename(trimmedPath).startsWith(MANAGED_CODEX_HOME_PREFIX)) {
+  const pathBaseName = trimmedPath.replace(/[\\/]+$/, "").split(/[\\/]/).at(-1) ?? "";
+  if (!pathBaseName.startsWith(MANAGED_CODEX_HOME_PREFIX)) {
     return false;
   }
   const normalizedTempRoot = normalizePathForComparison(tmpdir(), platform);
   const normalizedPath = normalizePathForComparison(trimmedPath, platform);
-  const separator = platform === "win32" ? "\\" : "/";
-  return normalizedPath.startsWith(`${normalizedTempRoot}${separator}`);
+  return normalizedPath.startsWith(`${normalizedTempRoot}/`);
 }
 function extractSkillDescriptionFromFrontmatter(frontmatter) {
   const lines = frontmatter.split(/\r?\n/);
@@ -9241,25 +9409,7 @@ function shouldSeedCodexSkillEntry(sourcePath) {
   }
   return true;
 }
-function seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir) {
-  if (!existsSync(sourceHomeDir)) {
-    return;
-  }
-  for (const fileName of CODEX_HOME_SEED_FILES) {
-    try {
-      copyCodexHomeEntry(join(sourceHomeDir, fileName), join(isolatedHomeDir, fileName));
-    } catch (error) {
-      logger.debug(`[codex] Failed to seed CODEX_HOME file ${fileName}`, error);
-    }
-  }
-  for (const dirName of CODEX_HOME_SEED_DIRS) {
-    try {
-      copyCodexHomeEntry(join(sourceHomeDir, dirName), join(isolatedHomeDir, dirName));
-    } catch (error) {
-      logger.debug(`[codex] Failed to seed CODEX_HOME directory ${dirName}`, error);
-    }
-  }
-  const sourceSkillsDir = join(sourceHomeDir, "skills");
+function seedCodexSkillEntries(sourceSkillsDir, isolatedHomeDir, sourceLabel) {
   if (!existsSync(sourceSkillsDir)) {
     return;
   }
@@ -9276,10 +9426,32 @@ function seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir) {
         join(destSkillsDir, entryName)
       );
     } catch (error) {
-      logger.debug(`[codex] Failed to seed CODEX_HOME skills entry ${entryName}`, error);
+      logger.debug(`[codex] Failed to seed CODEX_HOME skills entry ${entryName} from ${sourceLabel}`, error);
     }
   }
 }
+function seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir) {
+  if (existsSync(sourceHomeDir)) {
+    for (const fileName of CODEX_HOME_SEED_FILES) {
+      try {
+        copyCodexHomeEntry(join(sourceHomeDir, fileName), join(isolatedHomeDir, fileName));
+      } catch (error) {
+        logger.debug(`[codex] Failed to seed CODEX_HOME file ${fileName}`, error);
+      }
+    }
+    for (const dirName of CODEX_HOME_SEED_DIRS) {
+      try {
+        copyCodexHomeEntry(join(sourceHomeDir, dirName), join(isolatedHomeDir, dirName));
+      } catch (error) {
+        logger.debug(`[codex] Failed to seed CODEX_HOME directory ${dirName}`, error);
+      }
+    }
+  }
+  if (bundledSkillsDir) {
+    seedCodexSkillEntries(bundledSkillsDir, isolatedHomeDir, "bundled skills");
+  }
+  seedCodexSkillEntries(join(sourceHomeDir, "skills"), isolatedHomeDir, "source CODEX_HOME");
+}
 function prepareCodexAcpEnvironment(overrides = {}, options = {}) {
   const env = buildCodexAcpEnv(overrides, options);
   const platform = options.platform ?? process.platform;
@@ -9300,7 +9472,8 @@ function prepareCodexAcpEnvironment(overrides = {}, options = {}) {
   const isolatedHomeDir = tempDirFactory(join(tmpdir(), "happy-codex-home-"));
   mkdirSync$1(isolatedHomeDir, { recursive: true });
   const sourceHomeDir = options.sourceHomeDir ?? join(homedir$1(), ".codex");
-  seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir);
+  const bundledSkillsDir = options.bundledSkillsDir ?? join(projectPath(), "skills");
+  seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir);
   env.CODEX_HOME = isolatedHomeDir;
   return {
     env,
@@ -10776,14 +10949,14 @@ var launch = /*#__PURE__*/Object.freeze({
 const unifiedProviderExecutors = {
   claude: async (opts) => {
     const claudeOptions = opts.claudeOptions ?? {};
-    const { runClaude } = await import('./runClaude-BqN1RhrO.mjs');
+    const { runClaude } = await import('./runClaude-Y84RT6V0.mjs');
     await runClaude(opts.credentials, {
       ...claudeOptions,
       startingMode: claudeOptions.startingMode ?? (claudeOptions.startedBy === "daemon" ? "remote" : void 0)
     });
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-C3htqAO7.mjs');
+    const { runCodex } = await import('./runCodex-D2xIzHke.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -10792,7 +10965,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-CH9Cti4U.mjs');
+    const { runGemini } = await import('./runGemini-CAotw19V.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -10875,7 +11048,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-B_RdbyPU.mjs');
+      const { renderRuntimeProviders } = await import('./command-DU0KWNsf.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -10948,6 +11121,12 @@ function shouldRunMainClaudeFlow(opts) {
       process.exit(1);
     }
     return;
+  } else if (subcommand === "session") {
+    const exitCode = await handleSessionCommand(args.slice(1));
+    if (exitCode !== 0) {
+      process.exit(exitCode);
+    }
+    return;
   } else if (subcommand === "codex") {
     try {
       let startedBy = void 0;
@@ -11075,8 +11254,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./api-DZeS3vrX.mjs').then(function (n) { return n.O; });
-        const { ApiClient: ApiClient2 } = await import('./api-DZeS3vrX.mjs').then(function (n) { return n.P; });
+        const { readCredentials: readCredentials2 } = await import('./api-DugHuNd4.mjs').then(function (n) { return n.O; });
+        const { ApiClient: ApiClient2 } = await import('./api-DugHuNd4.mjs').then(function (n) { return n.P; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -11369,6 +11548,7 @@ ${chalk.bold("Usage:")}
   hicloud gemini            Start Gemini mode (ACP)
   hicloud cursor            Start Cursor mode (experimental ACP)
   hicloud connect           Connect AI vendor API keys
+  hicloud session           Manage tracked daemon sessions
   hicloud notify            Send push notification
   hicloud daemon            Manage background service that allows
                             to spawn new sessions away from your computer
@@ -11384,6 +11564,7 @@ ${chalk.bold("Examples:")}
   hicloud --claude-env ANTHROPIC_BASE_URL=http://127.0.0.1:3456
                            Use a custom API endpoint (e.g., claude-code-router)
   hicloud auth login --force Authenticate
+  hicloud session list       List daemon-tracked sessions
   hicloud doctor             Run diagnostics
 
 ${chalk.bold(`${BRAND_CONFIG.name} supports ALL Claude options!`)}