@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/adapters/image/reference.js

@@ -0,0 +1,41 @@
+// What an image API is told about the establishing image sent with a request, ahead of the
+// brief. An edit endpoint otherwise treats its input as the picture to change, so it says the
+// input is a reference for the look and the cast, not the composition to keep.
+export const referenceNote = "The attached image is a visual reference only: keep its characters, rendering style and colour palette, but do not copy its composition, pose or framing. Compose a new image from this brief:";
+export function withReferenceNote(prompt, reference) {
+    return reference === undefined ? prompt : `${referenceNote}\n\n${prompt}`;
+}
+// Every picture a request carries, in the order they are attached: the establishing image,
+// then each mentioned cast member's pictures.
+export function referencePictures(req) {
+    return [
+        ...(req.reference === undefined ? [] : [{ image: req.reference }]),
+        ...(req.cast ?? []).flatMap((member) => member.images.map((image) => ({ image, member: member.name }))),
+    ];
+}
+// The prompt a provider sends with the first `limit` of `referencePictures(req)` attached. A
+// request without cast keeps exactly the wording it always had. Cast members whose pictures
+// did not fit (a provider that takes fewer input images, or none) are described in words.
+export function withReferences(prompt, req, limit = Number.POSITIVE_INFINITY) {
+    if (req.cast === undefined || req.cast.length === 0)
+        return limit === 0 ? prompt : withReferenceNote(prompt, req.reference);
+    const sent = referencePictures(req).slice(0, limit);
+    const lines = [];
+    if (sent.length > 0)
+        lines.push("The attached images are visual references only: do not copy their composition, pose or framing.");
+    for (const [index, picture] of sent.entries()) {
+        const member = req.cast.find((row) => row.name === picture.member);
+        lines.push(member === undefined
+            ? `Image ${String(index + 1)} is the establishing image: keep its characters, rendering style and colour palette.`
+            : `Image ${String(index + 1)} shows ${member.name}${describe(member.description)}: draw ${member.name} to look exactly like this.`);
+    }
+    const shown = new Set(sent.flatMap((picture) => picture.member ?? []));
+    for (const member of req.cast)
+        if (!shown.has(member.name))
+            lines.push(`${member.name} appears in this image${describe(member.description)}.`);
+    lines.push("Compose a new image from this brief:");
+    return `${lines.join("\n")}\n\n${prompt}`;
+}
+function describe(description) {
+    return description.trim() === "" ? "" : ` (${description.trim()})`;
+}

package/dist/adapters/image/replicate.js

@@ -4,6 +4,7 @@ import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, missingKey, noImage, providerSaid, refusedImage, unreadable, } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
 import { downloadImage } from "./bytes.js";
+import { withReferences } from "./reference.js";
 import { dataUri, downloadVideo } from "./video.js";
 // The HTTP gateway adapter for Replicate: `fetch`, the injected clock and the downloader
 // beside this file, no SDK. The `replicate` package wraps exactly the two requests below, so
