weacpx 0.5.1 → 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) {
@@ -14953,6 +14989,12 @@ async function handleWeixinMessageTurn(full, deps) {
       text: requestText,
       ...media.length > 0 ? { media } : {},
       replyContextToken: contextToken,
+      metadata: {
+        channel: "weixin",
+        chatType: full.group_id ? "group" : "direct",
+        ...full.from_user_id ? { senderId: full.from_user_id } : {},
+        ...full.group_id ? { groupId: full.group_id } : {}
+      },
       perfSpan
     };
     try {
@@ -16104,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;
@@ -16911,6 +16954,7 @@ var init_command_list = __esm(() => {
     "/pm",
     "/session",
     "/ss",
+    "/ssn",
     "/workspace",
     "/ws",
     "/use",
@@ -16993,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) {
@@ -17258,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";
@@ -17495,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"
@@ -18155,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 {
@@ -18186,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 {
@@ -18553,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();
@@ -18561,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: "查看会话列表" },
@@ -18569,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",
@@ -19537,6 +19756,7 @@ var init_help_registry = __esm(() => {
   init_later_handler();
   HELP_TOPICS = [
     sessionHelp,
+    nativeSessionHelp,
     workspaceHelp,
     agentHelp,
     permissionHelp,
@@ -19573,6 +19793,7 @@ function renderHelpIndex() {
   return [
     "常用入口：",
     "- /ss <agent> (-d <path> | --ws <name>) - 快速新建或切到会话",
+    "- /ssn <agent> (-d <path> | --ws <name>) - 接入本地 Agent 原生会话",
     "- /use <alias> - 切换当前会话",
     "- /status - 查看当前会话状态",
     "",
@@ -19581,7 +19802,7 @@ function renderHelpIndex() {
     "",
     "查看专题说明：",
     "- /help <topic>",
-    "- 例如：/help ss、/help ws、/help pm"
+    "- 例如：/help ss、/help ssn、/help ws、/help pm"
   ].join(`
 `);
 }
@@ -19663,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)) {
@@ -19792,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);
@@ -20259,6 +20878,7 @@ class CommandRouter {
   quota;
   scheduled;
   scheduledDelivery;
+  resolveNativeSessionListFormat;
   logger;
   autoInstall = autoInstallOptionalDep;
   discoverPaths = discoverParentPackagePaths;
@@ -20268,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;
@@ -20278,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) {
@@ -20352,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":
@@ -20453,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) {
@@ -20815,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();
@@ -25138,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}`);
@@ -25176,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) {
@@ -25190,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);
@@ -25309,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) {
@@ -25324,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
@@ -25351,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,
@@ -26161,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,
@@ -26759,7 +27479,7 @@ import { join as join13 } from "node:path";
 function buildWeacpxMcpServerSpec(input) {
   const { command, args } = splitCommandLine(input.weacpxCommand);
   return {
-    name: "weacpx-orchestration",
+    name: "weacpx",
     type: "stdio",
     command,
     args: [
@@ -26956,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";
@@ -27065,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)],
@@ -27133,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;
@@ -27366,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",
@@ -27431,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);
 });
 
@@ -27644,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()) {
@@ -28228,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({
@@ -28819,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);
@@ -42176,11 +43008,11 @@ function buildWeacpxMcpToolRegistry(input) {
   if (internalSessionTools && !isExternalCoordinator && !sourceHandle) {
     tools.push({
       name: "scheduled_create",
-      description: "Create a one-shot scheduled task for the current conversation session using the recorded chat route. Provide only the time expression and message; routing/session/account details are resolved by weacpx.",
+      description: "Schedule a one-shot task to run a natural-language message at a future time, using the recorded chat route. By default — and like /later — the task runs in a FRESH TEMPORARY session (it snapshots the current agent and workspace but starts with brand-new history and is destroyed after running, so it does not pollute this conversation); the reply is still pushed back to this chat. Provide only timeText and message and OMIT mode to get this default. Routing, session, and account are resolved by weacpx.",
       inputSchema: exports_external.object({
         timeText: exports_external.string().min(1).describe("Time expression, e.g. 'in 2h', '30分钟后', 'tomorrow 09:00', or '周五 09:00'."),
-        message: exports_external.string().min(1).describe("Natural-language message to send to the current session at the scheduled time."),
-        mode: scheduledModeSchema.describe("'temp' creates a temporary one-shot session; 'bound' sends to the current bound session.").optional()
+        message: exports_external.string().min(1).describe("Natural-language message to run at the scheduled time."),
+        mode: scheduledModeSchema.describe("Optional; leave UNSET for the default temporary session (recommended). Set 'bound' ONLY when the user explicitly asks for the task to run inside this conversation's current session and share its context. 'temp' forces the temporary session.").optional()
       }).strict(),
       handler: async (args) => await asToolResult(async () => {
         const input2 = args;
@@ -42655,7 +43487,7 @@ function createWeacpxMcpServer(options) {
   const taskOptionsById = new Map;
   const watchTasksById = new Map;
   const server = new Server({
-    name: "weacpx-orchestration",
+    name: "weacpx",
     version: readVersion()
   }, {
     capabilities: {