@butlerbot/sdk 0.0.33 → 0.0.35

package/dist/modules/transport_link.js

@@ -3,6 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinkConversationTransport = void 0;
 const protocol_1 = require("../link/protocol");
 const transport_1 = require("./transport");
+/**
+ * How long to keep trying to pick a lost turn back up before giving up on it.
+ *
+ * A turn belongs to its conversation, not to the socket that asked for one, so neither losing
+ * the connection nor losing the instance answering it — which is what a deploy does — ends it.
+ * Long enough to outlast a deploy of either service, short enough that a caller awaiting a
+ * reply is not left there forever when the turn really is gone.
+ */
+const RESUME_WINDOW_MS = 60000;
+/** Waits between attempts to pick a turn back up. The last value repeats. */
+const RESUME_BACKOFF_MS = [250, 500, 1000, 2000, 4000, 5000];
 /**
  * Carries a turn over an existing Link connection.
  *
@@ -18,20 +29,20 @@ class LinkConversationTransport {
         link.on("disconnect", () => { this.sessionId = undefined; });
     }
     send(request, handlers) {
-        let closed = false;
+        const listening = { closed: false };
         const deliver = {
-            payload: (payload) => { if (!closed)
+            payload: (payload) => { if (!listening.closed)
                 handlers.payload(payload); },
-            convoId: (convoId) => { if (!closed)
+            convoId: (convoId) => { if (!listening.closed)
                 handlers.convoId(convoId); },
         };
-        void this.runTurn(request, deliver, true).catch((error) => {
+        void this.runTurn(request, deliver, true, listening).catch((error) => {
             const failure = error instanceof protocol_1.LinkError
                 ? (0, transport_1.failurePayload)(error.code, error.message, error.message, request.chatId)
                 : (0, transport_1.failurePayload)("link_error", String(error), "I'm afraid the connection to Alfred failed.", request.chatId);
             deliver.payload(failure);
         });
-        return { close: () => { closed = true; } };
+        return { close: () => { listening.closed = true; } };
     }
     /**
      * Stops a running turn.
@@ -96,57 +107,46 @@ class LinkConversationTransport {
      * ordinary answer for one that is simply idle.
      */
     attach(request, handlers) {
-        let closed = false;
-        const deliver = (payload) => { if (!closed)
+        const listening = { closed: false };
+        const deliver = (payload) => { if (!listening.closed)
             handlers.payload(payload); };
-        const watching = this.link.exchange("conversation.attach", {
-            chatId: request.chatId,
-            ...(request.afterEventId ? { afterEventId: request.afterEventId } : {}),
-        }, {
-            // A turn takes as long as it takes; only the transport dying ends it early.
-            timeoutMs: 0,
-            isDone: (frame) => frame.type === "conversation.done",
-            onFrame: (frame) => {
-                if (frame.type === "conversation.event") {
-                    const payload = frame.payload;
-                    const event = payload.event;
-                    const final = event.type === "response_status" && Boolean(event.payload?.completed);
-                    deliver({
-                        success: true,
-                        data: {
-                            response: event,
-                            convoId: payload.chatId ?? request.chatId,
-                            ...(final ? { quitStream: true } : {}),
-                        },
-                    });
-                    return;
-                }
-                if (frame.type === "conversation.notice") {
-                    deliver((0, transport_1.noticePayload)(frame.payload.message, frame.payload.chatId ?? request.chatId));
-                }
-            },
-        });
-        void watching.then((done) => {
-            const payload = done.payload;
+        const progress = { chatId: request.chatId, lastEventId: request.afterEventId, sawCompletion: false };
+        // Watching is allowed to end in silence, which is why `quietWhenGone` is true here and
+        // false for a turn of our own: nobody is waiting on an answer to a question they asked.
+        const resume = () => this.resume(request.chatId, progress, deliver, listening, { quietWhenGone: true });
+        void this.watch(request.chatId, progress, deliver).then(async (payload) => {
             if (payload.ok)
                 return;
             // Nothing running is not a failure: the caller asked to watch a conversation
             // that has nothing to watch, and the stream simply ends.
             if (payload.code === "no_active_turn")
                 return;
+            // The turn is alive, somewhere this connection can no longer see. Following it is
+            // the entire point of being here.
+            if (payload.code === "turn_suspended") {
+                if (payload.lastEventId)
+                    progress.lastEventId = payload.lastEventId;
+                await resume();
+                return;
+            }
             deliver((0, transport_1.failurePayload)(payload.code ?? "link_error", payload.error ?? "The turn could not be watched.", payload.message ?? payload.error ?? "I'm afraid I couldn't follow that response.", payload.chatId ?? request.chatId));
-        }, (error) => {
+        }, async (error) => {
             if (error instanceof protocol_1.LinkError && error.code === "no_active_turn")
                 return;
+            // The socket went while we were watching. The turn did not go with it.
+            if (error instanceof protocol_1.LinkError && error.code === "disconnected") {
+                await resume();
+                return;
+            }
             deliver(error instanceof protocol_1.LinkError
                 ? (0, transport_1.failurePayload)(error.code, error.message, error.message, request.chatId)
                 : (0, transport_1.failurePayload)("link_error", String(error), "I'm afraid the connection to Alfred failed.", request.chatId));
         });
         return {
             close: () => {
-                if (closed)
+                if (listening.closed)
                     return;
-                closed = true;
+                listening.closed = true;
                 // Best-effort: a socket that has gone has already ended the watch for us.
                 try {
                     this.link.send("conversation.detach", { chatId: request.chatId });
@@ -157,15 +157,14 @@ class LinkConversationTransport {
             },
         };
     }
-    async runTurn(request, handlers, mayRetry) {
+    async runTurn(request, handlers, mayRetry, listening) {
         const sessionId = await this.session(request);
-        let chatId = request.chatId ?? this.sessionChatId;
+        const progress = { chatId: request.chatId ?? this.sessionChatId, sawCompletion: false };
         let announcedChatId = false;
-        let sawCompletion = false;
         const learnChatId = (candidate) => {
             if (!candidate)
                 return;
-            chatId = candidate;
+            progress.chatId = candidate;
             this.sessionChatId = candidate;
             handlers.convoId(candidate);
             // Mirrors the HTTP transport's first byte, which tells a client which
@@ -176,13 +175,99 @@ class LinkConversationTransport {
                 handlers.payload((0, transport_1.convoStartedPayload)(candidate));
             }
         };
-        learnChatId(chatId);
-        const done = await this.link.exchange("conversation.chat", {
-            sessionId,
-            message: request.message,
-            ...(request.model ? { model: request.model } : {}),
-            ...(request.instructions ? { instructions: request.instructions } : {}),
-            ...(request.personality ? { personality: request.personality } : {}),
+        learnChatId(progress.chatId);
+        let done;
+        try {
+            done = await this.link.exchange("conversation.chat", {
+                sessionId,
+                message: request.message,
+                ...(request.model ? { model: request.model } : {}),
+                ...(request.instructions ? { instructions: request.instructions } : {}),
+                ...(request.personality ? { personality: request.personality } : {}),
+            }, {
+                // A turn takes as long as it takes; only the transport dying ends it early.
+                timeoutMs: 0,
+                isDone: (frame) => frame.type === "conversation.done",
+                onFrame: (frame) => {
+                    if (frame.type === "conversation.event") {
+                        const payload = frame.payload;
+                        learnChatId(payload.chatId);
+                        if (payload.eventId)
+                            progress.lastEventId = payload.eventId;
+                        const event = payload.event;
+                        const final = event.type === "response_status" && Boolean(event.payload?.completed);
+                        if (final)
+                            progress.sawCompletion = true;
+                        handlers.payload({
+                            success: true,
+                            data: {
+                                response: event,
+                                ...(payload.chatId ?? progress.chatId ? { convoId: payload.chatId ?? progress.chatId } : {}),
+                                ...(final ? { quitStream: true } : {}),
+                            },
+                        });
+                        return;
+                    }
+                    if (frame.type === "conversation.notice") {
+                        const payload = frame.payload;
+                        learnChatId(payload.chatId);
+                        handlers.payload((0, transport_1.noticePayload)(payload.message, payload.chatId ?? progress.chatId));
+                    }
+                },
+            });
+        }
+        catch (error) {
+            // The socket went while the turn was running. The turn did not go with it: it
+            // belongs to the conversation, and the conversation outlives this connection.
+            if (progress.chatId && error instanceof protocol_1.LinkError && error.code === "disconnected") {
+                await this.resume(progress.chatId, progress, handlers.payload, listening, { quietWhenGone: false });
+                return;
+            }
+            throw error;
+        }
+        const payload = done.payload;
+        learnChatId(payload.chatId);
+        if (payload.ok) {
+            // Nearly always the pipeline's own completion event has already closed the
+            // stream; this is for the turn that ended without one.
+            if (!progress.sawCompletion)
+                handlers.payload((0, transport_1.completedPayload)(payload.chatId ?? progress.chatId));
+            return;
+        }
+        // The session died with a connection we have since replaced. Reopening it is
+        // invisible to the caller, and the message has not been delivered yet.
+        if (payload.code === "unknown_session" && mayRetry) {
+            this.sessionId = undefined;
+            await this.runTurn(request, handlers, false, listening);
+            return;
+        }
+        // Core suspended the turn at a deploy and handed it to another instance, and the link
+        // service followed it as far as it could. The answer is still being written; rejoining
+        // it is the difference between a deploy costing a reply and costing nothing.
+        if (payload.code === "turn_suspended" && progress.chatId) {
+            if (payload.lastEventId)
+                progress.lastEventId = payload.lastEventId;
+            await this.resume(progress.chatId, progress, handlers.payload, listening, { quietWhenGone: false });
+            return;
+        }
+        handlers.payload((0, transport_1.failurePayload)(
+        // `turn_failed` means the dialogue itself failed, and then `error` holds the
+        // code the HTTP transport would have reported.
+        payload.code === "turn_failed" ? payload.error ?? payload.code : payload.code ?? "link_error", payload.error ?? "The turn failed.", payload.message ?? payload.error ?? "I'm afraid that turn could not be completed.", payload.chatId ?? progress.chatId));
+    }
+    /**
+     * One `conversation.attach`: streams a turn's events to the caller and resolves with how
+     * that watch ended.
+     *
+     * Shared by watching somebody else's turn and by rejoining one of our own, because from
+     * here the two are the same act. `progress` is carried rather than returned: a watch that
+     * dies halfway still has to leave behind where it got to, or a resume would replay from
+     * the beginning and the caller would read the answer twice.
+     */
+    async watch(chatId, progress, deliver) {
+        const done = await this.link.exchange("conversation.attach", {
+            chatId,
+            ...(progress.lastEventId ? { afterEventId: progress.lastEventId } : {}),
         }, {
             // A turn takes as long as it takes; only the transport dying ends it early.
             timeoutMs: 0,
@@ -190,48 +275,112 @@ class LinkConversationTransport {
             onFrame: (frame) => {
                 if (frame.type === "conversation.event") {
                     const payload = frame.payload;
-                    learnChatId(payload.chatId);
+                    if (payload.eventId)
+                        progress.lastEventId = payload.eventId;
                     const event = payload.event;
                     const final = event.type === "response_status" && Boolean(event.payload?.completed);
                     if (final)
-                        sawCompletion = true;
-                    handlers.payload({
+                        progress.sawCompletion = true;
+                    deliver({
                         success: true,
                         data: {
                             response: event,
-                            ...(payload.chatId ?? chatId ? { convoId: payload.chatId ?? chatId } : {}),
+                            convoId: payload.chatId ?? chatId,
                             ...(final ? { quitStream: true } : {}),
                         },
                     });
                     return;
                 }
                 if (frame.type === "conversation.notice") {
-                    const payload = frame.payload;
-                    learnChatId(payload.chatId);
-                    handlers.payload((0, transport_1.noticePayload)(payload.message, payload.chatId ?? chatId));
+                    deliver((0, transport_1.noticePayload)(frame.payload.message, frame.payload.chatId ?? chatId));
                 }
             },
         });
-        const payload = done.payload;
-        learnChatId(payload.chatId);
-        if (payload.ok) {
-            // Nearly always the pipeline's own completion event has already closed the
-            // stream; this is for the turn that ended without one.
-            if (!sawCompletion)
-                handlers.payload((0, transport_1.completedPayload)(payload.chatId ?? chatId));
+        return done.payload;
+    }
+    /**
+     * Picks a turn back up after losing sight of it.
+     *
+     * Two ways to lose one, one way to get it back. The socket can go — a deploy of the link
+     * service, a proxy timing out — which rejects the exchange carrying the turn. Or core can
+     * suspend the turn at its own deploy and hand it to another instance, which the link
+     * service follows for two minutes before giving up and saying `turn_suspended`. Either way
+     * the turn is still being answered and the conversation still holds it, so this re-attaches
+     * from the last event the caller was actually given and the stream reads as one answer.
+     *
+     * `no_active_turn` is the ambiguous reply and it is deliberately not treated as an ending:
+     * during a handover it means "not picked up yet" far more often than it means "gone", and
+     * the window is what decides between them.
+     *
+     * Nothing here throws. It runs behind a stream the caller already holds, so the outcomes
+     * that matter are the ones delivered into it: a completion, or a failure that says plainly
+     * that the answer was lost track of rather than that it failed.
+     */
+    async resume(chatId, progress, deliver, listening, options) {
+        const deadline = Date.now() + RESUME_WINDOW_MS;
+        for (let attempt = 0; !listening.closed && Date.now() < deadline; attempt++) {
+            if (attempt > 0)
+                await pause(RESUME_BACKOFF_MS[Math.min(attempt - 1, RESUME_BACKOFF_MS.length - 1)]);
+            if (listening.closed)
+                return;
+            try {
+                // The link reconnects on its own; this waits for it rather than racing it.
+                await this.link.ready();
+            }
+            catch (error) {
+                // Closed for good means nobody is coming back. Anything else is the link still
+                // being down, which is exactly what the window is for.
+                if (error instanceof protocol_1.LinkError && error.code === "closed")
+                    break;
+                continue;
+            }
+            // An attachment from before may still be registered against a connection that is
+            // itself still alive, and the server allows only one per conversation. Dropping it
+            // first costs nothing when there is none to drop.
+            try {
+                this.link.send("conversation.detach", { chatId });
+            }
+            catch {
+                // Not connected. The server dropped the attachment with the socket.
+            }
+            let payload;
+            try {
+                payload = await this.watch(chatId, progress, deliver);
+            }
+            catch (error) {
+                if (error instanceof protocol_1.LinkError && error.code === "closed")
+                    break;
+                if (error instanceof protocol_1.LinkError && error.code === "no_active_turn" && options.quietWhenGone)
+                    return;
+                continue;
+            }
+            if (payload.ok) {
+                if (!progress.sawCompletion)
+                    deliver((0, transport_1.completedPayload)(payload.chatId ?? chatId));
+                return;
+            }
+            // Not picked up yet, or suspended again mid-hop. Both mean it is still moving.
+            if (payload.code === "no_active_turn") {
+                if (options.quietWhenGone)
+                    return;
+                continue;
+            }
+            if (payload.code === "turn_suspended") {
+                if (payload.lastEventId)
+                    progress.lastEventId = payload.lastEventId;
+                continue;
+            }
+            deliver((0, transport_1.failurePayload)(payload.code ?? "link_error", payload.error ?? "The turn could not be picked back up.", payload.message ?? payload.error ?? "I'm afraid I couldn't follow that response.", payload.chatId ?? chatId));
             return;
         }
-        // The session died with a connection we have since replaced. Reopening it is
-        // invisible to the caller, and the message has not been delivered yet.
-        if (payload.code === "unknown_session" && mayRetry) {
-            this.sessionId = undefined;
-            await this.runTurn(request, handlers, false);
+        if (listening.closed)
             return;
-        }
-        handlers.payload((0, transport_1.failurePayload)(
-        // `turn_failed` means the dialogue itself failed, and then `error` holds the
-        // code the HTTP transport would have reported.
-        payload.code === "turn_failed" ? payload.error ?? payload.code : payload.code ?? "link_error", payload.error ?? "The turn failed.", payload.message ?? payload.error ?? "I'm afraid that turn could not be completed.", payload.chatId ?? chatId));
+        // The completion already reached the caller; there is nothing left to say.
+        if (progress.sawCompletion)
+            return;
+        if (options.quietWhenGone)
+            return;
+        deliver((0, transport_1.failurePayload)("turn_suspended", "The turn could not be picked back up.", "I'm afraid I lost track of that answer. It may well have finished — reopen the conversation to see where it got to.", chatId));
     }
     /** Opens a session, or reuses the open one when it is for the same conversation. */
     async session(request) {
@@ -257,3 +406,10 @@ class LinkConversationTransport {
     }
 }
 exports.LinkConversationTransport = LinkConversationTransport;
+/** Waits, without keeping a Node process alive on its own. */
+function pause(ms) {
+    return new Promise(resolve => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref?.();
+    });
+}

package/dist/types/jobs/index.d.ts

@@ -0,0 +1 @@
+export * from "./job";

package/dist/types/jobs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./job"), exports);

package/dist/types/jobs/job.d.ts

@@ -0,0 +1,179 @@
+import type { Delivery } from "../outreach/delivery";
+/**
+ * A job: long-running work Alfred does on its own, run as a sequence of short shifts.
+ *
+ * These are the shapes the jobs routes answer with. The server flattens a job row into a
+ * `JobView` before it leaves, and this is that view rather than the row.
+ */
+export declare const JOB_STATUSES: readonly ["queued", "running", "blocked", "waiting_user", "waiting_approval", "waiting_child", "waiting_budget", "review", "done", "failed", "cancelled"];
+export type JobStatus = typeof JOB_STATUSES[number];
+/** The statuses a job never leaves. */
+export declare const TERMINAL_JOB_STATUSES: readonly JobStatus[];
+export declare const JOB_AUTONOMY_MODES: readonly ["ask", "free", "auto"];
+/** How far a job may act outward on its own: ask first, act freely, or act and report. */
+export type JobAutonomy = typeof JOB_AUTONOMY_MODES[number];
+/** One job as a listing or a detail read shows it. */
+export type JobView = {
+    jobId: string;
+    /** A short name for listings, derived from the goal when nobody gave one. */
+    title: string;
+    /** The user's words, verbatim: what the job was asked to do. */
+    goal: string;
+    status: JobStatus;
+    /** Why it is where it is, specific enough to act on. */
+    statusDetail: string | null;
+    /** A one-line note the running shift may leave. */
+    progress: string | null;
+    /** The phase being worked, or the last one that was. */
+    currentPhaseId: string | null;
+    shiftsRun: number;
+    /** How many times the job has been reviewed. */
+    reviewRounds: number;
+    /** What the job has spent in total, in USD. */
+    spentUsd: number;
+    /** What the job has spent today, in USD. */
+    spendTodayUsd: number;
+    /** How many questions of this job's are waiting on the user. */
+    openQuestions: number;
+    lastRunAt: number;
+    /** The earliest the runner may pick it up again. */
+    wakeAt: number;
+    created: number;
+    /** `card://…/plan.md`, once a planning shift has written it. */
+    planCardUri: string | null;
+    /** `card://…/journal.md`, appended to as the job runs. */
+    journalCardUri: string | null;
+    /** The chat the job was asked for in, and where it reports back. */
+    originConversationId: string | null;
+    /** What was chosen for this job, or null when nothing was. */
+    autonomy: JobAutonomy | null;
+    /** When `autonomy` lapses back to asking, in UTC milliseconds. */
+    autonomyUntil: number | null;
+    /** Things this job asks about however free it otherwise is. */
+    alwaysAsk: string[];
+    /** What the gate actually reads, with the owner's setting and any lapse applied. */
+    effectiveAutonomy: JobAutonomy;
+};
+/** What the owner's jobs may spend today, and where that figure comes from. */
+export type JobAllowanceGranted = {
+    perDayUsd: number;
+    /** What set the figure: the owner's own allowance, or their tier. */
+    source: string;
+    remainingUsd: number;
+};
+/** Why the owner's jobs may not run at all. */
+export type JobAllowanceRefused = {
+    perDayUsd: 0;
+    source: null;
+    /** The reason in a word, such as a tier that does not include jobs. */
+    refused: string;
+    /** The same thing in a sentence, for showing a user. */
+    message: string;
+};
+export type JobAllowance = JobAllowanceGranted | JobAllowanceRefused;
+/** Whether an allowance is a refusal rather than a grant. */
+export declare function isJobAllowanceRefused(allowance: JobAllowance): allowance is JobAllowanceRefused;
+export type JobPlanPhaseKind = "plan" | "work" | "review";
+export type JobPlanPhaseStatus = "pending" | "running" | "blocked" | "done";
+/** One phase of a job's plan, as the plan card spells it out. */
+export type JobPlanPhase = {
+    id: string;
+    kind: JobPlanPhaseKind;
+    /** The model this phase is run on. */
+    model: string;
+    status: JobPlanPhaseStatus;
+    /** The card this phase has to leave behind before it may be done. */
+    artifact?: string;
+    /** What finishing it means, in the plan's own words. */
+    acceptance?: string;
+    /** Phase ids that have to be done first. */
+    dependsOn?: string[];
+    /** What the shift working this phase is told. */
+    brief?: string;
+};
+/**
+ * What is wrong with a plan card that could not be read.
+ *
+ * The parse issue names the line and what is wrong with it; a plain string is what a server
+ * that only has a sentence about it sends.
+ */
+export type JobPlanIssue = string | {
+    line: number;
+    message: string;
+};
+export type JobPlanRead = {
+    ok: true;
+    raw: string;
+    phases: JobPlanPhase[];
+} | {
+    ok: false;
+    reason: string;
+    issue?: JobPlanIssue;
+};
+/**
+ * One line of a job's journal.
+ *
+ * Loosely typed on purpose: the journal is a card the model writes as well as the runtime, and
+ * a reader that dropped the keys it did not know would hide exactly the entries worth reading.
+ */
+export type JobJournalEntry = {
+    at: number;
+    kind?: string;
+    title?: string;
+    body?: string;
+    [key: string]: unknown;
+};
+/** What may be written to the owner's job settings. */
+export type JobSettingsUpdate = {
+    /** A flat daily allowance, in USD. */
+    allowanceUsd?: number | null;
+    /** A daily allowance as a percentage of the owner's usage limit. */
+    allowancePercent?: number | null;
+    /** The autonomy new jobs start with. */
+    autonomy?: JobAutonomy | null;
+    /** Things every job of theirs asks about. */
+    alwaysAsk?: string[] | null;
+};
+/**
+ * The owner's job settings as they now stand.
+ *
+ * Open on purpose: the settings pipeline owns this document, and a setting it grows is worth
+ * handing back rather than dropping because the SDK has not been rebuilt.
+ */
+export type JobSettings = JobSettingsUpdate & {
+    [key: string]: unknown;
+};
+export type JobListResponse = {
+    success: true;
+    jobs: JobView[];
+    page: number;
+    limit: number;
+    total: number;
+    /** The status the listing was filtered to, when it was. */
+    status?: JobStatus;
+    allowance: JobAllowance;
+    spentTodayUsd: number;
+};
+export type JobDetailResponse = {
+    success: true;
+    job: JobView;
+    /** The job's autonomy in a sentence, ready to show. */
+    autonomyLine: string;
+    plan: JobPlanRead;
+    journal: JobJournalEntry[];
+    /** Questions of this job's nobody has answered yet. */
+    openDeliveries: Delivery[];
+};
+export type JobCancelResponse = {
+    success: true;
+    job: JobView;
+};
+export type JobUpdateResponse = {
+    success: true;
+    job: JobView;
+    autonomyLine: string;
+};
+export type JobSettingsResponse = {
+    success: true;
+    jobs: JobSettings;
+};

package/dist/types/jobs/job.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JOB_AUTONOMY_MODES = exports.TERMINAL_JOB_STATUSES = exports.JOB_STATUSES = void 0;
+exports.isJobAllowanceRefused = isJobAllowanceRefused;
+/**
+ * A job: long-running work Alfred does on its own, run as a sequence of short shifts.
+ *
+ * These are the shapes the jobs routes answer with. The server flattens a job row into a
+ * `JobView` before it leaves, and this is that view rather than the row.
+ */
+exports.JOB_STATUSES = [
+    "queued",
+    "running",
+    "blocked",
+    "waiting_user",
+    "waiting_approval",
+    "waiting_child",
+    "waiting_budget",
+    "review",
+    "done",
+    "failed",
+    "cancelled",
+];
+/** The statuses a job never leaves. */
+exports.TERMINAL_JOB_STATUSES = ["done", "failed", "cancelled"];
+exports.JOB_AUTONOMY_MODES = ["ask", "free", "auto"];
+/** Whether an allowance is a refusal rather than a grant. */
+function isJobAllowanceRefused(allowance) {
+    return allowance.source === null;
+}