vscode-cowriting-plugin-content/issues/coauthoring-plugin-on-cline.md

Summary

An inner-loop VS Code extension that delivers human+machine coauthoring on local files — live human/Claude attribution (what the machine changed vs. what you changed, in the buffer), region-anchored threads, and a propose/accept flow — built as a standalone extension on Cline's @cline/sdk agent.

Problem / pain

Coauthoring with an AI in the editor today has no persistent threads and no solid attribution/provenance: you can't see which spans the machine wrote vs. which you wrote, and discussion isn't anchored to document regions. Claude for VS Code can take a highlighted region as context but keeps no durable record. The forge (Gitea / rfc-app) is the outer loop — review, multi-party deliberation, a durable record. The inner loop, where writing actually happens keystroke by keystroke, has no home.

Who feels it

A writer/engineer coauthoring prose or specs with Claude inside VS Code — one human + one machine to start. (Later rungs add teams and the public process.)

Desired outcome / value

The editor becomes a real coauthoring surface: attribution + anchored threads

• propose/accept, persisted git-natively so it is serverless, durable, and portable up to the Gitea rung later without re-homing. This validates the coauthoring UX as the cheapest, fastest path to the core value — before any server or Gitea investment.

Acceptance — "done right"

A human can coauthor a document with Claude in VS Code and:

• see, live in the buffer, which spans are human vs. Claude (attribution);
• attach threads to document regions that survive the document being edited;
• accept / reject Claude's proposed diffs (propose-by-default);
• with all provenance and threads stored as git-native artifacts (no server).

(Epic-level end-state; the Features below refine each piece.)

Scope / non-goals

In scope: standalone extension on @cline/sdk; 1 human + 1 machine; local files; git-native persistence of attribution + threads.

Out of scope (deferred, not forgotten): turn-taking choreography; multi-file orchestration; the Gitea team rung (rfc-app#46); the rfc-app public-process rung; other editors (JetBrains, etc.); any server for v1.

Assumptions · constraints · dependencies

• Architecture = Approach A: a standalone extension that drives the agent via @cline/sdk — not a fork of Cline, not a companion trying to extend Cline's UI (VS Code extensions can't easily extend another's UI — rfc-app#48 Q2).
• Built on Cline @cline/sdk (Apache-2.0; programmatic agent + tool/plugin registration + MCP). Depends on its API stability.
• Part of a three-rung ladder, each a client of one shared git-native model (provenance, attributed diffs, anchored threads): editor (this) → Gitea substrate (#46) → rfc-app. git is truth; the surfaces are clients.
• Blocks: nothing yet. Source: rfc-app#48.

Source / signal

• ben.stull/rfc-app#48 — "VS Code coauthoring plugin: the inner-loop rung" (the capture-phase seed for this Epic), sibling of #46 (Gitea substrate rung).
• Capture session vs-code-cowriting-plugin-0001 — Approach decision (standalone on @cline/sdk) explored here against Cline's published SDK.

Priority (WSJF)

Provisional: Value high (core new capability + seeds the ladder) · Time-criticality medium · Opportunity-enablement high ÷ Size large (epic) → P1.

Decomposition (Epic → Features)

Decomposed one level at a time — only the first Feature is filed now; the rest are the planned shape, filed later as the Epic advances:

• F1 — POC: runnable extension skeleton that drives @cline/sdk → #2 (filed this session — de-risks Approach A and establishes the project skeleton).
• F2 — Region-anchored threads (VS Code Comments API), persisted git-natively.
• F3 — Live human/Claude attribution (Decorations API), tracking applied-proposal edits vs. human keystrokes.
• F4 — Propose/accept diff flow (inline-diff keep/reject).
• F5 — Git-native persistence format (.threads/ sidecar vs. git notes vs. trailers) + round-trip to the Gitea rung (#46).

Solution notes (optional — NOT a design)

Native primitives already exist for the differentiated bits: Comments API for region threads, Decorations API for attribution, inline-diff keep/reject for propose-by-default. @cline/sdk supplies the agent without a fork. The full Solution Design (git-native format, live-attribution anchoring, where Claude runs, server-or-not) is a follow-on brainstorming session — see rfc-app#48's open questions.