@meego-harness/mara-worker 0.8.0

package/dist/chunk-VUPAW5X2.js

@@ -0,0 +1,1424 @@
+// src/constants.ts
+var MIRA_WORKER_ROLE = "coder";
+var MIRA_WORKER_WORKING_TEXT = "Mira CLI is working";
+var MIRA_WORKER_CONFIG_DIR = ".meego-harness/mara-worker";
+var COCO_WORKER_ROLE = MIRA_WORKER_ROLE;
+var COCO_WORKER_WORKING_TEXT = MIRA_WORKER_WORKING_TEXT;
+var COCO_WORKER_CONFIG_DIR = MIRA_WORKER_CONFIG_DIR;
+
+// src/config.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join } from "path";
+import { confirm, isCancel, select, text } from "@clack/prompts";
+import { renderCliPrompt } from "@meego-harness/prompt-registry";
+import { resolveDefaultWorkerDeviceIdentityFile } from "@meego-harness/worker-sdk";
+import { z } from "zod";
+var miraWorkerConfigSchema = z.object({
+  serverUrl: z.string().trim().min(1, "serverUrl is required"),
+  email: z.string().trim().min(1, "email is required"),
+  workerId: z.string().trim().min(1, "workerId is required"),
+  capabilitySummary: z.string().trim().min(1, "capabilitySummary is required"),
+  defaultWorkspace: z.string().trim().min(1, "defaultWorkspace is required"),
+  repoMappings: z.record(z.string(), z.string()),
+  enabled: z.boolean().default(true),
+  permissionPreset: z.enum(["safe", "default", "full-access"]),
+  modelSelection: z.string().trim().min(1, "modelSelection is required"),
+  reasoningEffortDefault: z.enum([
+    "use-mira-default",
+    "use-coco-default",
+    "low",
+    "medium",
+    "high",
+    "xhigh"
+  ])
+});
+var miraWorkerStateSchema = z.object({
+  contexts: z.array(
+    z.object({
+      contextId: z.string(),
+      repo: z.string().optional(),
+      cwd: z.string(),
+      sessionId: z.string().optional(),
+      reasoningEffort: z.enum(["low", "medium", "high", "xhigh"]).optional(),
+      planMode: z.boolean()
+    })
+  )
+});
+function resolveMiraWorkerStorageDir(options = {}) {
+  return join(options.homeDir ?? homedir(), MIRA_WORKER_CONFIG_DIR);
+}
+function resolveMiraWorkerConfigFile(workerId, options = {}) {
+  return join(resolveMiraWorkerStorageDir(options), `${workerId}.json`);
+}
+function resolveMiraWorkerStateFile(workerId, options = {}) {
+  return join(resolveMiraWorkerStorageDir(options), `${workerId}.state.json`);
+}
+function loadMiraWorkerConfig(workerId, options = {}) {
+  const file = resolveMiraWorkerConfigFile(workerId, options);
+  if (!existsSync(file)) {
+    throw new Error(`Mira CLI worker config not found for ${workerId}: ${file}`);
+  }
+  return miraWorkerConfigSchema.parse(JSON.parse(readFileSync(file, "utf8")));
+}
+function writeMiraWorkerConfig(config, options = {}) {
+  mkdirSync(resolveMiraWorkerStorageDir(options), { recursive: true });
+  writeFileSync(
+    resolveMiraWorkerConfigFile(config.workerId, options),
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf8"
+  );
+}
+function loadMiraWorkerState(stateFile) {
+  if (!existsSync(stateFile)) {
+    return { contexts: [] };
+  }
+  return miraWorkerStateSchema.parse(JSON.parse(readFileSync(stateFile, "utf8")));
+}
+function writeMiraWorkerState(stateFile, state) {
+  mkdirSync(dirname(stateFile), { recursive: true });
+  writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+async function runMiraWorkerSetup(dependencies, prompter, input = {}) {
+  const homeDir = dependencies.homeDir;
+  const serverUrlPrompt = renderCliPrompt("cli.mara-worker.server-url", void 0);
+  const serverUrl = await resolveTextInput(input.serverUrl, prompter, {
+    message: serverUrlPrompt.message,
+    placeholder: serverUrlPrompt.placeholder,
+    validate: requiredString("serverUrl")
+  });
+  const emailPrompt = renderCliPrompt("cli.mara-worker.email", void 0);
+  const email = await resolveTextInput(input.email, prompter, {
+    message: emailPrompt.message,
+    placeholder: emailPrompt.placeholder,
+    validate: requiredString("email")
+  });
+  const workerIdPrompt = renderCliPrompt("cli.mara-worker.worker-id", void 0);
+  const workerId = await resolveTextInput(input.workerId, prompter, {
+    message: workerIdPrompt.message,
+    placeholder: workerIdPrompt.placeholder,
+    validate: requiredString("workerId")
+  });
+  const capabilitySummaryPrompt = renderCliPrompt("cli.mara-worker.capability-summary", void 0);
+  const capabilitySummary = await resolveTextInput(input.capabilitySummary, prompter, {
+    message: capabilitySummaryPrompt.message,
+    placeholder: capabilitySummaryPrompt.placeholder,
+    validate: requiredString("capabilitySummary")
+  });
+  const defaultWorkspacePrompt = renderCliPrompt("cli.mara-worker.default-workspace", void 0);
+  const defaultWorkspace = await resolveTextInput(input.defaultWorkspace, prompter, {
+    message: defaultWorkspacePrompt.message,
+    placeholder: defaultWorkspacePrompt.placeholder,
+    validate: validateDirectory("defaultWorkspace")
+  });
+  const permissionPresetPrompt = renderCliPrompt("cli.mara-worker.permission-preset", void 0);
+  const permissionPreset = await resolveSelectInput(input.permissionPreset, prompter, {
+    message: permissionPresetPrompt.message,
+    options: [
+      { value: "safe", label: "safe" },
+      { value: "default", label: "default" },
+      { value: "full-access", label: "full-access" }
+    ],
+    initialValue: "default"
+  });
+  const modelSelectionPrompt = renderCliPrompt("cli.mara-worker.model-selection", void 0);
+  const modelSelection = await resolveSelectInput(input.modelSelection, prompter, {
+    message: modelSelectionPrompt.message,
+    options: requireCliPromptOptions(
+      modelSelectionPrompt.options,
+      "cli.mara-worker.model-selection"
+    ),
+    initialValue: "use-mira-default"
+  });
+  const reasoningEffortPrompt = renderCliPrompt("cli.mara-worker.reasoning-effort", void 0);
+  const reasoningEffortDefault = await resolveSelectInput(input.reasoningEffortDefault, prompter, {
+    message: reasoningEffortPrompt.message,
+    options: [
+      { value: "use-mira-default", label: "use-mira-default" },
+      { value: "use-coco-default", label: "use-coco-default" },
+      { value: "low", label: "low" },
+      { value: "medium", label: "medium" },
+      { value: "high", label: "high" },
+      { value: "xhigh", label: "xhigh" }
+    ],
+    initialValue: "use-mira-default"
+  });
+  const repoMappings = input.repoMappings ? normalizeRepoMappings(input.repoMappings) : await promptRepoMappings(prompter, defaultWorkspace);
+  const result = miraWorkerConfigSchema.parse({
+    serverUrl,
+    email,
+    workerId,
+    capabilitySummary,
+    defaultWorkspace,
+    repoMappings,
+    enabled: input.enabled ?? true,
+    permissionPreset,
+    modelSelection,
+    reasoningEffortDefault
+  });
+  writeMiraWorkerConfig(result, { homeDir });
+  dependencies.logger.info(
+    `Configured mara worker ${result.workerId} at ${resolveMiraWorkerConfigFile(result.workerId, { homeDir })}`
+  );
+  return result;
+}
+function listMiraWorkerConfigs(options = {}) {
+  const storageDir = resolveMiraWorkerStorageDir(options);
+  if (!existsSync(storageDir)) {
+    return [];
+  }
+  return readdirSync(storageDir).filter((file) => file.endsWith(".json") && !file.endsWith(".state.json")).map((file) => {
+    const workerId = file.replace(/\.json$/u, "");
+    const config = loadMiraWorkerConfig(workerId, options);
+    return {
+      ...config,
+      configFile: resolveMiraWorkerConfigFile(workerId, options),
+      stateFile: resolveMiraWorkerStateFile(workerId, options)
+    };
+  }).sort((left, right) => left.workerId.localeCompare(right.workerId));
+}
+function getMiraWorkerDoctorReport(options = {}, dependencies = {}) {
+  return {
+    workers: listMiraWorkerConfigs(options).map((config) => {
+      const runtimeErrors = [];
+      try {
+        dependencies.assertCocoCliAvailable?.();
+      } catch (error) {
+        runtimeErrors.push(error instanceof Error ? error.message : "Mira CLI is unavailable");
+      }
+      return {
+        ...config,
+        configStatus: "ok",
+        runtimeStatus: runtimeErrors.length > 0 ? "error" : "ok",
+        errors: runtimeErrors
+      };
+    })
+  };
+}
+function setMiraWorkerEnabled(workerId, enabled, options = {}) {
+  const config = loadMiraWorkerConfig(workerId, options);
+  writeMiraWorkerConfig(
+    {
+      ...config,
+      enabled
+    },
+    options
+  );
+}
+function uninstallMiraWorker(workerId, options = {}) {
+  const configFile = resolveMiraWorkerConfigFile(workerId, options);
+  const stateFile = resolveMiraWorkerStateFile(workerId, options);
+  const config = existsSync(configFile) ? loadMiraWorkerConfig(workerId, options) : void 0;
+  const credentialFile = config ? resolveDefaultWorkerDeviceIdentityFile(
+    config.serverUrl,
+    config.workerId,
+    config.email,
+    options.homeDir
+  ) : void 0;
+  const removedConfig = removeFileIfPresent(configFile);
+  const removedState = removeFileIfPresent(stateFile);
+  const removedCredential = credentialFile ? removeFileIfPresent(credentialFile) : false;
+  return {
+    configFile,
+    stateFile,
+    credentialFile,
+    removedConfig,
+    removedState,
+    removedCredential
+  };
+}
+function createClackPrompter() {
+  return {
+    async text(params) {
+      const value = await text({
+        message: params.message,
+        placeholder: params.placeholder,
+        defaultValue: params.initialValue,
+        validate: params.validate ? (input) => params.validate?.(input ?? "") : void 0
+      });
+      const resolved = unwrapCanceledValue(value, "Mira CLI worker setup canceled");
+      return resolved;
+    },
+    async select(params) {
+      const value = await select({
+        message: params.message,
+        initialValue: params.initialValue,
+        options: params.options.map((option) => ({
+          value: option.value,
+          label: option.label
+        }))
+      });
+      const resolved = unwrapCanceledValue(value, "Mira CLI worker setup canceled");
+      return resolved;
+    },
+    async confirm(params) {
+      const value = await confirm({
+        message: params.message,
+        initialValue: params.initialValue
+      });
+      const resolved = unwrapCanceledValue(value, "Mira CLI worker setup canceled");
+      return resolved;
+    }
+  };
+}
+function requiredString(field) {
+  return (value) => value.trim() ? void 0 : `${field} is required`;
+}
+function validateDirectory(field) {
+  return (value) => {
+    const normalized = value.trim();
+    if (!normalized) {
+      return `${field} is required`;
+    }
+    if (!isAbsolute(normalized)) {
+      return `${field} must be an absolute path`;
+    }
+    if (!existsSync(normalized)) {
+      return `${field} does not exist`;
+    }
+    return void 0;
+  };
+}
+async function resolveTextInput(value, prompter, params) {
+  const resolved = value ?? await prompter.text(params);
+  const normalized = resolved.trim();
+  const validationError = params.validate?.(normalized);
+  if (validationError) {
+    throw new Error(validationError);
+  }
+  return normalized;
+}
+async function resolveSelectInput(value, prompter, params) {
+  const resolved = value ?? await prompter.select(params);
+  const normalized = resolved.trim();
+  const optionValues = params.options.map((option) => option.value);
+  if (!optionValues.includes(normalized)) {
+    throw new Error(`${params.message} must be one of: ${optionValues.join(", ")}`);
+  }
+  return normalized;
+}
+async function promptRepoMappings(prompter, defaultWorkspace) {
+  const repoMappings = {};
+  const addFirstPrompt = renderCliPrompt("cli.mara-worker.repo-mapping.add-first", void 0);
+  let addAnotherMapping = await prompter.confirm({
+    message: addFirstPrompt.message,
+    initialValue: false
+  });
+  while (addAnotherMapping) {
+    const repoNamePrompt = renderCliPrompt("cli.mara-worker.repo-mapping.repo-name", void 0);
+    const repo = await prompter.text({
+      message: repoNamePrompt.message,
+      placeholder: repoNamePrompt.placeholder,
+      validate: requiredString("repo")
+    });
+    const directoryPrompt = renderCliPrompt("cli.mara-worker.repo-mapping.directory", {
+      repo,
+      defaultWorkspace
+    });
+    const cwd = await prompter.text({
+      message: directoryPrompt.message,
+      placeholder: directoryPrompt.placeholder,
+      validate: validateDirectory("cwd")
+    });
+    repoMappings[repo.trim()] = cwd.trim();
+    const addAnotherPrompt = renderCliPrompt("cli.mara-worker.repo-mapping.add-another", void 0);
+    addAnotherMapping = await prompter.confirm({
+      message: addAnotherPrompt.message,
+      initialValue: false
+    });
+  }
+  return repoMappings;
+}
+function requireCliPromptOptions(options, key) {
+  if (!options?.length) {
+    throw new Error(`CLI prompt ${key} did not render selectable options`);
+  }
+  return options;
+}
+function normalizeRepoMappings(repoMappings) {
+  const normalized = {};
+  for (const [repo, cwd] of Object.entries(repoMappings)) {
+    const repoName = repo.trim();
+    const directory = cwd.trim();
+    const repoError = requiredString("repo")(repoName);
+    const directoryError = validateDirectory("cwd")(directory);
+    if (repoError) {
+      throw new Error(repoError);
+    }
+    if (directoryError) {
+      throw new Error(directoryError);
+    }
+    normalized[repoName] = directory;
+  }
+  return normalized;
+}
+function unwrapCanceledValue(value, message) {
+  if (isCancel(value)) {
+    throw new Error(message);
+  }
+  return value;
+}
+function removeFileIfPresent(file) {
+  if (!existsSync(file)) {
+    return false;
+  }
+  rmSync(file, { force: true });
+  return true;
+}
+var resolveCocoWorkerStorageDir = resolveMiraWorkerStorageDir;
+var resolveCocoWorkerConfigFile = resolveMiraWorkerConfigFile;
+var resolveCocoWorkerStateFile = resolveMiraWorkerStateFile;
+var loadCocoWorkerConfig = loadMiraWorkerConfig;
+var writeCocoWorkerConfig = writeMiraWorkerConfig;
+var loadCocoWorkerState = loadMiraWorkerState;
+var writeCocoWorkerState = writeMiraWorkerState;
+var runCocoWorkerSetup = runMiraWorkerSetup;
+var listCocoWorkerConfigs = listMiraWorkerConfigs;
+var getCocoWorkerDoctorReport = getMiraWorkerDoctorReport;
+var setCocoWorkerEnabled = setMiraWorkerEnabled;
+var uninstallCocoWorker = uninstallMiraWorker;
+
+// src/parts.ts
+function stringifyTaskMessageParts(parts) {
+  return parts.map((part) => {
+    if (part.type === "text") {
+      return part.text;
+    }
+    if (part.type === "data") {
+      return [
+        `[data${part.mimeType ? ` mimeType=${part.mimeType}` : ""}]`,
+        JSON.stringify(part.data, null, 2),
+        "[/data]"
+      ].join("\n");
+    }
+    return [
+      "[file-ref]",
+      `uri: ${part.uri}`,
+      part.name ? `name: ${part.name}` : void 0,
+      part.mimeType ? `mimeType: ${part.mimeType}` : void 0,
+      "[/file-ref]"
+    ].filter(Boolean).join("\n");
+  }).join("\n\n").trim();
+}
+
+// src/runtime.ts
+import { spawn, spawnSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import process from "process";
+import { createInterface } from "readline";
+import { fileURLToPath } from "url";
+var MiraCliTaskExecutor = class {
+  miraBin;
+  pythonBin;
+  runnerScript;
+  spawnChild;
+  constructor(config = {}) {
+    this.miraBin = config.miraBin ?? "mira";
+    this.pythonBin = config.pythonBin ?? "python3";
+    this.runnerScript = config.runnerScript ?? resolveDefaultRunnerScript();
+    this.spawnChild = config.spawn ?? spawn;
+  }
+  async runTurn(request) {
+    if (request.abortSignal.aborted) {
+      throw createAbortError();
+    }
+    const child = this.spawnChild(this.pythonBin, [this.runnerScript], {
+      cwd: request.cwd,
+      ...request.env ? { env: { ...process.env, ...request.env } } : {},
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      let stdoutBuffer = "";
+      const stderrLines = [];
+      function settle(callback) {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        request.abortSignal.removeEventListener("abort", onAbort);
+        callback();
+      }
+      function onAbort() {
+        killChildProcess(child);
+        settle(() => reject(createAbortError()));
+      }
+      request.abortSignal.addEventListener("abort", onAbort, { once: true });
+      child.stdout?.on("data", (chunk) => {
+        stdoutBuffer += chunk.toString();
+      });
+      if (child.stderr) {
+        const stderr = createInterface({ input: child.stderr });
+        stderr.on("line", (line) => {
+          const trimmed = line.trim();
+          if (!trimmed) {
+            return;
+          }
+          stderrLines.push(trimmed);
+          while (stderrLines.length > 40) {
+            stderrLines.shift();
+          }
+        });
+      }
+      child.once("error", (error) => {
+        settle(() => reject(error));
+      });
+      child.once("close", (code, signal) => {
+        if (request.abortSignal.aborted) {
+          settle(() => reject(createAbortError()));
+          return;
+        }
+        let response;
+        try {
+          response = parseMiraJsonResponse(stdoutBuffer);
+        } catch (error) {
+          if (code === 0) {
+            settle(() => reject(error instanceof Error ? error : new Error("Failed to parse Mira output")));
+            return;
+          }
+        }
+        if (code !== 0) {
+          settle(() => reject(new Error(buildMiraExitError({
+            code,
+            signal,
+            stderrLines,
+            stdoutText: stdoutBuffer,
+            response
+          }))));
+          return;
+        }
+        if (!response) {
+          settle(() => reject(new Error("Mira completed without a JSON response")));
+          return;
+        }
+        const errorMessage = readString(response.error);
+        if (errorMessage) {
+          const sessionValue = readString(response.sessionId) || readString(response.session_id);
+          const sessionSuffix = sessionValue ? `; sessionId=${sessionValue}` : "";
+          settle(() => reject(new Error(`Mira returned an error${sessionSuffix}: ${errorMessage}`)));
+          return;
+        }
+        const text2 = readString(response.text) || readString(response.message?.content);
+        if (!text2) {
+          settle(() => reject(new Error(`Mira completed without assistant text for context ${request.contextId}`)));
+          return;
+        }
+        const sessionId = readString(response.sessionId) || readString(response.session_id);
+        if (!sessionId) {
+          settle(() => reject(new Error(`Mira did not emit a session id for context ${request.contextId}`)));
+          return;
+        }
+        settle(() => resolve({ text: text2, sessionId }));
+      });
+      child.stdin?.end(
+        JSON.stringify(buildMiraPayload(request)),
+        "utf8"
+      );
+    });
+  }
+};
+function assertMiraCliAvailable(miraBin = "mira", run = spawnSync, pythonBin = "python3") {
+  const miraResult = run(miraBin, ["--help"], {
+    stdio: "ignore"
+  });
+  if (miraResult.error) {
+    throw new Error(`Unable to execute ${miraBin}: ${miraResult.error.message}`);
+  }
+  if (typeof miraResult.status === "number" && miraResult.status !== 0) {
+    throw new Error(
+      `Mira CLI preflight failed for "${miraBin} --help" with exit code ${String(miraResult.status)}`
+    );
+  }
+  const pythonResult = run(pythonBin, ["--version"], {
+    stdio: "ignore"
+  });
+  if (pythonResult.error) {
+    throw new Error(`Unable to execute ${pythonBin}: ${pythonResult.error.message}`);
+  }
+  if (typeof pythonResult.status === "number" && pythonResult.status !== 0) {
+    throw new Error(
+      `Python preflight failed for "${pythonBin} --version" with exit code ${String(pythonResult.status)}`
+    );
+  }
+}
+function buildMiraPayload(request) {
+  return {
+    cwd: request.cwd,
+    prompt: request.prompt,
+    session_id: request.sessionId,
+    model: request.model,
+    reasoning_effort: request.reasoningEffort,
+    permission_preset: request.permissionPreset,
+    disable_remote_capabilities: true
+  };
+}
+function createAbortError() {
+  const error = new Error("Mira run aborted");
+  error.name = "AbortError";
+  return error;
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError" || error instanceof Error && /abort/i.test(error.message);
+}
+function resolveDefaultRunnerScript() {
+  const runnerScript = fileURLToPath(new URL("../python/mira_worker_runner.py", import.meta.url));
+  if (!existsSync2(runnerScript)) {
+    throw new Error(`Mira CLI worker runner script not found: ${runnerScript}`);
+  }
+  return runnerScript;
+}
+function parseMiraJsonResponse(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed) {
+    throw new Error("Mira produced empty stdout");
+  }
+  try {
+    return parseMiraJsonResponseObject(JSON.parse(trimmed));
+  } catch {
+    const firstBrace = trimmed.indexOf("{");
+    const lastBrace = trimmed.lastIndexOf("}");
+    if (firstBrace < 0 || lastBrace <= firstBrace) {
+      throw new Error(`Mira returned invalid JSON: ${summarizeOutput(trimmed.split(/\r?\n/u))}`);
+    }
+    return parseMiraJsonResponseObject(JSON.parse(trimmed.slice(firstBrace, lastBrace + 1)));
+  }
+}
+function parseMiraJsonResponseObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Mira returned a non-object JSON response");
+  }
+  return value;
+}
+function buildMiraExitError(params) {
+  const base = `Mira CLI worker runner exited with code ${params.code}${params.signal ? ` (${params.signal})` : ""}`;
+  const responseError = params.response && typeof params.response.error === "string" ? params.response.error : "";
+  if (responseError) {
+    return `${base}; error=${responseError}`;
+  }
+  const stderrSummary = summarizeOutput(params.stderrLines);
+  if (stderrSummary) {
+    return `${base}; stderr=${stderrSummary}`;
+  }
+  const stdoutSummary = summarizeOutput(params.stdoutText.split(/\r?\n/u));
+  if (stdoutSummary) {
+    return `${base}; stdout=${stdoutSummary}`;
+  }
+  return base;
+}
+function summarizeOutput(lines) {
+  const compact = lines.map((line) => line.trim()).filter(Boolean);
+  if (!compact.length) {
+    return "";
+  }
+  return compact.slice(-5).join(" | ");
+}
+function readString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function killChildProcess(child) {
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+}
+var CocoCliTaskExecutor = MiraCliTaskExecutor;
+var assertCocoCliAvailable = assertMiraCliAvailable;
+
+// src/bridge.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import process2 from "process";
+import { parseManagerRunResult } from "@meego-harness/manager-contract";
+import { renderTextLlmPrompt } from "@meego-harness/prompt-registry";
+import { WorkerClientSDK } from "@meego-harness/worker-sdk";
+var CocoWorkerBridge = class {
+  config;
+  executor;
+  logger;
+  client;
+  activeTasks = /* @__PURE__ */ new Map();
+  pendingCanceledTaskIds = /* @__PURE__ */ new Set();
+  bindings = /* @__PURE__ */ new Map();
+  contextQueues = /* @__PURE__ */ new Map();
+  stateFile;
+  constructor(config, dependencies) {
+    this.config = config;
+    this.executor = dependencies.executor;
+    this.logger = dependencies.logger;
+    this.client = dependencies.client ?? new WorkerClientSDK({
+      serverUrl: config.serverUrl,
+      reconnectBaseDelayMs: config.reconnectBaseDelayMs,
+      reconnectMaxDelayMs: config.reconnectMaxDelayMs
+    });
+    this.stateFile = config.stateFile ?? join2(process2.cwd(), `${config.workerId}.state.json`);
+    for (const binding of loadCocoWorkerState(this.stateFile).contexts) {
+      this.bindings.set(binding.contextId, binding);
+    }
+  }
+  async start() {
+    this.client.onMessage(async (context) => {
+      await this.handleTaskMessage(context);
+    });
+    this.client.onCancel(async ({ taskId }) => {
+      await this.handleTaskCancel(taskId);
+    });
+    this.client.onRoleChange(async (request) => {
+      if (request.type === "promote-to-manager") {
+        await this.client.switchRole({
+          workerId: this.config.workerId,
+          email: this.config.email,
+          role: "manager",
+          managerGrant: request.managerGrant,
+          capabilitySummary: this.config.capabilitySummary,
+          credentialDeliveryEnabled: true,
+          initialAvailability: "available"
+        });
+        return;
+      }
+      await this.client.switchRole({
+        workerId: this.config.workerId,
+        email: this.config.email,
+        role: COCO_WORKER_ROLE,
+        capabilitySummary: this.config.capabilitySummary,
+        credentialDeliveryEnabled: true,
+        initialAvailability: "available"
+      });
+    });
+    await this.client.connect();
+    await this.client.login({
+      workerId: this.config.workerId,
+      email: this.config.email,
+      role: COCO_WORKER_ROLE,
+      capabilitySummary: this.config.capabilitySummary,
+      credentialDeliveryEnabled: true,
+      initialAvailability: "available"
+    });
+    return this;
+  }
+  async stop() {
+    for (const execution of this.activeTasks.values()) {
+      execution.abortController.abort();
+    }
+    this.activeTasks.clear();
+    this.pendingCanceledTaskIds.clear();
+    await this.client.disconnect();
+  }
+  async handleTaskMessage({
+    task,
+    message,
+    history,
+    delivery,
+    credentials,
+    controller
+  }) {
+    const previous = this.contextQueues.get(task.contextId) ?? Promise.resolve();
+    const current = previous.catch(() => void 0).then(async () => {
+      await this.processTaskMessage({ task, message, history, delivery, credentials, controller });
+    });
+    this.contextQueues.set(task.contextId, current);
+    try {
+      await current;
+    } finally {
+      if (this.contextQueues.get(task.contextId) === current) {
+        this.contextQueues.delete(task.contextId);
+      }
+    }
+  }
+  async processTaskMessage({
+    task,
+    message,
+    credentials,
+    controller
+  }) {
+    if (this.activeTasks.has(task.id)) {
+      this.logger.warn(`Ignoring duplicate active task delivery for ${task.id}`);
+      return;
+    }
+    if (this.pendingCanceledTaskIds.has(task.id)) {
+      this.pendingCanceledTaskIds.delete(task.id);
+      return;
+    }
+    const execution = {
+      abortController: new AbortController(),
+      canceled: false
+    };
+    this.activeTasks.set(task.id, execution);
+    const requestedRepo = readOptionalStringMetadata(task.metadata, "repo");
+    const existingBinding = this.bindings.get(task.contextId);
+    let binding = existingBinding;
+    let createdBinding = false;
+    try {
+      if (!binding) {
+        binding = this.createBinding(task.contextId, task.metadata);
+        this.bindings.set(task.contextId, binding);
+        this.persistState();
+        createdBinding = true;
+      } else {
+        const hydratedBinding = this.hydrateBindingFromMetadata(binding, task.metadata);
+        if (hydratedBinding !== binding) {
+          binding = hydratedBinding;
+          this.bindings.set(task.contextId, binding);
+          this.persistState();
+        }
+      }
+      const resolvedBinding = binding;
+      if (!resolvedBinding) {
+        throw new Error(`Missing context binding for ${task.contextId}`);
+      }
+      if (!await this.trySendTaskStatusUpdate(
+        task.id,
+        "working",
+        async () => await controller.working({
+          parts: [
+            {
+              type: "text",
+              text: COCO_WORKER_WORKING_TEXT
+            }
+          ]
+        })
+      )) {
+        return;
+      }
+      const managerRunInput = readManagerRunInput(task.metadata);
+      const prompt = managerRunInput ? buildManagerRunPrompt(managerRunInput) : stringifyTaskMessageParts(message.parts);
+      const planModePreamble = renderTextLlmPrompt("worker.mara.plan-mode-preamble", void 0).text;
+      const finalPrompt = !managerRunInput && createdBinding && resolvedBinding.planMode ? `${planModePreamble}
+
+${prompt}`.trim() : prompt;
+      const result = await this.executor.runTurn(buildCocoTaskExecutionRequest(
+        task,
+        finalPrompt,
+        resolvedBinding,
+        this.config,
+        execution,
+        credentials?.env
+      ));
+      if (this.isTaskCanceled(task.id)) {
+        return;
+      }
+      if (resolvedBinding.sessionId !== result.sessionId) {
+        resolvedBinding.sessionId = result.sessionId;
+        this.bindings.set(task.contextId, resolvedBinding);
+        this.persistState();
+      }
+      if (managerRunInput) {
+        const managerRunResult = parseManagerRunResult(parseJsonObjectOrThrow(result.text));
+        await this.trySendTaskStatusUpdate(
+          task.id,
+          "completed",
+          async () => await controller.complete({
+            parts: [
+              {
+                type: "text",
+                text: managerRunResult.summary
+              }
+            ],
+            metadata: buildCocoMetadata(resolvedBinding, requestedRepo, {
+              managerRunResult
+            })
+          })
+        );
+        return;
+      }
+      const structuredProtocol = readOptionalStringMetadata(
+        task.metadata,
+        "projectNodeResultProtocol"
+      );
+      const structuredResult = structuredProtocol ? await this.resolveStructuredProjectNodeResult(
+        task,
+        resolvedBinding,
+        structuredProtocol,
+        result.text,
+        execution,
+        credentials?.env
+      ) : {
+        status: "completed",
+        summary: result.text
+      };
+      if (structuredResult.status === "input_required") {
+        await this.trySendTaskStatusUpdate(
+          task.id,
+          "input-required",
+          async () => await controller.inputRequired({
+            parts: [
+              {
+                type: "text",
+                text: structuredResult.question
+              }
+            ],
+            metadata: buildCocoMetadata(resolvedBinding, requestedRepo, {
+              "mira.summary": structuredResult.summary,
+              "coco.summary": structuredResult.summary,
+              ...structuredResult.reasonType ? { projectNodeReasonType: structuredResult.reasonType } : {}
+            })
+          })
+        );
+        return;
+      }
+      await this.trySendTaskStatusUpdate(
+        task.id,
+        "completed",
+        async () => await controller.complete({
+          parts: [
+            {
+              type: "text",
+              text: structuredResult.summary
+            }
+          ],
+          metadata: buildCocoMetadata(
+            resolvedBinding,
+            requestedRepo,
+            structuredResult.projectNodeWrites || structuredResult.fieldPatches ? {
+              ...structuredResult.fieldPatches ? { projectNodeFieldPatches: structuredResult.fieldPatches } : {},
+              projectNodeWrites: structuredResult.projectNodeWrites ?? toProjectNodeWrites(structuredResult.fieldPatches ?? [])
+            } : void 0
+          )
+        })
+      );
+    } catch (error) {
+      if (this.isTaskCanceled(task.id) || isAbortError(error)) {
+        return;
+      }
+      await this.trySendTaskStatusUpdate(
+        task.id,
+        "failed",
+        async () => await controller.fail({
+          parts: [
+            {
+              type: "text",
+              text: error instanceof Error ? error.message : "Mira run failed"
+            }
+          ]
+        })
+      );
+    } finally {
+      this.activeTasks.delete(task.id);
+      this.pendingCanceledTaskIds.delete(task.id);
+    }
+  }
+  async trySendTaskStatusUpdate(taskId, targetState, action) {
+    try {
+      await action();
+      return true;
+    } catch (error) {
+      if (isTerminalTaskConflictError(error)) {
+        this.logger.warn(
+          `Ignoring stale terminal task update for ${taskId} while reporting ${targetState}: ${error.message}`
+        );
+        return false;
+      }
+      if (isWorkerConnectionClosedError(error)) {
+        this.logger.warn(
+          `Skipping ${targetState} update for ${taskId} because the worker connection is already closed`
+        );
+        return false;
+      }
+      throw error;
+    }
+  }
+  async handleTaskCancel(taskId) {
+    const execution = this.activeTasks.get(taskId);
+    if (!execution) {
+      this.pendingCanceledTaskIds.add(taskId);
+      return;
+    }
+    execution.canceled = true;
+    execution.abortController.abort();
+  }
+  createBinding(contextId, metadata) {
+    const repo = readOptionalStringMetadata(metadata, "repo");
+    const explicitReasoning = readOptionalReasoningEffort(metadata, "miraReasoningEffort") ?? readOptionalReasoningEffort(metadata, "cocoReasoningEffort");
+    const planMode = readOptionalBooleanMetadata(metadata, "miraPlanMode") ?? readOptionalBooleanMetadata(metadata, "cocoPlanMode") ?? false;
+    const cwd = this.resolveCwd(repo);
+    return {
+      contextId,
+      repo,
+      cwd,
+      reasoningEffort: explicitReasoning ?? (isDefaultReasoningSelection(this.config.reasoningEffortDefault) ? void 0 : this.config.reasoningEffortDefault),
+      planMode
+    };
+  }
+  hydrateBindingFromMetadata(binding, metadata) {
+    const repo = readOptionalStringMetadata(metadata, "repo");
+    if (!repo || binding.repo) {
+      return binding;
+    }
+    return {
+      ...binding,
+      repo,
+      cwd: this.resolveCwd(repo)
+    };
+  }
+  resolveCwd(repo) {
+    if (!repo) {
+      this.ensureDirectory(this.config.defaultWorkspace, "default workspace");
+      return this.config.defaultWorkspace;
+    }
+    const mapped = this.config.repoMappings[repo];
+    if (Object.keys(this.config.repoMappings).length > 0) {
+      if (!mapped) {
+        throw new Error(`No repo mapping configured for ${repo}`);
+      }
+      this.ensureDirectory(mapped, `mapped repo directory for ${repo}`);
+      return mapped;
+    }
+    const inferred = join2(this.config.defaultWorkspace, repo);
+    this.ensureDirectory(inferred, `workspace repo directory for ${repo}`);
+    return inferred;
+  }
+  ensureDirectory(path, label) {
+    if (!existsSync3(path)) {
+      throw new Error(`Missing ${label}: ${path}`);
+    }
+  }
+  persistState() {
+    mkdirSync2(dirname2(this.stateFile), { recursive: true });
+    writeCocoWorkerState(this.stateFile, {
+      contexts: Array.from(this.bindings.values())
+    });
+  }
+  isTaskCanceled(taskId) {
+    return this.activeTasks.get(taskId)?.canceled ?? this.pendingCanceledTaskIds.has(taskId);
+  }
+  async resolveStructuredProjectNodeResult(task, binding, protocol, firstText, execution, env) {
+    const firstParsed = parseProjectNodeResult(protocol, firstText);
+    if (firstParsed) {
+      return firstParsed;
+    }
+    const retryResult = await this.executor.runTurn(buildCocoTaskExecutionRequest(
+      task,
+      buildStructuredRetryPrompt(protocol),
+      binding,
+      this.config,
+      execution,
+      env
+    ));
+    if (this.isTaskCanceled(task.id)) {
+      throw new Error("task canceled before structured retry completed");
+    }
+    if (binding.sessionId !== retryResult.sessionId) {
+      binding.sessionId = retryResult.sessionId;
+      this.bindings.set(task.contextId, binding);
+      this.persistState();
+    }
+    const retryParsed = parseProjectNodeResult(protocol, retryResult.text, {
+      allowStringRepair: true
+    });
+    if (retryParsed) {
+      return retryParsed;
+    }
+    throw new Error("Mira returned an invalid structured result after one retry");
+  }
+};
+function buildCocoMetadata(binding, requestedRepo, extraMetadata) {
+  return {
+    "mira.sessionId": binding.sessionId,
+    "mira.cwd": binding.cwd,
+    "coco.sessionId": binding.sessionId,
+    "coco.cwd": binding.cwd,
+    ...binding.repo ? { "mira.repo": binding.repo, "coco.repo": binding.repo } : {},
+    ...requestedRepo ? { "mira.requestedRepo": requestedRepo, "coco.requestedRepo": requestedRepo } : {},
+    ...binding.reasoningEffort ? {
+      "mira.reasoningEffort": binding.reasoningEffort,
+      "coco.reasoningEffort": binding.reasoningEffort
+    } : {},
+    "mira.planMode": binding.planMode,
+    "coco.planMode": binding.planMode,
+    ...extraMetadata ? structuredClone(extraMetadata) : {}
+  };
+}
+function buildCocoTaskExecutionRequest(task, prompt, binding, config, execution, env) {
+  return {
+    taskId: task.id,
+    contextId: task.contextId,
+    cwd: binding.cwd,
+    prompt,
+    sessionId: binding.sessionId,
+    model: ["use-mira-default", "use-coco-default"].includes(config.modelSelection) ? void 0 : config.modelSelection,
+    reasoningEffort: binding.reasoningEffort,
+    permissionPreset: config.permissionPreset,
+    abortSignal: execution.abortController.signal,
+    ...env ? { env } : {}
+  };
+}
+function buildStructuredRetryPrompt(_protocol) {
+  return renderTextLlmPrompt("worker.mara.structured-retry", void 0).text;
+}
+function buildManagerRunPrompt(input) {
+  return renderTextLlmPrompt("worker.mara.manager-run", {
+    managerRunInput: input
+  }).text;
+}
+function isTerminalTaskConflictError(error) {
+  return error instanceof Error && (error.message.includes("task is already terminal") || error.message.includes("cannot continue a terminal task"));
+}
+function isWorkerConnectionClosedError(error) {
+  return error instanceof Error && error.message.includes("WebSocket is not connected");
+}
+function parseProjectNodeResult(protocol, text2, options = {}) {
+  const parsed = parseProjectNodeResultObject(text2, options);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  if (protocol !== "v1") {
+    return null;
+  }
+  if ("status" in parsed) {
+    const status = normalizeStatus(parsed.status);
+    const summary = normalizeSummary(parsed.summary);
+    if (!status || !summary) {
+      return null;
+    }
+    if (status === "completed") {
+      const projectNodeWrites = normalizeProjectNodeWrites(
+        parsed.projectNodeWrites
+      );
+      const fieldPatches = normalizeFieldPatches(parsed.fieldPatches);
+      return {
+        status,
+        summary,
+        ...projectNodeWrites && projectNodeWrites.length > 0 ? { projectNodeWrites } : {},
+        ...fieldPatches && fieldPatches.length > 0 ? { fieldPatches } : {}
+      };
+    }
+    const question = normalizeSummary(parsed.question);
+    if (!question) {
+      return null;
+    }
+    const reasonType = normalizeProjectNodeReasonType(
+      parsed.reasonType
+    ) ?? void 0;
+    return {
+      status,
+      summary,
+      question,
+      ...reasonType ? { reasonType } : {}
+    };
+  }
+  const choice = normalizeChoicePrefixedResult(parsed);
+  if (!choice) {
+    return null;
+  }
+  return choice;
+}
+function parseProjectNodeResultObject(text2, options = {}) {
+  const trimmed = text2.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const jsonText = unwrapJsonCodeFence(trimmed) ?? trimmed;
+  const parsedObject = parseJsonObjectWithOptionalRepair(
+    jsonText,
+    options.allowStringRepair ?? false
+  );
+  if (parsedObject) {
+    return parsedObject;
+  }
+  const matched = jsonText.match(/^([12])\s+(\{[\s\S]+\})$/);
+  if (!matched) {
+    return null;
+  }
+  const choiceObject = parseJsonObjectWithOptionalRepair(
+    matched[2],
+    options.allowStringRepair ?? false
+  );
+  if (!choiceObject || typeof choiceObject !== "object" || Array.isArray(choiceObject)) {
+    return null;
+  }
+  return {
+    choice: matched[1],
+    ...choiceObject
+  };
+}
+function unwrapJsonCodeFence(text2) {
+  if (!text2.startsWith("```") || !text2.endsWith("```")) {
+    return null;
+  }
+  const inner = text2.slice(3, -3);
+  const normalizedInner = inner.startsWith("\r\n") ? inner.slice(2) : inner.startsWith("\n") ? inner.slice(1) : inner;
+  const newlineIndex = normalizedInner.search(/\r?\n/u);
+  if (newlineIndex < 0) {
+    return null;
+  }
+  const header = normalizedInner.slice(0, newlineIndex).trim().toLowerCase();
+  if (header && header !== "json") {
+    return null;
+  }
+  return normalizedInner.slice(newlineIndex + 1).trim();
+}
+function parseJsonObjectWithOptionalRepair(text2, allowStringRepair) {
+  try {
+    return JSON.parse(text2);
+  } catch {
+    if (!allowStringRepair) {
+      return null;
+    }
+  }
+  const repaired = repairUnescapedJsonStringQuotes(text2);
+  if (!repaired || repaired === text2) {
+    return null;
+  }
+  try {
+    return JSON.parse(repaired);
+  } catch {
+    return null;
+  }
+}
+function parseJsonObjectOrThrow(text2) {
+  const trimmed = text2.trim();
+  const jsonText = unwrapJsonCodeFence(trimmed) ?? trimmed;
+  try {
+    const parsed = JSON.parse(jsonText);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("expected a JSON object");
+    }
+    return parsed;
+  } catch (error) {
+    const suffix = error instanceof Error ? `: ${error.message}` : "";
+    throw new Error(`Mira returned an invalid manager run result${suffix}`);
+  }
+}
+function repairUnescapedJsonStringQuotes(text2) {
+  let repaired = "";
+  let inString = false;
+  let escaped = false;
+  let changed = false;
+  for (let index = 0; index < text2.length; index += 1) {
+    const character = text2[index];
+    if (!inString) {
+      repaired += character;
+      if (character === '"') {
+        inString = true;
+      }
+      continue;
+    }
+    if (escaped) {
+      repaired += character;
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      repaired += character;
+      escaped = true;
+      continue;
+    }
+    if (character === '"') {
+      const nextNonWhitespace = findNextNonWhitespaceCharacter(text2, index + 1);
+      if (nextNonWhitespace === void 0 || nextNonWhitespace === "," || nextNonWhitespace === "}" || nextNonWhitespace === "]" || nextNonWhitespace === ":") {
+        repaired += character;
+        inString = false;
+        continue;
+      }
+      repaired += '\\"';
+      changed = true;
+      continue;
+    }
+    repaired += character;
+  }
+  return changed ? repaired : null;
+}
+function findNextNonWhitespaceCharacter(text2, startIndex) {
+  for (let index = startIndex; index < text2.length; index += 1) {
+    const character = text2[index];
+    if (!/\s/u.test(character)) {
+      return character;
+    }
+  }
+  return void 0;
+}
+function normalizeStatus(value) {
+  if (value === "completed" || value === "input_required") {
+    return value;
+  }
+  return null;
+}
+function normalizeSummary(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function normalizeChoicePrefixedResult(parsed) {
+  const choice = parsed.choice;
+  const summary = normalizeSummary(parsed.summary);
+  if (!summary || choice !== "1" && choice !== "2") {
+    return null;
+  }
+  if (choice === "1") {
+    return {
+      status: "completed",
+      summary
+    };
+  }
+  const question = normalizeSummary(parsed.question);
+  if (!question) {
+    return null;
+  }
+  const reasonType = normalizeProjectNodeReasonType(parsed.reasonType) ?? void 0;
+  return {
+    status: "input_required",
+    summary,
+    question,
+    ...reasonType ? { reasonType } : {}
+  };
+}
+function normalizeFieldPatches(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const patches = value.flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const record = item;
+    const fieldKey = normalizeSummary(record.fieldKey);
+    const patchValue = normalizeSummary(record.value);
+    const reason = normalizeSummary(record.reason) ?? void 0;
+    if (!fieldKey || !patchValue) {
+      return [];
+    }
+    return [{
+      fieldKey,
+      value: patchValue,
+      ...reason ? { reason } : {}
+    }];
+  });
+  return patches.length > 0 ? patches : null;
+}
+function normalizeProjectNodeWrites(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const writes = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    const kind = record.kind;
+    const fieldKey = normalizeSummary(record.fieldKey);
+    const reason = normalizeSummary(record.reason) ?? void 0;
+    if (!fieldKey) {
+      continue;
+    }
+    if (kind === "set-field") {
+      if (!("value" in record) || record.value === void 0) {
+        continue;
+      }
+      writes.push({
+        kind,
+        fieldKey,
+        value: record.value,
+        ...reason ? { reason } : {}
+      });
+      continue;
+    }
+    if (kind === "upload-attachment") {
+      const artifactId = normalizeSummary(record.artifactId);
+      if (!artifactId) {
+        continue;
+      }
+      writes.push({
+        kind,
+        fieldKey,
+        artifactId,
+        ...reason ? { reason } : {}
+      });
+    }
+  }
+  return writes.length > 0 ? writes : null;
+}
+function toProjectNodeWrites(patches) {
+  return patches.map((patch) => ({
+    kind: "set-field",
+    fieldKey: patch.fieldKey,
+    value: patch.value,
+    ...patch.reason ? { reason: patch.reason } : {}
+  }));
+}
+function normalizeProjectNodeReasonType(value) {
+  return value === "guidance_missing" || value === "guidance_conflict" || value === "business_fact_missing" || value === "permission_missing" || value === "external_dependency" || value === "unknown" ? value : null;
+}
+function readManagerRunInput(metadata) {
+  const input = metadata?.managerRunInput;
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return null;
+  }
+  return structuredClone(input);
+}
+function readOptionalStringMetadata(metadata, key) {
+  if (!metadata || !(key in metadata) || metadata[key] == null) {
+    return void 0;
+  }
+  const value = metadata[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${key} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function readOptionalBooleanMetadata(metadata, key) {
+  if (!metadata || !(key in metadata) || metadata[key] == null) {
+    return void 0;
+  }
+  const value = metadata[key];
+  if (typeof value !== "boolean") {
+    throw new TypeError(`${key} must be a boolean`);
+  }
+  return value;
+}
+function readOptionalReasoningEffort(metadata, key) {
+  const value = readOptionalStringMetadata(metadata, key);
+  if (!value) {
+    return void 0;
+  }
+  if (!["low", "medium", "high", "xhigh"].includes(value)) {
+    throw new Error(`${key} must be one of low, medium, high, xhigh`);
+  }
+  return value;
+}
+function isDefaultReasoningSelection(value) {
+  return value === "use-mira-default" || value === "use-coco-default";
+}
+
+export {
+  MIRA_WORKER_ROLE,
+  MIRA_WORKER_WORKING_TEXT,
+  MIRA_WORKER_CONFIG_DIR,
+  COCO_WORKER_ROLE,
+  COCO_WORKER_WORKING_TEXT,
+  COCO_WORKER_CONFIG_DIR,
+  resolveMiraWorkerStorageDir,
+  resolveMiraWorkerConfigFile,
+  resolveMiraWorkerStateFile,
+  loadMiraWorkerConfig,
+  writeMiraWorkerConfig,
+  loadMiraWorkerState,
+  writeMiraWorkerState,
+  runMiraWorkerSetup,
+  listMiraWorkerConfigs,
+  getMiraWorkerDoctorReport,
+  setMiraWorkerEnabled,
+  uninstallMiraWorker,
+  createClackPrompter,
+  resolveCocoWorkerStorageDir,
+  resolveCocoWorkerConfigFile,
+  resolveCocoWorkerStateFile,
+  loadCocoWorkerConfig,
+  writeCocoWorkerConfig,
+  loadCocoWorkerState,
+  writeCocoWorkerState,
+  runCocoWorkerSetup,
+  listCocoWorkerConfigs,
+  getCocoWorkerDoctorReport,
+  setCocoWorkerEnabled,
+  uninstallCocoWorker,
+  stringifyTaskMessageParts,
+  MiraCliTaskExecutor,
+  assertMiraCliAvailable,
+  buildMiraPayload,
+  createAbortError,
+  isAbortError,
+  CocoCliTaskExecutor,
+  assertCocoCliAvailable,
+  CocoWorkerBridge
+};
+//# sourceMappingURL=chunk-VUPAW5X2.js.map