@ganglion/xacpx 0.24.5 → 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

@@ -1,4 +1,26 @@
 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;
@@ -11,9 +33,18 @@ export interface BotProfile {
     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;

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-]+)*)?$/;
@@ -30740,7 +30740,11 @@ function isLogicalSessionOwner(value) {
   if (!isRecord4(value)) {
     return false;
   }
-  return (value.kind === "bot-direct" || value.kind === "group-member" || value.kind === "group-controller") && isString(value.bindingId) && value.bindingId.length > 0;
+  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 = {};
@@ -30836,7 +30840,7 @@ 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" && isString(value.createdAt) && isString(value.updatedAt);
+  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);
@@ -30846,7 +30850,10 @@ function parseBotProfiles(raw, dropped) {
       dropped.push({ section: "bots", key: id, reason: "malformed bot profile" });
       continue;
     }
-    bots[id] = value;
+    bots[id] = {
+      ...value,
+      profileRevision: value.profileRevision ?? 1
+    };
   }
   return bots;
 }
@@ -30860,6 +30867,9 @@ function isConversationRecord(value) {
   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;
   }
@@ -30887,7 +30897,7 @@ function isConversationTopic(value) {
   if (!isRecord4(value)) {
     return false;
   }
-  return isString(value.id) && isString(value.conversationId) && isString(value.title) && (value.status === "active" || value.status === "archived") && isString(value.createdAt) && isString(value.updatedAt);
+  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);
@@ -42581,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 () => {
@@ -42610,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";
     }
@@ -63134,6 +63150,7 @@ ${envelope}` : envelope;
       return {
         ok: false,
         errorMessage,
+        ...!timedOut && signal.aborted ? { cancelled: true } : {},
         ...internalAlias && priorTransportSession ? { postTurnDetection: { internalAlias, priorTransportSession } } : {}
       };
     }
@@ -63558,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);
@@ -63616,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);
@@ -64202,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);
@@ -64260,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

@@ -1,8 +1,15 @@
+import type { BotProfileSnapshot } from "../bots/bot-types";
 export type ConversationKind = "bot" | "group";
-export type ConversationTopicStatus = "active" | "archived";
+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;
@@ -10,6 +17,8 @@ export interface ConversationRecord {
     description?: string;
     botIds: string[];
     leadBotId?: string;
+    /** Bounded AppState lifecycle flag. SQLite conversation_lifecycle is authoritative for dispatch. */
+    lifecycle?: ConversationLifecycle;
     createdAt: string;
     updatedAt: string;
 }
@@ -25,17 +34,71 @@ 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;
@@ -49,3 +112,6 @@ export interface GroupTurnRecord {
     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/state/types.d.ts

@@ -7,7 +7,20 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.24.5",
+  "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",