weacpx 0.6.0 → 0.6.1

package/dist/commands/command-hints.d.ts

@@ -0,0 +1,11 @@
+export interface CommandHint {
+    /** 输入框命令名，含前导斜杠，如 "/session"。 */
+    name: string;
+    /** 简短描述，取自对应 help topic 的 summary（平台可能截断）。 */
+    description: string;
+}
+/**
+ * 从 HELP_TOPICS 派生输入框命令提示（单一真源，与 /help 同源不漂移）。
+ * 额外置顶 /help。
+ */
+export declare function listWeacpxCommandHints(): CommandHint[];

package/dist/commands/command-list.d.ts

@@ -0,0 +1,3 @@
+export declare const WEACPX_KNOWN_COMMAND_PREFIXES: readonly ["/help", "/agents", "/workspaces", "/sessions", "/tasks", "/status", "/cancel", "/stop", "/clear", "/mode", "/replymode", "/config", "/permission", "/pm", "/session", "/ss", "/ssn", "/workspace", "/ws", "/use", "/agent", "/delegate", "/dg", "/group", "/groups", "/task", "/later", "/lt"];
+export declare function isKnownWeacpxCommandPrefix(prefix: string): boolean;
+export declare function isKnownWeacpxCommandText(text: string): boolean;

package/dist/commands/config-clone.d.ts

@@ -0,0 +1,2 @@
+import type { AppConfig } from "../config/types";
+export declare function cloneAppConfig(config: AppConfig): AppConfig;

package/dist/commands/handlers/agent-handler.d.ts

@@ -0,0 +1,6 @@
+import type { HelpTopicMetadata } from "../help/help-types";
+import type { CommandRouterContext, RouterResponse } from "../router-types";
+export declare const agentHelp: HelpTopicMetadata;
+export declare function handleAgents(context: CommandRouterContext): RouterResponse;
+export declare function handleAgentAdd(context: CommandRouterContext, templateName: string): Promise<RouterResponse>;
+export declare function handleAgentRemove(context: CommandRouterContext, agentName: string): Promise<RouterResponse>;

package/dist/commands/handlers/config-handler.d.ts

@@ -0,0 +1,5 @@
+import type { HelpTopicMetadata } from "../help/help-types";
+import type { CommandRouterContext, RouterResponse } from "../router-types";
+export declare const configHelp: HelpTopicMetadata;
+export declare function handleConfigShow(context: CommandRouterContext): RouterResponse;
+export declare function handleConfigSet(context: CommandRouterContext, path: string, rawValue: string): Promise<RouterResponse>;

package/dist/commands/handlers/later-handler.d.ts

@@ -0,0 +1,21 @@
+import type { RouterResponse, ScheduledRouterOps } from "../router-types";
+import type { ScheduledSessionMode } from "../../scheduled/scheduled-types";
+export declare const laterHelpMetadata: {
+    topic: string;
+    aliases: string[];
+    summary: string;
+    commands: {
+        usage: string;
+        description: string;
+    }[];
+    examples: string[];
+    notes: string[];
+};
+export declare function handleLaterHelp(): RouterResponse;
+export declare function handleLaterCreate(tokens: string[], scheduled: ScheduledRouterOps, chatKey: string, currentSession: {
+    alias: string;
+    agent: string;
+    workspace: string;
+} | null, defaultMode: ScheduledSessionMode, accountId?: string, replyContextToken?: string): Promise<RouterResponse>;
+export declare function handleLaterList(scheduled: ScheduledRouterOps): RouterResponse;
+export declare function handleLaterCancel(id: string, scheduled: ScheduledRouterOps): Promise<RouterResponse>;

package/dist/commands/handlers/orchestration-handler.d.ts

