weacpx 0.5.2 → 0.6.0

package/dist/cli.js

@@ -9759,6 +9759,7 @@ function createEmptyState() {
   return {
     sessions: {},
     chat_contexts: {},
+    native_session_lists: {},
     orchestration: createEmptyOrchestrationState(),
     scheduled_tasks: {}
   };
@@ -9977,11 +9978,14 @@ function parseOrchestrationState(raw, path3) {
 function isReplyMode2(value) {
   return value === "stream" || value === "final" || value === "verbose";
 }
+function isSessionSource(value) {
+  return value === undefined || value === "weacpx" || value === "agent-side";
+}
 function isSessionRecord(value) {
   if (!isRecord2(value)) {
     return false;
   }
-  return isString(value.alias) && isString(value.agent) && isString(value.workspace) && isString(value.transport_session) && isOptionalString(value.transport_agent_command) && isOptionalString(value.mode_id) && (value.reply_mode === undefined || isReplyMode2(value.reply_mode)) && isString(value.created_at) && isString(value.last_used_at);
+  return isString(value.alias) && isString(value.agent) && isString(value.workspace) && isString(value.transport_session) && isSessionSource(value.source) && isOptionalString(value.agent_session_id) && isOptionalString(value.agent_session_title) && isOptionalString(value.agent_session_updated_at) && isOptionalString(value.attached_at) && isOptionalString(value.transport_agent_command) && isOptionalString(value.mode_id) && (value.reply_mode === undefined || isReplyMode2(value.reply_mode)) && isString(value.created_at) && isString(value.last_used_at);
 }
 function parseSessions(raw, path3) {
   const sessions = {};
@@ -10006,6 +10010,30 @@ function parseChatContexts(raw, path3) {
   }
   return chatContexts;
 }
+function isNativeSessionCacheEntry(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.session_id) && isOptionalString(value.cwd) && (value.title === undefined || value.title === null || isString(value.title)) && isOptionalString(value.updated_at);
+}
+function isNativeSessionListCacheRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.created_at) && isString(value.agent) && isOptionalString(value.workspace) && isString(value.cwd) && Array.isArray(value.sessions) && value.sessions.every(isNativeSessionCacheEntry) && (value.next_cursor === undefined || value.next_cursor === null || isString(value.next_cursor));
+}
+function parseNativeSessionLists(raw) {
+  if (!isRecord2(raw)) {
+    return {};
+  }
+  const nativeSessionLists = {};
+  for (const [chatKey, value] of Object.entries(raw)) {
+    if (isNativeSessionListCacheRecord(value)) {
+      nativeSessionLists[chatKey] = value;
+    }
+  }
+  return nativeSessionLists;
+}
 function isScheduledTaskStatus(value) {
   return value === "pending" || value === "triggering" || value === "executed" || value === "cancelled" || value === "missed" || value === "failed";
 }
@@ -10050,6 +10078,7 @@ function parseState(raw, path3) {
   return {
     sessions: parsedSessions,
     chat_contexts: parseChatContexts(chatContexts, path3),
+    native_session_lists: parseNativeSessionLists(raw.native_session_lists),
     orchestration,
     scheduled_tasks: parseScheduledTasks(raw.scheduled_tasks, path3)
   };
@@ -10167,6 +10196,13 @@ function resolveSessionAliasForInput(channelId, displayAlias, existingAliases) {
   }
   return scopedAlias;
 }
