@meego-harness/opencode-worker 0.1.0

package/dist/chunk-4MUQ7X6C.js

@@ -0,0 +1,1833 @@
+// src/constants.ts
+var OPENCODE_WORKER_ROLE = "coder";
+var OPENCODE_WORKER_WORKING_TEXT = "OpenCode CLI is working";
+var OPENCODE_WORKER_CONFIG_DIR = ".meego-harness/opencode-worker";
+
+// 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 openCodeModelSelectionSchema = z.string().trim().min(1, "modelSelection is required");
+var openCodeVariantSelectionSchema = z.string().trim().min(1, "variantDefault is required");
+var openCodeAgentSelectionSchema = z.string().trim().min(1, "agentDefault is required");
+var openCodeWorkerConfigSchema = 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"),
+  artifactStagingRoot: z.string().trim().min(1, "artifactStagingRoot is required").optional(),
+  repoMappings: z.record(z.string(), z.string()),
+  enabled: z.boolean().default(true),
+  permissionPreset: z.enum(["safe", "default", "full-access"]),
+  modelSelection: openCodeModelSelectionSchema,
+  variantDefault: openCodeVariantSelectionSchema,
+  agentDefault: openCodeAgentSelectionSchema,
+  openCodeShell: z.boolean().default(false)
+});
+var openCodeWorkerStateSchema = z.object({
+  contexts: z.array(
+    z.object({
+      contextId: z.string(),
+      repo: z.string().optional(),
+      cwd: z.string(),
+      sessionId: z.string().optional(),
+      variant: z.string().optional(),
+      agent: z.string().optional(),
+      planMode: z.boolean()
+    })
+  )
+});
+function resolveOpenCodeWorkerStorageDir(options = {}) {
+  return join(options.homeDir ?? homedir(), OPENCODE_WORKER_CONFIG_DIR);
+}
+function resolveOpenCodeWorkerConfigFile(workerId, options = {}) {
+  return join(resolveOpenCodeWorkerStorageDir(options), `${workerId}.json`);
+}
+function resolveOpenCodeWorkerStateFile(workerId, options = {}) {
+  return join(resolveOpenCodeWorkerStorageDir(options), `${workerId}.state.json`);
+}
+function loadOpenCodeWorkerConfig(workerId, options = {}) {
+  const file = resolveOpenCodeWorkerConfigFile(workerId, options);
+  if (!existsSync(file)) {
+    throw new Error(`OpenCode worker config not found for ${workerId}: ${file}`);
+  }
+  return openCodeWorkerConfigSchema.parse(JSON.parse(readFileSync(file, "utf8")));
+}
+function writeOpenCodeWorkerConfig(config, options = {}) {
+  mkdirSync(resolveOpenCodeWorkerStorageDir(options), { recursive: true });
+  writeFileSync(
+    resolveOpenCodeWorkerConfigFile(config.workerId, options),
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf8"
+  );
+}
+function loadOpenCodeWorkerState(stateFile) {
+  if (!existsSync(stateFile)) {
+    return { contexts: [] };
+  }
+  return openCodeWorkerStateSchema.parse(JSON.parse(readFileSync(stateFile, "utf8")));
+}
+function writeOpenCodeWorkerState(stateFile, state) {
+  mkdirSync(dirname(stateFile), { recursive: true });
+  writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+async function runOpenCodeWorkerSetup(dependencies, prompter, input) {
+  const homeDir = dependencies.homeDir;
+  const serverUrlPrompt = renderCliPrompt("cli.opencode-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.opencode-worker.email", void 0);
+  const email = await resolveTextInput(
+    input?.email,
+    prompter,
+    {
+      message: emailPrompt.message,
+      placeholder: emailPrompt.placeholder,
+      validate: requiredString("email")
+    }
+  );
+  const workerIdPrompt = renderCliPrompt("cli.opencode-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.opencode-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.opencode-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.opencode-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.opencode-worker.model-selection", void 0);
+  const modelSelection = await resolveTextInput(
+    input?.modelSelection,
+    prompter,
+    {
+      message: modelSelectionPrompt.message,
+      placeholder: modelSelectionPrompt.placeholder,
+      initialValue: "use-opencode-default",
+      validate: requiredString("modelSelection")
+    }
+  );
+  const variantPrompt = renderCliPrompt("cli.opencode-worker.variant", void 0);
+  const variantDefault = await resolveTextInput(
+    input?.variantDefault,
+    prompter,
+    {
+      message: variantPrompt.message,
+      placeholder: variantPrompt.placeholder,
+      initialValue: "use-opencode-default",
+      validate: requiredString("variantDefault")
+    }
+  );
+  const agentPrompt = renderCliPrompt("cli.opencode-worker.agent", void 0);
+  const agentDefault = await resolveTextInput(
+    input?.agentDefault,
+    prompter,
+    {
+      message: agentPrompt.message,
+      placeholder: agentPrompt.placeholder,
+      initialValue: "use-opencode-default",
+      validate: requiredString("agentDefault")
+    }
+  );
+  const repoMappings = input?.repoMappings ? { ...input.repoMappings } : await promptRepoMappings(prompter, defaultWorkspace);
+  const hasArtifactStagingRoot = input?.artifactStagingRoot !== void 0;
+  const artifactStagingRoot = input?.artifactStagingRoot?.trim();
+  const result = openCodeWorkerConfigSchema.parse({
+    serverUrl: serverUrl.trim(),
+    email: email.trim(),
+    workerId: workerId.trim(),
+    capabilitySummary: capabilitySummary.trim(),
+    defaultWorkspace: defaultWorkspace.trim(),
+    ...hasArtifactStagingRoot ? { artifactStagingRoot } : {},
+    repoMappings,
+    enabled: input?.enabled ?? true,
+    permissionPreset,
+    modelSelection,
+    variantDefault,
+    agentDefault,
+    openCodeShell: input?.openCodeShell ?? false
+  });
+  writeOpenCodeWorkerConfig(result, { homeDir });
+  dependencies.logger.info(
+    `Configured OpenCode worker ${result.workerId} at ${resolveOpenCodeWorkerConfigFile(result.workerId, { homeDir })}`
+  );
+  return result;
+}
+function listOpenCodeWorkerConfigs(options = {}) {
+  const storageDir = resolveOpenCodeWorkerStorageDir(options);
+  if (!existsSync(storageDir)) {
+    return [];
+  }
+  return readdirSync(storageDir).filter((file) => file.endsWith(".json") && !file.endsWith(".state.json")).map((file) => {
+    const workerId = file.replace(/\.json$/, "");
+    const config = loadOpenCodeWorkerConfig(workerId, options);
+    return {
+      ...config,
+      configFile: resolveOpenCodeWorkerConfigFile(workerId, options),
+      stateFile: resolveOpenCodeWorkerStateFile(workerId, options)
+    };
+  }).sort((left, right) => left.workerId.localeCompare(right.workerId));
+}
+function getOpenCodeWorkerDoctorReport(options = {}, dependencies = {}) {
+  return {
+    workers: listOpenCodeWorkerConfigs(options).map((config) => {
+      const runtimeErrors = [];
+      try {
+        dependencies.assertOpenCodeCliRuntimeContract?.("opencode", {
+          useShell: config.openCodeShell === true
+        });
+      } catch (error) {
+        runtimeErrors.push(error instanceof Error ? error.message : "OpenCode CLI is unavailable");
+      }
+      return {
+        ...config,
+        configStatus: "ok",
+        runtimeStatus: runtimeErrors.length > 0 ? "error" : "ok",
+        errors: runtimeErrors
+      };
+    })
+  };
+}
+function setOpenCodeWorkerEnabled(workerId, enabled, options = {}) {
+  const config = loadOpenCodeWorkerConfig(workerId, options);
+  writeOpenCodeWorkerConfig(
+    {
+      ...config,
+      enabled
+    },
+    options
+  );
+}
+function uninstallOpenCodeWorker(workerId, options = {}) {
+  const configFile = resolveOpenCodeWorkerConfigFile(workerId, options);
+  const stateFile = resolveOpenCodeWorkerStateFile(workerId, options);
+  const config = existsSync(configFile) ? loadOpenCodeWorkerConfig(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, "OpenCode 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, "OpenCode worker setup canceled");
+      return resolved;
+    },
+    async confirm(params) {
+      const value = await confirm({
+        message: params.message,
+        initialValue: params.initialValue
+      });
+      const resolved = unwrapCanceledValue(value, "OpenCode 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;
+  };
+}
+function unwrapCanceledValue(value, message) {
+  if (isCancel(value)) {
+    throw new Error(message);
+  }
+  return value;
+}
+async function resolveTextInput(providedValue, prompter, params) {
+  if (providedValue !== void 0) {
+    const error = params.validate?.(providedValue);
+    if (error) {
+      throw new Error(error);
+    }
+    return providedValue;
+  }
+  return await prompter.text(params);
+}
+async function resolveSelectInput(providedValue, prompter, params) {
+  if (providedValue !== void 0) {
+    return providedValue;
+  }
+  return await prompter.select(params);
+}
+async function promptRepoMappings(prompter, defaultWorkspace) {
+  const repoMappings = {};
+  const addFirstPrompt = renderCliPrompt("cli.opencode-worker.repo-mapping.add-first", void 0);
+  let addAnotherMapping = await prompter.confirm({
+    message: addFirstPrompt.message,
+    initialValue: false
+  });
+  while (addAnotherMapping) {
+    const repoNamePrompt = renderCliPrompt("cli.opencode-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.opencode-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.opencode-worker.repo-mapping.add-another", void 0);
+    addAnotherMapping = await prompter.confirm({
+      message: addAnotherPrompt.message,
+      initialValue: false
+    });
+  }
+  return repoMappings;
+}
+function removeFileIfPresent(file) {
+  if (!existsSync(file)) {
+    return false;
+  }
+  rmSync(file, { force: true });
+  return true;
+}
+
+// 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 { Buffer } from "buffer";
+import { spawn, spawnSync } from "child_process";
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import process from "process";
+import { renderTextLlmPrompt } from "@meego-harness/prompt-registry";
+var OPENCODE_PREFLIGHT_TIMEOUT_MS = 1e4;
+var OPENCODE_CONTRACT_TIMEOUT_MS = 3e4;
+var OPENCODE_MAX_BUFFER = 1024 * 1024;
+var OpenCodeCliTaskExecutor = class {
+  openCodeBin;
+  useShell;
+  shell;
+  spawnChild;
+  constructor(config = {}) {
+    this.openCodeBin = config.openCodeBin ?? "opencode";
+    this.useShell = config.useShell ?? false;
+    this.shell = config.shell ?? process.env.SHELL ?? "sh";
+    this.spawnChild = config.spawn ?? spawn;
+  }
+  async runTurn(request) {
+    if (request.abortSignal.aborted) {
+      throw createAbortError();
+    }
+    const args = buildOpenCodeArgs(request);
+    const command = buildOpenCodeSpawnCommand(this.openCodeBin, args, {
+      useShell: this.useShell,
+      shell: this.shell
+    });
+    const child = this.spawnChild(command.command, command.args, {
+      cwd: request.cwd,
+      detached: command.detached,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return await new Promise((resolve3, reject) => {
+      let settled = false;
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      function settle(callback) {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        request.abortSignal.removeEventListener("abort", onAbort);
+        callback();
+      }
+      function onAbort() {
+        killChildProcess(child, {
+          killProcessGroup: command.killProcessGroup
+        });
+        settle(() => reject(createAbortError()));
+      }
+      request.abortSignal.addEventListener("abort", onAbort, { once: true });
+      child.stdout?.on("data", (chunk) => {
+        stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      child.once("error", (error) => {
+        settle(() => reject(error));
+      });
+      child.once("close", (code, signal) => {
+        if (request.abortSignal.aborted) {
+          settle(() => reject(createAbortError()));
+          return;
+        }
+        const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+        const stderr = Buffer.concat(stderrChunks).toString("utf8");
+        if (code !== 0) {
+          settle(
+            () => reject(new Error(buildOpenCodeExitError({
+              code,
+              signal,
+              stderr,
+              stdout
+            })))
+          );
+          return;
+        }
+        try {
+          const result = parseOpenCodeJsonResult(stdout, request.contextId);
+          settle(() => resolve3(result));
+        } catch (error) {
+          settle(() => reject(error instanceof Error ? error : new Error("Failed to parse OpenCode output")));
+        }
+      });
+    });
+  }
+};
+function assertOpenCodeCliAvailable(openCodeBin = "opencode", run = spawnSync, options = {}) {
+  for (const args of [
+    ["--help"],
+    ["run", "--help"]
+  ]) {
+    const command = buildOpenCodeSpawnCommand(openCodeBin, args, options);
+    const result = run(command.command, command.args, {
+      ...command.detached ? { detached: true } : {},
+      killSignal: "SIGTERM",
+      stdio: "ignore",
+      timeout: OPENCODE_PREFLIGHT_TIMEOUT_MS
+    });
+    if (result.error) {
+      throw new Error(`Unable to execute ${openCodeBin}: ${result.error.message}`);
+    }
+    if (typeof result.status === "number" && result.status !== 0) {
+      throw new Error(
+        `OpenCode CLI preflight failed for "${[openCodeBin, ...args].join(" ")}" with exit code ${String(result.status)}`
+      );
+    }
+  }
+}
+function assertOpenCodeCliRuntimeContract(openCodeBin = "opencode", dependencies = {}) {
+  const run = dependencies.run ?? spawnSync;
+  const createTempDir = dependencies.createTempDir ?? (() => mkdtempSync(join2(tmpdir(), "meego-opencode-worker-doctor-")));
+  const tempDir = createTempDir();
+  const prompt = renderTextLlmPrompt("worker.opencode.runtime-contract-check", void 0).text;
+  const executionRequest = {
+    taskId: "doctor-contract",
+    contextId: "doctor-contract",
+    cwd: tempDir,
+    prompt,
+    variant: "low",
+    permissionPreset: "safe",
+    abortSignal: new AbortController().signal
+  };
+  const firstResult = runOpenCodeContractCommand(
+    run,
+    openCodeBin,
+    buildOpenCodeArgs(executionRequest),
+    tempDir,
+    dependencies
+  );
+  const firstParsed = parseOpenCodeJsonResult(firstResult.stdout, "doctor-contract");
+  const resumeResult = runOpenCodeContractCommand(
+    run,
+    openCodeBin,
+    buildOpenCodeArgs({
+      ...executionRequest,
+      sessionId: firstParsed.sessionId
+    }),
+    tempDir,
+    dependencies
+  );
+  parseOpenCodeJsonResult(resumeResult.stdout, "doctor-contract");
+}
+function buildOpenCodeArgs(request) {
+  const args = [
+    "run",
+    "--format",
+    "json"
+  ];
+  if (request.sessionId) {
+    args.push("--session", request.sessionId);
+  }
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  if (request.variant) {
+    args.push("--variant", request.variant);
+  }
+  if (request.agent) {
+    args.push("--agent", request.agent);
+  }
+  if (shouldSkipPermissionsForPreset(request.permissionPreset)) {
+    args.push("--dangerously-skip-permissions");
+  }
+  args.push(request.prompt);
+  return args;
+}
+function shouldSkipPermissionsForPreset(preset) {
+  return preset === "full-access";
+}
+function createAbortError() {
+  const error = new Error("OpenCode 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 parseOpenCodeJsonResult(stdout, contextId) {
+  const text2 = Buffer.isBuffer(stdout) ? stdout.toString("utf8") : stdout ?? "";
+  const trimmed = text2.trim();
+  if (!trimmed) {
+    throw new Error(`OpenCode did not emit JSON output for context ${contextId}`);
+  }
+  const events = trimmed.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      throw new Error(
+        `OpenCode emitted invalid JSONL for context ${contextId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  });
+  const errorEvent = events.find((event) => event.type === "error");
+  if (errorEvent) {
+    throw new Error(`OpenCode returned an error for context ${contextId}: ${summarizeOpenCodeError(errorEvent.error)}`);
+  }
+  const sessionId = events.map((event) => typeof event.sessionID === "string" ? event.sessionID.trim() : "").find((value) => value.length > 0);
+  const textParts = events.filter((event) => event.type === "text" && event.part?.type === "text").map((event) => typeof event.part?.text === "string" ? event.part.text.trim() : "").filter(Boolean);
+  if (!sessionId || textParts.length === 0) {
+    throw new Error(`OpenCode returned an invalid result for context ${contextId}`);
+  }
+  return {
+    text: textParts.join("\n\n").trim(),
+    sessionId
+  };
+}
+function summarizeOpenCodeError(error) {
+  if (!error || typeof error !== "object") {
+    return String(error ?? "unknown");
+  }
+  const data = error.data;
+  if (data && typeof data === "object" && typeof data.message === "string") {
+    return data.message;
+  }
+  if (typeof error.message === "string") {
+    return error.message;
+  }
+  if (typeof error.name === "string") {
+    return error.name;
+  }
+  return "unknown";
+}
+function buildOpenCodeSpawnCommand(openCodeBin, args, options) {
+  if (!options.useShell) {
+    return {
+      command: openCodeBin,
+      args,
+      detached: false,
+      killProcessGroup: false
+    };
+  }
+  return {
+    command: options.shell ?? process.env.SHELL ?? "sh",
+    args: ["-ic", buildShellCommand(openCodeBin, args)],
+    detached: true,
+    killProcessGroup: true
+  };
+}
+function buildShellCommand(command, args) {
+  return [command, ...args.map(quoteShellArg)].join(" ");
+}
+function quoteShellArg(value) {
+  if (value.length === 0) {
+    return "''";
+  }
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function killChildProcess(child, options) {
+  if (options.killProcessGroup && typeof child.pid === "number") {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+      return;
+    } catch {
+      child.kill("SIGTERM");
+      return;
+    }
+  }
+  child.kill("SIGTERM");
+}
+function runOpenCodeContractCommand(run, openCodeBin, args, cwd, options = {}) {
+  const command = buildOpenCodeSpawnCommand(openCodeBin, args, options);
+  const result = run(command.command, command.args, {
+    ...command.detached ? { detached: true } : {},
+    cwd,
+    encoding: "utf8",
+    maxBuffer: OPENCODE_MAX_BUFFER,
+    timeout: OPENCODE_CONTRACT_TIMEOUT_MS
+  });
+  if (result.error) {
+    throw new Error(`Unable to execute ${openCodeBin}: ${result.error.message}`);
+  }
+  if (typeof result.status === "number" && result.status !== 0) {
+    throw new Error(buildOpenCodeExitError({
+      code: result.status,
+      signal: result.signal,
+      stderr: stringifyOutput(result.stderr),
+      stdout: stringifyOutput(result.stdout)
+    }));
+  }
+  return result;
+}
+function buildOpenCodeExitError(params) {
+  const base = `OpenCode exited with code ${params.code}${params.signal ? ` (${params.signal})` : ""}`;
+  const stderr = summarizeOutput(params.stderr);
+  if (stderr) {
+    return `${base}; stderr=${stderr}`;
+  }
+  const stdout = summarizeOutput(params.stdout);
+  if (stdout) {
+    return `${base}; stdout=${stdout}`;
+  }
+  return base;
+}
+function summarizeOutput(value) {
+  return value.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).slice(-5).join(" | ");
+}
+function stringifyOutput(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  return "";
+}
+
+// src/bridge.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join4, relative as relative2, resolve as resolve2 } from "path";
+import process2 from "process";
+import {
+  parseManagerRunResult
+} from "@meego-harness/manager-contract";
+import { renderTextLlmPrompt as renderTextLlmPrompt2, renderTextPrompt } from "@meego-harness/prompt-registry";
+import { WorkerClientSDK } from "@meego-harness/worker-sdk";
+
+// src/artifacts.ts
+import { lstat, mkdir, readFile, rm } from "fs/promises";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join3, relative, resolve, sep } from "path";
+var DEFAULT_ARTIFACT_STAGING_ROOT = "artifacts";
+var MAX_STAGED_ARTIFACT_BYTES = 20 * 1024 * 1024;
+var SAFE_IDENTIFIER_PATTERN = /^[A-Za-z0-9._-]+$/u;
+var StagedArtifactValidationError = class extends Error {
+  artifactId;
+  constructor(artifactId, message) {
+    super(message);
+    this.name = "StagedArtifactValidationError";
+    this.artifactId = artifactId;
+  }
+};
+function resolveTaskArtifactStagingDir(input) {
+  assertSafeIdentifier(input.taskId, "taskId");
+  const cwd = resolve(input.cwd);
+  const rootInput = input.artifactStagingRoot ?? DEFAULT_ARTIFACT_STAGING_ROOT;
+  const root = isAbsolute2(rootInput) ? resolve(rootInput) : resolve(cwd, rootInput);
+  const rootRelativePath = relative(cwd, root);
+  if (rootRelativePath.startsWith("..") || isAbsolute2(rootRelativePath)) {
+    throw new Error(`artifactStagingRoot must resolve inside cwd: ${root}`);
+  }
+  return join3(root, input.taskId);
+}
+async function prepareArtifactStagingDir(artifactStagingDir, boundaryDir = dirname2(dirname2(artifactStagingDir))) {
+  await assertExistingPathComponentsAreNotSymlinks(artifactStagingDir, boundaryDir);
+  await rm(artifactStagingDir, { recursive: true, force: true });
+  await mkdir(artifactStagingDir, { recursive: true });
+}
+function validateArtifactManifest(manifests) {
+  const artifactIds = /* @__PURE__ */ new Set();
+  for (const manifest of manifests) {
+    validateSingleArtifactManifest(manifest);
+    if (artifactIds.has(manifest.artifactId)) {
+      throw new StagedArtifactValidationError(
+        manifest.artifactId,
+        `duplicate staged artifact id: ${manifest.artifactId}`
+      );
+    }
+    artifactIds.add(manifest.artifactId);
+  }
+}
+async function readStagedArtifact(artifactStagingDir, manifest, boundaryDir) {
+  validateSingleArtifactManifest(manifest);
+  await assertExistingPathComponentsAreNotSymlinks(artifactStagingDir, boundaryDir);
+  const artifactDir = join3(artifactStagingDir, manifest.artifactId);
+  const file = join3(artifactStagingDir, manifest.artifactId, manifest.fileName);
+  const artifactDirStat = await lstat(artifactDir).catch(() => {
+    throw new StagedArtifactValidationError(
+      manifest.artifactId,
+      `missing staged artifact directory: ${manifest.artifactId}`
+    );
+  });
+  if (artifactDirStat.isSymbolicLink() || !artifactDirStat.isDirectory()) {
+    throw new StagedArtifactValidationError(
+      manifest.artifactId,
+      `invalid staged artifact directory: ${manifest.artifactId}`
+    );
+  }
+  let fileStat;
+  try {
+    fileStat = await lstat(file);
+  } catch {
+    throw new StagedArtifactValidationError(
+      manifest.artifactId,
+      `missing staged artifact file: ${manifest.fileName}`
+    );
+  }
+  if (fileStat.isSymbolicLink() || !fileStat.isFile() || fileStat.size === 0 || fileStat.size > MAX_STAGED_ARTIFACT_BYTES) {
+    throw new StagedArtifactValidationError(
+      manifest.artifactId,
+      `invalid staged artifact file: ${manifest.fileName}`
+    );
+  }
+  const data = await readFile(file);
+  return {
+    artifactId: manifest.artifactId,
+    name: manifest.fileName,
+    parts: [
+      {
+        type: "data",
+        data: {
+          base64: data.toString("base64"),
+          fileName: manifest.fileName
+        },
+        ...manifest.mimeType ? { mimeType: manifest.mimeType } : {}
+      }
+    ]
+  };
+}
+async function cleanupStagedArtifact(artifactStagingDir, manifest, boundaryDir) {
+  await assertExistingPathComponentsAreNotSymlinks(artifactStagingDir, boundaryDir);
+  const artifactDir = join3(artifactStagingDir, manifest.artifactId);
+  await assertStagedArtifactDirectory(artifactDir, manifest);
+  await assertStagedArtifactFile(join3(artifactDir, manifest.fileName), manifest);
+  await rm(join3(artifactDir, manifest.fileName), { force: true });
+  await assertExistingPathComponentsAreNotSymlinks(artifactStagingDir, boundaryDir);
+  await assertStagedArtifactDirectory(artifactDir, manifest);
+  await rm(artifactDir, { recursive: false }).catch(ignoreNonEmptyDirectoryError);
+  await assertExistingPathIsNotSymlink(artifactStagingDir, manifest.artifactId, "artifactStagingDir");
+  await rm(artifactStagingDir, { recursive: false }).catch(ignoreNonEmptyDirectoryError);
+}
+function validateSingleArtifactManifest(manifest) {
+  assertSafeIdentifier(manifest.artifactId, "artifactId");
+  assertSafeFileName(manifest.artifactId, manifest.fileName);
+  if (manifest.mimeType !== void 0 && manifest.mimeType.trim().length === 0) {
+    throw new StagedArtifactValidationError(manifest.artifactId, "staged artifact mimeType is empty");
+  }
+}
+function assertSafeIdentifier(value, label) {
+  if (value === "." || value === ".." || !SAFE_IDENTIFIER_PATTERN.test(value)) {
+    throw new StagedArtifactValidationError(value, `unsafe staged artifact ${label}: ${value}`);
+  }
+}
+function assertSafeFileName(artifactId, fileName) {
+  if (fileName.length === 0 || fileName !== basename(fileName) || fileName.includes("..")) {
+    throw new StagedArtifactValidationError(artifactId, `unsafe staged artifact fileName: ${fileName}`);
+  }
+}
+async function assertExistingPathComponentsAreNotSymlinks(path, boundaryDir) {
+  const resolvedPath = resolve(path);
+  const resolvedBoundary = resolve(boundaryDir);
+  const relativePath = relative(resolvedBoundary, resolvedPath);
+  if (relativePath.startsWith("..") || isAbsolute2(relativePath)) {
+    throw new Error(`staged artifact path must stay inside boundary: ${resolvedPath}`);
+  }
+  await assertExistingPathIsNotSymlink(resolvedBoundary, resolvedBoundary, "path component");
+  const relativeParts = relativePath.split(sep).filter(Boolean);
+  let currentPath = resolvedBoundary;
+  for (const part of relativeParts) {
+    currentPath = join3(currentPath, part);
+    await assertExistingPathIsNotSymlink(currentPath, currentPath, "path component");
+  }
+}
+async function assertExistingPathIsNotSymlink(path, artifactId, label) {
+  const pathStat = await lstat(path).catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  });
+  if (pathStat?.isSymbolicLink()) {
+    throw new StagedArtifactValidationError(artifactId, `staged artifact ${label} is a symlink: ${path}`);
+  }
+}
+async function assertStagedArtifactDirectory(artifactDir, manifest) {
+  const artifactDirStat = await lstat(artifactDir);
+  if (artifactDirStat.isSymbolicLink() || !artifactDirStat.isDirectory()) {
+    throw new StagedArtifactValidationError(
+      manifest.artifactId,
+      `invalid staged artifact directory: ${manifest.artifactId}`
+    );
+  }
+}
+async function assertStagedArtifactFile(file, manifest) {
+  const fileStat = await lstat(file);
+  if (fileStat.isSymbolicLink() || !fileStat.isFile()) {
+    throw new StagedArtifactValidationError(
+      manifest.artifactId,
+      `invalid staged artifact file: ${manifest.fileName}`
+    );
+  }
+}
+function ignoreNonEmptyDirectoryError(error) {
+  if (!isNodeError(error) || error.code !== "ENOTEMPTY" && error.code !== "EEXIST") {
+    throw error;
+  }
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/bridge.ts
+var OpenCodeWorkerBridge = 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 ?? join4(process2.cwd(), `${config.workerId}.state.json`);
+    for (const binding of loadOpenCodeWorkerState(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,
+          supportedRoles: buildSupportedRoles(OPENCODE_WORKER_ROLE),
+          initialAvailability: "available"
+        });
+        return;
+      }
+      await this.client.switchRole({
+        workerId: this.config.workerId,
+        email: this.config.email,
+        role: request.role,
+        capabilitySummary: this.config.capabilitySummary,
+        supportedRoles: buildSupportedRoles(OPENCODE_WORKER_ROLE),
+        initialAvailability: "available"
+      });
+    });
+    await this.client.connect();
+    await this.client.login(buildWorkerLoginPayload(this.config, OPENCODE_WORKER_ROLE));
+    return this;
+  }
+  async stop() {
+    for (const execution of this.activeTasks.values()) {
+      execution.canceled = true;
+      execution.abortController.abort();
+    }
+    await Promise.allSettled(this.contextQueues.values());
+    this.activeTasks.clear();
+    this.pendingCanceledTaskIds.clear();
+    await this.client.disconnect();
+  }
+  async handleTaskMessage({
+    task,
+    message,
+    controller
+  }) {
+    this.supersedeActiveTaskExecution(task.id);
+    const previous = this.contextQueues.get(task.contextId) ?? Promise.resolve();
+    const current = previous.catch(() => void 0).then(async () => {
+      await this.processTaskMessage({ task, message, 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,
+    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,
+      supersededByMessage: 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;
+    let resolvedBinding;
+    let activeBinding;
+    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();
+        }
+      }
+      resolvedBinding = binding;
+      if (!resolvedBinding) {
+        throw new Error(`Missing context binding for ${task.contextId}`);
+      }
+      const currentBinding = resolvedBinding;
+      activeBinding = currentBinding;
+      if (!await this.trySendTaskStatusUpdate(
+        task.id,
+        "working",
+        async () => await controller.working({
+          parts: [
+            {
+              type: "text",
+              text: OPENCODE_WORKER_WORKING_TEXT
+            }
+          ]
+        })
+      )) {
+        return;
+      }
+      const managerRunInput = readManagerRunInput(task.metadata);
+      const structuredProtocol = readOptionalStringMetadata(
+        task.metadata,
+        "projectNodeResultProtocol"
+      );
+      const artifactStagingDir = structuredProtocol && !managerRunInput ? resolveTaskArtifactStagingDir({
+        cwd: currentBinding.cwd,
+        taskId: task.id,
+        artifactStagingRoot: this.config.artifactStagingRoot
+      }) : void 0;
+      if (artifactStagingDir) {
+        await prepareArtifactStagingDir(artifactStagingDir, currentBinding.cwd);
+      }
+      const prompt = managerRunInput ? buildManagerRunPrompt(managerRunInput) : stringifyTaskMessageParts(message.parts);
+      const promptWithArtifactInstructions = managerRunInput ? prompt : appendArtifactStagingInstructions(prompt, artifactStagingDir);
+      const finalPrompt = createdBinding && currentBinding.planMode ? `${renderTextLlmPrompt2("worker.opencode.plan-mode-preamble", void 0).text}
+
+${promptWithArtifactInstructions}`.trim() : promptWithArtifactInstructions;
+      const result = await this.runExecutorTurn(buildOpenCodeTaskExecutionRequest(
+        task,
+        finalPrompt,
+        currentBinding,
+        this.config,
+        execution
+      ));
+      if (this.isTaskCanceled(task.id)) {
+        return;
+      }
+      if (currentBinding.sessionId !== result.sessionId) {
+        currentBinding.sessionId = result.sessionId;
+        this.bindings.set(task.contextId, currentBinding);
+        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: buildOpenCodeMetadata(currentBinding, requestedRepo, {
+              managerRunResult
+            })
+          })
+        );
+        return;
+      }
+      const structuredResult = structuredProtocol ? await this.resolveStructuredProjectNodeResult(
+        task,
+        currentBinding,
+        structuredProtocol,
+        artifactStagingDir,
+        result.text,
+        execution
+      ) : {
+        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: buildOpenCodeMetadata(currentBinding, requestedRepo, {
+              "openCode.summary": structuredResult.summary,
+              ...structuredResult.options ? {
+                responseSpec: {
+                  required: true,
+                  allowedPartTypes: ["text"],
+                  options: structuredResult.options
+                }
+              } : {},
+              ...structuredResult.reasonType ? { projectNodeReasonType: structuredResult.reasonType } : {}
+            })
+          })
+        );
+        return;
+      }
+      await this.registerStructuredArtifacts(
+        artifactStagingDir,
+        currentBinding.cwd,
+        structuredResult.artifacts,
+        structuredResult.writes,
+        controller
+      );
+      await this.trySendTaskStatusUpdate(
+        task.id,
+        "completed",
+        async () => await controller.complete({
+          parts: [
+            {
+              type: "text",
+              text: structuredResult.summary
+            }
+          ],
+          metadata: buildOpenCodeMetadata(
+            currentBinding,
+            requestedRepo,
+            structuredResult.writes || structuredResult.childWorkItems ? {
+              ...structuredResult.writes ? { projectNodeWrites: structuredResult.writes } : {},
+              ...structuredResult.childWorkItems ? { projectNodeChildWorkItems: structuredResult.childWorkItems } : {}
+            } : 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 : "OpenCode run failed"
+            }
+          ],
+          metadata: buildOpenCodeFailureMetadata(
+            activeBinding,
+            requestedRepo,
+            this.config,
+            error
+          )
+        })
+      );
+    } 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();
+  }
+  supersedeActiveTaskExecution(taskId) {
+    const execution = this.activeTasks.get(taskId);
+    if (!execution || execution.canceled || execution.supersededByMessage) {
+      return;
+    }
+    execution.supersededByMessage = true;
+    execution.abortController.abort();
+  }
+  async runExecutorTurn(request) {
+    if (request.abortSignal.aborted) {
+      throw createAbortError();
+    }
+    const abortedResult = { aborted: true };
+    let abortObserved = false;
+    const executorPromise = this.executor.runTurn(request).catch((error) => {
+      if (abortObserved && (request.abortSignal.aborted || isAbortError(error))) {
+        return abortedResult;
+      }
+      throw error;
+    });
+    const abortPromise = new Promise((resolve3) => {
+      function onAbort() {
+        request.abortSignal.removeEventListener("abort", onAbort);
+        abortObserved = true;
+        resolve3(abortedResult);
+      }
+      request.abortSignal.addEventListener("abort", onAbort, { once: true });
+      void executorPromise.then(() => {
+        request.abortSignal.removeEventListener("abort", onAbort);
+      }, () => {
+        request.abortSignal.removeEventListener("abort", onAbort);
+      });
+    });
+    const result = await Promise.race([
+      executorPromise,
+      abortPromise
+    ]);
+    if ("aborted" in result) {
+      throw createAbortError();
+    }
+    return result;
+  }
+  createBinding(contextId, metadata) {
+    const repo = readOptionalStringMetadata(metadata, "repo");
+    const explicitVariant = readOptionalStringMetadata(metadata, "openCodeVariant");
+    const explicitAgent = readOptionalStringMetadata(metadata, "openCodeAgent");
+    const planMode = readOptionalBooleanMetadata(metadata, "openCodePlanMode") ?? false;
+    const cwd = this.resolveCwd(repo);
+    return {
+      contextId,
+      ...repo ? { repo } : {},
+      cwd,
+      variant: explicitVariant ?? (this.config.variantDefault === "use-opencode-default" ? void 0 : this.config.variantDefault),
+      agent: explicitAgent ?? (this.config.agentDefault === "use-opencode-default" ? void 0 : this.config.agentDefault),
+      planMode
+    };
+  }
+  hydrateBindingFromMetadata(binding, metadata) {
+    const repo = readOptionalStringMetadata(metadata, "repo");
+    if (binding.repo) {
+      return binding;
+    }
+    if (!repo) {
+      return binding;
+    }
+    return {
+      ...binding,
+      repo,
+      cwd: this.resolveCwd(repo)
+    };
+  }
+  resolveCwd(repo) {
+    if (!repo) {
+      this.ensureDirectory(this.config.defaultWorkspace, "default workspace directory");
+      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}`);
+      this.ensureWorkspaceSubdirectory(mapped, `mapped repo directory for ${repo}`);
+      return mapped;
+    }
+    const inferred = join4(this.config.defaultWorkspace, repo);
+    this.ensureDirectory(inferred, `workspace repo directory for ${repo}`);
+    this.ensureWorkspaceSubdirectory(inferred, `workspace repo directory for ${repo}`);
+    return inferred;
+  }
+  ensureDirectory(path, label) {
+    if (!existsSync2(path)) {
+      throw new Error(`Missing ${label}: ${path}`);
+    }
+  }
+  ensureWorkspaceSubdirectory(path, label) {
+    const workspaceRoot = resolve2(this.config.defaultWorkspace);
+    const candidate = resolve2(path);
+    const relativePath = relative2(workspaceRoot, candidate);
+    if (!relativePath || relativePath === "." || relativePath.startsWith("..") || isAbsolute3(relativePath)) {
+      throw new Error(`Expected ${label} to be a subdirectory of ${workspaceRoot}: ${candidate}`);
+    }
+  }
+  persistState() {
+    mkdirSync2(dirname3(this.stateFile), { recursive: true });
+    writeOpenCodeWorkerState(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, artifactStagingDir, firstText, execution) {
+    const firstParsed = parseProjectNodeResult(protocol, firstText);
+    if (firstParsed) {
+      return firstParsed;
+    }
+    const retryResult = await this.runExecutorTurn(buildOpenCodeTaskExecutionRequest(
+      task,
+      buildStructuredRetryPrompt(protocol, artifactStagingDir),
+      binding,
+      this.config,
+      execution
+    ));
+    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);
+    if (retryParsed) {
+      return retryParsed;
+    }
+    throw new Error("OpenCode returned an invalid structured result after one retry");
+  }
+  async registerStructuredArtifacts(artifactStagingDir, artifactBoundaryDir, manifests, writes, controller) {
+    const attachmentWrites = writes?.filter(isProjectNodeAttachmentWrite) ?? [];
+    if (!manifests?.length && attachmentWrites.length === 0) {
+      return;
+    }
+    const manifestById = /* @__PURE__ */ new Map();
+    for (const manifest of manifests ?? []) {
+      manifestById.set(manifest.artifactId, manifest);
+    }
+    for (const write of attachmentWrites) {
+      if (!manifestById.has(write.artifactId)) {
+        throw createAttachmentArtifactNotFoundError(write.artifactId);
+      }
+    }
+    if (!artifactStagingDir) {
+      throw createAttachmentArtifactNotFoundError(attachmentWrites[0].artifactId);
+    }
+    try {
+      validateArtifactManifest(manifests ?? []);
+    } catch (error) {
+      if (error instanceof StagedArtifactValidationError) {
+        throw createAttachmentArtifactSourceInvalidError(error.artifactId);
+      }
+      throw error;
+    }
+    for (const manifest of manifests ?? []) {
+      let artifact;
+      try {
+        artifact = await readStagedArtifact(artifactStagingDir, manifest, artifactBoundaryDir);
+      } catch (error) {
+        if (error instanceof StagedArtifactValidationError) {
+          throw createAttachmentArtifactSourceInvalidError(manifest.artifactId);
+        }
+        throw error;
+      }
+      await controller.addArtifact(artifact);
+      await cleanupStagedArtifact(artifactStagingDir, manifest, artifactBoundaryDir).catch((error) => {
+        this.logger.warn(
+          `Failed to clean staged artifact ${manifest.artifactId}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }
+  }
+};
+function isProjectNodeAttachmentWrite(write) {
+  return write.kind === "upload-attachment";
+}
+function createAttachmentArtifactNotFoundError(artifactId) {
+  return new Error(renderTextPrompt("sdk.runtime-error.message", {
+    errorCode: "work-item-attachment-artifact-not-found",
+    artifactId
+  }).text);
+}
+function createAttachmentArtifactSourceInvalidError(artifactId) {
+  return new Error(renderTextPrompt("sdk.runtime-error.message", {
+    errorCode: "work-item-attachment-source-invalid",
+    artifactId
+  }).text);
+}
+function buildWorkerLoginPayload(config, role) {
+  return {
+    workerId: config.workerId,
+    email: config.email,
+    role,
+    capabilitySummary: config.capabilitySummary,
+    supportedRoles: buildSupportedRoles(OPENCODE_WORKER_ROLE),
+    initialAvailability: "available"
+  };
+}
+function buildSupportedRoles(baseRole) {
+  return [baseRole, "manager"];
+}
+function buildOpenCodeMetadata(binding, requestedRepo, extraMetadata) {
+  return {
+    "openCode.sessionId": binding.sessionId,
+    "openCode.cwd": binding.cwd,
+    ...binding.repo ? { "openCode.repo": binding.repo } : {},
+    ...requestedRepo ? { "openCode.requestedRepo": requestedRepo } : {},
+    ...binding.variant ? { "openCode.variant": binding.variant } : {},
+    ...binding.agent ? { "openCode.agent": binding.agent } : {},
+    "openCode.planMode": binding.planMode,
+    ...extraMetadata ? structuredClone(extraMetadata) : {}
+  };
+}
+function buildOpenCodeFailureMetadata(binding, requestedRepo, config, error) {
+  const baseMetadata = binding ? buildOpenCodeMetadata(binding, requestedRepo) : {};
+  const failureReason = readOpenCodeFailureReason(error);
+  return {
+    ...baseMetadata,
+    "openCode.modelSelection": config.modelSelection,
+    "openCode.effectiveModel": config.modelSelection === "use-opencode-default" ? "opencode-default" : config.modelSelection,
+    "openCode.permissionPreset": config.permissionPreset,
+    ...config.variantDefault !== "use-opencode-default" ? { "openCode.defaultVariant": config.variantDefault } : {},
+    ...config.agentDefault !== "use-opencode-default" ? { "openCode.defaultAgent": config.agentDefault } : {},
+    ...failureReason ? { "openCode.failureReason": failureReason } : {}
+  };
+}
+function buildOpenCodeTaskExecutionRequest(task, prompt, binding, config, execution) {
+  return {
+    taskId: task.id,
+    contextId: task.contextId,
+    cwd: binding.cwd,
+    prompt,
+    sessionId: binding.sessionId,
+    model: config.modelSelection === "use-opencode-default" ? void 0 : config.modelSelection,
+    variant: binding.variant,
+    agent: binding.agent,
+    permissionPreset: config.permissionPreset,
+    abortSignal: execution.abortController.signal
+  };
+}
+function appendArtifactStagingInstructions(prompt, artifactStagingDir) {
+  if (!artifactStagingDir) {
+    return prompt;
+  }
+  const instructions = renderTextLlmPrompt2("worker.opencode.artifact-staging-instructions", {
+    artifactStagingDir
+  }).text;
+  return `${prompt}
+
+${instructions}`.trim();
+}
+function buildStructuredRetryPrompt(_protocol, artifactStagingDir) {
+  return renderTextLlmPrompt2(
+    "worker.opencode.structured-retry",
+    artifactStagingDir ? { artifactStagingDir } : void 0
+  ).text;
+}
+function buildManagerRunPrompt(input) {
+  return renderTextLlmPrompt2("worker.opencode.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) {
+  const parsed = parseProjectNodeResultObject(text2);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    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 writes = normalizeProjectNodeWrites(
+        parsed.projectNodeWrites ?? parsed.writes
+      );
+      if (writes === null) {
+        return null;
+      }
+      const artifacts = normalizeProjectNodeArtifacts(parsed.artifacts);
+      if (artifacts === null) {
+        return null;
+      }
+      const childWorkItems = normalizeProjectNodeChildWorkItems(
+        parsed.childWorkItems
+      );
+      return {
+        status,
+        summary,
+        ...artifacts && artifacts.length > 0 ? { artifacts } : {},
+        ...writes && writes.length > 0 ? { writes } : {},
+        ...childWorkItems && childWorkItems.length > 0 ? { childWorkItems } : {}
+      };
+    }
+    const question = normalizeSummary(parsed.question);
+    if (!question) {
+      return null;
+    }
+    const reasonType = normalizeProjectNodeReasonType(
+      parsed.reasonType
+    ) ?? void 0;
+    const options = normalizeResponseOptions(
+      parsed.options
+    );
+    return {
+      status,
+      summary,
+      question,
+      ...options ? { options } : {},
+      ...reasonType ? { reasonType } : {}
+    };
+  }
+  const choice = normalizeChoicePrefixedResult(parsed);
+  if (!choice) {
+    return null;
+  }
+  return choice;
+}
+function readManagerRunInput(metadata) {
+  const input = metadata?.managerRunInput;
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return null;
+  }
+  return structuredClone(input);
+}
+function readOpenCodeFailureReason(error) {
+  if (!(error instanceof Error)) {
+    return void 0;
+  }
+  const explicitReason = error.message.match(/;\s*reason=([^;]+)/u)?.[1]?.trim();
+  if (explicitReason) {
+    return explicitReason;
+  }
+  if (/context window/i.test(error.message)) {
+    return "context_window_exceeded";
+  }
+  return void 0;
+}
+function parseJsonObjectOrThrow(text2) {
+  const parsed = parseProjectNodeResultObject(text2);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("OpenCode returned an invalid manager run result");
+  }
+  return parsed;
+}
+function parseProjectNodeResultObject(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const jsonText = unwrapJsonCodeFence(trimmed) ?? trimmed;
+  try {
+    return JSON.parse(jsonText);
+  } catch {
+    const matched = jsonText.match(/^([12])\s+(\{[\s\S]+\})$/);
+    if (!matched) {
+      return null;
+    }
+    try {
+      return {
+        choice: matched[1],
+        ...JSON.parse(matched[2])
+      };
+    } catch {
+      return null;
+    }
+  }
+}
+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 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 normalizeResponseOptions(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return void 0;
+  }
+  const normalized = [];
+  const seenValues = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      return void 0;
+    }
+    const optionValue = normalizeSummary(item.value);
+    const label = normalizeSummary(item.label);
+    const responseText = normalizeSummary(item.responseText);
+    const description = normalizeSummary(item.description);
+    if (!optionValue || !label || !responseText || seenValues.has(optionValue)) {
+      return void 0;
+    }
+    seenValues.add(optionValue);
+    normalized.push({
+      value: optionValue,
+      label,
+      responseText,
+      ...description ? { description } : {}
+    });
+  }
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeProjectNodeWrites(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const writes = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      return null;
+    }
+    const record = item;
+    const fieldKey = normalizeSummary(record.fieldKey);
+    const reason = normalizeSummary(record.reason) ?? void 0;
+    if (!fieldKey) {
+      return null;
+    }
+    if (record.kind === "set-field") {
+      if (record.value === void 0 || record.value === null) {
+        return null;
+      }
+      writes.push({
+        kind: "set-field",
+        fieldKey,
+        value: structuredClone(record.value),
+        ...reason ? { reason } : {}
+      });
+      continue;
+    }
+    if (record.kind === "upload-attachment") {
+      const artifactId = normalizeSummary(record.artifactId);
+      if (!artifactId) {
+        return null;
+      }
+      writes.push({
+        kind: "upload-attachment",
+        fieldKey,
+        artifactId,
+        ...reason ? { reason } : {}
+      });
+      continue;
+    }
+    return null;
+  }
+  return writes;
+}
+function normalizeProjectNodeChildWorkItems(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const childWorkItems = value.flatMap((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      return [];
+    }
+    const record = item;
+    const stableKey = normalizeSummary(record.stableKey);
+    const name = normalizeSummary(record.name);
+    const description = normalizeSummary(record.description) ?? void 0;
+    if (!stableKey || !name) {
+      return [];
+    }
+    return [{
+      stableKey,
+      name,
+      ...description ? { description } : {}
+    }];
+  });
+  return childWorkItems;
+}
+function normalizeProjectNodeArtifacts(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const artifacts = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      return null;
+    }
+    const record = item;
+    const artifactId = normalizeSummary(record.artifactId);
+    const fileName = normalizeSummary(record.fileName);
+    if (!artifactId || !fileName) {
+      return null;
+    }
+    if ("mimeType" in record && typeof record.mimeType !== "string") {
+      return null;
+    }
+    artifacts.push({
+      artifactId,
+      fileName,
+      ...typeof record.mimeType === "string" ? { mimeType: record.mimeType } : {}
+    });
+  }
+  return artifacts;
+}
+function normalizeProjectNodeReasonType(value) {
+  return value === "guidance_missing" || value === "guidance_conflict" || value === "project_context_missing" || value === "project_context_conflict" || value === "business_fact_missing" || value === "permission_missing" || value === "external_dependency" || value === "unknown" ? value : null;
+}
+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;
+}
+
+export {
+  OPENCODE_WORKER_ROLE,
+  OPENCODE_WORKER_WORKING_TEXT,
+  OPENCODE_WORKER_CONFIG_DIR,
+  resolveOpenCodeWorkerStorageDir,
+  resolveOpenCodeWorkerConfigFile,
+  resolveOpenCodeWorkerStateFile,
+  loadOpenCodeWorkerConfig,
+  writeOpenCodeWorkerConfig,
+  loadOpenCodeWorkerState,
+  writeOpenCodeWorkerState,
+  runOpenCodeWorkerSetup,
+  listOpenCodeWorkerConfigs,
+  getOpenCodeWorkerDoctorReport,
+  setOpenCodeWorkerEnabled,
+  uninstallOpenCodeWorker,
+  createClackPrompter,
+  stringifyTaskMessageParts,
+  OpenCodeCliTaskExecutor,
+  assertOpenCodeCliAvailable,
+  assertOpenCodeCliRuntimeContract,
+  buildOpenCodeArgs,
+  shouldSkipPermissionsForPreset,
+  createAbortError,
+  isAbortError,
+  OpenCodeWorkerBridge
+};
+//# sourceMappingURL=chunk-4MUQ7X6C.js.map