@ganglion/xacpx 0.24.5-beta.0 → 0.24.6-beta.0

package/dist/adapters/adapter-catalog.d.ts

@@ -2,12 +2,12 @@ export declare const MANAGED_ADAPTERS: {
     readonly codex: {
         readonly packageName: "@agentclientprotocol/codex-acp";
         readonly binName: "codex-acp";
-        readonly defaultVersion: "1.10.0";
+        readonly defaultVersion: "1.12.0";
     };
     readonly claude: {
         readonly packageName: "@agentclientprotocol/claude-agent-acp";
         readonly binName: "claude-agent-acp";
-        readonly defaultVersion: "0.75.1";
+        readonly defaultVersion: "0.78.0";
     };
 };
 export type ManagedAdapterId = keyof typeof MANAGED_ADAPTERS;

package/dist/bots/bot-types.d.ts

@@ -0,0 +1,66 @@
+export type BotRuntimeScope = "bot-direct" | "group-member" | "group-controller";
+export interface BotProfilePresentation {
+    name: string;
+    avatar?: string;
+    role?: string;
+}
+export interface BotProfileBehavior {
+    instructions?: string;
+}
+export interface BotProfileExecution {
+    agent: string;
+    workspace: string;
+    model?: string;
+    effort?: string;
+}
+/** Durable linearization of the Bot fields a Run was accepted against. */
+export interface BotProfileSnapshot {
+    revision: number;
+    capturedAt: string;
+    presentation: BotProfilePresentation;
+    behavior: BotProfileBehavior;
+    execution: BotProfileExecution;
+}
+export interface BotProfile {
+    id: string;
+    name: string;
+    avatar?: string;
+    role?: string;
+    instructions?: string;
+    agent: string;
+    workspace: string;
+    cwd?: string;
+    model?: string;
+    effort?: string;
+    enabled: boolean;
+    /** Monotonic Bot-config generation. Missing on PR2 records; parse defaults to 1. */
+    profileRevision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function sessionMatchesExecution(session: {
+    agent: string;
+    workspace: string;
+    model?: string;
+    effort?: string;
+}, execution: BotProfileExecution): boolean;
+export declare function snapshotBotProfile(bot: BotProfile, capturedAt: string): BotProfileSnapshot;
+interface BotRuntimeBindingBase {
+    id: string;
+    conversationId: string;
+    topicId: string;
+    logicalSessionId: string;
+    sessionAlias: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export type BotRuntimeBinding = (BotRuntimeBindingBase & {
+    scope: "bot-direct";
+    botId: string;
+}) | (BotRuntimeBindingBase & {
+    scope: "group-member";
+    botId: string;
+}) | (BotRuntimeBindingBase & {
+    scope: "group-controller";
+});
+export {};

package/dist/bridge/bridge-main.js

@@ -7254,12 +7254,12 @@ var init_adapter_catalog = __esm(() => {
     codex: {
       packageName: "@agentclientprotocol/codex-acp",
       binName: "codex-acp",
-      defaultVersion: "1.10.0"
+      defaultVersion: "1.12.0"
     },
     claude: {
       packageName: "@agentclientprotocol/claude-agent-acp",
       binName: "claude-agent-acp",
-      defaultVersion: "0.75.1"
+      defaultVersion: "0.78.0"
     }
   };
   EXACT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
@@ -14539,8 +14539,9 @@ class RuntimeEngine {
               }
             } else if (event.type === "status") {
               if (event.tag === "plan") {
-                sink({ type: "prompt.segment", text: `${event.text}
-` });
+                const entries = toPromptPlanEntries(event.entries);
+                if (entries)
+                  sink({ type: "prompt.plan", entries });
                 return;
               }
               if (typeof event.used === "number" && typeof event.size === "number") {
@@ -16255,6 +16256,31 @@ async function buildRuntimeAttachments(media) {
   }
   return attachments;
 }
+var PROMPT_PLAN_STATUSES = new Set(["pending", "in_progress", "completed"]);
+var PROMPT_PLAN_PRIORITIES = new Set(["high", "medium", "low"]);
+function toPromptPlanEntries(value) {
+  if (!Array.isArray(value))
+    return;
+  if (value.length === 0)
+    return [];
+  const entries = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const record = item;
+    const content = typeof record.content === "string" ? record.content.trim() : "";
+    const status = typeof record.status === "string" ? record.status.trim() : "";
+    if (!content || !PROMPT_PLAN_STATUSES.has(status))
+      continue;
+    const priority = typeof record.priority === "string" ? record.priority.trim() : "";
+    entries.push({
+      content,
+      status,
+      ...PROMPT_PLAN_PRIORITIES.has(priority) ? { priority } : {}
+    });
+  }
+  return entries.length > 0 ? entries : undefined;
+}
 function mapRuntimeToolEvent(event) {
   const toolCallId = event.toolCallId || `tc-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
   const title = (event.title ?? "").trim();

package/dist/bridge/engine/runtime/runtime-worker-main.js

@@ -5872,12 +5872,12 @@ var init_adapter_catalog = __esm(() => {
     codex: {
       packageName: "@agentclientprotocol/codex-acp",
       binName: "codex-acp",
-      defaultVersion: "1.10.0"
+      defaultVersion: "1.12.0"
     },
     claude: {
       packageName: "@agentclientprotocol/claude-agent-acp",
       binName: "claude-agent-acp",
-      defaultVersion: "0.75.1"
+      defaultVersion: "0.78.0"
     }
   };
   EXACT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
@@ -7157,6 +7157,7 @@ async function* mapEvents(events) {
         };
       }
     } else if (event.type === "status") {
+      const planEntries = normalizeAdapterPlanEntries(event.entries);
       yield {
         type: "status",
         text: event.text,
@@ -7165,7 +7166,8 @@ async function* mapEvents(events) {
         ...event.size !== undefined ? { size: event.size } : {},
         ...event.cost ? { cost: event.cost } : {},
         ...event.breakdown ? { breakdown: event.breakdown } : {},
-        ...event.availableCommands ? { availableCommands: event.availableCommands } : {}
+        ...event.availableCommands ? { availableCommands: event.availableCommands } : {},
+        ...planEntries !== undefined ? { entries: planEntries } : {}
       };
     } else if (event.type === "tool_call") {
       const isInitialToolEvent = typeof event.toolCallId === "string" ? !toolCalls.has(event.toolCallId) : event.tag !== "tool_call_update";
@@ -7188,6 +7190,31 @@ async function* mapEvents(events) {
     }
   }
 }
+var ADAPTER_PLAN_STATUSES = new Set(["pending", "in_progress", "completed"]);
+var ADAPTER_PLAN_PRIORITIES = new Set(["high", "medium", "low"]);
+function normalizeAdapterPlanEntries(value) {
+  if (!Array.isArray(value))
+    return;
+  if (value.length === 0)
+    return [];
+  const entries = [];
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    const record = entry;
+    const content = typeof record.content === "string" ? record.content.trim() : "";
+    const status = typeof record.status === "string" ? record.status.trim() : "";
+    if (!content || !ADAPTER_PLAN_STATUSES.has(status))
+      continue;
+    const priority = typeof record.priority === "string" ? record.priority.trim() : "";
+    entries.push({
+      content,
+      status,
+      ...ADAPTER_PLAN_PRIORITIES.has(priority) ? { priority } : {}
+    });
+  }
+  return entries.length > 0 ? entries : undefined;
+}
 async function mapResult(result) {
   const settled = await result;
   if (settled.status === "failed") {

package/dist/cli.js

@@ -4355,12 +4355,12 @@ var init_adapter_catalog = __esm(() => {
     codex: {
       packageName: "@agentclientprotocol/codex-acp",
       binName: "codex-acp",
-      defaultVersion: "1.10.0"
+      defaultVersion: "1.12.0"
     },
     claude: {
       packageName: "@agentclientprotocol/claude-agent-acp",
       binName: "claude-agent-acp",
-      defaultVersion: "0.75.1"
+      defaultVersion: "0.78.0"
     }
   };
   EXACT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
@@ -30373,7 +30373,11 @@ function createEmptyState() {
     chat_contexts: {},
     native_session_lists: {},
     orchestration: createEmptyOrchestrationState(),
-    scheduled_tasks: {}
+    scheduled_tasks: {},
+    bots: {},
+    conversations: {},
+    conversation_topics: {},
+    bot_runtime_bindings: {}
   };
 }
 var init_types4 = () => {};
@@ -30730,7 +30734,17 @@ function isSessionRecord(value) {
   if (!isRecord4(value)) {
     return false;
   }
-  return isString(value.alias) && isString(value.agent) && isString(value.workspace) && isString(value.transport_session) && (value.logical_session_id === undefined || isLogicalSessionId(value.logical_session_id)) && 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.transport_acpx_agent) && (value.transport_agent_argv === undefined || isStringArray(value.transport_agent_argv)) && (value.transport_engine === undefined || value.transport_engine === "cli" || value.transport_engine === "runtime") && isOptionalString(value.mode_id) && isOptionalString(value.effort) && (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) && (value.logical_session_id === undefined || isLogicalSessionId(value.logical_session_id)) && 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.transport_acpx_agent) && (value.transport_agent_argv === undefined || isStringArray(value.transport_agent_argv)) && (value.transport_engine === undefined || value.transport_engine === "cli" || value.transport_engine === "runtime") && isOptionalString(value.mode_id) && isOptionalString(value.effort) && (value.reply_mode === undefined || isReplyMode2(value.reply_mode)) && isString(value.created_at) && isString(value.last_used_at) && (value.owner === undefined || isLogicalSessionOwner(value.owner));
+}
+function isLogicalSessionOwner(value) {
+  if (!isRecord4(value)) {
+    return false;
+  }
+  if (value.kind !== "bot-direct" && value.kind !== "group-member" && value.kind !== "group-controller" || !isString(value.bindingId) || value.bindingId.length === 0) {
+    return false;
+  }
+  const optional3 = (field) => value[field] === undefined || isString(value[field]) && value[field].length > 0;
+  return optional3("botId") && optional3("conversationId") && optional3("topicId");
 }
 function parseSessions(raw, dropped, migrated) {
   const sessions = {};
@@ -30822,6 +30836,108 @@ function parseScheduledTasks(raw, dropped) {
   }
   return tasks;
 }
+function isBotProfile(value) {
+  if (!isRecord4(value)) {
+    return false;
+  }
+  return isString(value.id) && isString(value.name) && isOptionalString(value.avatar) && isOptionalString(value.role) && isOptionalString(value.instructions) && isString(value.agent) && isString(value.workspace) && isOptionalString(value.cwd) && isOptionalString(value.model) && isOptionalString(value.effort) && typeof value.enabled === "boolean" && (value.profileRevision === undefined || typeof value.profileRevision === "number" && Number.isInteger(value.profileRevision) && value.profileRevision >= 1) && isString(value.createdAt) && isString(value.updatedAt);
+}
+function parseBotProfiles(raw, dropped) {
+  const source = sectionRecord(raw, "bots", dropped);
+  const bots = {};
+  for (const [id, value] of Object.entries(source)) {
+    if (!isBotProfile(value) || value.id !== id) {
+      dropped.push({ section: "bots", key: id, reason: "malformed bot profile" });
+      continue;
+    }
+    bots[id] = {
+      ...value,
+      profileRevision: value.profileRevision ?? 1
+    };
+  }
+  return bots;
+}
+function isUniqueStringArray(value) {
+  return isStringArray(value) && new Set(value).size === value.length;
+}
+function isConversationRecord(value) {
+  if (!isRecord4(value)) {
+    return false;
+  }
+  if (!isString(value.id) || !isString(value.title) || !isOptionalString(value.description) || !isUniqueStringArray(value.botIds) || !isOptionalString(value.leadBotId) || !isString(value.createdAt) || !isString(value.updatedAt)) {
+    return false;
+  }
+  if (value.lifecycle !== undefined && value.lifecycle !== "active" && value.lifecycle !== "deleting") {
+    return false;
+  }
+  if (value.leadBotId !== undefined && !value.botIds.includes(value.leadBotId)) {
+    return false;
+  }
+  if (value.kind === "bot") {
+    return value.botIds.length === 1;
+  }
+  if (value.kind === "group") {
+    return value.botIds.length >= 2;
+  }
+  return false;
+}
+function parseConversations(raw, dropped) {
+  const source = sectionRecord(raw, "conversations", dropped);
+  const conversations = {};
+  for (const [id, value] of Object.entries(source)) {
+    if (!isConversationRecord(value) || value.id !== id) {
+      dropped.push({ section: "conversations", key: id, reason: "malformed conversation record" });
+      continue;
+    }
+    conversations[id] = value;
+  }
+  return conversations;
+}
+function isConversationTopic(value) {
+  if (!isRecord4(value)) {
+    return false;
+  }
+  return isString(value.id) && isString(value.conversationId) && isString(value.title) && (value.status === "active" || value.status === "archived" || value.status === "deleting") && isString(value.createdAt) && isString(value.updatedAt);
+}
+function parseConversationTopics(raw, dropped) {
+  const source = sectionRecord(raw, "conversation_topics", dropped);
+  const topics = {};
+  for (const [id, value] of Object.entries(source)) {
+    if (!isConversationTopic(value) || value.id !== id) {
+      dropped.push({ section: "conversation_topics", key: id, reason: "malformed conversation topic" });
+      continue;
+    }
+    topics[id] = value;
+  }
+  return topics;
+}
+function isBotRuntimeBinding(value) {
+  if (!isRecord4(value)) {
+    return false;
+  }
+  if (!isString(value.id) || !isString(value.conversationId) || !isString(value.topicId) || !isString(value.logicalSessionId) || !isString(value.sessionAlias) || !isString(value.createdAt) || !isString(value.updatedAt)) {
+    return false;
+  }
+  if (value.scope === "bot-direct" || value.scope === "group-member") {
+    return isString(value.botId) && value.botId.length > 0;
+  }
+  if (value.scope === "group-controller") {
+    return value.botId === undefined;
+  }
+  return false;
+}
+function parseBotRuntimeBindings(raw, dropped) {
+  const source = sectionRecord(raw, "bot_runtime_bindings", dropped);
+  const bindings = {};
+  for (const [id, value] of Object.entries(source)) {
+    if (!isBotRuntimeBinding(value) || value.id !== id) {
+      dropped.push({ section: "bot_runtime_bindings", key: id, reason: "malformed bot runtime binding" });
+      continue;
+    }
+    bindings[id] = value;
+  }
+  return bindings;
+}
 function parseState(raw, path3, dropped = [], migrated = []) {
   if (!isRecord4(raw)) {
     throw new Error(`state file "${path3}" must contain a JSON object`);
@@ -30834,7 +30950,11 @@ function parseState(raw, path3, dropped = [], migrated = []) {
     chat_contexts: parseChatContexts(sectionRecord(raw.chat_contexts, "chat_contexts", dropped), dropped),
     native_session_lists: parseNativeSessionLists(raw.native_session_lists),
     orchestration: orchestration3,
-    scheduled_tasks: parseScheduledTasks(raw.scheduled_tasks, dropped)
+    scheduled_tasks: parseScheduledTasks(raw.scheduled_tasks, dropped),
+    bots: parseBotProfiles(raw.bots, dropped),
+    conversations: parseConversations(raw.conversations, dropped),
+    conversation_topics: parseConversationTopics(raw.conversation_topics, dropped),
+    bot_runtime_bindings: parseBotRuntimeBindings(raw.bot_runtime_bindings, dropped)
   };
 }
 function repairExternalCoordinatorIdentityCollisions(sessions, orchestration3, dropped) {
@@ -42471,6 +42591,7 @@ function lockForPhysicalKey(physicalKey) {
 }
 async function removeAliasWithPhysicalLifecycle(options) {
   const { sessions, transport, session: session3, internalAlias } = options;
+  const policy = options.physicalFailurePolicy ?? "legacy-cli-best-effort";
   const groupKey = physicalLifecycleKeyForResolvedSession(session3);
   const isRuntime = session3.transportEngine === "runtime";
   return lockForPhysicalKey(groupKey).run(async () => {
@@ -42500,9 +42621,14 @@ async function removeAliasWithPhysicalLifecycle(options) {
         await transport.deleteSession(session3);
         action = "deleted";
       } catch (error2) {
+        if (policy === "strict") {
+          throw error2;
+        }
         transportTeardownWarning = error2 instanceof Error ? error2.message : String(error2);
         action = "logical-only";
       }
+    } else if (remaining === 0 && policy === "strict") {
+      throw new Error(`cannot hard-delete last CLI alias "${internalAlias}": transport has no deleteSession operation`);
     } else {
       action = "logical-only";
     }
@@ -54938,6 +55064,10 @@ function replaceRuntimeState(target, source) {
   target.chat_contexts = source.chat_contexts;
   target.orchestration = source.orchestration;
   target.scheduled_tasks = source.scheduled_tasks;
+  target.bots = source.bots;
+  target.conversations = source.conversations;
+  target.conversation_topics = source.conversation_topics;
+  target.bot_runtime_bindings = source.bot_runtime_bindings;
 }
 
 // src/sessions/transport-engine.ts
@@ -55139,8 +55269,8 @@ class SessionService {
       ...this.permissionInteractionCapable !== undefined ? { permissionInteractionCapable: this.permissionInteractionCapable } : {}
     }).engine;
   }
-  async createSession(alias, agent3, workspace3) {
-    return await this.createLogicalSession(alias, agent3, workspace3, `${workspace3}:${alias}`);
+  async createSession(alias, agent3, workspace3, options) {
+    return await this.createLogicalSession(alias, agent3, workspace3, `${workspace3}:${alias}`, undefined, undefined, undefined, undefined, options);
   }
   listAllResolvedSessions() {
     const seen = new Set;
@@ -55547,6 +55677,9 @@ class SessionService {
   getLogicalSessionRecord(alias) {
     return this.state.sessions[alias] ?? null;
   }
+  getLogicalSessionById(logicalSessionId) {
+    return Object.values(this.state.sessions).find((session3) => session3.logical_session_id === logicalSessionId) ?? null;
+  }
   listLogicalSessionRecords() {
     return Object.values(this.state.sessions);
   }
@@ -56166,7 +56299,7 @@ class SessionService {
     }
     return input.sameAgentExistingEngine ?? siblingEngine ?? input.fallback();
   }
-  async createLogicalSession(alias, agent3, workspace3, transportSession, transportAgentCommand, native, transportAcpxAgent, transportAgentArgv) {
+  async createLogicalSession(alias, agent3, workspace3, transportSession, transportAgentCommand, native, transportAcpxAgent, transportAgentArgv, extras) {
     return await this.mutate(async () => {
       this.validateSession(alias, agent3, workspace3);
       if (Object.keys(this.state.orchestration.externalCoordinators).some((coordinatorSession) => sameCoordinatorSession(coordinatorSession, transportSession))) {
@@ -56191,8 +56324,8 @@ class SessionService {
         ...transportAcpxAgent ? { transport_acpx_agent: transportAcpxAgent } : sameAgentExisting?.transport_acpx_agent ? { transport_acpx_agent: sameAgentExisting.transport_acpx_agent } : {},
         ...transportAgentArgv && transportAgentArgv.length > 0 ? { transport_agent_argv: [...transportAgentArgv] } : sameAgentExisting?.transport_agent_argv ? { transport_agent_argv: [...sameAgentExisting.transport_agent_argv] } : {},
         mode_id: sameAgentExisting?.mode_id,
-        model: sameAgentExisting?.model,
-        effort: sameAgentExisting?.effort,
+        model: extras?.model ?? sameAgentExisting?.model,
+        effort: extras?.effort ?? sameAgentExisting?.effort,
         reply_mode: sameAgentExisting?.reply_mode,
         display_name: sameAgentExisting?.display_name,
         transport_engine: this.resolveEngineWithPhysicalInheritance({
@@ -56206,7 +56339,8 @@ class SessionService {
           ...sameAgentExisting ? { sameAgentExisting } : {}
         }),
         created_at: existingSession?.created_at ?? now,
-        last_used_at: now
+        last_used_at: now,
+        ...extras?.owner ? { owner: extras.owner } : {}
       };
       const nextState = structuredClone(this.state);
       nextState.sessions[alias] = session3;
@@ -63016,6 +63150,7 @@ ${envelope}` : envelope;
       return {
         ok: false,
         errorMessage,
+        ...!timedOut && signal.aborted ? { cancelled: true } : {},
         ...internalAlias && priorTransportSession ? { postTurnDetection: { internalAlias, priorTransportSession } } : {}
       };
     }
@@ -63440,10 +63575,13 @@ class TurnQueue {
     return {
       ok: result.ok,
       ...result.text !== undefined ? { text: result.text } : {},
-      ...result.errorMessage !== undefined ? { errorMessage: result.errorMessage } : {}
+      ...result.errorMessage !== undefined ? { errorMessage: result.errorMessage } : {},
+      ...result.cancelled ? { cancelled: true } : {}
     };
   }
   advanceQueue(key) {
+    const finished = this.inFlight.get(key);
+    this.recordSettledRequestId(finished?.promptRequestId);
     const interrupt = this.pendingInterrupts.get(key);
     if (interrupt) {
       this.pendingInterrupts.delete(key);
@@ -63498,6 +63636,26 @@ class TurnQueue {
     entry.controller.abort();
     return true;
   }
+  cancelTurnForPromptRequest(chatKey, sessionAlias, promptRequestId, concurrencyKey) {
+    const key = this.resolveKey(chatKey, sessionAlias, concurrencyKey);
+    const entry = this.inFlight.get(key);
+    if (!entry || entry.promptRequestId !== promptRequestId) {
+      return false;
+    }
+    entry.controller.abort();
+    return true;
+  }
+  inspectPromptRequest(chatKey, sessionAlias, promptRequestId, concurrencyKey) {
+    const key = this.resolveKey(chatKey, sessionAlias, concurrencyKey);
+    const entry = this.inFlight.get(key);
+    if (entry?.promptRequestId === promptRequestId) {
+      return "in-flight";
+    }
+    if (this.hasSettledRequestId(promptRequestId)) {
+      return "settled";
+    }
+    return "absent";
+  }
   async clearSession(chatKey, sessionAlias, concurrencyKey) {
     const key = this.resolveKey(chatKey, sessionAlias, concurrencyKey);
     const guardPreexisting = this.removing.has(key);
@@ -64084,26 +64242,40 @@ class ControlService {
     return task;
   }
   async prompt(input) {
+    return this.submitHumanPrompt(input, true);
+  }
+  async promptImmediate(input) {
+    return this.submitHumanPrompt(input, false);
+  }
+  submitHumanPrompt(input, queueable) {
     const channelId = getChannelIdFromChatKey(input.chatKey);
     const internalAlias = this.deps.sessions.getResolvedSessionByInternalAlias?.(input.sessionAlias)?.alias ?? this.deps.sessions.getResolvedSessionByInternalAlias?.(toInternalSessionAlias(channelId, input.sessionAlias))?.alias ?? scopeDisplayAliasToInternal(channelId, input.sessionAlias);
     const configTail = this.sessionConfigSetTails.get(internalAlias) ?? this.sessionConfigSetTails.get(input.sessionAlias);
+    const turnOrigin = queueable ? "human" : input.executionOrigin === "human" ? "human" : "orchestration";
+    const submit = () => {
+      if (input.abortSignal?.aborted) {
+        return Promise.resolve({ ok: false, cancelled: true, errorMessage: "cancelled" });
+      }
+      return this.turnQueue.submit({
+        chatKey: input.chatKey,
+        sessionAlias: input.sessionAlias,
+        concurrencyKey: internalAlias,
+        text: input.text,
+        senderId: input.senderId,
+        turnOrigin,
+        queueable,
+        ...input.isOwner !== undefined ? { isOwner: input.isOwner } : {},
+        ...input.accountId !== undefined ? { accountId: input.accountId } : {},
+        ...input.media !== undefined ? { media: input.media } : {},
+        ...input.agentMentions !== undefined ? { agentMentions: input.agentMentions } : {},
+        ...input.promptRequestId !== undefined ? { promptRequestId: input.promptRequestId } : {},
+        ...input.abortSignal !== undefined ? { abortSignal: input.abortSignal } : {}
+      });
+    };
     if (configTail) {
-      await configTail.catch(() => {});
+      return configTail.catch(() => {}).then(submit);
     }
-    return this.turnQueue.submit({
-      chatKey: input.chatKey,
-      sessionAlias: input.sessionAlias,
-      concurrencyKey: internalAlias,
-      text: input.text,
-      senderId: input.senderId,
-      turnOrigin: "human",
-      queueable: true,
-      ...input.isOwner !== undefined ? { isOwner: input.isOwner } : {},
-      ...input.accountId !== undefined ? { accountId: input.accountId } : {},
-      ...input.media !== undefined ? { media: input.media } : {},
-      ...input.agentMentions !== undefined ? { agentMentions: input.agentMentions } : {},
-      ...input.promptRequestId !== undefined ? { promptRequestId: input.promptRequestId } : {}
-    });
+    return submit();
   }
   async runScheduledTurn(input) {
     const channelId = getChannelIdFromChatKey(input.chatKey);
@@ -64142,6 +64314,16 @@ class ControlService {
     const internalAlias = this.deps.sessions.getResolvedSessionByInternalAlias?.(sessionAlias)?.alias ?? this.deps.sessions.getResolvedSessionByInternalAlias?.(toInternalSessionAlias(channelId, sessionAlias))?.alias ?? scopeDisplayAliasToInternal(channelId, sessionAlias);
     return this.turnQueue.cancelTurn(chatKey, sessionAlias, internalAlias);
   }
+  cancelTurnForPromptRequest(chatKey, sessionAlias, promptRequestId) {
+    const channelId = getChannelIdFromChatKey(chatKey);
+    const internalAlias = this.deps.sessions.getResolvedSessionByInternalAlias?.(sessionAlias)?.alias ?? this.deps.sessions.getResolvedSessionByInternalAlias?.(toInternalSessionAlias(channelId, sessionAlias))?.alias ?? scopeDisplayAliasToInternal(channelId, sessionAlias);
+    return this.turnQueue.cancelTurnForPromptRequest(chatKey, sessionAlias, promptRequestId, internalAlias);
+  }
+  inspectPromptRequest(chatKey, sessionAlias, promptRequestId) {
+    const channelId = getChannelIdFromChatKey(chatKey);
+    const internalAlias = this.deps.sessions.getResolvedSessionByInternalAlias?.(sessionAlias)?.alias ?? this.deps.sessions.getResolvedSessionByInternalAlias?.(toInternalSessionAlias(channelId, sessionAlias))?.alias ?? scopeDisplayAliasToInternal(channelId, sessionAlias);
+    return this.turnQueue.inspectPromptRequest(chatKey, sessionAlias, promptRequestId, internalAlias);
+  }
   async submitPeerTurn(input) {
     const channelId = getChannelIdFromChatKey(input.chatKey);
     const internalAlias = input.boundSessionAlias ?? this.deps.sessions.getResolvedSessionByInternalAlias?.(input.sessionAlias)?.alias ?? this.deps.sessions.getResolvedSessionByInternalAlias?.(toInternalSessionAlias(channelId, input.sessionAlias))?.alias ?? scopeDisplayAliasToInternal(channelId, input.sessionAlias);

package/dist/commands/session-remove-lifecycle.d.ts

@@ -1,5 +1,6 @@
 import type { SessionService } from "../sessions/session-service";
 import type { ResolvedSession, SessionTransport } from "../transport/types";
+export type PhysicalFailurePolicy = "legacy-cli-best-effort" | "strict";
 export interface PhysicalRemoveOutcome {
     wasActive: boolean;
     /**
@@ -26,6 +27,14 @@ export declare function removeAliasWithPhysicalLifecycle(options: {
     transport: Pick<SessionTransport, "releaseLogicalSession" | "deleteSession">;
     session: ResolvedSession;
     internalAlias: string;
+    /**
+     * Default `legacy-cli-best-effort` keeps `/session rm` semantics: a CLI
+     * last-owner `deleteSession` failure records a warning and still removes
+     * the LogicalSession. `strict` is the Bot/Conversation owned-session
+     * path: any Runtime or CLI physical failure throws BEFORE the logical row
+     * disappears so callers keep the retry handle.
+     */
+    physicalFailurePolicy?: PhysicalFailurePolicy;
 }): Promise<PhysicalRemoveOutcome>;
 export interface ProvisionalSessionCleanup {
     sessions: SessionService;

package/dist/config/types.d.ts

@@ -71,7 +71,7 @@ export interface TransportConfig {
      */
     turnIdleTimeoutSeconds?: number;
     /**
-     * Advanced acpx embedding-host ceilings (acpx 0.15.1, plan B5).
+     * Advanced acpx embedding-host ceilings (acpx 0.15.1+, plan B5).
      * `acpxMaxIncomingMessageBytes` overrides the 64 MiB default ceiling on
      * agent → acpx inbound ACP messages (`0` = unlimited — avoid unless a real
      * workload needs it); `acpxTerminalMaxOutputBytes` caps retained

package/dist/control/control-service.d.ts

@@ -7,6 +7,7 @@ import type { ScheduledTaskRecord } from "../scheduled/scheduled-types";
 import type { CancelTaskInput, OrchestrationService, OrchestrationTaskFilter } from "../orchestration/orchestration-service";
 import type { OrchestrationTaskRecord } from "../orchestration/orchestration-types";
 import type { AgentMessageCompletion, AgentMessageMode } from "../orchestration/agent-messaging-types";
+import type { PermissionInteractionOrigin } from "../permissions/permission-types.js";
 import type { ControlEventBus } from "./control-event-bus";
 import type { AgentCatalogEntry } from "../config/agent-catalog";
 import { type BrowseDirsResult, type DirListing, type FileContent, type SearchOptions, type SearchResult, type WorkspaceDiff } from "./workspace-fs";
@@ -221,11 +222,23 @@ export interface ControlPromptInput {
      *  turn-started so the hub can tie a queued prompt back to its pre-written inbound
      *  row (see PromptPayload.promptRequestId). */
     promptRequestId?: string;
+    /** Conversation pre-admission cancel. Checked after any config-tail wait and
+     *  immediately before TurnQueue.submit so a cancelled Run never starts. */
+    abortSignal?: AbortSignal;
+    /**
+     * Conversation execution provenance, derived by ConversationStore at claim
+     * from the live authority epoch. `promptImmediate` fail-closes to
+     * orchestration unless this is exactly `"human"`. Interactive `prompt()`
+     * ignores it and is always human. Omitting it cannot mint human authority.
+     */
+    executionOrigin?: PermissionInteractionOrigin;
 }
 export interface ControlPromptResult {
     ok: boolean;
     text?: string;
     errorMessage?: string;
+    /** Proven cancellation (AbortSignal / user Stop), not an error string match. */
+    cancelled?: boolean;
     /** True when this prompt did not run immediately and was instead appended to the
      *  per-session server-side queue (a turn was already in flight). */
     queued?: boolean;
@@ -386,6 +399,14 @@ export declare class ControlService {
     getOrchestrationTask(taskId: string): Promise<OrchestrationTaskRecord | null>;
     cancelOrchestrationTask(input: CancelTaskInput): Promise<OrchestrationTaskRecord>;
     prompt(input: ControlPromptInput): Promise<ControlPromptResult>;
+    /**
+     * Conversation execution seam: same TurnQueue / SessionTurnRunner path as
+     * `prompt()`, but never FIFO-enqueues when the session lane is busy.
+     * Turn origin is the store-derived `executionOrigin` (fail-closed to
+     * orchestration). ConversationStore already owns durable queuing.
+     */
+    promptImmediate(input: ControlPromptInput): Promise<ControlPromptResult>;
+    private submitHumanPrompt;
     /** Run a fired scheduled task as a real turn through the same machinery as a manual
      *  prompt — so it streams live and persists to history — while tagging turn-started
      *  with the prompt text + schedule origin so the hub records the inbound message and
@@ -395,6 +416,8 @@ export declare class ControlService {
     isBusy(chatKey: string, sessionAlias: string): boolean;
     isSessionBusy(internalAlias: string): boolean;
     cancelTurn(chatKey: string, sessionAlias: string): boolean;
+    cancelTurnForPromptRequest(chatKey: string, sessionAlias: string, promptRequestId: string): boolean;
+    inspectPromptRequest(chatKey: string, sessionAlias: string, promptRequestId: string): "in-flight" | "settled" | "absent";
     submitPeerTurn(input: {
         chatKey: string;
         sessionAlias: string;

package/dist/control/session-turn-runner.d.ts

@@ -36,6 +36,8 @@ export interface TurnResult {
     ok: boolean;
     text?: string;
     errorMessage?: string;
+    /** Proven user-Stop / abort cancellation. Idle-timeout aborts omit this. */
+    cancelled?: boolean;
     postTurnDetection?: {
         internalAlias: string;
         priorTransportSession: string;

package/dist/control/turn-queue.d.ts

@@ -150,6 +150,14 @@ export declare class TurnQueue {
     private advanceQueue;
     private drainQueuedPrompt;
     cancelTurn(chatKey: string, sessionAlias: string, concurrencyKey?: string): boolean;
+    /**
+     * Abort the in-flight turn only when it is the given promptRequestId.
+     * A minted Conversation correlation id is not a lane-wide cancel: a later
+     * prompt on the same session must not be aborted, and a settled request
+     * must not be treated as cancelled just because Stop was pressed late.
+     */
+    cancelTurnForPromptRequest(chatKey: string, sessionAlias: string, promptRequestId: string, concurrencyKey?: string): boolean;
+    inspectPromptRequest(chatKey: string, sessionAlias: string, promptRequestId: string, concurrencyKey?: string): "in-flight" | "settled" | "absent";
     /** Tear down all turn state for a session that is being removed or archived: drop every
      *  queued prompt, abort a running turn, and wait (bounded) for it to unwind. The queue is
      *  cleared BEFORE the abort so the aborting turn's finally sees it empty and releases the

package/dist/conversations/conversation-types.d.ts

@@ -0,0 +1,117 @@
+import type { BotProfileSnapshot } from "../bots/bot-types";
+export type ConversationKind = "bot" | "group";
+export type ConversationLifecycle = "active" | "deleting";
+export type ConversationTopicStatus = "active" | "archived" | "deleting";
+export type ConversationMessageRole = "human" | "bot" | "system";
+export type GroupTurnOrigin = "human-explicit" | "controller" | "handoff" | "recovery";
+export type GroupTurnState = "queued" | "running" | "completed" | "failed" | "cancelled";
+export type ConversationRunMode = "explicit";
+export type ConversationRunState = "queued" | "running" | "waiting-human" | "completed" | "failed" | "cancelled" | "indeterminate";
+export type MemberTurnOrigin = "human" | "followup" | "retry" | "recovery";
+export type MemberTurnState = "queued" | "dispatched" | "running" | "completed" | "failed" | "cancelled" | "indeterminate";
+export type PendingDispatchState = "pending" | "claimed" | "completed";
+export interface ConversationRecord {
+    id: string;
+    kind: ConversationKind;
+    title: string;
+    description?: string;
+    botIds: string[];
+    leadBotId?: string;
+    /** Bounded AppState lifecycle flag. SQLite conversation_lifecycle is authoritative for dispatch. */
+    lifecycle?: ConversationLifecycle;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConversationTopic {
+    id: string;
+    conversationId: string;
+    title: string;
+    status: ConversationTopicStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConversationMessage {
+    id: string;
+    conversationId: string;
+    topicId: string;
+    seq: number;
+    role: ConversationMessageRole;
+    senderBotId?: string;
+    recipients?: string[];
+    content: string;
+    replyTo?: string;
+    runId?: string;
+    createdAt: string;
+    sourceTurn?: {
+        sessionAlias: string;
+        turnId?: string;
+    };
+}
+export interface ConversationRun {
+    id: string;
+    conversationId: string;
+    topicId: string;
+    requestMessageId: string;
+    requestId: string;
+    mode: ConversationRunMode;
+    state: ConversationRunState;
+    completionReason?: string;
+    generation: number;
+    maxMemberTurns: number;
+    consumedMemberTurns: number;
+    profileRevision: number;
+    profileSnapshot: BotProfileSnapshot;
+    createdAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+export interface MemberTurnRecord {
+    id: string;
+    runId: string;
+    conversationId: string;
+    topicId: string;
+    botId: string;
+    sessionAlias?: string;
+    logicalSessionId?: string;
+    sourceTurnId?: string;
+    queueItemId?: string;
+    batch: number;
+    attempt: number;
+    origin: MemberTurnOrigin;
+    state: MemberTurnState;
+    triggerMessageIds: string[];
+    createdAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+export interface PendingDispatch {
+    id: string;
+    runId: string;
+    memberTurnId: string;
+    generation: number;
+    state: PendingDispatchState;
+    owner?: string;
+    leaseExpiresAt?: string;
+    /** Live dispatcher epoch that accepted this work. Matching claim keeps human
+     *  permission authority; mismatch or revoked epoch is recovery/orchestration. */
+    authorityEpoch?: string;
+    createdAt: string;
+    claimedAt?: string;
+    completedAt?: string;
+}
+export interface GroupTurnRecord {
+    id: string;
+    conversationId: string;
+    topicId: string;
+    botId: string;
+    sessionAlias: string;
+    triggerMessageIds: string[];
+    origin: GroupTurnOrigin;
+    state: GroupTurnState;
+    createdAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+export declare const ACTIVE_RUN_STATES: readonly ConversationRunState[];
+export declare const TERMINAL_RUN_STATES: readonly ConversationRunState[];
+export declare const TERMINAL_MEMBER_STATES: readonly MemberTurnState[];

package/dist/sessions/session-service.d.ts

@@ -1,7 +1,7 @@
 import type { AppConfig } from "../config/types";
 import { AsyncMutex } from "../orchestration/async-mutex";
 import type { StateStore } from "../state/state-store";
-import type { AppState, BackgroundResult, LogicalSession, SessionTransportEngine } from "../state/types";
+import type { AppState, BackgroundResult, LogicalSession, LogicalSessionOwner, SessionTransportEngine } from "../state/types";
 import type { SessionResourceLifecyclePublishInput } from "./session-resource-catalog";
 import type { AgentSession, ResolvedSession } from "../transport/types";
 import type { ReapTarget } from "../transport/queue-owner-reaper";
@@ -125,7 +125,11 @@ export declare class SessionService {
         agent: string;
         workspace: string;
     }): SessionTransportEngine;
-    createSession(alias: string, agent: string, workspace: string): Promise<ResolvedSession>;
+    createSession(alias: string, agent: string, workspace: string, options?: {
+        owner?: LogicalSessionOwner;
+        model?: string;
+        effort?: string;
+    }): Promise<ResolvedSession>;
     /**
      * All currently-known logical sessions resolved to transport sessions, deduped by
      * the composite identity acpx keys its session records on (agent + agent command +
@@ -250,6 +254,7 @@ export declare class SessionService {
      * does not carry (immutable logical_session_id, archived flag).
      */
     getLogicalSessionRecord(alias: string): LogicalSession | null;
+    getLogicalSessionById(logicalSessionId: string): LogicalSession | null;
     /** Read-only view of every persisted logical session record, across all channels. */
     listLogicalSessionRecords(): LogicalSession[];
     setCurrentSessionMode(chatKey: string, modeId: string | undefined): Promise<void>;

package/dist/state/types.d.ts

@@ -1,7 +1,26 @@
+import type { BotProfile, BotRuntimeBinding } from "../bots/bot-types";
+import type { ConversationRecord, ConversationTopic } from "../conversations/conversation-types";
 import { type OrchestrationState } from "../orchestration/orchestration-types";
 import type { ScheduledTaskRecord } from "../scheduled/scheduled-types";
 export type SessionTransportEngine = "cli" | "runtime";
 export type LogicalSessionSource = "xacpx" | "agent-side";
+export interface LogicalSessionOwner {
+    kind: "bot-direct" | "group-member" | "group-controller";
+    bindingId: string;
+    /**
+     * Explicit Bot id for scoped bot-direct ownership. Optional on PR2 records
+     * that only stored `bindingId` (the legacy deterministic default-Topic id).
+     */
+    botId?: string;
+    conversationId?: string;
+    topicId?: string;
+}
+export declare function createBotDirectOwner(input: {
+    bindingId: string;
+    botId: string;
+    conversationId: string;
+    topicId: string;
+}): LogicalSessionOwner;
 export interface NativeSessionCacheEntry {
     session_id: string;
     cwd?: string;
@@ -59,6 +78,7 @@ export interface LogicalSession {
     archived_at?: string;
     created_at: string;
     last_used_at: string;
+    owner?: LogicalSessionOwner;
 }
 export interface BackgroundResult {
     text: string;
@@ -76,5 +96,9 @@ export interface AppState {
     native_session_lists: Record<string, NativeSessionListCacheRecord>;
     orchestration: OrchestrationState;
     scheduled_tasks: Record<string, ScheduledTaskRecord>;
+    bots: Record<string, BotProfile>;
+    conversations: Record<string, ConversationRecord>;
+    conversation_topics: Record<string, ConversationTopic>;
+    bot_runtime_bindings: Record<string, BotRuntimeBinding>;
 }
 export declare function createEmptyState(): AppState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.24.5-beta.0",
+  "version": "0.24.6-beta.0",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",
@@ -86,12 +86,13 @@
     "test:unit": "node ./scripts/run-tests.mjs tests/unit",
     "test:smoke": "node ./scripts/run-tests.mjs tests/smoke",
     "test:compat:acpx": "node ./scripts/run-tests.mjs tests/compat",
+    "test:release-boundary": "node ./scripts/release-plan-boundary.mjs",
     "lint:acpx-imports": "node ./scripts/lint-acpx-imports.mjs",
     "smoke:local-install": "node ./scripts/smoke-local-install.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "acpx": "0.15.1",
+    "acpx": "0.16.0",
     "node-pty": "^1.1.0",
     "proper-lockfile": "^4.1.2",
     "protobufjs": "^7.5.6",