remote-codex 0.11.11 → 0.11.13

package/apps/supervisor-api/dist/{chunk-2QAVWDYV.js → chunk-ZTQPMDTP.js}

@@ -8,9 +8,9 @@ var __export = (target, all) => {
 import Fastify from "fastify";
 import multipart from "@fastify/multipart";
 import websocket from "@fastify/websocket";
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import fs26 from "fs";
-import path25 from "path";
+import path26 from "path";
 import { ZodError } from "zod";
 
 // ../../packages/config/src/index.ts
@@ -98,6 +98,7 @@ var envSchema = z.object({
   ELAGENTE_HARNESS_BASE_URL: z.string().url().optional(),
   INACT_X_APP_KEY: z.string().min(1).optional(),
   REMOTE_CODEX_CHEMISTRY_TOOLS_ENABLED: z.string().optional(),
+  REMOTE_CODEX_HARNESS_WAKEUP_CALLBACK_BASE_URL: z.string().url().optional(),
   REMOTE_CODEX_WORKER_RUNTIME_MANIFEST: z.string().min(1).optional(),
   APP_NAME: z.string().min(1).optional(),
   APP_VERSION: z.string().min(1).optional(),
@@ -209,6 +210,7 @@ function loadRuntimeConfig(env = process.env) {
     harnessBaseUrl: parsed.ELAGENTE_HARNESS_BASE_URL ?? null,
     harnessEnabled: Boolean(parsed.ELAGENTE_HARNESS_BASE_URL && parsed.INACT_X_APP_KEY),
     chemistryToolsEnabled: parseBoolean(parsed.REMOTE_CODEX_CHEMISTRY_TOOLS_ENABLED, false),
+    harnessWakeupCallbackBaseUrl: parsed.REMOTE_CODEX_HARNESS_WAKEUP_CALLBACK_BASE_URL?.replace(/\/+$/, "") ?? null,
     workerRuntimeManifestPath: parsed.REMOTE_CODEX_WORKER_RUNTIME_MANIFEST ? path.resolve(parsed.REMOTE_CODEX_WORKER_RUNTIME_MANIFEST) : runtimeRole === "worker" ? "/opt/remote-codex/worker-runtime-manifest.json" : null,
     appName: parsed.APP_NAME ?? (runtimeRole === "worker" ? "Remote Codex Worker" : "Remote Codex Supervisor"),
     appVersion: parsed.APP_VERSION ?? "0.1.0",
@@ -2316,7 +2318,7 @@ Subquery.prototype.getSQL = function() {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path26, field }, columnIndex) => {
+    (result2, { path: path27, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -2326,8 +2328,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path26.entries()) {
-        if (pathChunkIndex < path26.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path27.entries()) {
+        if (pathChunkIndex < path27.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -2335,8 +2337,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path26.length === 2) {
-            const objectName = path26[0];
+          if (joinsNotNullableMap && is(field, Column) && path27.length === 2) {
+            const objectName = path27[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -6390,6 +6392,8 @@ __export(schema_exports, {
   controlUsageImportState: () => controlUsageImportState,
   controlUsers: () => controlUsers,
   controlWorkspaces: () => controlWorkspaces,
+  harnessJobWatches: () => harnessJobWatches,
+  harnessNotifyRegistrations: () => harnessNotifyRegistrations,
   hosts: () => hosts,
   notifications: () => notifications,
   policies: () => policies,
@@ -6855,6 +6859,33 @@ var controlAuditLogs = sqliteTable("control_audit_logs", {
   metadataJson: text("metadata_json").notNull(),
   createdAt: text("created_at").notNull()
 });
+var harnessNotifyRegistrations = sqliteTable("harness_notify_registrations", {
+  id: text("id").primaryKey(),
+  agentId: text("agent_id").notNull(),
+  hookToken: text("hook_token").notNull(),
+  secret: text("secret").notNull(),
+  callbackUrl: text("callback_url").notNull(),
+  registeredAt: text("registered_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var harnessJobWatches = sqliteTable(
+  "harness_job_watches",
+  {
+    id: text("id").primaryKey(),
+    jobId: text("job_id").notNull(),
+    threadId: text("thread_id").notNull(),
+    title: text("title"),
+    status: text("status").notNull().default("pending"),
+    lastJobStatus: text("last_job_status"),
+    lastError: text("last_error"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    deliveredAt: text("delivered_at")
+  },
+  (table) => ({
+    jobIdUnique: uniqueIndex("harness_job_watches_job_id_idx").on(table.jobId)
+  })
+);
 
 // ../../packages/db/src/client.ts
 function resolvePlatform() {
@@ -7394,6 +7425,72 @@ function deleteNotificationsByThreadId(db, threadId) {
 function deleteWorkspaceRecord(db, id) {
   db.delete(workspaces).where(eq(workspaces.id, id)).run();
 }
+function getHarnessNotifyRegistration(db) {
+  return db.select().from(harnessNotifyRegistrations).where(eq(harnessNotifyRegistrations.id, "default")).get();
+}
+function upsertHarnessNotifyRegistration(db, input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = getHarnessNotifyRegistration(db);
+  if (existing) {
+    db.update(harnessNotifyRegistrations).set({
+      agentId: input.agentId,
+      hookToken: input.hookToken,
+      secret: input.secret,
+      callbackUrl: input.callbackUrl,
+      updatedAt: now
+    }).where(eq(harnessNotifyRegistrations.id, "default")).run();
+    return getHarnessNotifyRegistration(db);
+  }
+  const record = {
+    id: "default",
+    agentId: input.agentId,
+    hookToken: input.hookToken,
+    secret: input.secret,
+    callbackUrl: input.callbackUrl,
+    registeredAt: now,
+    updatedAt: now
+  };
+  db.insert(harnessNotifyRegistrations).values(record).run();
+  return record;
+}
+function getHarnessJobWatchByJobId(db, jobId) {
+  return db.select().from(harnessJobWatches).where(eq(harnessJobWatches.jobId, jobId)).get();
+}
+function listHarnessJobWatches(db) {
+  return db.select().from(harnessJobWatches).orderBy(desc(harnessJobWatches.createdAt)).all();
+}
+function listPendingHarnessJobWatches(db) {
+  return db.select().from(harnessJobWatches).where(eq(harnessJobWatches.status, "pending")).all();
+}
+function upsertHarnessJobWatch(db, input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = getHarnessJobWatchByJobId(db, input.jobId);
+  if (existing) {
+    db.update(harnessJobWatches).set({
+      threadId: input.threadId,
+      title: input.title ?? existing.title,
+      updatedAt: now
+    }).where(eq(harnessJobWatches.id, existing.id)).run();
+    return getHarnessJobWatchByJobId(db, input.jobId);
+  }
+  const record = {
+    id: randomUUID(),
+    jobId: input.jobId,
+    threadId: input.threadId,
+    title: input.title ?? null,
+    status: "pending",
+    lastJobStatus: null,
+    lastError: null,
+    createdAt: now,
+    updatedAt: now,
+    deliveredAt: null
+  };
+  db.insert(harnessJobWatches).values(record).run();
+  return record;
+}
+function updateHarnessJobWatch(db, id, input) {
+  db.update(harnessJobWatches).set({ ...input, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(harnessJobWatches.id, id)).run();
+}
 
 // ../../packages/db/src/seed.ts
 var defaultPolicies = [
@@ -9151,7 +9248,7 @@ function extractFileChangeEntries(item) {
       isRecord4(entry.summary) ? entry.summary : null,
       isRecord4(entry.diff) ? entry.diff : null
     ].filter((candidate) => Boolean(candidate));
-    const path26 = uniqueStrings([
+    const path27 = uniqueStrings([
       stringOrNull(valueFromRecords(nestedRecords, ["path", "filePath", "targetPath"])),
       stringOrNull(
         valueFromRecords(nestedRecords, [
@@ -9198,7 +9295,7 @@ function extractFileChangeEntries(item) {
     const diffStats = explicitAdditions === 0 && explicitDeletions === 0 && diffText ? countUnifiedDiffStats(diffText) : null;
     const additions = explicitAdditions || diffStats?.additions || 0;
     const deletions = explicitDeletions || diffStats?.deletions || 0;
-    const normalizedPath = path26 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
+    const normalizedPath = path27 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
     if (!normalizedPath && additions === 0 && deletions === 0) {
       return null;
     }
@@ -13508,14 +13605,14 @@ function displayPath(pathValue, options) {
   }
   return relativePath;
 }
-function toolIsLowInformationPatch(normalized, state, input, patchText, path26, metadataStats) {
+function toolIsLowInformationPatch(normalized, state, input, patchText, path27, metadataStats) {
   if (normalized !== "applypatch" && normalized !== "patch") {
     return false;
   }
   if (toolStateStatus(state) !== "running") {
     return false;
   }
-  if (path26 || patchText || metadataStats || stringValue2(state.output)) {
+  if (path27 || patchText || metadataStats || stringValue2(state.output)) {
     return false;
   }
   return !isRecord9(input) || Object.keys(input).length === 0;
@@ -13558,7 +13655,7 @@ function fileChangeStatsFromMetadata(metadata) {
   if (files.length === 0) {
     return null;
   }
-  const paths = files.map((file) => stringValue2(file.filePath) ?? stringValue2(file.path) ?? stringValue2(file.relativePath)).filter((path26) => Boolean(path26));
+  const paths = files.map((file) => stringValue2(file.filePath) ?? stringValue2(file.path) ?? stringValue2(file.relativePath)).filter((path27) => Boolean(path27));
   const addedLines = files.reduce((total, file) => total + (numberValue(file.additions) ?? numberValue(file.addedLines) ?? numberValue(file.added) ?? 0), 0);
   const removedLines = files.reduce((total, file) => total + (numberValue(file.deletions) ?? numberValue(file.removedLines) ?? numberValue(file.removed) ?? 0), 0);
   return {
@@ -13706,28 +13803,28 @@ function mapAssistantTool(messageId2, tool, options) {
   ].includes(normalized)) {
     const metadataStats = fileChangeStatsFromMetadata(state.metadata);
     const patchText = isRecord9(input) ? stringValue2(input.patchText) ?? stringValue2(input.patch) ?? stringValue2(input.diff) : null;
-    const path26 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
-    if (toolIsLowInformationPatch(normalized, state, input, patchText, path26, metadataStats)) {
+    const path27 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
+    if (toolIsLowInformationPatch(normalized, state, input, patchText, path27, metadataStats)) {
       return null;
     }
     const output = stringValue2(state.output);
     const diffStats = countUnifiedDiffStats2(patchText);
-    const displayFilePath = displayPath(path26, options);
+    const displayFilePath = displayPath(path27, options);
     return {
       id,
       kind: "fileChange",
       text: metadataStats ? metadataStats.changedFiles > 1 ? `${metadataStats.changedFiles} changed files` : displayFilePath ?? metadataStats.previewText : displayFilePath ?? output ?? summary ?? name,
       previewText: metadataStats ? metadataStats.changedFiles > 1 ? `${metadataStats.changedFiles} changed files` : displayFilePath ?? metadataStats.previewText : displayFilePath ? `${name}: ${displayFilePath}` : output ?? summary ?? name,
       detailText,
-      changedFiles: metadataStats?.changedFiles ?? (path26 ? 1 : null),
+      changedFiles: metadataStats?.changedFiles ?? (path27 ? 1 : null),
       addedLines: metadataStats?.addedLines ?? diffStats?.addedLines ?? null,
       removedLines: metadataStats?.removedLines ?? diffStats?.removedLines ?? null,
       status: toolStateStatus(state)
     };
   }
   if (["read", "grep", "glob", "list", "ls", "bashoutput"].includes(normalized)) {
-    const path26 = filePathFromInput(input);
-    const text2 = displayPath(path26, options) ?? summary ?? name;
+    const path27 = filePathFromInput(input);
+    const text2 = displayPath(path27, options) ?? summary ?? name;
     return {
       id,
       kind: "fileRead",
@@ -16200,6 +16297,15 @@ function parseUuidV7Timestamp2(id) {
   }
   return new Date(millis).toISOString();
 }
+function normalizeHistoryItemCreatedAt(item, fallback) {
+  if (item.createdAt) {
+    return item;
+  }
+  return {
+    ...item,
+    createdAt: parseUuidV7Timestamp2(item.id) ?? fallback
+  };
+}
 function summarizeText(text2, fallback) {
   const lines = text2.replace(/\r\n/g, "\n").split("\n");
   while (lines.length > 1 && lines.at(-1)?.trim() === "") {
@@ -16552,13 +16658,17 @@ function mergePersistedHistoryItemsIntoTurns(turns, persistedItemsByTurnId, defe
   });
 }
 function agentTurnToThreadTurnDto(turn, deferredDetails) {
+  const startedAt = turn.startedAt ?? parseUuidV7Timestamp2(turn.providerTurnId);
   const baseTurn = {
     id: turn.providerTurnId,
-    startedAt: turn.startedAt ?? parseUuidV7Timestamp2(turn.providerTurnId),
+    startedAt,
     status: turn.status,
     error: turn.error?.message ?? null,
     items: visibleRuntimeTurnItems(turn.items).map(
-      (item, transcriptIndex) => item.transcriptOrder === transcriptIndex ? item : { ...item, transcriptOrder: transcriptIndex }
+      (item, transcriptIndex) => normalizeHistoryItemCreatedAt(
+        item.transcriptOrder === transcriptIndex ? item : { ...item, transcriptOrder: transcriptIndex },
+        startedAt
+      )
     )
   };
   return deferredDetails ? deferLargeHistoryItemDetails(baseTurn, deferredDetails) : baseTurn;
@@ -19357,7 +19467,11 @@ var ThreadDeletionCoordinator = class {
 };
 
 // src/exports/thread-pdf-export.ts
+import { spawn as spawn2 } from "child_process";
 import fs11 from "fs";
+import os3 from "os";
+import path14 from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
 import puppeteer from "puppeteer-core";
 import { marked } from "marked";
 var MAX_TEXT_CHARS = 12e3;
@@ -19371,6 +19485,8 @@ var EMBEDDED_CJK_FONT_CANDIDATES = [
   { path: "/mnt/c/Windows/Fonts/msyh.ttc", format: "truetype", weight: 400 }
 ];
 var PUPPETEER_CHANNEL = "chrome";
+var PDF_EXPORT_TIMEOUT_MS = 45e3;
+var MAX_CHROME_STDERR_CHARS = 4e3;
 var embeddedCjkFontCss = null;
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -20397,35 +20513,15 @@ endobj
 `
     );
   }
-  const browser = await launchPdfBrowser();
-  try {
-    const page = await browser.newPage();
-    await page.setContent(renderThreadExportHtml(snapshot), {
-      waitUntil: "load"
-    });
-    return Buffer.from(
-      await page.pdf({
-        format: "Letter",
-        printBackground: true,
-        preferCSSPageSize: true
-      })
-    );
-  } finally {
-    await browser.close();
-  }
+  return renderPdfWithChromeCli(renderThreadExportHtml(snapshot));
 }
-async function launchPdfBrowser() {
-  const launchOptions = {
-    headless: true,
-    args: ["--no-sandbox", "--disable-setuid-sandbox", "--font-render-hinting=none"]
-  };
-  if (process.env.PUPPETEER_EXECUTABLE_PATH) {
-    launchOptions.executablePath = process.env.PUPPETEER_EXECUTABLE_PATH;
-  } else {
-    launchOptions.channel = PUPPETEER_CHANNEL;
-  }
+function resolvePdfBrowserExecutablePath() {
   try {
-    return await puppeteer.launch(launchOptions);
+    const executablePath = process.env.PUPPETEER_EXECUTABLE_PATH ? process.env.PUPPETEER_EXECUTABLE_PATH : puppeteer.executablePath(PUPPETEER_CHANNEL);
+    if (!fs11.existsSync(executablePath)) {
+      throw new Error(`Browser executable was not found at ${executablePath}`);
+    }
+    return executablePath;
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     throw new Error(
@@ -20433,6 +20529,89 @@ async function launchPdfBrowser() {
     );
   }
 }
+async function renderPdfWithChromeCli(html) {
+  const executablePath = resolvePdfBrowserExecutablePath();
+  const tempDir = await fs11.promises.mkdtemp(path14.join(os3.tmpdir(), "remote-codex-pdf-"));
+  const htmlPath = path14.join(tempDir, "thread-export.html");
+  const pdfPath = path14.join(tempDir, "thread-export.pdf");
+  try {
+    await fs11.promises.writeFile(htmlPath, html, "utf8");
+    await printHtmlToPdf({
+      executablePath,
+      htmlPath,
+      pdfPath
+    });
+    const pdf = await fs11.promises.readFile(pdfPath);
+    if (pdf.length === 0 || !pdf.subarray(0, 4).equals(Buffer.from("%PDF"))) {
+      throw new Error("Chrome did not produce a valid PDF file.");
+    }
+    return pdf;
+  } finally {
+    await fs11.promises.rm(tempDir, { force: true, recursive: true });
+  }
+}
+async function printHtmlToPdf(input) {
+  const args = [
+    "--headless",
+    "--disable-gpu",
+    "--disable-dev-shm-usage",
+    "--no-sandbox",
+    "--disable-setuid-sandbox",
+    "--font-render-hinting=none",
+    "--no-pdf-header-footer",
+    "--print-to-pdf-no-header",
+    `--print-to-pdf=${input.pdfPath}`,
+    pathToFileURL3(input.htmlPath).href
+  ];
+  await new Promise((resolve, reject) => {
+    const child = spawn2(input.executablePath, args, {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    let settled = false;
+    let stderr = "";
+    const complete = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      child.kill("SIGTERM");
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    };
+    const timeout = setTimeout(() => {
+      child.kill("SIGKILL");
+      complete(new Error(`Chrome PDF export timed out after ${PDF_EXPORT_TIMEOUT_MS}ms.`));
+    }, PDF_EXPORT_TIMEOUT_MS);
+    child.stderr.on("data", (chunk) => {
+      stderr = truncateChromeStderr(`${stderr}${chunk.toString("utf8")}`);
+      if (stderr.includes("bytes written to file")) {
+        complete();
+      }
+    });
+    child.on("error", (error) => {
+      complete(error);
+    });
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        complete();
+        return;
+      }
+      const reason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
+      const detail = stderr ? ` ${stderr}` : "";
+      complete(new Error(`Chrome PDF export failed with ${reason}.${detail}`));
+    });
+  });
+}
+function truncateChromeStderr(value) {
+  if (value.length <= MAX_CHROME_STDERR_CHARS) {
+    return value;
+  }
+  return value.slice(value.length - MAX_CHROME_STDERR_CHARS);
+}
 
 // src/thread-export-coordinator.ts
 function userPromptPreviewFromTurn(turn) {
@@ -20703,7 +20882,7 @@ var ThreadForkCoordinator = class {
 // src/thread-attachment-coordinator.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import fs12 from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 async function pathExists(absPath) {
   try {
     await fs12.access(absPath);
@@ -20713,8 +20892,8 @@ async function pathExists(absPath) {
   }
 }
 function sanitizeAttachmentFileName(originalName) {
-  const basename = path14.basename(originalName).trim() || "attachment";
-  const extension = path14.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
+  const basename = path15.basename(originalName).trim() || "attachment";
+  const extension = path15.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
   const rawStem = extension ? basename.slice(0, -extension.length) : basename;
   const sanitizedStem = rawStem.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
   const stem = sanitizedStem || "attachment";
@@ -20722,7 +20901,7 @@ function sanitizeAttachmentFileName(originalName) {
   return `${stem}-${randomUUID3().slice(0, 8)}${normalizedExtension}`;
 }
 function threadTempDirectoryPath2(workspacePath, localThreadId) {
-  return path14.join(workspacePath, ".temp", "threads", localThreadId);
+  return path15.join(workspacePath, ".temp", "threads", localThreadId);
 }
 var ThreadAttachmentCoordinator = class {
   constructor(db) {
@@ -20763,7 +20942,7 @@ var ThreadAttachmentCoordinator = class {
       const savedFileName = sanitizeAttachmentFileName(
         attachment.manifest.originalName
       );
-      await fs12.writeFile(path14.join(tempDirectory, savedFileName), attachment.buffer);
+      await fs12.writeFile(path15.join(tempDirectory, savedFileName), attachment.buffer);
       const relativePath = `./.temp/threads/${localThreadId}/${savedFileName}`;
       const replacementToken = attachment.manifest.kind === "photo" ? `[PHOTO ${relativePath}]` : `[FILE ${relativePath}]`;
       rewrittenPrompt = rewrittenPrompt.split(attachment.manifest.placeholder).join(replacementToken);
@@ -20777,7 +20956,7 @@ var ThreadAttachmentCoordinator = class {
 
 // src/thread-import-coordinator.ts
 import fs13 from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 async function pathExists2(absPath) {
   try {
     await fs13.access(absPath);
@@ -20787,19 +20966,19 @@ async function pathExists2(absPath) {
   }
 }
 async function resolveComparablePath2(absPath) {
-  const resolved = path15.resolve(absPath);
+  const resolved = path16.resolve(absPath);
   if (await pathExists2(resolved)) {
     return fs13.realpath(resolved);
   }
-  const parentPath = path15.dirname(resolved);
+  const parentPath = path16.dirname(resolved);
   if (parentPath === resolved) {
     return resolved;
   }
   const resolvedParent = await resolveComparablePath2(parentPath);
-  return path15.join(resolvedParent, path15.basename(resolved));
+  return path16.join(resolvedParent, path16.basename(resolved));
 }
 async function resolveImportedWorkspacePath(workspaceRoot, candidatePath) {
-  if (!path15.isAbsolute(candidatePath)) {
+  if (!path16.isAbsolute(candidatePath)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Imported session path must be absolute."
@@ -20807,7 +20986,7 @@ async function resolveImportedWorkspacePath(workspaceRoot, candidatePath) {
   }
   const resolvedRoot = await resolveComparablePath2(workspaceRoot);
   const resolvedCandidate = await resolveComparablePath2(candidatePath);
-  const normalizedRoot = resolvedRoot.endsWith(path15.sep) ? resolvedRoot : `${resolvedRoot}${path15.sep}`;
+  const normalizedRoot = resolvedRoot.endsWith(path16.sep) ? resolvedRoot : `${resolvedRoot}${path16.sep}`;
   if (resolvedCandidate !== resolvedRoot && !resolvedCandidate.startsWith(normalizedRoot)) {
     throw new HttpError(403, {
       code: "forbidden",
@@ -20860,7 +21039,7 @@ var ThreadImportCoordinator = class {
     if (!workspace) {
       workspace = createWorkspaceRecord(this.db, {
         absPath: importedPath,
-        label: path15.basename(importedPath) || "workspace"
+        label: path16.basename(importedPath) || "workspace"
       });
     }
     const created = createThreadRecord(this.db, {
@@ -20936,11 +21115,18 @@ function harnessDeveloperInstructions(config) {
     return null;
   }
   const baseUrl = config.harnessBaseUrl.replace(/\/+$/, "");
-  return [
+  const lines = [
     `ElAgente Harness chemistry tools are available at ${baseUrl}.`,
     "For chemistry tasks, call its HTTP API directly using the sandbox env var INACT_X_APP_KEY as the x-api-key header; never print or expose that key.",
     "Discover tools with GET /, GET /farmaco/tools, GET /farmaco/.help, GET /quntur/tools, or GET /estructural/tools; invoke approved tools with POST /{module}/tools/{tool} using JSON input."
-  ].join(" ");
+  ];
+  if (config.harnessWakeupCallbackBaseUrl) {
+    const supervisorBaseUrl = `http://127.0.0.1:${config.port}`;
+    lines.push(
+      `For long-running compute jobs you do not need to stay running: first GET ${supervisorBaseUrl}/api/harness/wakeup and read "notifyTo"; submit the job with "notify_to" set to that value. If you submit directly to Harness rather than through the Remote Codex Harness invoke proxy, immediately register POST ${supervisorBaseUrl}/api/harness/job-watches with JSON {"jobId": "<job id>"}. After that you may end your turn; this thread is woken with a new message when the job reaches a terminal status.`
+    );
+  }
+  return lines.join(" ");
 }
 function combineDeveloperInstructions(parts) {
   const normalized = parts.map((part) => part?.trim()).filter((part) => Boolean(part));
@@ -22118,8 +22304,8 @@ var ThreadService = class {
 
 // src/routes/agent-runtimes.ts
 import fs15 from "fs/promises";
-import { spawn as spawn2 } from "child_process";
-import path16 from "path";
+import { spawn as spawn3 } from "child_process";
+import path17 from "path";
 import { z as z3 } from "zod";
 
 // src/provider-schemas.ts
@@ -22340,7 +22526,7 @@ async function refreshBackendInstallation(app, runtime) {
 async function installedPackageVersion(packageName) {
   const globalRoot = await npmGlobalRoot3();
   if (globalRoot) {
-    const global = await packageVersionFromPath(path16.join(globalRoot, packageName, "package.json"));
+    const global = await packageVersionFromPath(path17.join(globalRoot, packageName, "package.json"));
     if (global) {
       return global;
     }
@@ -22391,7 +22577,7 @@ function versionStringContains(installedVersion, latestVersion) {
   return Boolean(installedVersion && latestVersion && installedVersion.includes(latestVersion));
 }
 async function packageVersionFromNode(packageName) {
-  return packageVersionFromPath(path16.resolve("node_modules", packageName, "package.json"));
+  return packageVersionFromPath(path17.resolve("node_modules", packageName, "package.json"));
 }
 async function packageVersionFromPath(packageJsonPath) {
   try {
@@ -22418,14 +22604,14 @@ async function npmGlobalBin() {
     return firstLine(result.stdout);
   }
   const prefix = await npmGlobalPrefix();
-  return prefix ? path16.join(prefix, "bin") : null;
+  return prefix ? path17.join(prefix, "bin") : null;
 }
 async function npmGlobalPrefix() {
   const result = await runShellCommand("npm prefix -g", 3e3);
   return result.code === 0 ? firstLine(result.stdout) : null;
 }
 async function commandPathFor(command) {
-  if (path16.isAbsolute(command)) {
+  if (path17.isAbsolute(command)) {
     return command;
   }
   const result = await runShellCommand(`command -v ${shellQuote(command)}`, 3e3);
@@ -22450,7 +22636,7 @@ function commandFailureMessage(command, result) {
 }
 function runShellCommand(command, timeoutMs = 0) {
   return new Promise((resolve) => {
-    const child = spawn2(command, {
+    const child = spawn3(command, {
       shell: true,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -22621,6 +22807,14 @@ var harnessToolParamSchema = harnessModuleParamSchema.extend({
   tool: z4.string().trim().min(1).max(160).regex(/^[a-zA-Z0-9_-]+$/)
 });
 var harnessInvokeBodySchema = z4.record(z4.string(), z4.unknown());
+var harnessJobWatchBodySchema = z4.object({
+  jobId: z4.string().trim().min(1).max(200).regex(/^[a-zA-Z0-9_.:-]+$/),
+  threadId: z4.string().trim().min(1).max(200).optional(),
+  title: z4.string().trim().min(1).max(300).optional()
+});
+var harnessHookParamSchema = z4.object({
+  token: z4.string().trim().min(1).max(200).regex(/^[a-zA-Z0-9_-]+$/)
+});
 var harnessInvokeContextSchema = z4.object({
   workspaceId: z4.string().uuid().nullable().optional(),
   sessionId: z4.string().uuid().nullable().optional(),
@@ -22964,6 +23158,19 @@ async function registerSystemRoutes(app) {
           metadata: harnessUsageMetadata(payload, attributionSource)
         }).catch(() => void 0);
       }
+      const invokeJobId = stringField2(result, ["job_id", "jobId", "compute_job_id", "computeJobId"]);
+      if (invokeJobId && context.threadId && app.services.harnessWakeupService.enabled()) {
+        await app.services.harnessWakeupService.watchJob({
+          jobId: invokeJobId,
+          threadId: context.threadId,
+          title: `${params.module}/${params.tool}`
+        }).catch((watchError) => {
+          request.log.warn(
+            { err: watchError, jobId: invokeJobId },
+            "Harness wakeup auto-watch failed."
+          );
+        });
+      }
       return payload;
     } catch (error) {
       if (error instanceof HttpError) {
@@ -22975,6 +23182,68 @@ async function registerSystemRoutes(app) {
       });
     }
   });
+  app.get("/api/harness/wakeup", async () => {
+    try {
+      return await app.services.harnessWakeupService.getWakeupInfo();
+    } catch (error) {
+      if (error instanceof HttpError) {
+        throw error;
+      }
+      throw new HttpError(503, {
+        code: "harness_unavailable",
+        message: error instanceof Error ? error.message : "ElAgenteHarness is unavailable."
+      });
+    }
+  });
+  app.get("/api/harness/job-watches", async () => {
+    return {
+      watches: listHarnessJobWatches(app.services.database.db)
+    };
+  });
+  app.post("/api/harness/job-watches", async (request, reply) => {
+    const body = harnessJobWatchBodySchema.parse(request.body ?? {});
+    try {
+      const result = await app.services.harnessWakeupService.watchJob({
+        jobId: body.jobId,
+        threadId: body.threadId ?? null,
+        title: body.title ?? null
+      });
+      reply.status(201);
+      return result;
+    } catch (error) {
+      if (error instanceof HttpError) {
+        throw error;
+      }
+      throw new HttpError(503, {
+        code: "harness_unavailable",
+        message: error instanceof Error ? error.message : "ElAgenteHarness is unavailable."
+      });
+    }
+  });
+  app.register(async (hookApp) => {
+    hookApp.addContentTypeParser(
+      ["application/json", "text/plain"],
+      { parseAs: "buffer" },
+      (_request, body, done) => done(null, body)
+    );
+    hookApp.addContentTypeParser(
+      "*",
+      { parseAs: "buffer" },
+      (_request, body, done) => done(null, body)
+    );
+    hookApp.post("/api/hooks/harness-notify/:token", async (request, reply) => {
+      const params = harnessHookParamSchema.parse(request.params);
+      const signatureHeader = request.headers["x-webhook-signature"];
+      const rawBody = Buffer.isBuffer(request.body) ? request.body : Buffer.from(typeof request.body === "string" ? request.body : "");
+      const result = app.services.harnessWakeupService.handleCallback({
+        hookToken: params.token,
+        rawBody,
+        signature: typeof signatureHeader === "string" ? signatureHeader : null
+      });
+      reply.status(202);
+      return result;
+    });
+  });
   app.get("/api/config/workspace-settings", async () => {
     return getWorkspaceSettings(
       app.services.database.db,
@@ -23097,7 +23366,7 @@ async function registerSystemRoutes(app) {
 
 // src/routes/threads.ts
 import fs17 from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import { z as z5 } from "zod";
 
 // src/worker-identity.ts
@@ -23569,7 +23838,7 @@ async function registerThreadRoutes(app) {
         message: "Workspace was not found for this thread."
       });
     }
-    const candidatePath = path17.isAbsolute(query.path) ? query.path : path17.resolve(workspace.absPath, query.path);
+    const candidatePath = path18.isAbsolute(query.path) ? query.path : path18.resolve(workspace.absPath, query.path);
     const requestedPath = await fs17.realpath(candidatePath).catch(() => null);
     if (!requestedPath) {
       throw new HttpError(404, {
@@ -23577,8 +23846,8 @@ async function registerThreadRoutes(app) {
         message: "Image file was not found."
       });
     }
-    const resolvedWorkspaceRoot = await fs17.realpath(app.services.config.workspaceRoot).catch(() => path17.resolve(app.services.config.workspaceRoot));
-    const workspacePrefix = resolvedWorkspaceRoot.endsWith(path17.sep) ? resolvedWorkspaceRoot : `${resolvedWorkspaceRoot}${path17.sep}`;
+    const resolvedWorkspaceRoot = await fs17.realpath(app.services.config.workspaceRoot).catch(() => path18.resolve(app.services.config.workspaceRoot));
+    const workspacePrefix = resolvedWorkspaceRoot.endsWith(path18.sep) ? resolvedWorkspaceRoot : `${resolvedWorkspaceRoot}${path18.sep}`;
     if (requestedPath !== resolvedWorkspaceRoot && !requestedPath.startsWith(workspacePrefix)) {
       throw new HttpError(403, {
         code: "forbidden",
@@ -23775,9 +24044,9 @@ async function registerThreadRoutes(app) {
 // src/routes/workspaces.ts
 import fs18 from "fs/promises";
 import { createReadStream } from "fs";
-import os3 from "os";
-import path18 from "path";
-import { spawn as spawn3 } from "child_process";
+import os4 from "os";
+import path19 from "path";
+import { spawn as spawn4 } from "child_process";
 import { Readable } from "stream";
 import { z as z6 } from "zod";
 var createWorkspaceSchema = z6.union([
@@ -23864,7 +24133,7 @@ function toWorkspaceFileDto(file) {
   };
 }
 function languageForPath(filePath) {
-  const extension = path18.extname(filePath).slice(1).toLowerCase();
+  const extension = path19.extname(filePath).slice(1).toLowerCase();
   switch (extension) {
     case "js":
     case "jsx":
@@ -23910,18 +24179,18 @@ function languageForPath(filePath) {
   }
 }
 function relativeWorkspacePath(rootPath, absPath) {
-  const relative = path18.relative(rootPath, absPath);
-  return relative === "" ? "" : relative.split(path18.sep).join("/");
+  const relative = path19.relative(rootPath, absPath);
+  return relative === "" ? "" : relative.split(path19.sep).join("/");
 }
 async function resolveWorkspaceItemPath(rootPath, relativePath = "") {
-  const candidate = path18.resolve(rootPath, relativePath || ".");
+  const candidate = path19.resolve(rootPath, relativePath || ".");
   const comparable = await assertPathWithinRoot(rootPath, candidate);
   return comparable;
 }
 async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
   const stats = await fs18.stat(absPath);
   const relativePath = relativeWorkspacePath(rootPath, absPath);
-  const name = relativePath ? path18.basename(absPath) : path18.basename(rootPath);
+  const name = relativePath ? path19.basename(absPath) : path19.basename(rootPath);
   if (!stats.isDirectory()) {
     return {
       name,
@@ -23956,7 +24225,7 @@ async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
   }).slice(0, 400);
   node.children = (await Promise.all(
     visible.map(async (entry) => {
-      const childPath = path18.join(absPath, entry.name);
+      const childPath = path19.join(absPath, entry.name);
       try {
         if (!entry.isDirectory() && !entry.isFile()) {
           return null;
@@ -23980,19 +24249,19 @@ function requireWorkspaceRecord(app, workspaceId) {
   return record;
 }
 function artifactRoot(record) {
-  return path18.join(record.absPath, ".remote-codex", "artifacts");
+  return path19.join(record.absPath, ".remote-codex", "artifacts");
 }
 function artifactFilePath(record, artifactId) {
-  return path18.join(artifactRoot(record), artifactId, "artifact.bin");
+  return path19.join(artifactRoot(record), artifactId, "artifact.bin");
 }
 function artifactMetadataPath(record, artifactId) {
-  return path18.join(artifactRoot(record), artifactId, "metadata.json");
+  return path19.join(artifactRoot(record), artifactId, "metadata.json");
 }
 function safeArtifactFileName(value) {
-  return path18.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
+  return path19.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
 }
 function artifactIdFromName(name) {
-  const base = path18.basename(name).replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
+  const base = path19.basename(name).replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
   return `${base || "artifact"}-${Date.now().toString(36)}`;
 }
 async function readArtifactMetadata(record, artifactId) {
@@ -24035,7 +24304,7 @@ async function listWorkspaceArtifacts(record) {
   return artifacts.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
 function contentTypeForPath(filePath) {
-  switch (path18.extname(filePath).slice(1).toLowerCase()) {
+  switch (path19.extname(filePath).slice(1).toLowerCase()) {
     case "png":
       return "image/png";
     case "jpg":
@@ -24065,7 +24334,7 @@ function contentTypeForPath(filePath) {
   }
 }
 async function collectFolderZipEntries(rootPath, folderPath) {
-  const folderName = path18.basename(folderPath) || "workspace-folder";
+  const folderName = path19.basename(folderPath) || "workspace-folder";
   const entries = [];
   let totalBytes = 0;
   const pending = [folderPath];
@@ -24073,7 +24342,7 @@ async function collectFolderZipEntries(rootPath, folderPath) {
     const current = pending.pop();
     const children = await fs18.readdir(current, { withFileTypes: true });
     for (const child of children) {
-      const childPath = await resolveWorkspaceItemPath(rootPath, path18.relative(rootPath, path18.join(current, child.name)));
+      const childPath = await resolveWorkspaceItemPath(rootPath, path19.relative(rootPath, path19.join(current, child.name)));
       if (child.isDirectory()) {
         pending.push(childPath);
         continue;
@@ -24133,7 +24402,7 @@ async function createFolderZipFile(rootPath, folderPath) {
   let offset = 0;
   for (const entry of entries) {
     const data = await fs18.readFile(entry.absPath);
-    const name = Buffer.from(entry.archivePath.split(path18.sep).join("/"), "utf8");
+    const name = Buffer.from(entry.archivePath.split(path19.sep).join("/"), "utf8");
     const checksum = crc32(data);
     const { dosDate, dosTime } = zipDosDateTime(entry.updatedAt);
     const localHeader = Buffer.alloc(30);
@@ -24180,8 +24449,8 @@ async function createFolderZipFile(rootPath, folderPath) {
   endRecord.writeUInt32LE(centralSize, 12);
   endRecord.writeUInt32LE(offset, 16);
   endRecord.writeUInt16LE(0, 20);
-  const tempDir = await fs18.mkdtemp(path18.join(os3.tmpdir(), "remote-codex-folder-download-"));
-  const zipPath = path18.join(tempDir, `${path18.basename(folderPath) || "workspace-folder"}.zip`);
+  const tempDir = await fs18.mkdtemp(path19.join(os4.tmpdir(), "remote-codex-folder-download-"));
+  const zipPath = path19.join(tempDir, `${path19.basename(folderPath) || "workspace-folder"}.zip`);
   await fs18.writeFile(zipPath, Buffer.concat([...localParts, ...centralParts, endRecord]));
   return { zipPath, tempDir };
 }
@@ -24192,7 +24461,7 @@ function cleanupTemporaryZip(zipPath, tempDir) {
   };
 }
 function sanitizeUploadFilename(filename) {
-  const baseName = path18.basename(filename?.trim() || "upload");
+  const baseName = path19.basename(filename?.trim() || "upload");
   if (!baseName || baseName === "." || baseName === "..") {
     return "upload";
   }
@@ -24204,7 +24473,7 @@ function inferGitRepoName(gitUrl) {
   const normalized = withoutQuery.replace(/[\\/]+$/, "");
   const rawName = normalized.split(/[/:]/).filter(Boolean).at(-1) ?? "";
   const repoName = rawName.endsWith(".git") ? rawName.slice(0, -4) : rawName;
-  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path18.sep)) {
+  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path19.sep)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Unable to infer a target directory from the Git URL."
@@ -24225,7 +24494,7 @@ async function pathExists4(absPath) {
 }
 function cloneRepository(gitUrl, targetPath) {
   return new Promise((resolve, reject) => {
-    const child = spawn3("git", ["clone", gitUrl, targetPath], {
+    const child = spawn4("git", ["clone", gitUrl, targetPath], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     let stderr = "";
@@ -24269,7 +24538,7 @@ async function registerWorkspaceRoutes(app) {
   });
   app.get("/api/workspaces/tree", async (request) => {
     const query = treeQuerySchema.parse(request.query);
-    const requestedPath = query.path ? path18.resolve(query.path) : app.services.config.workspaceRoot;
+    const requestedPath = query.path ? path19.resolve(query.path) : app.services.config.workspaceRoot;
     const tree = await readWorkspaceTree({
       rootPath: app.services.config.workspaceRoot,
       targetPath: requestedPath,
@@ -24335,7 +24604,7 @@ async function registerWorkspaceRoutes(app) {
       const nextOffset = offset + read.bytesRead;
       return {
         path: relativeWorkspacePath(rootPath, filePath),
-        name: path18.basename(filePath),
+        name: path19.basename(filePath),
         content: buffer.subarray(0, read.bytesRead).toString("utf8"),
         language: languageForPath(filePath),
         size: stats.size,
@@ -24371,7 +24640,7 @@ async function registerWorkspaceRoutes(app) {
     const stats = await fs18.stat(itemPath);
     if (stats.isDirectory()) {
       const { zipPath, tempDir } = await createFolderZipFile(rootPath, itemPath);
-      const filename2 = `${path18.basename(itemPath) || "workspace-folder"}.zip`;
+      const filename2 = `${path19.basename(itemPath) || "workspace-folder"}.zip`;
       const cleanup = cleanupTemporaryZip(zipPath, tempDir);
       reply.raw.once("finish", () => void cleanup());
       reply.raw.once("close", () => void cleanup());
@@ -24387,7 +24656,7 @@ async function registerWorkspaceRoutes(app) {
         message: "Only file and folder downloads are supported from this endpoint."
       });
     }
-    const filename = path18.basename(itemPath);
+    const filename = path19.basename(itemPath);
     reply.header("content-type", contentTypeForPath(itemPath)).header(
       "content-disposition",
       `attachment; filename="${filename}"; filename*=UTF-8''${encodeURIComponent(filename)}`
@@ -24453,7 +24722,7 @@ async function registerWorkspaceRoutes(app) {
       kind: "file",
       file: {
         path: file.path,
-        name: path18.basename(file.path),
+        name: path19.basename(file.path),
         size: file.size
       }
     };
@@ -24495,7 +24764,7 @@ async function registerWorkspaceRoutes(app) {
         message: "Artifact content must not be empty."
       });
     }
-    const dir = path18.dirname(artifactFilePath(record, artifactId));
+    const dir = path19.dirname(artifactFilePath(record, artifactId));
     await fs18.mkdir(dir, { recursive: true, mode: 448 });
     const filePath = artifactFilePath(record, artifactId);
     await fs18.writeFile(filePath, content, { flag: "wx" }).catch((error) => {
@@ -24558,7 +24827,7 @@ async function registerWorkspaceRoutes(app) {
     const params = z6.object({ id: z6.string().uuid(), artifactId: workspaceArtifactIdSchema }).parse(request.params);
     const record = requireWorkspaceRecord(app, params.id);
     const artifact = await readArtifactMetadata(record, params.artifactId);
-    await fs18.rm(path18.dirname(artifactFilePath(record, params.artifactId)), {
+    await fs18.rm(path19.dirname(artifactFilePath(record, params.artifactId)), {
       recursive: true,
       force: true
     });
@@ -24573,7 +24842,7 @@ async function registerWorkspaceRoutes(app) {
     let validated;
     if ("gitUrl" in body) {
       const repoName = inferGitRepoName(body.gitUrl);
-      const targetPath = path18.join(settings.devHome, repoName);
+      const targetPath = path19.join(settings.devHome, repoName);
       if (await pathExists4(targetPath)) {
         throw new HttpError(409, {
           code: "conflict",
@@ -24837,7 +25106,7 @@ async function registerAuthRoutes(app) {
 
 // src/provider-host-config-service.ts
 import fs19 from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function providerError(message, statusCode = 404) {
   const error = new Error(message);
@@ -24845,16 +25114,16 @@ function providerError(message, statusCode = 404) {
   return error;
 }
 function resolveProviderHostFilePath(providerHome, name) {
-  return path19.join(providerHome, name);
+  return path20.join(providerHome, name);
 }
 function resolveArchiveRoot(providerHome) {
-  return path19.join(providerHome, "supervisor-config-archives");
+  return path20.join(providerHome, "supervisor-config-archives");
 }
 function resolveArchiveIndexPath(providerHome) {
-  return path19.join(resolveArchiveRoot(providerHome), "index.json");
+  return path20.join(resolveArchiveRoot(providerHome), "index.json");
 }
 function resolveArchivePath(providerHome, archiveId) {
-  return path19.join(resolveArchiveRoot(providerHome), archiveId);
+  return path20.join(resolveArchiveRoot(providerHome), archiveId);
 }
 function defaultArchiveLabel(createdAt) {
   return `Backup ${createdAt.replace("T", " ").replace(/\.\d{3}Z$/, " UTC")}`;
@@ -24970,7 +25239,7 @@ var ProviderHostConfigService = class {
     const providerHome = this.providerHome(provider2);
     const fileName = this.assertHostFile(provider2, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
-    await fs19.mkdir(path19.dirname(filePath), { recursive: true });
+    await fs19.mkdir(path20.dirname(filePath), { recursive: true });
     await fs19.writeFile(filePath, input.content, "utf8");
     return this.readFile(provider2, fileName);
   }
@@ -25005,7 +25274,7 @@ var ProviderHostConfigService = class {
         exists: hostFile.exists
       };
       if (hostFile.exists) {
-        await fs19.writeFile(path19.join(archivePath, name), hostFile.content, "utf8");
+        await fs19.writeFile(path20.join(archivePath, name), hostFile.content, "utf8");
       }
     }
     const archive = {
@@ -25045,7 +25314,7 @@ var ProviderHostConfigService = class {
     for (const name of fileNames) {
       const hostPath = resolveProviderHostFilePath(providerHome, name);
       if (archive.files[name]?.exists) {
-        const content = await fs19.readFile(path19.join(archivePath, name), "utf8");
+        const content = await fs19.readFile(path20.join(archivePath, name), "utf8");
         await fs19.writeFile(hostPath, content, "utf8");
       } else {
         await fs19.rm(hostPath, { force: true });
@@ -25065,8 +25334,8 @@ import fs21 from "fs/promises";
 
 // src/shell/shell-prompt.ts
 import fs20 from "fs/promises";
-import os4 from "os";
-import path20 from "path";
+import os5 from "os";
+import path21 from "path";
 function basenameFromPath2(filePath) {
   if (!filePath) {
     return "";
@@ -25075,7 +25344,7 @@ function basenameFromPath2(filePath) {
   if (!normalized) {
     return "";
   }
-  return path20.basename(normalized) || normalized;
+  return path21.basename(normalized) || normalized;
 }
 function isInteractiveShellCommand(command) {
   const normalized = (command ?? "").trim().toLowerCase();
@@ -25236,8 +25505,8 @@ function buildShellPromptInitScriptContents(command) {
 async function ensureShellPromptInitScript(command) {
   const normalized = command.trim().toLowerCase();
   const extension = normalized === "zsh" ? "zsh" : "sh";
-  const filePath = path20.join(
-    os4.tmpdir(),
+  const filePath = path21.join(
+    os5.tmpdir(),
     `remote-codex-shell-prompt.${extension}`
   );
   await fs20.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
@@ -25860,13 +26129,13 @@ var terminalPluginManifest = {
   }
 };
 
-// ../../node_modules/.pnpm/@remote-codex+plugin-xyz-viewer@file+..+remote-codex-thread-ui+packages+plugin-xyz-view_5227bf80a742872b523d08ba646669ff/node_modules/@remote-codex/plugin-xyz-viewer/dist/chunk-6FS7BLJV.js
+// src/plugins/xyz-viewer-plugin-manifest.ts
 var XYZ_MOLECULE_ARTIFACT_TYPE = "chemistry.molecule3d";
 var xyzViewerPluginManifest = {
   id: "remote-codex.xyz-viewer",
   name: "XYZ Molecule Viewer",
   version: "0.1.0",
-  description: "A draft built-in plugin for previewing xyz, extxyz, cif, and pdb molecular structures with 3Dmol.js.",
+  description: "A built-in plugin for previewing xyz, extxyz, cif, and pdb molecular structures.",
   remoteCodex: "^0.11.0",
   capabilities: {
     artifactTypes: [
@@ -25897,11 +26166,7 @@ var xyzViewerPluginManifest = {
         command: "node",
         args: ["bin/remote-codex-plugin-mcp.mjs"]
       }
-    ],
-    frontend: {
-      entry: "./dist/index.js",
-      style: "./src/styles.css"
-    }
+    ]
   }
 };
 
@@ -25919,7 +26184,7 @@ var builtinPlugins = [
 
 // src/plugins/plugin-service.ts
 import fs22 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 var MANAGED_CODEX_MCP_BEGIN = "# BEGIN remote-codex managed plugin MCP servers";
 var MANAGED_CODEX_MCP_END = "# END remote-codex managed plugin MCP servers";
 var REMOTE_CODEX_MOLECULE_MCP_TOOL_NAME = "remote_codex_render_molecule";
@@ -25931,7 +26196,7 @@ function normalizeManagedCommand(server, repoRoot) {
   if (server.name === "remote_codex_plugins") {
     return {
       command: process.execPath,
-      args: [path21.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
+      args: [path22.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
     };
   }
   return {
@@ -26118,7 +26383,7 @@ var PluginService = class {
     if (!input.codexHome) {
       return;
     }
-    const configPath = path21.join(input.codexHome, "config.toml");
+    const configPath = path22.join(input.codexHome, "config.toml");
     let current = "";
     try {
       current = await fs22.readFile(configPath, "utf8");
@@ -26136,7 +26401,7 @@ var PluginService = class {
     if (next === current) {
       return;
     }
-    await fs22.mkdir(path21.dirname(configPath), { recursive: true });
+    await fs22.mkdir(path22.dirname(configPath), { recursive: true });
     await fs22.writeFile(configPath, next, "utf8");
   }
   async importPlugin(input) {
@@ -26377,7 +26642,7 @@ var PluginSettingsStore = class {
 
 // src/worker-bootstrap.ts
 import fs23 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
@@ -26388,7 +26653,7 @@ function tomlString(value) {
   return JSON.stringify(value);
 }
 async function writePrivateFile(filePath, content) {
-  await fs23.mkdir(path22.dirname(filePath), { recursive: true, mode: 448 });
+  await fs23.mkdir(path23.dirname(filePath), { recursive: true, mode: 448 });
   await fs23.writeFile(filePath, content, { encoding: "utf8", mode: 384 });
   await fs23.chmod(filePath, 384);
 }
@@ -26404,7 +26669,7 @@ async function configureWorkerProviderGateway(config) {
   process.env.ANTHROPIC_BASE_URL = anthropicBaseUrl;
   if (config.agentProviders.codex.enabled) {
     await writePrivateFile(
-      path22.join(config.agentProviders.codex.home, "config.toml"),
+      path23.join(config.agentProviders.codex.home, "config.toml"),
       [
         'model_provider = "sub2api"',
         'forced_login_method = "api"',
@@ -26420,7 +26685,7 @@ async function configureWorkerProviderGateway(config) {
       ].join("\n")
     );
     await writePrivateFile(
-      path22.join(config.agentProviders.codex.home, "auth.json"),
+      path23.join(config.agentProviders.codex.home, "auth.json"),
       `${JSON.stringify(
         {
           OPENAI_API_KEY: config.llmGatewayToken
@@ -26433,7 +26698,7 @@ async function configureWorkerProviderGateway(config) {
   }
   if (config.agentProviders.claude.enabled) {
     await writePrivateFile(
-      path22.join(config.agentProviders.claude.home, "settings.json"),
+      path23.join(config.agentProviders.claude.home, "settings.json"),
       `${JSON.stringify(
         {
           env: {
@@ -26449,7 +26714,7 @@ async function configureWorkerProviderGateway(config) {
   }
   if (config.agentProviders.opencode.enabled) {
     await writePrivateFile(
-      path22.join(config.agentProviders.opencode.home, "opencode.json"),
+      path23.join(config.agentProviders.opencode.home, "opencode.json"),
       `${JSON.stringify(
         {
           provider: {
@@ -26496,8 +26761,8 @@ var BackendPluginHost = class {
 };
 
 // src/shell/pty-shell-backend.ts
-import path23 from "path";
-import { spawn as spawn4 } from "@homebridge/node-pty-prebuilt-multiarch";
+import path24 from "path";
+import { spawn as spawn5 } from "@homebridge/node-pty-prebuilt-multiarch";
 
 // src/shell/default-shell.ts
 import fs24 from "fs";
@@ -26516,7 +26781,7 @@ function resolveDefaultShell(env = process.env) {
 var MAX_SCROLLBACK_BYTES = 512 * 1024;
 var ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\u001B\[[0-?]*[ -/]*[@-~]`, "g");
 function shellArgs(shell) {
-  const shellName = path23.basename(shell).toLowerCase();
+  const shellName = path24.basename(shell).toLowerCase();
   if (process.platform === "win32") {
     return [];
   }
@@ -26538,7 +26803,7 @@ function lastVisibleLine(snapshot) {
 }
 function inferRuntime(session) {
   const promptLine = lastVisibleLine(session.scrollback);
-  const shell = path23.basename(session.shell);
+  const shell = path24.basename(session.shell);
   const isCommandRunning = session.exitCode !== null ? false : !/[$#>]\s*$/.test(promptLine.trimEnd());
   return {
     panePid: session.pty.pid,
@@ -26566,7 +26831,7 @@ var PtyShellBackend = class {
     if (this.sessions.has(input.sessionId)) {
       return;
     }
-    const pty = spawn4(this.shell, shellArgs(this.shell), {
+    const pty = spawn5(this.shell, shellArgs(this.shell), {
       name: "xterm-256color",
       cwd: input.cwd,
       cols: input.cols ?? 120,
@@ -26685,7 +26950,7 @@ var PtyShellBackend = class {
 
 // src/shell/tmux-manager.ts
 import fs25 from "fs";
-import path24 from "path";
+import path25 from "path";
 import { spawn as spawnChild } from "child_process";
 async function defaultExecCommand(command, args) {
   return await new Promise((resolve, reject) => {
@@ -26712,16 +26977,16 @@ async function defaultExecCommand(command, args) {
   });
 }
 function resolveExecutablePath(command) {
-  if (command.includes(path24.sep)) {
+  if (command.includes(path25.sep)) {
     return command;
   }
   const searchPath = process.env.PATH ?? "";
-  for (const entry of searchPath.split(path24.delimiter)) {
+  for (const entry of searchPath.split(path25.delimiter)) {
     const trimmed = entry.trim();
     if (!trimmed) {
       continue;
     }
-    const candidate = path24.join(trimmed, command);
+    const candidate = path25.join(trimmed, command);
     if (fs25.existsSync(candidate)) {
       return candidate;
     }
@@ -27427,6 +27692,9 @@ function makeShellErrorEnvelope(shellId, error) {
 var HARNESS_MODULES = ["estructural", "quntur", "farmaco"];
 var HARNESS_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var HARNESS_RUN_ID_PATTERN = /^[a-zA-Z0-9_.-]+$/;
+var HARNESS_JOB_ID_PATTERN = /^[a-zA-Z0-9_.:-]+$/;
+var HARNESS_NOTIFICATION_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var HARNESS_TERMINAL_JOB_STATUSES = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
 var MOLECULE_ARTIFACT_TYPES = /* @__PURE__ */ new Set(["xyz", "extxyz", "pdb", "cif"]);
 function recordFrom(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -27480,22 +27748,22 @@ function payloadItems(payload, fields) {
   const record = recordFrom(payload);
   return arrayField(record, fields) ?? (record ? [record] : []);
 }
-function artifactPreviewKind(type, format, path26) {
+function artifactPreviewKind(type, format, path27) {
   const candidates = [
     type,
     format,
-    path26?.split(".").pop() ?? null
+    path27?.split(".").pop() ?? null
   ].map((value) => value?.trim().toLowerCase()).filter(Boolean);
   return candidates.some((value) => MOLECULE_ARTIFACT_TYPES.has(value)) ? "molecule" : "file";
 }
 function normalizeArtifactRef(value) {
   const record = recordFrom(value);
-  const path26 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
+  const path27 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
   const type = stringField3(record, ["type", "artifactType", "artifact_type", "format", "extension"]);
-  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path26 ?? "artifact";
+  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path27 ?? "artifact";
   return {
     title,
-    path: path26,
+    path: path27,
     type,
     downloadUrl: stringField3(record, ["downloadUrl", "download_url", "url", "href"])
   };
@@ -27529,23 +27797,68 @@ function normalizeArtifact(module, runId, value) {
   if (!record) {
     return null;
   }
-  const path26 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
+  const path27 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
   const type = stringField3(record, ["type", "artifactType", "artifact_type"]);
   const format = stringField3(record, ["format", "fileFormat", "file_format", "extension"]) ?? type;
-  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path26 ?? `${module} artifact`;
+  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path27 ?? `${module} artifact`;
   return {
     module,
     runId,
     title,
-    path: path26,
+    path: path27,
     type,
     format,
     mimeType: stringField3(record, ["mimeType", "mime_type", "contentType", "content_type"]),
     sizeBytes: numberField2(record, ["sizeBytes", "size_bytes", "bytes"]),
     downloadUrl: stringField3(record, ["downloadUrl", "download_url", "url", "href"]),
-    previewKind: artifactPreviewKind(type, format, path26)
+    previewKind: artifactPreviewKind(type, format, path27)
   };
 }
+function parseTomlScalar(raw) {
+  const value = raw.trim();
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+function parseTomlLines(text2) {
+  const record = {};
+  for (const line of text2.split("\n")) {
+    const match = /^([A-Za-z0-9_]+)\s*=\s*(.+)$/.exec(line.trim());
+    if (match && !(match[1] in record)) {
+      record[match[1]] = parseTomlScalar(match[2]);
+    }
+  }
+  return record;
+}
+function parseTomlBlocks(text2, blockName) {
+  const marker = `[[${blockName}]]`;
+  const blocks = [];
+  let current = null;
+  for (const line of text2.split("\n")) {
+    if (line.trim() === marker) {
+      if (current) {
+        blocks.push(parseTomlLines(current.join("\n")));
+      }
+      current = [];
+      continue;
+    }
+    if (line.trim().startsWith("[[") && current) {
+      blocks.push(parseTomlLines(current.join("\n")));
+      current = null;
+      continue;
+    }
+    current?.push(line);
+  }
+  if (current) {
+    blocks.push(parseTomlLines(current.join("\n")));
+  }
+  return blocks;
+}
 function normalizeRuns(module, result) {
   const runs = payloadItems(result.payload, ["runs", "items", "results"]).map((item) => normalizeRun(module, item)).filter(Boolean);
   return { runs };
@@ -27589,6 +27902,57 @@ var WorkerHarnessClient = class {
   async me() {
     return this.fetchText("/members/.me");
   }
+  async whoami() {
+    const { text: text2 } = await this.fetchText("/members/.me");
+    const record = parseTomlLines(text2);
+    const agentId = record.id?.trim();
+    if (!agentId) {
+      throw new Error("ElAgenteHarness /members/.me response did not include an id.");
+    }
+    return { agentId };
+  }
+  async registerNotifyCallback(input) {
+    return this.fetchPayload("/notify/register", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        agent_id: input.agentId,
+        callback: input.callback,
+        secret: input.secret
+      })
+    });
+  }
+  async getComputeJob(jobId) {
+    const id = this.requireJobId(jobId);
+    const { text: text2 } = await this.fetchText(`/compute/jobs/${encodeURIComponent(id)}`);
+    const record = parseTomlLines(text2);
+    const status = record.status?.trim() ?? null;
+    return {
+      jobId: record.id?.trim() ?? id,
+      status,
+      terminal: status !== null && HARNESS_TERMINAL_JOB_STATUSES.has(status),
+      title: record.title?.trim() || null,
+      reason: record.reason?.trim() || null,
+      raw: record
+    };
+  }
+  async listUnreadNotifications() {
+    const { text: text2 } = await this.fetchText("/notify/inbox");
+    return parseTomlBlocks(text2, "notifications").filter((entry) => entry.id?.trim()).map((entry) => ({
+      id: entry.id.trim(),
+      from: entry.from?.trim() ?? "",
+      message: entry.message ?? ""
+    }));
+  }
+  async markNotificationRead(notificationId) {
+    const id = notificationId.trim();
+    if (!HARNESS_NOTIFICATION_ID_PATTERN.test(id)) {
+      throw new Error(`Unsupported Harness notification id: ${notificationId}`);
+    }
+    return this.fetchText(`/notify/inbox/${encodeURIComponent(id)}`);
+  }
   async home() {
     return this.fetchPayload("/");
   }
@@ -27655,6 +28019,13 @@ var WorkerHarnessClient = class {
     }
     return normalized;
   }
+  requireJobId(jobId) {
+    const normalized = jobId.trim();
+    if (!HARNESS_JOB_ID_PATTERN.test(normalized)) {
+      throw new Error(`Unsupported Harness job id: ${jobId}`);
+    }
+    return normalized;
+  }
   requireRunId(runId) {
     const normalized = runId.trim();
     if (!HARNESS_RUN_ID_PATTERN.test(normalized)) {
@@ -27670,9 +28041,9 @@ var WorkerHarnessClient = class {
     }
     return { baseUrl, apiKey };
   }
-  async fetchText(path26) {
+  async fetchText(path27) {
     const config = this.requireHarnessConfig();
-    const response = await this.fetchImpl(`${config.baseUrl}${path26}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path27}`, {
       headers: {
         "x-api-key": config.apiKey
       }
@@ -27683,11 +28054,11 @@ var WorkerHarnessClient = class {
     }
     return { text: text2 };
   }
-  async fetchPayload(path26, init = {}) {
+  async fetchPayload(path27, init = {}) {
     const config = this.requireHarnessConfig();
     const headers = new Headers(init.headers);
     headers.set("x-api-key", config.apiKey);
-    const response = await this.fetchImpl(`${config.baseUrl}${path26}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path27}`, {
       ...init,
       headers
     });
@@ -27701,9 +28072,9 @@ var WorkerHarnessClient = class {
       return { text: text2 };
     }
   }
-  async fetchBinary(path26) {
+  async fetchBinary(path27) {
     const config = this.requireHarnessConfig();
-    const response = await this.fetchImpl(`${config.baseUrl}${path26}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path27}`, {
       headers: {
         "x-api-key": config.apiKey
       }
@@ -27728,6 +28099,297 @@ var WorkerHarnessClient = class {
   }
 };
 
+// src/harness-wakeup-service.ts
+import crypto3 from "crypto";
+var JOB_ID_FROM_MESSAGE_PATTERN = /^id:\s*(\S+)\s*$/m;
+function timingSafeEqualString2(left, right) {
+  const leftBuffer = Buffer.from(left);
+  const rightBuffer = Buffer.from(right);
+  return leftBuffer.length === rightBuffer.length && crypto3.timingSafeEqual(leftBuffer, rightBuffer);
+}
+var HarnessWakeupService = class {
+  constructor(config, db, harnessClient, threadService, logger) {
+    this.config = config;
+    this.db = db;
+    this.harnessClient = harnessClient;
+    this.threadService = threadService;
+    this.logger = logger;
+  }
+  config;
+  db;
+  harnessClient;
+  threadService;
+  logger;
+  reconcileInFlight = null;
+  reconcileQueued = false;
+  disabledReasonFor(keyPresent) {
+    if (!this.config.harnessBaseUrl) {
+      return "missing_harness_base_url";
+    }
+    if (!keyPresent) {
+      return "missing_harness_key";
+    }
+    if (!this.config.harnessWakeupCallbackBaseUrl) {
+      return "missing_callback_base_url";
+    }
+    return null;
+  }
+  disabledReason() {
+    return this.disabledReasonFor(this.harnessClient.configured().keyPresent);
+  }
+  status() {
+    const keyPresent = this.harnessClient.configured().keyPresent;
+    const reason = this.disabledReasonFor(keyPresent);
+    return {
+      enabled: reason === null,
+      reason,
+      harnessBaseUrl: this.config.harnessBaseUrl,
+      callbackBaseUrl: this.config.harnessWakeupCallbackBaseUrl,
+      keyPresent
+    };
+  }
+  enabled() {
+    return this.disabledReason() === null;
+  }
+  requireEnabled() {
+    if (!this.enabled()) {
+      throw new HttpError(409, {
+        code: "conflict",
+        message: "Harness wakeup is not configured. REMOTE_CODEX_HARNESS_WAKEUP_CALLBACK_BASE_URL and the Harness key are required."
+      });
+    }
+  }
+  buildCallbackUrl(hookToken) {
+    const base = this.config.harnessWakeupCallbackBaseUrl.replace(/\/+$/, "");
+    const userSuffix = this.config.userId ? `?u=${encodeURIComponent(this.config.userId)}` : "";
+    return `${base}/harness-notify/${hookToken}${userSuffix}`;
+  }
+  async ensureRegistration() {
+    this.requireEnabled();
+    const existing = getHarnessNotifyRegistration(this.db);
+    if (existing) {
+      const desiredUrl = this.buildCallbackUrl(existing.hookToken);
+      if (existing.callbackUrl === desiredUrl) {
+        return existing;
+      }
+      await this.harnessClient.registerNotifyCallback({
+        agentId: existing.agentId,
+        callback: desiredUrl,
+        secret: existing.secret
+      });
+      return upsertHarnessNotifyRegistration(this.db, {
+        agentId: existing.agentId,
+        hookToken: existing.hookToken,
+        secret: existing.secret,
+        callbackUrl: desiredUrl
+      });
+    }
+    const { agentId } = await this.harnessClient.whoami();
+    const hookToken = crypto3.randomBytes(32).toString("hex");
+    const secret = crypto3.randomBytes(32).toString("hex");
+    const callbackUrl = this.buildCallbackUrl(hookToken);
+    await this.harnessClient.registerNotifyCallback({
+      agentId,
+      callback: callbackUrl,
+      secret
+    });
+    return upsertHarnessNotifyRegistration(this.db, {
+      agentId,
+      hookToken,
+      secret,
+      callbackUrl
+    });
+  }
+  async getWakeupInfo() {
+    const status = this.status();
+    if (!status.enabled) {
+      return {
+        ...status,
+        enabled: false
+      };
+    }
+    const registration = await this.ensureRegistration();
+    return {
+      ...status,
+      enabled: true,
+      notifyTo: registration.agentId,
+      registered: true
+    };
+  }
+  async watchJob(input) {
+    this.requireEnabled();
+    const jobId = input.jobId.trim();
+    if (!jobId) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "jobId is required."
+      });
+    }
+    let threadId = input.threadId?.trim() || null;
+    if (!threadId) {
+      const runningThreads = listThreadRecords(this.db).filter(
+        (thread) => thread.status === "running"
+      );
+      if (runningThreads.length === 1) {
+        threadId = runningThreads[0].id;
+      }
+    }
+    if (!threadId) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "threadId is required when it cannot be inferred from a single running thread."
+      });
+    }
+    if (!getThreadRecordById(this.db, threadId)) {
+      throw new HttpError(404, {
+        code: "not_found",
+        message: "Thread was not found."
+      });
+    }
+    const registration = await this.ensureRegistration();
+    const watch = upsertHarnessJobWatch(this.db, {
+      jobId,
+      threadId,
+      title: input.title ?? null
+    });
+    return {
+      watch,
+      notifyTo: registration.agentId
+    };
+  }
+  verifyCallback(input) {
+    const registration = getHarnessNotifyRegistration(this.db);
+    if (!registration || !timingSafeEqualString2(registration.hookToken, input.hookToken)) {
+      throw new HttpError(404, {
+        code: "not_found",
+        message: "Unknown harness hook."
+      });
+    }
+    const expected = crypto3.createHmac("sha256", registration.secret).update(input.rawBody).digest("hex");
+    if (!input.signature || !timingSafeEqualString2(expected, input.signature.trim())) {
+      throw new HttpError(403, {
+        code: "forbidden",
+        message: "Invalid harness hook signature."
+      });
+    }
+    let payload = {};
+    try {
+      const parsed = JSON.parse(input.rawBody.toString("utf8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        payload = parsed;
+      }
+    } catch {
+    }
+    return payload;
+  }
+  handleCallback(input) {
+    const payload = this.verifyCallback(input);
+    this.scheduleReconcile();
+    return {
+      accepted: true,
+      type: typeof payload.type === "string" ? payload.type : null
+    };
+  }
+  scheduleReconcile() {
+    if (this.reconcileInFlight) {
+      this.reconcileQueued = true;
+      return;
+    }
+    this.reconcileInFlight = this.reconcile().catch((error) => {
+      this.logger.error({ err: error }, "Harness wakeup reconcile failed.");
+    }).finally(() => {
+      this.reconcileInFlight = null;
+      if (this.reconcileQueued) {
+        this.reconcileQueued = false;
+        this.scheduleReconcile();
+      }
+    });
+  }
+  async waitForReconcile() {
+    while (this.reconcileInFlight) {
+      await this.reconcileInFlight;
+    }
+  }
+  async reconcile() {
+    const watches = listPendingHarnessJobWatches(this.db);
+    for (const watch of watches) {
+      try {
+        const job = await this.harnessClient.getComputeJob(watch.jobId);
+        updateHarnessJobWatch(this.db, watch.id, {
+          lastJobStatus: job.status
+        });
+        if (!job.terminal) {
+          continue;
+        }
+        await this.wakeThread(watch, job);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.warn(
+          { jobId: watch.jobId, threadId: watch.threadId, err: error },
+          "Harness wakeup delivery attempt failed; will retry on the next callback."
+        );
+        updateHarnessJobWatch(this.db, watch.id, { lastError: message });
+      }
+    }
+    await this.acknowledgeNotifications();
+  }
+  async wakeThread(watch, job) {
+    const thread = getThreadRecordById(this.db, watch.threadId);
+    if (!thread) {
+      updateHarnessJobWatch(this.db, watch.id, {
+        status: "failed",
+        lastError: "Thread was not found."
+      });
+      return;
+    }
+    if (thread.isConnected === false) {
+      await this.threadService.resumeThread(watch.threadId);
+    }
+    const title = watch.title ?? job.title;
+    const prompt = [
+      `[Harness job wakeup] Compute job ${job.jobId}${title ? ` ("${title}")` : ""} finished with status: ${job.status}.`,
+      job.reason ? `Reason: ${job.reason}.` : null,
+      `Retrieve details and outputs from the ElAgente Harness API (GET /compute/jobs/${job.jobId}, output files under GET /compute/jobs/${job.jobId}/files/...) using the INACT_X_APP_KEY env var, then continue the original task.`
+    ].filter(Boolean).join(" ");
+    await this.threadService.sendPrompt(watch.threadId, { prompt });
+    updateHarnessJobWatch(this.db, watch.id, {
+      status: "delivered",
+      lastError: null,
+      deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async acknowledgeNotifications() {
+    let notifications2;
+    try {
+      notifications2 = await this.harnessClient.listUnreadNotifications();
+    } catch (error) {
+      this.logger.warn({ err: error }, "Harness wakeup inbox listing failed.");
+      return;
+    }
+    for (const notification of notifications2) {
+      if (!notification.from.includes("jobs")) {
+        continue;
+      }
+      const jobId = JOB_ID_FROM_MESSAGE_PATTERN.exec(notification.message)?.[1] ?? null;
+      if (!jobId) {
+        continue;
+      }
+      const watch = getHarnessJobWatchByJobId(this.db, jobId);
+      if (watch && watch.status === "pending") {
+        continue;
+      }
+      try {
+        await this.harnessClient.markNotificationRead(notification.id);
+      } catch (error) {
+        this.logger.warn(
+          { notificationId: notification.id, err: error },
+          "Harness wakeup notification acknowledgement failed."
+        );
+      }
+    }
+  }
+};
+
 // src/worker-control-plane-sync.ts
 import { setTimeout as delay } from "timers/promises";
 var WorkerControlPlaneSyncError = class extends Error {
@@ -27863,7 +28525,7 @@ var WorkerControlPlaneSyncClient = class {
 };
 
 // src/auth.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 var AUTH_COOKIE_NAME = "remote_codex_session";
 var AuthService = class {
   required;
@@ -27946,7 +28608,7 @@ var AuthService = class {
     const payload = {
       username,
       expiresAt: expiresAtMs,
-      nonce: crypto3.randomBytes(16).toString("base64url")
+      nonce: crypto4.randomBytes(16).toString("base64url")
     };
     const payloadText = Buffer.from(JSON.stringify(payload), "utf8").toString(
       "base64url"
@@ -27994,7 +28656,7 @@ var AuthService = class {
     };
   }
   sign(payloadText) {
-    return crypto3.createHmac("sha256", this.secret ?? "").update(payloadText).digest("base64url");
+    return crypto4.createHmac("sha256", this.secret ?? "").update(payloadText).digest("base64url");
   }
 };
 function unauthorizedPayload() {
@@ -28051,7 +28713,7 @@ function constantTimeEqual(left, right) {
   if (leftBuffer.length !== rightBuffer.length) {
     return false;
   }
-  return crypto3.timingSafeEqual(leftBuffer, rightBuffer);
+  return crypto4.timingSafeEqual(leftBuffer, rightBuffer);
 }
 
 // src/relay-tunnel-client.ts
@@ -28218,6 +28880,14 @@ var RelayTunnelClient = class {
 var MAX_PROMPT_ATTACHMENTS2 = 10;
 var MAX_PROMPT_ATTACHMENT_BYTES2 = 25 * 1024 * 1024;
 var WORKER_AUTH_EXEMPT_PATHS = /* @__PURE__ */ new Set(["/healthz", "/readyz"]);
+var WORKER_AUTH_HOOK_PATH_PREFIX = "/api/hooks/";
+var WORKER_AUTH_LOOPBACK_PATHS = /* @__PURE__ */ new Set([
+  "/api/harness/wakeup",
+  "/api/harness/job-watches"
+]);
+function isLoopbackAddress(ip) {
+  return ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1";
+}
 var RELAY_FORWARD_HEADER = "x-remote-codex-relay-forwarded";
 var SUPERVISOR_LOG_REDACTION_PATHS = [
   "req.headers.authorization",
@@ -28248,16 +28918,16 @@ var HttpError = class extends Error {
 };
 function findRepoRoot(start = process.cwd()) {
   if (process.env.REMOTE_CODEX_REPO_ROOT) {
-    return path25.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
+    return path26.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
   }
-  let current = path25.resolve(start);
-  while (current !== path25.dirname(current)) {
-    if (fs26.existsSync(path25.join(current, "pnpm-workspace.yaml")) && fs26.existsSync(path25.join(current, "scripts", "service-restart.mjs"))) {
+  let current = path26.resolve(start);
+  while (current !== path26.dirname(current)) {
+    if (fs26.existsSync(path26.join(current, "pnpm-workspace.yaml")) && fs26.existsSync(path26.join(current, "scripts", "service-restart.mjs"))) {
       return current;
     }
-    current = path25.dirname(current);
+    current = path26.dirname(current);
   }
-  return path25.resolve(process.cwd());
+  return path26.resolve(process.cwd());
 }
 function createServiceLifecycle() {
   return {
@@ -28269,14 +28939,14 @@ function createServiceLifecycle() {
         });
       }
       const repoRoot = findRepoRoot();
-      const restartScript = path25.join(repoRoot, "scripts", "service-restart.mjs");
-      if (!fs26.existsSync(restartScript) || !fs26.existsSync(path25.join(repoRoot, "pnpm-workspace.yaml"))) {
+      const restartScript = path26.join(repoRoot, "scripts", "service-restart.mjs");
+      if (!fs26.existsSync(restartScript) || !fs26.existsSync(path26.join(repoRoot, "pnpm-workspace.yaml"))) {
         throw new HttpError(503, {
           code: "service_unavailable",
           message: "Build and restart requires a Remote Codex source checkout. Set REMOTE_CODEX_REPO_ROOT to the checkout path, or update the npm package with npm install -g remote-codex@latest."
         });
       }
-      const child = spawn5(process.execPath, [restartScript, "launch"], {
+      const child = spawn6(process.execPath, [restartScript, "launch"], {
         cwd: repoRoot,
         detached: true,
         env: process.env,
@@ -28334,7 +29004,8 @@ function buildApp(options = {}) {
     disableRequestLogging: config.disableRequestLogging
   });
   app.addHook("onRequest", async (request) => {
-    if (config.runtimeRole !== "worker" || !config.workerAuthToken || WORKER_AUTH_EXEMPT_PATHS.has(request.url.split("?")[0] ?? request.url)) {
+    const requestPath = request.url.split("?")[0] ?? request.url;
+    if (config.runtimeRole !== "worker" || !config.workerAuthToken || WORKER_AUTH_EXEMPT_PATHS.has(requestPath) || requestPath.startsWith(WORKER_AUTH_HOOK_PATH_PREFIX) || WORKER_AUTH_LOOPBACK_PATHS.has(requestPath) && isLoopbackAddress(request.ip)) {
       return;
     }
     const headerToken = request.headers["x-remote-codex-worker-token"];
@@ -28364,6 +29035,13 @@ function buildApp(options = {}) {
     relaySocketBridge.handleMessage
   ) : null;
   relayTunnelClient?.validateConfig();
+  const harnessWakeupService = new HarnessWakeupService(
+    config,
+    database.db,
+    harnessClient,
+    threadService,
+    app.log
+  );
   app.decorate("services", {
     config,
     database,
@@ -28376,6 +29054,7 @@ function buildApp(options = {}) {
     pluginRegistry,
     pluginService,
     harnessClient,
+    harnessWakeupService,
     controlPlaneSyncClient,
     authService,
     relayTunnelClient,
@@ -28392,6 +29071,12 @@ function buildApp(options = {}) {
     if (requestPath === "/api/auth/login" || requestPath === "/api/auth/logout" || requestPath === "/api/auth/session") {
       return;
     }
+    if (requestPath.startsWith(WORKER_AUTH_HOOK_PATH_PREFIX)) {
+      return;
+    }
+    if (WORKER_AUTH_LOOPBACK_PATHS.has(requestPath) && isLoopbackAddress(request.ip)) {
+      return;
+    }
     if (config.mode === "relay" && request.headers[RELAY_FORWARD_HEADER] === "1") {
       return;
     }