@@ -41,6 +42,13 @@ export function replicateImage(deps) {
         id: "replicate",
         models: () => Promise.resolve(replicateModels),
         generate: async (req) => {
+            // The Replicate models listed take no input image to draw from (the FLUX image inputs
+            // copy the picture's composition), so an establishing image is refused, not dropped.
+            if (req.reference !== undefined)
+                throw providerError({
+                    kind: "unsupported",
+                    message: "Replicate's image models can't use an establishing image as a reference. Choose Codex CLI, OpenAI, Google or fal.ai under Images → Provider on Play or in Edit project → Providers, or set Establishing image to Off in the Images section.",
+                });
             const response = await deps.fetch(`${replicateBase}/models/${req.model}/predictions`, {
                 method: "POST",
                 signal: req.signal,
@@ -51,7 +59,8 @@ export function replicateImage(deps) {
                 },
                 body: JSON.stringify({
                     input: {
-                        prompt: req.prompt,
+                        // These models take no input image, so the cast is described in words.
+                        prompt: withReferences(req.prompt, req, 0),
                         // Replicate takes the aspect, so the closest size is exact.
                         aspect_ratio: req.aspect,
                         // The port stores PNG or JPEG and these models default to WebP. Nothing else
@@ -159,7 +168,7 @@ function declined(current) {
         kind: refusal ? "refusal" : "other",
         message: refusal
             ? refusedImage("Replicate", message)
-            : providerSaid("Replicate", "could not make the image", message, "Use Retry stage; if it keeps happening, reword the image prompt in the Images section of Edit project or choose another image model in its Providers section."),
+            : providerSaid("Replicate", "could not make the image", message, "Use Try again; if it keeps happening, reword the image prompt in the Images section of Edit project or choose another image model in its Providers section."),
     });
 }
 function auth(deps) {
@@ -181,6 +190,9 @@ function kindOf(status) {
     // ceiling: everything else is `other` and is retried, so a 402 with no credit left fails the
     // same way four times over. A terminal "this will never work" kind has to reach the port's
     // error contract first, which is not this adapter's to widen.
+    // The provider's own server failed; the same request may well succeed later.
+    if (status >= 500)
+        return "dropped";
     return "other";
 }
 async function failure(response, subject = "image request") {

package/dist/adapters/image/video.js

@@ -16,13 +16,13 @@ export async function downloadVideo(download) {
         // The link is not quoted back: a delivery link carries its own signature.
         throw providerError({
             kind: "other",
-            message: `${download.provider} made the video clip, but Slopify could not download it (error ${String(response.status)}). Check your internet connection, then use Retry stage.`,
+            message: `${download.provider} made the video clip, but Slopify could not download it (error ${String(response.status)}). Check your internet connection, then use Try again.`,
         });
     const bytes = new Uint8Array(await response.arrayBuffer());
     if (!sniffVideo(bytes))
         throw providerError({
             kind: "other",
-            message: `${download.provider} sent back something that is not an MP4 video clip (${describeBytes(bytes)}). Use Retry stage; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look.`,
+            message: `${download.provider} sent back something that is not an MP4 video clip (${describeBytes(bytes)}). Use Try again; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look.`,
         });
     return { bytes, mime: "video/mp4" };
 }

package/dist/adapters/key-probes.js

@@ -0,0 +1,36 @@
+import { cartesiaVersion } from "./tts/cartesia.js";
+// Settings → Providers' Test button, per provider. Some answer a key they do not recognise
+// with something other than 401: Google with 400 API_KEY_INVALID, ElevenLabs with 400
+// invalid_api_key, Inworld with 403 "does not exist". Observed on 2026-09-27; their
+// documentation says 401.
+const bearer = (key) => ({ Authorization: `Bearer ${key}` });
+export const keyProbes = {
+    openrouter: { url: "https://openrouter.ai/api/v1/key", headers: bearer },
+    "openai-tts": { url: "https://api.openai.com/v1/models", headers: bearer },
+    "openai-image": { url: "https://api.openai.com/v1/models", headers: bearer },
+    "google-image": {
+        url: "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
+        headers: (key) => ({ "x-goog-api-key": key }),
+        badKey: (status, body) => status === 400 && body.includes("API_KEY_INVALID"),
+    },
+    // fal.ai's model list answers without a key; its price lookup requires one.
+    fal: {
+        url: "https://api.fal.ai/v1/models/pricing?endpoint_id=fal-ai/flux/dev",
+        headers: (key) => ({ Authorization: `Key ${key}` }),
+    },
+    replicate: { url: "https://api.replicate.com/v1/account", headers: bearer },
+    elevenlabs: {
+        url: "https://api.elevenlabs.io/v1/models",
+        headers: (key) => ({ "xi-api-key": key }),
+        badKey: (status, body) => status === 400 && body.includes("invalid_api_key"),
+    },
+    cartesia: {
+        url: "https://api.cartesia.ai/voices?limit=1",
+        headers: (key) => ({ "X-API-Key": key, "Cartesia-Version": cartesiaVersion }),
+    },
+    inworld: {
+        url: "https://api.inworld.ai/voices/v1/voices?pageSize=1",
+        headers: (key) => ({ Authorization: `Basic ${key}` }),
+        badKey: (status, body) => status === 403 && /does not exist|was deleted/i.test(body),
+    },
+};

package/dist/adapters/llm/claude-code.js

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
+import { isoOfEpoch } from "../../kernel/ports/plan-limits.js";
 import { cliCheck, cliReported, commandOf } from "../explain.js";
 import { nodeClaudeCodeModels } from "./claude-code-models.js";
 import { cliLoginError } from "./cli-login-error.js";
 import { documentToolName, documentWorkspace, } from "./document-workspace.js";
-import { cliEvent, cliInput, cliShaped, endedWithout, promptOf, stopCliRun, stuckCli, } from "./run-cli.js";
+import { imageWorkspace, readFileName, unseenImages, } from "./image-workspace.js";
+import { cliEvent, cliInput, cliShaped, endedKind, endedWithout, promptOf, stopCliRun, stuckCli, } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 // The local-agent adapter for Claude Code: spawned non-interactively, authenticated by the
 // CLI's own login, no key anywhere in this file. Readiness is not computed here - `adapters/**`
@@ -24,7 +26,14 @@ const writingRole = "You are the writing and research component of Slopify, a vi
 // never something a stage does quietly, and no stage should touch the disk. `--tools ""`
 // empties the built-in set and `--strict-mcp-config` drops the user's MCP servers; the init
 // event of a run with both reports `"tools":[]` and `"mcp_servers":[]`.
-export function claudeCodeArgs(req, documents) {
+//
+// Pictures (a review's) are copied into a private folder that becomes the working directory,
+// and only the Read tool is allowed: `claude --help` 2.1.281 says `--restricted` confines the
+// file tools to the working directories, and Read hands an image file to the model as an
+// image. The run's tool calls are checked afterwards: every picture must have been read.
+export function claudeCodeArgs(req, documents, images) {
+    const isolated = documents !== undefined || images !== undefined;
+    const tools = [req.webSearch === true ? "WebSearch" : "", images ? "Read" : ""].filter(Boolean);
     return [
         "-p",
         "--output-format",
@@ -34,7 +43,7 @@ export function claudeCodeArgs(req, documents) {
         "--include-partial-messages",
         // `claude --help` 2.1.263: safe mode excludes CLAUDE.md, output styles, skills and
         // hooks while retaining login and managed policy. --bare would discard OAuth.
-        ...(documents
+        ...(isolated
             ? [
                 "--restricted",
                 "--setting-sources",
@@ -55,18 +64,17 @@ export function claudeCodeArgs(req, documents) {
         writingRole +
             (documents
                 ? " Use the explicitly supplied research MCP tool to read request documents; it is the only permitted local reference source."
+                : "") +
+            (images
+                ? " Open the supplied image files in the current folder with the Read tool; they are the only local files you may open."
                 : ""),
         "--strict-mcp-config",
         "--tools",
-        req.webSearch === true ? "WebSearch" : "",
-        ...(documents ? ["--mcp-config", documents.config, "--permission-mode", "dontAsk"] : []),
-        ...(req.webSearch === true || documents
-            ? [
-                "--allowedTools",
-                [req.webSearch === true ? "WebSearch" : "", documents ? documentToolName : ""]
-                    .filter(Boolean)
-                    .join(","),
-            ]
+        tools.join(","),
+        ...(documents ? ["--mcp-config", documents.config] : []),
+        ...(isolated ? ["--permission-mode", "dontAsk"] : []),
+        ...(tools.length > 0 || documents
+            ? ["--allowedTools", [...tools, documents ? documentToolName : ""].filter(Boolean).join(",")]
             : []),
         ...(req.model === "" ? [] : ["--model", req.model]),
         ...(req.thinking !== undefined && req.thinking !== "off" ? ["--effort", req.thinking] : []),
@@ -76,7 +84,20 @@ export function claudeCodeArgs(req, documents) {
 }
 const assistantEvent = z.object({
     message: z.object({
-        content: z.array(z.object({ type: z.string(), text: z.string().optional() })),
+        content: z.array(z.object({
+            type: z.string(),
+            text: z.string().optional(),
+            name: z.string().optional(),
+            input: z.object({ file_path: z.unknown().optional() }).loose().optional(),
+        })),
+    }),
+});
+// `--include-partial-messages` streams the model's own events; a text block grows by
+// `content_block_delta` events carrying a `text_delta`. Anything else is only a heartbeat.
+const partialText = z.object({
+    event: z.object({
+        type: z.literal("content_block_delta"),
+        delta: z.object({ type: z.literal("text_delta"), text: z.string() }),
     }),
 });
 // The result event as 2.1.258 writes it. `subtype` stays "success" even for a failed run -
@@ -90,29 +111,55 @@ const resultEvent = z.object({
     stop_reason: z.string().nullish(),
     api_error_status: z.number().nullish(),
     modelUsage: z
-        .record(z.string(), z.object({ inputTokens: z.number(), outputTokens: z.number() }))
+        .record(z.string(), z.object({
+        inputTokens: z.number(),
+        outputTokens: z.number(),
+        cacheReadInputTokens: z.number().optional(),
+        cacheCreationInputTokens: z.number().optional(),
+    }))
         .optional(),
 });
+// The plan windows as 2.1.258 reports them around every call, in `rate_limit_event`:
+// `utilization` is the used fraction of the window, `resetsAt` epoch seconds, and `status`
+// turns "rejected" when the allowance is used up.
+const limitWindow = z.object({ utilization: z.number(), resetsAt: z.number().nullish() }).partial();
+const rateLimitEvent = z.object({
+    rate_limit_info: z.object({
+        status: z.string().optional(),
+        resetsAt: z.number().nullish(),
+        unifiedWindows: z
+            .object({ five_hour: limitWindow.optional(), seven_day: limitWindow.optional() })
+            .partial()
+            .optional(),
+    }),
+});
 export function claudeCodeLlm(deps) {
     const binary = deps.binary ?? claudeCodeBinary;
     async function* complete(req) {
         req.signal.throwIfAborted();
         const documents = documentWorkspace(req.documents);
+        let images;
+        const read = new Set();
         let run;
         let ended;
+        let limits;
         try {
-            run = deps.run(binary, claudeCodeArgs(req, documents), req.signal, {
-                ...(documents
+            images = imageWorkspace(req.images);
+            const folder = images?.directory ?? documents?.directory;
+            run = deps.run(binary, claudeCodeArgs(req, documents, images), req.signal, {
+                ...(folder !== undefined
                     ? {
-                        cwd: documents.directory,
+                        cwd: folder,
                         env: {
                             ...(deps.env ?? process.env),
                             CLAUDE_CODE_SAFE_MODE: "0",
-                            PWD: documents.directory,
+                            PWD: folder,
                         },
                     }
                     : {}),
-                stdin: cliInput([documents?.instructions, promptOf(req.messages)].filter(Boolean).join("\n\n")),
+                stdin: cliInput([documents?.instructions, images?.instructions, promptOf(req.messages)]
+                    .filter(Boolean)
+                    .join("\n\n")),
             });
             for await (const line of lines(run.stdout, req.signal)) {
                 if (line.trim() === "") {
@@ -120,9 +167,34 @@ export function claudeCodeLlm(deps) {
                 }
                 const event = cliEvent(binary, line);
                 // Partial text/thinking and tool events are a heartbeat. Full assistant
-                // messages remain the sole prose source so text is never appended twice.
+                // messages remain the sole prose source so text is never appended twice; partial
+                // prose is only shown on the live panel.
                 yield { type: "activity" };
                 req.signal.throwIfAborted();
+                if (event.type === "stream_event" && !documents) {
+                    const typed = partialText.safeParse(event.value);
+                    if (typed.success && typed.data.event.delta.text !== "")
+                        yield { type: "partial", text: typed.data.event.delta.text };
+                    continue;
+                }
+                if (event.type === "assistant" && images) {
+                    for (const block of cliShaped(binary, assistantEvent, event.value).message.content) {
+                        const file = block.type === "tool_use" && block.name === "Read"
+                            ? readFileName(block.input?.file_path)
+                            : undefined;
+                        if (file !== undefined)
+                            read.add(file);
+                    }
+                    continue;
+                }
+                if (event.type === "rate_limit_event") {
+                    // A shape this version does not know is not a failure: the plan windows are
+                    // reported beside the answer, never needed for it.
+                    const parsed = rateLimitEvent.safeParse(event.value);
+                    if (parsed.success)
+                        limits = parsed.data.rate_limit_info;
+                    continue;
+                }
                 if (event.type === "assistant" && !documents) {
                     for (const block of cliShaped(binary, assistantEvent, event.value).message.content) {
                         // A turn also carries `thinking` and `tool_use` blocks; only the prose is the
@@ -143,25 +215,36 @@ export function claudeCodeLlm(deps) {
                 catch {
                     throw providerError({
                         kind: "unavailable",
-                        message: "Slopify could not hand the whole prompt to the Claude Code CLI, so it cannot tell what the CLI worked on (it may already have used your quota). Use Retry stage to run it again.",
+                        message: "Slopify could not hand the whole prompt to the Claude Code CLI, so it cannot tell what the CLI worked on (it may already have used your quota). Use Try again to run it again.",
                     });
                 }
                 if (result.is_error === true || result.subtype !== "success") {
                     const login = cliLoginError("claude-code", result.result ?? result.subtype);
                     if (login)
                         throw login;
+                    const planLimit = claudePlanLimit(result.result ?? result.subtype, result.api_error_status ?? null, limits);
+                    if (planLimit !== undefined)
+                        throw providerError({
+                            kind: "rate_limit",
+                            message: `Your Claude plan's usage limit is used up (Claude Code said: ${redact(result.result ?? result.subtype)}). Slopify waits for it to reset and then carries on by itself.`,
+                            planLimit,
+                        });
                     throw providerError({
                         kind: kindOf(result.api_error_status ?? null),
                         message: cliReported(binary, redact(result.result ?? result.subtype), nextStep(binary, result.api_error_status ?? null)),
                     });
                 }
                 documents?.verifyRead();
-                if (documents && result.result)
+                if (images && images.unread(read).length > 0)
+                    throw unseenImages();
+                if ((documents || images) && result.result)
                     yield { type: "delta", text: result.result };
+                const windows = limits === undefined ? [] : claudeWindows(limits);
                 yield {
                     type: "done",
                     usage: usageOf(result.modelUsage),
                     finishReason: result.stop_reason ?? null,
+                    ...(windows.length === 0 ? {} : { limits: { after: windows } }),
                 };
                 return;
             }
@@ -181,6 +264,7 @@ export function claudeCodeLlm(deps) {
             }
             finally {
                 documents?.remove();
+                images?.remove();
             }
         }
         // A cancelled run ends its stream the same way an exhausted one does: the child was
@@ -189,19 +273,19 @@ export function claudeCodeLlm(deps) {
         req.signal.throwIfAborted();
         // The stream ended with no result event at all.
         if (!run)
-            throw new Error("The Claude Code CLI could not be started. Check it is installed and set up in Settings → Providers, then use Retry stage.");
+            throw new Error("The Claude Code CLI could not be started. Check it is installed and set up in Settings → Providers, then use Try again.");
         const login = cliLoginError("claude-code", run.stderr());
         if (login)
             throw login;
         throw providerError({
-            kind: "other",
+            kind: endedKind(ended),
             message: ended === undefined ? stuckCli(binary) : endedWithout(binary, ended, run.stderr()),
         });
     }
     return {
         id: "claude-code",
         // Partial messages keep the deadline alive; complete assistant turns supply prose.
-        capabilities: { streams: true, reportsUsage: true, webSearch: true },
+        capabilities: { streams: true, reportsUsage: true, webSearch: true, images: true },
         models: deps.readModels ?? (() => nodeClaudeCodeModels(binary)),
         complete,
     };
@@ -215,27 +299,79 @@ function kindOf(status) {
     if (status === 429) {
         return "rate_limit";
     }
+    // The provider's own server failed; the same request may well succeed later.
+    if (status !== null && status >= 500)
+        return "dropped";
     return "other";
 }
 // What most often fixes the upstream status the CLI passed on.
 function nextStep(binary, status) {
     if (status === 401 || status === 403)
-        return `Run "${commandOf(binary)} auth login" in a terminal to sign in again, then use Retry stage.`;
+        return `Run "${commandOf(binary)} auth login" in a terminal to sign in again, then use Try again.`;
     if (status === 429)
-        return "Your Claude usage limit may be used up: wait until it resets, then use Retry stage.";
+        return "Your Claude usage limit may be used up: wait until it resets, then use Try again.";
     if (status === 404)
-        return "The chosen model may not exist or not be available to your account: choose another in the Providers section of Edit project, then use Retry stage.";
+        return "The chosen model may not exist or not be available to your account: choose another in the Providers section of Edit project, then use Try again.";
     return cliCheck(binary);
 }
 // `modelUsage` is keyed by model id and a run may touch more than one - a fallback model,
 // a sub-agent - so the counts are summed. An empty object means the CLI reported none.
-function usageOf(usage) {
-    const entries = Object.values(usage ?? {});
+// The CLI's `inputTokens` leaves out the prompt it read from or wrote to its cache, which on
+// a short call is nearly all of it, so both are added back: tokens in is every input token.
+export function usageOf(usage) {
+    const entries = Object.entries(usage ?? {});
     if (entries.length === 0) {
         return null;
     }
+    const cached = entries.reduce((total, [, one]) => total + (one.cacheReadInputTokens ?? 0), 0);
+    return {
+        inputTokens: entries.reduce((total, [, one]) => total +
+            one.inputTokens +
+            (one.cacheReadInputTokens ?? 0) +
+            (one.cacheCreationInputTokens ?? 0), 0),
+        outputTokens: entries.reduce((total, [, one]) => total + one.outputTokens, 0),
+        ...(cached === 0 ? {} : { cachedInputTokens: cached }),
+        // Only a single model is named: a run split across two has no one price.
+        ...(entries.length === 1 && entries[0] !== undefined ? { model: entries[0][0] } : {}),
+    };
+}
+// The 5-hour and 7-day windows, used fraction turned into a percentage.
+export function claudeWindows(info) {
+    const windows = [];
+    const named = [
+        ["five_hour", info.unifiedWindows?.five_hour],
+        ["weekly", info.unifiedWindows?.seven_day],
+    ];
+    for (const [kind, one] of named) {
+        if (one?.utilization === undefined)
+            continue;
+        windows.push({
+            kind,
+            // Rounded to hundredths of a percent, so 0.07 reads 7 rather than 7.000000000000001.
+            usedPercent: Math.max(0, Math.min(100, Math.round(one.utilization * 10_000) / 100)),
+            resetsAt: isoOfEpoch(one.resetsAt),
+        });
+    }
+    return windows;
+}
+// Claude Code ends a run refused for the plan's allowance with a 429 whose text is
+// "Claude AI usage limit reached|<epoch seconds>" (the recorded shape), and says so again in
+// the `rate_limit_event` it wrote before it, whose status is then "rejected". A 429 that is
+// neither is an ordinary rate limit and is retried as one.
+export function claudePlanLimit(text, status, info) {
+    const stamped = /usage limit reached\|(\d{9,13})/i.exec(text);
+    if (stamped?.[1] !== undefined)
+        return { account: "claude-code", resetsAt: isoOfEpoch(Number(stamped[1])) };
+    const rejected = info?.status === "rejected";
+    if (!rejected && !(status === 429 && /usage limit|hit your limit|limit reached/i.test(text)))
+        return undefined;
+    const full = [info?.unifiedWindows?.five_hour, info?.unifiedWindows?.seven_day]
+        .filter((one) => (one?.utilization ?? 0) >= 1)
+        .map((one) => isoOfEpoch(one?.resetsAt))
+        .filter((at) => at !== null)
+        .toSorted();
     return {
-        inputTokens: entries.reduce((total, one) => total + one.inputTokens, 0),
-        outputTokens: entries.reduce((total, one) => total + one.outputTokens, 0),
+        account: "claude-code",
+        resetsAt: full.at(-1) ?? (rejected ? isoOfEpoch(info?.resetsAt) : null),
     };
 }

package/dist/adapters/llm/cli-login-error.js

@@ -12,6 +12,6 @@ export function cliLoginError(provider, text) {
             : "codex login";
     return providerError({
         kind: "missing_key",
-        message: `The ${cliName(provider)} is not signed in, or its sign-in has expired. Open a terminal on the computer running the CLI, run "${command}" and sign in, then use Retry stage.`,
+        message: `The ${cliName(provider)} is not signed in, or its sign-in has expired. Open a terminal on the computer running the CLI, run "${command}" and sign in, then use Try again.`,
     });
 }

package/dist/adapters/llm/codex-limits.js

@@ -0,0 +1,157 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { cliCommand } from "../../kernel/cli-command.js";
+import { isoOfEpoch, windowKindOf, } from "../../kernel/ports/plan-limits.js";
+// The Codex plan windows. `codex exec --json` reports none, so they are asked of the CLI's
+// app server with `account/rateLimits/read` - a metadata-only exchange that starts no thread
+// and spends nothing. Measured on 0.155.1: the reply carries `rateLimits.primary` and
+// `.secondary`, each `{ usedPercent, windowDurationMins, resetsAt }` with `resetsAt` in epoch
+// seconds; a ChatGPT Pro plan answered a weekly (10080-minute) primary and no secondary.
+const windowSchema = z
+    .object({
+    usedPercent: z.number(),
+    windowDurationMins: z.number().nullish(),
+    resetsAt: z.number().nullish(),
+})
+    .nullish();
+const readSchema = z.object({
+    rateLimits: z.object({ primary: windowSchema, secondary: windowSchema }),
+});
+export function codexWindows(result) {
+    const parsed = readSchema.safeParse(result);
+    if (!parsed.success)
+        return [];
+    const windows = [];
+    for (const one of [parsed.data.rateLimits.primary, parsed.data.rateLimits.secondary]) {
+        if (one === null || one === undefined)
+            continue;
+        windows.push({
+            kind: windowKindOf(one.windowDurationMins),
+            usedPercent: Math.max(0, Math.min(100, one.usedPercent)),
+            resetsAt: isoOfEpoch(one.resetsAt),
+        });
+    }
+    return windows;
+}
+// Null whenever the answer cannot be had - no CLI, signed out, an older version without the
+// method, a slow start: the windows are reported beside a run, never needed for it.
+export async function nodeCodexLimits(binary, env, timeoutMs = 10_000) {
+    const command = cliCommand(binary);
+    const directory = await mkdtemp(join(tmpdir(), "slopify-codex-limits-"));
+    const child = spawn(command.file, [...command.args, "app-server", "--listen", "stdio://"], {
+        cwd: directory,
+        env: { ...env, PWD: directory },
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    child.on("error", () => { });
+    child.stdin.on("error", () => { });
+    child.stderr.resume();
+    const closed = new Promise((resolve) => child.once("close", () => resolve()));
+    const terminate = (signal) => {
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            try {
+                process.kill(-child.pid, signal);
+                return;
+            }
+            catch {
+                /* The process may already have exited. */
+            }
+        }
+        child.kill(signal);
+    };
+    const timer = setTimeout(() => terminate("SIGKILL"), timeoutMs);
+    const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
+    let buffer = "";
+    try {
+        send({
+            id: 1,
+            method: "initialize",
+            params: { clientInfo: { name: "slopify_limits", version: "1.0" } },
+        });
+        child.stdout.setEncoding("utf8");
+        for await (const piece of child.stdout) {
+            buffer += piece;
+            if (buffer.length > 1024 * 1024)
+                return null;
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf("\n");
+                if (line === "")
+                    continue;
+                const reply = z
+                    .object({ id: z.unknown().optional(), result: z.unknown().optional() })
+                    .safeParse(JSON.parse(line));
+                if (!reply.success)
+                    continue;
+                if (reply.data.id === 1) {
+                    send({ method: "initialized" });
+                    send({ id: 2, method: "account/rateLimits/read" });
+                }
+                else if (reply.data.id === 2) {
+                    const windows = codexWindows(reply.data.result);
+                    return windows.length === 0 ? null : windows;
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+        terminate("SIGTERM");
+        let grace;
+        await Promise.race([
+            closed,
+            new Promise((resolve) => {
+                grace = setTimeout(() => {
+                    terminate("SIGKILL");
+                    resolve();
+                }, 1000);
+            }),
+        ]);
+        clearTimeout(grace);
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+const months = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+// Codex refuses a turn over the plan's allowance with "You've hit your usage limit. … Try
+// again at <time>." (the messages in the 0.155.1 binary). The time is local and written either
+// as "3:04 PM" alone or with a date, "Sep 28th, 2026 3:04 PM". A usage-limit text with no time
+// still counts: the wait then checks again later instead of at a known reset.
+export function codexPlanLimit(message, now) {
+    if (!/hit your usage limit|usage limit reached|usage_limit_reached/i.test(message))
+        return undefined;
+    return { account: "codex", resetsAt: codexRetryAt(message, now) };
+}
+function codexRetryAt(message, now) {
+    const dated = /try again at\s+([A-Za-z]{3})[a-z]*\.?\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+(\d{4})\s+(\d{1,2}):(\d{2})\s*(AM|PM)/i.exec(message);
+    if (dated !== null) {
+        const month = months.indexOf((dated[1] ?? "").toLowerCase());
+        if (month < 0)
+            return null;
+        const at = new Date(Number(dated[3]), month, Number(dated[2]), hour24(Number(dated[4]), dated[6] ?? ""), Number(dated[5]));
+        return Number.isNaN(at.getTime()) ? null : at.toISOString();
+    }
+    const timed = /try again at\s+(\d{1,2}):(\d{2})\s*(AM|PM)/i.exec(message);
+    if (timed === null)
+        return null;
+    const at = new Date(now);
+    at.setHours(hour24(Number(timed[1]), timed[3] ?? ""), Number(timed[2]), 0, 0);
+    // A time already past today is tomorrow's.
+    if (at.getTime() <= now.getTime())
+        at.setDate(at.getDate() + 1);
+    return at.toISOString();
+}
+function hour24(hour, meridiem) {
+    const pm = meridiem.toUpperCase() === "PM";
+    return (hour % 12) + (pm ? 12 : 0);
+}