chatroom-cli 1.101.5 → 1.102.0

package/dist/index.js

@@ -28548,13 +28548,6 @@ function prefixCatalogModelsWithInfer(infer, models) {
 var init_model_provider = () => {};
 
 // src/daemon/infrastructure/local/harness/services/cursor-sdk/cursor-sdk-package.ts
-var exports_cursor_sdk_package = {};
-__export(exports_cursor_sdk_package, {
-  importBundledCursorSdk: () => importBundledCursorSdk,
-  getBundledCursorSdkVersion: () => getBundledCursorSdkVersion,
-  formatCursorSdkLoadError: () => formatCursorSdkLoadError,
-  formatCursorSdkError: () => formatCursorSdkError
-});
 import { existsSync, readFileSync as readFileSync3 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname2, join as join7 } from "node:path";
@@ -29396,13 +29389,6 @@ var init_claude = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/services/claude-sdk/claude-sdk-package.ts
-var exports_claude_sdk_package = {};
-__export(exports_claude_sdk_package, {
-  resolvePathToClaudeCodeExecutable: () => resolvePathToClaudeCodeExecutable,
-  importBundledClaudeSdk: () => importBundledClaudeSdk,
-  getBundledClaudeSdkVersion: () => getBundledClaudeSdkVersion,
-  formatClaudeSdkLoadError: () => formatClaudeSdkLoadError
-});
 import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { dirname as dirname3, join as join8 } from "node:path";
@@ -35120,12 +35106,6 @@ var init_opencode_sdk = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/services/pi-sdk/pi-sdk-package.ts
-var exports_pi_sdk_package = {};
-__export(exports_pi_sdk_package, {
-  importBundledPiSdk: () => importBundledPiSdk,
-  getBundledPiSdkVersion: () => getBundledPiSdkVersion,
-  formatPiSdkLoadError: () => formatPiSdkLoadError
-});
 import { existsSync as existsSync5, readFileSync as readFileSync7 } from "node:fs";
 import { dirname as dirname6, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL4 } from "node:url";
@@ -85390,28 +85370,6 @@ async function recoverAgentState(deps) {
       log4(`   \uD83D\uDD00 Registered ${registeredCount} workspace(s) on recovery`);
     }
   }
-  try {
-    const managedSessions = await deps.backend.getMachineHarnessSessions();
-    let orphanSessionCount = 0;
-    let totalFailedTurns = 0;
-    for (const hs of managedSessions) {
-      const hasActiveSlot = activeSlots.some((s) => s.chatroomId === hs.chatroomId);
-      if (hasActiveSlot)
-        continue;
-      try {
-        const result = await deps.backend.markOrphanTurnsFailed(hs.harnessSessionId);
-        orphanSessionCount++;
-        totalFailedTurns += result.failedTurns;
-      } catch (err) {
-        warn(`[daemon] ⚠️ Failed to mark orphan turns for session ${hs.harnessSessionId}: ${err.message}`);
-      }
-    }
-    if (orphanSessionCount > 0) {
-      log4(`   \uD83E\uDDF9 Marked ${totalFailedTurns} turns as failed across ${orphanSessionCount} orphan sessions`);
-    }
-  } catch (err) {
-    warn(`[daemon] ⚠️ Orphan turn cleanup failed: ${err.message}`);
-  }
 }
 
 // ../../services/backend/src/domain/usecase/agent/build-agent-restart-event.ts
