Function dispatchHeadlessTaskMethod

src/workspaces/service.ts:543–639

(
    ws: WorkspaceMeta,
    adapter: CliAdapter,
    prompt: string,
    timeoutMs: number,
    // The firing issue's id, when this dispatch came from the ScheduleScanner.
    // Manual/external runs (the workspace "run task" route) leave it undefined.
    issueId?: string,
  )

   * Throws `HeadlessCapacityError` when too many tasks are already in flight.
   */
  const dispatchHeadlessTaskMethod = async (
    ws: WorkspaceMeta,
    adapter: CliAdapter,
    prompt: string,
    timeoutMs: number,
    // The firing issue's id, when this dispatch came from the ScheduleScanner.
    // Manual/external runs (the workspace "run task" route) leave it undefined.
    issueId?: string,
  ): Promise<{ taskId: string }> => {
    if (!adapter.capabilities.headless || !adapter.composeHeadlessCommand) {
      throw new Error(`adapter "${adapter.id}" has no headless mode`);
    }
    await ensureAgentCredentialReady({
      meta: ws,
      agentId: adapter.id,
      adapter,
      logger: launcherLogger,
    });
    if (headlessTasks.runningCount() >= MAX_CONCURRENT_HEADLESS) {
      throw new HeadlessCapacityError(MAX_CONCURRENT_HEADLESS);
    }
    const rec = await headlessTasks.create({
      wsId: ws.id,
      agent: adapter.id,
      prompt,
      startedAt: Date.now(),
      ...(issueId ? { issueId } : {}),
    });
    // Fire-and-forget: run to natural exit, then fill the record. NOTE: status
    // is judged by exit code — pi can exit 0 on an in-band model error, so
    // "done" means "process exited cleanly", not "the agent succeeded"; the
    // operator confirms via the Inbox / the task's tail.
    void runHeadlessTaskMethod(ws, adapter, prompt, timeoutMs, {
      taskId: rec.taskId,
      onSessionId: (id) =>
        void headlessTasks
          .setAgentSessionId(rec.taskId, id)
          .catch((err) =>
            launcherLogger.warn('headless.session_id_record_failed', { taskId: rec.taskId, err }),
          ),
    })
      .then(async (r) => {
        const status = r.killed ? 'failed' : r.exitCode === 0 ? 'done' : 'failed';
        await headlessTasks.complete(rec.taskId, {
          status,
          finishedAt: Date.now(),
          durationMs: r.durationMs,
          exitCode: r.exitCode,
          signal: r.signal,
          killed: r.killed,
        });
        // Scheduled one-shot issues are the only board items whose lifecycle can
        // be closed mechanically from a run exit. Repeating schedules keep their
        // issue open; failed one-shots stay open so the operator can inspect and
        // decide whether to rerun.
        try {
          const issueCompletion = await completeOneShotIssueAfterRun({
            wsDir: ws.dir,