@@ -0,0 +1,16 @@
+import type { GroupListFilter, TaskListFilter } from "../parse-command";
+import type { HelpTopicMetadata } from "../help/help-types";
+import type { CommandRouterContext, RouterResponse } from "../router-types";
+export declare const orchestrationHelp: HelpTopicMetadata;
+export declare function handleDelegateRequest(context: CommandRouterContext, chatKey: string, targetAgent: string, task: string, role?: string, groupId?: string, replyContextToken?: string, accountId?: string): Promise<RouterResponse>;
+export declare function handleGroupCreate(context: CommandRouterContext, chatKey: string, title: string): Promise<RouterResponse>;
+export declare function handleGroupList(context: CommandRouterContext, chatKey: string, filter?: GroupListFilter): Promise<RouterResponse>;
+export declare function handleGroupGet(context: CommandRouterContext, chatKey: string, groupId: string): Promise<RouterResponse>;
+export declare function handleGroupCancel(context: CommandRouterContext, chatKey: string, groupId: string): Promise<RouterResponse>;
+export declare function handleGroupDelegate(context: CommandRouterContext, chatKey: string, groupId: string, targetAgent: string, task: string, role?: string, replyContextToken?: string, accountId?: string): Promise<RouterResponse>;
+export declare function handleTaskList(context: CommandRouterContext, chatKey: string, filter?: TaskListFilter): Promise<RouterResponse>;
+export declare function handleTaskGet(context: CommandRouterContext, chatKey: string, taskId: string): Promise<RouterResponse>;
+export declare function handleTaskApprove(context: CommandRouterContext, chatKey: string, taskId: string): Promise<RouterResponse>;
+export declare function handleTaskReject(context: CommandRouterContext, chatKey: string, taskId: string): Promise<RouterResponse>;
+export declare function handleTaskCancel(context: CommandRouterContext, chatKey: string, taskId: string): Promise<RouterResponse>;
+export declare function handleTasksClean(context: CommandRouterContext, chatKey: string): Promise<RouterResponse>;

package/dist/commands/handlers/permission-handler.d.ts

@@ -0,0 +1,9 @@
+import type { NonInteractivePermissions, PermissionMode, AppConfig } from "../../config/types";
+import type { HelpTopicMetadata } from "../help/help-types";
+import type { CommandRouterContext, RouterResponse } from "../router-types";
+export declare const permissionHelp: HelpTopicMetadata;
+export declare function handlePermissionStatus(context: CommandRouterContext, title: string): RouterResponse;
+export declare function handlePermissionModeSet(context: CommandRouterContext, mode: PermissionMode): Promise<RouterResponse>;
+export declare function handlePermissionAutoStatus(context: CommandRouterContext, title: string): RouterResponse;
+export declare function handlePermissionAutoSet(context: CommandRouterContext, policy: NonInteractivePermissions): Promise<RouterResponse>;
+export declare function renderPermissionStatus(config: AppConfig | undefined, title: string): string;

package/dist/commands/handlers/session-handler.d.ts

