chatroom-cli 1.68.4 → 1.69.0

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---"
@@ -77106,6 +77109,40 @@ function getFileReferenceProofOfCompletionExample() {
 - \`apps/webapp/src/path/to/file.ts\` — <what changed and why>`;
 }
 
+// ../../services/backend/prompts/utils/handoff-quality-principles.ts
+function getHandoffQualityPrinciplesCommentBlock() {
+  const bullets = HANDOFF_QUALITY_PRINCIPLES.map((p) => `- ${p.name}: ${p.description}`).join(`
+`);
+  return `<!-- Demonstrate adherence to:
+${bullets}
+-->`;
+}
+var HANDOFF_QUALITY_PRINCIPLES, PROOF_OF_PRINCIPLES_HEADING_H2 = "## Proof of Principles", PROOF_OF_PRINCIPLES_HEADING_H3 = "### Proof of Principles";
+var init_handoff_quality_principles = __esm(() => {
+  HANDOFF_QUALITY_PRINCIPLES = [
+    {
+      name: "Semantic Consistency",
+      description: "the organization of the code, the code and the functionality of the code use a consistent and well maintained set of terms."
+    },
+    {
+      name: "Organization & Maintainability",
+      description: "a small change in requirements should result in a small change in code in a small number of files and folders."
+    },
+    {
+      name: "Static Evaluability and Provability",
+      description: "the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order."
+    },
+    {
+      name: "No Revisit",
+      description: "implemented in a way so the user does not have to revisit this implementation again."
+    },
+    {
+      name: "Leave It Better",
+      description: "leave the code in a slightly better state than before when touching files."
+    }
+  ];
+});
+
 // ../../services/backend/prompts/cli/role-guidance/command.ts
 function roleGuidanceCommand(params = {}) {
   const prefix = params.cliEnvPrefix ?? "";
@@ -77140,13 +77177,8 @@ function getBuilderToPlannerHandoffTemplate(roleGuidanceContext) {
 - [ ] I confirm that I have seen this template at the start of this task, before implementing or modifying any code
 ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 
-## Proof of Principle
-<!-- Demonstrate adherence to:
-- Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
-- Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
-- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
-- Leave It Better: leave the code in a slightly better state than before when touching files.
--->
+${PROOF_OF_PRINCIPLES_HEADING_H2}
+${getHandoffQualityPrinciplesCommentBlock()}
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
 ## Proof of Completion
@@ -77165,6 +77197,7 @@ ${CODE_CHANGE_VERIFICATION_CONFIRMATION}
 \`\`\``;
 }
 var init_builder_to_planner = __esm(() => {
+  init_handoff_quality_principles();
   init_role_guidance_disclosure();
 });
 
@@ -77303,13 +77336,8 @@ ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 ## What changed
 <high-level view of what changed since the user's message before the detailed proofs below>
 
-### Proof of Principle
-<!-- Demonstrate adherence to:
-- Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
-- Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
-- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
-- Leave It Better: leave the code in a slightly better state than before when touching files.
--->
+${PROOF_OF_PRINCIPLES_HEADING_H3}
+${getHandoffQualityPrinciplesCommentBlock()}
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
 ### Proof of Completion
@@ -77354,6 +77382,7 @@ ${getUnresolvedDecisionsSectionBlock()}
 }
 var init_planner_to_user = __esm(() => {
   init_context_disclosure();
+  init_handoff_quality_principles();
   init_role_guidance_disclosure();
 });
 
@@ -77405,13 +77434,8 @@ ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 ## What changed
 <high-level view of what changed since the user's message before the detailed proofs below>
 
-### Proof of Principle
-<!-- Demonstrate adherence to:
-- Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
-- Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
-- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
-- Leave It Better: leave the code in a slightly better state than before when touching files.
--->
+${PROOF_OF_PRINCIPLES_HEADING_H3}
+${getHandoffQualityPrinciplesCommentBlock()}
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
 ### Proof of Completion
@@ -77456,6 +77480,7 @@ ${getUnresolvedDecisionsSectionBlock()}
 }
 var init_solo_to_user = __esm(() => {
   init_context_disclosure();
+  init_handoff_quality_principles();
   init_role_guidance_disclosure();
 });
 
@@ -78940,6 +78965,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, {
@@ -79046,7 +79148,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 {
@@ -79102,47 +79204,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);
@@ -79151,7 +79253,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);
@@ -79912,7 +80014,7 @@ __export(exports_read, {
   taskReadEffect: () => taskReadEffect,
   taskRead: () => taskRead
 });
-async function createDefaultDeps10() {
+async function createDefaultDeps11() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -79954,7 +80056,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)));
 }
@@ -80045,7 +80147,7 @@ __export(exports_skill, {
   activateSkillEffect: () => activateSkillEffect,
   activateSkill: () => activateSkill
 });
-async function createDefaultDeps11() {
+async function createDefaultDeps12() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80114,12 +80216,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)));
 }
@@ -80197,7 +80299,7 @@ __export(exports_messages, {
   listBySenderRoleEffect: () => listBySenderRoleEffect,
   listBySenderRole: () => listBySenderRole
 });
-async function createDefaultDeps12() {
+async function createDefaultDeps13() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80258,12 +80360,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)));
 }
@@ -80393,7 +80495,7 @@ __export(exports_context2, {
   inspectContextEffect: () => inspectContextEffect,
   inspectContext: () => inspectContext
 });
-async function createDefaultDeps13() {
+async function createDefaultDeps14() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80434,17 +80536,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)));
 }
@@ -80452,7 +80554,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)));
 }
@@ -80693,7 +80795,7 @@ __export(exports_guidelines, {
   listGuidelineTypesEffect: () => listGuidelineTypesEffect,
   listGuidelineTypes: () => listGuidelineTypes
 });
-async function createDefaultDeps14() {
+async function createDefaultDeps15() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80734,12 +80836,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)));
 }
@@ -80809,7 +80911,7 @@ __export(exports_artifact, {
   createArtifactEffect: () => createArtifactEffect,
   createArtifact: () => createArtifact
 });
