Todoist as Async Conversation Channel

Agent creates task: "Should we use LiveKit or ElevenLabs for voice? (ADR-0043)"
  → Joel comments from phone: "LiveKit, we want self-hosted"
    → Agent picks up comment, has full task context
      → Agent responds: "Done. Updated ADR-0043 for LiveKit. Created 3 subtasks."
        → Joel taps ✅

┌─────────────┐     ┌──────────────┐     ┌─────────────────┐
│   Todoist    │     │   Inngest    │     │   Agent Loop    │
│  (Joel's     │────▶│   Cron       │────▶│   Function      │
│   phone)    │     │  (2 min poll)│     │                 │
└─────────────┘     └──────────────┘     └────────┬────────┘
       ▲                                          │
       │            ┌──────────────┐              │
       └────────────│  Todoist API │◀─────────────┘
         comment    │  addComment  │   agent reply
                    └──────────────┘

// Inngest cron: every 2 minutes
inngest.createFunction(
  { id: "todoist-comment-poll" },
  { cron: "*/2 * * * *" },
  async ({ step }) => {
    const lastCheck = await step.run("get-last-check", () =>
      redis.get("todoist:last-comment-check")
    );
 
    const activities = await step.run("poll-activities", () =>
      todoist.getActivities({
        objectEventTypes: ["note:added"],
        dateFrom: lastCheck || new Date(Date.now() - 120_000).toISOString(),
        annotateNotes: true,    // includes comment content
        annotateParents: true,  // includes parent task info
      })
    );
 
    // Filter to comments by Joel (not by the agent)
    const joelComments = activities.results.filter(
      a => a.initiator_id !== AGENT_USER_ID
    );
 
    for (const comment of joelComments) {
      await step.sendEvent("emit-comment", {
        name: "todoist/comment.added",
        data: {
          taskId: comment.parent_item_id,
          commentContent: comment.extra_data?.content,
          taskContent: comment.extra_data?.parent_name,
        },
      });
    }
 
    await step.run("update-checkpoint", () =>
      redis.set("todoist:last-comment-check", new Date().toISOString())
    );
  }
);

inngest.createFunction(
  { id: "todoist-comment-respond" },
  { event: "todoist/comment.added" },
  async ({ event, step }) => {
    // Load full task context
    const task = await step.run("load-task", () =>
      todoist.getTask(event.data.taskId)
    );
 
    const { results: comments } = await step.run("load-comments", () =>
      todoist.getComments({ taskId: event.data.taskId })
    );
 
    // Build conversation from task + comments
    const conversation = [
      { role: "system", content: buildTaskSystemPrompt(task) },
      ...comments.map(c => ({
        role: c.postedBy === AGENT_USER_ID ? "assistant" : "user",
        content: c.content,
      })),
    ];
 
    // Agent processes and decides action
    const response = await step.ai.infer("respond", {
      model: "anthropic/claude-sonnet",
      body: { messages: conversation },
    });
 
    // Post reply as comment
    await step.run("post-reply", () =>
      todoist.addComment({
        taskId: event.data.taskId,
        content: response.choices[0].message.content,
      })
    );
 
    // Agent may also take actions based on the conversation
    const actions = parseActions(response);
    if (actions.complete) {
      await step.run("complete-task", () =>
        todoist.closeTask(event.data.taskId)
      );
    }
    if (actions.createSubtasks) {
      for (const subtask of actions.createSubtasks) {
        await step.run(`create-subtask-${subtask.id}`, () =>
          todoist.addTask({ ...subtask, parentId: event.data.taskId })
        );
      }
    }
  }
);

// Agent needs a decision
await todoist.addTask({
  content: "Choose: LiveKit (self-hosted) or ElevenLabs (managed) for voice?",
  description: [
    "## Context",
    "ADR-0043 Phase 3 needs a realtime voice provider.",
    "",
    "## Options",
    "1. **LiveKit Agents** — OSS, self-host on k8s, WebRTC, pluggable STT/LLM/TTS",
    "2. **ElevenLabs Agents** — managed, WebSocket, good TTS, less control",
    "",
    "## My recommendation",
    "LiveKit — aligns with self-hosted principle, already have k8s cluster.",
    "",
    "**Reply with your choice and I'll update the ADR.**",
  ].join("\n"),
  labels: ["review"],
  priority: 2,
});

function buildTaskSystemPrompt(task: Task): string {
  return [
    "You are Joel's AI assistant, responding in the context of a specific task.",
    `Task: ${task.content}`,
    task.description ? `\nBrief:\n${task.description}` : "",
    `\nProject: ${task.projectId}`,
    task.labels.length ? `Labels: ${task.labels.join(", ")}` : "",
    task.due ? `Due: ${task.due.string}` : "",
    "\nRules:",
    "- Be concise — this is a task comment, not an essay",
    "- If you can take action (update ADRs, create tasks, run code), do it and report what you did",
    "- If you need more info, ask a specific question",
    "- If the decision is made, summarize the outcome and complete the task",
  ].join("\n");
}