lody 0.41.7-next.1 → 0.41.8-next.1

package/dist/index.js

@@ -40324,7 +40324,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
     }
   }
   const name = "lody";
-  const version$3 = "0.41.7-next.1";
+  const version$3 = "0.41.8-next.1";
   const description = "Lody Agent CLI tool for managing remote command execution";
   const type = "module";
   const main$3 = "dist/index.js";
@@ -70344,6 +70344,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   componentsGeneric();
   const getAcpCapabilityCacheKey = (cliType, agentType) => `${cliType}:${agentType}`;
   const isBuiltinAgentType = (agentType) => agentType === "claude" || agentType === "codex";
+  const selectFullAccessModeValue = (cliType, agentType, option2) => {
+    if (option2.category !== "mode") {
+      return void 0;
+    }
+    if (cliType === "builtin" && agentType === "claude") {
+      return option2.options.find((candidate) => candidate.value === "bypassPermissions")?.value;
+    }
+    if (cliType === "builtin" && agentType === "codex") {
+      return option2.options.find((candidate) => candidate.value === "full-access")?.value;
+    }
+    return void 0;
+  };
+  function computeFullAccessConfigDefaults(cliType, agentType, configOptions) {
+    const defaults2 = {};
+    for (const option2 of configOptions) {
+      const fullAccessModeValue = selectFullAccessModeValue(cliType, agentType, option2);
+      if (fullAccessModeValue) {
+        defaults2[option2.id] = fullAccessModeValue;
+      }
+    }
+    return defaults2;
+  }
   function computeTitleGenerationDefaults(cliType, agentType, configOptions) {
     const defaults2 = {};
     for (const opt of configOptions) {
@@ -70352,8 +70374,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           const haiku = opt.options.find((o) => /haiku/i.test(o.value) || /haiku/i.test(o.name));
           defaults2[opt.id] = haiku?.value ?? opt.currentValue;
         } else if (opt.category === "mode") {
-          const fullAccess = opt.options.find((o) => o.value === "bypassPermissions");
-          defaults2[opt.id] = fullAccess?.value ?? opt.currentValue;
+          defaults2[opt.id] = selectFullAccessModeValue(cliType, agentType, opt) ?? opt.currentValue;
         } else {
           defaults2[opt.id] = opt.currentValue;
         }
@@ -70362,8 +70383,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           const codexModel = opt.options.find((o) => /gpt-5\.2-codex/i.test(o.value));
           defaults2[opt.id] = codexModel?.value ?? opt.currentValue;
         } else if (opt.category === "mode") {
-          const fullAccess = opt.options.find((o) => o.value === "full-access");
-          defaults2[opt.id] = fullAccess?.value ?? opt.currentValue;
+          defaults2[opt.id] = selectFullAccessModeValue(cliType, agentType, opt) ?? opt.currentValue;
         } else if (opt.id === "reasoning_effort" || opt.category === "thought_level") {
           const low = opt.options.find((o) => o.value === "low");
           defaults2[opt.id] = low?.value ?? opt.currentValue;
@@ -74309,6 +74329,9 @@ Task description:
   };
   const sessionHistorySchema = schema.LoroMap({
     id: schema.String(),
+    userTurnId: schema.String({
+      required: false
+    }),
     items: schema.LoroList(historyMessageItemSchema, void 0, {
       required: false
     }),
@@ -100983,7 +101006,7 @@ path=/${options.repoFullName}.git
   }
   function loadACPIdleTimerConfig() {
     return {
-      idleTimeoutMs: readEnvNumber$1("LODY_ACP_IDLE_TIMEOUT_MS", 3 * 60 * 60 * 1e3),
+      idleTimeoutMs: readEnvNumber$1("LODY_ACP_IDLE_TIMEOUT_MS", 30 * 60 * 1e3),
       enabled: process.env.LODY_ACP_IDLE_TIMER_ENABLED !== "false"
     };
   }
@@ -101869,7 +101892,7 @@ postId\u662F${normalizedFeedbackPostId}\uFF0C\u4F60\u9700\u8981\u5728\u5408\u900
         if (await abortIfCurrentTurnCancelled()) {
           return;
         }
-        await this.deps.createAssistantEntryForTurn(sessionId, sessionDoc, conversationTurnId, session.agentClient?.currentModel);
+        await this.deps.createAssistantEntryForTurn(sessionId, sessionDoc, conversationTurnId, session.agentClient?.currentModel, userTurnId);
         if (await abortIfCurrentTurnCancelled()) {
           return;
         }
@@ -102052,7 +102075,7 @@ postId\u662F${normalizedFeedbackPostId}\uFF0C\u4F60\u9700\u8981\u5728\u5408\u900
         if (await abortIfCurrentTurnCancelled()) {
           return;
         }
-        await this.deps.createAssistantEntryForTurn(sessionId, sessionDoc, conversationTurnId, session.agentClient?.currentModel);
+        await this.deps.createAssistantEntryForTurn(sessionId, sessionDoc, conversationTurnId, session.agentClient?.currentModel, userTurnId);
         const normalizedInputBlocks = normalizeSessionInputBlocks(agentConfig.inputBlocks, agentConfig.prompt);
         const imageOnlyInputBlocks = normalizedInputBlocks.filter((block) => block.type === "image");
         const createPromptText = buildPrompt(agentConfig.prompt, project, agentConfig.issuePRMentions, fromFeedbackPostId);
@@ -102672,7 +102695,7 @@ postId\u662F${normalizedFeedbackPostId}\uFF0C\u4F60\u9700\u8981\u5728\u5408\u900
         clearActiveTurnId: (sessionId, turnId) => this.clearActiveTurnIdIfMatches(sessionId, turnId),
         buildAcpPromptBlocks: async (args2) => await this.buildAcpPromptBlocks(args2),
         applyAcpModeAndModel: async (session, config22) => await this.applyAcpModeAndModel(session, config22),
-        createAssistantEntryForTurn: async (sessionId, sessionDoc, turnId, modelInfo) => await this.createAssistantEntryForTurn(sessionId, sessionDoc, turnId, modelInfo),
+        createAssistantEntryForTurn: async (sessionId, sessionDoc, turnId, modelInfo, userTurnId) => await this.createAssistantEntryForTurn(sessionId, sessionDoc, turnId, modelInfo, userTurnId),
         finalizeTurn: async (ctx) => await this.finalizeTurn(ctx),
         handleTurnError: async (sessionId, sessionDoc, error2) => await this.handleTurnError(sessionId, sessionDoc, error2),
         recordChatFailure: async (sessionDoc, reason, message) => await this.recordChatFailure(sessionDoc, reason, message),
@@ -102952,12 +102975,13 @@ postId\u662F${normalizedFeedbackPostId}\uFF0C\u4F60\u9700\u8981\u5728\u5408\u900
         this.logger.warn(`[${sessionId}] Failed to record code session diffs: ${formatErrorMessage(error2)}`);
       }
     }
