Cross-project coordination: a driver conversation that reads, dispatches, and verifies across projects

[RyanSeanPhillips]

Summary

Let one conversation drive coordinated work across projects: design a change in its own project, then read the other project's state, and dispatch the needed change there — either by injecting a prompt into a running session or by launching a new coordinated session — and verify it kicked off.

This is the driver/lead model (asymmetric orchestration), not symmetric peer chat. One conversation leads; the other project executes the requested change.

Motivating use case

Working in physiometrics, I add richer error reporting. The analytics app must change to consume it. Today there's no channel for the two conversations to coordinate, so I relay everything by hand. I want the physiometrics conversation to: design the error payload → look at what analytics needs → ask analytics to update (inject into its running session, or start a coordinated session there) → confirm it's on track.

The driver's three capabilities

1. Read the other project. See what needs doing in analytics without leaving physiometrics. Composes existing tools: get_project_context, search_conversations, or consult_agent (runs the analytics agent read-only with that repo's context). Possibly a thin read_project_file/listing helper.
2. Dispatch the work. Two ways:
   • Inject into a running session — deliver a prompt into analytics' live cockpit tile (Method B), prefill + confirm (operator gates it; also the loop-guard). Cockpit-only (external terminals have no stdin IPC) → falls back to (queue/launch).
   • Launch a new coordinated session — launch_session({ project: "analytics", prompt: "<coordinated brief>" }) seeds the task context. (Multi-word prompts now arrive intact — launch_session truncates multi-word prompt to first token #8 fixed.)
3. Verify / read-back. Confirm the dispatched session received the brief and started on-task by reading its opening turns (correlate via get_active_sessions → newest session in the project). This is primitive CLD CTRL rebrand + cross-platform CLI/TUI #1 of Verify launched-session kickoff + allow early interjection (read-back + message-in) #9.

Shared coordination thread (optional richer mode)

For back-and-forth on a longer task: a coordination task in the control-plane task store = { id, projects[], goal, append-only message log tagged by author project, per-project last-read marker }, with create_coordination_task / post_to_task / read_task_thread MCP tools. A post is delivered to the peer via Method B (prefill+confirm) if running, else queued with a 📥 badge + offered on next launch. Personas instruct each session: "you're collaborating with on task ; post progress + open questions and check the thread before finalizing interfaces."

Delivery baseline (Method A — always works)

send_project_feedback({ project, note }) writes to the target project's queue (control dir, keyed by path); surfaced as a 📥 dashboard badge + nudge + an offer to inject pending notes into the kickoff on next launch_session. Works even when the target isn't running, and for external sessions.

Proposed build order

1. Feedback baseline (A): send_project_feedback + queue + dashboard badge + launch-inject offer.
2. Live inject (B): deliver a note into a running cockpit tile, prefill + confirm.
3. Driver verbs: read-the-other-project helper + launch_session coordinated-brief ergonomics + read-back/verify (overlaps Verify launched-session kickoff + allow early interjection (read-back + message-in) #9).
4. Coordination thread: shared task + post/read tools + persona wiring.

Decisions

• Live inject is prefill + confirm (human gates each hop; doubles as loop-guard). A later "auto-relay" mode could drop the confirm with a turn cap.

Relates to #9 (read-back + message-in primitives this builds on). Most of it composes existing MCP tools (get_project_context, consult_agent, launch_session) plus the new feedback/inject bridge.