chatroom-cli 1.68.5 → 1.69.1

package/dist/index.js

@@ -2168,7 +2168,8 @@ __export(exports_stdin_heredoc, {
   HANDOFF_STDIN_DELIMITER: () => HANDOFF_STDIN_DELIMITER,
   HANDOFF_MESSAGE_MARKER: () => HANDOFF_MESSAGE_MARKER,
   CONTEXT_STDIN_DELIMITER: () => CONTEXT_STDIN_DELIMITER,
-  BACKLOG_STDIN_DELIMITER: () => BACKLOG_STDIN_DELIMITER
+  BACKLOG_STDIN_DELIMITER: () => BACKLOG_STDIN_DELIMITER,
+  AGENTIC_QUERY_STDIN_DELIMITER: () => AGENTIC_QUERY_STDIN_DELIMITER
 });
 function formatStdinHeredocCommand(commandPrefix, delimiter, placeholder, options) {
   const marker = options?.messageMarker;
@@ -2204,16 +2205,18 @@ function findReservedDelimiterLines(content) {
   }
   return hits;
 }
-var HANDOFF_STDIN_DELIMITER = "CHATROOM_HANDOFF_END", CONTEXT_STDIN_DELIMITER = "CHATROOM_CONTEXT_END", BACKLOG_STDIN_DELIMITER = "CHATROOM_BACKLOG_END", CLASSIFY_STDIN_DELIMITER = "CHATROOM_CLASSIFY_END", HANDOFF_MESSAGE_MARKER = "---MESSAGE---", RESERVED_STDIN_HEREDOC_DELIMITERS, RESERVED_STRUCTURED_PARAM_MARKERS;
+var HANDOFF_STDIN_DELIMITER = "CHATROOM_HANDOFF_END", CONTEXT_STDIN_DELIMITER = "CHATROOM_CONTEXT_END", BACKLOG_STDIN_DELIMITER = "CHATROOM_BACKLOG_END", AGENTIC_QUERY_STDIN_DELIMITER = "CHATROOM_AGENTIC_QUERY_END", CLASSIFY_STDIN_DELIMITER = "CHATROOM_CLASSIFY_END", HANDOFF_MESSAGE_MARKER = "---MESSAGE---", RESERVED_STDIN_HEREDOC_DELIMITERS, RESERVED_STRUCTURED_PARAM_MARKERS;
 var init_stdin_heredoc = __esm(() => {
   RESERVED_STDIN_HEREDOC_DELIMITERS = [
     HANDOFF_STDIN_DELIMITER,
     CONTEXT_STDIN_DELIMITER,
     BACKLOG_STDIN_DELIMITER,
+    AGENTIC_QUERY_STDIN_DELIMITER,
     CLASSIFY_STDIN_DELIMITER
   ];
   RESERVED_STRUCTURED_PARAM_MARKERS = [
     HANDOFF_MESSAGE_MARKER,
+    "---RESULT---",
     "---TITLE---",
     "---DESCRIPTION---",
     "---TECH_SPECS---"
@@ -29916,6 +29919,22 @@ var init_commandcode = __esm(() => {
   init_command_code_agent_service();
 });
 
+// src/infrastructure/services/remote-agents/tap-process-stream-writes.ts
+function tapProcessStreamWrites(onWrite) {
+  const stdoutOriginal = process.stdout.write.bind(process.stdout);
+  const stderrOriginal = process.stderr.write.bind(process.stderr);
+  const wrap = (original) => (...args2) => {
+    onWrite();
+    return original(...args2);
+  };
+  process.stdout.write = wrap(stdoutOriginal);
+  process.stderr.write = wrap(stderrOriginal);
+  return () => {
+    process.stdout.write = stdoutOriginal;
+    process.stderr.write = stderrOriginal;
+  };
+}
+
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-models.ts
 function resolveCursorSdkModel(model) {
   const prefix = `${CURSOR_PROVIDER2}/`;
@@ -30505,56 +30524,66 @@ ${deferredResume}` : deferredResume;
                   isFirstTurn = true;
                 }
               }
-              const run3 = await withTimeout(agent.send(nextPrompt, {
-                local: { force: isFirstTurn },
-                idempotencyKey: randomUUID2()
-              }), SEND_TIMEOUT_MS, "agent.send");
-              session2.run = run3;
-              isFirstTurn = false;
-              const adapter = new CursorSdkStreamAdapter(logPrefix, emitLogLine);
-              wireNativeStreamAdapter({
-                adapter,
-                assistantTextCallbacks,
-                outputCallbacks,
-                agentEndCallbacks,
-                entry
-              });
+              const notifyHarnessOutput = () => {
+                entry.lastOutputAt = Date.now();
+                for (const cb of outputCallbacks)
+                  cb();
+              };
+              const restoreStreamTap = tapProcessStreamWrites(notifyHarnessOutput);
               try {
-                for await (const message of run3.stream()) {
-                  if (session2.aborted)
-                    break;
-                  adapter.handleMessage(message);
+                const run3 = await withTimeout(agent.send(nextPrompt, {
+                  local: { force: isFirstTurn },
+                  idempotencyKey: randomUUID2()
+                }), SEND_TIMEOUT_MS, "agent.send");
+                session2.run = run3;
+                isFirstTurn = false;
+                const adapter = new CursorSdkStreamAdapter(logPrefix, emitLogLine);
+                wireNativeStreamAdapter({
+                  adapter,
+                  assistantTextCallbacks,
+                  outputCallbacks,
+                  agentEndCallbacks,
+                  entry
+                });
+                try {
+                  for await (const message of run3.stream()) {
+                    if (session2.aborted)
+                      break;
+                    adapter.handleMessage(message);
+                  }
+                } catch (streamErr) {
+                  exitCode = 1;
+                  writeSpawnError2(logPrefix, streamErr, emitLogLine);
+                  break;
                 }
-              } catch (streamErr) {
-                exitCode = 1;
-                writeSpawnError2(logPrefix, streamErr, emitLogLine);
-                break;
-              }
-              if (session2.aborted) {
-                exitCode = 1;
-                exitSignal = "SIGTERM";
-                break;
-              }
-              let result;
-              try {
-                result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS, "run.wait");
-              } catch (waitErr) {
-                exitCode = 1;
-                writeSpawnError2(logPrefix, waitErr, emitLogLine);
-                break;
-              }
-              adapter.flushPendingOutput();
-              if (result.status === "error") {
-                exitCode = 2;
-                const detail = typeof result.result === "string" && result.result.trim().length > 0 ? result.result.trim() : `no error detail from SDK (run ${result.id})`;
-                const runErrorLine = formatAgentLogLine(logPrefix, "run-error", `run ${result.id} failed: ${detail}`);
-                process.stderr.write(`${runErrorLine}
+                if (session2.aborted) {
+                  exitCode = 1;
+                  exitSignal = "SIGTERM";
+                  break;
+                }
+                let result;
+                try {
+                  result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS, "run.wait");
+                } catch (waitErr) {
+                  exitCode = 1;
+                  writeSpawnError2(logPrefix, waitErr, emitLogLine);
+                  break;
+                }
+                adapter.flushPendingOutput();
+                if (result.status === "error") {
+                  exitCode = 2;
+                  const detail = typeof result.result === "string" && result.result.trim().length > 0 ? result.result.trim() : `no error detail from SDK (run ${result.id})`;
+                  const runErrorLine = formatAgentLogLine(logPrefix, "run-error", `run ${result.id} failed: ${detail}`);
+                  process.stderr.write(`${runErrorLine}
 `);
-                emitLogLine(runErrorLine);
-                break;
+                  emitLogLine(runErrorLine);
+                  break;
+                }
+                adapter.finish();
+                nextPrompt = null;
+              } finally {
+                restoreStreamTap();
               }
-              adapter.finish();
-              nextPrompt = null;
             } catch (turnErr) {
               exitCode = 1;
               writeSpawnError2(logPrefix, turnErr, emitLogLine);
@@ -78962,6 +78991,83 @@ var init_handoff = __esm(() => {
   init_error_formatting();
 });
 
+// src/commands/agentic-query/complete.ts
+var exports_complete = {};
+__export(exports_complete, {
+  agenticQueryComplete: () => agenticQueryComplete
+});
+async function createDefaultDeps9() {
+  const client4 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
+      query: (endpoint, args2) => client4.query(endpoint, args2)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+function handleCompleteError(err) {
+  return exports_Effect.sync(() => {
+    if (err._tag === "NotAuthenticated") {
+      formatAuthError(err.convexUrl, err.otherUrls);
+      process.exit(1);
+    }
+    if (err._tag === "InvalidChatroomId") {
+      formatChatroomIdError(err.id);
+      process.exit(1);
+    }
+    console.error(`
+❌ ERROR: Agentic query complete failed`);
+    console.error(`
+${err.errorData?.message ?? err.cause.message}`);
+    process.exit(1);
+  });
+}
+async function agenticQueryComplete(chatroomId, options) {
+  const deps = await createDefaultDeps9();
+  await exports_Effect.runPromise(agenticQueryCompleteEffect(chatroomId, options).pipe(exports_Effect.provide(commandServicesLayerFromDeps(deps)), exports_Effect.catchAll(handleCompleteError)));
+}
+var agenticQueryCompleteEffect = (chatroomId, options) => exports_Effect.gen(function* () {
+  const backend2 = yield* BackendService;
+  const sessionId = yield* requireSessionIdEffect((a) => ({
+    _tag: "NotAuthenticated",
+    convexUrl: a.convexUrl,
+    otherUrls: a.otherUrls
+  }));
+  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
+    _tag: "InvalidChatroomId",
+    id: id3
+  }));
+  yield* backend2.mutation(api.web.agenticQuery.index.complete, {
+    sessionId,
+    chatroomId,
+    queryId: options.queryId,
+    result: options.result
+  }).pipe(exports_Effect.mapError((cause3) => {
+    let errorData;
+    if (cause3 instanceof ConvexError) {
+      errorData = cause3.data;
+    }
+    return { _tag: "CompleteFailed", cause: cause3, errorData };
+  }));
+  yield* exports_Effect.sync(() => {
+    console.log(`✅ Agentic query ${options.queryId} completed`);
+  });
+});
+var init_complete = __esm(() => {
+  init_values();
+  init_esm();
+  init_api3();
+  init_storage();
+  init_client2();
+  init_services();
+  init_error_formatting();
+});
+
 // src/commands/backlog/backlog-fs-service.ts
 import * as nodeFs from "node:fs/promises";
 var BacklogFsService, BacklogFsServiceLive, BacklogFsServiceFrom = (ops) => exports_Layer.succeed(BacklogFsService, {
@@ -79068,7 +79174,7 @@ function buildBaseLayer(d) {
 function buildFsLayer(fs11) {
   return fs11 ? BacklogFsServiceFrom(fs11) : BacklogFsServiceLive;
 }
-async function createDefaultDeps9() {
+async function createDefaultDeps10() {
   const client4 = await getConvexClient();
   const fs11 = await import("node:fs/promises");
   return {
@@ -79124,47 +79230,47 @@ function computeContentHash(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 async function listBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(listBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function addBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(addBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function completeBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(completeBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function reopenBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(reopenBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function patchBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(patchBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function scoreBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(scoreBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function markForReviewBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(markForReviewBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function historyBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(historyBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function updateBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(updateBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function closeBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   await exports_Effect.runPromise(closeBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function exportBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   if (!d.fs) {
     console.error("❌ File system operations not available");
     process.exit(1);
@@ -79173,7 +79279,7 @@ async function exportBacklog(chatroomId, options, deps) {
   await exports_Effect.runPromise(exportBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(exports_Layer.merge(buildBaseLayer(d), buildFsLayer(d.fs)))));
 }
 async function importBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps9();
+  const d = deps ?? await createDefaultDeps10();
   if (!d.fs) {
     console.error("❌ File system operations not available");
     process.exit(1);
@@ -79934,7 +80040,7 @@ __export(exports_read, {
   taskReadEffect: () => taskReadEffect,
   taskRead: () => taskRead
 });
-async function createDefaultDeps10() {
+async function createDefaultDeps11() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -79976,7 +80082,7 @@ function handleTaskReadError(err) {
   });
 }
 async function taskRead(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(taskReadEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleTaskReadError(err)), exports_Effect.provide(layer)));
 }
@@ -80067,7 +80173,7 @@ __export(exports_skill, {
   activateSkillEffect: () => activateSkillEffect,
   activateSkill: () => activateSkill
 });
-async function createDefaultDeps11() {
+async function createDefaultDeps12() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80136,12 +80242,12 @@ function handleActivateSkillError(err) {
   });
 }
 async function listSkills(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps12();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listSkillsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleListSkillsError(err)), exports_Effect.provide(layer)));
 }
 async function activateSkill(chatroomId, skillId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps12();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(activateSkillEffect(chatroomId, skillId, options).pipe(exports_Effect.catchAll((err) => handleActivateSkillError(err)), exports_Effect.provide(layer)));
 }
@@ -80219,7 +80325,7 @@ __export(exports_messages, {
   listBySenderRoleEffect: () => listBySenderRoleEffect,
   listBySenderRole: () => listBySenderRole
 });
-async function createDefaultDeps12() {
+async function createDefaultDeps13() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80280,12 +80386,12 @@ function handleMessagesError(err) {
   });
 }
 async function listBySenderRole(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps12();
+  const d = deps ?? await createDefaultDeps13();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listBySenderRoleEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleMessagesError(err)), exports_Effect.provide(layer)));
 }
 async function listSinceMessage(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps12();
+  const d = deps ?? await createDefaultDeps13();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listSinceMessageEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleMessagesError(err)), exports_Effect.provide(layer)));
 }
@@ -80415,7 +80521,7 @@ __export(exports_context2, {
   inspectContextEffect: () => inspectContextEffect,
   inspectContext: () => inspectContext
 });
-async function createDefaultDeps13() {
+async function createDefaultDeps14() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80456,17 +80562,17 @@ function handleContextError(err) {
   });
 }
 async function readContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps14();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(readContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
 async function newContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps14();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(newContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
 async function listContexts(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps14();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listContextsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
@@ -80474,7 +80580,7 @@ function viewTemplate() {
   return getContextViewTemplate();
 }
 async function inspectContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps14();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(inspectContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
@@ -80715,7 +80821,7 @@ __export(exports_guidelines, {
   listGuidelineTypesEffect: () => listGuidelineTypesEffect,
   listGuidelineTypes: () => listGuidelineTypes
 });
-async function createDefaultDeps14() {
+async function createDefaultDeps15() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80756,12 +80862,12 @@ function handleListGuidelineTypesError(err) {
   });
 }
 async function viewGuidelines(options, deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps15();
   const layer = layerFromDeps7(d);
   await exports_Effect.runPromise(viewGuidelinesEffect(options).pipe(exports_Effect.catchAll((err) => handleViewGuidelinesError(err)), exports_Effect.provide(layer)));
 }
 async function listGuidelineTypes(deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps15();
   const layer = layerFromDeps7(d);
   await exports_Effect.runPromise(listGuidelineTypesEffect().pipe(exports_Effect.catchAll((err) => handleListGuidelineTypesError(err)), exports_Effect.provide(layer)));
 }
@@ -80831,7 +80937,7 @@ __export(exports_artifact, {
   createArtifactEffect: () => createArtifactEffect,
   createArtifact: () => createArtifact
 });
-async function createDefaultDeps15() {
+async function createDefaultDeps16() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80853,19 +80959,19 @@ function handleArtifactError(err) {
   });
 }
 async function createArtifact(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps16();
   const layer = commandServicesLayerFromDeps(d);
   return exports_Effect.runPromise(createArtifactEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err).pipe(exports_Effect.map(() => {
     return;
   }))), exports_Effect.provide(layer)));
 }
 async function viewArtifact(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps16();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(viewArtifactEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err)), exports_Effect.provide(layer)));
 }
 async function viewManyArtifacts(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps16();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(viewManyArtifactsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err)), exports_Effect.provide(layer)));
 }