-    async createAssistantEntryForTurn(sessionId, sessionDoc, turnId, modelInfo) {
+    async createAssistantEntryForTurn(sessionId, sessionDoc, turnId, modelInfo, userTurnId) {
       this.logger.debug(`[${sessionId}] Creating assistant entry for turn ${turnId}`);
       await sessionDoc.updateHistory((history) => {
         history.push({
           id: turnId,
           role: "assistant",
+          userTurnId,
           items: [],
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           userId: void 0,
@@ -106502,6 +106526,14 @@ const getSessionId = () => {
   return process.env.LODY_SESSION_ID || extractSessionIdFromPath();
 };
 
+const getAssociationSessionId = () => {
+  const workspaceSessionId = String(process.env.LODY_WORKSPACE_SESSION_ID || '').trim();
+  if (workspaceSessionId) {
+    return workspaceSessionId;
+  }
+  return getSessionId();
+};
+
 const parseRepoFromUrl = (raw) => {
   const value = String(raw || '').trim();
   if (!value) return null;
@@ -106740,7 +106772,7 @@ const postPullRequestAssociation = async (payload) => {
   const baseUrl = process.env.LODY_AUTH_URL;
   const cliToken = process.env.LODY_CLI_TOKEN;
   const workspaceId = process.env.LODY_WORKSPACE_ID;
-  const sessionId = getSessionId();
+  const sessionId = getAssociationSessionId();
   if (!sessionId) return;
   if (!baseUrl || !cliToken || !workspaceId) {
     console.error('[lody] PR association skipped: missing auth configuration.');
@@ -112131,6 +112163,7 @@ export PATH="${ghShimBinDir}:$PATH"
     }
     buildShellEnv(extraEnv) {
       const configEnv = this.config.env ?? {};
+      const workspaceSessionId = this.config.parentSessionId ?? this.sessionId;
       return {
         ...process.env,
         ...configEnv,
@@ -112139,7 +112172,8 @@ export PATH="${ghShimBinDir}:$PATH"
         TERM: "xterm-256color",
         PS1: "",
         PROMPT_COMMAND: "",
-        LODY_SESSION_ID: this.sessionId
+        LODY_SESSION_ID: this.sessionId,
+        LODY_WORKSPACE_SESSION_ID: workspaceSessionId
       };
     }
     async createAgent(callbacks) {
@@ -141268,6 +141302,12 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     slug: string$1().nullable(),
     role: string$1()
   });
+  const WorkspaceGitHubRepositorySchema = object({
+    id: number$1(),
+    name: string$1(),
+    fullName: string$1(),
+    private: boolean()
+  });
   const WorkspaceListResultSchema = discriminatedUnion("valid", [
     object({
       valid: literal(false),
@@ -141284,6 +141324,16 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     success: literal(true),
     existing: boolean()
   });
+  const WorkspaceGitHubRepositoryListResultSchema = discriminatedUnion("valid", [
+    object({
+      valid: literal(false),
+      repositories: array$1(WorkspaceGitHubRepositorySchema)
+    }),
+    object({
+      valid: literal(true),
+      repositories: array$1(WorkspaceGitHubRepositorySchema)
+    })
+  ]);
   function createAuthConvexClient() {
     if (!LODY_AUTH_URL) {
       throw new Error("LODY_AUTH_URL is not defined.");
@@ -141301,6 +141351,18 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     }
     return parsed.workspaces;
   }
+  async function listWorkspaceGitHubRepositoriesForCliToken(input2) {
+    const client = createAuthConvexClient();
+    const raw = await client.query(api.github.listWorkspaceRepositoriesForCliToken, {
+      cliToken: input2.token,
+      workspaceId: input2.workspaceId
+    });
+    const parsed = WorkspaceGitHubRepositoryListResultSchema.parse(raw);
+    if (!parsed.valid) {
+      throw new Error("CLI token is invalid or expired. Run `lody login` again.");
+    }
+    return parsed.repositories;
+  }
   async function registerSessionOwnerForCliToken(input2) {
     const client = createAuthConvexClient();
     const raw = await client.mutation(api.sessions.registerSessionOwnerFromCliToken, {
@@ -144504,6 +144566,171 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     });
   });
   const agentConfigCommand = new Command("agent-config").description("Manage agent configs").addCommand(agentConfigListCommand).addCommand(agentConfigShowCommand).addCommand(agentConfigRefreshCapabilitiesCommand).addCommand(agentConfigCreateCommand).addCommand(agentConfigUpdateCommand).addCommand(agentConfigDeleteCommand);
+  class SessionTurnWaitError extends Error {
+    constructor(code, sessionId, userTurnId, message) {
+      super(message);
+      this.code = code;
+      this.sessionId = sessionId;
+      this.userTurnId = userTurnId;
+      this.name = "SessionTurnWaitError";
+    }
+  }
+  const normalizeMessageItems = (items) => {
+    return Array.isArray(items) ? items : [];
+  };
+  const findUserTurnIndex = (history, userTurnId) => {
+    return history.findIndex((entry2) => entry2?.id === userTurnId && entry2.role === "user");
+  };
+  function findAssistantEntryForUserTurn(history, userTurnId) {
+    const userTurnIndex = findUserTurnIndex(history, userTurnId);
+    if (userTurnIndex < 0) {
+      return void 0;
+    }
+    for (let index2 = userTurnIndex + 1; index2 < history.length; index2 += 1) {
+      const entry2 = history[index2];
+      if (entry2?.role === "assistant" && entry2.userTurnId === userTurnId) {
+        return entry2;
+      }
+    }
+    return void 0;
+  }
+  const findUserTurn = (history, userTurnId) => {
+    const userTurnIndex = findUserTurnIndex(history, userTurnId);
+    return userTurnIndex >= 0 ? history[userTurnIndex] : void 0;
+  };
+  const findChatFailureMessage = (history, userTurnId) => {
+    const userTurnIndex = findUserTurnIndex(history, userTurnId);
+    if (userTurnIndex < 0) {
+      return void 0;
+    }
+    for (let index2 = history.length - 1; index2 > userTurnIndex; index2 -= 1) {
+      const entry2 = history[index2];
+      if (entry2?.role !== "system" || !Array.isArray(entry2.items)) {
+        continue;
+      }
+      for (const item of entry2.items) {
+        const noticeMeta = item.type === "system_notice" ? item.meta : void 0;
+        if (item.type === "system_notice" && item.name === "chat_failed" && noticeMeta && typeof noticeMeta === "object" && "message" in noticeMeta && typeof noticeMeta.message === "string" && noticeMeta.message.trim()) {
+          return noticeMeta.message.trim();
+        }
+      }
+    }
+    return void 0;
+  };
+  function calculateTurnDurationMs(entry2) {
+    const startedAt = Date.parse(entry2.timestamp);
+    if (!Number.isFinite(startedAt) || typeof entry2.endedAt !== "number") {
+      return 0;
+    }
+    return Math.max(0, entry2.endedAt - startedAt);
+  }
+  async function waitForTurnCompletion(options) {
+    const mirror = options.sessionDoc.mirror;
+    if (!mirror) {
+      throw new Error("SessionDocument not initialized");
+    }
+    return await new Promise((resolve2, reject) => {
+      let settled = false;
+      let lastAssistantTurnId;
+      let lastSerializedItems = [];
+      let unsubscribe2 = () => {
+      };
+      let timeoutId;
+      const cleanup = () => {
+        unsubscribe2();
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        options.signal?.removeEventListener("abort", handleAbort);
+      };
+      const settle = (handler) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        handler();
+      };
+      const emit = (event) => {
+        options.onEvent?.(event);
+      };
+      const rejectWith = (error2) => {
+        settle(() => reject(error2));
+      };
+      const inspect2 = (next) => {
+        if (settled) {
+          return;
+        }
+        const history = Array.isArray(next.history) ? next.history : [];
+        const userTurn = findUserTurn(history, options.userTurnId);
+        if (userTurn?.status === "failed") {
+          rejectWith(new SessionTurnWaitError("failed", options.sessionDoc.sessionId, options.userTurnId, findChatFailureMessage(history, options.userTurnId) ?? "Session turn failed."));
+          return;
+        }
+        if (userTurn?.status === "canceled") {
+          rejectWith(new SessionTurnWaitError("canceled", options.sessionDoc.sessionId, options.userTurnId, "Session turn was canceled."));
+          return;
+        }
+        const assistantEntry = findAssistantEntryForUserTurn(history, options.userTurnId);
+        if (assistantEntry) {
+          const items = normalizeMessageItems(assistantEntry.items);
+          if (assistantEntry.id !== lastAssistantTurnId) {
+            lastAssistantTurnId = assistantEntry.id;
+            lastSerializedItems = [];
+          }
+          if (options.outputMode === "jsonl") {
+            const nextSerializedItems = items.map((item) => JSON.stringify(item));
+            for (let index2 = 0; index2 < nextSerializedItems.length; index2 += 1) {
+              if (nextSerializedItems[index2] !== lastSerializedItems[index2]) {
+                emit({
+                  type: "update",
+                  sessionId: options.sessionDoc.sessionId,
+                  turnId: assistantEntry.id,
+                  content: items[index2]
+                });
+              }
+            }
+            lastSerializedItems = nextSerializedItems;
+          }
+          if (userTurn?.status === "handled" && (assistantEntry.finished === true || typeof assistantEntry.endedAt === "number")) {
+            const completedTurn = {
+              sessionId: options.sessionDoc.sessionId,
+              userTurnId: options.userTurnId,
+              turnId: assistantEntry.id,
+              content: items,
+              durationMs: calculateTurnDurationMs(assistantEntry),
+              entry: assistantEntry
+            };
+            if (options.outputMode === "jsonl") {
+              emit({
+                type: "done",
+                sessionId: options.sessionDoc.sessionId,
+                turnId: assistantEntry.id,
+                durationMs: completedTurn.durationMs
+              });
+            }
+            settle(() => resolve2(completedTurn));
+            return;
+          }
+        }
+      };
+      const handleAbort = () => {
+        rejectWith(new Error("Turn completion wait aborted."));
+      };
+      unsubscribe2 = mirror.subscribe((next) => {
+        inspect2(next);
+      });
+      options.signal?.addEventListener("abort", handleAbort, {
+        once: true
+      });
+      if (options.timeoutMs > 0) {
+        timeoutId = setTimeout(() => {
+          rejectWith(new SessionTurnWaitError("timeout", options.sessionDoc.sessionId, options.userTurnId, `Timed out waiting for session turn completion after ${Math.ceil(options.timeoutMs / 1e3)}s.`));
+        }, options.timeoutMs);
+      }
+      inspect2(mirror.getState());
+    });
+  }
   function resolvePromptCandidate(input2) {
     return normalizeCliValue(input2.prompt) ?? normalizeCliValue(input2.promptFileContent) ?? normalizeCliValue(input2.positionalPrompt) ?? normalizeCliValue(input2.stdinText);
   }
@@ -145005,9 +145232,70 @@ ${entry2.text}`).join("\n\n");
       agentType: args2.agentType,
       modeId: args2.modeId,
       modelId: args2.modelId,
+      configOptionValues: args2.configOptionValues && Object.keys(args2.configOptionValues).length > 0 ? args2.configOptionValues : void 0,
       resume: args2.resume
     };
   }
+  function resolveBuiltinFullAccessModeId(cliType, agentType) {
+    if (cliType !== "builtin") {
+      return void 0;
+    }
+    if (agentType === "claude") {
+      return "bypassPermissions";
+    }
+    if (agentType === "codex") {
+      return "full-access";
+    }
+    return void 0;
+  }
+  function resolveStructuredOutputTimeoutMs(timeoutSeconds) {
+    return (timeoutSeconds ?? 600) * 1e3;
+  }
+  async function resolveTurnDispatchConfig(args2) {
+    const modeId = normalizeCliValue(args2.mode);
+    const modelId = normalizeCliValue(args2.model);
+    if (args2.outputMode === "human" || modeId) {
+      return {
+        modeId: modeId ?? void 0,
+        modelId: modelId ?? void 0
+      };
+    }
+    const capabilities = await args2.manager.getAcpCapabilities(args2.machineId, args2.cliType, args2.agentType);
+    const configOptionValues = capabilities?.configOptions ? computeFullAccessConfigDefaults(args2.cliType, args2.agentType, capabilities.configOptions) : {};
+    if (Object.keys(configOptionValues).length > 0) {
+      return {
+        modelId: modelId ?? void 0,
+        configOptionValues
+      };
+    }
+    return {
+      modeId: resolveBuiltinFullAccessModeId(args2.cliType, args2.agentType),
+      modelId: modelId ?? void 0
+    };
+  }
+  function buildStructuredWaitError(outputMode, sessionId, userTurnId, error2) {
+    const message = formatErrorMessage(error2);
+    if (outputMode === "json") {
+      return Object.assign(new Error(message), {
+        structuredOutputPayload: {
+          ok: false,
+          sessionId,
+          userTurnId,
+          error: message
+        }
+      });
+    }
+    const code = error2 instanceof SessionTurnWaitError ? error2.code : "failed";
+    return Object.assign(new Error(message), {
+      structuredOutputPayload: {
+        type: "error",
+        sessionId,
+        userTurnId,
+        code,
+        error: message
+      }
+    });
+  }
   async function removeHistoryEntryById(sessionDoc, historyId) {
     await sessionDoc.updateHistory((history) => history.filter((entry2) => entry2.id !== historyId));
   }
@@ -145025,38 +145313,42 @@ ${entry2.text}`).join("\n\n");
       logger2.warn(`Failed to update session activity timestamps for ${sessionId}: ${formatErrorMessage(error2)}`);
     }
   }
-  const dispatchLocalSessionControl = dispatchLocalControl;
-  function extractCreateResponse(responses) {
-    const target = responses.find((response) => response.type === "session/create_response");
+  function extractCancelResponse(responses) {
+    const target = responses.find((response) => response.type === "session/cancel_response");
     if (!target) {
-      throw new Error("Missing session/create_response from local CLI daemon.");
+      throw new Error("Missing session/cancel_response from local CLI daemon.");
     }
-    return SessionCreateResponseSchema.parse(target);
+    return SessionCancelResponseSchema.parse(target);
   }
-  function extractChatResponse(responses) {
-    const target = responses.find((response) => response.type === "session/chat_response");
+  function extractMachineStatusResponse(responses) {
+    const target = responses.find((response) => response.type === "machine/status_response");
     if (!target) {
-      throw new Error("Missing session/chat_response from local CLI daemon.");
+      throw new Error("Missing machine/status_response from local CLI daemon.");
     }
-    return SessionChatResponseSchema.parse(target);
+    return MachineStatusResponseSchema.parse(target);
   }
-  function extractCancelResponse(responses) {
-    const target = responses.find((response) => response.type === "session/cancel_response");
-    if (!target) {
-      throw new Error("Missing session/cancel_response from local CLI daemon.");
+  async function ensureLocalRuntimeAvailable(machineId, workspaceId) {
+    try {
+      extractMachineStatusResponse(await dispatchLocalControl({
+        type: "machine/status",
+        machineId,
+        workspaceId
+      }));
+    } catch (error2) {
+      throw new Error(`Local session runtime is not available: ${formatErrorMessage(error2)}`, {
+        cause: error2
+      });
     }
-    return SessionCancelResponseSchema.parse(target);
   }
   function shouldQueueMachineDelete(session) {
     return normalizeCliValue(session.repoFullName) !== void 0;
   }
-  async function createSessionResult(auth, workspace, manager, prompt2, options) {
+  async function createSessionResult(auth, workspace, manager, prompt2, options, agentConfig, dispatchConfig, structuredOutput) {
     const normalizedRepo = normalizeCliValue(options.repo);
     const normalizedLocalProject = normalizeCliValue(options.localProject);
     if (normalizedRepo && normalizedLocalProject) {
       throw new Error("Pass either --repo or --local-project, not both.");
     }
-    const agentConfig = await resolveAgentConfigOrThrow(manager, options.agentConfig);
     const requestedBranch = normalizeCliValue(options.branch);
     const branch = resolveBaseBranchPreference({
       preferredBranch: requestedBranch,
@@ -145108,18 +145400,29 @@ ${entry2.text}`).join("\n\n");
         env: mergedEnv
       } : {}
     });
-    let response;
+    let completionAbortController;
+    let completionPromise;
     try {
-      const modeId = normalizeCliValue(options.mode);
-      const modelId = normalizeCliValue(options.model);
+      const modeId = dispatchConfig.modeId;
+      const modelId = dispatchConfig.modelId;
       const sessionCreatePrompt = buildAgentPrompt(prompt2, agentConfig.prompt ?? "");
       const userTurnId = await appendUserPromptHistory(sessionDoc, prompt2, auth.userId, buildCliHistoryInputConfig({
         prompt: sessionCreatePrompt,
         cliType: agentConfig.cliType,
         agentType: agentConfig.agentType,
         modeId: modeId ?? void 0,
-        modelId: modelId ?? void 0
+        modelId: modelId ?? void 0,
+        configOptionValues: dispatchConfig.configOptionValues
       }));
+      completionAbortController = structuredOutput ? new AbortController() : void 0;
+      completionPromise = structuredOutput ? waitForTurnCompletion({
+        sessionDoc,
+        userTurnId,
+        outputMode: structuredOutput.outputMode,
+        timeoutMs: structuredOutput.timeoutMs,
+        signal: completionAbortController?.signal,
+        onEvent: structuredOutput.onEvent
+      }) : void 0;
       if (repoFullName) {
         await registerSessionOwnerForCliToken({
           token: auth.token,
@@ -145129,44 +145432,23 @@ ${entry2.text}`).join("\n\n");
           repoFullName
         });
       }
-      response = extractCreateResponse(await dispatchLocalSessionControl({
-        type: "session/create",
+      await updateSessionActivityTimestampsBestEffort(manager, sessionId);
+      await manager.repo.upsertDocMeta(sessionRoomId, {
+        status: SessionStatusFactory.idle()
+      });
+      return {
         sessionId,
         machineId: auth.machineId,
         workspaceId: workspace.id,
-        ...project ? {
-          project
-        } : {},
-        acpSessionConfig: {
-          prompt: sessionCreatePrompt,
-          cliType: agentConfig.cliType,
-          agentType: agentConfig.agentType,
-          ...modeId ? {
-            modeId
-          } : {},
-          ...modelId ? {
-            modelId
-          } : {}
-        },
-        ...Object.keys(mergedEnv).length > 0 ? {
-          env: mergedEnv
-        } : {},
         userTurnId,
-        userId: auth.userId,
-        userName: auth.userName,
-        userEmail: auth.userEmail
-      }));
+        completionPromise
+      };
     } catch (error2) {
+      completionAbortController?.abort();
+      await completionPromise?.catch(() => void 0);
       await rollbackPendingSessionCreate(manager, sessionId);
       throw error2;
     }
-    await updateSessionActivityTimestampsBestEffort(manager, sessionId);
-    return {
-      sessionId,
-      machineId: auth.machineId,
-      workspaceId: workspace.id,
-      response
-    };
   }
   async function buildSessionShowResult(workspace, manager, sessionId) {
     const session = await resolveSessionMetaOrThrow(manager, sessionId);
@@ -145238,11 +145520,15 @@ ${entry2.text}`).join("\n\n");
       await exitSessionCommand(0);
     } catch (error2) {
       const message = formatErrorMessage(error2);
+      const structuredOutputPayload = error2 && typeof error2 === "object" && "structuredOutputPayload" in error2 ? error2.structuredOutputPayload : void 0;
       if (options.json || options.jsonl) {
-        printJson({
+        printJson(structuredOutputPayload ?? (options.jsonl ? {
+          type: "error",
+          error: message
+        } : {
           ok: false,
           error: message
-        });
+        }));
       } else {
         getLogger("session").error(message);
       }
@@ -145280,29 +145566,70 @@ ${entry2.text}`).join("\n\n");
       process.exit(code);
     }
   }
-  const sessionCreateCommand = new Command("create").description("Create a new session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--agent-config <idOrName>", "Agent config id or name").option("--title <title>", "Session title").option("--repo <owner/repo>", "GitHub repository to attach").option("--local-project <id|name|path>", "Local project id, name, or root path").option("--branch <name>", "Project branch to use (defaults to main)").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--env <keyValue>", "Extra environment variable in KEY=VALUE form; repeatable", collectListOption, []).option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--debug", "Enable debug output").argument("[prompt]", "Prompt text").action(async (promptArg, options) => {
+  const sessionCreateCommand = new Command("create").description("Create a new session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--agent-config <idOrName>", "Agent config id or name").option("--title <title>", "Session title").option("--repo <owner/repo>", "GitHub repository to attach").option("--local-project <id|name|path>", "Local project id, name, or root path").option("--branch <name>", "Project branch to use (defaults to main)").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--env <keyValue>", "Extra environment variable in KEY=VALUE form; repeatable", collectListOption, []).option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--timeout <seconds>", "Wait timeout in seconds for structured output", parsePositiveIntOption).option("--debug", "Enable debug output").argument("[prompt]", "Prompt text").action(async (promptArg, options) => {
     await runSessionCommand(options, async () => {
+      const outputMode = resolveStructuredOutputMode(options);
       const auth = getAuthContextOrThrow();
       const workspace = await resolveWorkspaceOrThrow(auth, options.workspace);
       const prompt2 = await readPromptText(options, promptArg);
+      await ensureLocalRuntimeAvailable(auth.machineId, workspace.id);
       await withWorkspaceManager(auth, workspace, async (manager) => {
-        const result = await createSessionResult(auth, workspace, manager, prompt2, options);
-        if (options.json) {
-          printJson({
-            ok: true,
-            sessionId: result.sessionId,
-            workspaceId: result.workspaceId,
-            machineId: result.machineId,
-            response: result.response
-          });
+        const agentConfig = await resolveAgentConfigOrThrow(manager, options.agentConfig);
+        const dispatchConfig = await resolveTurnDispatchConfig({
+          manager,
+          machineId: auth.machineId,
+          cliType: agentConfig.cliType,
+          agentType: agentConfig.agentType,
+          mode: options.mode,
+          model: options.model,
+          outputMode
+        });
+        const result = await createSessionResult(auth, workspace, manager, prompt2, options, agentConfig, dispatchConfig, outputMode === "human" ? void 0 : {
+          outputMode,
+          timeoutMs: resolveStructuredOutputTimeoutMs(options.timeout),
+          onEvent: outputMode === "jsonl" ? (event) => printJson(event) : void 0
+        });
+        if (outputMode === "json") {
+          try {
+            const completionPromise = result.completionPromise;
+            if (!completionPromise) {
+              throw new Error("Missing completion promise for structured session create output.");
+            }
+            const completedTurn = await completionPromise;
+            printJson({
+              ok: true,
+              sessionId: result.sessionId,
+              workspaceId: result.workspaceId,
+              machineId: result.machineId,
+              userTurnId: result.userTurnId,
+              turnId: completedTurn.turnId,
+              content: completedTurn.content,
+              durationMs: completedTurn.durationMs
+            });
+          } catch (error2) {
+            throw buildStructuredWaitError(outputMode, result.sessionId, result.userTurnId, error2);
+          }
+          return;
+        }
+        if (outputMode === "jsonl") {
+          try {
+            const completionPromise = result.completionPromise;
+            if (!completionPromise) {
+              throw new Error("Missing completion promise for structured session create output.");
+            }
+            await completionPromise;
+          } catch (error2) {
+            throw buildStructuredWaitError(outputMode, result.sessionId, result.userTurnId, error2);
+          }
           return;
         }
         console.log(result.sessionId);
       });
     });
   });
-  const sessionChatCommand = new Command("chat").description("Send a new user prompt to an existing session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").argument("[prompt]", "Prompt text").action(async (sessionIdArg, promptArg, options) => {
+  const sessionChatCommand = new Command("chat").description("Send a new user prompt to an existing session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--timeout <seconds>", "Wait timeout in seconds for structured output", parsePositiveIntOption).option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").argument("[prompt]", "Prompt text").action(async (sessionIdArg, promptArg, options) => {
     await runSessionCommand(options, async () => {
+      const outputMode = resolveStructuredOutputMode(options);
       const auth = getAuthContextOrThrow();
       const stdinState = shouldReadStdinForChatArgResolution({
         sessionIdArg,
@@ -145332,58 +145659,71 @@ ${entry2.text}`).join("\n\n");
           throw new Error(`Session ${sessionId} is archived. Restore it before chatting.`);
         }
         ensureLocalMachineSession(session, auth);
+        await ensureLocalRuntimeAvailable(auth.machineId, workspace.id);
         const sessionDoc = await manager.getOrCreateSessionDoc(sessionId);
-        const modeId = normalizeCliValue(options.mode);
-        const modelId = normalizeCliValue(options.model);
+        const dispatchConfig = await resolveTurnDispatchConfig({
+          manager,
+          machineId: auth.machineId,
+          cliType: session.cliType,
+          agentType: session.agentType,
+          mode: options.mode,
+          model: options.model,
+          outputMode
+        });
         const userTurnId = await appendUserPromptHistory(sessionDoc, prompt2, auth.userId, buildCliHistoryInputConfig({
           prompt: prompt2,
           cliType: session.cliType,
           agentType: session.agentType,
-          modeId: modeId ?? void 0,
-          modelId: modelId ?? void 0,
+          modeId: dispatchConfig.modeId,
+          modelId: dispatchConfig.modelId,
+          configOptionValues: dispatchConfig.configOptionValues,
           resume: session.acpSessionId ?? void 0
         }));
-        let response;
+        const completionAbortController = outputMode === "human" ? void 0 : new AbortController();
+        const completionPromise = outputMode === "human" ? void 0 : waitForTurnCompletion({
+          sessionDoc,
+          userTurnId,
+          outputMode,
+          timeoutMs: resolveStructuredOutputTimeoutMs(options.timeout),
+          signal: completionAbortController?.signal,
+          onEvent: outputMode === "jsonl" ? (event) => printJson(event) : void 0
+        });
         try {
-          response = extractChatResponse(await dispatchLocalSessionControl({
-            type: "session/chat",
-            sessionId,
-            machineId: auth.machineId,
-            workspaceId: workspace.id,
-            ...session.project ? {
-              project: session.project
-            } : {},
-            acpSessionConfig: {
-              prompt: prompt2,
-              cliType: session.cliType,
-              agentType: session.agentType,
-              ...modeId ? {
-                modeId
-              } : {},
-              ...modelId ? {
-                modelId
-              } : {},
-              ...session.acpSessionId ? {
-                resume: session.acpSessionId
-              } : {}
-            },
-            userTurnId,
-            userId: auth.userId,
-            userName: auth.userName,
-            userEmail: auth.userEmail
-          }));
+          await updateSessionActivityTimestampsBestEffort(manager, sessionId);
         } catch (error2) {
+          completionAbortController?.abort();
+          await completionPromise?.catch(() => void 0);
           await removeHistoryEntryById(sessionDoc, userTurnId);
           throw error2;
         }
-        await updateSessionActivityTimestampsBestEffort(manager, sessionId);
-        if (options.json) {
-          printJson({
-            ok: true,
-            sessionId,
-            userTurnId,
-            response
-          });
+        if (outputMode === "json") {
+          try {
+            if (!completionPromise) {
+              throw new Error("Missing completion promise for structured session chat output.");
+            }
+            const completedTurn = await completionPromise;
+            printJson({
+              ok: true,
+              sessionId,
+              userTurnId,
+              turnId: completedTurn.turnId,
+              content: completedTurn.content,
+              durationMs: completedTurn.durationMs
+            });
+          } catch (error2) {
+            throw buildStructuredWaitError(outputMode, sessionId, userTurnId, error2);
+          }
+          return;
+        }
+        if (outputMode === "jsonl") {
+          try {
+            if (!completionPromise) {
+              throw new Error("Missing completion promise for structured session chat output.");
+            }
+            await completionPromise;
+          } catch (error2) {
+            throw buildStructuredWaitError(outputMode, sessionId, userTurnId, error2);
+          }
           return;
         }
         console.log(userTurnId);
@@ -145405,7 +145745,7 @@ ${entry2.text}`).join("\n\n");
         if (!turnId) {
           throw new Error(`Session ${sessionId} has no active turn to cancel.`);
         }
-        const response = extractCancelResponse(await dispatchLocalSessionControl({
+        const response = extractCancelResponse(await dispatchLocalControl({
           type: "session/cancel",
           sessionId,
           machineId: auth.machineId,
@@ -146485,6 +146825,69 @@ ${entry2.text}`).join("\n\n");
       }
     });
   });
+  function sortGitHubRepositories(repositories) {
+    return [
+      ...repositories
+    ].sort((left, right) => {
+      const fullNameCompare = left.fullName.localeCompare(right.fullName);
+      if (fullNameCompare !== 0) {
+        return fullNameCompare;
+      }
+      const nameCompare = left.name.localeCompare(right.name);
+      if (nameCompare !== 0) {
+        return nameCompare;
+      }
+      return left.id - right.id;
+    });
+  }
+  function formatRepositoryVisibility(repository) {
+    return repository.private ? "private" : "public";
+  }
+  function printHumanRepositoryList(repositories) {
+    if (repositories.length === 0) {
+      console.log("No GitHub repositories found.");
+      return;
+    }
+    console.log(renderTerminalTable([
+      {
+        header: "ID"
+      },
+      {
+        header: "Repository"
+      },
+      {
+        header: "Visibility"
+      }
+    ], repositories.map((repository) => [
+      repository.id,
+      repository.fullName,
+      formatRepositoryVisibility(repository)
+    ])));
+  }
+  const githubCommand = new Command("github").description("Manage GitHub repositories linked to a workspace").addCommand(new Command("list").description("List GitHub repositories linked to a workspace").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--json", "Print JSON output").option("--debug", "Enable debug output").action(async (options) => {
+    await runOneShotCommand("github", options, async () => {
+      const auth = getAuthContextOrThrow$1("github");
+      const workspace = await resolveWorkspaceOrThrow$1(auth, options.workspace);
+      const repositories = sortGitHubRepositories(await listWorkspaceGitHubRepositoriesForCliToken({
+        token: auth.token,
+        workspaceId: workspace.id
+      }));
+      if (options.json) {
+        printJson({
+          ok: true,
+          workspaceId: workspace.id,
+          repositories: repositories.map((repository) => ({
+            id: repository.id,
+            name: repository.name,
+            fullName: repository.fullName,
+            private: repository.private
+          }))
+        });
+        return;
+      }
+      printHumanRepositoryList(repositories);
+    });
+  }));
   var main = {
     exports: {}
   };
@@ -146824,6 +147227,7 @@ ${entry2.text}`).join("\n\n");
   program.addCommand(agentConfigCommand);
   program.addCommand(machineCommand);
   program.addCommand(exportCommand);
+  program.addCommand(githubCommand);
   program.configureHelp({
     sortSubcommands: true,
     subcommandTerm: (cmd) => cmd.name() + " " + cmd.usage()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.41.7-next.1",
+  "version": "0.41.8-next.1",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",