@@ -0,0 +1,37 @@
+import type { CommandRouterContext, RouterResponse, SessionInteractionOps, SessionLifecycleOps, SessionRenderRecoveryOps } from "../router-types";
+import type { PromptMediaInput, ResolvedSession } from "../../transport/types";
+import type { ToolUseEvent } from "../../channels/types.js";
+import type { PerfSpan } from "../../perf/perf-tracer";
+import type { HelpTopicMetadata } from "../help/help-types";
+import type { ChatRequestMetadata } from "../../weixin/agent/interface";
+export interface SessionHandlerContext extends CommandRouterContext {
+    lifecycle: SessionLifecycleOps;
+    interaction: SessionInteractionOps;
+    recovery: SessionRenderRecoveryOps;
+}
+export declare const sessionHelp: HelpTopicMetadata;
+export declare const nativeSessionHelp: HelpTopicMetadata;
+export declare const modeHelp: HelpTopicMetadata;
+export declare const replyModeHelp: HelpTopicMetadata;
+export declare const statusHelp: HelpTopicMetadata;
+export declare const cancelHelp: HelpTopicMetadata;
+export declare function handleSessions(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleSessionNew(context: SessionHandlerContext, chatKey: string, alias: string, agent: string, workspace: string): Promise<RouterResponse>;
+export declare function handleSessionShortcut(context: SessionHandlerContext, chatKey: string, agent: string, target: {
+    cwd?: string;
+    workspace?: string;
+}, createNew: boolean): Promise<RouterResponse>;
+export declare function handleSessionAttach(context: SessionHandlerContext, chatKey: string, alias: string, agent: string, workspace: string, transportSession: string): Promise<RouterResponse>;
+export declare function handleSessionUse(context: SessionHandlerContext, chatKey: string, alias: string): Promise<RouterResponse>;
+export declare function handleModeShow(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleModeSet(context: SessionHandlerContext, chatKey: string, modeId: string): Promise<RouterResponse>;
+export declare function handleReplyModeShow(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleReplyModeSet(context: SessionHandlerContext, chatKey: string, replyMode: "stream" | "final" | "verbose"): Promise<RouterResponse>;
+export declare function handleReplyModeReset(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleStatus(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleCancel(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleSessionReset(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleSessionTail(context: SessionHandlerContext, chatKey: string, lines?: number): Promise<RouterResponse>;
+export declare function handleSessionRemove(context: SessionHandlerContext, chatKey: string, alias: string): Promise<RouterResponse>;
+export declare function handlePromptWithSession(context: SessionHandlerContext, session: ResolvedSession, chatKey: string, text: string, reply?: (text: string) => Promise<void>, replyContextToken?: string, accountId?: string, media?: PromptMediaInput, abortSignal?: AbortSignal, onToolEvent?: (event: ToolUseEvent) => void | Promise<void>, onThought?: (chunk: string) => void | Promise<void>, perfSpan?: PerfSpan, metadata?: ChatRequestMetadata): Promise<RouterResponse>;
+export declare function handlePrompt(context: SessionHandlerContext, chatKey: string, text: string, reply?: (text: string) => Promise<void>, replyContextToken?: string, accountId?: string, media?: PromptMediaInput, abortSignal?: AbortSignal, onToolEvent?: (event: ToolUseEvent) => void | Promise<void>, onThought?: (chunk: string) => void | Promise<void>, perfSpan?: PerfSpan, metadata?: ChatRequestMetadata): Promise<RouterResponse>;

package/dist/commands/handlers/workspace-handler.d.ts

@@ -0,0 +1,8 @@
+import type { HelpTopicMetadata } from "../help/help-types";
+import type { CommandRouterContext, RouterResponse } from "../router-types";
+export declare const workspaceHelp: HelpTopicMetadata;
+export declare function handleWorkspaces(context: CommandRouterContext): RouterResponse;
+export declare function handleWorkspaceCreate(context: CommandRouterContext, workspaceName: string, cwd: string, options?: {
+    raw?: boolean;
+}): Promise<RouterResponse>;
+export declare function handleWorkspaceRemove(context: CommandRouterContext, workspaceName: string): Promise<RouterResponse>;

package/dist/commands/help/help-registry.d.ts

@@ -0,0 +1,4 @@
+import type { HelpTopicMetadata } from "./help-types";
+export declare const HELP_TOPICS: HelpTopicMetadata[];
+export declare function getHelpTopic(topic: string): HelpTopicMetadata | null;
+export declare function listHelpTopics(): HelpTopicMetadata[];

package/dist/commands/help/help-types.d.ts

@@ -0,0 +1,12 @@
+export interface HelpCommandEntry {
+    usage: string;
+    description: string;
+}
+export interface HelpTopicMetadata {
+    topic: string;
+    aliases: string[];
+    summary: string;
+    commands: HelpCommandEntry[];
+    examples?: string[];
+    notes?: string[];
+}

package/dist/commands/parse-command.d.ts

@@ -0,0 +1,175 @@
+import type { OrchestrationTaskStatus } from "../orchestration/orchestration-types";
+export interface TaskListFilter {
+    status?: OrchestrationTaskStatus;
+    stuck?: boolean;
+    sort?: "updatedAt" | "createdAt";
+    order?: "asc" | "desc";
+}
+export interface GroupListFilter {
+    status?: "pending" | "running" | "terminal";
+    stuck?: boolean;
+    sort?: "updatedAt" | "createdAt";
+    order?: "asc" | "desc";
+}
+export type ParsedCommand = {
+    kind: "help";
+    topic?: string;
+} | {
+    kind: "agents";
+} | {
+    kind: "agent.add";
+    template: string;
+} | {
+    kind: "agent.rm";
+    name: string;
+} | {
+    kind: "permission.status";
+} | {
+    kind: "permission.mode.set";
+    mode: "approve-all" | "approve-reads" | "deny-all";
+} | {
+    kind: "permission.auto.status";
+} | {
+    kind: "permission.auto.set";
+    policy: "deny" | "fail";
+} | {
+    kind: "config.show";
+} | {
+    kind: "config.set";
+    path: string;
+    value: string;
+} | {
+    kind: "workspaces";
+} | {
+    kind: "workspace.new";
+    name: string;
+    cwd: string;
+    raw?: boolean;
+} | {
+    kind: "workspace.rm";
+    name: string;
+} | {
+    kind: "sessions";
+} | {
+    kind: "status";
+} | {
+    kind: "cancel";
+} | {
+    kind: "session.reset";
+} | {
+    kind: "session.tail";
+    lines?: number;
+} | {
+    kind: "session.rm";
+    alias: string;
+} | {
+    kind: "delegate.request";
+    targetAgent: string;
+    role?: string;
+    groupId?: string;
+    task: string;
+} | {
+    kind: "groups";
+    filter?: GroupListFilter;
+} | {
+    kind: "group.new";
+    title: string;
+} | {
+    kind: "group.get";
+    groupId: string;
+} | {
+    kind: "group.cancel";
+    groupId: string;
+} | {
+    kind: "group.delegate";
+    groupId: string;
+    targetAgent: string;
+    role?: string;
+    task: string;
+} | {
+    kind: "tasks";
+    filter?: TaskListFilter;
+} | {
+    kind: "tasks.clean";
+} | {
+    kind: "task.get";
+    taskId: string;
+} | {
+    kind: "task.approve";
+    taskId: string;
+} | {
+    kind: "task.reject";
+    taskId: string;
+} | {
+    kind: "task.cancel";
+    taskId: string;
+} | {
+    kind: "mode.show";
+} | {
+    kind: "mode.set";
+    modeId: string;
+} | {
+    kind: "replymode.show";
+} | {
+    kind: "replymode.set";
+    replyMode: "stream" | "final" | "verbose";
+} | {
+    kind: "replymode.reset";
+} | {
+    kind: "session.use";
+    alias: string;
+} | {
+    kind: "session.new";
+    alias: string;
+    agent: string;
+    workspace: string;
+} | {
+    kind: "session.shortcut";
+    agent: string;
+    cwd?: string;
+    workspace?: string;
+} | {
+    kind: "session.shortcut.new";
+    agent: string;
+    cwd?: string;
+    workspace?: string;
+} | {
+    kind: "session.attach";
+    alias: string;
+    agent: string;
+    workspace: string;
+    transportSession: string;
+} | {
+    kind: "session.native.list";
+    agent?: string;
+    cwd?: string;
+    workspace?: string;
+    all?: boolean;
+    cursor?: string;
+} | {
+    kind: "session.native.select";
+    identifier: string;
+    alias?: string;
+} | {
+    kind: "session.native.attach";
+    identifier: string;
+    alias?: string;
+} | {
+    kind: "later.help";
+} | {
+    kind: "later.create";
+    tokens: string[];
+} | {
+    kind: "later.list";
+} | {
+    kind: "later.cancel";
+    id: string;
+} | {
+    kind: "invalid";
+    text: string;
+    recognizedCommand: string;
+} | {
+    kind: "prompt";
+    text: string;
+};
+export declare function parseCommand(input: string): ParsedCommand;

package/dist/commands/router-types.d.ts

@@ -0,0 +1,144 @@
+import type { ConfigStore } from "../config/config-store";
+import type { AppConfig } from "../config/types";
+import type { AppLogger } from "../logging/app-logger";
+import type { OrchestrationService } from "../orchestration/orchestration-service";
+import type { SessionService } from "../sessions/session-service";
+import type { PromptMediaInput, ReplyQuotaContext, SessionTransport } from "../transport/types";
+import type { QuotaManager } from "../weixin/messaging/quota-manager.js";
+import type { ToolUseEvent } from "../channels/types.js";
+import type { PerfSpan } from "../perf/perf-tracer";
+export interface RouterResponse {
+    text?: string;
+}
+export interface PromptRouteMetadata {
+    chatKey: string;
+    replyContextToken?: string;
+    accountId?: string;
+}
+export interface CoordinatorTaskQuestionRef {
+    taskId: string;
+    questionId: string;
+}
+export interface ActiveHumanQuestionPackageContext {
+    packageId: string;
+    promptText: string;
+    awaitingReplyMessageId?: string;
+    deliveredChatKey?: string;
+    deliveryAccountId?: string;
+    routeReplyContextToken?: string;
+    deliveredAt?: string;
+    openTaskIds: string[];
+    messageTaskQuestions?: Array<{
+        taskId: string;
+        questionId: string;
+    }>;
+    openTaskQuestions?: Array<{
+        taskId: string;
+        questionId: string;
+        question: string;
+        whyBlocked: string;
+        whatIsNeeded: string;
+    }>;
+    queuedCount: number;
+}
+export type WritableConfigStore = Pick<ConfigStore, "load" | "save" | "upsertWorkspace" | "removeWorkspace" | "upsertAgent" | "removeAgent" | "updateTransport" | "updateChannel">;
+export interface CommandRouterContext {
+    sessions: SessionService;
+    transport: SessionTransport;
+    orchestration?: OrchestrationRouterOps;
+    config?: AppConfig;
+    configStore?: WritableConfigStore;
+    logger: AppLogger;
+    replaceConfig: (updated: AppConfig) => void;
+    quota?: QuotaManager;
+    /**
+     * Resolves the render format for a chat's `/ssn` native session list. Backed
+     * by the channel's declared capability (see MessageChannelRuntime
+     * `nativeSessionListFormat`); handlers default to "table" when unset.
+     */
+    resolveNativeSessionListFormat?: (chatKey: string) => "cards" | "table";
+}
+export interface OrchestrationRouterOps {
+    createGroup: OrchestrationService["createGroup"];
+    getGroupSummary: OrchestrationService["getGroupSummary"];
+    listGroupSummaries: OrchestrationService["listGroupSummaries"];
+    cancelGroup: OrchestrationService["cancelGroup"];
+    requestDelegate: OrchestrationService["requestDelegate"];
+    getTask: OrchestrationService["getTask"];
+    listTasks: OrchestrationService["listTasks"];
+    requestTaskCancellation: OrchestrationService["requestTaskCancellation"];
+    cancelTask: OrchestrationService["cancelTask"];
+    approveTask: OrchestrationService["approveTask"];
+    cleanTasks: OrchestrationService["cleanTasks"];
+    listSessionBlockingTasks: OrchestrationService["listSessionBlockingTasks"];
+    purgeSessionReferences: OrchestrationService["purgeSessionReferences"];
+    listPendingTaskNotices: OrchestrationService["listPendingTaskNotices"];
+    markTaskNoticeDelivered: OrchestrationService["markTaskNoticeDelivered"];
+    markTaskNoticeFailed: OrchestrationService["markTaskNoticeFailed"];
+    listPendingCoordinatorGroups?: OrchestrationService["listPendingCoordinatorGroups"];
+    markCoordinatorGroupsInjected?: OrchestrationService["markCoordinatorGroupsInjected"];
+    markCoordinatorGroupsInjectionFailed?: OrchestrationService["markCoordinatorGroupsInjectionFailed"];
+    listPendingCoordinatorResults: OrchestrationService["listPendingCoordinatorResults"];
+    listPendingCoordinatorBlockers?: OrchestrationService["listPendingCoordinatorBlockers"];
+    listContestedCoordinatorResults?: OrchestrationService["listContestedCoordinatorResults"];
+    markCoordinatorResultsInjected?: OrchestrationService["markCoordinatorResultsInjected"];
+    markTaskInjectionApplied: OrchestrationService["markTaskInjectionApplied"];
+    markTaskInjectionFailed: OrchestrationService["markTaskInjectionFailed"];
+    recordCoordinatorRouteContext?: OrchestrationService["recordCoordinatorRouteContext"];
+    claimActiveHumanReply?: OrchestrationService["claimActiveHumanReply"];
+    getActiveHumanQuestionPackage?: (coordinatorSession: string) => Promise<ActiveHumanQuestionPackageContext | null>;
+    reserveLogicalTransportSession?: OrchestrationService["reserveLogicalTransportSession"];
+}
+export interface SessionLifecycleOps {
+    resolveSession: (alias: string, agent: string, workspace: string, transportSession: string) => import("../transport/types").ResolvedSession;
+    ensureTransportSession: (session: import("../transport/types").ResolvedSession, reply?: (text: string) => Promise<void>, perfSpan?: PerfSpan) => Promise<void>;
+    checkTransportSession: (session: import("../transport/types").ResolvedSession) => Promise<boolean>;
+    markSessionReady?: (session: import("../transport/types").ResolvedSession) => void;
+    reserveTransportSession: (transportSession: string) => Promise<() => Promise<void>>;
+    handleSessionShortcut: (chatKey: string, agent: string, target: {
+        cwd?: string;
+        workspace?: string;
+    }, createNew: boolean, reply?: (text: string) => Promise<void>) => Promise<RouterResponse>;
+    resetCurrentSession: (chatKey: string, reply?: (text: string) => Promise<void>) => Promise<RouterResponse>;
+    refreshSessionTransportAgentCommand: (alias: string) => Promise<void>;
+}
+export interface SessionInteractionOps {
+    setModeTransportSession: (session: import("../transport/types").ResolvedSession, modeId: string) => Promise<void>;
+    cancelTransportSession: (session: import("../transport/types").ResolvedSession) => Promise<{
+        cancelled: boolean;
+        message: string;
+    }>;
+    promptTransportSession: (session: import("../transport/types").ResolvedSession, text: string, reply?: (text: string) => Promise<void>, replyContext?: ReplyQuotaContext, media?: PromptMediaInput, abortSignal?: AbortSignal, onToolEvent?: (event: ToolUseEvent) => void | Promise<void>, onThought?: (chunk: string) => void | Promise<void>, perfSpan?: PerfSpan) => Promise<{
+        text: string;
+    }>;
+}
+export interface SessionRenderRecoveryOps {
+    renderSessionCreationError: (session: import("../transport/types").ResolvedSession, error: unknown) => RouterResponse;
+    renderSessionCreationVerificationError: (session: import("../transport/types").ResolvedSession) => RouterResponse;
+    tryRecoverMissingSession: (session: import("../transport/types").ResolvedSession, error: unknown) => Promise<import("../transport/types").ResolvedSession | null>;
+    renderTransportError: (session: import("../transport/types").ResolvedSession, error: unknown) => RouterResponse;
+}
+export interface SessionShortcutOps {
+    resolveSession: (alias: string, agent: string, workspace: string, transportSession: string) => import("../transport/types").ResolvedSession;
+    ensureTransportSession: (session: import("../transport/types").ResolvedSession, reply?: (text: string) => Promise<void>, perfSpan?: PerfSpan) => Promise<void>;
+    checkTransportSession: (session: import("../transport/types").ResolvedSession) => Promise<boolean>;
+    reserveTransportSession: (transportSession: string) => Promise<() => Promise<void>>;
+    refreshSessionTransportAgentCommand: (alias: string) => Promise<void>;
+}
+export interface SessionRecoveryOps {
+    resolveSessionAgentCommand: (session: import("../transport/types").ResolvedSession) => Promise<string | undefined | null>;
+    setSessionTransportAgentCommand: (alias: string, command: string) => Promise<void>;
+    getSession: (alias: string) => Promise<import("../transport/types").ResolvedSession | null>;
+}
+export interface SessionResetOps {
+    ensureTransportSession: (session: import("../transport/types").ResolvedSession, reply?: (text: string) => Promise<void>, perfSpan?: PerfSpan) => Promise<void>;
+    checkTransportSession: (session: import("../transport/types").ResolvedSession) => Promise<boolean>;
+    reserveTransportSession: (transportSession: string) => Promise<() => Promise<void>>;
+    resolveSession: (alias: string, agent: string, workspace: string, transportSession: string) => import("../transport/types").ResolvedSession;
+    refreshSessionTransportAgentCommand: (alias: string) => Promise<void>;
+    now: () => number;
+}
+export type ScheduledRouterOps = Pick<import("../scheduled/scheduled-service").ScheduledTaskService, "createTask" | "listPending" | "cancelPending">;
+export interface ScheduledDeliveryCapabilityOps {
+    supportsScheduledMessages(chatKey: string): boolean;
+}

package/dist/commands/workspace-name.d.ts

@@ -0,0 +1,4 @@
+export declare function sanitizeWorkspaceName(input: string, fallback?: string): string;
+export declare function allocateWorkspaceName(base: string, existing: Record<string, unknown>): string;
+export declare function isWorkspaceNameValid(input: string): boolean;
+export declare function quoteWorkspaceNameIfNeeded(input: string): string;

package/dist/commands/workspace-path.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeWorkspacePath(input: string): string;
+export declare function basenameForWorkspacePath(input: string): string;
+export declare function sameWorkspacePath(left: string, right: string): boolean;
+export declare function pathExists(filePath: string): Promise<boolean>;

package/dist/config/agent-templates.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "./types";
+export declare function getAgentTemplate(name: string): AgentConfig | null;
+export declare function listAgentTemplates(): string[];
+export declare function sameAgentConfig(left: AgentConfig, right: AgentConfig): boolean;

package/dist/config/config-store.d.ts

@@ -0,0 +1,13 @@
+import type { AppConfig } from "./types";
+export declare class ConfigStore {
+    private readonly path;
+    constructor(path: string);
+    load(): Promise<AppConfig>;
+    save(config: AppConfig): Promise<void>;
+    upsertWorkspace(name: string, cwd: string, description?: string): Promise<AppConfig>;
+    removeWorkspace(name: string): Promise<AppConfig>;
+    upsertAgent(name: string, agent: AppConfig["agents"][string]): Promise<AppConfig>;
+    removeAgent(name: string): Promise<AppConfig>;
+    updateTransport(transport: Partial<AppConfig["transport"]>): Promise<AppConfig>;
+    updateChannel(channel: Partial<AppConfig["channel"]>): Promise<AppConfig>;
+}

package/dist/config/load-config.d.ts

@@ -0,0 +1,10 @@
+import type { AppConfig, LoggingLevel } from "./types";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function parsePositiveOptionalNumber(value: unknown, path: string, defaultValue: number): number;
+export declare function loadConfig(path: string): Promise<AppConfig>;
+export declare function loadConfig(path: string, options: {
+    defaultLoggingLevel?: LoggingLevel;
+}): Promise<AppConfig>;
+export declare function parseConfig(raw: unknown, options?: {
+    defaultLoggingLevel?: LoggingLevel;
+}): AppConfig;

package/dist/config/resolve-agent-command.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveAgentCommand(driver: string, command: string | undefined): string | undefined;
+export declare function isLegacyCodexCommand(command: string): boolean;

package/dist/formatting/render-text.d.ts

@@ -0,0 +1,23 @@
+import type { AppConfig } from "../config/types";
+import type { OrchestrationGroupRecord, OrchestrationGroupSummary, OrchestrationTaskRecord } from "../orchestration/orchestration-types";
+export declare function renderAgents(config: AppConfig): string;
+export declare function renderWorkspaces(config: AppConfig): string;
+export declare function renderOrchestrationUnavailable(): string;
+export declare function renderDelegateSuccess(taskId: string, workerSession: string): string;
+export declare function renderGroupCreated(group: OrchestrationGroupRecord): string;
+export declare function renderGroupList(groups: OrchestrationGroupSummary[]): string;
+export declare function renderGroupSummary(summary: OrchestrationGroupSummary): string;
+export declare function renderGroupCancelSuccess(input: {
+    summary: OrchestrationGroupSummary;
+    cancelledTaskIds: string[];
+    skippedTaskIds: string[];
+}): string;
+export declare function renderTaskList(tasks: OrchestrationTaskRecord[]): string;
+export declare function renderTaskSummary(task: OrchestrationTaskRecord): string;
+export declare function renderTaskCancelSuccess(task: OrchestrationTaskRecord): string;
+export declare function renderTaskApprovalSuccess(task: OrchestrationTaskRecord): string;
+export declare function renderTaskRejectSuccess(task: OrchestrationTaskRecord): string;
+export declare function renderTaskConfirmationUnavailable(task: OrchestrationTaskRecord): string;
+export declare function renderTasksCleanResult(removedTasks: number, removedBindings: number): string;
+export declare function renderTaskProgress(task: OrchestrationTaskRecord, summary: string): string;
+export declare function renderTaskHeartbeat(task: OrchestrationTaskRecord, elapsedSeconds: number): string;

package/dist/orchestration/async-mutex.d.ts

@@ -0,0 +1,4 @@
+export declare class AsyncMutex {
+    private tail;
+    run<T>(critical: () => Promise<T>): Promise<T>;
+}

package/dist/orchestration/build-coordinator-prompt.d.ts

@@ -0,0 +1,66 @@
+import type { OrchestrationGroupRecord, OrchestrationTaskRecord } from "./orchestration-types";
+interface ActiveHumanQuestionPackageView {
+    packageId: string;
+    promptText: string;
+    awaitingReplyMessageId?: string;
+    deliveredChatKey?: string;
+    deliveryAccountId?: string;
+    routeReplyContextToken?: string;
+    deliveredAt?: string;
+    openTaskIds: string[];
+    messageTaskQuestions?: Array<{
+        taskId: string;
+        questionId: string;
+    }>;
+    openTaskQuestions?: Array<{
+        taskId: string;
+        questionId: string;
+        question: string;
+        whyBlocked: string;
+        whatIsNeeded: string;
+    }>;
+    queuedCount: number;
+}
+export declare function shouldBindHumanReply(input: {
+    chatKey?: string;
+    accountId?: string;
+    replyContextToken?: string;
+    activePackage?: {
+        awaitingReplyMessageId?: string;
+        deliveredChatKey?: string;
+        deliveryAccountId?: string;
+        routeReplyContextToken?: string;
+        messageTaskQuestions?: Array<{
+            taskId: string;
+            questionId: string;
+        }>;
+    } | null;
+}): boolean;
+export declare function buildCoordinatorPrompt(input: {
+    orchestration: {
+        listPendingCoordinatorGroups?: (coordinatorSession: string) => Promise<OrchestrationGroupRecord[]>;
+        listPendingCoordinatorResults: (coordinatorSession: string) => Promise<OrchestrationTaskRecord[]>;
+        listPendingCoordinatorBlockers?: (coordinatorSession: string) => Promise<OrchestrationTaskRecord[]>;
+        listContestedCoordinatorResults?: (coordinatorSession: string) => Promise<OrchestrationTaskRecord[]>;
+        getActiveHumanQuestionPackage?: (coordinatorSession: string) => Promise<ActiveHumanQuestionPackageView | null>;
+    };
+    coordinatorSession: string;
+    chatKey?: string;
+    accountId?: string;
+    replyContextToken?: string;
+    userText?: string;
+    maxPromptLength?: number;
+}): Promise<{
+    promptText: string;
+    taskIds: string[];
+    groupIds: string[];
+    claimHumanReply?: {
+        coordinatorSession: string;
+        chatKey: string;
+        packageId: string;
+        messageId: string;
+        accountId?: string;
+        replyContextToken?: string;
+    };
+}>;
+export {};