codex-chatgpt-control 0.2.0-alpha.1 → 0.5.0-alpha.1

package/dist/src/commands/registry.js

@@ -7,8 +7,9 @@ const descriptors = [
         `await chatgpt.askInThread({ thread: { type: "search", query: "Naming macOS Utility" }, prompt: "Continue." });`,
         `await chatgpt.askInThread({ thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true, prompt: "Continue." });`
     ]),
-    workflow("askWithFiles", "Attach absolute local file paths, optionally set mode, ask, wait, and read.", [
-        `await chatgpt.askWithFiles({ thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true, mode: { model: "Pro" }, files: ["/absolute/host/path/brief.md"], prompt: "Summarize this.", wait: true, read: { format: "markdown" } });`
+    workflow("askWithFiles", "Attach absolute local file paths, optionally open/configure Chat or Work, ask, wait, and read.", [
+        `await chatgpt.askWithFiles({ thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true, experience: "chat", configuration: { intelligence: "Pro" }, files: ["/absolute/host/path/brief.md"], prompt: "Summarize this.", wait: true, read: { format: "markdown" } });`,
+        `await chatgpt.askWithFiles({ mode: { model: "Pro" }, files: ["/absolute/host/path/image.jpg"], prompt: "Describe this image.", wait: true });`
     ]),
     workflow("askAndDownload", "Ask ChatGPT to produce a visible downloadable output and save the latest exposed file.", [
         `await chatgpt.askAndDownload({ prompt: "Create a CSV.", download: { destDir: "/absolute/host/output" }, wait: true });`
@@ -16,13 +17,16 @@ const descriptors = [
     workflow("runMessages", "Run sequential prompts where later prompts can use earlier step data.", [
         `await chatgpt.runMessages({ messages: [{ id: "first", prompt: "alpha" }, { id: "second", prompt: "beta" }] });`
     ]),
-    workflow("runner.run", "Agents-style facade: run a visible ChatGPT browser-control agent against input, files, thread, existing-tab, mode, and response options.", [
-        `const agent = chatgpt.agent({ name: "reviewer", instructions: "Review deeply." }); await chatgpt.runner.run(agent, { input: "Review this.", thread: { type: "new" } });`,
+    workflow("runner.run", "Agents-style facade: run a visible ChatGPT agent against input, files, thread, existing-tab, experience, configuration, legacy mode, and response options.", [
+        `const agent = chatgpt.agent({ name: "reviewer", instructions: "Review deeply." }); await chatgpt.runner.run(agent, { input: "Review this.", thread: { type: "new" }, experience: "chat" });`,
         `await chatgpt.runner.run(agent, { input: "Continue.", thread: { type: "url", url: "https://chatgpt.com/c/<conversation-id>" }, existingTab: true });`
     ]),
     workflow("responses.create", "Narrow Responses-shaped adapter over the visible ChatGPT browser-control runner; rejects unsupported API-only fields before prompt submission.", [
         `await chatgpt.responses.create({ input: "Summarize.", thread: { type: "current" }, text: { format: "markdown" }, stream: false });`
     ]),
+    workflow("work.start", "Open Work, optionally apply model/effort/speed configuration, submit one task, and optionally wait/read without blind resubmission.", [
+        `await chatgpt.work.start({ prompt: "Analyze the attached package.", files: ["/absolute/path/package.tgz"], configuration: { model: "GPT-5.6 Sol", effort: "High", speed: "Fast" }, wait: true, read: { format: "markdown" } });`
+    ]),
     workflow("copyLatest", "Copy or DOM-read the latest assistant response with Markdown-first fidelity.", [
         `await chatgpt.copyLatest({ prefer: "clipboard" });`
     ]),
@@ -63,6 +67,14 @@ const descriptors = [
         `await chatgpt.createReport(result, { destDir: "/absolute/host/reports" });`
     ]),
     primitive("session.bootstrap", "Attach to ChatGPT in Chrome and detect login/blocker state.", 30000),
+    primitive("experience.detect", "Detect whether the scoped visible composer is Chat, Work, or unknown and return its selector profile.", 30000),
+    primitive("experience.open", "Open Chat or Work and verify the target surface from scoped composer evidence.", 30000),
+    primitive("configuration.inspect", "Inspect the active Chat or Work selector profile, axes, options, and selected values.", 30000),
+    primitive("configuration.apply", "Apply model/intelligence/effort/speed configuration one axis at a time and verify the final visible state.", 30000),
+    primitive("work.status", "Read current Work task progress and optionally enumerate visible artifacts.", 5000),
+    primitive("work.wait", "Wait for the current Work task response to stabilize.", 120000),
+    primitive("work.steer", "Submit a visible steering message to the current Work task without opening a new task.", 120000),
+    primitive("work.readLatest", "Read the latest response from the current Work task.", 30000),
     primitive("threads.new", "Open a new ChatGPT thread.", 30000),
     primitive("threads.search", "Search visible ChatGPT history by query.", 30000),
     primitive("threads.open", "Open a thread by URL, conversation id, title, or search result.", 30000),
@@ -71,6 +83,7 @@ const descriptors = [
     primitive("messages.ask", "Compose, submit, optionally wait, and optionally read.", 120000),
     primitive("messages.wait", "Wait for the latest assistant response to stabilize.", 120000),
     primitive("messages.readLatest", "Read the latest message as Markdown, normalized text, blocks, or HTML.", 30000),
+    primitive("messages.status", "Read a compact latest-assistant progress snapshot without treating partial text as complete.", 5000),
     primitive("messages.waitAndRead", "Wait for completion and read the latest message.", 120000),
     primitive("artifacts.listLatest", "Detect the latest visible generated ChatGPT artifact, such as an image-only result.", 30000),
     primitive("artifacts.wait", "Wait for a visible generated ChatGPT artifact to appear and stabilize.", 120000),
@@ -82,7 +95,8 @@ const descriptors = [
     primitive("projects.sources.planAdd", "Dry-run an append-only Project Sources file add from explicit local files without opening ChatGPT.", 30000),
     primitive("projects.sources.add", "Append explicit local files to a visible ChatGPT Project Sources list after confirmMutation: true.", 180000),
     primitive("response.copy", "Click Copy response and return clipboard Markdown, with DOM fallback.", 5000),
-    primitive("modes.set", "Select a visible model, intelligence, effort, or nested model-version candidate when unambiguous.", 30000),
+    primitive("modes.set", "Legacy compatibility command: select a visible model/intelligence/effort/version candidate with historical warning-oriented verification.", 30000),
+    primitive("modes.get", "Legacy compatibility command: read mode labels shown on visible composer controls without changing them.", 30000),
     primitive("tools.select", "Select a visible ChatGPT tool when unambiguous.", 30000)
 ];
 export function commandDescriptors() {
@@ -190,12 +204,24 @@ function workflowArgs(name) {
         return { first: "first message", second: "second message" };
     if (name === "new-ask-read")
         return { prompt: "message to send" };
+    if (name === "work.start") {
+        return {
+            prompt: "visible Work task prompt",
+            newTask: "start from a blank Work task; defaults to true",
+            files: "optional absolute local file paths",
+            configuration: "optional Work model, effort, and speed values",
+            wait: "optional wait behavior",
+            read: "optional response capture behavior"
+        };
+    }
     if (name === "askWithFiles") {
         return {
             files: "absolute local file paths to attach before submitting",
             prompt: "message to send after files are attached",
             thread: "optional thread selector",
             existingTab: "true or explicit policy to claim a user-open Chrome tab instead of opening a replacement",
+            experience: "optional chat or work surface",
+            configuration: "optional strict visible configuration such as { intelligence: \"Pro\" } or Work model/effort/speed",
             mode: "optional visible mode selection, e.g. { model: \"Pro\" } or { intelligence: \"Pro\", modelVersion: \"5.4\" }",
             wait: "true or wait options; defaults to true",
             read: "true or read options such as { format: \"markdown\" }; defaults to Markdown",
@@ -206,6 +232,9 @@ function workflowArgs(name) {
         prompt: "message to send or workflow-specific input",
         thread: "optional thread selector",
         existingTab: "true or explicit policy to claim a user-open Chrome tab instead of opening a replacement",
+        experience: "optional chat or work surface",
+        configuration: "optional surface-aware visible configuration",
+        mode: "legacy visible mode preference",
         report: "optional redacted report settings"
     };
 }
@@ -232,8 +261,34 @@ function reportArgs(name) {
     return { result: "CommandResult to persist", destDir: "optional report directory" };
 }
 function primitiveArgs(name) {
+    if (name === "messages.wait")
+        return {
+            timeoutMs: "optional wait timeout",
+            stableMs: "optional stability window before completion",
+            pollMs: "optional polling interval",
+            mode: "normal or deep_research",
+            responseContent: "include for current behavior, metadata to omit assistant text and return chars/hash only"
+        };
     if (name === "messages.readLatest")
         return { role: "assistant or user", format: "markdown, normalized_text, visible_text, html, blocks, or all" };
+    if (name === "messages.status")
+        return { maxPreviewChars: "maximum latest-assistant preview characters to return; defaults to 240" };
+    if (name === "experience.detect")
+        return { timeoutMs: "optional timeout for attaching to the ChatGPT page" };
+    if (name === "experience.open")
+        return { experience: "chat or work", timeoutMs: "optional verified-switch timeout" };
+    if (name === "configuration.inspect")
+        return { experience: "optional expected chat or work surface", includeOptions: "open visible axis menus to enumerate options; defaults to true", timeoutMs: "optional inspection timeout" };
+    if (name === "configuration.apply")
+        return { experience: "optional target chat or work surface", desired: "model, intelligence, effort, speed, and/or modelVersion values", strict: "fail when visible postconditions are not verified; defaults to true", timeoutMs: "optional selection timeout" };
+    if (name === "work.status")
+        return { includeArtifacts: "include the latest visible artifact inventory; defaults to false for lightweight polling", maxPreviewChars: "maximum assistant preview characters" };
+    if (name === "work.wait")
+        return { timeoutMs: "optional Work wait timeout", stableMs: "required response stability window", pollMs: "polling interval" };
+    if (name === "work.steer")
+        return { prompt: "visible steering message for the current task", wait: "optional wait behavior", read: "optional response capture behavior" };
+    if (name === "work.readLatest")
+        return { format: "markdown, normalized_text, visible_text, html, blocks, or all", maxChars: "optional capture limit" };
     if (name === "artifacts.listLatest")
         return { kind: "artifact kind; currently image", max: "maximum artifacts to return" };
     if (name === "artifacts.wait")
@@ -245,7 +300,18 @@ function primitiveArgs(name) {
     if (name.startsWith("threads.search"))
         return { query: "history search query" };
     if (name === "files.preflight")
-        return { paths: "absolute local file paths", maxBytesPerFile: "optional local per-file byte limit", maxTotalBytes: "optional local total byte limit" };
+        return {
+            paths: "absolute local file paths",
+            maxBytesPerFile: "optional local per-file byte limit",
+            maxTotalBytes: "optional local total byte limit",
+            includeHashes: "optional SHA-256 metadata for diagnostics; file contents are not returned"
+        };
+    if (name === "files.attach")
+        return {
+            paths: "absolute local file paths",
+            includeDiagnostics: "optional preflight and browser input file-size metadata",
+            includeHashes: "optional SHA-256 metadata inside diagnostics; file contents are not returned"
+        };
     if (name.startsWith("files.attach"))
         return { paths: "absolute local file paths" };
     if (name === "projects.sources.list")
@@ -264,6 +330,11 @@ function primitiveArgs(name) {
             timeoutMs: "optional timeout for opening and selecting the visible mode menu"
         };
     }
+    if (name === "modes.get") {
+        return {
+            timeoutMs: "optional timeout for attaching to the ChatGPT page"
+        };
+    }
     return {};
 }
 function primitiveExamples(name) {
@@ -275,9 +346,32 @@ function primitiveExamples(name) {
             `await chatgpt.askWithFiles({ mode: { model: "Pro" }, files: ["/absolute/host/path.jpg"], prompt: "Describe this image.", wait: true });`
         ];
     }
+    if (name === "modes.get") {
+        return [
+            `await chatgpt.modes.get();`,
+            `// Verify an expensive Pro consult before submitting: const current = await chatgpt.modes.get();`
+        ];
+    }
+    if (name === "experience.detect")
+        return [`await chatgpt.experience.detect();`];
+    if (name === "experience.open")
+        return [`await chatgpt.experience.open({ experience: "work" });`];
+    if (name === "configuration.inspect")
+        return [`await chatgpt.configuration.inspect({ experience: "work" });`];
+    if (name === "configuration.apply")
+        return [`await chatgpt.configuration.apply({ experience: "work", desired: { model: "GPT-5.6 Sol", effort: "High", speed: "Fast" }, strict: true });`];
+    if (name === "work.status")
+        return [`await chatgpt.work.status();`];
+    if (name === "work.wait")
+        return [`await chatgpt.work.wait({ timeoutMs: 600000 });`];
+    if (name === "work.steer")
+        return [`await chatgpt.work.steer({ prompt: "Focus the comparison on deployment ergonomics." });`];
+    if (name === "work.readLatest")
+        return [`await chatgpt.work.readLatest({ format: "markdown" });`];
     if (name === "files.preflight") {
         return [
-            `await chatgpt.files.preflight({ paths: ["/absolute/host/path.md"] });`
+            `await chatgpt.files.preflight({ paths: ["/absolute/host/path.md"] });`,
+            `await chatgpt.files.preflight({ paths: ["/absolute/host/path.md"], includeHashes: true });`
         ];
     }
     if (name === "files.attach") {
@@ -313,7 +407,7 @@ function primitiveBlockers(name) {
         return ["browser_bridge_unavailable", "login_required", "selector_drift", "confirmation", "permission", "upload_failed"];
     if (name.startsWith("artifacts."))
         return ["browser_bridge_unavailable", "login_required", "artifact_unavailable", "artifact_selector_drift", "artifact_download_unavailable"];
-    if (name.startsWith("modes.") || name.startsWith("tools."))
+    if (name.startsWith("modes.") || name.startsWith("tools.") || name.startsWith("experience.") || name.startsWith("configuration.") || name.startsWith("work."))
         return ["browser_bridge_unavailable", "login_required", "selector_drift"];
     return commonBlockers();
 }

package/dist/src/commands/reports.js

@@ -23,7 +23,7 @@ export async function createRunReport(env, result, options = {}) {
         }, options);
         const report = {
             schemaVersion: 1,
-            createdAt: new Date().toISOString(),
+            createdAt,
             includeContent,
             summary,
             steps: result.steps?.map(step => ({

package/dist/src/commands/response-actions.js

@@ -6,7 +6,7 @@ import { readLatestMessage, readMessages } from "../dom/messages.js";
 import { copyResponseButtons } from "../dom/selectors.js";
 import { contextFromPage } from "./context.js";
 import { withCommandOutputText } from "./output.js";
-import { bootstrap } from "./session.js";
+import { ensurePage } from "./session.js";
 export async function copyResponse(env, args = {}) {
     const boot = await ensurePage(env);
     if (!boot.ok) {
@@ -166,9 +166,3 @@ function mergeResponseMetadata(data, latest) {
     if (latest.sourcesAvailable !== undefined)
         data.sourcesAvailable = latest.sourcesAvailable;
 }
-async function ensurePage(env) {
-    if (env.page !== undefined) {
-        return resultOk({}, await contextFromPage(env.page));
-    }
-    return bootstrap(env, { preferExistingTab: true });
-}

package/dist/src/commands/sequence.js

@@ -1,12 +1,15 @@
 import { downloadLatestArtifact, listLatestArtifacts, waitForArtifact } from "./artifacts.js";
+import { applyConfiguration, inspectConfiguration } from "./configuration.js";
+import { detectExperience, openExperience } from "./experience.js";
 import { attachFiles, downloadLatestFile } from "./files.js";
 import { addProjectSources, buildProjectSourceAddPlan, listProjectSources } from "./project-sources.js";
-import { askMessage, composeMessage, readLatest, submitMessage, waitAndRead, waitForMessage } from "./messages.js";
+import { askMessage, composeMessage, messageStatus, readLatest, submitMessage, waitAndRead, waitForMessage } from "./messages.js";
 import { copyResponse } from "./response-actions.js";
 import { bootstrap } from "./session.js";
 import { newThread, openThread, searchThreads } from "./threads.js";
 import { setMode, selectTool } from "./modes.js";
 import { withCommandOutputText } from "./output.js";
+import { readLatestWork, startWork, steerWork, waitForWork, workStatus } from "./work.js";
 export const defaultSequencePolicy = {
     stopOnError: true,
     returnPartial: true,
@@ -43,6 +46,24 @@ export async function executeStep(step, env, previousResults) {
     switch (step.command) {
         case "session.bootstrap":
             return bootstrap(env, step.args);
+        case "experience.detect":
+            return detectExperience(env, step.args);
+        case "experience.open":
+            return openExperience(env, step.args);
+        case "configuration.inspect":
+            return inspectConfiguration(env, step.args);
+        case "configuration.apply":
+            return applyConfiguration(env, step.args);
+        case "work.start":
+            return startWork(env, step.args);
+        case "work.status":
+            return workStatus(env, step.args);
+        case "work.wait":
+            return waitForWork(env, step.args);
+        case "work.steer":
+            return steerWork(env, step.args);
+        case "work.readLatest":
+            return readLatestWork(env, step.args);
         case "threads.search":
             return searchThreads(env, step.args);
         case "threads.open":
@@ -59,6 +80,8 @@ export async function executeStep(step, env, previousResults) {
             return waitForMessage(env, step.args);
         case "messages.readLatest":
             return readLatest(env, step.args);
+        case "messages.status":
+            return messageStatus(env, step.args);
         case "messages.waitAndRead":
             return waitAndRead(env, step.args);
         case "artifacts.listLatest":

package/dist/src/commands/session.d.ts

@@ -1,2 +1,4 @@
 import type { BootstrapArgs, BootstrapData, CommandResult, RuntimeEnv } from "../types.js";
 export declare function bootstrap(env: RuntimeEnv, args?: BootstrapArgs): Promise<CommandResult<BootstrapData>>;
+export declare function ensurePage(env: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function verifyTabAffinity(env: RuntimeEnv): Promise<CommandResult<unknown> | undefined>;

package/dist/src/commands/session.js

@@ -1,4 +1,4 @@
-import { attachChatGPTBrowser } from "../browser/attach.js";
+import { attachChatGPTBrowser, tabIdFromPage } from "../browser/attach.js";
 import { readPageState } from "../browser/page-state.js";
 import { resultError, resultOk } from "../errors.js";
 import { contextFromPage } from "./context.js";
@@ -7,6 +7,9 @@ export async function bootstrap(env, args = {}) {
         const attached = await attachChatGPTBrowser(env, args);
         env.browser = attached.browser;
         env.page = attached.page;
+        if (attached.tabId !== undefined) {
+            env.expectedTabId = attached.tabId;
+        }
         const state = await readPageState(attached.page);
         const data = {
             browserName: attached.browserName,
@@ -23,3 +26,49 @@ export async function bootstrap(env, args = {}) {
         return resultError(error instanceof Error ? error : new Error(String(error)));
     }
 }
+export async function ensurePage(env) {
+    if (env.page === undefined) {
+        return bootstrap(env, { preferExistingTab: true });
+    }
+    const affinity = await verifyTabAffinity(env);
+    if (affinity !== undefined) {
+        return affinity;
+    }
+    return resultOk({}, await contextFromPage(env.page, tabContext(env)));
+}
+export async function verifyTabAffinity(env) {
+    if (env.expectedTabId === undefined || env.page === undefined) {
+        return undefined;
+    }
+    const actualTabId = tabIdFromPage(env.page);
+    if (actualTabId === env.expectedTabId) {
+        return undefined;
+    }
+    const code = actualTabId === undefined ? "tab_affinity_unverifiable" : "tab_affinity_lost";
+    const message = actualTabId === undefined
+        ? `ChatGPT command cannot verify it is still attached to expected tab ${env.expectedTabId}.`
+        : `ChatGPT command would run on tab ${actualTabId}, but the workflow expected tab ${env.expectedTabId}.`;
+    return {
+        ok: false,
+        status: "blocked",
+        warnings: [],
+        blocker: {
+            kind: "selector_drift",
+            code,
+            message,
+            remediation: [
+                {
+                    label: "Reclaim the intended tab",
+                    instruction: "Run session.bootstrap again with an exact existingTab target, or pass the correct page/tab to createChatGPT before retrying.",
+                    userActionRequired: false
+                }
+            ],
+            resumable: false
+        },
+        context: await contextFromPage(env.page, tabContext(env, actualTabId))
+    };
+}
+function tabContext(env, actualTabId = tabIdFromPage(env.page)) {
+    const tabId = actualTabId ?? env.expectedTabId;
+    return tabId === undefined ? {} : { tabId };
+}

package/dist/src/commands/threads.js

@@ -1,11 +1,11 @@
 import { parseConversationId, readPageState } from "../browser/page-state.js";
 import { resultError, resultOk } from "../errors.js";
-import { countPageMessages, readLatestMessageText } from "../dom/messages.js";
 import { requiredLocator, searchChatsButton, searchChatsInput, newChatButton } from "../dom/selectors.js";
 import { anyLabelPattern, localeLabels } from "../dom/locale-labels.js";
 import { normalizeWhitespace, stripTags } from "../dom/visible-text.js";
 import { contextFromPage } from "./context.js";
-import { bootstrap } from "./session.js";
+import { ensureConversationTarget } from "./conversation.js";
+import { ensurePage } from "./session.js";
 const CHATGPT_HOME = "https://chatgpt.com/";
 export function extractThreadSearchResultsFromHtml(html) {
     const anchors = html.matchAll(/<a\b(?<attrs>[^>]*\bhref=["'](?<href>\/c\/[^"']+)["'][^>]*)>(?<body>[\s\S]*?)<\/a>/gi);
@@ -100,13 +100,7 @@ export async function openThread(env, args, previousResults) {
                 context: await contextFromPage(page)
             };
         }
-        if (target.href !== undefined && target.href.startsWith("/")) {
-            await page.goto?.(new URL(target.href, CHATGPT_HOME).toString(), { waitUntil: "domcontentloaded", timeout: args.timeoutMs ?? 30000 });
-        }
-        else {
-            await page.goto?.(target.href ?? target.url, { waitUntil: "domcontentloaded", timeout: args.timeoutMs ?? 30000 });
-        }
-        await waitForThreadHydrated(page, args.timeoutMs ?? 30000, parseConversationId(target.url));
+        await ensureConversationTarget(page, target, { timeoutMs: args.timeoutMs ?? 30000 });
         const state = await readPageState(page);
         return resultOk(openThreadData(state.url, state.conversationId, state.title ?? target.title), await contextFromPage(page));
     }
@@ -114,12 +108,6 @@ export async function openThread(env, args, previousResults) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
-async function ensurePage(env) {
-    if (env.page !== undefined) {
-        return resultOk({}, await contextFromPage(env.page));
-    }
-    return bootstrap(env, { preferExistingTab: true });
-}
 async function resolveOpenTarget(env, args, previousResults) {
     if (args.url !== undefined) {
         return { url: args.url };
@@ -283,19 +271,3 @@ function filterResultsByQuery(results, query) {
         return haystack.includes(wanted) || wanted.includes(normalizeForMatch(result.title));
     });
 }
-async function waitForThreadHydrated(page, timeoutMs, expectedConversationId) {
-    const started = Date.now();
-    await page.waitForTimeout?.(1000);
-    while (Date.now() - started < timeoutMs) {
-        const url = typeof page.url === "function" ? await Promise.resolve(page.url()).catch(() => "") : "";
-        const urlMatches = expectedConversationId === undefined || url.includes(expectedConversationId);
-        const count = await countPageMessages(page).catch(() => 0);
-        const latestAssistantText = await readLatestMessageText(page, "assistant").catch(() => undefined);
-        const title = typeof page.title === "function" ? await page.title().catch(() => "") : "";
-        if (urlMatches && ((latestAssistantText?.trim().length ?? 0) > 0 || (count > 0 && title.length > 0 && title !== "ChatGPT"))) {
-            await page.waitForTimeout?.(250);
-            return;
-        }
-        await page.waitForTimeout?.(500);
-    }
-}

package/dist/src/commands/work.d.ts

@@ -0,0 +1,6 @@
+import type { CommandResult, ReadWorkLatestArgs, ReadWorkLatestData, RuntimeEnv, StartWorkArgs, StartWorkData, SteerWorkArgs, SteerWorkData, WorkStatusArgs, WorkStatusData, WorkWaitArgs, WorkWaitData } from "../types.js";
+export declare function startWork(env: RuntimeEnv, args: StartWorkArgs): Promise<CommandResult<StartWorkData>>;
+export declare function workStatus(env: RuntimeEnv, args?: WorkStatusArgs): Promise<CommandResult<WorkStatusData>>;
+export declare function waitForWork(env: RuntimeEnv, args?: WorkWaitArgs): Promise<CommandResult<WorkWaitData>>;
+export declare function steerWork(env: RuntimeEnv, args: SteerWorkArgs): Promise<CommandResult<SteerWorkData>>;
+export declare function readLatestWork(env: RuntimeEnv, args?: ReadWorkLatestArgs): Promise<CommandResult<ReadWorkLatestData>>;