-async function createDefaultDeps15() {
+async function createDefaultDeps16() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80831,19 +80933,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)));
 }
@@ -81193,7 +81295,7 @@ __export(exports_telegram, {
   sendMessageEffect: () => sendMessageEffect,
   sendMessage: () => sendMessage
 });
-async function createDefaultDeps16() {
+async function createDefaultDeps17() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -81275,7 +81377,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)));
 }
@@ -99194,7 +99296,7 @@ function harnessEventSessionId(event) {
 
 class OpencodeSdkHarness {
   type = "opencode-sdk";
-  displayName = "Opencode";
+  displayName = "OpenCode (SDK)";
   client;
   childProcess;
   cwd;
@@ -100277,6 +100379,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;
@@ -100371,22 +100491,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 {
@@ -100427,7 +100540,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();
@@ -100437,122 +100550,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 () => {
@@ -100569,22 +100624,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 {
@@ -100594,19 +100668,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
@@ -100979,6 +101090,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(/[/\\]+$/, "");
@@ -101119,8 +101660,31 @@ function gunzipBase64Payload(base643, maxBytes) {
 var init_workspace_path_security = () => {};
 
 // src/infrastructure/services/workspace/workspace-visibility-policy.ts
+function isHiddenDirName(name) {
+  return HIDDEN_DIR_NAMES.has(name);
+}
+function isShallowSyncDirName(name) {
+  return SHALLOW_SYNC_DIR_NAMES.has(name);
+}
 function isAlwaysExcludedDirName(name) {
-  return ALWAYS_EXCLUDE_DIR_NAMES.has(name);
+  return isHiddenDirName(name) || isShallowSyncDirName(name);
+}
+function shouldShallowSyncByHeuristics(context5) {
+  if (context5.immediateChildCount >= SHALLOW_HEURISTIC_MIN_CHILD_COUNT)
+    return true;
+  if (!context5.relativePath.includes("/") && context5.immediateSiblingCount >= 300) {
+    return context5.immediateChildCount >= 100;
+  }
+  return false;
+}
+function classifyDirectorySyncMode(dirName, context5) {
+  if (isHiddenDirName(dirName))
+    return "hidden";
+  if (isShallowSyncDirName(dirName))
+    return "shallow";
+  if (shouldShallowSyncByHeuristics(context5))
+    return "shallow";
+  return "full";
 }
 function isSecretPath(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
@@ -101128,7 +101692,15 @@ function isSecretPath(relativePath) {
 }
 function hasExcludedDirSegment(relativePath) {
   const segments = relativePath.split("/");
-  return segments.some((segment) => isAlwaysExcludedDirName(segment));
+  const lastIndex = segments.length - 1;
+  for (let index = 0;index < segments.length; index++) {
+    const name = segments[index];
+    if (isHiddenDirName(name))
+      return true;
+    if (isShallowSyncDirName(name) && index < lastIndex)
+      return true;
+  }
+  return false;
 }
 function isPathVisible(relativePath) {
   if (!relativePath)
@@ -101138,11 +101710,11 @@ function isPathVisible(relativePath) {
 function isPathContentReadable(relativePath) {
   return isPathVisible(relativePath);
 }
-var ALWAYS_EXCLUDE_DIR_NAMES, SECRET_PATH_PATTERNS;
+var HIDDEN_DIR_NAMES, SHALLOW_SYNC_DIR_NAMES, ALWAYS_EXCLUDE_DIR_NAMES, SECRET_PATH_PATTERNS, SHALLOW_HEURISTIC_MIN_CHILD_COUNT = 500;
 var init_workspace_visibility_policy = __esm(() => {
-  ALWAYS_EXCLUDE_DIR_NAMES = new Set([
+  HIDDEN_DIR_NAMES = new Set([".git"]);
+  SHALLOW_SYNC_DIR_NAMES = new Set([
     "node_modules",
-    ".git",
     "dist",
     "build",
     ".next",
@@ -101155,6 +101727,7 @@ var init_workspace_visibility_policy = __esm(() => {
     "_generated",
     ".vercel"
   ]);
+  ALWAYS_EXCLUDE_DIR_NAMES = new Set([...HIDDEN_DIR_NAMES, ...SHALLOW_SYNC_DIR_NAMES]);
   SECRET_PATH_PATTERNS = [
     /^\.env$/,
     /^\.env\./,
@@ -101167,100 +101740,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";
@@ -101293,11 +101772,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;
@@ -101928,29 +102407,41 @@ async function isWorkspacePathIgnored(rootDir, relativePath) {
   const ruleSets = await loadApplicableIgnoreRuleSets(rootDir, relativePath);
   return isPathIgnoredByRuleSets(ruleSets, relativePath);
 }
+function mergeWorkspaceIgnoreRuleSets(inheritedRuleSets, localRuleSets) {
+  return localRuleSets.length === 0 ? [...inheritedRuleSets] : [...inheritedRuleSets, ...localRuleSets];
+}
+async function readWorkspaceDirectoryDirents(rootDir, relDir) {
+  const absDir = relDir ? path3.join(rootDir, relDir) : rootDir;
+  try {
+    return await fsPromises.readdir(absDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
 async function loadAllWorkspaceIgnoreRuleSets(rootDir) {
   const collected = [];
   async function visit(relDir, inheritedRuleSets) {
     const localRuleSets = await loadDirectoryIgnoreRuleSets(rootDir, relDir);
-    const ruleSets = localRuleSets.length === 0 ? inheritedRuleSets : [...inheritedRuleSets, ...localRuleSets];
+    const ruleSets = mergeWorkspaceIgnoreRuleSets(inheritedRuleSets, localRuleSets);
     collected.push(...localRuleSets);
-    const absDir = relDir ? path3.join(rootDir, relDir) : rootDir;
-    let dirents;
-    try {
-      dirents = await fsPromises.readdir(absDir, { withFileTypes: true });
-    } catch {
+    const dirents = await readWorkspaceDirectoryDirents(rootDir, relDir);
+    if (!dirents)
       return;
-    }
     for (const ent of dirents) {
       if (!ent.isDirectory())
         continue;
-      if (isAlwaysExcludedDirName(ent.name))
-        continue;
       const relativePath = relDir ? `${relDir}/${ent.name}` : ent.name;
       if (!isPathVisible(relativePath))
         continue;
       if (isPathIgnoredByRuleSets(ruleSets, relativePath))
         continue;
+      const syncMode = classifyDirectorySyncMode(ent.name, {
+        relativePath,
+        immediateSiblingCount: dirents.length,
+        immediateChildCount: 0
+      });
+      if (syncMode !== "full")
+        continue;
       await visit(relativePath, ruleSets);
     }
   }
@@ -101965,40 +102456,43 @@ var init_workspace_ignore = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/workspace-file-walk.ts
-import { promises as fsPromises2 } from "node:fs";
-import path4 from "node:path";
 async function walkWorkspaceFiles(rootDir, options) {
   const maxFilePaths = options?.maxFilePaths ?? 1e4;
   const filePaths = [];
+  const directoryStubs = [];
   let truncated = false;
-  async function visitDir(relDir, inheritedRuleSets) {
+  async function visitDir(relDir, inheritedRuleSets, siblingCount) {
     if (truncated || filePaths.length >= maxFilePaths) {
       truncated = true;
       return;
     }
     const localRuleSets = await loadDirectoryIgnoreRuleSets(rootDir, relDir);
-    const ruleSets = localRuleSets.length === 0 ? inheritedRuleSets : [...inheritedRuleSets, ...localRuleSets];
-    const absDir = relDir ? path4.join(rootDir, relDir) : rootDir;
-    let dirents;
-    try {
-      dirents = await fsPromises2.readdir(absDir, { withFileTypes: true });
-    } catch {
+    const ruleSets = mergeWorkspaceIgnoreRuleSets(inheritedRuleSets, localRuleSets);
+    const dirents = await readWorkspaceDirectoryDirents(rootDir, relDir);
+    if (!dirents)
       return;
-    }
     for (const ent of dirents) {
       if (truncated || filePaths.length >= maxFilePaths) {
         truncated = true;
         return;
       }
-      if (isAlwaysExcludedDirName(ent.name))
-        continue;
       const relativePath = relDir ? `${relDir}/${ent.name}` : ent.name;
       if (!isPathVisible(relativePath))
         continue;
       if (ent.isDirectory()) {
         if (isPathIgnoredByRuleSets(ruleSets, relativePath))
           continue;
-        await visitDir(relativePath, ruleSets);
+        const syncMode = classifyDirectorySyncMode(ent.name, {
+          relativePath,
+          immediateSiblingCount: siblingCount,
+          immediateChildCount: dirents.length
+        });
+        if (syncMode === "hidden")
+          continue;
+        directoryStubs.push(relativePath);
+        if (syncMode === "shallow")
+          continue;
+        await visitDir(relativePath, ruleSets, dirents.length);
       } else if (ent.isFile()) {
         if (isPathIgnoredByRuleSets(ruleSets, relativePath))
           continue;
@@ -102008,8 +102502,8 @@ async function walkWorkspaceFiles(rootDir, options) {
       }
     }
   }
-  await visitDir("", []);
-  return { filePaths, truncated };
+  await visitDir("", [], 0);
+  return { filePaths, directoryStubs, truncated };
 }
 var init_workspace_file_walk = __esm(() => {
   init_workspace_ignore();
@@ -102022,7 +102516,8 @@ async function scanFileTree(rootDir, options) {
   const scannedAt = Date.now();
   const walk = await walkWorkspaceFiles(rootDir, { maxFilePaths: maxEntries });
   const filteredPaths = walk.filePaths.filter((p) => !isExcluded(p));
-  const entries2 = buildEntries(filteredPaths, maxEntries);
+  const filteredStubs = walk.directoryStubs.filter((p) => !isExcluded(p));
+  const entries2 = buildEntries(filteredPaths, filteredStubs, maxEntries);
   return {
     entries: entries2,
     scannedAt,
@@ -102032,28 +102527,31 @@ async function scanFileTree(rootDir, options) {
 function isExcluded(filePath) {
   return hasExcludedDirSegment(filePath);
 }
-function buildEntries(filePaths, maxEntries) {
-  const directories = new Set;
+function entryDepth(entryPath) {
+  return entryPath.split("/").length;
+}
+function buildEntries(filePaths, directoryStubs, maxEntries) {
+  const directories = new Set(directoryStubs);
   for (const filePath of filePaths) {
     const parts2 = filePath.split("/");
     for (let i2 = 1;i2 < parts2.length; i2++) {
       directories.add(parts2.slice(0, i2).join("/"));
     }
   }
-  const entries2 = [];
-  const sortedDirs = Array.from(directories).sort();
-  for (const dir of sortedDirs) {
-    if (entries2.length >= maxEntries)
-      break;
-    entries2.push({ path: dir, type: "directory" });
-  }
-  const sortedFiles = filePaths.slice().sort();
-  for (const file2 of sortedFiles) {
-    if (entries2.length >= maxEntries)
-      break;
-    entries2.push({ path: file2, type: "file" });
+  const entries2 = [
+    ...Array.from(directories).map((dir) => ({ path: dir, type: "directory" })),
+    ...filePaths.map((file2) => ({ path: file2, type: "file" }))
+  ];
+  const uniqueByPath = new Map;
+  for (const entry of entries2) {
+    uniqueByPath.set(entry.path, entry);
   }
-  return entries2;
+  return Array.from(uniqueByPath.values()).sort((left3, right3) => {
+    const depthDelta = entryDepth(left3.path) - entryDepth(right3.path);
+    if (depthDelta !== 0)
+      return depthDelta;
+    return left3.path.localeCompare(right3.path);
+  }).slice(0, maxEntries);
 }
 var DEFAULT_MAX_ENTRIES = 1e4;
 var init_file_tree_scanner = __esm(() => {
@@ -102063,7 +102561,7 @@ var init_file_tree_scanner = __esm(() => {
 
 // src/infrastructure/services/workspace/git-workspace-porcelain.ts
 import { existsSync as existsSync7 } from "node:fs";
-import path5 from "node:path";
+import path4 from "node:path";
 function isEmptyRepoHeadError(error51) {
   const message = error51.message.toLowerCase();
   return message.includes("unknown revision") || message.includes("bad revision") || message.includes("ambiguous argument") || message.includes("needed a single revision");
@@ -102262,7 +102760,7 @@ function porcelainUntrackedDeletedEvents(args2) {
     const prevEntry = prevByWsPath.get(wsPath);
     if (prevEntry?.xy !== "??")
       continue;
-    const absPath = path5.join(args2.node.workTree, prevEntry.path);
+    const absPath = path4.join(args2.node.workTree, prevEntry.path);
     if (!exists3(absPath)) {
       events.push({
         kind: prevEntry.path.endsWith("/") ? "unlinkDir" : "unlink",
@@ -102529,8 +103027,8 @@ var init_git_workspace_change_source = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/git-workspace-hierarchy.ts
-import { promises as fsPromises3 } from "node:fs";
-import path6 from "node:path";
+import { promises as fsPromises2 } from "node:fs";
+import path5 from "node:path";
 function normalizeRel(p) {
   return p.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
 }
@@ -102545,15 +103043,15 @@ async function resolveGitDir(workTree) {
   const raw = await revParse(workTree, "--git-dir");
   if (!raw)
     return null;
-  return path6.isAbsolute(raw) ? raw : path6.resolve(workTree, raw);
+  return path5.isAbsolute(raw) ? raw : path5.resolve(workTree, raw);
 }
 async function findNestedWorkTrees(workspaceRoot) {
   const found = [];
   async function visit(relDir) {
-    const absDir = relDir ? path6.join(workspaceRoot, relDir) : workspaceRoot;
+    const absDir = relDir ? path5.join(workspaceRoot, relDir) : workspaceRoot;
     let dirents;
     try {
-      dirents = await fsPromises3.readdir(absDir, { withFileTypes: true });
+      dirents = await fsPromises2.readdir(absDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -102562,7 +103060,7 @@ async function findNestedWorkTrees(workspaceRoot) {
       const relativePath = relDir ? `${relDir}/${name}` : name;
       if (name === ".git") {
         if (relDir) {
-          found.push(path6.resolve(workspaceRoot, relDir));
+          found.push(path5.resolve(workspaceRoot, relDir));
         }
         continue;
       }
@@ -102576,12 +103074,12 @@ async function findNestedWorkTrees(workspaceRoot) {
     }
   }
   await visit("");
-  return [...new Set(found.map((p) => path6.resolve(p)))].sort((a, b) => a.length - b.length || a.localeCompare(b));
+  return [...new Set(found.map((p) => path5.resolve(p)))].sort((a, b) => a.length - b.length || a.localeCompare(b));
 }
 async function discoverGitWorkspaceHierarchy(workingDir) {
   let workspaceRoot;
   try {
-    workspaceRoot = await fsPromises3.realpath(workingDir);
+    workspaceRoot = await fsPromises2.realpath(workingDir);
   } catch {
     return null;
   }
@@ -102592,8 +103090,8 @@ async function discoverGitWorkspaceHierarchy(workingDir) {
   const gitDir = await resolveGitDir(workspaceRoot);
   if (!toplevelRaw || !gitDir)
     return null;
-  const toplevel = path6.resolve(toplevelRaw);
-  const relFromToplevel = normalizeRel(path6.relative(toplevel, workspaceRoot));
+  const toplevel = path5.resolve(toplevelRaw);
+  const relFromToplevel = normalizeRel(path5.relative(toplevel, workspaceRoot));
   if (relFromToplevel.startsWith(".."))
     return null;
   const pathspec = relFromToplevel && toplevel !== workspaceRoot ? [relFromToplevel] : [];
@@ -102606,7 +103104,7 @@ async function discoverGitWorkspaceHierarchy(workingDir) {
     nestedNodes.push({
       workTree,
       gitDir: nestedGitDir,
-      relativePath: normalizeRel(path6.relative(workspaceRoot, workTree)),
+      relativePath: normalizeRel(path5.relative(workspaceRoot, workTree)),
       pathspec: [],
       children: []
     });
@@ -102624,7 +103122,7 @@ async function discoverGitWorkspaceHierarchy(workingDir) {
     for (const candidate of sorted) {
       if (candidate === node)
         continue;
-      const prefix = candidate.workTree.endsWith(path6.sep) ? candidate.workTree : candidate.workTree + path6.sep;
+      const prefix = candidate.workTree.endsWith(path5.sep) ? candidate.workTree : candidate.workTree + path5.sep;
       if (node.workTree.startsWith(prefix) && candidate.workTree.length >= parent.workTree.length) {
         parent = candidate;
       }
@@ -102736,7 +103234,7 @@ var init_readdirp = __esm(() => {
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
       const statMethod = opts.lstat ? lstat : stat2;
       if (wantBigintFsStats) {
-        this._stat = (path7) => statMethod(path7, { bigint: true });
+        this._stat = (path6) => statMethod(path6, { bigint: true });
       } else {
         this._stat = statMethod;
       }
@@ -102761,8 +103259,8 @@ var init_readdirp = __esm(() => {
           const par2 = this.parent;
           const fil = par2 && par2.files;
           if (fil && fil.length > 0) {
-            const { path: path7, depth } = par2;
-            const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path7));
+            const { path: path6, depth } = par2;
+            const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path6));
             const awaited = await Promise.all(slice);
             for (const entry of awaited) {
               if (!entry)
@@ -102802,20 +103300,20 @@ var init_readdirp = __esm(() => {
         this.reading = false;
       }
     }
-    async _exploreDir(path7, depth) {
+    async _exploreDir(path6, depth) {
       let files;
       try {
-        files = await readdir(path7, this._rdOptions);
+        files = await readdir(path6, this._rdOptions);
       } catch (error51) {
         this._onError(error51);
       }
-      return { files, depth, path: path7 };
+      return { files, depth, path: path6 };
     }
-    async _formatEntry(dirent, path7) {
+    async _formatEntry(dirent, path6) {
       let entry;
       const basename2 = this._isDirent ? dirent.name : dirent;
       try {
-        const fullPath = presolve(pjoin(path7, basename2));
+        const fullPath = presolve(pjoin(path6, basename2));
         entry = { path: prelative(this._root, fullPath), fullPath, basename: basename2 };
         entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
       } catch (err) {
@@ -102875,16 +103373,16 @@ import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
 import { realpath as fsrealpath, lstat as lstat2, open, stat as stat3 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp from "node:path";
-function createFsWatchInstance(path7, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path6, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path7);
-    emitRaw(rawEvent, evPath, { watchedPath: path7 });
-    if (evPath && path7 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path7, evPath), KEY_LISTENERS, sp.join(path7, evPath));
+    listener(path6);
+    emitRaw(rawEvent, evPath, { watchedPath: path6 });
+    if (evPath && path6 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path6, evPath), KEY_LISTENERS, sp.join(path6, evPath));
     }
   };
   try {
-    return fs_watch(path7, {
+    return fs_watch(path6, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error51) {
@@ -102900,13 +103398,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error51) => fsW._handleError(error51);
   }
-  _watchWithNodeFs(path7, listener) {
+  _watchWithNodeFs(path6, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path7);
-    const basename3 = sp.basename(path7);
+    const directory = sp.dirname(path6);
+    const basename3 = sp.basename(path6);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path7);
+    const absolutePath = sp.resolve(path6);
     const options = {
       persistent: opts.persistent
     };
@@ -102916,12 +103414,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path7, absolutePath, options, {
+      closer = setFsWatchFileListener(path6, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path7, absolutePath, options, {
+      closer = setFsWatchListener(path6, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -102939,7 +103437,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path7, newStats) => {
+    const listener = async (path6, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -102953,11 +103451,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file2, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path7);
+            this.fsw._closeFile(path6);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file2, listener);
             if (closer2)
-              this.fsw._addPathCloser(path7, closer2);
+              this.fsw._addPathCloser(path6, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -102981,7 +103479,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path7, item) {
+  async _handleSymlink(entry, directory, path6, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -102991,7 +103489,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path7);
+        linkPath = await fsrealpath(path6);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -103001,12 +103499,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path7, entry.stats);
+          this.fsw._emit(EV.CHANGE, path6, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path7, entry.stats);
+        this.fsw._emit(EV.ADD, path6, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -103036,9 +103534,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path7 = sp.join(directory, item);
+      let path6 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path7, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path6, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -103047,8 +103545,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path7 = sp.join(dir, sp.relative(dir, path7));
-        this._addToNodeFs(path7, initialAdd, wh, depth + 1);
+        path6 = sp.join(dir, sp.relative(dir, path6));
+        this._addToNodeFs(path6, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve6, reject) => {
@@ -103097,13 +103595,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path7, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path6, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path6) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path7);
+    const wh = this.fsw._getWatchHelpers(path6);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -103119,8 +103617,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path7);
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const absPath = sp.resolve(path6);
+        const targetPath = follow ? await fsrealpath(path6) : path6;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -103130,29 +103628,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const targetPath = follow ? await fsrealpath(path6) : path6;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path7, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path6, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sp.resolve(path7), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path6), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path7, closer);
+        this.fsw._addPathCloser(path6, closer);
       return false;
     } catch (error51) {
       if (this.fsw._handleError(error51)) {
         ready();
-        return path7;
+        return path6;
       }
     }
   }
@@ -103190,12 +103688,12 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
   foreach(cont[listenerType], (listener) => {
     listener(val1, val2, val3);
   });
-}, setFsWatchListener = (path7, fullPath, options, handlers) => {
+}, setFsWatchListener = (path6, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path7, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path6, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -103205,7 +103703,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path7, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path6, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error51) => {
@@ -103214,7 +103712,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
         cont.watcherUnusable = true;
       if (isWindows && error51.code === "EPERM") {
         try {
-          const fd = await open(path7, "r");
+          const fd = await open(path6, "r");
           await fd.close();
           broadcastErr(error51);
         } catch (err) {}
@@ -103242,7 +103740,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
       Object.freeze(cont);
     }
   };
-}, FsWatchFileInstances, setFsWatchFileListener = (path7, fullPath, options, handlers) => {
+}, FsWatchFileInstances, setFsWatchFileListener = (path6, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -103264,7 +103762,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path7, curr));
+          foreach(cont.listeners, (listener2) => listener2(path6, curr));
         }
       })
     };
@@ -103600,24 +104098,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path7) {
-  if (typeof path7 !== "string")
+function normalizePath(path6) {
+  if (typeof path6 !== "string")
     throw new Error("string expected");
-  path7 = sp2.normalize(path7);
-  path7 = path7.replace(/\\/g, "/");
+  path6 = sp2.normalize(path6);
+  path6 = path6.replace(/\\/g, "/");
   let prepend4 = false;
-  if (path7.startsWith("//"))
+  if (path6.startsWith("//"))
     prepend4 = true;
-  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
+  path6 = path6.replace(DOUBLE_SLASH_RE, "/");
   if (prepend4)
-    path7 = "/" + path7;
-  return path7;
+    path6 = "/" + path6;
+  return path6;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path7 = normalizePath(testString);
+  const path6 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path7, stats)) {
+    if (pattern(path6, stats)) {
       return true;
     }
   }
@@ -103698,10 +104196,10 @@ class WatchHelper {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path7, follow, fsw) {
+  constructor(path6, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path7;
-    this.path = path7 = path7.replace(REPLACER_RE, "");
+    const watchPath = path6;
+    this.path = path6 = path6.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -103748,17 +104246,17 @@ var SLASH = "/", SLASH_SLASH = "//", ONE_DOT = ".", TWO_DOTS = "..", STRING_TYPE
     str = SLASH + str;
   }
   return str;
-}, normalizePathToUnix = (path7) => toUnix(sp2.normalize(toUnix(path7))), normalizeIgnored = (cwd = "") => (path7) => {
-  if (typeof path7 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path7) ? path7 : sp2.join(cwd, path7));
+}, normalizePathToUnix = (path6) => toUnix(sp2.normalize(toUnix(path6))), normalizeIgnored = (cwd = "") => (path6) => {
+  if (typeof path6 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path6) ? path6 : sp2.join(cwd, path6));
   } else {
-    return path7;
+    return path6;
   }
-}, getAbsolutePath = (path7, cwd) => {
-  if (sp2.isAbsolute(path7)) {
-    return path7;
+}, getAbsolutePath = (path6, cwd) => {
+  if (sp2.isAbsolute(path6)) {
+    return path6;
   }
-  return sp2.join(cwd, path7);
+  return sp2.join(cwd, path6);
 }, EMPTY_SET, STAT_METHOD_F = "stat", STAT_METHOD_L = "lstat", FSWatcher;
 var init_chokidar = __esm(() => {
   init_readdirp();
@@ -103874,20 +104372,20 @@ var init_chokidar = __esm(() => {
       this._closePromise = undefined;
       let paths = unifyPaths(paths_);
       if (cwd) {
-        paths = paths.map((path7) => {
-          const absPath = getAbsolutePath(path7, cwd);
+        paths = paths.map((path6) => {
+          const absPath = getAbsolutePath(path6, cwd);
           return absPath;
         });
       }
-      paths.forEach((path7) => {
-        this._removeIgnoredPath(path7);
+      paths.forEach((path6) => {
+        this._removeIgnoredPath(path6);
       });
       this._userIgnored = undefined;
       if (!this._readyCount)
         this._readyCount = 0;
       this._readyCount += paths.length;
-      Promise.all(paths.map(async (path7) => {
-        const res = await this._nodeFsHandler._addToNodeFs(path7, !_internal, undefined, 0, _origAdd);
+      Promise.all(paths.map(async (path6) => {
+        const res = await this._nodeFsHandler._addToNodeFs(path6, !_internal, undefined, 0, _origAdd);
         if (res)
           this._emitReady();
         return res;
@@ -103906,17 +104404,17 @@ var init_chokidar = __esm(() => {
         return this;
       const paths = unifyPaths(paths_);
       const { cwd } = this.options;
-      paths.forEach((path7) => {
-        if (!sp2.isAbsolute(path7) && !this._closers.has(path7)) {
+      paths.forEach((path6) => {
+        if (!sp2.isAbsolute(path6) && !this._closers.has(path6)) {
           if (cwd)
-            path7 = sp2.join(cwd, path7);
-          path7 = sp2.resolve(path7);
+            path6 = sp2.join(cwd, path6);
+          path6 = sp2.resolve(path6);
         }
-        this._closePath(path7);
-        this._addIgnoredPath(path7);
-        if (this._watched.has(path7)) {
+        this._closePath(path6);
+        this._addIgnoredPath(path6);
+        if (this._watched.has(path6)) {
           this._addIgnoredPath({
-            path: path7,
+            path: path6,
             recursive: true
           });
         }
@@ -103965,38 +104463,38 @@ var init_chokidar = __esm(() => {
       if (event !== EVENTS.ERROR)
         this.emit(EVENTS.ALL, event, ...args2);
     }
-    async _emit(event, path7, stats) {
+    async _emit(event, path6, stats) {
       if (this.closed)
         return;
       const opts = this.options;
       if (isWindows)
-        path7 = sp2.normalize(path7);
+        path6 = sp2.normalize(path6);
       if (opts.cwd)
-        path7 = sp2.relative(opts.cwd, path7);
-      const args2 = [path7];
+        path6 = sp2.relative(opts.cwd, path6);
+      const args2 = [path6];
       if (stats != null)
         args2.push(stats);
       const awf = opts.awaitWriteFinish;
       let pw;
-      if (awf && (pw = this._pendingWrites.get(path7))) {
+      if (awf && (pw = this._pendingWrites.get(path6))) {
         pw.lastChange = new Date;
         return this;
       }
       if (opts.atomic) {
         if (event === EVENTS.UNLINK) {
-          this._pendingUnlinks.set(path7, [event, ...args2]);
+          this._pendingUnlinks.set(path6, [event, ...args2]);
           setTimeout(() => {
-            this._pendingUnlinks.forEach((entry, path8) => {
+            this._pendingUnlinks.forEach((entry, path7) => {
               this.emit(...entry);
               this.emit(EVENTS.ALL, ...entry);
-              this._pendingUnlinks.delete(path8);
+              this._pendingUnlinks.delete(path7);
             });
           }, typeof opts.atomic === "number" ? opts.atomic : 100);
           return this;
         }
-        if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
+        if (event === EVENTS.ADD && this._pendingUnlinks.has(path6)) {
           event = EVENTS.CHANGE;
-          this._pendingUnlinks.delete(path7);
+          this._pendingUnlinks.delete(path6);
         }
       }
       if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -104014,16 +104512,16 @@ var init_chokidar = __esm(() => {
             this.emitWithAll(event, args2);
           }
         };
-        this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
+        this._awaitWriteFinish(path6, awf.stabilityThreshold, event, awfEmit);
         return this;
       }
       if (event === EVENTS.CHANGE) {
-        const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 50);
+        const isThrottled = !this._throttle(EVENTS.CHANGE, path6, 50);
         if (isThrottled)
           return this;
       }
       if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-        const fullPath = opts.cwd ? sp2.join(opts.cwd, path7) : path7;
+        const fullPath = opts.cwd ? sp2.join(opts.cwd, path6) : path6;
         let stats2;
         try {
           stats2 = await stat4(fullPath);
@@ -104042,23 +104540,23 @@ var init_chokidar = __esm(() => {
       }
       return error51 || this.closed;
     }
-    _throttle(actionType, path7, timeout3) {
+    _throttle(actionType, path6, timeout3) {
       if (!this._throttled.has(actionType)) {
         this._throttled.set(actionType, new Map);
       }
       const action = this._throttled.get(actionType);
       if (!action)
         throw new Error("invalid throttle");
-      const actionPath = action.get(path7);
+      const actionPath = action.get(path6);
       if (actionPath) {
         actionPath.count++;
         return false;
       }
       let timeoutObject;
       const clear = () => {
-        const item = action.get(path7);
+        const item = action.get(path6);
         const count3 = item ? item.count : 0;
-        action.delete(path7);
+        action.delete(path6);
         clearTimeout(timeoutObject);
         if (item)
           clearTimeout(item.timeoutObject);
@@ -104066,50 +104564,50 @@ var init_chokidar = __esm(() => {
       };
       timeoutObject = setTimeout(clear, timeout3);
       const thr = { timeoutObject, clear, count: 0 };
-      action.set(path7, thr);
+      action.set(path6, thr);
       return thr;
     }
     _incrReadyCount() {
       return this._readyCount++;
     }
-    _awaitWriteFinish(path7, threshold, event, awfEmit) {
+    _awaitWriteFinish(path6, threshold, event, awfEmit) {
       const awf = this.options.awaitWriteFinish;
       if (typeof awf !== "object")
         return;
       const pollInterval = awf.pollInterval;
       let timeoutHandler;
-      let fullPath = path7;
-      if (this.options.cwd && !sp2.isAbsolute(path7)) {
-        fullPath = sp2.join(this.options.cwd, path7);
+      let fullPath = path6;
+      if (this.options.cwd && !sp2.isAbsolute(path6)) {
+        fullPath = sp2.join(this.options.cwd, path6);
       }
       const now = new Date;
       const writes = this._pendingWrites;
       function awaitWriteFinishFn(prevStat) {
         statcb(fullPath, (err, curStat) => {
-          if (err || !writes.has(path7)) {
+          if (err || !writes.has(path6)) {
             if (err && err.code !== "ENOENT")
               awfEmit(err);
             return;
           }
           const now2 = Number(new Date);
           if (prevStat && curStat.size !== prevStat.size) {
-            writes.get(path7).lastChange = now2;
+            writes.get(path6).lastChange = now2;
           }
-          const pw = writes.get(path7);
+          const pw = writes.get(path6);
           const df = now2 - pw.lastChange;
           if (df >= threshold) {
-            writes.delete(path7);
+            writes.delete(path6);
             awfEmit(undefined, curStat);
           } else {
             timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
           }
         });
       }
-      if (!writes.has(path7)) {
-        writes.set(path7, {
+      if (!writes.has(path6)) {
+        writes.set(path6, {
           lastChange: now,
           cancelWait: () => {
-            writes.delete(path7);
+            writes.delete(path6);
             clearTimeout(timeoutHandler);
             return event;
           }
@@ -104117,8 +104615,8 @@ var init_chokidar = __esm(() => {
         timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
       }
     }
-    _isIgnored(path7, stats) {
-      if (this.options.atomic && DOT_RE.test(path7))
+    _isIgnored(path6, stats) {
+      if (this.options.atomic && DOT_RE.test(path6))
         return true;
       if (!this._userIgnored) {
         const { cwd } = this.options;
@@ -104128,13 +104626,13 @@ var init_chokidar = __esm(() => {
         const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
         this._userIgnored = anymatch(list, undefined);
       }
-      return this._userIgnored(path7, stats);
+      return this._userIgnored(path6, stats);
     }
-    _isntIgnored(path7, stat5) {
-      return !this._isIgnored(path7, stat5);
+    _isntIgnored(path6, stat5) {
+      return !this._isIgnored(path6, stat5);
     }
-    _getWatchHelpers(path7) {
-      return new WatchHelper(path7, this.options.followSymlinks, this);
+    _getWatchHelpers(path6) {
+      return new WatchHelper(path6, this.options.followSymlinks, this);
     }
     _getWatchedDir(directory) {
       const dir = sp2.resolve(directory);
@@ -104148,57 +104646,57 @@ var init_chokidar = __esm(() => {
       return Boolean(Number(stats.mode) & 256);
     }
     _remove(directory, item, isDirectory) {
-      const path7 = sp2.join(directory, item);
-      const fullPath = sp2.resolve(path7);
-      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path7) || this._watched.has(fullPath);
-      if (!this._throttle("remove", path7, 100))
+      const path6 = sp2.join(directory, item);
+      const fullPath = sp2.resolve(path6);
+      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path6) || this._watched.has(fullPath);
+      if (!this._throttle("remove", path6, 100))
         return;
       if (!isDirectory && this._watched.size === 1) {
         this.add(directory, item, true);
       }
-      const wp = this._getWatchedDir(path7);
+      const wp = this._getWatchedDir(path6);
       const nestedDirectoryChildren = wp.getChildren();
-      nestedDirectoryChildren.forEach((nested2) => this._remove(path7, nested2));
+      nestedDirectoryChildren.forEach((nested2) => this._remove(path6, nested2));
       const parent = this._getWatchedDir(directory);
       const wasTracked = parent.has(item);
       parent.remove(item);
       if (this._symlinkPaths.has(fullPath)) {
         this._symlinkPaths.delete(fullPath);
       }
-      let relPath = path7;
+      let relPath = path6;
       if (this.options.cwd)
-        relPath = sp2.relative(this.options.cwd, path7);
+        relPath = sp2.relative(this.options.cwd, path6);
       if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
         const event = this._pendingWrites.get(relPath).cancelWait();
         if (event === EVENTS.ADD)
           return;
       }
-      this._watched.delete(path7);
+      this._watched.delete(path6);
       this._watched.delete(fullPath);
       const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-      if (wasTracked && !this._isIgnored(path7))
-        this._emit(eventName, path7);
-      this._closePath(path7);
+      if (wasTracked && !this._isIgnored(path6))
+        this._emit(eventName, path6);
+      this._closePath(path6);
     }
-    _closePath(path7) {
-      this._closeFile(path7);
-      const dir = sp2.dirname(path7);
-      this._getWatchedDir(dir).remove(sp2.basename(path7));
+    _closePath(path6) {
+      this._closeFile(path6);
+      const dir = sp2.dirname(path6);
+      this._getWatchedDir(dir).remove(sp2.basename(path6));
     }
-    _closeFile(path7) {
-      const closers = this._closers.get(path7);
+    _closeFile(path6) {
+      const closers = this._closers.get(path6);
       if (!closers)
         return;
       closers.forEach((closer) => closer());
-      this._closers.delete(path7);
+      this._closers.delete(path6);
     }
-    _addPathCloser(path7, closer) {
+    _addPathCloser(path6, closer) {
       if (!closer)
         return;
-      let list = this._closers.get(path7);
+      let list = this._closers.get(path6);
       if (!list) {
         list = [];
-        this._closers.set(path7, list);
+        this._closers.set(path6, list);
       }
       list.push(closer);
     }
@@ -104223,7 +104721,7 @@ var init_chokidar = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/workspace-fs-watcher.ts
-import path7 from "node:path";
+import path6 from "node:path";
 function isTooManyOpenFilesError(error51) {
   if (!(error51 instanceof Error))
     return false;
@@ -104231,10 +104729,10 @@ function isTooManyOpenFilesError(error51) {
   return errno === "EMFILE" || errno === "ENOSPC" || error51.message.includes("EMFILE");
 }
 function toRelativePath(rootDir, absolutePath) {
-  return path7.relative(rootDir, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
+  return path6.relative(rootDir, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
 }
 function createWorkspaceFsWatcher(options) {
-  const absWorkingDir = path7.resolve(options.workingDir);
+  const absWorkingDir = path6.resolve(options.workingDir);
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   let stopped = false;
   let debounceTimer = null;
@@ -104330,16 +104828,16 @@ function diffPathIndexes(previous, next4) {
   const removed = [];
   const typeChanged = [];
   const prev = previous ?? {};
-  for (const [path8, type] of Object.entries(next4)) {
-    if (!(path8 in prev)) {
-      added.push(path8);
-    } else if (prev[path8] !== type) {
-      typeChanged.push(path8);
+  for (const [path7, type] of Object.entries(next4)) {
+    if (!(path7 in prev)) {
+      added.push(path7);
+    } else if (prev[path7] !== type) {
+      typeChanged.push(path7);
     }
   }
-  for (const path8 of Object.keys(prev)) {
-    if (!(path8 in next4)) {
-      removed.push(path8);
+  for (const path7 of Object.keys(prev)) {
+    if (!(path7 in next4)) {
+      removed.push(path7);
     }
   }
   added.sort();
@@ -104425,7 +104923,7 @@ function createManifestFromTree(args2) {
   };
 }
 function entriesFromPathIndex(paths) {
-  return Object.entries(paths).map(([path8, type]) => ({ path: path8, type })).sort((a, b) => a.path.localeCompare(b.path));
+  return Object.entries(paths).map(([path7, type]) => ({ path: path7, type })).sort((a, b) => a.path.localeCompare(b.path));
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
@@ -104434,7 +104932,7 @@ var init_workspace_sync_state = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import path8 from "node:path";
+import path7 from "node:path";
 function deltaEntry(paths, pathValue) {
   const type = paths[pathValue];
   if (type === undefined)
@@ -104500,7 +104998,7 @@ async function addDirectorySubtree(rootDir, relativeDir, paths) {
     return;
   ensureParentDirectories(paths, relativeDir);
   paths[relativeDir] = "directory";
-  const subtree = await scanFileTree(path8.join(rootDir, relativeDir));
+  const subtree = await scanFileTree(path7.join(rootDir, relativeDir));
   for (const entry of subtree.entries) {
     const prefixedPath = `${relativeDir}/${entry.path}`;
     if (await isWorkspacePathIgnored(rootDir, prefixedPath))
@@ -108363,7 +108861,7 @@ async function discoverModelsForHarness(harness, service3) {
 async function discoverModels(agentServices) {
   return exports_Effect.runPromise(discoverModelsEffect(agentServices));
 }
-function createDefaultDeps17() {
+function createDefaultDeps18() {
   return {
     backend: {
       mutation: async () => {
@@ -108698,7 +109196,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)));
@@ -111576,6 +112074,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();
@@ -111630,6 +112129,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;
@@ -111697,6 +112198,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);
@@ -111750,6 +112253,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...`);
@@ -111934,7 +112445,7 @@ __export(exports_opencode_install, {
   installTool: () => installTool
 });
 import * as os2 from "os";
-import * as path9 from "path";
+import * as path8 from "path";
 async function isChatroomInstalledDefault() {
   try {
     const { execSync: execSync3 } = await import("child_process");
@@ -111944,7 +112455,7 @@ async function isChatroomInstalledDefault() {
     return false;
   }
 }
-async function createDefaultDeps18() {
+async function createDefaultDeps19() {
   const client4 = await getConvexClient();
   const fs12 = await import("fs/promises");
   return {
@@ -112019,7 +112530,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)));
 }
@@ -112304,9 +112815,9 @@ After logging in, try this command again.\`;
   const fsService = yield* OpenCodeInstallFsService;
   const { checkExisting = true } = options;
   const homeDir = os2.homedir();
-  const toolDir = path9.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path9.join(toolDir, "chatroom.ts");
-  const handoffToolPath = path9.join(toolDir, "chatroom-handoff.ts");
+  const toolDir = path8.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path8.join(toolDir, "chatroom.ts");
+  const handoffToolPath = path8.join(toolDir, "chatroom-handoff.ts");
   if (checkExisting) {
     const existingFiles = [];
     const toolExists = yield* fsService.access(toolPath);
@@ -112577,6 +113088,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();
@@ -112861,4 +113399,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=5C6D9BF3DF7B24AB64756E2164756E21
+//# debugId=766A192ADD34FFEC64756E2164756E21