@longtable/cli 0.1.54 → 0.1.56

package/dist/cli.js

@@ -18,8 +18,9 @@ import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodex
 import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router.js";
 import { PERSONA_DEFINITIONS, listRoleDefinitions } from "./personas.js";
 import { buildPanelFallback, renderPanelSummary } from "./panel.js";
+import { createPanelWorkerRun, launchPanelWorkerRun, panelWorkerRunPath, readPanelWorkerRun, refreshPanelWorkerRun, requestPanelWorkerStop, resumePanelWorkerRun, waitForPanelWorkerRun } from "./panel-runtime.js";
 import { LONGTABLE_MANAGED_HOOK_EVENTS, codexHooksEnabled, enableCodexHooksFeature, getMissingManagedCodexHookEvents, getMissingManagedCodexHookTrustState, mergeCodexHookTrustState, mergeManagedCodexHooksConfig, removeCodexHookTrustState, removeManagedCodexHooks } from "./codex-hooks.js";
-import { appendInvocationRecordToWorkspace, applyResearchSpecificationPatch, assertWorkspaceNotBlocked, answerWorkspaceQuestion, buildQuestionOpportunitySpecs, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, diffResearchSpecifications, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, findUnincorporatedResearchEvidence, proposeResearchSpecificationPatch, pruneWorkspaceQuestions, readResearchSpecificationHistory, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
+import { appendInvocationRecordToWorkspace, applyResearchSpecificationPatch, assertWorkspaceNotBlocked, answerWorkspaceQuestion, buildQuestionOpportunitySpecs, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, createWorkspaceHandoff, diffResearchSpecifications, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, findUnincorporatedResearchEvidence, proposeResearchSpecificationPatch, pruneWorkspaceQuestions, readResearchSpecificationHistory, recordPanelResultInWorkspace, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
 import { buildTeamDebate } from "./debate.js";
 import { createPromptRenderer } from "./prompt-renderer.js";
 const VALID_MODES = new Set([
@@ -158,7 +159,12 @@ function usage() {
         "  longtable clarify --prompt <task-context> [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json] [--force]",
         "  longtable question --prompt <decision-context> [--title <text>] [--text <question>] [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json]",
         "  longtable clear-question --question <id> --reason <text> [--cwd <path>] [--json]",
-        "  longtable panel [--prompt <text>] [--role <role[,role]>] [--mode review|critique|draft|commit] [--visibility synthesis_only|show_on_conflict|always_visible] [--print] [--json] [--setup <path>] [--cwd <path>]",
+        "  longtable panel [--prompt <text>] [--role <role[,role]>] [--mode review|critique|draft|commit] [--visibility synthesis_only|show_on_conflict|always_visible] [--provider codex|claude] [--native-workers|--native-subagents] [--wait [ms]] [--print] [--json] [--setup <path>] [--cwd <path>]",
+        "  longtable panel status --run <panel_run_id> [--wait [ms]] [--cwd <path>] [--json]",
+        "  longtable panel stop --run <panel_run_id> [--cwd <path>] [--json]",
+        "  longtable panel resume --run <panel_run_id> [--wait [ms]] [--cwd <path>] [--json]",
+        "  longtable panel record [--invocation <id>] --result-file <json> [--surface sequential_fallback|native_subagents|native_workers] [--cwd <path>] [--json]",
+        "  longtable handoff [--cwd <path>] [--output <file>] [--print] [--json]",
         "  longtable decide [--question <id>] --answer <value-or-text> [--rationale <text>] [--provider codex|claude] [--cwd <path>] [--json]",
         "  longtable explore|review|critique|draft|commit|submit [--prompt <text>] [--role <role[,role]>] [--panel] [--show-conflicts] [--show-deliberation] [--print] [--json] [--stage <stage>] [--setup <path>] [--cwd <path>]",
         "  longtable codex persist-init [--answers-json <json> | --stdin | full setup flags] [--install-skills] [--install-prompts] [--json]",
@@ -194,7 +200,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "audit", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "prune-questions", "panel", "decide", "sentinel", "team", "access", "search", "spec"].includes(command);
+    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "audit", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "prune-questions", "panel", "handoff", "decide", "sentinel", "access", "search", "spec"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -203,7 +209,7 @@ function parseArgs(argv) {
     else if (command === "codex" || command === "claude" || command === "mcp") {
         startIndex = 2;
     }
-    else if ((command === "access" || command === "search" || command === "spec") && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
+    else if ((command === "access" || command === "search" || command === "spec" || command === "panel") && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
         subcommand = maybeSubcommand;
         startIndex = 2;
     }
@@ -2302,6 +2308,132 @@ function parsePanelMode(value) {
     }
     return "review";
 }
+function requireRunId(args) {
+    if (typeof args.run !== "string" || args.run.trim().length === 0) {
+        throw new Error("A panel run id is required. Pass --run <panel_run_id>.");
+    }
+    return args.run.trim();
+}
+function commandAvailable(command) {
+    try {
+        execSync(`command -v ${command}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseWaitMs(value) {
+    if (value === undefined || value === false) {
+        return undefined;
+    }
+    if (value === true) {
+        return 30_000;
+    }
+    const trimmed = value.trim();
+    const multiplier = trimmed.endsWith("s") ? 1000 : 1;
+    const numeric = Number.parseInt(trimmed.endsWith("s") ? trimmed.slice(0, -1) : trimmed, 10);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        throw new Error(`Invalid --wait value: ${value}. Use milliseconds or a value like 30s.`);
+    }
+    return numeric * multiplier;
+}
+function panelWorkerNextCommands(context, runId) {
+    const cwdFlag = `--cwd "${context.project.projectPath}"`;
+    return {
+        status: `longtable panel status ${cwdFlag} --run ${runId}`,
+        stop: `longtable panel stop ${cwdFlag} --run ${runId}`,
+        resume: `longtable panel resume ${cwdFlag} --run ${runId}`
+    };
+}
+async function recordTerminalNativeWorkerRun(context, run) {
+    if ((run.status !== "completed" && run.status !== "blocked") || !existsSync(run.aggregateResultPath)) {
+        return null;
+    }
+    const aggregate = JSON.parse(await readFile(run.aggregateResultPath, "utf8"));
+    return recordPanelResultInWorkspace({
+        context,
+        result: {
+            ...aggregate,
+            invocationId: run.invocationId,
+            surface: "native_workers",
+            status: aggregate.status ?? run.status
+        }
+    });
+}
+function summarizePanelRecordOutput(result) {
+    if (!result) {
+        return null;
+    }
+    return {
+        invocationId: result.invocation.id,
+        status: result.invocation.status,
+        surface: result.invocation.surface,
+        evidenceRecordIds: result.evidenceRecords.map((record) => record.id)
+    };
+}
+async function runPanelStatusCommand(args) {
+    const context = await requireWorkspaceContext(args);
+    const runId = requireRunId(args);
+    const waitMs = parseWaitMs(args.wait);
+    const initial = await refreshPanelWorkerRun(await readPanelWorkerRun(context.project.projectPath, runId));
+    const refreshed = waitMs ? await waitForPanelWorkerRun(initial.run, waitMs) : initial.run;
+    const recordedPanelResult = await recordTerminalNativeWorkerRun(context, refreshed);
+    const nextCommands = panelWorkerNextCommands(context, refreshed.id);
+    if (args.json === true) {
+        console.log(JSON.stringify({ ...refreshed, nextCommands, recordedPanelResult: summarizePanelRecordOutput(recordedPanelResult) }, null, 2));
+        return;
+    }
+    console.log("LongTable panel run status");
+    console.log(`- run: ${refreshed.id}`);
+    console.log(`- status: ${refreshed.status}`);
+    for (const worker of refreshed.workers) {
+        console.log(`- ${worker.label} (${worker.role}): ${worker.status}`);
+    }
+    console.log(`- stop: ${nextCommands.stop}`);
+    console.log(`- resume: ${nextCommands.resume}`);
+    if (recordedPanelResult) {
+        console.log(`- recorded evidence: ${recordedPanelResult.evidenceRecords.length}`);
+    }
+}
+async function runPanelStopCommand(args) {
+    const context = await requireWorkspaceContext(args);
+    const runId = requireRunId(args);
+    const stopped = await requestPanelWorkerStop(await readPanelWorkerRun(context.project.projectPath, runId));
+    const nextCommands = panelWorkerNextCommands(context, stopped.id);
+    if (args.json === true) {
+        console.log(JSON.stringify({ ...stopped, nextCommands }, null, 2));
+        return;
+    }
+    console.log("LongTable panel run stop requested");
+    console.log(`- run: ${stopped.id}`);
+    console.log(`- status: ${stopped.status}`);
+    for (const worker of stopped.workers) {
+        console.log(`- ${worker.label} (${worker.role}): ${worker.status}`);
+    }
+    console.log(`- resume: ${nextCommands.resume}`);
+}
+async function runPanelResumeCommand(args) {
+    const context = await requireWorkspaceContext(args);
+    const runId = requireRunId(args);
+    const waitMs = parseWaitMs(args.wait);
+    const { run } = await refreshPanelWorkerRun(await readPanelWorkerRun(context.project.projectPath, runId));
+    const resumed = run.status === "completed" ? run : await launchPanelWorkerRun(await resumePanelWorkerRun(run));
+    const finalRun = waitMs ? await waitForPanelWorkerRun(resumed, waitMs) : resumed;
+    const recordedPanelResult = await recordTerminalNativeWorkerRun(context, finalRun);
+    const nextCommands = panelWorkerNextCommands(context, finalRun.id);
+    if (args.json === true) {
+        console.log(JSON.stringify({ ...finalRun, nextCommands, recordedPanelResult: summarizePanelRecordOutput(recordedPanelResult) }, null, 2));
+        return;
+    }
+    console.log("LongTable panel run resume requested");
+    console.log(`- run: ${finalRun.id}`);
+    console.log(`- status: ${finalRun.status}`);
+    console.log(`- status command: ${nextCommands.status}`);
+    if (recordedPanelResult) {
+        console.log(`- recorded evidence: ${recordedPanelResult.evidenceRecords.length}`);
+    }
+}
 async function loadOptionalSetup(path) {
     try {
         return await loadSetupOutput(path);
@@ -2388,7 +2520,9 @@ async function runPanelCommand(args) {
         await assertWorkspaceNotBlocked(existingContext);
     }
     const projectAware = await buildProjectAwarePrompt(prompt, workingDirectory);
-    const provider = setup?.providerSelection.provider;
+    const provider = args.provider === "codex" || args.provider === "claude"
+        ? args.provider
+        : setup?.providerSelection.provider;
     const visibility = parsePanelVisibility(typeof args.visibility === "string" ? args.visibility : undefined) ??
         parsePanelVisibility(setup?.profileSeed.panelPreference) ??
         "always_visible";
@@ -2398,7 +2532,9 @@ async function runPanelCommand(args) {
         mode,
         roleFlag: typeof args.role === "string" ? args.role : undefined,
         provider,
-        visibility
+        visibility,
+        nativeSubagents: args["native-subagents"] === true,
+        nativeWorkers: args["native-workers"] === true
     });
     if (projectAware.projectContextFound) {
         const context = await loadProjectContextFromDirectory(workingDirectory);
@@ -2406,6 +2542,30 @@ async function runPanelCommand(args) {
             await appendInvocationRecordToWorkspace(context, fallback.invocationRecord, [fallback.questionRecord]);
         }
     }
+    if (args.print === true) {
+        console.log(fallback.prompt);
+        return;
+    }
+    const waitMs = parseWaitMs(args.wait);
+    const nativeWorkersRequested = args["native-workers"] === true && fallback.plan.preferredSurface === "native_workers";
+    const nativeRunContext = nativeWorkersRequested
+        ? await loadProjectContextFromDirectory(workingDirectory)
+        : null;
+    const nativeRun = nativeWorkersRequested && nativeRunContext
+        ? await launchPanelWorkerRun(await createPanelWorkerRun({
+            workingDirectory: nativeRunContext.project.projectPath,
+            fallback,
+            initialStatus: "planned",
+            diagnostics: [
+                commandAvailable("tmux") ? "tmux:available" : "tmux:unavailable",
+                commandAvailable("codex") ? "codex:available" : "codex:unavailable"
+            ]
+        }))
+        : null;
+    const finalNativeRun = nativeRun && waitMs ? await waitForPanelWorkerRun(nativeRun, waitMs) : nativeRun;
+    const recordedPanelResult = finalNativeRun && nativeRunContext
+        ? await recordTerminalNativeWorkerRun(nativeRunContext, finalNativeRun)
+        : null;
     if (args.json === true) {
         console.log(JSON.stringify({
             intent: fallback.intent,
@@ -2414,22 +2574,51 @@ async function runPanelCommand(args) {
             invocationRecord: fallback.invocationRecord,
             questionRecord: fallback.questionRecord,
             execution: {
-                status: "planned",
+                status: finalNativeRun?.status ?? "planned",
                 stableSurface: "sequential_fallback",
-                nativeParallel: "not_required_for_option_a",
+                preferredSurface: fallback.plan.preferredSurface,
+                nativeParallel: fallback.plan.preferredSurface === "native_workers"
+                    ? "longtable_native_workers"
+                    : fallback.plan.preferredSurface === "native_subagents"
+                        ? "session_dependent"
+                        : "not_requested",
                 projectContextFound: projectAware.projectContextFound,
-                invocationLogged: projectAware.projectContextFound
+                invocationLogged: projectAware.projectContextFound,
+                nativeRunCreated: Boolean(finalNativeRun),
+                waitMs,
+                degradedReason: nativeWorkersRequested && !finalNativeRun
+                    ? "native workers require an existing LongTable workspace; sequential fallback prompt returned"
+                    : finalNativeRun?.status === "degraded"
+                        ? "native workers require local tmux and codex commands; sequential fallback remains available"
+                        : undefined
             },
+            nativeRun: finalNativeRun,
+            recordedPanelResult: summarizePanelRecordOutput(recordedPanelResult),
             fallbackPrompt: fallback.prompt
         }, null, 2));
         return;
     }
-    if (args.print === true) {
-        console.log(fallback.prompt);
-        return;
-    }
     console.log(renderPanelSummary(fallback.plan));
     console.log("");
+    if (finalNativeRun) {
+        console.log("LongTable native panel worker run created");
+        console.log(`- run: ${finalNativeRun.id}`);
+        console.log(`- status: ${finalNativeRun.status}`);
+        console.log(`- state: ${panelWorkerRunPath(nativeRunContext.project.projectPath, finalNativeRun.id)}`);
+        const nextCommands = panelWorkerNextCommands(nativeRunContext, finalNativeRun.id);
+        console.log(`- next status: ${nextCommands.status}`);
+        console.log(`- stop: ${nextCommands.stop}`);
+        console.log(`- resume: ${nextCommands.resume}`);
+        if (recordedPanelResult) {
+            console.log(`- recorded evidence: ${recordedPanelResult.evidenceRecords.length}`);
+        }
+        if (finalNativeRun.status === "degraded") {
+            console.log("- degraded: native workers are unavailable; use the sequential fallback prompt below.");
+            console.log("");
+            console.log(fallback.prompt);
+        }
+        return;
+    }
     const exitCode = await runCodexThinWrapper({
         prompt: fallback.prompt,
         mode,
@@ -2439,6 +2628,106 @@ async function runPanelCommand(args) {
     });
     exit(exitCode);
 }
+function parseInvocationSurface(value) {
+    if (value === undefined || value === true) {
+        return undefined;
+    }
+    const allowed = [
+        "native_parallel",
+        "native_subagents",
+        "native_workers",
+        "generated_skill",
+        "prompt_alias",
+        "sequential_fallback",
+        "file_backed_panel_debate",
+        "file_backed_debate",
+        "mcp_transport"
+    ];
+    if (allowed.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid panel result surface: ${value}.`);
+}
+function parseInvocationStatus(value) {
+    if (value === undefined || value === true) {
+        return undefined;
+    }
+    const allowed = ["planned", "running", "completed", "blocked", "degraded", "error"];
+    if (allowed.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid panel result status: ${value}.`);
+}
+async function readPanelResultRecordInput(args) {
+    const resultFile = typeof args["result-file"] === "string" ? args["result-file"] : undefined;
+    const baseDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
+    const fromFile = resultFile
+        ? JSON.parse(await readFile(resolve(baseDirectory, resultFile), "utf8"))
+        : {};
+    const result = {
+        ...fromFile,
+        ...(typeof args.invocation === "string" ? { invocationId: args.invocation } : {}),
+        ...(typeof args.synthesis === "string" ? { synthesis: args.synthesis } : {}),
+        ...(typeof args["conflict-summary"] === "string" ? { conflictSummary: args["conflict-summary"] } : {}),
+        ...(typeof args["decision-prompt"] === "string" ? { decisionPrompt: args["decision-prompt"] } : {}),
+        ...(parseInvocationSurface(args.surface) ? { surface: parseInvocationSurface(args.surface) } : {}),
+        ...(parseInvocationStatus(args.status) ? { status: parseInvocationStatus(args.status) } : {})
+    };
+    if (!result.synthesis &&
+        !result.conflictSummary &&
+        !result.decisionPrompt &&
+        (!result.memberResults || result.memberResults.length === 0)) {
+        throw new Error("Panel result content is required. Pass --result-file with synthesis, conflictSummary, decisionPrompt, or memberResults.");
+    }
+    return result;
+}
+async function runPanelRecordCommand(args) {
+    const context = await requireWorkspaceContext(args);
+    const resultInput = await readPanelResultRecordInput(args);
+    const result = await recordPanelResultInWorkspace({
+        context,
+        result: resultInput
+    });
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            invocation: result.invocation,
+            evidenceRecords: result.evidenceRecords,
+            files: {
+                state: context.stateFilePath,
+                current: context.currentFilePath
+            }
+        }, null, 2));
+        return;
+    }
+    console.log("LongTable panel result recorded");
+    console.log(`- invocation: ${result.invocation.id}`);
+    console.log(`- status: ${result.invocation.status}`);
+    console.log(`- surface: ${result.invocation.surface}`);
+    console.log(`- evidence records: ${result.evidenceRecords.length}`);
+    console.log(`- unincorporated evidence: longtable spec unincorporated --cwd "${context.project.projectPath}"`);
+    console.log(`- next handoff: longtable handoff --cwd "${context.project.projectPath}"`);
+}
+async function runHandoff(args) {
+    const context = await requireWorkspaceContext(args);
+    const result = await createWorkspaceHandoff({
+        context,
+        outputPath: typeof args.output === "string" ? args.output : undefined
+    });
+    if (args.json === true) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (args.print === true) {
+        console.log(result.content);
+        return;
+    }
+    console.log("LongTable handoff created");
+    console.log(`- file: ${result.path}`);
+    console.log(`- latest invocation: ${result.latestInvocationId ?? "none"}`);
+    console.log(`- unincorporated evidence: ${result.sourceEvidenceIds.length}`);
+    console.log(`- pending decisions: ${result.pendingQuestionIds.length}`);
+    console.log("Use this handoff directly in Codex/Claude, or paste it into OMX `$ralplan` when OMX is installed.");
+}
 function parseLimit(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -3555,9 +3844,6 @@ async function runPanelDebateCommand(args) {
     console.log(`- rounds: ${debate.run.roundCount}`);
     console.log(`- checkpoint: ${debate.questionRecord.id}`);
 }
-function disabledTeamCommandError() {
-    return new Error("`longtable team` is disabled. Use `longtable panel --prompt <text>` for visible multi-role review, or `longtable ask --prompt \"lt debate: <text>\"` when debate is explicitly requested.");
-}
 async function runDecide(args) {
     const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
     const answer = typeof args.answer === "string" ? args.answer.trim() : "";
@@ -3732,7 +4018,7 @@ async function runCodexSubcommand(subcommand, args) {
         const installed = await installCodexSkills(roles, customDir, skillSurface);
         console.log(`Installed ${installed.length} LongTable Codex skills in ${resolveCodexSkillsDir(customDir)} (${skillSurface} surface)`);
         console.log("Use them inside Codex with natural-language triggers such as `lt explore: ...` or `lt panel: ...`.");
-        console.log("Use `$longtable` as the general router; compact installs expose only the most common role shortcuts.");
+        console.log("Use `$longtable` as the general router; compact installs expose `$longtable-panel` plus the most common role shortcuts.");
         for (const skill of installed) {
             console.log(`- ${skill.name}`);
         }
@@ -3936,6 +4222,10 @@ async function main() {
         await runResume(values);
         return;
     }
+    if (command === "handoff") {
+        await runHandoff(values);
+        return;
+    }
     if (command === "doctor" || command === "status") {
         await runDoctor(values);
         return;
@@ -3993,6 +4283,25 @@ async function main() {
         return;
     }
     if (command === "panel") {
+        if (subcommand === "record") {
+            await runPanelRecordCommand(values);
+            return;
+        }
+        if (subcommand === "status") {
+            await runPanelStatusCommand(values);
+            return;
+        }
+        if (subcommand === "stop") {
+            await runPanelStopCommand(values);
+            return;
+        }
+        if (subcommand === "resume") {
+            await runPanelResumeCommand(values);
+            return;
+        }
+        if (subcommand) {
+            throw new Error(`Unknown panel subcommand: ${subcommand}`);
+        }
         await runPanelCommand(values);
         return;
     }
@@ -4000,9 +4309,6 @@ async function main() {
         await runSentinel(values);
         return;
     }
-    if (command === "team") {
-        throw disabledTeamCommandError();
-    }
     if (command === "decide") {
         await runDecide(values);
         return;

package/dist/panel-runtime.d.ts

@@ -0,0 +1,20 @@
+import type { PanelMemberResult, PanelWorkerRun, PanelWorkerRunStatus } from "@longtable/core";
+import type { PanelFallback } from "./panel.js";
+export declare function panelWorkerRunDirectory(workingDirectory: string, runId: string): string;
+export declare function panelWorkerRunPath(workingDirectory: string, runId: string): string;
+export declare function createPanelWorkerRun(options: {
+    workingDirectory: string;
+    fallback: PanelFallback;
+    initialStatus?: PanelWorkerRunStatus;
+    diagnostics?: string[];
+}): Promise<PanelWorkerRun>;
+export declare function readPanelWorkerRun(workingDirectory: string, runId: string): Promise<PanelWorkerRun>;
+export declare function writePanelWorkerRun(run: PanelWorkerRun): Promise<void>;
+export declare function launchPanelWorkerRun(run: PanelWorkerRun): Promise<PanelWorkerRun>;
+export declare function refreshPanelWorkerRun(run: PanelWorkerRun): Promise<{
+    run: PanelWorkerRun;
+    memberResults: PanelMemberResult[];
+}>;
+export declare function requestPanelWorkerStop(run: PanelWorkerRun): Promise<PanelWorkerRun>;
+export declare function resumePanelWorkerRun(run: PanelWorkerRun): Promise<PanelWorkerRun>;
+export declare function waitForPanelWorkerRun(run: PanelWorkerRun, timeoutMs: number): Promise<PanelWorkerRun>;