@@ -81215,7 +81321,7 @@ __export(exports_telegram, {
   sendMessageEffect: () => sendMessageEffect,
   sendMessage: () => sendMessage
 });
-async function createDefaultDeps16() {
+async function createDefaultDeps17() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -81297,7 +81403,7 @@ ${err.cause.message}`);
   });
 }
 async function sendMessage(options, deps) {
-  const d = deps ?? await createDefaultDeps16();
+  const d = deps ?? await createDefaultDeps17();
   const layer = layerFromDeps8(d);
   await exports_Effect.runPromise(sendMessageEffect(options).pipe(exports_Effect.catchAll((err) => handleSendMessageError(err)), exports_Effect.provide(layer)));
 }
@@ -99216,7 +99322,7 @@ function harnessEventSessionId(event) {
 
 class OpencodeSdkHarness {
   type = "opencode-sdk";
-  displayName = "Opencode";
+  displayName = "OpenCode (SDK)";
   client;
   childProcess;
   cwd;
@@ -100299,6 +100405,24 @@ var init_opencode_session_events = __esm(() => {
   ];
 });
 
+// src/commands/machine/daemon-start/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/commands/machine/daemon-start/direct-harness/prompt-subscriber.ts
 function startMessageSubscriber(session2, wsClient2, deps) {
   let processing = false;
@@ -100393,22 +100517,15 @@ function wireResumedSessionEvents(handle, deps, info) {
     agent: info.lastUsedConfig.agent ?? "build",
     model: info.lastUsedConfig.model
   };
-  let lastBoundKey = null;
+  const bindTurnMessage = bindTurnMessageOnEvent(handle, deps.sessionRepository, "direct-harness");
   handle.session.onEvent((event) => {
-    const turn = handle.currentTurn;
-    if (turn?.messageId !== null && turn?.messageId !== undefined) {
-      const key = `${turn.turnId}:${turn.messageId}`;
-      if (key !== lastBoundKey) {
-        lastBoundKey = key;
-        deps.sessionRepository.bindTurnMessageId(turn.turnId, turn.messageId).catch((err) => console.warn("[direct-harness] bindTurnMessageId error (resume):", err));
-      }
-    }
+    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) {
+async function deliverPendingMessages(handle, deps, rowId, messages, info, _daemonSession) {
   for (const msg of messages) {
     const override = info?.lastUsedConfig ?? { agent: "build" };
     try {
@@ -100449,7 +100566,7 @@ async function processSessionMessages(session2, deps, rowId, messages, info) {
     await deps.sessionRepository.markActive(rowId).catch(() => {});
     wireResumedSessionEvents(handle, deps, info);
   }
-  await deliverPendingMessages(handle, deps, rowId, messages, info);
+  await deliverPendingMessages(handle, deps, rowId, messages, info, session2);
 }
 var init_prompt_subscriber = __esm(() => {
   init_idle_handler();
@@ -100459,122 +100576,64 @@ var init_prompt_subscriber = __esm(() => {
   init_opencode_session_events();
 });
 
-// src/commands/machine/daemon-start/direct-harness/session-subscriber.ts
-function startSessionSubscriber(daemonSession, wsClient2, deps) {
-  const inFlight = new Set;
-  const unsub = wsClient2.onUpdate(api.daemon.directHarness.sessions.listPendingSessionsForMachine, {
-    sessionId: daemonSession.sessionId,
-    machineId: daemonSession.machineId
-  }, (pendingSessions) => {
-    if (!pendingSessions || pendingSessions.length === 0)
-      return;
-    for (const session2 of pendingSessions) {
-      const rowId = session2._id;
-      if (inFlight.has(rowId))
-        continue;
-      inFlight.add(rowId);
-      processOne(daemonSession, deps, session2).finally(() => inFlight.delete(rowId));
-    }
-  }, (err) => {
-    console.warn("[direct-harness] Session subscription error:", err instanceof Error ? err.message : String(err));
-  });
-  return { stop: unsub };
-}
-async function getOrCreateHarness(daemonSession, deps, session2, workspace) {
-  const harnessName = session2.opencode?.harnessName ?? "opencode-sdk";
-  const key = makeHarnessKey(session2.workspaceId, harnessName);
-  let harness = deps.harnesses.get(key);
+// src/commands/machine/daemon-start/shared-harness/get-or-create-bound-harness.ts
+async function getOrCreateBoundHarness(params) {
+  const { harnesses, workspaceId, harnessName, workingDir, convexUrl, logPrefix } = params;
+  const key = makeHarnessKey(workspaceId, harnessName);
+  let harness = harnesses.get(key);
   if (harness && !harness.isAlive()) {
-    console.warn(`[direct-harness] Harness ${harnessName} for workspace ${session2.workspaceId} is no longer alive — restarting`);
+    console.warn(`${logPrefix} Harness ${harnessName} for workspace ${workspaceId} is no longer alive — restarting`);
     harness.close().catch(() => {});
-    deps.harnesses.delete(key);
+    harnesses.delete(key);
     harness = undefined;
   }
   if (!harness) {
     harness = await startBoundHarness({
       harnessName,
-      workingDir: workspace.workingDir,
-      workspaceId: session2.workspaceId,
-      resolvedConvexUrl: daemonSession.convexUrl
+      workingDir,
+      workspaceId,
+      resolvedConvexUrl: convexUrl
     });
-    deps.harnesses.set(key, harness);
+    harnesses.set(key, harness);
   }
   return harness;
 }
-function recordLiveSessionChunk(event, handle, journal, extractChunk, deps) {
-  const chunk2 = extractChunk(event);
-  if (chunk2 === null) {
-    return;
-  }
-  journal.record({
-    content: chunk2.content,
-    timestamp: Date.now(),
-    messageId: chunk2.messageId,
-    partType: chunk2.partType
-  });
-  if (handle.currentTurn && handle.currentTurn.messageId === null) {
-    handle.currentTurn.messageId = chunk2.messageId;
-    deps.sessionRepository.bindTurnMessageId(handle.currentTurn.turnId, chunk2.messageId).catch((err) => console.warn("[direct-harness] bindTurnMessageId error:", err));
-  }
-}
-function handleLiveSessionProviderId(event, deps, rowId, handle, liveSession) {
-  if (event.type !== "session.provider_id")
-    return;
-  const sessionId = event.payload.sessionId;
-  if (!sessionId || sessionId === handle.opencodeSessionId)
-    return;
-  deps.sessionRepository.associateOpenCodeSessionId(rowId, sessionId, liveSession.sessionTitle ?? "").catch((err) => console.warn("[direct-harness] associateOpenCodeSessionId (provider id) error:", err));
-}
-function handleLiveSessionTitleUpdate(event, deps, rowId, liveSession) {
-  if (!isOpenCodeSessionEventType(event.type))
-    return;
-  if (event.type !== "session.updated") {
-    return;
-  }
-  const info = event.payload.info;
-  const newTitle = info?.title;
-  if (!newTitle || newTitle === liveSession.sessionTitle) {
-    return;
-  }
-  liveSession.setTitle?.(newTitle);
-  deps.sessionRepository.updateSessionTitle(rowId, newTitle).catch((err) => console.warn("[direct-harness] updateSessionTitle error:", err));
-}
-function handleLiveSessionEvent(event, ctx) {
-  const { handle, journal, extractChunk, idleConfig, deps, rowId, liveSession } = ctx;
-  recordLiveSessionChunk(event, handle, journal, extractChunk, deps);
-  if (event.type === "session.idle") {
-    handleSessionIdle(handle, journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[direct-harness] idle handler error:", err));
-  }
-  handleLiveSessionTitleUpdate(event, deps, rowId, liveSession);
-  handleLiveSessionProviderId(event, deps, rowId, handle, liveSession);
-}
-async function processOne(daemonSession, deps, session2) {
-  const rowId = session2._id;
+var init_get_or_create_bound_harness = __esm(() => {
+  init_registry4();
+});
+
+// src/commands/machine/daemon-start/shared-harness/open-pending-session.ts
+async function openPendingHarnessSession(daemonSession, deps, input, options) {
+  const { rowId, workspaceId, harnessName, lastUsedConfig } = input;
+  const { logPrefix, handleProviderIdEvents } = options;
   try {
     const workspace = await daemonSession.backend.query(api.workspaces.getWorkspaceById, {
       sessionId: daemonSession.sessionId,
-      workspaceId: session2.workspaceId
+      workspaceId
     });
     if (!workspace) {
-      console.warn(`[direct-harness] Cannot open session ${rowId}: workspace ${session2.workspaceId} not found`);
+      console.warn(`${logPrefix} Workspace ${workspaceId} not found for session ${rowId}`);
       await deps.sessionRepository.markFailed(rowId);
       return;
     }
-    const harnessName = session2.opencode?.harnessName ?? "opencode-sdk";
-    const harness = await getOrCreateHarness(daemonSession, deps, session2, workspace);
-    const modelConfig = session2.opencode?.lastUsedConfig.model;
+    const harness = await getOrCreateBoundHarness({
+      harnesses: deps.harnesses,
+      workspaceId,
+      harnessName,
+      workingDir: workspace.workingDir,
+      convexUrl: daemonSession.convexUrl,
+      logPrefix
+    });
+    const modelConfig = lastUsedConfig.model;
     const model = modelConfig ? `${modelConfig.providerID}/${modelConfig.modelID}` : undefined;
     const liveSession = await harness.newSession({
-      agent: session2.opencode?.lastUsedConfig.agent ?? "build",
+      agent: lastUsedConfig.agent,
       model,
       harnessSessionId: rowId
     });
     const journal = deps.journalFactory.create(rowId);
     const extractChunk = createChunkExtractor(harness.type);
-    const idleConfig = {
-      agent: session2.opencode?.lastUsedConfig.agent ?? "build",
-      model: session2.opencode?.lastUsedConfig.model
-    };
+    const idleConfig = { agent: lastUsedConfig.agent, model: lastUsedConfig.model };
     let unsubscribeEvents = () => {};
     let closed = false;
     const close2 = async () => {
@@ -100591,22 +100650,41 @@ async function processOne(daemonSession, deps, session2) {
       harnessSessionId: rowId,
       harnessName,
       opencodeSessionId: liveSession.opencodeSessionId,
-      workspaceId: session2.workspaceId,
+      workspaceId,
       session: liveSession,
       journal,
       currentTurn: null,
       close: close2
     };
     unsubscribeEvents = liveSession.onEvent((event) => {
-      handleLiveSessionEvent(event, {
-        handle,
-        journal,
-        extractChunk,
-        idleConfig,
-        deps,
-        rowId,
-        liveSession
-      });
+      const chunk2 = extractChunk(event);
+      if (chunk2 !== null) {
+        journal.record({
+          content: chunk2.content,
+          timestamp: Date.now(),
+          messageId: chunk2.messageId,
+          partType: chunk2.partType
+        });
+        if (handle.currentTurn && handle.currentTurn.messageId === null) {
+          handle.currentTurn.messageId = chunk2.messageId;
+          deps.sessionRepository.bindTurnMessageId(handle.currentTurn.turnId, chunk2.messageId).catch((err) => console.warn(`${logPrefix} bindTurnMessageId error:`, err));
+        }
+      }
+      if (event.type === "session.idle") {
+        handleSessionIdle(handle, journal, idleConfig, deps.sessionRepository).catch((err) => console.warn(`${logPrefix} idle handler error:`, err));
+      }
+      if (isOpenCodeSessionEventType(event.type) && event.type === "session.updated") {
+        const info = event.payload.info;
+        if (info?.title) {
+          deps.sessionRepository.updateSessionTitle(rowId, info.title).catch((err) => console.warn(`${logPrefix} updateSessionTitle error:`, err));
+        }
+      }
+      if (handleProviderIdEvents && event.type === "session.provider_id") {
+        const sessionId = event.payload.sessionId;
+        if (sessionId && sessionId !== handle.opencodeSessionId) {
+          deps.sessionRepository.associateOpenCodeSessionId(rowId, sessionId, liveSession.sessionTitle ?? "").catch((err) => console.warn(`${logPrefix} associateOpenCodeSessionId (provider id) error:`, err));
+        }
+      }
     });
     deps.activeSessions.set(rowId, handle);
     try {
@@ -100616,19 +100694,56 @@ async function processOne(daemonSession, deps, session2) {
       await liveSession.close().catch(() => {});
       throw err;
     }
-    console.log(`[direct-harness] Session opened: rowId=${rowId} agent=${session2.opencode?.lastUsedConfig.agent ?? "build"} workspace=${session2.workspaceId}`);
+    console.log(`${logPrefix} Session opened: ${rowId} agent=${lastUsedConfig.agent} workspace=${workspaceId}`);
   } catch (err) {
-    console.warn(`[direct-harness] Failed to open session ${rowId}:`, err instanceof Error ? err.message : String(err));
+    console.warn(`${logPrefix} Failed to open session ${rowId}:`, err instanceof Error ? err.message : String(err));
     try {
       await deps.sessionRepository.markFailed(rowId);
     } catch {}
   }
 }
-var init_session_subscriber = __esm(() => {
+var init_open_pending_session = __esm(() => {
   init_idle_handler();
   init_api3();
   init_registry4();
   init_opencode_session_events();
+  init_get_or_create_bound_harness();
+});
+
+// src/commands/machine/daemon-start/direct-harness/session-subscriber.ts
+function startSessionSubscriber(daemonSession, wsClient2, deps) {
+  const inFlight = new Set;
+  const unsub = wsClient2.onUpdate(api.daemon.directHarness.sessions.listPendingSessionsForMachine, {
+    sessionId: daemonSession.sessionId,
+    machineId: daemonSession.machineId
+  }, (pendingSessions) => {
+    if (!pendingSessions || pendingSessions.length === 0)
+      return;
+    for (const session2 of pendingSessions) {
+      const rowId = session2._id;
+      if (inFlight.has(rowId))
+        continue;
+      inFlight.add(rowId);
+      (async () => {
+        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 });
+      })().finally(() => inFlight.delete(rowId));
+    }
+  }, (err) => {
+    console.warn("[direct-harness] Session subscription error:", err instanceof Error ? err.message : String(err));
+  });
+  return { stop: unsub };
+}
+var init_session_subscriber = __esm(() => {
+  init_api3();
+  init_open_pending_session();
 });
 
 // src/commands/machine/daemon-start/direct-harness/shutdown-sessions.ts
@@ -101001,6 +101116,436 @@ var init_start_subscriptions = __esm(() => {
   init_convex_session_repository();
 });
 
+// ../../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'
+## Summary
+...
+
+## Results
+...
+
+## Grounding
+...
+
+## Files
+...
+CHATROOM_AGENTIC_QUERY_END`;
+  return [
+    "You answer workspace-scoped search and ask queries by exploring the connected codebase.",
+    "Use tools to read and search files. Prefer evidence over speculation.",
+    "When done, submit results with the CLI heredoc below (markdown body only — no protocol markers like ---RESULT---).",
+    "",
+    "## Required markdown sections",
+    "- ## Summary",
+    "- ## Results",
+    "- ## Grounding (required for ask mode; path:line evidence)",
+    "- ## Files",
+    "",
+    "## Complete command",
+    completeCmd,
+    "",
+    `Convex URL: ${params.convexUrl}`
+  ].join(`
+`);
+}
+
+// src/commands/machine/daemon-start/agentic-query/prompt-subscriber.ts
+async function ensureHarnessAlive(daemonSession, deps, info) {
+  const key = makeHarnessKey(info.workspaceId, info.harnessName);
+  const existing = deps.harnesses.get(key);
+  if (existing?.isAlive())
+    return existing;
+  if (existing) {
+    existing.close().catch(() => {});
+    deps.harnesses.delete(key);
+  }
+  const workspace = await daemonSession.backend.query(api.workspaces.getWorkspaceById, {
+    sessionId: daemonSession.sessionId,
+    workspaceId: info.workspaceId
+  });
+  if (!workspace) {
+    console.warn(`[agentic-query] Cannot resume ${info.runId}: workspace not found`);
+    return null;
+  }
+  const harness = await startBoundHarness({
+    harnessName: info.harnessName,
+    workingDir: workspace.workingDir,
+    workspaceId: info.workspaceId,
+    resolvedConvexUrl: daemonSession.convexUrl
+  });
+  deps.harnesses.set(key, harness);
+  return harness;
+}
+function wireResumedIdle(handle, deps, info) {
+  const idleConfig = {
+    agent: info.lastUsedConfig.agent ?? "build",
+    model: info.lastUsedConfig.model
+  };
+  const bindTurnMessage = bindTurnMessageOnEvent(handle, deps.sessionRepository, "agentic-query");
+  handle.session.onEvent((event) => {
+    bindTurnMessage();
+    if (event.type === "session.idle") {
+      handleSessionIdle(handle, handle.journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[agentic-query] idle handler error (resume):", err));
+    }
+  });
+}
+async function resolveSessionHandle(daemonSession, deps, info) {
+  const rowId = info.runId;
+  const cached5 = deps.activeSessions.get(rowId);
+  if (cached5)
+    return cached5;
+  if (!info.opencodeSessionId || !info.harnessName) {
+    console.log(`[agentic-query] Session ${rowId} not yet open — waiting for session-subscriber`);
+    return null;
+  }
+  try {
+    const harness = await ensureHarnessAlive(daemonSession, deps, info);
+    if (!harness)
+      return null;
+    const resumed = await resumeSession({
+      harness,
+      journalFactory: deps.journalFactory,
+      chunkExtractor: createChunkExtractor(harness.type)
+    }, {
+      harnessSessionId: rowId,
+      opencodeSessionId: info.opencodeSessionId,
+      workspaceId: info.workspaceId,
+      harnessName: info.harnessName
+    });
+    deps.activeSessions.set(rowId, resumed);
+    wireResumedIdle(resumed, deps, info);
+    console.log(`[agentic-query] Resumed session ${rowId}`);
+    return resumed;
+  } catch (err) {
+    console.warn(`[agentic-query] Resume failed for ${rowId}: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function deliverMessage(deps, daemonSession, existingSession, info, msg) {
+  const rowId = info.runId;
+  await deps.sessionRepository.setGenerating(rowId, true);
+  const { turnId } = await deps.sessionRepository.beginAssistantTurn(rowId);
+  existingSession.currentTurn = { turnId, messageId: null };
+  await existingSession.session.prompt({
+    parts: [{ type: "text", text: msg.content }],
+    agent: info.lastUsedConfig.agent,
+    ...info.lastUsedConfig.model ? { model: info.lastUsedConfig.model } : {},
+    system: renderAgenticQuerySystemPrompt({
+      convexUrl: daemonSession.convexUrl,
+      chatroomId: info.chatroomId,
+      queryId: info.agenticQueryId
+    })
+  });
+  try {
+    await deps.sessionRepository.markTurnProcessed(rowId, msg.seq);
+  } catch (err) {
+    console.warn(`[agentic-query] markTurnProcessed failed for session ${rowId} seq=${msg.seq}: ${err}`);
+  }
+}
+async function drainPendingBatch(daemonSession, deps, batch) {
+  for (const info of batch.sessions) {
+    const existingSession = await resolveSessionHandle(daemonSession, deps, info);
+    if (!existingSession)
+      continue;
+    const pendingMsgs = batch.messages.filter((m) => m.runId === info.runId).sort((a, b) => a.seq - b.seq);
+    for (const msg of pendingMsgs) {
+      await deliverMessage(deps, daemonSession, existingSession, info, msg);
+    }
+  }
+}
+function startPromptSubscriber(daemonSession, wsClient2, deps) {
+  const handle = wsClient2.onUpdate(api.daemon.agenticQuery.messages.pendingForMachine, { sessionId: daemonSession.sessionId, machineId: daemonSession.machineId }, async (batch) => {
+    if (!batch)
+      return;
+    await drainPendingBatch(daemonSession, deps, batch);
+  });
+  return { stop: handle };
+}
+var init_prompt_subscriber2 = __esm(() => {
+  init_api3();
+  init_resume_session();
+  init_registry4();
+  init_idle_handler();
+});
+
+// src/commands/machine/daemon-start/agentic-query/session-subscriber.ts
+function startSessionSubscriber2(daemonSession, wsClient2, deps) {
+  const inFlight = new Set;
+  const unsub = wsClient2.onUpdate(api.daemon.agenticQuery.runs.pendingForMachine, { sessionId: daemonSession.sessionId, machineId: daemonSession.machineId }, (pendingSessions) => {
+    if (!pendingSessions || pendingSessions.length === 0)
+      return;
+    for (const session2 of pendingSessions) {
+      const rowId = session2.runId;
+      if (inFlight.has(rowId))
+        continue;
+      inFlight.add(rowId);
+      openPendingHarnessSession(daemonSession, deps, {
+        rowId: session2.runId,
+        workspaceId: session2.workspaceId,
+        harnessName: session2.harnessName,
+        lastUsedConfig: session2.lastUsedConfig
+      }, { logPrefix: "[agentic-query]", handleProviderIdEvents: false }).finally(() => inFlight.delete(rowId));
+    }
+  }, (err) => {
+    console.warn("[agentic-query] Session subscription error:", err instanceof Error ? err.message : String(err));
+  });
+  return { stop: unsub };
+}
+var init_session_subscriber2 = __esm(() => {
+  init_api3();
+  init_open_pending_session();
+});
+
+// src/infrastructure/repos/convex-agentic-query-output-repository.ts
+class ConvexAgenticQueryOutputRepository {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async appendChunks(runId, chunks) {
+    const { backend: backend2, sessionId } = this.options;
+    if (chunks.length === 0)
+      return;
+    await backend2.mutation(api.daemon.agenticQuery.messages.appendMessages, {
+      sessionId,
+      runId,
+      chunks: chunks.map((c) => ({
+        content: c.content,
+        timestamp: c.timestamp,
+        messageId: c.messageId,
+        partType: c.partType
+      }))
+    });
+  }
+}
+var init_convex_agentic_query_output_repository = __esm(() => {
+  init_api3();
+});
+
+// src/infrastructure/repos/convex-agentic-query-run-repository.ts
+class ConvexAgenticQueryRunRepository {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async associateOpenCodeSessionId(harnessSessionId, opencodeSessionId, sessionTitle) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.runs.associateOpenCodeSessionId, {
+      sessionId,
+      runId: harnessSessionId,
+      opencodeSessionId,
+      sessionTitle
+    });
+  }
+  async getOpenCodeSessionId(harnessSessionId) {
+    const { backend: backend2, sessionId } = this.options;
+    const result = await backend2.query(api.daemon.agenticQuery.runs.getRun, {
+      sessionId,
+      runId: harnessSessionId
+    });
+    return result?.opencode?.opencodeSessionId;
+  }
+  async markClosed(harnessSessionId) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.runs.closeRun, {
+      sessionId,
+      runId: harnessSessionId
+    });
+  }
+  async markIdle(harnessSessionId) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.runs.markIdle, {
+      sessionId,
+      runId: harnessSessionId
+    });
+  }
+  async markFailed(harnessSessionId) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.runs.markFailed, {
+      sessionId,
+      runId: harnessSessionId
+    });
+  }
+  async markActive(harnessSessionId) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.runs.markActive, {
+      sessionId,
+      runId: harnessSessionId
+    });
+  }
+  async markTurnProcessed(harnessSessionId, turnSeq) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.turns.markTurnProcessed, {
+      sessionId,
+      runId: harnessSessionId,
+      turnSeq
+    });
+  }
+  async setGenerating(harnessSessionId, isGenerating) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.queue.setGenerating, {
+      sessionId,
+      runId: harnessSessionId,
+      isGenerating
+    });
+  }
+  async dequeueNext(harnessSessionId) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.queue.dequeueNext, {
+      sessionId,
+      runId: harnessSessionId
+    });
+    return null;
+  }
+  async beginAssistantTurn(harnessSessionId) {
+    const { backend: backend2, sessionId } = this.options;
+    return backend2.mutation(api.daemon.agenticQuery.turns.beginAssistantTurn, {
+      sessionId,
+      runId: harnessSessionId
+    });
+  }
+  async bindTurnMessageId(turnId, messageId) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.turns.bindTurnMessageId, {
+      sessionId,
+      turnId,
+      messageId
+    });
+  }
+  async finalizeAssistantTurn(turnId) {
+    const { backend: backend2, sessionId } = this.options;
+    await backend2.mutation(api.daemon.agenticQuery.turns.finalizeAssistantTurn, {
+      sessionId,
+      turnId
+    });
+  }
+  async updateSessionTitle(harnessSessionId, title) {}
+}
+var init_convex_agentic_query_run_repository = __esm(() => {
+  init_api3();
+});
+
+// src/commands/machine/daemon-start/agentic-query/start-subscriptions.ts
+function startAgenticQuerySubscriptions(session2, wsClient2, activeSessions, harnesses) {
+  const sessionRepository = new ConvexAgenticQueryRunRepository({
+    backend: session2.backend,
+    sessionId: session2.sessionId
+  });
+  const outputRepository = new ConvexAgenticQueryOutputRepository({
+    backend: session2.backend,
+    sessionId: session2.sessionId
+  });
+  const journalFactory = new BufferedJournalFactory({ outputRepository });
+  const deps = { activeSessions, harnesses, sessionRepository, journalFactory };
+  const pendingPromptSubscriptionHandle = startPromptSubscriber(session2, wsClient2, deps);
+  const pendingHarnessSessionSubscriptionHandle = startSessionSubscriber2(session2, wsClient2, deps);
+  return {
+    pendingPromptSubscriptionHandle,
+    pendingHarnessSessionSubscriptionHandle
+  };
+}
+var init_start_subscriptions2 = __esm(() => {
+  init_prompt_subscriber2();
+  init_session_subscriber2();
+  init_convex_agentic_query_output_repository();
+  init_convex_agentic_query_run_repository();
+});
+
+// src/commands/machine/daemon-start/file-content-classifier.ts
+function extensionOf(path3) {
+  const lastDot = path3.lastIndexOf(".");
+  if (lastDot === -1)
+    return null;
+  return path3.slice(lastDot).toLowerCase();
+}
+function hasKnownBinaryExtension(path3) {
+  const ext = extensionOf(path3);
+  return ext !== null && BINARY_EXTENSIONS.has(ext);
+}
+function hasNulByte(buffer) {
+  return buffer.includes(0);
+}
+function hasTooManyControlChars(buffer) {
+  let count3 = 0;
+  const threshold = Math.max(1, Math.floor(buffer.length * 0.01));
+  for (const byte of buffer) {
+    if (byte === 0)
+      return true;
+    if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
+      count3++;
+      if (count3 > threshold)
+        return true;
+    }
+  }
+  return false;
+}
+function classifyFileContent(path3, buffer) {
+  if (hasKnownBinaryExtension(path3)) {
+    return { kind: "binary", encoding: "binary" };
+  }
+  if (buffer.length === 0) {
+    return { kind: "text", encoding: "utf8" };
+  }
+  if (hasNulByte(buffer)) {
+    return { kind: "binary", encoding: "binary" };
+  }
+  try {
+    const decoded = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    if (decoded.length === 0) {
+      return { kind: "text", encoding: "utf8" };
+    }
+    if (hasTooManyControlChars(buffer)) {
+      return { kind: "binary", encoding: "binary" };
+    }
+    return { kind: "text", encoding: "utf8" };
+  } catch {
+    return { kind: "binary", encoding: "binary" };
+  }
+}
+var BINARY_EXTENSIONS;
+var init_file_content_classifier = __esm(() => {
+  BINARY_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".ogg",
+    ".webm",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".bz2",
+    ".7z",
+    ".rar",
+    ".pdf",
+    ".doc",
+    ".docx",
+    ".xls",
+    ".xlsx",
+    ".ppt",
+    ".pptx",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".bin",
+    ".dat",
+    ".db",
+    ".sqlite"
+  ]);
+});
+
 // src/infrastructure/services/workspace/normalize-working-dir.ts
 function normalizeWorkingDirForLookup(workingDir) {
   return workingDir.trim().replace(/[/\\]+$/, "");
@@ -101221,100 +101766,6 @@ var init_workspace_visibility_policy = __esm(() => {
   ];
 });
 
-// src/commands/machine/daemon-start/file-content-classifier.ts
-function extensionOf(path3) {
-  const lastDot = path3.lastIndexOf(".");
-  if (lastDot === -1)
-    return null;
-  return path3.slice(lastDot).toLowerCase();
-}
-function hasKnownBinaryExtension(path3) {
-  const ext = extensionOf(path3);
-  return ext !== null && BINARY_EXTENSIONS.has(ext);
-}
-function hasNulByte(buffer) {
-  return buffer.includes(0);
-}
-function hasTooManyControlChars(buffer) {
-  let count3 = 0;
-  const threshold = Math.max(1, Math.floor(buffer.length * 0.01));
-  for (const byte of buffer) {
-    if (byte === 0)
-      return true;
-    if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
-      count3++;
-      if (count3 > threshold)
-        return true;
-    }
-  }
-  return false;
-}
-function classifyFileContent(path3, buffer) {
-  if (hasKnownBinaryExtension(path3)) {
-    return { kind: "binary", encoding: "binary" };
-  }
-  if (buffer.length === 0) {
-    return { kind: "text", encoding: "utf8" };
-  }
-  if (hasNulByte(buffer)) {
-    return { kind: "binary", encoding: "binary" };
-  }
-  try {
-    const decoded = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
-    if (decoded.length === 0) {
-      return { kind: "text", encoding: "utf8" };
-    }
-    if (hasTooManyControlChars(buffer)) {
-      return { kind: "binary", encoding: "binary" };
-    }
-    return { kind: "text", encoding: "utf8" };
-  } catch {
-    return { kind: "binary", encoding: "binary" };
-  }
-}
-var BINARY_EXTENSIONS;
-var init_file_content_classifier = __esm(() => {
-  BINARY_EXTENSIONS = new Set([
-    ".png",
-    ".jpg",
-    ".jpeg",
-    ".gif",
-    ".webp",
-    ".ico",
-    ".mp3",
-    ".mp4",
-    ".wav",
-    ".ogg",
-    ".webm",
-    ".zip",
-    ".tar",
-    ".gz",
-    ".bz2",
-    ".7z",
-    ".rar",
-    ".pdf",
-    ".doc",
-    ".docx",
-    ".xls",
-    ".xlsx",
-    ".ppt",
-    ".pptx",
-    ".woff",
-    ".woff2",
-    ".ttf",
-    ".otf",
-    ".eot",
-    ".exe",
-    ".dll",
-    ".so",
-    ".dylib",
-    ".bin",
-    ".dat",
-    ".db",
-    ".sqlite"
-  ]);
-});
-
 // src/commands/machine/daemon-start/file-content-fulfillment.ts
 import { readFile as readFile7 } from "node:fs/promises";
 import { gzipSync as gzipSync2 } from "node:zlib";
@@ -101347,11 +101798,11 @@ var MAX_CONTENT_BYTES, fulfillFileContentRequestsEffect;
 var init_file_content_fulfillment = __esm(() => {
   init_esm();
   init_daemon_services();
+  init_file_content_classifier();
   init_api3();
   init_assert_registered_working_dir();
   init_workspace_path_security();
   init_workspace_visibility_policy();
-  init_file_content_classifier();
   MAX_CONTENT_BYTES = 500 * 1024;
   fulfillFileContentRequestsEffect = exports_Effect.gen(function* () {
     const session2 = yield* DaemonSessionService;
@@ -108436,7 +108887,7 @@ async function discoverModelsForHarness(harness, service3) {
 async function discoverModels(agentServices) {
   return exports_Effect.runPromise(discoverModelsEffect(agentServices));
 }
-function createDefaultDeps17() {
+function createDefaultDeps18() {
   return {
     backend: {
       mutation: async () => {
@@ -108771,7 +109222,7 @@ var init_init2 = __esm(() => {
       convexUrl,
       agentServices,
       cachedModels,
-      deps: createDefaultDeps17()
+      deps: createDefaultDeps18()
     });
     yield* registerEventListenersEffect().pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
     yield* logStartupEffect(cachedModels).pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
@@ -111649,6 +112100,7 @@ var init_command_loop = __esm(() => {
   init_pid();
   init_daemon_services();
   init_start_subscriptions();
+  init_start_subscriptions2();
   init_file_content_subscription();
   init_file_tree_subscription();
   init_file_write_subscription();
@@ -111703,6 +112155,8 @@ var init_command_loop = __esm(() => {
     let pendingPromptSubscriptionHandle = null;
     let pendingHarnessSessionSubscriptionHandle = null;
     let commandSubscriptionHandle = null;
+    let aqPendingPromptSubscriptionHandle = null;
+    let aqPendingHarnessSessionSubscriptionHandle = null;
     let lifecycleManager = null;
     let closeDirectHarnessSessionsOnShutdown = null;
     const activeSessions = new Map;
@@ -111770,6 +112224,8 @@ var init_command_loop = __esm(() => {
       pendingHarnessSessionSubscriptionHandle?.stop();
       commandSubscriptionHandle?.stop();
       lifecycleManager?.stopMonitoring();
+      aqPendingPromptSubscriptionHandle?.stop();
+      aqPendingHarnessSessionSubscriptionHandle?.stop();
     };
     const runDaemonShutdownEffect = async () => {
       await withTimeout2(exports_Effect.runPromise(onDaemonShutdownEffect.pipe(exports_Effect.provide(effectContext2))), PROCESS_KILL_TIMEOUT_MS);
@@ -111823,6 +112279,14 @@ var init_command_loop = __esm(() => {
       commandSubscriptionHandle = handles.commandSubscriptionHandle;
       lifecycleManager = handles.lifecycleManager;
       closeDirectHarnessSessionsOnShutdown = handles.closeSessionsOnShutdown;
+      const aqHandles = startAgenticQuerySubscriptions({
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        backend: session2.backend,
+        convexUrl: session2.convexUrl
+      }, wsClient2, activeSessions, harnesses);
+      aqPendingPromptSubscriptionHandle = aqHandles.pendingPromptSubscriptionHandle;
+      aqPendingHarnessSessionSubscriptionHandle = aqHandles.pendingHarnessSessionSubscriptionHandle;
     }
     console.log(`
 Listening for commands...`);
@@ -112017,7 +112481,7 @@ async function isChatroomInstalledDefault() {
     return false;
   }
 }
-async function createDefaultDeps18() {
+async function createDefaultDeps19() {
   const client4 = await getConvexClient();
   const fs12 = await import("fs/promises");
   return {
@@ -112092,7 +112556,7 @@ After installation, run this command again.`;
   });
 }
 async function installTool(options = {}, deps) {
-  const d = deps ?? await createDefaultDeps18();
+  const d = deps ?? await createDefaultDeps19();
   const layer = layerFromDeps9(d);
   return exports_Effect.runPromise(installToolEffect(options).pipe(exports_Effect.catchAll((err) => handleInstallError(err)), exports_Effect.provide(layer)));
 }
@@ -112650,6 +113114,33 @@ handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").
     nextRole: options.nextRole
   });
 });