+function scopeDisplayAliasToInternal(channelId, displayAlias) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  return channelId === "weixin" ? normalized : toInternalSessionAlias(channelId, normalized);
+}
 function buildDefaultTransportSession(channelId, displayAlias) {
   const normalized = displayAlias.trim();
   if (normalized.length === 0) {
@@ -16110,6 +16146,7 @@ var init_consumer_lock = __esm(() => {
 // src/channels/weixin-channel.ts
 class WeixinChannel {
   id = "weixin";
+  nativeSessionListFormat = "cards";
   agent = null;
   quota = null;
   logger = null;
@@ -16917,6 +16954,7 @@ var init_command_list = __esm(() => {
     "/pm",
     "/session",
     "/ss",
+    "/ssn",
     "/workspace",
     "/ws",
     "/use",
@@ -16999,6 +17037,51 @@ function parseCommand(input) {
   if (command === "/session" && parts[1] === "rm" && parts[2] && parts.length === 3) {
     return { kind: "session.rm", alias: parts[2] };
   }
+  if (command === "/ssn") {
+    if (parts.length === 1) {
+      return { kind: "session.native.list" };
+    }
+    const identifier = parts[1] ?? "";
+    if (/^\d+$/.test(identifier)) {
+      const selected = readNativeAttachCommand(parts, 1);
+      if (!selected) {
+        return { kind: "invalid", text: trimmed, recognizedCommand: "/ssn" };
+      }
+      return selected.alias ? { kind: "session.native.select", identifier, alias: selected.alias } : { kind: "session.native.select", identifier };
+    }
+    if (parts[1] === "attach") {
+      if (!parts[2]) {
+        return { kind: "invalid", text: trimmed, recognizedCommand: "/ssn" };
+      }
+      const attached = readNativeAttachCommand(parts, 2);
+      if (attached) {
+        return attached;
+      }
+      return { kind: "invalid", text: trimmed, recognizedCommand: "/ssn" };
+    }
+    const nativeList = readNativeListCommand(parts, 1);
+    if (nativeList) {
+      return nativeList;
+    }
+    return { kind: "invalid", text: trimmed, recognizedCommand: "/ssn" };
+  }
+  if (command === "/session" && parts[1] === "native") {
+    const nativeList = readNativeListCommand(parts, 2);
+    if (nativeList) {
+      return nativeList;
+    }
+    return { kind: "invalid", text: trimmed, recognizedCommand: "/session" };
+  }
+  if (command === "/session" && parts[1] === "attach" && parts[2] === "native") {
+    if (!parts[3]) {
+      return { kind: "invalid", text: trimmed, recognizedCommand: "/session" };
+    }
+    const attached = readNativeAttachCommand(parts, 3);
+    if (attached) {
+      return attached;
+    }
+    return { kind: "invalid", text: trimmed, recognizedCommand: "/session" };
+  }
   if (command === "/group" && parts[1] === "new" && parts.length > 2) {
     const title = parts.slice(2).join(" ");
     if (title.trim().length > 0) {
@@ -17264,6 +17347,97 @@ function readSessionShortcutTarget(parts, startIndex) {
   }
   return null;
 }
+function readNativeListCommand(parts, startIndex) {
+  let agent = "";
+  let cwd = "";
+  let workspace = "";
+  let all = false;
+  let cursor = "";
+  let invalid = false;
+  if (startIndex < parts.length && !parts[startIndex]?.startsWith("-")) {
+    agent = parts[startIndex] ?? "";
+    startIndex += 1;
+  }
+  for (let index = startIndex;index < parts.length; index += 1) {
+    const part = parts[index];
+    if (part === "--all") {
+      all = true;
+      continue;
+    }
+    if (part === "--cursor") {
+      const value = parts[index + 1] ?? "";
+      if (index + 1 >= parts.length || value.startsWith("-")) {
+        invalid = true;
+        break;
+      }
+      cursor = value;
+      index += 1;
+      continue;
+    }
+    if (part === "--cwd" || part === "-d") {
+      const value = parts[index + 1] ?? "";
+      if (index + 1 >= parts.length || value.startsWith("-") || workspace) {
+        invalid = true;
+        break;
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (part === "--ws" || part === "-ws") {
+      const value = parts[index + 1] ?? "";
+      if (index + 1 >= parts.length || value.startsWith("-") || cwd) {
+        invalid = true;
+        break;
+      }
+      workspace = value;
+      index += 1;
+      continue;
+    }
+    invalid = true;
+    break;
+  }
+  if (invalid) {
+    return null;
+  }
+  const result = {
+    kind: "session.native.list"
+  };
+  if (agent.trim().length > 0)
+    result.agent = agent;
+  if (cwd.trim().length > 0)
+    result.cwd = cwd;
+  if (workspace.trim().length > 0)
+    result.workspace = workspace;
+  if (all)
+    result.all = true;
+  if (cursor.trim().length > 0)
+    result.cursor = cursor;
+  return Object.keys(result).length > 1 ? result : { kind: "session.native.list" };
+}
+function readNativeAttachCommand(parts, identifierIndex) {
+  const identifier = parts[identifierIndex] ?? "";
+  let alias = "";
+  for (let index = identifierIndex + 1;index < parts.length; index += 1) {
+    if (parts[index] === "-a" || parts[index] === "--alias") {
+      const value = parts[index + 1] ?? "";
+      if (index + 1 >= parts.length || value.startsWith("-")) {
+        return null;
+      }
+      alias = value;
+      index += 1;
+      continue;
+    }
+    return null;
+  }
+  if (identifier.trim().length === 0 || identifier.startsWith("-")) {
+    return null;
+  }
+  if (alias.trim().length > 0) {
+    return { kind: "session.native.attach", identifier, alias };
+  }
+  return { kind: "session.native.attach", identifier };
+}
 function normalizeCommand(command) {
   if (command === "/ss")
     return "/session";
@@ -17501,6 +17675,9 @@ var init_command_policy = __esm(() => {
     "session.shortcut": "/session",
     "session.shortcut.new": "/session",
     "session.attach": "/session attach",
+    "session.native.list": "/ssn",
+    "session.native.select": "/ssn",
+    "session.native.attach": "/ssn attach",
     "later.create": "/later",
     "later.list": "/later list",
     "later.cancel": "/later cancel"
@@ -18161,7 +18338,7 @@ async function handleSessions(context, chatKey) {
 }
 async function handleSessionNew(context, chatKey, alias, agent, workspace) {
   const channelId = getChannelIdFromChatKey(chatKey);
-  const internalAlias = channelId === "weixin" ? alias : toInternalSessionAlias(channelId, alias);
+  const internalAlias = scopeDisplayAliasToInternal(channelId, alias);
   const session = context.lifecycle.resolveSession(internalAlias, agent, workspace, `${workspace}:${internalAlias}`);
   const releaseTransportReservation = await context.lifecycle.reserveTransportSession(session.transportSession);
   try {
@@ -18192,7 +18369,7 @@ async function handleSessionShortcut(context, chatKey, agent, target, createNew)
 }
 async function handleSessionAttach(context, chatKey, alias, agent, workspace, transportSession) {
   const channelId = getChannelIdFromChatKey(chatKey);
-  const internalAlias = channelId === "weixin" ? alias : toInternalSessionAlias(channelId, alias);
+  const internalAlias = scopeDisplayAliasToInternal(channelId, alias);
   const attached = context.lifecycle.resolveSession(internalAlias, agent, workspace, transportSession);
   const releaseTransportReservation = await context.lifecycle.reserveTransportSession(attached.transportSession);
   try {
@@ -18559,7 +18736,7 @@ async function markCoordinatorResultsInjectionFailed(context, taskIds, groupIds,
     });
   }
 }
-var NO_CURRENT_SESSION_TEXT = "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。", DEFAULT_SESSION_TAIL_LINES = 50, MAX_SESSION_TAIL_LINES = 500, sessionHelp, modeHelp, replyModeHelp, statusHelp, cancelHelp;
+var NO_CURRENT_SESSION_TEXT = "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。", DEFAULT_SESSION_TAIL_LINES = 50, MAX_SESSION_TAIL_LINES = 500, sessionHelp, nativeSessionHelp, modeHelp, replyModeHelp, statusHelp, cancelHelp;
 var init_session_handler = __esm(() => {
   init_build_coordinator_prompt();
   init_channel_scope();
@@ -18567,7 +18744,7 @@ var init_session_handler = __esm(() => {
   sessionHelp = {
     topic: "session",
     aliases: ["ss", "sessions"],
-    summary: "创建、恢复、切换和重置逻辑会话。",
+    summary: "创建、复用、切换和重置 weacpx 逻辑会话。",
     commands: [
       { usage: "/sessions", description: "查看当前会话列表" },
       { usage: "/session 或 /ss", description: "查看会话列表" },
@@ -18575,12 +18752,48 @@ var init_session_handler = __esm(() => {
       { usage: "/ss new <agent> (-d <path> | --ws <name>)", description: "强制新建会话" },
       { usage: "/ss new <alias> -a <name> --ws <name>", description: "按指定配置新建会话" },
       { usage: "/ss attach <alias> -a <name> --ws <name> --name <transport-session>", description: "绑定已有会话" },
+      { usage: "/ssn 或 /help ssn", description: "接入本地 native 会话（Codex 等 Agent 原生会话）" },
       { usage: "/session tail [N]", description: "补拉当前会话的历史输出（默认 50 行）" },
       { usage: "/session rm <alias>", description: "删除逻辑会话" },
       { usage: "/use <alias>", description: "切换当前会话" },
       { usage: "/session reset 或 /clear", description: "重置当前会话上下文" }
     ],
-    examples: ["/ss codex -d /absolute/path/to/repo", "/use backend-fix", "/session rm old-session", "/session reset"]
+    examples: [
+      "/ss codex -d /absolute/path/to/repo",
+      "/ssn",
+      "/ssn 1",
+      "/use backend-fix",
+      "/session rm old-session",
+      "/session reset"
+    ]
+  };
+  nativeSessionHelp = {
+    topic: "native",
+    aliases: ["ssn", "native-session"],
+    summary: "接入 Codex 等 Agent 的本地原生会话。",
+    commands: [
+      { usage: "/ssn", description: "按当前 weacpx 会话上下文查看本地 native 会话" },
+      { usage: "/ssn <agent> --ws <workspace>", description: "查询指定工作区的本地 native 会话；只有一个候选时自动接入" },
+      { usage: "/ssn <agent> -d <path>", description: "按本机绝对路径查询；只有一个候选时自动接入" },
+      { usage: "/ssn <agent> --ws <workspace> --all", description: "跨 cwd 查看该 agent 的 native 会话" },
+      { usage: "/ssn 1", description: "接入或切换到最近一次列表里的第 1 个候选" },
+      { usage: "/ssn 1 -a <alias>", description: "接入第 1 个候选并指定 weacpx 别名（推荐，无需完整 sessionId）" },
+      { usage: "/ssn attach <sessionId> -a <alias>", description: "按原生 sessionId 接入（适合已知完整 id），并指定 weacpx 别名" },
+      { usage: "/ss attach native <sessionId> -a <alias>", description: "/ssn attach 的长写法" }
+    ],
+    examples: [
+      "/ssn codex --ws backend",
+      "/ssn codex -d /absolute/path/to/repo",
+      "/ssn",
+      "/ssn 1",
+      "/ssn 1 -a fix-ci"
+    ],
+    notes: [
+      "/ss 管 weacpx 逻辑会话；/ssn 只负责查询和接入 Agent 原生会话。",
+      "接入后继续发普通消息，会继续同一个 Agent 原生会话，不是复制一份新上下文。",
+      "如果当前 acpx 或 Agent 不支持 native 会话，请继续使用 /ss。",
+      "完整说明见 docs/native-sessions.md。"
+    ]
   };
   modeHelp = {
     topic: "mode",
@@ -19543,6 +19756,7 @@ var init_help_registry = __esm(() => {
   init_later_handler();
   HELP_TOPICS = [
     sessionHelp,
+    nativeSessionHelp,
     workspaceHelp,
     agentHelp,
     permissionHelp,
@@ -19579,6 +19793,7 @@ function renderHelpIndex() {
   return [
     "常用入口：",
     "- /ss <agent> (-d <path> | --ws <name>) - 快速新建或切到会话",
+    "- /ssn <agent> (-d <path> | --ws <name>) - 接入本地 Agent 原生会话",
     "- /use <alias> - 切换当前会话",
     "- /status - 查看当前会话状态",
     "",
@@ -19587,7 +19802,7 @@ function renderHelpIndex() {
     "",
     "查看专题说明：",
     "- /help <topic>",
-    "- 例如：/help ss、/help ws、/help pm"
+    "- 例如：/help ss、/help ssn、/help ws、/help pm"
   ].join(`
 `);
 }
@@ -19669,7 +19884,7 @@ async function handleSessionShortcutCommand(context, ops, chatKey, agent, target
   });
   const baseAlias = `${workspace.name}:${agent}`;
   const channelId = getChannelIdFromChatKey(chatKey);
-  const scopedBase = channelId === "weixin" ? baseAlias : `${channelId}:${baseAlias}`;
+  const scopedBase = scopeDisplayAliasToInternal(channelId, baseAlias);
   const alias = createNew ? await allocateUniqueSessionAlias(context, scopedBase, chatKey) : scopedBase;
   const display = toDisplaySessionAlias(alias);
   if (!createNew && await hasLogicalSession(context, alias, chatKey)) {
@@ -19798,6 +20013,404 @@ var init_session_shortcut_handler = __esm(() => {
   init_channel_scope();
 });
 
+// src/commands/handlers/native-session-handler.ts
+async function handleNativeSessionList(context, chatKey, input) {
+  const target = await resolveNativeTarget(context, chatKey, input);
+  if (isRouterResponse(target)) {
+    return target;
+  }
+  const listAgentSessions = context.transport.listAgentSessions?.bind(context.transport);
+  if (!listAgentSessions) {
+    return { text: `当前 transport 不支持列出本地会话，请继续使用 /ss。
+说明：/help ssn` };
+  }
+  const query = {
+    agent: target.agent,
+    agentCommand: target.agentCommand,
+    cwd: target.cwd,
+    ...input.cursor ? { cursor: input.cursor } : {},
+    ...input.all ? {} : { filterCwd: target.cwd }
+  };
+  let result;
+  try {
+    result = await listAgentSessions(query);
+  } catch (error2) {
+    return { text: renderNativeListError(target, error2) };
+  }
+  if (!result) {
+    return { text: `当前 transport 不支持列出本地会话，请继续使用 /ss。
+说明：/help ssn` };
+  }
+  await context.sessions.cacheNativeSessionList(chatKey, {
+    agent: target.agent,
+    workspace: target.workspace,
+    cwd: target.cwd,
+    sessions: result.sessions,
+    ...result.nextCursor !== undefined ? { nextCursor: result.nextCursor } : {}
+  });
+  if (result.sessions.length === 0) {
+    return {
+      text: [
+        `没有找到本地 ${target.agentDisplayName} 会话（${target.workspaceLabel}）。`,
+        `你可以稍后再试，或先通过 /ss 保持当前逻辑会话。`
+      ].join(`
+`)
+    };
+  }
+  const explicitAttachTarget = Boolean(input.workspace || input.cwd);
+  if (explicitAttachTarget && !input.all && !input.cursor && result.sessions.length === 1) {
+    return await attachNativeSession(context, chatKey, target, result.sessions[0], undefined);
+  }
+  const attachedEntries = await buildAttachedEntries(context, chatKey, target.agent, result.sessions);
+  const nativeSessionListOptions = { format: context.resolveNativeSessionListFormat?.(chatKey) ?? "table" };
+  return {
+    text: renderNativeSessionList(target, result, attachedEntries, Boolean(input.all), nativeSessionListOptions)
+  };
+}
+async function handleNativeSessionSelect(context, chatKey, identifier, alias) {
+  const trimmed = identifier.trim();
+  if (!trimmed) {
+    return { text: `请选择要切换的 native 会话编号或 sessionId。
+说明：/help ssn` };
+  }
+  if (/^[0-9]+$/.test(trimmed)) {
+    const cached2 = await context.sessions.getNativeSessionList(chatKey, NATIVE_SESSION_CACHE_TTL_MS);
+    if (!cached2 || cached2.sessions.length === 0) {
+      return { text: `当前没有可用的 native 会话列表，请先执行 /ssn 再选择。
+说明：/help ssn` };
+    }
+    const index = Number(trimmed) - 1;
+    const session = cached2.sessions[index];
+    if (!session) {
+      return { text: "编号超出范围，请先执行 /ssn 重新获取列表。" };
+    }
+    const target2 = await resolveTargetFromCachedSession(context, chatKey, cached2, session);
+    if (isRouterResponse(target2)) {
+      return target2;
+    }
+    return await attachNativeSession(context, chatKey, target2, session, alias);
+  }
+  const target = await resolveNativeTarget(context, chatKey, {});
+  if (isRouterResponse(target)) {
+    return target;
+  }
+  return await attachNativeSession(context, chatKey, target, { sessionId: trimmed }, alias);
+}
+async function attachNativeSession(context, chatKey, target, session, alias) {
+  if (!context.transport.resumeAgentSession) {
+    return { text: "当前 transport 不支持接入本地会话，请继续使用 /ss。" };
+  }
+  const nativeTarget = target;
+  const existing = await context.sessions.findAttachedNativeSession(chatKey, nativeTarget.agent, session.sessionId);
+  if (existing) {
+    await context.sessions.useSession(chatKey, existing.alias);
+    const displayAlias2 = toDisplaySessionAlias(existing.alias);
+    return {
+      text: `已切换到已接入的本地会话：${nativeTarget.agentDisplayName} · ${displayAlias2}`
+    };
+  }
+  const requestedAlias = alias?.trim() || buildDefaultNativeAlias(nativeTarget.agent, session.sessionId);
+  const displayAlias = await allocateUniqueNativeAlias(context, chatKey, requestedAlias);
+  const internalAlias = scopeDisplayAliasToInternal(getChannelIdFromChatKey(chatKey), displayAlias);
+  const transportSession = context.sessions.buildDefaultTransportSessionForChat(chatKey, displayAlias);
+  const resolvedSession = context.lifecycle.resolveSession(internalAlias, nativeTarget.agent, nativeTarget.workspace, transportSession);
+  const releaseReservation = await context.lifecycle.reserveTransportSession(resolvedSession.transportSession);
+  try {
+    try {
+      await context.transport.resumeAgentSession(resolvedSession, session.sessionId);
+    } catch (error2) {
+      return { text: renderNativeResumeError(target, error2) };
+    }
+    const verified = await context.lifecycle.checkTransportSession(resolvedSession);
+    if (!verified) {
+      return { text: `本地 ${target.agentDisplayName} 会话接入失败：未检测到已恢复的后端会话。` };
+    }
+    await context.sessions.attachNativeSession({
+      alias: internalAlias,
+      agent: nativeTarget.agent,
+      workspace: nativeTarget.workspace,
+      transportSession,
+      ...target.agentCommand ? { transportAgentCommand: target.agentCommand } : {},
+      agentSessionId: session.sessionId,
+      title: session.title,
+      updatedAt: session.updatedAt
+    });
+    await context.sessions.useSession(chatKey, internalAlias);
+    await refreshAgentCommandBestEffort(context, internalAlias);
+    return {
+      text: `已接入本地 ${target.agentDisplayName} 会话并切换：${toDisplaySessionAlias(internalAlias)}`
+    };
+  } finally {
+    await releaseReservation();
+  }
+}
+async function resolveNativeTarget(context, chatKey, input) {
+  const currentSession = await context.sessions.getCurrentSession(chatKey);
+  const agent = input.agent?.trim() || currentSession?.agent || "";
+  if (!agent) {
+    return {
+      text: `请先选择上下文，例如：
+/ssn codex --ws project
+/ssn codex -d /Users/me/project
+说明：/help ssn`
+    };
+  }
+  const agentConfig = context.config?.agents[agent];
+  if (!agentConfig) {
+    return { text: `Agent「${agent}」未注册。` };
+  }
+  const workspaceResolution = await resolveNativeWorkspace(context, input, currentSession);
+  if (isRouterResponse(workspaceResolution)) {
+    return workspaceResolution;
+  }
+  return {
+    agent,
+    agentDisplayName: displayAgentName(agent),
+    agentCommand: resolveAgentCommand(agentConfig.driver, agentConfig.command),
+    workspace: workspaceResolution.workspace,
+    workspaceLabel: workspaceResolution.workspaceLabel,
+    cwd: workspaceResolution.cwd,
+    source: workspaceResolution.source
+  };
+}
+async function resolveTargetFromCachedSession(context, chatKey, cached2, session) {
+  if (session.cwd && !sameWorkspacePath(session.cwd, cached2.cwd)) {
+    return await resolveNativeTarget(context, chatKey, {
+      agent: cached2.agent,
+      cwd: session.cwd
+    });
+  }
+  return await resolveNativeTarget(context, chatKey, {
+    agent: cached2.agent,
+    ...cached2.workspace ? { workspace: cached2.workspace } : { cwd: cached2.cwd }
+  });
+}
+async function resolveNativeWorkspace(context, input, currentSession) {
+  if (input.workspace) {
+    const workspaceConfig = context.config?.workspaces[input.workspace];
+    if (!workspaceConfig) {
+      return { text: `工作区「${input.workspace}」未注册。` };
+    }
+    return {
+      workspace: input.workspace,
+      workspaceLabel: input.workspace,
+      cwd: workspaceConfig.cwd,
+      source: "workspace"
+    };
+  }
+  if (input.cwd) {
+    const cwd = normalizeWorkspacePath(input.cwd);
+    const existing = Object.entries(context.config?.workspaces ?? {}).find(([, workspace]) => sameWorkspacePath(workspace.cwd, cwd));
+    if (existing) {
+      return {
+        workspace: existing[0],
+        workspaceLabel: existing[0],
+        cwd: existing[1].cwd,
+        source: "cwd"
+      };
+    }
+    if (!await pathExists(cwd)) {
+      return { text: `工作区路径不存在：${input.cwd}` };
+    }
+    if (!context.configStore || !context.config) {
+      return { text: "当前没有加载可写入的配置，无法根据路径创建工作区。" };
+    }
+    const workspaceName = allocateWorkspaceName(sanitizeWorkspaceName(basenameForWorkspacePath(cwd)), context.config.workspaces);
+    const updated = await context.configStore.upsertWorkspace(workspaceName, cwd);
+    context.replaceConfig(updated);
+    return {
+      workspace: workspaceName,
+      workspaceLabel: workspaceName,
+      cwd,
+      source: "cwd"
+    };
+  }
+  if (currentSession) {
+    return {
+      workspace: currentSession.workspace,
+      workspaceLabel: currentSession.workspace,
+      cwd: currentSession.cwd,
+      source: "workspace"
+    };
+  }
+  return {
+    text: `请先选择上下文，例如：
+/ssn codex --ws project
+/ssn codex -d /Users/me/project
+说明：/help ssn`
+  };
+}
+async function buildAttachedEntries(context, chatKey, agent, sessions) {
+  const currentSession = await context.sessions.getCurrentSession(chatKey);
+  return await Promise.all(sessions.map(async (session) => {
+    const attached = await context.sessions.findAttachedNativeSession(chatKey, agent, session.sessionId);
+    if (!attached) {
+      return { session };
+    }
+    return {
+      session,
+      attached: {
+        alias: attached.alias,
+        displayAlias: toDisplaySessionAlias(attached.alias),
+        isCurrent: currentSession?.alias === attached.alias
+      }
+    };
+  }));
+}
+function renderNativeSessionList(target, result, entries, includeAll, options = {}) {
+  if (options.format === "cards") {
+    return renderNativeSessionCardList(target, result, entries, includeAll);
+  }
+  return renderNativeSessionTableList(target, result, entries, includeAll);
+}
+function renderNativeSessionTableList(target, result, entries, includeAll) {
+  const lines = [`本地 ${target.agentDisplayName} 会话（${target.workspaceLabel}）：`];
+  lines.push("| # | 标题 | 更新时间 | ID |");
+  lines.push("|---|---|---|---|");
+  entries.forEach((entry, index) => {
+    const title = escapeMarkdownTableCell(renderNativeSessionTitle(entry.session.title, entry.session.sessionId));
+    const updatedAt = entry.session.updatedAt ? formatNativeSessionTime(entry.session.updatedAt) : "-";
+    const idParts = [entry.session.sessionId];
+    if (entry.attached) {
+      idParts.push(`已接入：${entry.attached.displayAlias}${entry.attached.isCurrent ? " [当前]" : ""}`);
+    }
+    lines.push(`| ${index + 1} | ${title} | ${escapeMarkdownTableCell(updatedAt)} | ${escapeMarkdownTableCell(idParts.join(" · "))} |`);
+  });
+  lines.push("");
+  lines.push("操作：");
+  lines.push("接入：/ssn 1");
+  lines.push("指定别名：/ssn 1 -a fix-ci");
+  lines.push("说明：/help ssn");
+  if (result.nextCursor) {
+    lines.push(`更多：${renderNextPageCommand(target, result.nextCursor, includeAll)}`);
+  }
+  return lines.join(`
+`);
+}
+function renderNativeSessionCardList(target, result, entries, includeAll) {
+  const lines = [
+    `本地 ${target.agentDisplayName} 会话（${target.workspaceLabel}）：`,
+    "回复编号接入，ID 尾号用于区分。"
+  ];
+  entries.forEach((entry, index) => {
+    const title = renderNativeSessionTitle(entry.session.title, entry.session.sessionId);
+    const updatedAt = entry.session.updatedAt ? formatNativeSessionTime(entry.session.updatedAt) : "-";
+    lines.push("");
+    lines.push(`【${index + 1}】 ${title}`);
+    lines.push(`时间：${updatedAt}`);
+    lines.push(`ID：${formatSessionIdTail(entry.session.sessionId)}`);
+    if (entry.attached) {
+      lines.push(`已接入：${entry.attached.displayAlias}${entry.attached.isCurrent ? " [当前]" : ""}`);
+    }
+  });
+  lines.push("");
+  lines.push("操作：");
+  lines.push("接入：/ssn 1");
+  lines.push("指定别名：/ssn 1 -a fix-ci");
+  lines.push("说明：/help ssn");
+  if (result.nextCursor) {
+    lines.push(`更多：${renderNextPageCommand(target, result.nextCursor, includeAll)}`);
+  }
+  return lines.join(`
+`);
+}
+function renderNativeSessionTitle(title, fallback) {
+  const normalized = (title?.trim() || fallback).replace(/\s+/g, " ");
+  const maxLength = 60;
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
+}
+function buildDefaultNativeAlias(agent, sessionId) {
+  return `${agent}-${sessionIdTail(sessionId)}`;
+}
+function formatSessionIdTail(sessionId) {
+  const tail = sessionIdTail(sessionId);
+  return tail.length < sessionId.trim().length ? `…${tail}` : tail;
+}
+function sessionIdTail(sessionId) {
+  const trimmed = sessionId.trim();
+  if (trimmed.length <= 8) {
+    return trimmed;
+  }
+  return trimmed.slice(-8);
+}
+function formatNativeSessionTime(value) {
+  const date4 = new Date(value);
+  if (Number.isNaN(date4.getTime())) {
+    return value;
+  }
+  const pad = (input) => String(input).padStart(2, "0");
+  return `${date4.getFullYear()}-${pad(date4.getMonth() + 1)}-${pad(date4.getDate())} ${pad(date4.getHours())}:${pad(date4.getMinutes())}`;
+}
+function escapeMarkdownTableCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function renderNextPageCommand(target, nextCursor, includeAll) {
+  const scope = target.source === "workspace" && target.workspace ? `--ws ${target.workspace}` : `-d ${target.cwd}`;
+  const allFlag = includeAll ? " --all" : "";
+  return `/ssn ${target.agent} ${scope}${allFlag} --cursor ${nextCursor}`;
+}
+async function allocateUniqueNativeAlias(context, chatKey, baseDisplayAlias) {
+  const channelId = getChannelIdFromChatKey(chatKey);
+  const visible = await context.sessions.listSessions(chatKey);
+  const existing = new Set(visible.map((session) => session.internalAlias));
+  const base = baseDisplayAlias.trim() || "native-session";
+  const transportFor = (candidate) => context.sessions.buildDefaultTransportSessionForChat(chatKey, candidate);
+  const isFree = (candidate) => !existing.has(scopeDisplayAliasToInternal(channelId, candidate)) && context.sessions.countAliasesSharingTransport(transportFor(candidate)) === 0;
+  if (isFree(base)) {
+    return base;
+  }
+  let suffix = 2;
+  while (!isFree(`${base}-${suffix}`)) {
+    suffix += 1;
+  }
+  return `${base}-${suffix}`;
+}
+async function refreshAgentCommandBestEffort(context, alias) {
+  try {
+    await context.lifecycle.refreshSessionTransportAgentCommand(alias);
+  } catch (error2) {
+    await context.logger.error("session.native.agent_command_refresh_failed", "failed to refresh native session agent command", {
+      alias,
+      error: error2 instanceof Error ? error2.message : String(error2)
+    });
+  }
+}
+function renderNativeListError(target, error2) {
+  return [
+    `本地 ${target.agentDisplayName} 会话查询失败：${formatErrorMessage(error2)}`,
+    "请确认 acpx/Agent 支持 native 会话查询，或继续使用 /ss。",
+    "说明：/help ssn"
+  ].join(`
+`);
+}
+function renderNativeResumeError(target, error2) {
+  return [
+    `本地 ${target.agentDisplayName} 会话接入失败：${formatErrorMessage(error2)}`,
+    "请确认 acpx/Agent 支持 native 会话恢复，或继续使用 /ss。",
+    "说明：/help ssn"
+  ].join(`
+`);
+}
+function formatErrorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function isRouterResponse(value) {
+  return typeof value.text === "string";
+}
+function displayAgentName(agent) {
+  if (!agent) {
+    return agent;
+  }
+  return agent.charAt(0).toUpperCase() + agent.slice(1);
+}
+var NATIVE_SESSION_CACHE_TTL_MS;
+var init_native_session_handler = __esm(() => {
+  init_channel_scope();
+  init_workspace_name();
+  init_workspace_path();
+  NATIVE_SESSION_CACHE_TTL_MS = 10 * 60 * 1000;
+});
+
 // src/commands/handlers/session-recovery-handler.ts
 function renderTransportError(session, error2) {
   const message = error2 instanceof Error ? error2.message : String(error2);
@@ -20265,6 +20878,7 @@ class CommandRouter {
   quota;
   scheduled;
   scheduledDelivery;
+  resolveNativeSessionListFormat;
   logger;
   autoInstall = autoInstallOptionalDep;
   discoverPaths = discoverParentPackagePaths;
@@ -20274,7 +20888,7 @@ class CommandRouter {
   __setDiscoverPathsForTest(fn) {
     this.discoverPaths = fn;
   }
-  constructor(sessions, transport, config2, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex, orchestration, quota, scheduled, scheduledDelivery) {
+  constructor(sessions, transport, config2, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex, orchestration, quota, scheduled, scheduledDelivery, resolveNativeSessionListFormat) {
     this.sessions = sessions;
     this.transport = transport;
     this.config = config2;
@@ -20284,6 +20898,7 @@ class CommandRouter {
     this.quota = quota;
     this.scheduled = scheduled;
     this.scheduledDelivery = scheduledDelivery;
+    this.resolveNativeSessionListFormat = resolveNativeSessionListFormat;
     this.logger = logger2 ?? createNoopAppLogger();
   }
   async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan) {
@@ -20358,6 +20973,12 @@ class CommandRouter {
           return await handleSessionShortcut(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.agent, command, true);
         case "session.attach":
           return await handleSessionAttach(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.alias, command.agent, command.workspace, command.transportSession);
+        case "session.native.list":
+          return await handleNativeSessionList(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command);
+        case "session.native.select":
+          return await handleNativeSessionSelect(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.identifier, command.alias);
+        case "session.native.attach":
+          return await handleNativeSessionSelect(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.identifier, command.alias);
         case "session.use":
           return await handleSessionUse(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.alias);
         case "mode.show":
@@ -20459,7 +21080,8 @@ class CommandRouter {
       configStore: this.configStore,
       logger: this.logger,
       replaceConfig: (updated) => this.replaceConfig(updated),
-      ...this.quota ? { quota: this.quota } : {}
+      ...this.quota ? { quota: this.quota } : {},
+      ...this.resolveNativeSessionListFormat ? { resolveNativeSessionListFormat: this.resolveNativeSessionListFormat } : {}
     };
   }
   createSessionHandlerContext(reply, perfSpan) {
@@ -20821,6 +21443,7 @@ var init_command_router = __esm(() => {
   init_agent_handler();
   init_workspace_handler();
   init_session_shortcut_handler();
+  init_native_session_handler();
   init_later_handler();
   init_session_recovery_handler();
   init_auto_install_optional_dep();
@@ -25144,11 +25767,13 @@ class SessionService {
   stateStore;
   state;
   stateMutex;
+  now;
   constructor(config2, stateStore, state, options = {}) {
     this.config = config2;
     this.stateStore = stateStore;
     this.state = state;
     this.stateMutex = options.stateMutex ?? new AsyncMutex;
+    this.now = options.now ?? (() => Date.now());
   }
   async createSession(alias, agent, workspace) {
     return await this.createLogicalSession(alias, agent, workspace, `${workspace}:${alias}`);
@@ -25182,6 +25807,14 @@ class SessionService {
   async attachSession(alias, agent, workspace, transportSession, transportAgentCommand) {
     return await this.createLogicalSession(alias, agent, workspace, transportSession, transportAgentCommand);
   }
+  async attachNativeSession(input) {
+    return await this.createLogicalSession(input.alias, input.agent, input.workspace, input.transportSession, input.transportAgentCommand, {
+      source: "agent-side",
+      agentSessionId: input.agentSessionId,
+      title: input.title,
+      updatedAt: input.updatedAt
+    });
+  }
   async getSession(alias) {
     const session = this.state.sessions[alias];
     if (!session) {
@@ -25196,6 +25829,22 @@ class SessionService {
     const preferred = matches.find((session) => session.alias === expectedAlias && session.workspace === expectedWorkspace) ?? matches[0];
     return preferred ? this.toResolvedSession(preferred) : null;
   }
+  async findAttachedNativeSession(chatKey, agent, agentSessionId) {
+    const channelId = getChannelIdFromChatKey(chatKey);
+    for (const session of Object.values(this.state.sessions)) {
+      if (session.source !== "agent-side") {
+        continue;
+      }
+      if (session.agent !== agent || session.agent_session_id !== agentSessionId) {
+        continue;
+      }
+      if (!isSessionAliasVisibleInChannel(session.alias, channelId)) {
+        continue;
+      }
+      return this.toResolvedSession(session);
+    }
+    return null;
+  }
   async useSession(chatKey, alias) {
     await this.mutate(async () => {
       const channelId = getChannelIdFromChatKey(chatKey);
@@ -25315,6 +25964,49 @@ class SessionService {
       return { wasActive };
     });
   }
+  async cacheNativeSessionList(chatKey, input) {
+    await this.mutate(async () => {
+      this.state.native_session_lists[chatKey] = {
+        created_at: new Date(this.now()).toISOString(),
+        agent: input.agent,
+        ...input.workspace !== undefined ? { workspace: input.workspace } : {},
+        cwd: input.cwd,
+        sessions: input.sessions.map((session) => ({
+          session_id: session.sessionId,
+          ...session.cwd !== undefined ? { cwd: session.cwd } : {},
+          ...session.title !== undefined ? { title: session.title } : {},
+          ...session.updatedAt !== undefined ? { updated_at: session.updatedAt } : {}
+        })),
+        ...input.nextCursor !== undefined ? { next_cursor: input.nextCursor } : {}
+      };
+      await this.persist();
+    });
+  }
+  async getNativeSessionList(chatKey, ttlMs = 10 * 60 * 1000) {
+    const cached2 = this.state.native_session_lists[chatKey];
+    if (!cached2) {
+      return null;
+    }
+    const createdAt = Date.parse(cached2.created_at);
+    if (Number.isNaN(createdAt)) {
+      return null;
+    }
+    if (this.now() - createdAt > ttlMs) {
+      return null;
+    }
+    return {
+      agent: cached2.agent,
+      ...cached2.workspace !== undefined ? { workspace: cached2.workspace } : {},
+      cwd: cached2.cwd,
+      sessions: cached2.sessions.map((session) => ({
+        sessionId: session.session_id,
+        ...session.cwd !== undefined ? { cwd: session.cwd } : {},
+        ...session.title !== undefined ? { title: session.title } : {},
+        ...session.updated_at !== undefined ? { updatedAt: session.updated_at } : {}
+      })),
+      ...cached2.next_cursor !== undefined ? { nextCursor: cached2.next_cursor } : {}
+    };
+  }
   toResolvedSession(session) {
     const agentConfig = this.config.agents[session.agent];
     if (!agentConfig) {
@@ -25330,6 +26022,11 @@ class SessionService {
       agentCommand: session.transport_agent_command ?? resolveAgentCommand(agentConfig.driver, agentConfig.command),
       workspace: session.workspace,
       transportSession: session.transport_session,
+      source: session.source,
+      agentSessionId: session.agent_session_id,
+      agentSessionTitle: session.agent_session_title,
+      agentSessionUpdatedAt: session.agent_session_updated_at,
+      attachedAt: session.attached_at,
       modeId: session.mode_id,
       replyMode: session.reply_mode,
       cwd: workspaceConfig.cwd
@@ -25357,20 +26054,25 @@ class SessionService {
   async persist() {
     await this.stateStore.save(this.state);
   }
-  async createLogicalSession(alias, agent, workspace, transportSession, transportAgentCommand) {
+  async createLogicalSession(alias, agent, workspace, transportSession, transportAgentCommand, native) {
     return await this.mutate(async () => {
       this.validateSession(alias, agent, workspace);
       if (this.state.orchestration.externalCoordinators[transportSession]) {
         throw new Error(`transport session "${transportSession}" conflicts with an external coordinator`);
       }
       const existingSession = this.state.sessions[alias];
-      const now = new Date().toISOString();
+      const now = new Date(this.now()).toISOString();
       const normalizedTransportAgentCommand = transportAgentCommand?.trim();
       const session = {
         alias,
         agent,
         workspace,
         transport_session: transportSession,
+        source: native?.source,
+        agent_session_id: native?.agentSessionId,
+        agent_session_title: native?.title ?? undefined,
+        agent_session_updated_at: native?.updatedAt,
+        attached_at: native ? now : undefined,
         ...normalizedTransportAgentCommand ? { transport_agent_command: normalizedTransportAgentCommand } : existingSession?.transport_agent_command ? { transport_agent_command: existingSession.transport_agent_command } : {},
         mode_id: existingSession?.mode_id,
         reply_mode: existingSession?.reply_mode,
@@ -26167,6 +26869,18 @@ class AcpxBridgeTransport {
       lines
     });
   }
+  async listAgentSessions(query) {
+    return await this.client.request("listAgentSessions", { ...query });
+  }
+  async resumeAgentSession(session, agentSessionId) {
+    await this.client.request("resumeAgentSession", {
+      agent: session.agent,
+      ...session.agentCommand ? { agentCommand: session.agentCommand } : {},
+      cwd: session.cwd,
+      name: session.transportSession,
+      agentSessionId
+    });
+  }
   async prompt(session, text, reply, replyContext, options) {
     const sink = reply ? createQuotaGatedReplySink({
       reply,
@@ -26962,6 +27676,76 @@ function permissionModeToFlag(permissionMode) {
   }
 }
 
+// src/transport/agent-session-list.ts
+import path15 from "node:path";
+function isUnknownFilterCwdOption(output) {
+  return /(?:unknown|unrecognized) option/i.test(output) && output.includes("--filter-cwd");
+}
+async function runAgentSessionList(options) {
+  let result = await options.runList(true);
+  let filterLocally = false;
+  if (result.code !== 0 && options.filterCwd && isUnknownFilterCwdOption(result.stdout + result.stderr)) {
+    result = await options.runList(false);
+    filterLocally = true;
+  }
+  if (result.code !== 0) {
+    if ((result.stdout + result.stderr).includes("sessionCapabilities.list")) {
+      return;
+    }
+    throw new Error(options.formatError(result));
+  }
+  return parseAgentSessionListOutput(result.stdout, filterLocally ? options.filterCwd : undefined);
+}
+function parseAgentSessionListOutput(stdout2, filterCwd) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout2);
+  } catch {
+    throw new Error("failed to parse acpx sessions list output");
+  }
+  if (!isAgentSessionListResult(parsed)) {
+    return;
+  }
+  return filterCwd ? filterAgentSessionListByCwd(parsed, filterCwd) : parsed;
+}
+function isAgentSessionListResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const record3 = value;
+  if (record3.source !== "agent" || !Array.isArray(record3.sessions))
+    return false;
+  return record3.sessions.every((session) => {
+    if (!session || typeof session !== "object" || Array.isArray(session))
+      return false;
+    const item = session;
+    return typeof item.sessionId === "string";
+  });
+}
+function filterAgentSessionListByCwd(result, cwd) {
+  return {
+    ...result,
+    sessions: result.sessions.filter((session) => session.cwd && sameAgentSessionCwd(session.cwd, cwd))
+  };
+}
+function sameAgentSessionCwd(left, right) {
+  const normalizedLeft = normalizeAgentSessionCwd(left);
+  const normalizedRight = normalizeAgentSessionCwd(right);
+  if (isWindowsLikePath2(normalizedLeft) || isWindowsLikePath2(normalizedRight)) {
+    return normalizedLeft.toLowerCase() === normalizedRight.toLowerCase();
+  }
+  return normalizedLeft === normalizedRight;
+}
+function normalizeAgentSessionCwd(input) {
+  if (isWindowsLikePath2(input)) {
+    return path15.win32.normalize(input).replace(/\\/g, "/");
+  }
+  return path15.posix.normalize(input.replace(/\\/g, "/"));
+}
+function isWindowsLikePath2(input) {
+  return /^[a-zA-Z]:[\\/]/.test(input) || input.startsWith("\\\\");
+}
+var init_agent_session_list = () => {};
+
 // src/transport/acpx-cli/acpx-cli-transport.ts
 import { createRequire as createRequire5 } from "node:module";
 import { spawn as spawn9 } from "node:child_process";
@@ -27071,6 +27855,23 @@ class AcpxCliTransport {
       timeoutMs: this.sessionInitTimeoutMs
     });
   }
+  async listAgentSessions(query) {
+    return await runAgentSessionList({
+      filterCwd: query.filterCwd,
+      runList: async (includeFilterCwd) => {
+        const args = this.buildAgentQueryArgs(query, "json", [
+          "sessions",
+          "list",
+          ...includeFilterCwd && query.filterCwd ? ["--filter-cwd", query.filterCwd] : [],
+          ...query.cursor ? ["--cursor", query.cursor] : []
+        ]);
+        return await this.runCommandWithTimeout(this.runCommand, args, {
+          timeoutMs: this.sessionInitTimeoutMs
+        });
+      },
+      formatError: (result) => normalizeCommandError(result) ?? `command failed with exit code ${result.code}`
+    });
+  }
   async tailSessionHistory(session, lines) {
     const candidates = [
       ["sessions", "history", "quiet", "-s", session.transportSession, String(lines)],
@@ -27139,6 +27940,20 @@ ${baseText}` : "" };
       message: output.trim()
     };
   }
+  async resumeAgentSession(session, agentSessionId) {
+    const args = this.buildArgs(session, [
+      "sessions",
+      "new",
+      "--name",
+      session.transportSession,
+      "--resume-session",
+      agentSessionId
+    ]);
+    const runResume = session.agentCommand ? this.run : this.runWithPty;
+    await runResume.call(this, args, {
+      timeoutMs: this.sessionInitTimeoutMs
+    });
+  }
   async updatePermissionPolicy(policy) {
     this.permissionMode = policy.permissionMode;
     this.nonInteractivePermissions = policy.nonInteractivePermissions;
@@ -27372,6 +28187,13 @@ ${baseText}` : "" };
     }
     return [...prefix, session.agent, ...tail2];
   }
+  buildAgentQueryArgs(query, format, tail2) {
+    const prefix = ["--format", format, "--cwd", query.cwd, ...this.buildPermissionArgs()];
+    if (query.agentCommand) {
+      return [...prefix, "--agent", query.agentCommand, ...tail2];
+    }
+    return [...prefix, query.agent, ...tail2];
+  }
   buildPromptArgs(session, text, promptFile) {
     const prefix = [
       "--format",
@@ -27437,6 +28259,7 @@ var init_acpx_cli_transport = __esm(() => {
   init_node_pty_helper();
   init_terminate_process_tree();
   init_acpx_queue_owner_launcher();
+  init_agent_session_list();
   require4 = createRequire5(import.meta.url);
 });
 
@@ -27650,6 +28473,9 @@ class MessageChannelRegistry {
     }
     await channel.sendScheduledMessage(input);
   }
+  nativeSessionListFormat(chatKey) {
+    return this.getByChatKey(chatKey)?.nativeSessionListFormat ?? "table";
+  }
   createConsumerLocks() {
     const result = [];
     for (const channel of this.channels.values()) {
@@ -28234,7 +29060,7 @@ async function buildApp(paths, deps = {}) {
     listScheduledTasksFromRoute: async (input) => await listScheduledTasksFromRoute(input, { state, scheduled: scheduledService }),
     cancelScheduledTaskFromRoute: async (input) => await cancelScheduledTaskFromRoute(input, { state, scheduled: scheduledService })
   });
-  const router = new CommandRouter(sessions, transport, config2, configStore, logger2, undefined, orchestration, quota, scheduledService, deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : undefined);
+  const router = new CommandRouter(sessions, transport, config2, configStore, logger2, undefined, orchestration, quota, scheduledService, deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : undefined, deps.channel?.nativeSessionListFormat ? deps.channel.nativeSessionListFormat.bind(deps.channel) : undefined);
   const agent = new ConsoleAgent(router, logger2);
   const scheduledScheduler = new ScheduledTaskScheduler(scheduledService, {
     dispatchTask: buildScheduledDispatchTask({
@@ -28825,107 +29651,107 @@ async function checkRuntime(options = {}) {
 }
 function createRuntimeFsProbe() {
   return {
-    stat: async (path15) => await stat3(path15),
-    access: async (path15, mode) => await access4(path15, mode)
+    stat: async (path16) => await stat3(path16),
+    access: async (path16, mode) => await access4(path16, mode)
   };
 }
-async function checkDirectoryCreatable(label, path15, probe, platform) {
+async function checkDirectoryCreatable(label, path16, probe, platform) {
   try {
-    const stats = await probe.stat(path15);
+    const stats = await probe.stat(path16);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (exists but is not a directory)`
+        detail: `${label}: ${path16} (exists but is not a directory)`
       };
     }
-    await probe.access(path15, directoryAccessMode(platform));
+    await probe.access(path16, directoryAccessMode(platform));
     return {
       ok: true,
-      detail: `${label}: ${path15} (writable)`
+      detail: `${label}: ${path16} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path16} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(path15, probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(path16, probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path16} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path15} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path16} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkFileCreatable(label, path15, probe, platform) {
+async function checkFileCreatable(label, path16, probe, platform) {
   try {
-    const stats = await probe.stat(path15);
+    const stats = await probe.stat(path16);
     if (stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (exists but is a directory)`
+        detail: `${label}: ${path16} (exists but is a directory)`
       };
     }
-    await probe.access(path15, constants.W_OK);
+    await probe.access(path16, constants.W_OK);
     return {
       ok: true,
-      detail: `${label}: ${path15} (writable)`
+      detail: `${label}: ${path16} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path16} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname14(path15), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname14(path16), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path16} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path15} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path16} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkCreatableAncestorDirectory(path15, probe, platform) {
+async function checkCreatableAncestorDirectory(path16, probe, platform) {
   try {
-    const stats = await probe.stat(path15);
+    const stats = await probe.stat(path16);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        creatableFrom: path15,
-        blockingPath: path15
+        creatableFrom: path16,
+        blockingPath: path16
       };
     }
-    await probe.access(path15, directoryAccessMode(platform));
+    await probe.access(path16, directoryAccessMode(platform));
     return {
       ok: true,
-      creatableFrom: path15
+      creatableFrom: path16
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        creatableFrom: path15,
-        blockingPath: path15
+        creatableFrom: path16,
+        blockingPath: path16
       };
     }
-    const parent = dirname14(path15);
-    if (parent === path15) {
+    const parent = dirname14(path16);
+    if (parent === path16) {
       return {
         ok: false,
-        creatableFrom: path15,
-        blockingPath: path15
+        creatableFrom: path16,
+        blockingPath: path16
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(parent, probe, platform);