@sentry/junior 0.177.0 → 0.179.0

package/dist/{catalog-runtime-2TD4CXSB.js → catalog-runtime-FBVA6WAQ.js}

@@ -1,15 +1,15 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-J2EWL6GJ.js";
-import "./chunk-7B6NW4P7.js";
+} from "./chunk-YFNAMRGE.js";
+import "./chunk-SLGGOASN.js";
 import "./chunk-CGA4ERJ5.js";
 import "./chunk-M63DETLL.js";
-import "./chunk-7CVYXUOJ.js";
+import "./chunk-HQNE5APD.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-ORMJY4RG.js";
-import "./chunk-SNPQGTHJ.js";
+import "./chunk-UT6X7XN7.js";
+import "./chunk-TIEKUH4Q.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

package/dist/chat/agent/sandbox.d.ts

@@ -31,6 +31,8 @@ export interface AgentSandboxOptions {
     actor?: Actor;
     locationConfiguration?: LocationConfigurationService;
     configurationValues: Record<string, unknown>;
+    /** Durable-worker soft yield for long Workspace snapshot waits. */
+    shouldYield?: () => boolean;
     getActiveSkill(): Skill | null;
     prepareSandbox(workspace: SandboxWorkspace): void | Promise<void>;
     prepareWorkspace?(workspace: SandboxWorkspace, recipe: Workspace, signal?: AbortSignal): Promise<void>;

package/dist/chat/conversations/sql/participants.d.ts

@@ -9,6 +9,7 @@ export declare function recordConversationParticipant(executor: JuniorSqlDatabas
     actorIdentityId: string;
     conversationId: string;
     atMs: number;
+    restoreArchive?: boolean;
 }): Promise<void>;
 /** Find which of the supplied root conversations include the linked user. */
 export declare function rootConversationIdsForParticipant(executor: JuniorSqlDatabase, args: {

package/dist/chat/conversations/store.d.ts

@@ -18,7 +18,6 @@ export interface ConversationLineage {
     parentConversationId: string;
 }
 export interface Conversation {
-    archivedAtMs?: number;
     channelName?: string;
     conversationId: string;
     createdAtMs: number;

package/dist/chat/sandbox/errors.d.ts

@@ -6,6 +6,10 @@ export declare function isSandboxUnavailableError(error: unknown): boolean;
 export declare function isSandboxMissingError(error: unknown): boolean;
 /** Detect transient snapshot boot races so sandbox creation can retry. */
 export declare function isSnapshottingError(error: unknown): boolean;
+/** Detect cancellation so a durable builder stays available for check-in. */
+export declare function isAbortError(error: unknown): boolean;
+/** Detect transient Vercel Sandbox API failures that keep a job resumable. */
+export declare function isSandboxApiTransientError(error: unknown): boolean;
 /** Detect interrupted command streams where no reliable exit status is available. */
 export declare function isSandboxCommandStreamInterruptedError(error: unknown): boolean;
 /** Wrap raw sandbox setup failures into one stable user-facing error contract. */

package/dist/chat/sandbox/noninteractive-command.d.ts

@@ -10,6 +10,7 @@ interface NonInteractiveCommandInput extends NonInteractiveShellOptions {
     login?: boolean;
     signal?: AbortSignal;
     sudo?: boolean;
+    timeoutMs?: number;
 }
 /** Render one argv command as a safely quoted shell script. */
 export declare function buildCommandScript(input: Pick<NonInteractiveCommandInput, "args" | "cmd">): string;

package/dist/chat/sandbox/prepare-workspace.d.ts

@@ -1,11 +1,35 @@
 import type { SandboxSession } from "@/chat/sandbox/workspace";
 import type { Workspace } from "@/chat/workspaces/types";
-/** Prepare repositories and setup state before a Workspace snapshot is captured. */
-export declare function prepareWorkspaceSnapshot(params: {
+interface PrepareWorkspaceParams {
     sandbox: SandboxSession;
     workspace: Workspace;
     signal?: AbortSignal;
     applyNetworkPolicy(sandbox: SandboxSession): Promise<unknown>;
     prepareRepositories?(sandbox: SandboxSession, workspace: Workspace, signal?: AbortSignal): Promise<void>;
     removeCredentialRoute: boolean;
-}): Promise<void>;
+}
+/** Prepare repositories before a Workspace setup script starts. */
+export declare function prepareWorkspaceRepositories(params: PrepareWorkspaceParams): Promise<void>;
+/** Build the command for one Workspace setup script. */
+export declare function workspaceSetupCommand(workspace: Workspace): {
+    cmd: string;
+    args: string[];
+    cwd: string;
+    env: {
+        JUNIOR_REPOS_ROOT: string;
+        JUNIOR_WORKSPACE_ROOT: string;
+    };
+};
+/** Build a restart-safe command for one Workspace snapshot setup script. */
+export declare function workspaceSnapshotSetupCommand(workspace: Workspace, buildId: string): {
+    cmd: string;
+    args: string[];
+    cwd: string;
+    env: {
+        JUNIOR_REPOS_ROOT: string;
+        JUNIOR_WORKSPACE_ROOT: string;
+    };
+};
+/** Prepare repositories and setup state before a Workspace snapshot is captured. */
+export declare function prepareWorkspaceSnapshot(params: PrepareWorkspaceParams): Promise<void>;
+export {};

package/dist/chat/sandbox/sandbox.d.ts

@@ -33,6 +33,8 @@ export interface SandboxOptions {
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
+    /** Durable-worker soft yield for long Workspace snapshot waits. */
+    shouldYield?: () => boolean;
     traceContext?: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
     credentialEgress?: CredentialContext;

package/dist/chat/sandbox/session.d.ts

@@ -38,6 +38,8 @@ interface SandboxRuntimeOptions {
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
+    /** Durable-worker soft yield for long Workspace snapshot waits. */
+    shouldYield?: () => boolean;
     traceContext?: LogContext;
     commandEnv?: () => Promise<Record<string, string>>;
     createNetworkPolicy?: (egressId: string, traceHeaders?: TracePropagationHeaders) => NetworkPolicy | undefined;

package/dist/chat/sandbox/snapshot/builder-sandbox.d.ts

@@ -0,0 +1,5 @@
+import { Sandbox } from "@vercel/sandbox";
+/** Resume the named Sandbox that owns one Workspace snapshot build. */
+export declare function getWorkspaceSnapshotBuilder(name: string, signal?: AbortSignal): Promise<Sandbox>;
+/** Permanently delete named Workspace snapshot builders without resuming them. */
+export declare function deleteWorkspaceSnapshotBuilders(names: Iterable<string>): Promise<void>;

package/dist/chat/sandbox/snapshot/install.d.ts

@@ -1,6 +1,6 @@
 import type { PluginRuntimeDependency, PluginRuntimePostinstallCommand } from "@/chat/plugins/types";
 import type { SandboxSession } from "@/chat/sandbox/workspace";
 /** Install declared system and npm dependencies into a snapshot sandbox. */
-export declare function dependencies(sandbox: SandboxSession, values: PluginRuntimeDependency[], signal?: AbortSignal): Promise<void>;
+export declare function dependencies(sandbox: SandboxSession, values: PluginRuntimeDependency[], signal?: AbortSignal, timeoutMs?: number): Promise<void>;
 /** Run declared postinstall commands after dependency binaries are available. */
-export declare function postinstall(sandbox: SandboxSession, commands: PluginRuntimePostinstallCommand[], signal?: AbortSignal): Promise<void>;
+export declare function postinstall(sandbox: SandboxSession, commands: PluginRuntimePostinstallCommand[], signal?: AbortSignal, timeoutMs?: number): Promise<void>;

package/dist/chat/sandbox/snapshot/span.d.ts

@@ -1,2 +1,5 @@
+import type { Snapshot } from "@/chat/sandbox/snapshot/resolve";
+/** Record the reusable snapshot selected for a new Sandbox. */
+export declare function setSnapshotSpanAttributes(snapshot: Snapshot): void;
 /** Record one stage of dependency snapshot resolution or creation. */
 export declare function trace<T>(name: string, op: string, attributes: Record<string, unknown>, callback: () => Promise<T>): Promise<T>;

package/dist/chat/sandbox/snapshot/store.d.ts

@@ -1,28 +1,31 @@
 import type { JuniorDatabase } from "@/db/db";
-import type { WorkspaceSnapshot, WorkspaceSnapshotBuild } from "@/chat/workspaces/types";
+import type { Workspace, WorkspaceSnapshot, WorkspaceSnapshotBuild } from "@/chat/workspaces/types";
 /** Current ready artifact and build state for one Workspace profile. */
 export interface WorkspaceSnapshots {
     ready: WorkspaceSnapshot | null;
     build: WorkspaceSnapshotBuild | null;
 }
+/** Result of replacing the ready snapshot for one Workspace profile. */
+export interface WorkspaceSnapshotWriteResult {
+    written: boolean;
+    replacedBuilderNames: string[];
+}
 /** Load bounded ready and build views for one Workspace profile hash. */
 export declare function loadSnapshotsForProfile(db: JuniorDatabase, workspaceId: string, profileHash: string): Promise<WorkspaceSnapshots>;
-/** Drop in-flight or failed rows when a recipe changes. Keep ready rows. */
-export declare function clearNonReadySnapshots(db: JuniorDatabase, workspaceId: string): Promise<string[]>;
-/** Drop one ready row whose provider snapshot no longer exists. */
-export declare function invalidateMissingReadySnapshot(params: {
+/** Drop every snapshot row before its Workspace is deleted. */
+export declare function clearWorkspaceSnapshots(db: JuniorDatabase, workspaceId: string): Promise<string[]>;
+/** Drop one ready snapshot and return the name of its provider owner. */
+export declare function invalidateReadySnapshot(params: {
     workspaceId: string;
     profileHash: string;
     snapshotId: string;
-}): Promise<void>;
-/** Record the full Sandbox snapshot after a successful Workspace prepare. */
-export declare function setWorkspaceSnapshot(workspaceId: string, snapshot: WorkspaceSnapshot): Promise<void>;
-/** Record a Workspace snapshot build that can continue across execution slices. */
-export declare function setWorkspaceSnapshotBuild(workspaceId: string, build: WorkspaceSnapshotBuild): Promise<void>;
-/** Persist Workspace snapshot facts when resolve returns a concrete entry. */
-export declare function recordResolvedWorkspaceSnapshot(workspaceId: string, snapshot: {
-    snapshotId?: string;
-    profileHash?: string;
-    createdAtMs?: number;
-    buildDurationMs?: number;
-}): Promise<void>;
+}): Promise<string | null>;
+/** Complete one owned build and report provider owners that it replaced. */
+export declare function setWorkspaceSnapshot(workspaceId: string, snapshot: WorkspaceSnapshot, options: {
+    buildId: string;
+}): Promise<WorkspaceSnapshotWriteResult>;
+/** Update an owned build row. Initial creation locks and verifies its Workspace. */
+export declare function setWorkspaceSnapshotBuild(workspaceId: string, build: WorkspaceSnapshotBuild, options?: {
+    insertIfMissing?: boolean;
+    expectedRecipe?: Pick<Workspace, "setupScript" | "repos">;
+}): Promise<boolean>;

package/dist/chat/sandbox/snapshot/waiting-error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Soft deadline hit while a Workspace snapshot is still building.
+ * The tool returns timed_out so the host can yield at a tool-result boundary.
+ */
+export declare class WorkspaceSnapshotWaitingError extends Error {
+    readonly code = "workspace_snapshot_waiting";
+    readonly workspaceName: string;
+    constructor(workspaceName: string);
+}
+/** True when a structured tool result is a soft Workspace snapshot wait. */
+export declare function isWorkspaceSnapshotWaitingResult(details: unknown): boolean;
+/** Workspace name from a soft-wait tool result, if present. */
+export declare function workspaceNameFromWaitingResult(details: unknown): string | undefined;
+/** True when an error chain contains the Workspace snapshot wait signal. */
+export declare function isWorkspaceSnapshotWaitingError(error: unknown): error is WorkspaceSnapshotWaitingError;

package/dist/chat/sandbox/snapshot/workspace.d.ts

@@ -0,0 +1,17 @@
+import type { Snapshot } from "@/chat/sandbox/snapshot/resolve";
+import { type SandboxSession } from "@/chat/sandbox/workspace";
+import type { Workspace } from "@/chat/workspaces/types";
+/**
+ * Resolve a Workspace snapshot through resumable execution slices.
+ * Cold builds have one shared one-hour budget across every execution slice.
+ */
+export declare function resolveWorkspaceSnapshot(params: {
+    workspace: Workspace;
+    runtime: string;
+    staleSnapshotId?: string;
+    signal?: AbortSignal;
+    shouldYield?: () => boolean;
+    applyNetworkPolicy(sandbox: SandboxSession): Promise<unknown>;
+    prepareRepositories?(sandbox: SandboxSession, workspace: Workspace, signal?: AbortSignal): Promise<void>;
+    removeCredentialRoute: boolean;
+}): Promise<Snapshot>;

package/dist/chat/scheduled-tasks/personal.d.ts

@@ -1,8 +1,7 @@
 /** Viewer-scoped scheduled-task queries and mutations. */
 import type { User } from "@sentry/junior-plugin-api";
-import type { SchedulerStore } from "./store";
+import type { JuniorDatabase } from "@/db/db";
 import type { ScheduledTask } from "./types";
-type PersonalScheduledTaskStore = Pick<SchedulerStore, "getTask" | "listTasksCreatedBy" | "saveTask">;
 export interface ViewerScheduledTaskPage {
     nextCursor?: string;
     tasks: ScheduledTask[];
@@ -18,9 +17,7 @@ export declare class InvalidScheduledTaskCursorError extends Error {
 export declare class PersonalScheduledTaskNotFoundError extends Error {
     constructor();
 }
-/** Build scheduled-task operations limited to tasks created by one user. */
-export declare function createViewerScheduledTasks(store: PersonalScheduledTaskStore, user: User): {
-    delete(id: string, nowMs?: number): Promise<void>;
-    list(input: ViewerScheduledTaskPageInput): Promise<ViewerScheduledTaskPage>;
-};
-export {};
+/** Delete one scheduled task created by the viewer. */
+export declare function deleteViewerScheduledTask(db: JuniorDatabase, user: User, id: string, nowMs?: number): Promise<void>;
+/** List scheduled tasks created by the viewer with a stable SQL cursor. */
+export declare function listViewerScheduledTasks(db: JuniorDatabase, user: User, input: ViewerScheduledTaskPageInput): Promise<ViewerScheduledTaskPage>;

package/dist/chat/scheduled-tasks/runs.d.ts

@@ -0,0 +1,49 @@
+import type { JuniorDatabase } from "@/db/db";
+import { type ScheduledRun } from "./types";
+/** List incomplete runs for retained scheduled tasks. */
+export declare function listIncompleteScheduledRuns(db: JuniorDatabase): Promise<ScheduledRun[]>;
+/** Claim one due scheduler run under the deployed global claim lock. */
+export declare function claimDueScheduledRun(db: JuniorDatabase, args: {
+    nowMs: number;
+}): Promise<ScheduledRun | undefined>;
+/** Mark a pending run dispatched only for the active claim. */
+export declare function markScheduledRunDispatched(db: JuniorDatabase, args: {
+    claimedAtMs: number;
+    dispatchId: string;
+    nowMs: number;
+    runId: string;
+}): Promise<ScheduledRun | undefined>;
+/** Complete a run only for its active start timestamp. */
+export declare function markScheduledRunCompleted(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    resultMessageTs?: string;
+    runId: string;
+    startedAtMs: number;
+}): Promise<ScheduledRun | undefined>;
+/** Fail a claimed or running run only for its active transition guard. */
+export declare function markScheduledRunFailed(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    errorMessage: string;
+    startedAtMs?: number;
+    runId: string;
+}): Promise<ScheduledRun | undefined>;
+/** Block a claimed or running run only for its active transition guard. */
+export declare function markScheduledRunBlocked(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    errorMessage: string;
+    runId: string;
+    startedAtMs?: number;
+}): Promise<ScheduledRun | undefined>;
+/** Skip a pending run only before dispatch begins. */
+export declare function markScheduledRunSkipped(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    errorMessage: string;
+    runId: string;
+}): Promise<ScheduledRun | undefined>;
+/** Advance a scheduled task after a terminal run under its task lock. */
+export declare function advanceScheduledTaskAfterRun(db: JuniorDatabase, args: {
+    errorMessage?: string;
+    nowMs: number;
+    run: ScheduledRun;
+    status: "blocked" | "completed" | "failed";
+}): Promise<void>;

package/dist/chat/scheduled-tasks/schedule-intent.d.ts

@@ -11,9 +11,9 @@ export declare const scheduleIntentSchema: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"after">;
         value: z.ZodNumber;
         unit: z.ZodEnum<{
-            day: "day";
             hour: "hour";
             minute: "minute";
+            day: "day";
             second: "second";
             week: "week";
         }>;

package/dist/chat/scheduled-tasks/tasks.d.ts

@@ -0,0 +1,27 @@
+import type { JuniorDatabase } from "@/db/db";
+import { juniorSchedulerTasks } from "@/db/schema/scheduled-tasks";
+import { type ScheduledTask } from "./types";
+type ScheduledTaskRow = Pick<typeof juniorSchedulerTasks.$inferSelect, "creatorIdentityId" | "record" | "title">;
+/** Decode a retained scheduler task row and reject invalid routing context. */
+export declare function parseScheduledTaskRow(row: ScheduledTaskRow): ScheduledTask | undefined;
+/** Keep scan paths from returning current or legacy tombstones. */
+export declare function isListedScheduledTask(task: ScheduledTask | undefined): task is ScheduledTask;
+/** Build the stable run id for one task occurrence. */
+export declare function scheduledRunId(taskId: string, scheduledForMs: number): string;
+/** Acquire the deployed advisory lock for one scheduled task. */
+export declare function withScheduledTaskLock<T>(db: JuniorDatabase, taskId: string, callback: (db: JuniorDatabase) => Promise<T>): Promise<T>;
+/** Read and decode one scheduled task. */
+export declare function readScheduledTask(db: JuniorDatabase, taskId: string): Promise<ScheduledTask | undefined>;
+/** List decoded scheduled tasks in stable creation order. */
+export declare function listScheduledTasks(db: JuniorDatabase): Promise<ScheduledTask[]>;
+/** List decoded scheduled tasks for one team in stable creation order. */
+export declare function listScheduledTasksForTeam(db: JuniorDatabase, teamId: string): Promise<ScheduledTask[]>;
+/** Create a scheduled task once under its retry-stable task lock. */
+export declare function createScheduledTask(db: JuniorDatabase, task: ScheduledTask): Promise<ScheduledTask>;
+/** Save a scheduled task and clear its blocked occurrence on reactivation. */
+export declare function saveScheduledTask(db: JuniorDatabase, task: ScheduledTask): Promise<ScheduledTask>;
+/** Save a scheduled task inside a task lock already held by the caller. */
+export declare function saveScheduledTaskInLock(db: JuniorDatabase, task: ScheduledTask, current: ScheduledTask | undefined): Promise<void>;
+/** List scheduled tasks whose current Slack destination is public. */
+export declare function listPublicScheduledTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<ScheduledTask[]>;
+export {};

package/dist/chat/scheduled-tasks/tool-support.d.ts

@@ -1,12 +1,10 @@
 import { type Identity, type SlackDestination, type SlackActor, type SlackSource, type User } from "@sentry/junior-plugin-api";
 import { z } from "zod";
-import { type SchedulerStore } from "./store";
 import type { ScheduledTask, ScheduledTaskConversationAccess, ScheduledTaskPrincipal, ScheduledTaskStatus } from "./types";
 export interface SchedulerToolContext {
     actor?: SlackActor;
     now?: () => number;
     source?: SlackSource;
-    store: SchedulerStore;
     users: {
         resolveActor(): Promise<{
             identity: Identity;
@@ -226,8 +224,6 @@ export declare function buildTaskId(args: {
     destination: SlackDestination;
     toolCallId: string | undefined;
 }): string;
-/** Keep concrete scheduler tools coupled to the injected store, not global state. */
-export declare function schedulerStore(context: SchedulerToolContext): SchedulerStore;
 /** Accept only persisted scheduler statuses from model-facing update input. */
 export declare function normalizeStatus(value: string | undefined): ScheduledTaskStatus | undefined;
 /** Centralize scheduler timezone defaulting for all concrete tool entry points. */

package/dist/chat/scheduled-tasks/tools/create.d.ts

@@ -20,7 +20,7 @@ export declare function createSlackScheduleCreateTaskTool(context: SchedulerTool
             timing: {
                 type: "after";
                 value: number;
-                unit: "day" | "hour" | "minute" | "second" | "week";
+                unit: "hour" | "minute" | "day" | "second" | "week";
             } | {
                 type: "at";
                 date: string;

package/dist/chat/scheduled-tasks/tools/update.d.ts

@@ -21,7 +21,7 @@ export declare function createSlackScheduleUpdateTaskTool(context: SchedulerTool
             timing: {
                 type: "after";
                 value: number;
-                unit: "day" | "hour" | "minute" | "second" | "week";
+                unit: "hour" | "minute" | "day" | "second" | "week";
             } | {
                 type: "at";
                 date: string;

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

@@ -1,86 +1,135 @@
-/** Durable scheduled-task domain types owned by Junior core. */
-import type { SlackDestination, SystemActor } from "@sentry/junior-plugin-api";
 import { z } from "zod";
-export type ScheduledTaskStatus = "active" | "blocked" | "completed" | "deleted";
-export declare const scheduledTaskCredentialModeSchema: z.ZodEnum<{
+declare const scheduledTaskStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    blocked: "blocked";
+    active: "active";
+    deleted: "deleted";
+}>;
+export type ScheduledTaskStatus = z.output<typeof scheduledTaskStatusSchema>;
+declare const scheduledTaskCredentialModeSchema: z.ZodEnum<{
     system: "system";
     creator: "creator";
 }>;
-export type ScheduledTaskCredentialMode = z.infer<typeof scheduledTaskCredentialModeSchema>;
-export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
-export interface ScheduledTaskPrincipal {
-    slackUserId: string;
-    fullName?: string;
-    userName?: string;
-}
-export type ScheduledTaskExecutionActor = SystemActor;
+export type ScheduledTaskCredentialMode = z.output<typeof scheduledTaskCredentialModeSchema>;
+declare const scheduledRunStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    blocked: "blocked";
+    skipped: "skipped";
+}>;
+export type ScheduledRunStatus = z.output<typeof scheduledRunStatusSchema>;
+/** Validate the current scheduled-task domain shape. */
+export declare const scheduledTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    conversationAccess: z.ZodObject<{
+        audience: z.ZodEnum<{
+            channel: "channel";
+            direct: "direct";
+            group: "group";
+        }>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+    }, z.core.$strict>;
+    createdAtMs: z.ZodNumber;
+    createdBy: z.ZodObject<{
+        slackUserId: z.ZodString;
+        fullName: z.ZodOptional<z.ZodString>;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    creatorIdentityId: z.ZodString;
+    credentialMode: z.ZodEnum<{
+        system: "system";
+        creator: "creator";
+    }>;
+    destination: z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>;
+    executionActor: z.ZodOptional<z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    lastRunAtMs: z.ZodOptional<z.ZodNumber>;
+    nextRunAtMs: z.ZodOptional<z.ZodNumber>;
+    originalRequest: z.ZodOptional<z.ZodString>;
+    runNowAtMs: z.ZodOptional<z.ZodNumber>;
+    schedule: z.ZodObject<{
+        description: z.ZodString;
+        kind: z.ZodEnum<{
+            one_off: "one_off";
+            recurring: "recurring";
+        }>;
+        recurrence: z.ZodOptional<z.ZodObject<{
+            dayOfMonth: z.ZodOptional<z.ZodNumber>;
+            frequency: z.ZodEnum<{
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                yearly: "yearly";
+            }>;
+            interval: z.ZodNumber;
+            month: z.ZodOptional<z.ZodNumber>;
+            startDate: z.ZodString;
+            time: z.ZodObject<{
+                hour: z.ZodNumber;
+                minute: z.ZodNumber;
+            }, z.core.$strict>;
+            weekdays: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strict>>;
+        timezone: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        active: "active";
+        deleted: "deleted";
+    }>;
+    statusReason: z.ZodOptional<z.ZodString>;
+    task: z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strict>;
+    title: z.ZodOptional<z.ZodString>;
+    updatedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+/** Validate the current scheduled-run domain shape. */
+export declare const scheduledRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    attempt: z.ZodNumber;
+    claimedAtMs: z.ZodNumber;
+    completedAtMs: z.ZodOptional<z.ZodNumber>;
+    dispatchId: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    resultMessageTs: z.ZodOptional<z.ZodString>;
+    scheduledForMs: z.ZodNumber;
+    startedAtMs: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        blocked: "blocked";
+        skipped: "skipped";
+    }>;
+    taskId: z.ZodString;
+}, z.core.$strict>;
+export type ScheduledTask = z.output<typeof scheduledTaskSchema>;
+export type ScheduledRun = z.output<typeof scheduledRunSchema>;
+export type ScheduledTaskRecord = Omit<ScheduledTask, "title">;
+export type ScheduledTaskPrincipal = ScheduledTask["createdBy"];
+export type ScheduledTaskExecutionActor = NonNullable<ScheduledTask["executionActor"]>;
+export type ScheduledTaskConversationAccess = ScheduledTask["conversationAccess"];
+export type ScheduledTaskSchedule = ScheduledTask["schedule"];
+export type ScheduledTaskRecurrence = NonNullable<ScheduledTaskSchedule["recurrence"]>;
+export type ScheduledTaskSpec = ScheduledTask["task"];
+export type ScheduledCalendarFrequency = ScheduledTaskRecurrence["frequency"];
+export type ScheduledLocalTime = ScheduledTaskRecurrence["time"];
 export declare const SCHEDULED_TASK_SYSTEM_ACTOR: Readonly<{
     platform: "system";
     name: string;
 }>;
-export interface ScheduledTaskConversationAccess {
-    audience: "direct" | "group" | "channel";
-    visibility: "private" | "public";
-}
-export type ScheduledCalendarFrequency = "daily" | "weekly" | "monthly" | "yearly";
-export interface ScheduledLocalTime {
-    hour: number;
-    minute: number;
-}
-export interface ScheduledTaskRecurrence {
-    dayOfMonth?: number;
-    frequency: ScheduledCalendarFrequency;
-    interval: number;
-    month?: number;
-    startDate: string;
-    time: ScheduledLocalTime;
-    weekdays?: number[];
-}
-export interface ScheduledTaskSchedule {
-    description: string;
-    timezone: string;
-    kind: "one_off" | "recurring";
-    recurrence?: ScheduledTaskRecurrence;
-}
-export interface ScheduledTaskSpec {
-    text: string;
-}
-export interface ScheduledTask {
-    id: string;
-    createdAtMs: number;
-    createdBy: ScheduledTaskPrincipal;
-    /** Authoritative provider identity that created the task. */
-    creatorIdentityId: string;
-    conversationAccess: ScheduledTaskConversationAccess;
-    /** Selects system credentials or task-bound creator credential delegation. */
-    credentialMode: ScheduledTaskCredentialMode;
-    destination: SlackDestination;
-    executionActor?: ScheduledTaskExecutionActor;
-    lastRunAtMs?: number;
-    nextRunAtMs?: number;
-    originalRequest?: string;
-    runNowAtMs?: number;
-    schedule: ScheduledTaskSchedule;
-    status: ScheduledTaskStatus;
-    statusReason?: string;
-    task: ScheduledTaskSpec;
-    /**
-     * Short display title generated from the task instruction.
-     * SQL-backed column; never stored inside the JSON record payload.
-     */
-    title?: string;
-    updatedAtMs: number;
-}
-export interface ScheduledRun {
-    id: string;
-    attempt: number;
-    claimedAtMs: number;
-    completedAtMs?: number;
-    dispatchId?: string;
-    errorMessage?: string;
-    resultMessageTs?: string;
-    scheduledForMs: number;
-    startedAtMs?: number;
-    status: ScheduledRunStatus;
-    taskId: string;
-}
+export {};

package/dist/chat/services/workspace-snapshot-wait.d.ts

@@ -0,0 +1,27 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { PiMessage } from "@/chat/pi/messages";
+/** Pending soft wait for a Workspace snapshot from the latest tool result. */
+export declare function pendingWorkspaceSnapshotWait(messages: readonly PiMessage[]): {
+    name: string;
+} | null;
+/**
+ * Continue a soft Workspace snapshot wait without another model turn.
+ * Re-invokes switchWorkspace and appends the complete Pi tool boundary.
+ */
+export declare function continueWorkspaceSnapshotWait(args: {
+    messages: PiMessage[];
+    tools: AgentTool[];
+    signal?: AbortSignal;
+}): Promise<{
+    kind: "none";
+} | {
+    kind: "waiting";
+    messages: PiMessage[];
+} | {
+    kind: "ready";
+    messages: PiMessage[];
+} | {
+    kind: "failed";
+    error: unknown;
+    messages: PiMessage[];
+}>;