+var agenticQueryCommand = program2.command("agentic-query").description("Agentic search/ask query commands");
+agenticQueryCommand.command("complete").description("Submit the structured agentic query result markdown").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--query-id <id>", "Agentic query identifier").action(async (options) => {
+  await maybeRequireAuth();
+  const { decode: decode5 } = await Promise.resolve().then(() => exports_decode);
+  const stdinContent = await readStdin();
+  let result;
+  try {
+    const { AGENTIC_QUERY_STDIN_DELIMITER: AGENTIC_QUERY_STDIN_DELIMITER2, validateStdinHeredocBody: validateStdinHeredocBody2 } = await Promise.resolve().then(() => (init_stdin_heredoc(), exports_stdin_heredoc));
+    const decoded = decode5(stdinContent, { singleParam: "result" });
+    let body = decoded.result;
+    body = body.replace(/^(---RESULT---\s*)+/i, "").trim();
+    validateStdinHeredocBody2(body, AGENTIC_QUERY_STDIN_DELIMITER2);
+    result = body;
+  } catch (err) {
+    console.error(`❌ Failed to decode stdin: ${err.message}`);
+    process.exit(1);
+  }
+  if (!result?.trim()) {
+    console.error("❌ Result body is empty");
+    process.exit(1);
+  }
+  const { agenticQueryComplete: agenticQueryComplete2 } = await Promise.resolve().then(() => (init_complete(), exports_complete));
+  await agenticQueryComplete2(options.chatroomId, {
+    queryId: options.queryId,
+    result
+  });
+});
 var backlogCommand = program2.command("backlog").description("Manage task queue and backlog");
 backlogCommand.command("list").description("List backlog items").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--limit <n>", "Maximum number of items to show").option("--sort <sort>", "Sort order: date:desc (default) | priority:desc").option("--filter <filter>", "Filter: unscored (only items without priority score)").action(async (options) => {
   await maybeRequireAuth();
@@ -112934,4 +113425,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=4AEC2FD829D3A5B464756E2164756E21
+//# debugId=FD69F45D45D4302D64756E2164756E21