weacpx 0.5.2 → 0.6.1

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

@@ -0,0 +1,471 @@
+import type { AppConfig } from "../config/types";
+import type { AppLogger } from "../logging/app-logger";
+import type { AppState } from "../state/types";
+import type { ExternalCoordinatorRecord, OrchestrationCoordinatorRouteContextRecord, OrchestrationGroupRecord, OrchestrationGroupSummary, OrchestrationSourceKind, OrchestrationTaskEventRecord, OrchestrationTaskRecord, OrchestrationTaskStatus } from "./orchestration-types";
+import { AsyncMutex } from "./async-mutex";
+export interface RequestDelegateInput {
+    sourceHandle: string;
+    sourceKind: OrchestrationSourceKind;
+    coordinatorSession: string;
+    workspace: string;
+    cwd?: string;
+    targetAgent: string;
+    task: string;
+    role?: string;
+    groupId?: string;
+    chatKey?: string;
+    replyContextToken?: string;
+    accountId?: string;
+    parallel?: boolean;
+}
+export interface RequestDelegateRpcInput {
+    sourceHandle: string;
+    targetAgent: string;
+    task: string;
+    cwd?: string;
+    role?: string;
+    groupId?: string;
+    parallel?: boolean;
+}
+export interface RequestDelegateResult {
+    taskId: string;
+    status: OrchestrationTaskStatus;
+    workerSession: string;
+}
+export interface RegisterExternalCoordinatorInput {
+    coordinatorSession: string;
+    workspace?: string;
+    defaultTargetAgent?: string;
+}
+export interface RequestDelegateRpcResult {
+    taskId: string;
+    status: Extract<OrchestrationTaskStatus, "needs_confirmation" | "running" | "queued">;
+    workerSession?: string;
+}
+export interface RecordWorkerReplyInput {
+    taskId: string;
+    sourceHandle: string;
+    status?: Extract<OrchestrationTaskStatus, "completed" | "failed" | "cancelled">;
+    summary?: string;
+    resultText?: string;
+}
+export interface RecordTaskNoticeDeliveryInput {
+    taskId: string;
+    deliveryAccountId: string;
+}
+export interface MarkTaskErrorInput {
+    taskId: string;
+    errorMessage: string;
+}
+export interface CancelTaskInput {
+    taskId: string;
+    sourceHandle?: string;
+    coordinatorSession?: string;
+}
+export interface CancelWorkerTaskRequest {
+    taskId: string;
+    workerSession: string;
+    workspace: string;
+    cwd?: string;
+    targetAgent: string;
+}
+export interface ResumeWorkerTaskRequest {
+    taskId: string;
+    workerSession: string;
+    coordinatorSession: string;
+    workspace: string;
+    cwd?: string;
+    targetAgent: string;
+    answer: string;
+}
+export interface WakeCoordinatorRequest {
+    coordinatorSession: string;
+}
+export interface DeliverCoordinatorMessageRequest {
+    coordinatorSession: string;
+    chatKey: string;
+    accountId?: string;
+    replyContextToken?: string;
+    text: string;
+}
+type FrozenCoordinatorDeliveryRoute = Pick<DeliverCoordinatorMessageRequest, "chatKey" | "accountId" | "replyContextToken">;
+export interface ConfirmTaskInput {
+    taskId: string;
+    coordinatorSession: string;
+}
+export interface WorkerRaiseQuestionInput {
+    taskId: string;
+    sourceHandle: string;
+    question: string;
+    whyBlocked: string;
+    whatIsNeeded: string;
+}
+export interface CoordinatorTaskQuestionRef {
+    taskId: string;
+    questionId: string;
+}
+export interface CoordinatorRequestHumanInputResult {
+    packageId?: string;
+    queuedTaskIds: string[];
+}
+export interface RetryHumanQuestionPackageDeliveryResult {
+    packageId: string;
+    messageId: string;
+}
+export interface ClaimedActiveHumanReply {
+    coordinatorSession: string;
+    packageId: string;
+    messageId: string;
+    chatKey: string;
+    promptText: string;
+    taskQuestions: CoordinatorTaskQuestionRef[];
+    queuedCount: number;
+}
+export interface ActiveHumanQuestionPackage {
+    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 interface OrchestrationServiceDeps {
+    now: () => Date;
+    createId: () => string;
+    loadState: () => Promise<AppState>;
+    saveState: (state: AppState) => Promise<void>;
+    stateMutex?: AsyncMutex;
+    config: AppConfig;
+    ensureWorkerSession: (request: EnsureWorkerSessionRequest) => Promise<string>;
+    dispatchWorkerTask: (request: DispatchWorkerTaskRequest) => Promise<void>;
+    cancelWorkerTask?: (request: CancelWorkerTaskRequest) => Promise<void>;
+    resumeWorkerTask?: (request: ResumeWorkerTaskRequest) => Promise<void>;
+    closeWorkerSession?: (request: {
+        workerSession: string;
+        coordinatorSession: string;
+        workspace: string;
+        cwd?: string;
+        targetAgent: string;
+        role?: string;
+    }) => Promise<void>;
+    wakeCoordinatorSession?: (request: WakeCoordinatorRequest) => Promise<void>;
+    deliverCoordinatorMessage?: (request: DeliverCoordinatorMessageRequest) => Promise<FrozenCoordinatorDeliveryRoute | void>;
+    interruptWorkerTask?: (request: CancelWorkerTaskRequest) => Promise<void>;
+    findReusableWorkerSession?: (request: ReusableWorkerLookupRequest) => Promise<string | null | undefined> | string | null | undefined;
+    logger?: AppLogger;
+}
+export interface EnsureWorkerSessionRequest {
+    workerSession: string;
+    sourceHandle: string;
+    sourceKind: OrchestrationSourceKind;
+    coordinatorSession: string;
+    workspace: string;
+    cwd?: string;
+    targetAgent: string;
+    role?: string;
+}
+export interface ReusableWorkerLookupRequest {
+    sourceHandle: string;
+    sourceKind: OrchestrationSourceKind;
+    coordinatorSession: string;
+    workspace: string;
+    cwd?: string;
+    targetAgent: string;
+    role?: string;
+}
+export interface DispatchWorkerTaskRequest {
+    taskId: string;
+    workerSession: string;
+    coordinatorSession: string;
+    workspace: string;
+    cwd?: string;
+    targetAgent: string;
+    role?: string;
+    task: string;
+}
+export interface CancelGroupResult {
+    summary: OrchestrationGroupSummary;
+    cancelledTaskIds: string[];
+    skippedTaskIds: string[];
+}
+export interface CleanTasksResult {
+    removedTasks: number;
+    removedBindings: number;
+}
+export type ResetGcTrigger = "startup" | "interval";
+export interface PurgeExpiredResetCoordinatorsInput {
+    cutoffDays: number;
+    trigger: ResetGcTrigger;
+}
+export interface PurgeExpiredResetCoordinatorsResult {
+    candidates: number;
+    purgedCoordinators: number;
+    removed: {
+        tasks: number;
+        workerBindings: number;
+        groups: number;
+        coordinatorRoutes: number;
+        humanQuestionPackages: number;
+        coordinatorQuestionState: number;
+    };
+}
+export interface OrchestrationTaskFilter {
+    sourceHandle?: string;
+    coordinatorSession?: string;
+    workspace?: string;
+    targetAgent?: string;
+    role?: string;
+    status?: OrchestrationTaskStatus;
+    stuck?: boolean;
+    sort?: "updatedAt" | "createdAt";
+    order?: "asc" | "desc";
+}
+export interface WatchTaskInput {
+    coordinatorSession: string;
+    taskId: string;
+    afterSeq?: number;
+    mode?: "next_event" | "until_attention_or_terminal";
+    includeProgress?: boolean;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+export interface WatchTaskResult {
+    status: "event" | "attention_required" | "terminal" | "timeout" | "not_found";
+    task: OrchestrationTaskRecord | null;
+    events: OrchestrationTaskEventRecord[];
+    nextAfterSeq: number;
+    historyTruncated?: boolean;
+}
+export declare function clampWatchTimeout(value: number | undefined): number;
+export interface OrchestrationGroupListFilter {
+    coordinatorSession: string;
+    status?: "pending" | "running" | "terminal";
+    stuck?: boolean;
+    sort?: "updatedAt" | "createdAt";
+    order?: "asc" | "desc";
+}
+export declare class OrchestrationService {
+    private readonly deps;
+    private readonly stateMutex;
+    private readonly pendingWorkerSessions;
+    private readonly pendingLogicalTransportSessions;
+    /**
+     * Per-agent counter for parallel tasks that have passed the capacity gate
+     * but have not yet been persisted as `running` in state (i.e., they are
+     * between the gate mutate and the inner persist mutate). This closes the
+     * TOCTOU window: a concurrent `reconcileParallelSlots` Phase 3 or a second
+     * delegation can see these in-flight starts as occupied slots.
+     */
+    private readonly pendingParallelStarts;
+    constructor(deps: OrchestrationServiceDeps);
+    private mutate;
+    registerExternalCoordinator(input: RegisterExternalCoordinatorInput): Promise<ExternalCoordinatorRecord>;
+    createGroup(input: {
+        coordinatorSession: string;
+        title: string;
+    }): Promise<OrchestrationGroupRecord>;
+    getGroupSummary(input: {
+        groupId: string;
+        coordinatorSession: string;
+    }): Promise<OrchestrationGroupSummary | null>;
+    listGroupSummaries(input: OrchestrationGroupListFilter): Promise<OrchestrationGroupSummary[]>;
+    cancelGroup(input: {
+        groupId: string;
+        coordinatorSession: string;
+    }): Promise<CancelGroupResult>;
+    requestDelegate(input: RequestDelegateInput): Promise<RequestDelegateResult>;
+    requestDelegate(input: RequestDelegateRpcInput): Promise<RequestDelegateRpcResult>;
+    private requestDelegateForHuman;
+    requestDelegateFromRpc(input: RequestDelegateRpcInput): Promise<RequestDelegateRpcResult>;
+    private runAutoRunRpcWorkerTask;
+    private completeAutoRunStartupCancellation;
+    private cleanupAutoRunStartupBinding;
+    recordWorkerReply(input: RecordWorkerReplyInput): Promise<OrchestrationTaskRecord>;
+    markTaskNoticePending(taskId: string): Promise<OrchestrationTaskRecord>;
+    markTaskNoticeDelivered(taskId: string, deliveryAccountId: string): Promise<OrchestrationTaskRecord>;
+    markTaskNoticeFailed(input: MarkTaskErrorInput): Promise<OrchestrationTaskRecord>;
+    listPendingTaskNotices(): Promise<OrchestrationTaskRecord[]>;
+    recordTaskNoticeDelivery(input: RecordTaskNoticeDeliveryInput): Promise<OrchestrationTaskRecord>;
+    getTask(taskId: string): Promise<OrchestrationTaskRecord | null>;
+    watchTask(input: WatchTaskInput): Promise<WatchTaskResult>;
+    recordCoordinatorRouteContext(input: {
+        coordinatorSession: string;
+        chatKey: string;
+        sessionAlias?: string;
+        accountId?: string;
+        replyContextToken?: string;
+        channel?: string;
+        chatType?: "direct" | "group";
+        senderId?: string;
+        senderName?: string;
+        groupId?: string;
+        isOwner?: boolean;
+    }): Promise<OrchestrationCoordinatorRouteContextRecord>;
+    workerRaiseQuestion(input: WorkerRaiseQuestionInput): Promise<{
+        taskId: string;
+        questionId: string;
+        status: "blocked";
+    }>;
+    coordinatorAnswerQuestion(input: {
+        coordinatorSession: string;
+        taskId: string;
+        questionId: string;
+        answer: string;
+    }): Promise<OrchestrationTaskRecord>;
+    coordinatorRetractAnswer(input: {
+        coordinatorSession: string;
+        taskId: string;
+        questionId: string;
+    }): Promise<OrchestrationTaskRecord>;
+    coordinatorRequestHumanInput(input: {
+        coordinatorSession: string;
+        taskQuestions: CoordinatorTaskQuestionRef[];
+        promptText: string;
+        expectedActivePackageId?: string;
+    }): Promise<CoordinatorRequestHumanInputResult>;
+    retryHumanQuestionPackageDelivery(input: {
+        coordinatorSession: string;
+        packageId: string;
+        messageId: string;
+    }): Promise<RetryHumanQuestionPackageDeliveryResult>;
+    claimActiveHumanReply(input: {
+        coordinatorSession: string;
+        chatKey: string;
+        packageId: string;
+        messageId: string;
+        accountId?: string;
+        replyContextToken?: string;
+    }): Promise<ClaimedActiveHumanReply | null>;
+    getActiveHumanQuestionPackage(coordinatorSession: string): Promise<ActiveHumanQuestionPackage | null>;
+    coordinatorReviewContestedResult(input: {
+        coordinatorSession: string;
+        taskId: string;
+        reviewId: string;
+        decision: "accept" | "discard";
+    }): Promise<OrchestrationTaskRecord>;
+    listTasks(filter?: OrchestrationTaskFilter): Promise<OrchestrationTaskRecord[]>;
+    cleanTasks(coordinatorSession: string): Promise<CleanTasksResult>;
+    listSessionBlockingTasks(transportSession: string): Promise<OrchestrationTaskRecord[]>;
+    purgeSessionReferences(transportSession: string): Promise<CleanTasksResult>;
+    purgeExpiredResetCoordinators(input: PurgeExpiredResetCoordinatorsInput): Promise<PurgeExpiredResetCoordinatorsResult>;
+    listPendingCoordinatorResults(coordinatorSession: string): Promise<OrchestrationTaskRecord[]>;
+    listPendingCoordinatorBlockers(coordinatorSession: string): Promise<OrchestrationTaskRecord[]>;
+    listContestedCoordinatorResults(coordinatorSession: string): Promise<OrchestrationTaskRecord[]>;
+    listPendingCoordinatorGroups(coordinatorSession: string): Promise<OrchestrationGroupRecord[]>;
+    markCoordinatorResultsInjected(taskIds: string[]): Promise<void>;
+    markCoordinatorGroupsInjected(groupIds: string[]): Promise<void>;
+    markCoordinatorGroupsInjectionFailed(groupIds: string[], errorMessage: string): Promise<void>;
+    markTaskInjectionApplied(taskIds: string[]): Promise<void>;
+    markTaskInjectionFailed(taskIds: string[], errorMessage: string): Promise<void>;
+    recordTaskProgress(taskId: string, summary?: string): Promise<OrchestrationTaskRecord>;
+    listHeartbeatTasks(thresholdSeconds: number): Promise<OrchestrationTaskRecord[]>;
+    cancelTask(input: CancelTaskInput): Promise<OrchestrationTaskRecord>;
+    requestTaskCancellation(input: CancelTaskInput): Promise<OrchestrationTaskRecord>;
+    completeTaskCancellation(taskId: string): Promise<OrchestrationTaskRecord>;
+    failTaskCancellation(taskId: string, errorMessage: string): Promise<OrchestrationTaskRecord>;
+    approveTask(input: ConfirmTaskInput): Promise<OrchestrationTaskRecord>;
+    /**
+     * Resolves the transport worker-session name for a delegation.
+     *
+     * For parallel delegations a fresh unique name is minted by appending a
+     * `:p-<id>` suffix. That suffix is purely a naming convention for
+     * human/log readability — it MUST NOT be treated as the source of truth
+     * for ephemerality. `WorkerBindingRecord.ephemeral` is the authoritative
+     * marker for whether a session is an ephemeral parallel slot; no code
+     * should detect ephemerality by string-matching the session name.
+     */
+    private resolveWorkerSession;
+    private reserveProposedWorkerSession;
+    private ensureReservedWorkerSession;
+    reserveLogicalTransportSession(transportSession: string): Promise<() => Promise<void>>;
+    private buildGroupSummary;
+    private canInjectGroupIntoCoordinator;
+    private canInjectTaskIntoCoordinator;
+    private resolveRpcSourceContext;
+    private resolveRpcTargetLocation;
+    private assertRpcRequestAllowed;
+    private validateRequest;
+    private validateRpcRequest;
+    private normalizeWorkingDirectory;
+    private workspaceLabelFromCwd;
+    private cwdWorkerSessionPart;
+    private normalizeRole;
+    private normalizeGroupId;
+    private assertCoordinatorQuestionMatch;
+    private assertTaskAnswerIsWithinAwaitedHumanSnapshot;
+    private matchesFilter;
+    private isTerminalStatus;
+    private assertCoordinatorOwnership;
+    private assertNeedsConfirmation;
+    private assertGroupOwnership;
+    private ensureHumanQuestionPackages;
+    private ensureCoordinatorQuestionState;
+    private ensureCoordinatorRoutes;
+    private isExternalCoordinatorSession;
+    private assertWorkerSessionDoesNotConflictExternalCoordinator;
+    private assertWorkerSessionAvailable;
+    private hasActiveTaskWorkerSession;
+    /** Count parallel-slot tasks currently holding an acpx session for an agent. */
+    private countActiveParallelSlots;
+    /**
+     * Whether a new parallel task for this agent may start now, or must be queued.
+     * The cap comes from the `orchestration.maxParallelTasksPerAgent` config key.
+     */
+    private canStartParallelTask;
+    /**
+     * Idempotent reconciliation for parallel slots:
+     *  1. close acpx sessions of ephemeral parallel tasks that have terminated
+     *     (terminal status, no pending review), and drop their worker bindings;
+     *  2. drain `queued` parallel tasks into running, up to the per-agent cap.
+     * Safe to call repeatedly; close failures are logged and never block draining.
+     */
+    reconcileParallelSlots(): Promise<void>;
+    private assertProposedWorkerSessionDoesNotConflictExternalCoordinator;
+    private ensureExternalCoordinators;
+    private ensureGroups;
+    private removeEmptyGroupsForCoordinator;
+    private removeCoordinatorMetadataIfUnused;
+    private isResetCoordinatorSession;
+    private collectResetCoordinatorCandidates;
+    private parseDateMs;
+    private resolveResetCoordinatorActivityAtMs;
+    private cascadeRemoveCoordinatorRecords;
+    private bumpGroupUpdated;
+    private getLatestDeliveredPackageMessage;
+    private snapshotCoordinatorDeliveryRoute;
+    private normalizeFrozenDeliveryRoute;
+    private serializeFrozenDeliveryRoute;
+    private resolveFrozenPackageMessageRoute;
+    private deliverHumanQuestionPackageMessage;
+    private recordPackageMessageDeliverySuccess;
+    private recordPackageMessageDeliveryError;
+    private recordOpenQuestionWakeError;
+    private handoffQueuedQuestions;
+    private restoreBlockedQuestionAfterResumeFailure;
+    private captureTaskHumanPackageContext;
+    private resolveTaskFromHumanPackage;
+    private detachTaskFromQuestionFlows;
+    private reopenActiveHumanPackageForTask;
+    private buildReplacementOpenQuestion;
+    private resolveLiveMessageTaskQuestions;
+    private logEvent;
+    private taskContext;
+    private groupContext;
+    private startWorkerCancellation;
+    private appendTaskEvent;
+}
+export {};

package/dist/orchestration/progress-line-parser.d.ts

@@ -0,0 +1,19 @@
+export declare const MAX_PROGRESS_SUMMARY_LENGTH = 500;
+export interface ProgressLineFeedOptions {
+    /**
+     * True when the caller is passing a complete semantic text segment rather
+     * than arbitrary stream bytes. This lets progress paragraphs without a
+     * trailing newline surface immediately while keeping the default raw-stream
+     * parser conservative about partial chunks.
+     */
+    segmentComplete?: boolean;
+}
+export declare class ProgressLineBuffer {
+    private pending;
+    feed(segment: string, options?: ProgressLineFeedOptions): string[];
+    flush(): string[];
+    private extractLine;
+    private trimPendingIfHopeless;
+}
+export declare function sanitizeProgressSummary(summary: string): string;
+export declare function stripProgressLines(text: string): string;

package/dist/orchestration/render-delegate-group-result.d.ts

@@ -0,0 +1,6 @@
+import type { OrchestrationGroupRecord, OrchestrationTaskRecord } from "./orchestration-types";
+export declare function renderDelegateGroupResult(group: OrchestrationGroupRecord, tasks: OrchestrationTaskRecord[]): string;
+export declare function renderDelegateGroupResultBlocks(groups: Array<{
+    group: OrchestrationGroupRecord;
+    tasks: OrchestrationTaskRecord[];
+}>): string;

package/dist/orchestration/render-delegate-question-package.d.ts

@@ -0,0 +1,21 @@
+interface BlockedTaskInput {
+    taskId: string;
+    workerSession?: string;
+    targetAgent: string;
+    question: string;
+    whyBlocked: string;
+    whatIsNeeded: string;
+}
+interface ContestedReviewInput {
+    taskId: string;
+    reviewId: string;
+    resultId: string;
+    resultText: string;
+}
+export interface RenderDelegateQuestionPackageInput {
+    coordinatorSession: string;
+    blockedTasks: BlockedTaskInput[];
+    contestedReviews?: ContestedReviewInput[];
+}
+export declare function renderDelegateQuestionPackage(input: RenderDelegateQuestionPackageInput): string;
+export {};

package/dist/orchestration/render-delegate-result.d.ts

@@ -0,0 +1,2 @@
+import type { OrchestrationTaskRecord } from "./orchestration-types";
+export declare function renderDelegateResultBlocks(tasks: OrchestrationTaskRecord[]): string;

package/dist/orchestration/task-watch-timeouts.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_TASK_WATCH_TIMEOUT_MS = 60000;
+export declare const MAX_TASK_WATCH_TIMEOUT_MS: number;
+export declare const DEFAULT_TASK_WATCH_POLL_INTERVAL_MS = 1000;
+export declare const MAX_TASK_WATCH_POLL_INTERVAL_MS = 10000;
+export declare const TASK_WATCH_RPC_TIMEOUT_PADDING_MS = 5000;

package/dist/plugin-api.d.ts

@@ -3,6 +3,7 @@ export type { ChannelFactory, CreateChannelDeps } from "./channels/create-channe
 export type { ChannelStartInput, ConsumerLock, ConsumerLockMetadata, ConsumerLockOptions, CoordinatorMessageInput, MessageChannelRuntime, ScheduledChannelMessageInput, OrchestrationDeliveryCallbacks, OutboundQuota, ToolUseEvent, ToolUseKind, ToolUseStatus, } from "./channels/types.js";
 export type { ChannelCliInput, ChannelCliIo, ChannelCliParseResult, ChannelCliProvider, ChannelCliValidationIssue, } from "./channels/cli/provider.js";
 export type { ChannelRuntimeConfig } from "./config/types.js";
+export type { CommandHint } from "./commands/command-hints.js";
 export type { AppLogger } from "./logging/app-logger.js";
 export type { WeacpxPlugin } from "./plugins/types.js";
 export { WEACPX_PLUGIN_API_VERSION, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION, } from "./plugins/types.js";

package/dist/scheduled/parse-later-time.d.ts

@@ -0,0 +1,11 @@
+export type LaterTimeParseErrorCode = "missing_time" | "unrecognized_time" | "missing_message" | "past_today_time" | "too_soon" | "out_of_range";
+export type LaterTimeParseResult = {
+    ok: true;
+    executeAt: Date;
+    messageStartIndex: number;
+} | {
+    ok: false;
+    code: LaterTimeParseErrorCode;
+    value?: string;
+};
+export declare function parseLaterTime(tokens: string[], now?: Date): LaterTimeParseResult;

package/dist/scheduled/scheduled-render.d.ts

@@ -0,0 +1,7 @@
+import type { ScheduledTaskRecord } from "./scheduled-types";
+export declare function renderLaterHelp(): string;
+export declare function renderLaterUnsupportedChannel(): string;
+export declare function renderTaskCreated(task: ScheduledTaskRecord, displaySession: string): string;
+export declare function renderLaterList(tasks: ScheduledTaskRecord[], displaySession: (internalAlias: string) => string): string;
+export declare function preview(text: string): string;
+export declare function formatLocalDateTime(date: Date): string;

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

@@ -0,0 +1,41 @@
+import { AsyncMutex } from "../orchestration/async-mutex";
+import type { StateStore } from "../state/state-store";
+import type { AppState } from "../state/types";
+import type { ScheduledSessionMode, ScheduledTaskRecord } from "./scheduled-types";
+export interface CreateScheduledTaskInput {
+    chatKey: string;
+    sessionAlias: string;
+    executeAt: Date;
+    message: string;
+    sessionMode?: ScheduledSessionMode;
+    agent?: string;
+    workspace?: string;
+    accountId?: string;
+    replyContextToken?: string;
+    sourceLabel?: string;
+}
+export interface ScheduledTaskServiceOptions {
+    now?: () => Date;
+    generateId?: () => string;
+    stateMutex?: AsyncMutex;
+}
+export declare class ScheduledTaskService {
+    private readonly state;
+    private readonly stateStore;
+    private readonly now;
+    private readonly generateId;
+    private readonly stateMutex;
+    private readonly claimedInThisSession;
+    constructor(state: AppState, stateStore: Pick<StateStore, "save">, options?: ScheduledTaskServiceOptions);
+    createTask(input: CreateScheduledTaskInput): Promise<ScheduledTaskRecord>;
+    listPending(): ScheduledTaskRecord[];
+    cancelPending(inputId: string): Promise<boolean>;
+    markStartupMissed(): Promise<void>;
+    claimDueTasks(): Promise<ScheduledTaskRecord[]>;
+    markExecuted(id: string): Promise<void>;
+    markFailed(id: string, error: unknown): Promise<void>;
+    private nextId;
+    private mutate;
+    private save;
+}
+export declare function normalizeId(input: string): string;

package/dist/scheduled/scheduled-types.d.ts

@@ -0,0 +1,29 @@
+export declare const LATER_MIN_DELAY_MS = 10000;
+export declare const LATER_MAX_DELAY_MS: number;
+export declare const LATER_MESSAGE_PREVIEW_CHARS = 120;
+export type ScheduledTaskStatus = "pending" | "triggering" | "executed" | "cancelled" | "missed" | "failed";
+export type ScheduledSessionMode = "temp" | "bound";
+export interface ScheduledTaskRecord {
+    id: string;
+    chat_key: string;
+    session_alias: string;
+    /** Absent ⇒ "bound" (legacy tasks created before temp mode existed). */
+    session_mode?: ScheduledSessionMode;
+    /** Agent snapshot at creation; only set for "temp" tasks. */
+    agent?: string;
+    /** Workspace snapshot at creation; only set for "temp" tasks. */
+    workspace?: string;
+    execute_at: string;
+    message: string;
+    status: ScheduledTaskStatus;
+    created_at: string;
+    account_id?: string;
+    reply_context_token?: string;
+    source_label?: string;
+    triggered_at?: string;
+    executed_at?: string;
+    cancelled_at?: string;
+    missed_at?: string;
+    failed_at?: string;
+    last_error?: string;
+}