@@ -101420,15 +101378,6 @@ function createRecoverAgentStateDeps(agentMgr, session2) {
         workingDir: args2.workingDir,
         hostname: session2.config?.hostname ?? "unknown",
         registeredBy: args2.registeredBy
-      }),
-      getMachineHarnessSessions: async () => session2.backend.query(api.daemon.directHarness.turns.getMachineHarnessSessions, {
-        sessionId: session2.sessionId,
-        machineId: session2.machineId
-      }),
-      markOrphanTurnsFailed: async (harnessSessionId) => session2.backend.mutation(api.daemon.directHarness.turns.markOrphanTurnsFailed, {
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        harnessSessionId
       })
     },
     session: {
@@ -105023,31 +104972,6 @@ var init_capabilities_bridge = __esm(() => {
   init_models_refresh();
 });
 
-// ../../services/backend/config/featureFlags.ts
-function getAllowedSignupMethodsForEnvironment(nodeEnv, convexDeployment, e2eSeedingEnabled) {
-  if (e2eSeedingEnabled === "true") {
-    return ["self", "invite"];
-  }
-  if (convexDeployment?.startsWith("local:")) {
-    return ["self", "invite"];
-  }
-  if (nodeEnv && DEV_NODE_ENVS.has(nodeEnv)) {
-    return ["self", "invite"];
-  }
-  return ["invite"];
-}
-var DEV_NODE_ENVS, featureFlags;
-var init_featureFlags = __esm(() => {
-  DEV_NODE_ENVS = new Set(["development", "test"]);
-  featureFlags = {
-    disableLogin: false,
-    directHarnessWorkers: true,
-    get allowedSignupMethods() {
-      return getAllowedSignupMethodsForEnvironment("development", process.env.CONVEX_DEPLOYMENT, process.env.E2E_SEEDING_ENABLED);
-    }
-  };
-});
-
 // ../../services/backend/prompts/agentic-query/system-prompt.ts
 function renderAgenticQuerySystemPrompt(params) {
   const completeCmd = `chatroom agentic-query complete --chatroom-id=${params.chatroomId} --query-id=${params.queryId} << 'CHATROOM_AGENTIC_QUERY_END'
@@ -106623,7 +106547,6 @@ var init_pi_sdk2 = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/bound-harness-registry.ts
-import { execSync as execSync2 } from "node:child_process";
 async function startBoundHarness(config4) {
   switch (config4.harnessName) {
     case "opencode-sdk":
@@ -106654,58 +106577,6 @@ function createChunkExtractor(harnessName) {
       return createStandardSdkChunkExtractor();
   }
 }
-function opencodeOnPath() {
-  try {
-    execSync2("opencode --version", { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isCursorSdkInstalled() {
-  if (!process.env.CURSOR_API_KEY?.trim())
-    return false;
-  try {
-    const { importBundledCursorSdk: importBundledCursorSdk2 } = await Promise.resolve().then(() => (init_cursor_sdk_package(), exports_cursor_sdk_package));
-    await importBundledCursorSdk2();
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isPiSdkInstalled() {
-  try {
-    const { importBundledPiSdk: importBundledPiSdk2 } = await Promise.resolve().then(() => (init_pi_sdk_package(), exports_pi_sdk_package));
-    const { ModelRegistry, AuthStorage } = await importBundledPiSdk2();
-    const authStorage = AuthStorage.create();
-    const modelRegistry = ModelRegistry.create(authStorage);
-    return modelRegistry.getAvailable().length > 0;
-  } catch {
-    return false;
-  }
-}
-async function isClaudeSdkInstalled() {
-  try {
-    const { importBundledClaudeSdk: importBundledClaudeSdk2, resolvePathToClaudeCodeExecutable: resolvePathToClaudeCodeExecutable2 } = await Promise.resolve().then(() => (init_claude_sdk_package(), exports_claude_sdk_package));
-    await importBundledClaudeSdk2();
-    await resolvePathToClaudeCodeExecutable2();
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function listInstalledNativeDirectHarnesses() {
-  const installed2 = [];
-  if (opencodeOnPath())
-    installed2.push("opencode-sdk");
-  if (await isCursorSdkInstalled())
-    installed2.push("cursor-sdk");
-  if (await isPiSdkInstalled())
-    installed2.push("pi-sdk");
-  if (await isClaudeSdkInstalled())
-    installed2.push("claude-sdk");
-  return installed2;
-}
 var init_bound_harness_registry = __esm(() => {
   init_claude_sdk2();
   init_cursor_sdk2();
@@ -106717,14 +106588,26 @@ var init_bound_harness_registry = __esm(() => {
 function makeHarnessKey(workspaceId, harnessName) {
   return `${workspaceId}:${harnessName}`;
 }
-function parseHarnessKey(key) {
-  const idx = key.indexOf(":");
-  if (idx === -1)
-    throw new Error(`Invalid harness key: ${key}`);
-  return { workspaceId: key.slice(0, idx), harnessName: key.slice(idx + 1) };
+
+// src/daemon/entry/shared-harness/bind-turn-message-on-event.ts
+function bindTurnMessageOnEvent(handle, sessionRepository, logPrefix) {
+  let lastBoundKey = null;
+  return () => {
+    const turn = handle.currentTurn;
+    if (!turn)
+      return;
+    const messageId = turn.messageId;
+    if (messageId == null)
+      return;
+    const key = `${turn.turnId}:${messageId}`;
+    if (key === lastBoundKey)
+      return;
+    lastBoundKey = key;
+    sessionRepository.bindTurnMessageId(turn.turnId, messageId).catch((err) => console.warn(`[${logPrefix}] bindTurnMessageId error (resume):`, err));
+  };
 }
 
-// src/daemon/entry/direct-harness/idle-handler.ts
+// src/daemon/entry/shared-harness/idle-handler.ts
 async function handleSessionIdle(handle, journal, config4, sessionRepository) {
   await exports_Effect.runPromise(handleSessionIdleEffect(handle, journal, config4, sessionRepository));
 }
@@ -106737,7 +106620,7 @@ var handleSessionIdleEffect = (handle, journal, config4, sessionRepository) => e
       try: () => sessionRepository.finalizeAssistantTurn(turnId),
       catch: (e) => e
     })), exports_Effect.catchAll((err) => exports_Effect.sync(() => {
-      console.warn(`[direct-harness] Failed to finalize turn ${turnId} for session ${rowId}:`, err instanceof Error ? err.message : String(err));
+      console.warn(`[harness] Failed to finalize turn ${turnId} for session ${rowId}:`, err instanceof Error ? err.message : String(err));
     })));
   }
   const next4 = yield* exports_Effect.tryPromise({
@@ -106763,35 +106646,17 @@ var handleSessionIdleEffect = (handle, journal, config4, sessionRepository) => e
     try: () => sessionRepository.markTurnProcessed(rowId, next4.seq),
     catch: (e) => e
   })), exports_Effect.catchAll((err) => exports_Effect.gen(function* () {
-    console.warn(`[direct-harness] Failed to prompt queued message for session ${rowId}:`, err instanceof Error ? err.message : String(err));
+    console.warn(`[harness] Failed to prompt queued message for session ${rowId}:`, err instanceof Error ? err.message : String(err));
     yield* exports_Effect.promise(() => sessionRepository.setGenerating(rowId, false));
     handle.currentTurn = null;
   })));
 }), (err) => exports_Effect.sync(() => {
-  console.warn(`[direct-harness] Unexpected error in handleSessionIdleEffect:`, err instanceof Error ? err.message : String(err));
+  console.warn(`[harness] Unexpected error in handleSessionIdleEffect:`, err instanceof Error ? err.message : String(err));
 }));
 var init_idle_handler = __esm(() => {
   init_esm();
 });
 
-// src/daemon/entry/shared-harness/bind-turn-message-on-event.ts
-function bindTurnMessageOnEvent(handle, sessionRepository, logPrefix) {
-  let lastBoundKey = null;
-  return () => {
-    const turn = handle.currentTurn;
-    if (!turn)
-      return;
-    const messageId = turn.messageId;
-    if (messageId == null)
-      return;
-    const key = `${turn.turnId}:${messageId}`;
-    if (key === lastBoundKey)
-      return;
-    lastBoundKey = key;
-    sessionRepository.bindTurnMessageId(turn.turnId, messageId).catch((err) => console.warn(`[${logPrefix}] bindTurnMessageId error (resume):`, err));
-  };
-}
-
 // src/daemon/entry/agentic-query/prompt-drain.ts
 async function drainPendingAgenticQueryMessages(daemonSession, deps) {
   const batch = await daemonSession.backend.query(api.daemon.agenticQuery.messages.pendingForMachine, { sessionId: daemonSession.sessionId, machineId: daemonSession.machineId });
@@ -107050,10 +106915,10 @@ async function openPendingHarnessSession(daemonSession, deps, input, options) {
 }
 var init_open_pending_session = __esm(() => {
   init_get_or_create_bound_harness();
+  init_idle_handler();
   init_api3();
   init_bound_harness_registry();
   init_opencode_session_events();
-  init_idle_handler();
 });
 
 // src/daemon/entry/agentic-query/session-processor.ts
@@ -110471,772 +110336,6 @@ async function dispatchCommandInboundEvent(event) {
 }
 var handler2;
 
-// src/daemon/entry/direct-harness/command-processor.ts
-async function dispatchPendingCommand(session2, deps, cmd) {
-  switch (cmd.type) {
-    case "refreshCapabilities":
-      await handleRefreshCapabilities(session2, deps, cmd);
-      break;
-    case "refreshSessionTitle":
-      await handleRefreshSessionTitle(session2, deps, cmd);
-      break;
-    case "closeSession":
-      await handleCloseSession(session2, deps, cmd);
-      break;
-    default:
-      await markFailed(session2, cmd._id, `Unknown command type: ${cmd.type}`);
-  }
-}
-async function processPendingCommand(session2, deps, cmd, now) {
-  if (now - cmd.createdAt > DIRECT_HARNESS_COMMAND_TTL_MS) {
-    console.log(`[direct-harness] Discarding stale command ${cmd._id} (type=${cmd.type}, age=${now - cmd.createdAt}ms)`);
-    await markFailed(session2, cmd._id, "Command expired (TTL)");
-    return;
-  }
-  await dispatchPendingCommand(session2, deps, cmd);
-}
-async function drainPendingHarnessCommands(session2, deps, processed = new Set) {
-  await drain(session2, deps, processed);
-}
-async function drain(session2, deps, processed) {
-  const pending3 = await session2.backend.query(api.daemon.directHarness.commands.listPendingCommands, { sessionId: session2.sessionId, machineId: session2.machineId });
-  if (!pending3 || pending3.length === 0)
-    return;
-  const now = Date.now();
-  for (const cmd of pending3) {
-    if (processed.has(cmd._id))
-      continue;
-    processed.add(cmd._id);
-    try {
-      await processPendingCommand(session2, deps, cmd, now);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[direct-harness] Command ${cmd._id} failed: ${message}`);
-      await markFailed(session2, cmd._id, message).catch(() => {});
-    }
-  }
-}
-async function handleRefreshCapabilities(session2, deps, cmd) {
-  const payload = cmd.refreshCapabilities;
-  console.log(`[direct-harness] Processing refreshCapabilities for workspace=${cmd.workspaceId}` + (payload ? ` (initiatedBy=${payload.initiatedBy})` : ""));
-  const installed2 = await listInstalledNativeDirectHarnesses();
-  const harnessEntries = [];
-  let cwd = "";
-  for (const harnessName of installed2) {
-    const harness = await deps.lifecycleManager.getOrStart(cmd.workspaceId, harnessName);
-    cwd = harness.cwd;
-    const [agents, providers] = await Promise.all([harness.listAgents(), harness.listProviders()]);
-    harnessEntries.push({
-      name: harness.type,
-      displayName: harness.displayName,
-      agents: [...agents],
-      providers: [...providers]
-    });
-  }
-  const existing = await session2.backend.query(api.daemon.directHarness.capabilities.getForMachine, { sessionId: session2.sessionId, machineId: session2.machineId });
-  const updatedWorkspace = {
-    workspaceId: cmd.workspaceId,
-    cwd,
-    name: cwd,
-    harnesses: harnessEntries
-  };
-  const merged = [
-    ...(existing?.workspaces ?? []).filter((ws) => ws.workspaceId !== cmd.workspaceId),
-    updatedWorkspace
-  ];
-  await deps.publisher.publish({
-    machineId: session2.machineId,
-    lastSeenAt: Date.now(),
-    workspaces: merged
-  });
-  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-    sessionId: session2.sessionId,
-    commandId: cmd._id,
-    status: "done"
-  });
-  console.log(`[direct-harness] Capabilities refreshed for workspace=${cmd.workspaceId}`);
-}
-async function handleRefreshSessionTitle(session2, deps, cmd) {
-  const { harnessSessionId } = cmd.refreshSessionTitle ?? {};
-  if (!harnessSessionId) {
-    await markFailed(session2, cmd._id, "refreshSessionTitle: missing harnessSessionId");
-    return;
-  }
-  const sessionRow = await session2.backend.query(api.daemon.directHarness.sessions.getSession, {
-    harnessSessionId
-  });
-  if (!sessionRow?.opencodeSessionId) {
-    await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-      sessionId: session2.sessionId,
-      commandId: cmd._id,
-      status: "done"
-    });
-    return;
-  }
-  const harnessName = sessionRow.harnessName ?? "opencode-sdk";
-  const harness = await deps.lifecycleManager.getOrStart(sessionRow.workspaceId ?? cmd.workspaceId, harnessName);
-  const newTitle = await harness.fetchSessionTitle(sessionRow.opencodeSessionId);
-  if (newTitle) {
-    await session2.backend.mutation(api.daemon.directHarness.sessions.updateSessionTitle, {
-      sessionId: session2.sessionId,
-      harnessSessionId,
-      sessionTitle: newTitle
-    });
-    console.log(`[direct-harness] Refreshed title for session ${harnessSessionId}: "${newTitle}"`);
-  }
-  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-    sessionId: session2.sessionId,
-    commandId: cmd._id,
-    status: "done"
-  });
-}
-async function closeDisconnectedHarnessSession(deps, sessionRow, harnessSessionId) {
-  if (!sessionRow.opencodeSessionId) {
-    await deps.sessionRepository.markClosed(harnessSessionId);
-    return;
-  }
-  const harnessName = sessionRow.harnessName ?? "opencode-sdk";
-  const harness = await deps.lifecycleManager.getOrStart(sessionRow.workspaceId ?? "", harnessName);
-  const liveSession = await harness.resumeSession(sessionRow.opencodeSessionId, {
-    harnessSessionId
-  });
-  await liveSession.close();
-  await deps.sessionRepository.markClosed(harnessSessionId);
-}
-async function closeHarnessSession(session2, deps, harnessSessionId) {
-  const sessionRow = await session2.backend.query(api.daemon.directHarness.sessions.getSession, {
-    harnessSessionId
-  });
-  if (!sessionRow) {
-    throw new Error(`Harness session ${harnessSessionId} not found`);
-  }
-  if (sessionRow.status === "closed" || sessionRow.status === "failed") {
-    return;
-  }
-  const handle = deps.activeSessions.get(harnessSessionId);
-  if (handle) {
-    await handle.close();
-    deps.activeSessions.delete(harnessSessionId);
-    return;
-  }
-  await closeDisconnectedHarnessSession(deps, sessionRow, harnessSessionId);
-}
-async function handleCloseSession(session2, deps, cmd) {
-  const { harnessSessionId } = cmd.closeSession ?? {};
-  if (!harnessSessionId) {
-    await markFailed(session2, cmd._id, "closeSession: missing harnessSessionId");
-    return;
-  }
-  console.log(`[direct-harness] Processing closeSession for harnessSessionId=${harnessSessionId}`);
-  await closeHarnessSession(session2, deps, harnessSessionId);
-  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-    sessionId: session2.sessionId,
-    commandId: cmd._id,
-    status: "done"
-  });
-  console.log(`[direct-harness] Closed session ${harnessSessionId}`);
-}
-async function markFailed(session2, commandId, errorMessage) {
-  await session2.backend.mutation(api.daemon.directHarness.commands.updateCommandStatus, {
-    sessionId: session2.sessionId,
-    commandId,
-    status: "failed",
-    errorMessage
-  });
-}
-var DIRECT_HARNESS_COMMAND_TTL_MS = 60000;
-var init_command_processor = __esm(() => {
-  init_api3();
-  init_bound_harness_registry();
-});
-
-// src/daemon/entry/direct-harness/harness-lifecycle-manager.ts
-class HarnessLifecycleManager {
-  harnesses;
-  activeSessions;
-  resolveWorkspace;
-  resolvedConvexUrl;
-  idleSince = new Map;
-  monitorTimer = null;
-  constructor(harnesses, activeSessions, resolveWorkspace, resolvedConvexUrl) {
-    this.harnesses = harnesses;
-    this.activeSessions = activeSessions;
-    this.resolveWorkspace = resolveWorkspace;
-    this.resolvedConvexUrl = resolvedConvexUrl;
-  }
-  getOrStartHarnessEffect(workspaceId, harnessName) {
-    const key = makeHarnessKey(workspaceId, harnessName);
-    const existing = this.harnesses.get(key);
-    if (existing?.isAlive())
-      return exports_Effect.succeed(existing);
-    if (existing) {
-      existing.close().catch(() => {});
-      this.harnesses.delete(key);
-    }
-    return exports_Effect.gen(this, function* () {
-      const workspace = yield* exports_Effect.tryPromise({
-        try: () => this.resolveWorkspace(workspaceId),
-        catch: (e) => e instanceof Error ? e : new Error(String(e))
-      });
-      if (!workspace) {
-        return yield* exports_Effect.fail(new Error(`Workspace ${workspaceId} not found — cannot start harness`));
-      }
-      console.log(`[${formatTimestamp()}] \uD83D\uDD27 Auto-starting ${harnessName} for workspace=${workspaceId} (${workspace.workingDir})`);
-      const harness = yield* exports_Effect.tryPromise({
-        try: () => startBoundHarness({
-          harnessName,
-          workingDir: workspace.workingDir,
-          workspaceId,
-          resolvedConvexUrl: this.resolvedConvexUrl
-        }),
-        catch: (e) => e instanceof Error ? e : new Error(String(e))
-      });
-      this.harnesses.set(key, harness);
-      this.idleSince.set(key, Date.now());
-      return harness;
-    });
-  }
-  async getOrStart(workspaceId, harnessName) {
-    return exports_Effect.runPromise(this.getOrStartHarnessEffect(workspaceId, harnessName));
-  }
-  startMonitoring() {
-    if (this.monitorTimer)
-      return;
-    this.monitorTimer = setInterval(() => this.checkInactivity(), CHECK_INTERVAL_MS);
-    this.monitorTimer.unref();
-  }
-  stopMonitoring() {
-    if (this.monitorTimer) {
-      clearInterval(this.monitorTimer);
-      this.monitorTimer = null;
-    }
-  }
-  checkInactivity() {
-    const now = Date.now();
-    for (const key of this.harnesses.keys()) {
-      const { workspaceId, harnessName } = parseHarnessKey(key);
-      const hasActiveSessions = this.hasSessionsForHarnessKey(workspaceId, harnessName);
-      if (hasActiveSessions) {
-        this.idleSince.delete(key);
-      } else {
-        const idleStart = this.idleSince.get(key);
-        if (idleStart === undefined) {
-          this.idleSince.set(key, now);
-        } else if (now - idleStart >= INACTIVITY_TTL_MS) {
-          const idleMinutes = Math.round((now - idleStart) / 60000);
-          console.log(`[${formatTimestamp()}] \uD83D\uDD2A Killing idle harness ${harnessName} for workspace=${workspaceId} (idle ${idleMinutes}min)`);
-          this.harnesses.get(key)?.close().catch(() => {});
-          this.harnesses.delete(key);
-          this.idleSince.delete(key);
-        }
-      }
-    }
-  }
-  hasSessionsForHarnessKey(workspaceId, harnessName) {
-    for (const handle of this.activeSessions.values()) {
-      if (handle.workspaceId === workspaceId && handle.harnessName === harnessName) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-var INACTIVITY_TTL_MS, CHECK_INTERVAL_MS;
-var init_harness_lifecycle_manager = __esm(() => {
-  init_esm();
-  init_bound_harness_registry();
-  INACTIVITY_TTL_MS = 15 * 60 * 1000;
-  CHECK_INTERVAL_MS = 60 * 1000;
-});
-
-// src/daemon/entry/direct-harness/prompt-drain.ts
-async function drainPendingHarnessMessages(session2, deps) {
-  const pending3 = await session2.backend.query(api.daemon.directHarness.messages.pendingForMachine, { sessionId: session2.sessionId, machineId: session2.machineId });
-  if (!pending3 || pending3.messages.length === 0)
-    return;
-  const bySession = new Map;
-  for (const msg of pending3.messages) {
-    const list = bySession.get(msg.harnessSessionId);
-    if (list) {
-      list.push(msg);
-    } else {
-      bySession.set(msg.harnessSessionId, [msg]);
-    }
-  }
-  const sessionInfo = new Map;
-  for (const s of pending3.sessions) {
-    sessionInfo.set(s._id, s);
-  }
-  for (const [rowId, messages] of bySession) {
-    try {
-      await processSessionMessages(session2, deps, rowId, messages, sessionInfo.get(rowId));
-    } catch (err) {
-      console.warn(`[direct-harness] Failed to process messages for session ${rowId}:`, err instanceof Error ? err.message : String(err));
-    }
-  }
-}
-async function resumeSessionHandle(session2, deps, rowId, info) {
-  const opencodeSessionId = info.opencodeSessionId;
-  if (!opencodeSessionId) {
-    console.warn(`[direct-harness] Session ${rowId} not yet open — waiting for session-subscriber`);
-    return null;
-  }
-  const workspaceId = info.workspaceId;
-  const harnessName = info.harnessName;
-  if (!workspaceId) {
-    console.warn(`[direct-harness] Cannot resume session ${rowId}: no workspace info`);
-    return null;
-  }
-  const key = makeHarnessKey(workspaceId, harnessName);
-  let harness = deps.harnesses.get(key);
-  if (harness && !harness.isAlive()) {
-    harness.close().catch(() => {});
-    deps.harnesses.delete(key);
-    harness = undefined;
-  }
-  if (!harness) {
-    const workspace = await session2.backend.query(api.workspaces.getWorkspaceById, {
-      sessionId: session2.sessionId,
-      workspaceId
-    });
-    if (!workspace) {
-      console.warn(`[direct-harness] Cannot resume session ${rowId}: workspace not found`);
-      return null;
-    }
-    harness = await startBoundHarness({
-      harnessName,
-      workingDir: workspace.workingDir,
-      workspaceId,
-      resolvedConvexUrl: session2.convexUrl
-    });
-    deps.harnesses.set(key, harness);
-  }
-  try {
-    return await resumeSession({
-      harness,
-      journalFactory: deps.journalFactory,
-      chunkExtractor: createChunkExtractor(harness.type)
-    }, { harnessSessionId: rowId, opencodeSessionId, workspaceId, harnessName });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.warn(`[direct-harness] Cannot resume session ${rowId}: ${message}`);
-    await deps.sessionRepository.markFailed(rowId).catch(() => {});
-    return null;
-  }
-}
-function wireResumedSessionEvents(handle, deps, info) {
-  const idleConfig = {
-    agent: info.lastUsedConfig.agent ?? "build",
-    model: info.lastUsedConfig.model
-  };
-  const bindTurnMessage = bindTurnMessageOnEvent(handle, deps.sessionRepository, "direct-harness");
-  handle.session.onEvent((event) => {
-    bindTurnMessage();
-    if (event.type === OPENCODE_SESSION_EVENT_TYPES[0]) {
-      handleSessionIdle(handle, handle.journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[direct-harness] idle handler error (resume):", err));
-    }
-  });
-}
-async function deliverPendingMessages(handle, deps, rowId, messages, info, _daemonSession) {
-  for (const msg of messages) {
-    const override = info?.lastUsedConfig ?? { agent: "build" };
-    try {
-      await deps.sessionRepository.setGenerating(rowId, true);
-      const { turnId } = await deps.sessionRepository.beginAssistantTurn(rowId);
-      handle.currentTurn = { turnId, messageId: null };
-      await handle.session.prompt({
-        parts: [{ type: "text", text: msg.content }],
-        agent: override.agent,
-        ...override.model ? { model: override.model } : {}
-      });
-      await deps.sessionRepository.markTurnProcessed(rowId, msg.seq);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[direct-harness] Prompt failed for session ${rowId} seq=${msg.seq}: ${message}`);
-      await deps.sessionRepository.markIdle(rowId).catch(() => {});
-      deps.activeSessions.delete(rowId);
-      if (info?.workspaceId && info.harnessName) {
-        deps.harnesses.delete(makeHarnessKey(info.workspaceId, info.harnessName));
-      }
-      return;
-    }
-  }
-}
-async function processSessionMessages(session2, deps, rowId, messages, info) {
-  let handle = deps.activeSessions.get(rowId);
-  if (!handle) {
-    if (!info) {
-      console.warn(`[direct-harness] Session ${rowId} not yet open — waiting for session-subscriber`);
-      return;
-    }
-    const resumed = await resumeSessionHandle(session2, deps, rowId, info);
-    if (!resumed) {
-      return;
-    }
-    handle = resumed;
-    deps.activeSessions.set(rowId, handle);
-    await deps.sessionRepository.markActive(rowId).catch(() => {});
-    wireResumedSessionEvents(handle, deps, info);
-  }
-  await deliverPendingMessages(handle, deps, rowId, messages, info, session2);
-}
-var init_prompt_drain2 = __esm(() => {
-  init_idle_handler();
-  init_api3();
-  init_resume_harness_session();
-  init_bound_harness_registry();
-  init_opencode_session_events();
-});
-
-// src/daemon/entry/direct-harness/session-processor.ts
-async function processPendingHarnessSessions(daemonSession, deps) {
-  const pendingSessions = await daemonSession.backend.query(api.daemon.directHarness.sessions.listPendingSessionsForMachine, {
-    sessionId: daemonSession.sessionId,
-    machineId: daemonSession.machineId
-  });
-  await processPendingHarnessSessionRows(daemonSession, deps, pendingSessions);
-}
-async function processPendingHarnessSessionRows(daemonSession, deps, pendingSessions) {
-  if (!pendingSessions || pendingSessions.length === 0)
-    return;
-  for (const session2 of pendingSessions) {
-    const harnessName = session2.opencode?.harnessName ?? "opencode-sdk";
-    const agent = session2.opencode?.lastUsedConfig?.agent ?? "build";
-    const model = session2.opencode?.lastUsedConfig?.model;
-    await openPendingHarnessSession(daemonSession, deps, {
-      rowId: session2._id,
-      workspaceId: session2.workspaceId,
-      harnessName,
-      lastUsedConfig: { agent, ...model ? { model } : {} }
-    }, { logPrefix: "[direct-harness]", handleProviderIdEvents: true });
-  }
-}
-var init_session_processor2 = __esm(() => {
-  init_api3();
-  init_open_pending_session();
-});
-
-// src/daemon/entry/direct-harness/shutdown-sessions.ts
-async function listHarnessSessionIdsForShutdown(session2) {
-  const ids3 = new Set;
-  const managed = await session2.backend.query(api.daemon.directHarness.turns.getMachineHarnessSessions, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId
-  });
-  for (const row of managed) {
-    ids3.add(row.harnessSessionId);
-  }
-  const pending3 = await session2.backend.query(api.daemon.directHarness.sessions.listPendingSessionsForMachine, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId
-  });
-  for (const row of pending3) {
-    ids3.add(row._id);
-  }
-  return [...ids3];
-}
-async function closeAllMachineHarnessSessionsOnShutdown(session2, deps) {
-  const commandDeps = {
-    lifecycleManager: deps.lifecycleManager,
-    publisher: {},
-    activeSessions: deps.activeSessions,
-    sessionRepository: deps.sessionRepository
-  };
-  const harnessSessionIds = await listHarnessSessionIdsForShutdown(session2);
-  if (harnessSessionIds.length === 0)
-    return;
-  console.log(`[direct-harness] Closing ${harnessSessionIds.length} harness session(s) on daemon shutdown...`);
-  for (const harnessSessionId of harnessSessionIds) {
-    try {
-      await session2.backend.mutation(api.daemon.directHarness.turns.markOrphanTurnsFailed, {
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        harnessSessionId
-      });
-    } catch {}
-    try {
-      await closeHarnessSession(session2, commandDeps, harnessSessionId);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[direct-harness] Failed to close session ${harnessSessionId} on shutdown: ${message}`);
-      try {
-        await deps.sessionRepository.markClosed(harnessSessionId);
-      } catch {}
-    }
-  }
-}
-var init_shutdown_sessions = __esm(() => {
-  init_command_processor();
-  init_api3();
-});
-
-// src/infrastructure/repos/convex-capabilities-publisher.ts
-class ConvexCapabilitiesPublisher {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  async publish(caps) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.capabilities.publishMachineCapabilities, {
-      sessionId,
-      machineId: caps.machineId,
-      workspaces: caps.workspaces.map((ws) => ({
-        workspaceId: ws.workspaceId,
-        cwd: ws.cwd,
-        name: ws.name,
-        harnesses: ws.harnesses.map((h) => ({
-          name: h.name,
-          displayName: h.displayName,
-          agents: h.agents.map((a) => ({
-            name: a.name,
-            mode: a.mode,
-            ...a.model ? { model: a.model } : {},
-            ...a.description ? { description: a.description } : {}
-          })),
-          providers: h.providers.map((p) => ({
-            providerID: p.providerID,
-            name: p.name,
-            models: p.models.map((m) => ({ modelID: m.modelID, name: m.name }))
-          })),
-          ...h.configSchema !== undefined ? { configSchema: h.configSchema } : {}
-        }))
-      }))
-    });
-  }
-}
-var init_convex_capabilities_publisher = __esm(() => {
-  init_api3();
-});
-
-// src/infrastructure/repos/convex-output-repository.ts
-class ConvexOutputRepository {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  async appendChunks(harnessSessionId, chunks) {
-    const { backend: backend2, sessionId } = this.options;
-    if (chunks.length === 0)
-      return;
-    console.log(`[output-repo] Calling appendMessages: harnessSessionId="${harnessSessionId}", ${chunks.length} chunks`);
-    try {
-      await backend2.mutation(api.daemon.directHarness.messages.appendMessages, {
-        sessionId,
-        harnessSessionId,
-        chunks: chunks.map((c) => ({
-          content: c.content,
-          timestamp: c.timestamp,
-          messageId: c.messageId,
-          partType: c.partType
-        }))
-      });
-      console.log(`[output-repo] appendMessages succeeded for "${harnessSessionId}"`);
-    } catch (err) {
-      console.error(`[output-repo] appendMessages FAILED for "${harnessSessionId}": ${err instanceof Error ? err.message : String(err)}`);
-      throw err;
-    }
-  }
-}
-var init_convex_output_repository = __esm(() => {
-  init_api3();
-});
-
-// src/infrastructure/repos/convex-session-repository.ts
-class ConvexSessionRepository {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  async associateOpenCodeSessionId(harnessSessionId, opencodeSessionId, sessionTitle) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.sessions.associateHarnessSessionId, {
-      sessionId,
-      harnessSessionId,
-      opencodeSessionId,
-      sessionTitle
-    });
-  }
-  async getOpenCodeSessionId(harnessSessionId) {
-    const result = await this.options.backend.query(api.daemon.directHarness.sessions.getSession, {
-      harnessSessionId
-    });
-    return result?.opencodeSessionId;
-  }
-  async markClosed(harnessSessionId) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.sessions.closeSession, {
-      sessionId,
-      harnessSessionId
-    });
-  }
-  async markIdle(harnessSessionId) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.sessions.markIdle, {
-      sessionId,
-      harnessSessionId
-    });
-  }
-  async markFailed(harnessSessionId) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.sessions.markFailed, {
-      sessionId,
-      harnessSessionId
-    });
-  }
-  async markActive(harnessSessionId) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.sessions.markActive, {
-      sessionId,
-      harnessSessionId
-    });
-  }
-  async markTurnProcessed(harnessSessionId, turnSeq) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.turns.markTurnProcessed, {
-      sessionId,
-      harnessSessionId,
-      turnSeq
-    });
-  }
-  async setGenerating(harnessSessionId, isGenerating) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.queue.setGenerating, {
-      sessionId,
-      harnessSessionId,
-      isGenerating
-    });
-  }
-  async dequeueNext(harnessSessionId) {
-    const { backend: backend2, sessionId } = this.options;
-    const result = await backend2.mutation(api.daemon.directHarness.queue.dequeueNext, {
-      sessionId,
-      harnessSessionId
-    });
-    if (!result)
-      return null;
-    return { content: result.content, seq: result.turnSeq };
-  }
-  async beginAssistantTurn(harnessSessionId) {
-    const { backend: backend2, sessionId } = this.options;
-    return backend2.mutation(api.daemon.directHarness.turns.beginAssistantTurn, {
-      sessionId,
-      harnessSessionId
-    });
-  }
-  async bindTurnMessageId(turnId, messageId) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.turns.bindTurnMessageId, {
-      sessionId,
-      turnId,
-      messageId
-    });
-  }
-  async finalizeAssistantTurn(turnId) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.turns.finalizeAssistantTurn, {
-      sessionId,
-      turnId
-    });
-  }
-  async updateSessionTitle(harnessSessionId, title) {
-    const { backend: backend2, sessionId } = this.options;
-    await backend2.mutation(api.daemon.directHarness.sessions.updateSessionTitle, {
-      sessionId,
-      harnessSessionId,
-      sessionTitle: title
-    });
-  }
-}
-var init_convex_session_repository = __esm(() => {
-  init_api3();
-});
-
-// src/daemon/entry/direct-harness-inbound-registry.ts
-function registerDirectHarnessInboundHandler(h) {
-  handler3 = h;
-}
-function unregisterDirectHarnessInboundHandler() {
-  handler3 = undefined;
-}
-async function dispatchDirectHarnessInboundEvent(event) {
-  if (handler3)
-    await handler3(event);
-}
-var handler3;
-
-// src/daemon/entry/direct-harness/start-subscriptions.ts
-function startDirectHarnessSubscriptions(session2, activeSessions, harnesses) {
-  const sessionRepository = new ConvexSessionRepository({
-    backend: session2.backend,
-    sessionId: session2.sessionId
-  });
-  const outputRepository = new ConvexOutputRepository({
-    backend: session2.backend,
-    sessionId: session2.sessionId
-  });
-  const journalFactory = new BufferedJournalFactory({ outputRepository });
-  const sharedDeps = {
-    activeSessions,
-    harnesses,
-    sessionRepository,
-    journalFactory
-  };
-  const lifecycleManager = new HarnessLifecycleManager(harnesses, activeSessions, async (workspaceId) => session2.backend.query(api.workspaces.getWorkspaceById, {
-    sessionId: session2.sessionId,
-    workspaceId
-  }), session2.convexUrl);
-  lifecycleManager.startMonitoring();
-  const commandDeps = {
-    lifecycleManager,
-    publisher: new ConvexCapabilitiesPublisher({
-      backend: session2.backend,
-      sessionId: session2.sessionId
-    }),
-    activeSessions,
-    sessionRepository
-  };
-  registerDirectHarnessInboundHandler(async (event) => {
-    switch (event.type) {
-      case "direct-harness.prompt":
-        await drainPendingHarnessMessages(session2, sharedDeps);
-        break;
-      case "direct-harness.session-opened":
-        await processPendingHarnessSessions(session2, sharedDeps);
-        break;
-      case "direct-harness.command":
-        await drainPendingHarnessCommands(session2, commandDeps);
-        break;
-    }
-  });
-  return {
-    lifecycleManager,
-    closeSessionsOnShutdown: async () => {
-      unregisterDirectHarnessInboundHandler();
-      await closeAllMachineHarnessSessionsOnShutdown(session2, {
-        lifecycleManager,
-        activeSessions,
-        sessionRepository
-      });
-    },
-    stop: () => {
-      unregisterDirectHarnessInboundHandler();
-      lifecycleManager.stopMonitoring();
-    }
-  };
-}
-var init_start_subscriptions2 = __esm(() => {
-  init_command_processor();
-  init_harness_lifecycle_manager();
-  init_prompt_drain2();
-  init_session_processor2();
-  init_shutdown_sessions();
-  init_api3();
-  init_convex_capabilities_publisher();
-  init_convex_output_repository();
-  init_convex_session_repository();
-});
-
 // src/daemon/entry/enhancer/constants.ts
 var ENHANCER_AGENT_ROLE = "enhancer", ENHANCER_AGENT_END_GRACE_MS = 3000;
 
@@ -111418,16 +110517,16 @@ var init_wait_for_enhancer_job = __esm(() => {
 
 // src/daemon/entry/enhancer-inbound-registry.ts
 function registerEnhancerInboundHandler(h) {
-  handler4 = h;
+  handler3 = h;
 }
 function unregisterEnhancerInboundHandler() {
-  handler4 = undefined;
+  handler3 = undefined;
 }
 async function dispatchEnhancerInboundEvent(event) {
-  if (handler4)
-    await handler4(event);
+  if (handler3)
+    await handler3(event);
 }
-var handler4;
+var handler3;
 
 // src/daemon/entry/enhancer/job-subscriber.ts
 async function processEnhancerJobForSpawn(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, job, inFlight2, logSink) {
@@ -111619,22 +110718,22 @@ var init_job_subscriber = __esm(() => {
 function startEnhancerSubscriptions(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, logSink) {
   return startEnhancerJobSubscriber(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, logSink);
 }
-var init_start_subscriptions3 = __esm(() => {
+var init_start_subscriptions2 = __esm(() => {
   init_job_subscriber();
 });
 
 // src/daemon/entry/file-inbound-registry.ts
 function registerFileInboundHandler(h) {
-  handler5 = h;
+  handler4 = h;
 }
 function unregisterFileInboundHandler() {
-  handler5 = undefined;
+  handler4 = undefined;
 }
 async function dispatchFileInboundEvent(event) {
-  if (handler5)
-    await handler5(event);
+  if (handler4)
+    await handler4(event);
 }
-var handler5;
+var handler4;
 
 // src/daemon/entry/files/file-content-classifier.ts
 function extensionOf(path3) {
@@ -115721,7 +114820,7 @@ function createCoalescingStateOutbox(options) {
       return;
     timer = setTimeout(() => {
       timer = null;
-      drain2().catch(() => {
+      drain().catch(() => {
         return;
       });
     }, Math.max(0, delayMs));
@@ -115730,7 +114829,7 @@ function createCoalescingStateOutbox(options) {
   if (pending3) {
     schedule2(retryAttempt > 0 ? computeExponentialRetryDelayMs(retryAttempt - 1, retryDelayMs, maxRetryDelayMs) : 0);
   }
-  async function drain2() {
+  async function drain() {
     if (stopped || !pending3 || inFlight2)
       return;
     const batch = pending3;
@@ -115794,7 +114893,7 @@ function createCoalescingStateOutbox(options) {
       });
     }
     if (pending3)
-      await drain2();
+      await drain();
   };
   const stop4 = async () => {
     if (stopped)
@@ -118482,16 +117581,16 @@ var init_git_subscription = __esm(() => {
 
 // src/daemon/entry/workspace-git-inbound-registry.ts
 function registerWorkspaceGitInboundHandler(h) {
-  handler6 = h;
+  handler5 = h;
 }
 function unregisterWorkspaceGitInboundHandler() {
-  handler6 = undefined;
+  handler5 = undefined;
 }
 async function dispatchWorkspaceGitInboundEvent(event) {
-  if (handler6)
-    await handler6(event);
+  if (handler5)
+    await handler5(event);
 }
-var handler6;
+var handler5;
 
 // src/events/lifecycle/on-daemon-shutdown.ts
 var onDaemonShutdownEffect;
@@ -118538,7 +117637,6 @@ function createDaemonRuntime(deps) {
   let fileTreeSubscriptionHandle = null;
   let workspaceListSubscriptionHandle = null;
   let logObserverSubscriptionHandle = null;
-  let directHarnessWorkerHandle = null;
   let agenticQueryWorkerHandle = null;
   let enhancerWorkerHandle = null;
   let taskInboxHandle = null;
@@ -118578,7 +117676,6 @@ function createDaemonRuntime(deps) {
     workspaceListSubscriptionHandle?.stop();
     taskInboxHandle?.stop();
     logObserverSubscriptionHandle?.stop();
-    directHarnessWorkerHandle?.stop();
     agenticQueryWorkerHandle?.stop();
     enhancerWorkerHandle?.stop();
   };
@@ -118603,12 +117700,8 @@ function createDaemonRuntime(deps) {
     await deps.agentLifecycleOutbox?.stopAll().catch(() => {
       return;
     });
-    if (directHarnessWorkerHandle) {
-      await withTimeout2(directHarnessWorkerHandle.closeSessionsOnShutdown(), PROCESS_KILL_TIMEOUT_MS);
-    } else {
-      for (const handle of activeSessions.values()) {
-        await withTimeout2(handle.close(), CLOSE_TIMEOUT_MS);
-      }
+    for (const handle of activeSessions.values()) {
+      await withTimeout2(handle.close(), CLOSE_TIMEOUT_MS);
     }
     for (const harness of harnesses.values()) {
       await withTimeout2(harness.close(), CLOSE_TIMEOUT_MS);
@@ -118684,21 +117777,13 @@ function createDaemonRuntime(deps) {
     taskInboxHandle = yield* startTaskInboxEffect(deps.wsClient);
     logObserverSubscriptionHandle = startLogObserverSubscription({ sessionId: session2.sessionId, machineId: session2.machineId }, deps.wsClient);
     const commandRunRuntime = yield* exports_Effect.runtime();
-    if (featureFlags.directHarnessWorkers) {
-      directHarnessWorkerHandle = startDirectHarnessSubscriptions({
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        backend: session2.backend,
-        convexUrl: session2.convexUrl
-      }, activeSessions, harnesses);
-      agenticQueryWorkerHandle = startAgenticQuerySubscriptions({
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        backend: session2.backend,
-        convexUrl: session2.convexUrl
-      }, activeSessions, harnesses);
-      enhancerWorkerHandle = startEnhancerSubscriptions(session2.sessionId, session2.machineId, session2.convexUrl, deps.wsClient, session2.backend, session2.agentServices, getActiveLogSink());
-    }
+    agenticQueryWorkerHandle = startAgenticQuerySubscriptions({
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      backend: session2.backend,
+      convexUrl: session2.convexUrl
+    }, activeSessions, harnesses);
+    enhancerWorkerHandle = startEnhancerSubscriptions(session2.sessionId, session2.machineId, session2.convexUrl, deps.wsClient, session2.backend, session2.agentServices, getActiveLogSink());
     console.log(`
 Listening for commands...`);
     console.log(`Press Ctrl+C to stop
@@ -118725,14 +117810,12 @@ Listening for commands...`);
 }
 var PROCESS_KILL_TIMEOUT_MS = 6000, CLOSE_TIMEOUT_MS = 3000, SHUTDOWN_WATCHDOG_MS = 12000;
 var init_daemon_runtime = __esm(() => {
-  init_featureFlags();
   init_reliability();
   init_esm();
   init_start_subscriptions();
   init_command_dispatch();
   init_daemon_services();
   init_start_subscriptions2();
-  init_start_subscriptions3();
   init_file_content_subscription();
   init_file_tree_subscription();
   init_file_write_subscription();
@@ -118783,24 +117866,6 @@ function createCommandRouterDeps() {
 }
 var init_command_bridge = () => {};
 
-// src/daemon/domain/usecase/process-direct-harness-prompt.ts
-async function processDirectHarnessInbound(deps, event) {
-  await deps.dispatchInbound(event);
-}
-var init_process_direct_harness_prompt = () => {};
-
-// src/daemon/entry/bridge/direct-harness-bridge.ts
-function createDirectHarnessRouterDeps() {
-  return {
-    deliverInbound: async (event) => {
-      await processDirectHarnessInbound({ dispatchInbound: dispatchDirectHarnessInboundEvent }, event);
-    }
-  };
-}
-var init_direct_harness_bridge = __esm(() => {
-  init_process_direct_harness_prompt();
-});
-
 // src/daemon/domain/usecase/process-enhancer-job.ts
 async function processEnhancerJobInbound(deps, event) {
   await deps.dispatchInbound(event);
@@ -118882,7 +117947,6 @@ var init_workspace_git_bridge = () => {};
 // src/daemon/entry/default-router-deps.ts
 function createDefaultEventRouterDeps() {
   return {
-    directHarness: createDirectHarnessRouterDeps(),
     command: createCommandRouterDeps(),
     workspaceGit: createWorkspaceGitRouterDeps(),
     file: createFileRouterDeps(),
@@ -118893,7 +117957,6 @@ function createDefaultEventRouterDeps() {
 var init_default_router_deps = __esm(() => {
   init_agentic_query_bridge();
   init_command_bridge();
-  init_direct_harness_bridge();
   init_enhancer_bridge();
   init_file_bridge();
   init_workspace_git_bridge();
@@ -118932,24 +117995,6 @@ function createAssignedTaskStatusPublisher(deps) {
 }
 var init_assigned_task_status = () => {};
 
-// src/daemon/infrastructure/convex/publishers/capabilities.ts
-function createCapabilitiesPublisher(deps) {
-  const capabilitiesPublisher = new ConvexCapabilitiesPublisher({
-    backend: deps.backend,
-    sessionId: deps.sessionId
-  });
-  return {
-    async publish(event) {
-      if (event.type !== "capabilities.updated")
-        return;
-      await capabilitiesPublisher.publish(event.capabilities);
-    }
-  };
-}
-var init_capabilities = __esm(() => {
-  init_convex_capabilities_publisher();
-});
-
 // src/daemon/infrastructure/convex/publishers/command-result.ts
 function createCommandResultPublisher(deps) {
   return {
@@ -119067,77 +118112,6 @@ var init_models = __esm(() => {
   init_api3();
 });
 
-// src/daemon/infrastructure/convex/publishers/session-lifecycle.ts
-function createSessionLifecyclePublisher(deps) {
-  const sessionRepository = new ConvexSessionRepository({
-    backend: deps.backend,
-    sessionId: deps.sessionId
-  });
-  return {
-    async publish(event) {
-      if (event.type !== "session.lifecycle")
-        return;
-      const { harnessSessionId, action, opencodeSessionId, sessionTitle } = event;
-      switch (action) {
-        case "opened":
-          if (!opencodeSessionId || !sessionTitle)
-            return;
-          await sessionRepository.associateOpenCodeSessionId(harnessSessionId, opencodeSessionId, sessionTitle);
-          break;
-        case "resumed":
-          await sessionRepository.markActive(harnessSessionId);
-          break;
-        case "idle":
-          await sessionRepository.markIdle(harnessSessionId);
-          break;
-        case "closed":
-          await sessionRepository.markClosed(harnessSessionId);
-          break;
-        case "failed":
-          await sessionRepository.markFailed(harnessSessionId);
-          break;
-      }
-    }
-  };
-}
-var init_session_lifecycle = __esm(() => {
-  init_convex_session_repository();
-});
-
-// src/daemon/infrastructure/convex/publishers/turn-output.ts
-function createTurnOutputPublisher(deps) {
-  const outputRepository = new ConvexOutputRepository({
-    backend: deps.backend,
-    sessionId: deps.sessionId
-  });
-  const sessionRepository = new ConvexSessionRepository({
-    backend: deps.backend,
-    sessionId: deps.sessionId
-  });
-  return {
-    async publish(event) {
-      if (event.type === "turn.chunk") {
-        await outputRepository.appendChunks(event.harnessSessionId, [
-          {
-            content: event.content,
-            timestamp: event.timestamp,
-            messageId: event.messageId,
-            partType: event.partType === "text" || event.partType === "reasoning" ? event.partType : undefined
-          }
-        ]);
-        return;
-      }
-      if (event.type === "turn.completed") {
-        await sessionRepository.finalizeAssistantTurn(event.turnId);
-      }
-    }
-  };
-}
-var init_turn_output = __esm(() => {
-  init_convex_output_repository();
-  init_convex_session_repository();
-});
-
 // src/daemon/infrastructure/convex/publishers/workspace-commands.ts
 function createWorkspaceCommandsPublisher(deps) {
   return {
@@ -119161,11 +118135,8 @@ var init_workspace_commands = __esm(() => {
 function createConvexPublishers(deps) {
   return {
     heartbeat: createDaemonHeartbeatPublisher(deps),
-    turnOutput: createTurnOutputPublisher(deps),
-    sessionLifecycle: createSessionLifecyclePublisher(deps),
     assignedTaskStatus: createAssignedTaskStatusPublisher(deps),
     gitState: createGitStatePublisher(deps),
-    capabilities: createCapabilitiesPublisher(deps),
     models: createModelsPublisher(deps),
     harnessFingerprint: createHarnessFingerprintPublisher(deps),
     commandResult: createCommandResultPublisher(deps),
@@ -119176,17 +118147,10 @@ function routeConvexEvent(publishers, event) {
   switch (event.type) {
     case "heartbeat":
       return publishers.heartbeat.publish(event);
-    case "turn.chunk":
-    case "turn.completed":
-      return publishers.turnOutput.publish(event);
-    case "session.lifecycle":
-      return publishers.sessionLifecycle.publish(event);
     case "task.status":
       return publishers.assignedTaskStatus.publish(event);
     case "git.state":
       return publishers.gitState.publish(event);
-    case "capabilities.updated":
-      return publishers.capabilities.publish(event);
     case "models.updated":
       return publishers.models.publish(event);
     case "harness.fingerprint.updated":
@@ -119224,14 +118188,11 @@ function createPublisherRegistry(deps = {}) {
 }
 var init_publisher_registry = __esm(() => {
   init_assigned_task_status();
-  init_capabilities();
   init_command_result();
   init_daemon_heartbeat();
   init_git_state();
   init_harness_fingerprint();
   init_models();
-  init_session_lifecycle();
-  init_turn_output();
   init_workspace_commands();
 });
 
@@ -119293,13 +118254,6 @@ async function handleCommandInbound(deps, event) {
   }
 }
 
-// src/daemon/domain/usecase/handle-direct-harness-inbound.ts
-async function handleDirectHarnessInbound(deps, event) {
-  if (deps.deliverInbound) {
-    await deps.deliverInbound(event);
-  }
-}
-
 // src/daemon/domain/usecase/handle-enhancer-inbound.ts
 async function handleEnhancerInbound(deps, event) {
   if (deps.deliverInbound) {
@@ -119324,11 +118278,6 @@ async function handleWorkspaceGitInbound(deps, event) {
 // src/daemon/entry/event-router.ts
 async function routeInboundEvent(deps, event) {
   switch (event.type) {
-    case "direct-harness.session-opened":
-    case "direct-harness.prompt":
-    case "direct-harness.command":
-      await handleDirectHarnessInbound(deps.directHarness, event);
-      break;
     case "command.received":
     case "command-run.updated":
       await handleCommandInbound(deps.command, event);
@@ -119359,7 +118308,7 @@ var init_event_router = () => {};
 function startAgenticQueryPromptSubscriber(deps, onEvent) {
   let processing = false;
   const emittedThisDrain = new Set;
-  const drain2 = (batch) => {
+  const drain = (batch) => {
     if (!batch.messages?.length)
       return;
     const runIds = new Set(batch.messages.map((m) => m.runId));
@@ -119377,7 +118326,7 @@ function startAgenticQueryPromptSubscriber(deps, onEvent) {
       return;
     processing = true;
     try {
-      drain2(batch);
+      drain(batch);
     } finally {
       processing = false;
       emittedThisDrain.clear();
@@ -119457,106 +118406,6 @@ var init_command_run = __esm(() => {
   init_api3();
 });
 
-// src/daemon/infrastructure/convex/subscribers/direct-harness-command.ts
-function startDirectHarnessCommandSubscriber(deps, onEvent) {
-  const seen = new Set;
-  let processing = false;
-  const drain2 = async () => {
-    const pending3 = await deps.wsClient.query(api.daemon.directHarness.commands.listPendingCommands, { sessionId: deps.sessionId, machineId: deps.machineId });
-    if (!pending3?.length)
-      return;
-    for (const cmd of pending3) {
-      if (seen.has(cmd._id))
-        continue;
-      seen.add(cmd._id);
-      onEvent({ type: "direct-harness.command", commandId: cmd._id });
-    }
-  };
-  const unsub = deps.wsClient.onUpdate(api.daemon.directHarness.commands.listPendingCommands, { sessionId: deps.sessionId, machineId: deps.machineId }, () => {
-    if (processing)
-      return;
-    processing = true;
-    drain2().catch((err) => console.warn(`[daemon] direct-harness-command drain error: ${err instanceof Error ? err.message : String(err)}`)).finally(() => {
-      processing = false;
-    });
-  }, (err) => {
-    console.warn(`[daemon] direct-harness-command subscriber error: ${err instanceof Error ? err.message : String(err)}`);
-  });
-  return {
-    async stop() {
-      unsub();
-    }
-  };
-}
-var init_direct_harness_command = __esm(() => {
-  init_api3();
-});
-
-// src/daemon/infrastructure/convex/subscribers/direct-harness-prompt.ts
-function startDirectHarnessPromptSubscriber(deps, onEvent) {
-  let processing = false;
-  const emittedForDrain = new Set;
-  const drain2 = async () => {
-    const pending3 = await deps.wsClient.query(api.daemon.directHarness.messages.pendingForMachine, { sessionId: deps.sessionId, machineId: deps.machineId });
-    if (!pending3?.messages.length)
-      return;
-    const sessionIds = new Set(pending3.messages.map((m) => m.harnessSessionId));
-    for (const harnessSessionId of sessionIds) {
-      if (emittedForDrain.has(harnessSessionId))
-        continue;
-      emittedForDrain.add(harnessSessionId);
-      onEvent({ type: "direct-harness.prompt", harnessSessionId });
-    }
-  };
-  const unsub = deps.wsClient.onUpdate(api.daemon.directHarness.messages.pendingForMachine, { sessionId: deps.sessionId, machineId: deps.machineId }, () => {
-    if (processing)
-      return;
-    processing = true;
-    drain2().catch((err) => console.warn(`[daemon] direct-harness-prompt drain error: ${err instanceof Error ? err.message : String(err)}`)).finally(() => {
-      processing = false;
-      emittedForDrain.clear();
-    });
-  }, (err) => {
-    console.warn(`[daemon] direct-harness-prompt subscriber error: ${err instanceof Error ? err.message : String(err)}`);
-  });
-  return {
-    async stop() {
-      unsub();
-    }
-  };
-}
-var init_direct_harness_prompt = __esm(() => {
-  init_api3();
-});
-
-// src/daemon/infrastructure/convex/subscribers/direct-harness-session.ts
-function startDirectHarnessSessionSubscriber(deps, onEvent) {
-  const seen = new Set;
-  const unsub = deps.wsClient.onUpdate(api.daemon.directHarness.sessions.listPendingSessionsForMachine, { sessionId: deps.sessionId, machineId: deps.machineId }, (pendingSessions) => {
-    if (!pendingSessions?.length)
-      return;
-    for (const session2 of pendingSessions) {
-      if (seen.has(session2._id))
-        continue;
-      seen.add(session2._id);
-      onEvent({
-        type: "direct-harness.session-opened",
-        harnessSessionId: session2._id
-      });
-    }
-  }, (err) => {
-    console.warn(`[daemon] direct-harness-session subscriber error: ${err instanceof Error ? err.message : String(err)}`);
-  });
-  return {
-    async stop() {
-      unsub();
-    }
-  };
-}
-var init_direct_harness_session = __esm(() => {
-  init_api3();
-});
-
 // src/daemon/infrastructure/convex/subscribers/enhancer-job.ts
 function startEnhancerJobSubscriber2(deps, onEvent) {
   const seen = new Set;
@@ -119775,7 +118624,7 @@ function startMachineCommandInboxSubscriber(deps, onClaimed) {
   let queued = false;
   let stopped = false;
   const args2 = { sessionId: deps.sessionId, machineId: deps.machineId };
-  const drain2 = async () => {
+  const drain = async () => {
     if (stopped || draining) {
       queued = true;
       return;
@@ -119794,9 +118643,9 @@ function startMachineCommandInboxSubscriber(deps, onClaimed) {
   };
   const unsub = deps.wsClient.onUpdate(api.daemon.machineCommandInbox.watchNext, args2, (result) => {
     if (result?.commandId)
-      drain2();
+      drain();
   }, (err) => console.warn(`[daemon] machine-command-inbox watch error: ${String(err)}`));
-  drain2();
+  drain();
   return {
     async stop() {
       stopped = true;
@@ -119813,9 +118662,6 @@ function startAllSubscribers(deps) {
   const onEvent = (event) => {
     routeInboundEvent(deps.router, event);
   };
-  const session2 = startDirectHarnessSessionSubscriber(deps, onEvent);
-  const prompt = startDirectHarnessPromptSubscriber(deps, onEvent);
-  const directHarnessCommand = startDirectHarnessCommandSubscriber(deps, onEvent);
   const machineCommands = startMachineCommandInboxSubscriber(deps, async (claimed) => {
     await dispatchCommandInboundEvent({
       type: "command.received",
@@ -119835,9 +118681,6 @@ function startAllSubscribers(deps) {
   return {
     async stopAll() {
       await Promise.all([
-        session2.stop(),
-        prompt.stop(),
-        directHarnessCommand.stop(),
         machineCommands.stop(),
         commandRun.stop(),
         gitRequest.stop(),
@@ -119857,9 +118700,6 @@ var init_subscriber_registry = __esm(() => {
   init_agentic_query_prompt();
   init_agentic_query_session();
   init_command_run();
-  init_direct_harness_command();
-  init_direct_harness_prompt();
-  init_direct_harness_session();
   init_enhancer_job();
   init_file_content_request();
   init_file_tree_release_request();
@@ -122941,9 +121781,9 @@ var require_event_target2 = __commonJS((exports, module) => {
   }
   Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
   var EventTarget = {
-    addEventListener(type, handler7, options = {}) {
+    addEventListener(type, handler6, options = {}) {
       for (const listener of this.listeners(type)) {
-        if (!options[kForOnEventAttribute] && listener[kListener] === handler7 && !listener[kForOnEventAttribute]) {
+        if (!options[kForOnEventAttribute] && listener[kListener] === handler6 && !listener[kForOnEventAttribute]) {
           return;
         }
       }
@@ -122954,7 +121794,7 @@ var require_event_target2 = __commonJS((exports, module) => {
             data: isBinary ? data : data.toString()
           });
           event[kTarget] = this;
-          callListener(handler7, this, event);
+          callListener(handler6, this, event);
         };
       } else if (type === "close") {
         wrapper = function onClose(code2, message) {
@@ -122964,7 +121804,7 @@ var require_event_target2 = __commonJS((exports, module) => {
             wasClean: this._closeFrameReceived && this._closeFrameSent
           });
           event[kTarget] = this;
-          callListener(handler7, this, event);
+          callListener(handler6, this, event);
         };
       } else if (type === "error") {
         wrapper = function onError3(error51) {
@@ -122973,28 +121813,28 @@ var require_event_target2 = __commonJS((exports, module) => {
             message: error51.message
           });
           event[kTarget] = this;
-          callListener(handler7, this, event);
+          callListener(handler6, this, event);
         };
       } else if (type === "open") {
         wrapper = function onOpen() {
           const event = new Event2("open");
           event[kTarget] = this;
-          callListener(handler7, this, event);
+          callListener(handler6, this, event);
         };
       } else {
         return;
       }
       wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
-      wrapper[kListener] = handler7;
+      wrapper[kListener] = handler6;
       if (options.once) {
         this.once(type, wrapper);
       } else {
         this.on(type, wrapper);
       }
     },
-    removeEventListener(type, handler7) {
+    removeEventListener(type, handler6) {
       for (const listener of this.listeners(type)) {
-        if (listener[kListener] === handler7 && !listener[kForOnEventAttribute]) {
+        if (listener[kListener] === handler6 && !listener[kForOnEventAttribute]) {
           this.removeListener(type, listener);
           break;
         }
@@ -123523,16 +122363,16 @@ var require_websocket2 = __commonJS((exports, module) => {
         }
         return null;
       },
-      set(handler7) {
+      set(handler6) {
         for (const listener of this.listeners(method)) {
           if (listener[kForOnEventAttribute]) {
             this.removeListener(method, listener);
             break;
           }
         }
-        if (typeof handler7 !== "function")
+        if (typeof handler6 !== "function")
           return;
-        this.addEventListener(method, handler7, {
+        this.addEventListener(method, handler6, {
           [kForOnEventAttribute]: true
         });
       }
@@ -134571,8 +133411,8 @@ import * as os2 from "os";
 import * as path8 from "path";
 async function isChatroomInstalledDefault() {
   try {
-    const { execSync: execSync3 } = await import("child_process");
-    execSync3("chatroom --version", { stdio: "pipe" });
+    const { execSync: execSync2 } = await import("child_process");
+    execSync2("chatroom --version", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -135626,4 +134466,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=2AE77EB9BC17ACF764756E2164756E21
+//# debugId=471FD0F14F27D83064756E2164756E21