inplan 0.1.0

package/bin/cli.js

@@ -0,0 +1,1409 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn as spawn2 } from "child_process";
+import { createRequire } from "module";
+import { appendFileSync as appendFileSync2, copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename3, dirname as dirname6, join as join5, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// ../core/dist/chunk-7QR2RJUX.js
+function isReply(c) {
+  return c.parentId !== void 0;
+}
+function isDocComment(c) {
+  return c.anchor === "doc";
+}
+function isSpanComment(c) {
+  return !isReply(c) && !isDocComment(c);
+}
+var COMMENT_ID_RE = /^cmt-[0-9a-z]+$/;
+var ANCHOR_LINK_RE = /\]\(#(cmt-[0-9a-z]+)\)/gi;
+function stripCode(body) {
+  let inFence = false;
+  const out = [];
+  for (const line of body.split("\n")) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      inFence = !inFence;
+      out.push("");
+    } else if (inFence) {
+      out.push("");
+    } else {
+      out.push(line.replace(/`[^`]*`/g, ""));
+    }
+  }
+  return out.join("\n");
+}
+function extractAnchorIdList(body) {
+  const ids = [];
+  for (const m of stripCode(body).matchAll(ANCHOR_LINK_RE)) {
+    ids.push(m[1].toLowerCase());
+  }
+  return ids;
+}
+function extractAnchorIds(body) {
+  return new Set(extractAnchorIdList(body));
+}
+function anchorLinkCounts(body) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const id of extractAnchorIdList(body)) {
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  return counts;
+}
+var BLOCK_OPEN = "<!--inplan";
+var BLOCK_CLOSE = "-->";
+var DOC_FORMAT_VERSION = 1;
+function findBlockOpen(markdown) {
+  let inFence = false;
+  let offset = 0;
+  for (const line of markdown.split("\n")) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      inFence = !inFence;
+    } else if (!inFence) {
+      const trimmed = line.trimStart();
+      if (trimmed.startsWith(BLOCK_OPEN)) return offset + (line.length - trimmed.length);
+    }
+    offset += line.length + 1;
+  }
+  return -1;
+}
+function parse(markdown) {
+  const openIdx = findBlockOpen(markdown);
+  if (openIdx === -1) {
+    return { body: markdown.replace(/\s+$/, ""), comments: [], version: DOC_FORMAT_VERSION };
+  }
+  const afterOpen = openIdx + BLOCK_OPEN.length;
+  const closeIdx = markdown.indexOf(BLOCK_CLOSE, afterOpen);
+  if (closeIdx === -1) {
+    throw new ParseError("comment data block is not closed with `-->`");
+  }
+  let inner = markdown.slice(afterOpen, closeIdx);
+  let version = DOC_FORMAT_VERSION;
+  const versionMatch = /^[^\S\n]*v(\d+)\b/.exec(inner);
+  if (versionMatch) {
+    version = Number(versionMatch[1]);
+    inner = inner.slice(versionMatch[0].length);
+  }
+  const jsonText = inner.trim();
+  let comments;
+  try {
+    const parsed = jsonText.length === 0 ? [] : JSON.parse(jsonText);
+    if (!Array.isArray(parsed)) {
+      throw new ParseError("comment data block must contain a JSON array");
+    }
+    comments = parsed;
+  } catch (err) {
+    if (err instanceof ParseError) throw err;
+    throw new ParseError(`comment data block is not valid JSON: ${err.message}`);
+  }
+  const body = markdown.slice(0, openIdx).replace(/\s+$/, "");
+  return { body, comments, version };
+}
+function serialize(doc) {
+  const body = doc.body.replace(/\s+$/, "");
+  const json = JSON.stringify(doc.comments, null, 2);
+  const version = doc.version ?? DOC_FORMAT_VERSION;
+  const block = `${BLOCK_OPEN} v${version}
+${json}
+${BLOCK_CLOSE}
+`;
+  return body.length === 0 ? `
+${block}` : `${body}
+
+${block}`;
+}
+var ParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+  }
+};
+function checkIntegrity(doc) {
+  const errors = [];
+  const byId = /* @__PURE__ */ new Map();
+  const linkCounts = anchorLinkCounts(doc.body);
+  for (const c of doc.comments) {
+    if (!COMMENT_ID_RE.test(c.id)) {
+      errors.push({ code: "malformed_id", commentId: c.id, message: `malformed comment id: ${JSON.stringify(c.id)}` });
+    }
+    if (byId.has(c.id)) {
+      errors.push({ code: "duplicate_id", commentId: c.id, message: `duplicate comment id: ${c.id}` });
+    } else {
+      byId.set(c.id, c);
+    }
+  }
+  for (const c of doc.comments) {
+    const count = linkCounts.get(c.id) ?? 0;
+    if (isSpanComment(c)) {
+      if (count === 0) {
+        errors.push({ code: "span_missing_link", commentId: c.id, message: `span comment ${c.id} has no in-body anchor link` });
+      } else if (count > 1) {
+        errors.push({ code: "span_duplicate_link", commentId: c.id, message: `span comment ${c.id} has ${count} anchor links (expected 1)` });
+      }
+    } else if (count > 0) {
+      const kind = isReply(c) ? "reply" : "document-level comment";
+      errors.push({ code: "nonspan_has_link", commentId: c.id, message: `${kind} ${c.id} must not have an in-body anchor link` });
+    }
+    if (isReply(c) && !byId.has(c.parentId)) {
+      errors.push({ code: "missing_parent", commentId: c.id, message: `comment ${c.id} references missing parent ${c.parentId}` });
+    }
+  }
+  for (const [id] of linkCounts) {
+    const target = byId.get(id);
+    if (!target) {
+      errors.push({ code: "dangling_link", commentId: id, message: `anchor link #${id} has no matching comment` });
+    } else if (!isSpanComment(target)) {
+      errors.push({ code: "link_targets_nonspan", commentId: id, message: `anchor link #${id} targets a non-span comment` });
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+function findOrphans(doc) {
+  const links = extractAnchorIds(doc.body);
+  return doc.comments.filter((c) => isSpanComment(c) && !links.has(c.id));
+}
+function detectLostComments(prev, next) {
+  const previouslyOrphaned = new Set(findOrphans(prev).map((c) => c.id));
+  return findOrphans(next).filter((c) => !previouslyOrphaned.has(c.id));
+}
+var CONTROL_LOG_VERSION = 1;
+var LogEventType = {
+  EditorPid: "editor_pid",
+  ModeChanged: "mode_changed",
+  CommentCreated: "comment_created",
+  CommentModified: "comment_modified",
+  CommentDeleted: "comment_deleted",
+  CommentResolved: "comment_resolved",
+  CommentAnswered: "comment_answered",
+  DocumentEdited: "document_edited",
+  TurnEnded: "turn_ended",
+  AgentRevised: "agent_revised",
+  AgentRevisionProposed: "agent_revision_proposed",
+  RevisionHunkAccepted: "revision_hunk_accepted",
+  RevisionHunkRejected: "revision_hunk_rejected",
+  RevisionAcceptedAll: "revision_accepted_all",
+  RevisionRejectedAll: "revision_rejected_all",
+  SettingsChanged: "settings_changed",
+  AgentDoneSuggested: "agent_done_suggested",
+  ReloadSuggested: "reload_suggested",
+  /** Cloud→local handoff: a human on the web asked the attached local agent to
+   *  bring the doc back to disk (the inverse of "Collaborate on Cloud"). */
+  SaveLocallyRequested: "save_locally_requested",
+  /** Turn-mode escape: the human reclaimed control after the agent failed to hand it back. */
+  HumanReclaimed: "human_reclaimed",
+  /** In-window navigation: the editor followed a Markdown link to a sibling doc.
+   *  Payload `{ path }` is the new doc; the attached agent's `wait` steps down and
+   *  the human's agent re-attaches there (the local analogue of save-locally). */
+  NavigatedTo: "navigated_to",
+  SessionClosed: "session_closed"
+};
+function serializeLogEntry(entry) {
+  return JSON.stringify(entry);
+}
+function parseLogLine(line) {
+  return JSON.parse(line);
+}
+function parseLog(text) {
+  return text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).map(parseLogLine);
+}
+
+// ../core/dist/node.js
+import { appendFileSync, closeSync, existsSync, openSync, readFileSync, readSync, statSync } from "fs";
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  unlinkSync,
+  unwatchFile,
+  watch,
+  watchFile,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { homedir } from "os";
+import { basename, dirname, join as join2, relative, resolve } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+function readLog(path) {
+  if (!existsSync(path)) return [];
+  return parseLog(readFileSync(path, "utf8"));
+}
+function readLogIncrement(path, byteOffset) {
+  if (!existsSync(path)) return { entries: [], offset: 0, reset: byteOffset !== 0 };
+  const size = statSync(path).size;
+  if (size < byteOffset) return { entries: [], offset: 0, reset: true };
+  if (size === byteOffset) return { entries: [], offset: byteOffset, reset: false };
+  const len = size - byteOffset;
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.allocUnsafe(len);
+    const got = readSync(fd, buf, 0, len, byteOffset);
+    const chunk = buf.toString("utf8", 0, got);
+    const lastNl = chunk.lastIndexOf("\n");
+    if (lastNl === -1) return { entries: [], offset: byteOffset, reset: false };
+    const complete = chunk.slice(0, lastNl + 1);
+    return { entries: parseLog(complete), offset: byteOffset + Buffer.byteLength(complete, "utf8"), reset: false };
+  } finally {
+    closeSync(fd);
+  }
+}
+function appendLog(path, entry) {
+  const existing = readLog(path);
+  const seq = existing.length ? existing[existing.length - 1].seq + 1 : 1;
+  const full = {
+    seq,
+    ts: entry.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    actor: entry.actor,
+    type: entry.type,
+    ...entry.payload !== void 0 ? { payload: entry.payload } : {}
+  };
+  appendFileSync(path, serializeLogEntry(full) + "\n");
+  return full;
+}
+var MAX_BACKUPS = 25;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var FsControlChannel = class {
+  constructor(paths) {
+    this.paths = paths;
+  }
+  paths;
+  // Incremental-read state: bytes already consumed + the entries parsed so far.
+  // Lets readSince parse only newly-appended bytes (O(new)) rather than re-reading
+  // the whole log each poll, while still seeing appends from other processes
+  // (the editor) since it re-stats to the current size every call.
+  byteOffset = 0;
+  parsed = [];
+  append(event) {
+    return Promise.resolve(appendLog(this.paths.logPath, event));
+  }
+  readSince(cursor) {
+    let inc = readLogIncrement(this.paths.logPath, this.byteOffset);
+    if (inc.reset) {
+      this.parsed = [];
+      this.byteOffset = 0;
+      inc = readLogIncrement(this.paths.logPath, 0);
+    }
+    if (inc.entries.length) this.parsed.push(...inc.entries);
+    this.byteOffset = inc.offset;
+    const entries = this.parsed.filter((e) => e.seq > cursor);
+    const next = this.parsed.length ? this.parsed[this.parsed.length - 1].seq : cursor;
+    return Promise.resolve({ entries, cursor: next });
+  }
+  subscribe(onChange) {
+    let timer = null;
+    const fire = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(onChange, 50);
+    };
+    try {
+      const watcher = watch(this.paths.logPath, fire);
+      return () => {
+        if (timer) clearTimeout(timer);
+        watcher.close();
+      };
+    } catch {
+      const listener = () => fire();
+      watchFile(this.paths.logPath, { interval: 200 }, listener);
+      return () => {
+        if (timer) clearTimeout(timer);
+        unwatchFile(this.paths.logPath, listener);
+      };
+    }
+  }
+  getCursor() {
+    if (!existsSync2(this.paths.cursorPath)) return Promise.resolve(0);
+    const n = Number(readFileSync2(this.paths.cursorPath, "utf8").trim());
+    return Promise.resolve(Number.isFinite(n) ? n : 0);
+  }
+  setCursor(seq) {
+    writeFileSync(this.paths.cursorPath, String(seq));
+    return Promise.resolve();
+  }
+  claimLock(token) {
+    writeFileSync(this.paths.waitLockPath, token);
+    return Promise.resolve();
+  }
+  isSuperseded(token) {
+    if (!existsSync2(this.paths.waitLockPath)) return Promise.resolve(false);
+    return Promise.resolve(readFileSync2(this.paths.waitLockPath, "utf8").trim() !== token);
+  }
+  presence() {
+    const log = readLog(this.paths.logPath);
+    for (let i = log.length - 1; i >= 0; i--) {
+      if (log[i].type === LogEventType.EditorPid) {
+        const pid = log[i].payload?.pid;
+        return Promise.resolve(typeof pid === "number" && isProcessAlive(pid));
+      }
+    }
+    return Promise.resolve(false);
+  }
+};
+var FsDocumentStore = class {
+  constructor(paths) {
+    this.paths = paths;
+  }
+  paths;
+  readOrNull(path) {
+    return existsSync2(path) ? readFileSync2(path, "utf8") : null;
+  }
+  loadDoc() {
+    return Promise.resolve(readFileSync2(this.paths.file, "utf8"));
+  }
+  saveDoc(content) {
+    writeFileSync(this.paths.file, content);
+    return Promise.resolve();
+  }
+  getCanonical() {
+    return Promise.resolve(this.readOrNull(this.paths.canonicalPath));
+  }
+  setCanonical(content) {
+    writeFileSync(this.paths.canonicalPath, content);
+    return Promise.resolve();
+  }
+  getProposed() {
+    return Promise.resolve(this.readOrNull(this.paths.proposedPath));
+  }
+  setProposed(content) {
+    writeFileSync(this.paths.proposedPath, content);
+    return Promise.resolve();
+  }
+  clearProposed() {
+    if (existsSync2(this.paths.proposedPath)) unlinkSync(this.paths.proposedPath);
+    return Promise.resolve();
+  }
+  backup(content) {
+    mkdirSync(this.paths.backupsDir, { recursive: true });
+    const seqs = this.backupSeqs();
+    const next = (seqs.at(-1) ?? 0) + 1;
+    writeFileSync(join(this.paths.backupsDir, `autosave-${next}.md`), content);
+    for (const n of seqs.slice(0, Math.max(0, seqs.length + 1 - MAX_BACKUPS))) {
+      try {
+        unlinkSync(join(this.paths.backupsDir, `autosave-${n}.md`));
+      } catch {
+      }
+    }
+    return Promise.resolve();
+  }
+  backupSeqs() {
+    if (!existsSync2(this.paths.backupsDir)) return [];
+    return readdirSync(this.paths.backupsDir).map((name) => /^autosave-(\d+)\.md$/.exec(name)?.[1]).filter((n) => n != null).map(Number).sort((a, b) => a - b);
+  }
+};
+function sidecarRoot() {
+  if (process.env.INPLAN_SIDECAR_DIR) return process.env.INPLAN_SIDECAR_DIR;
+  const home = process.env.INPLAN_HOME || join2(homedir(), ".inplan");
+  return join2(home, "sidecars");
+}
+function repoRootOf(absFile) {
+  let dir = dirname(absFile);
+  for (; ; ) {
+    if (existsSync3(join2(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function docPaths(file) {
+  const abs = resolve(file);
+  const root = repoRootOf(abs);
+  const raw = root ? `${basename(root)}/${relative(root, abs)}` : `${basename(dirname(abs))}/${basename(abs)}`;
+  const label = raw.replace(/[/\\]+/g, "-").replace(/[^A-Za-z0-9._-]/g, "_");
+  const key = `${label}-${createHash("sha1").update(abs).digest("hex").slice(0, 12)}`;
+  const controlDir = join2(sidecarRoot(), key);
+  return {
+    file: abs,
+    controlDir,
+    logPath: join2(controlDir, "log.jsonl"),
+    canonicalPath: join2(controlDir, "canonical.md"),
+    backupsDir: join2(controlDir, "backups"),
+    proposedPath: join2(controlDir, "proposed.md"),
+    cursorPath: join2(controlDir, "cursor"),
+    waitLockPath: join2(controlDir, "waitlock"),
+    waitDebugPath: join2(controlDir, "wait-debug.log"),
+    statusPath: join2(controlDir, "status.json")
+  };
+}
+var DEFAULT_SETTINGS = { autoResolve: true };
+function globalSettingsPath() {
+  const base = process.env.INPLAN_HOME || join3(homedir2(), ".inplan");
+  return join3(base, "settings.json");
+}
+function readGlobalSettings() {
+  const path = globalSettingsPath();
+  if (!existsSync4(path)) return { ...DEFAULT_SETTINGS };
+  try {
+    const raw = JSON.parse(readFileSync3(path, "utf8"));
+    return { ...DEFAULT_SETTINGS, ...raw };
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+function settingsFromEntries(entries, base = readGlobalSettings()) {
+  const settings = { ...base };
+  for (const e of entries) {
+    if (e.type === LogEventType.SettingsChanged && e.payload && typeof e.payload === "object") {
+      Object.assign(settings, e.payload);
+    }
+  }
+  return settings;
+}
+var DEFAULT_STATUS = { location: "local" };
+function hashBody(text) {
+  return createHash2("sha256").update(text, "utf8").digest("hex");
+}
+function readStatus(statusPath) {
+  if (!existsSync5(statusPath)) return { ...DEFAULT_STATUS };
+  try {
+    const raw = JSON.parse(readFileSync4(statusPath, "utf8"));
+    if (raw.location !== "local" && raw.location !== "cloud") return { ...DEFAULT_STATUS };
+    if (raw.location === "cloud" && typeof raw.cloudDocId !== "string") return { ...DEFAULT_STATUS };
+    return { ...DEFAULT_STATUS, ...raw, location: raw.location };
+  } catch {
+    return { ...DEFAULT_STATUS };
+  }
+}
+function writeStatus(statusPath, status) {
+  mkdirSync3(dirname3(statusPath), { recursive: true });
+  writeFileSync3(statusPath, `${JSON.stringify(status, null, 2)}
+`);
+}
+
+// src/cli.ts
+import { HocuspocusProvider, HocuspocusProviderWebsocket } from "@hocuspocus/provider";
+import * as Y from "yjs";
+import WebSocket2 from "ws";
+
+// src/agentAuthor.ts
+function agentAuthorFor(model) {
+  const m = model?.trim();
+  return m ? `Agent (${m}) <agent@inplan>` : "Agent <agent@inplan>";
+}
+
+// src/provenance.ts
+import { execFileSync } from "child_process";
+import { basename as basename2, dirname as dirname4, relative as relative2, sep } from "path";
+var defaultRun = (args, cwd) => {
+  try {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+};
+function repoNameFromRemote(url) {
+  const seg = url.trim().replace(/\.git$/, "").replace(/\/$/, "").split(/[/:]/).filter(Boolean).pop();
+  return seg || null;
+}
+function gitProvenance(file, run = defaultRun) {
+  const dir = dirname4(file);
+  const root = run(["rev-parse", "--show-toplevel"], dir);
+  if (!root) return { repo: "local", path: basename2(file) };
+  const remote = run(["remote", "get-url", "origin"], dir);
+  const repo = remote && repoNameFromRemote(remote) || basename2(root) || "local";
+  const rel = relative2(root, file).split(sep).join("/");
+  return { repo, path: rel || basename2(file) };
+}
+
+// src/cliAuth.ts
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname5, join as join4 } from "path";
+import { createClient as createClient2 } from "@supabase/supabase-js";
+import WebSocket from "ws";
+
+// ../backend-supabase/dist/index.js
+import { createClient } from "@supabase/supabase-js";
+var PRESENCE_TTL_MS = 15e3;
+var SupabaseControlChannel = class {
+  constructor(db, docId, consumerId = "default") {
+    this.db = db;
+    this.docId = docId;
+    this.consumerId = consumerId;
+  }
+  db;
+  docId;
+  consumerId;
+  async append(event) {
+    const { data, error } = await this.db.from("events").insert({ doc_id: this.docId, actor: event.actor, type: event.type, payload: event.payload ?? null }).select("seq, ts, actor, type, payload").single();
+    if (error) throw new Error(`append failed: ${error.message}`);
+    return rowToEntry(data);
+  }
+  async readSince(cursor) {
+    const { data, error } = await this.db.from("events").select("seq, ts, actor, type, payload").eq("doc_id", this.docId).gt("seq", cursor).order("seq", { ascending: true });
+    if (error) throw new Error(`readSince failed: ${error.message}`);
+    const rows = data ?? [];
+    const entries = rows.map(rowToEntry);
+    const last = entries[entries.length - 1];
+    return { entries, cursor: last ? last.seq : cursor };
+  }
+  subscribe(onChange) {
+    const channel = this.db.channel(`events:${this.docId}`).on(
+      "postgres_changes",
+      { event: "INSERT", schema: "public", table: "events", filter: `doc_id=eq.${this.docId}` },
+      () => onChange()
+    ).subscribe();
+    return () => {
+      void this.db.removeChannel(channel);
+    };
+  }
+  async getCursor() {
+    const { data, error } = await this.db.from("cursors").select("seq").eq("doc_id", this.docId).eq("consumer_id", this.consumerId).maybeSingle();
+    if (error) throw new Error(`getCursor failed: ${error.message}`);
+    const seq = data?.seq;
+    return typeof seq === "number" ? seq : 0;
+  }
+  async setCursor(seq) {
+    const { error } = await this.db.from("cursors").upsert({ doc_id: this.docId, consumer_id: this.consumerId, seq }, { onConflict: "doc_id,consumer_id" });
+    if (error) throw new Error(`setCursor failed: ${error.message}`);
+  }
+  async claimLock(token) {
+    const { error } = await this.db.from("locks").upsert({ doc_id: this.docId, token, claimed_at: (/* @__PURE__ */ new Date()).toISOString() }, { onConflict: "doc_id" });
+    if (error) throw new Error(`claimLock failed: ${error.message}`);
+  }
+  async isSuperseded(token) {
+    const { data, error } = await this.db.from("locks").select("token").eq("doc_id", this.docId).maybeSingle();
+    if (error) throw new Error(`isSuperseded failed: ${error.message}`);
+    const current = data?.token;
+    return current != null && current !== token;
+  }
+  async presence() {
+    const { data, error } = await this.db.from("editor_presence").select("last_seen").eq("doc_id", this.docId).maybeSingle();
+    if (error) throw new Error(`presence failed: ${error.message}`);
+    const lastSeen = data?.last_seen;
+    if (!lastSeen) return false;
+    return Date.now() - new Date(lastSeen).getTime() < PRESENCE_TTL_MS;
+  }
+};
+function rowToEntry(r) {
+  return { seq: r.seq, ts: r.ts, actor: r.actor, type: r.type, payload: r.payload ?? void 0 };
+}
+var SupabaseDocumentStore = class {
+  constructor(db, docId) {
+    this.db = db;
+    this.docId = docId;
+  }
+  db;
+  docId;
+  async loadDoc() {
+    return await this.readColumn("body") ?? "";
+  }
+  async saveDoc(content) {
+    await this.writeColumns({ body: content });
+  }
+  async getCanonical() {
+    return this.readColumn("canonical");
+  }
+  async setCanonical(content) {
+    await this.writeColumns({ canonical: content });
+  }
+  async getProposed() {
+    return this.readColumn("proposed");
+  }
+  async setProposed(content) {
+    await this.writeColumns({ proposed: content });
+  }
+  async clearProposed() {
+    await this.writeColumns({ proposed: null });
+  }
+  async backup(content) {
+    const { error } = await this.db.from("doc_versions").insert({ doc_id: this.docId, body: content });
+    if (error) throw new Error(`backup failed: ${error.message}`);
+  }
+  async readColumn(name) {
+    const { data, error } = await this.db.from("documents").select(name).eq("id", this.docId).maybeSingle();
+    if (error) throw new Error(`read ${name} failed: ${error.message}`);
+    const value = data?.[name];
+    return typeof value === "string" ? value : null;
+  }
+  async writeColumns(patch) {
+    const { error } = await this.db.from("documents").update({ ...patch, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", this.docId);
+    if (error) throw new Error(`update failed: ${error.message}`);
+  }
+};
+
+// src/cliAuth.ts
+var realtimeTransport = { transport: WebSocket };
+function authPath() {
+  const base = process.env.INPLAN_HOME || join4(homedir3(), ".inplan");
+  return join4(base, "auth.json");
+}
+function loadAuth() {
+  const path = authPath();
+  if (!existsSync6(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync5(path, "utf8"));
+    if (typeof raw.url === "string" && typeof raw.anonKey === "string" && typeof raw.refreshToken === "string") {
+      return { url: raw.url, anonKey: raw.anonKey, refreshToken: raw.refreshToken, ...raw.email ? { email: raw.email } : {} };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveAuth(auth) {
+  const path = authPath();
+  mkdirSync4(dirname5(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(auth, null, 2)}
+`, { mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function clearAuth() {
+  const path = authPath();
+  if (existsSync6(path)) rmSync(path, { force: true });
+}
+async function authedSession() {
+  const auth = loadAuth();
+  if (!auth) return null;
+  const db = createClient2(auth.url, auth.anonKey, {
+    auth: { persistSession: false, autoRefreshToken: true, detectSessionInUrl: false },
+    realtime: realtimeTransport
+  });
+  const { data, error } = await db.auth.refreshSession({ refresh_token: auth.refreshToken });
+  if (error || !data.session) return null;
+  const rotated = data.session.refresh_token || auth.refreshToken;
+  const email = data.session.user?.email ?? auth.email;
+  if (rotated !== auth.refreshToken || email !== auth.email) {
+    saveAuth({ ...auth, refreshToken: rotated, ...email ? { email } : {} });
+  }
+  return { db, session: data.session };
+}
+async function currentUser() {
+  const s = await authedSession();
+  if (!s) return null;
+  return { id: s.session.user.id, ...s.session.user.email ? { email: s.session.user.email } : {} };
+}
+async function remoteBackend(docId, consumerId = "cli-agent") {
+  const s = await authedSession();
+  if (!s) return null;
+  return {
+    db: s.db,
+    channel: new SupabaseControlChannel(s.db, docId, consumerId),
+    store: new SupabaseDocumentStore(s.db, docId),
+    token: s.session.access_token
+  };
+}
+
+// src/update.ts
+import { spawn } from "child_process";
+var UPDATE_PKG = process.env.INPLAN_PKG || "inplan";
+function compareVersions(a, b) {
+  const parts = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const pa = parts(a);
+  const pb = parts(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+async function latestVersion(pkg) {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${pkg.replace("/", "%2F")}/latest`, { headers: { accept: "application/json" } });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate(opts) {
+  const latest = await (opts.fetchLatest ?? latestVersion)(opts.pkg);
+  return { current: opts.current, latest, updateAvailable: latest !== null && compareVersions(opts.current, latest) < 0 };
+}
+function selfUpdate(pkg) {
+  return new Promise((resolve3) => {
+    const child = spawn("npm", ["install", "-g", `${pkg}@latest`], { stdio: ["ignore", "pipe", "pipe"] });
+    let output2 = "";
+    child.stdout?.on("data", (d) => output2 += d);
+    child.stderr?.on("data", (d) => output2 += d);
+    child.on("error", (e) => resolve3({ ok: false, output: e.message }));
+    child.on("close", (code) => resolve3({ ok: code === 0, output: output2.trim() }));
+  });
+}
+
+// src/editorProcess.ts
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function latestEditorPid(logPath) {
+  const entries = readLog(logPath);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].type === LogEventType.EditorPid) {
+      const pid = entries[i].payload?.pid;
+      return typeof pid === "number" ? pid : null;
+    }
+  }
+  return null;
+}
+function runningEditorPid(logPath) {
+  const pid = latestEditorPid(logPath);
+  return pid !== null && isProcessAlive2(pid) ? pid : null;
+}
+
+// src/gate.ts
+function evaluateAgentEdit(canonicalText, currentText, confirmed) {
+  const current = parse(currentText);
+  const canonical = parse(canonicalText);
+  const lost = detectLostComments(canonical, current);
+  const unconfirmed = lost.filter((c) => !confirmed.has(c.id));
+  const removedIds = lost.filter((c) => confirmed.has(c.id)).map((c) => c.id);
+  const removedSet = new Set(removedIds);
+  const accepted = {
+    body: current.body,
+    comments: current.comments.filter((c) => !removedSet.has(c.id))
+  };
+  const integrityErrors = checkIntegrity(accepted).errors.filter((e) => e.code !== "span_missing_link");
+  return {
+    integrityOk: integrityErrors.length === 0,
+    integrityErrors,
+    lost,
+    unconfirmed,
+    removedIds,
+    acceptedText: serialize(accepted),
+    changed: currentText !== canonicalText
+  };
+}
+
+// src/wait.ts
+var defaultActionable = (e) => e.actor === "user";
+function wakePredicate(cadence) {
+  return cadence === "instant" ? (e) => e.actor === "user" : (e) => e.type === LogEventType.TurnEnded || e.type === LogEventType.SessionClosed || e.type === LogEventType.SaveLocallyRequested || e.type === LogEventType.NavigatedTo;
+}
+function waitForActions(opts) {
+  const debounceMs2 = opts.debounceMs ?? 3e3;
+  const pollMs2 = opts.pollMs ?? 200;
+  const isActionable = opts.isActionable ?? defaultActionable;
+  const watchEditor = opts.watchEditor ?? true;
+  const ch = opts.channel;
+  return new Promise((resolve3, reject) => {
+    let deadline = null;
+    let lastCount = -1;
+    let sawEditorAlive = false;
+    let busy = false;
+    let done = false;
+    const cleanup = () => {
+      clearInterval(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+    };
+    const finish = (r) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      resolve3(r);
+    };
+    const onAbort = () => {
+      if (done) return;
+      done = true;
+      cleanup();
+      reject(new Error("wait aborted"));
+    };
+    const tick = async () => {
+      if (busy || done) return;
+      busy = true;
+      try {
+        const { entries, cursor } = await ch.readSince(opts.cursor);
+        if (done) return;
+        if (opts.token) {
+          try {
+            if (await ch.isSuperseded(opts.token)) {
+              finish({ entries, cursor, superseded: true });
+              return;
+            }
+          } catch {
+          }
+        }
+        if (watchEditor) {
+          let alive = false;
+          try {
+            alive = await ch.presence();
+          } catch {
+          }
+          if (alive) sawEditorAlive = true;
+          else if (sawEditorAlive) {
+            finish({ entries, cursor, editorGone: true });
+            return;
+          }
+        }
+        if (entries.some(isActionable)) {
+          if (entries.length !== lastCount) {
+            lastCount = entries.length;
+            deadline = Date.now() + debounceMs2;
+          } else if (deadline !== null && Date.now() >= deadline) {
+            finish({ entries, cursor });
+          }
+        }
+      } finally {
+        busy = false;
+      }
+    };
+    const timer = setInterval(() => void tick(), pollMs2);
+    opts.signal?.addEventListener("abort", onAbort);
+    void tick();
+  });
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+function output(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+function getFlag(args, name) {
+  const withEq = args.find((a) => a.startsWith(`--${name}=`));
+  if (withEq) return withEq.slice(name.length + 3);
+  const idx = args.indexOf(`--${name}`);
+  if (idx !== -1 && idx + 1 < args.length && !args[idx + 1].startsWith("--")) return args[idx + 1];
+  return void 0;
+}
+function hasFlag(args, name) {
+  return args.includes(`--${name}`);
+}
+var debounceMs = Number(process.env.INPLAN_DEBOUNCE_MS ?? 3e3);
+var pollMs = Number(process.env.INPLAN_POLL_MS ?? 200);
+var COLLAB_URL = process.env.INPLAN_COLLAB_URL || "wss://inplan-collab.fly.dev";
+function announcePresence(docId, token, model) {
+  try {
+    const ydoc = new Y.Doc();
+    const socket = new HocuspocusProviderWebsocket({ url: COLLAB_URL, WebSocketPolyfill: WebSocket2 });
+    const provider = new HocuspocusProvider({ websocketProvider: socket, name: docId, document: ydoc, token });
+    provider.awareness?.setLocalStateField("inplanPresence", { kind: "agent", agentLocation: "local", ...model ? { model } : {} });
+    return {
+      destroy: () => {
+        try {
+          provider.destroy();
+          socket.destroy();
+          ydoc.destroy();
+        } catch {
+        }
+      }
+    };
+  } catch {
+    return { destroy: () => {
+    } };
+  }
+}
+function resolveBundledApp() {
+  try {
+    const here = dirname6(fileURLToPath(import.meta.url));
+    const appMain = join5(here, "..", "app", "main", "index.js");
+    if (!existsSync7(appMain)) return null;
+    const electron = createRequire(import.meta.url)("electron");
+    return typeof electron === "string" ? { electron, appMain } : null;
+  } catch {
+    return null;
+  }
+}
+function spawnApp(file) {
+  const override = process.env.INPLAN_APP_CMD;
+  const bundled = override ? null : resolveBundledApp();
+  if (!override && !bundled) {
+    process.stderr.write("[inplan] no editor available (set INPLAN_APP_CMD, or install the published `inplan` package); running headless\n");
+    return null;
+  }
+  const env = { ...process.env, INPLAN_CLI: process.argv[1] ?? "" };
+  const child = override ? spawn2(override, [file], { detached: true, stdio: "ignore", shell: true, env }) : spawn2(bundled.electron, [bundled.appMain, file], { detached: true, stdio: "ignore", env });
+  child.unref();
+  return child.pid ?? null;
+}
+function cadenceFrom(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].type === LogEventType.ModeChanged) {
+      const c = entries[i].payload?.cadence;
+      if (c === "instant" || c === "turn") return c;
+    }
+  }
+  return "turn";
+}
+function acceptanceFrom(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].type === LogEventType.ModeChanged) {
+      const a = entries[i].payload?.acceptance;
+      if (a === "auto" || a === "review") return a;
+    }
+  }
+  return "auto";
+}
+function maxSeqFrom(entries) {
+  return entries.length ? entries[entries.length - 1].seq : 0;
+}
+function fsBackend(file) {
+  const p = docPaths(file);
+  mkdirSync5(p.controlDir, { recursive: true });
+  return {
+    channel: new FsControlChannel(p),
+    store: new FsDocumentStore(p),
+    history: async () => readLog(p.logPath),
+    logExit: (reason) => logWaitExit(p, reason)
+  };
+}
+function logWaitExit(p, reason) {
+  try {
+    appendFileSync2(p.waitDebugPath, `${(/* @__PURE__ */ new Date()).toISOString()} pid=${process.pid} ${reason}
+`);
+  } catch {
+  }
+}
+async function waitCycle(backend, explicitCursor, confirmed, model) {
+  const { channel, store } = backend;
+  const history = await backend.history();
+  const cursor = explicitCursor ?? (await channel.getCursor() || maxSeqFrom(history));
+  const current = await store.loadDoc();
+  let canonicalText = await store.getCanonical();
+  if (canonicalText === null) {
+    canonicalText = current;
+    await store.setCanonical(current);
+  }
+  const ev = evaluateAgentEdit(canonicalText, current, confirmed);
+  if (ev.unconfirmed.length > 0) {
+    output({
+      status: "confirm_required",
+      message: "Edit removes anchored comment(s). Re-run wait with --confirmed-comment-deletion=<ids> to proceed.",
+      lost: ev.unconfirmed.map((c) => ({ id: c.id, text: c.text, author: c.author }))
+    });
+    process.exit(3);
+  }
+  if (!ev.integrityOk) {
+    output({ status: "integrity_error", errors: ev.integrityErrors });
+    process.exit(2);
+  }
+  const acceptance = acceptanceFrom(history);
+  const bodyChanged = parse(canonicalText).body !== parse(current).body;
+  if (ev.removedIds.length > 0) {
+    await store.saveDoc(ev.acceptedText);
+    await store.setCanonical(ev.acceptedText);
+    await store.clearProposed();
+    await channel.append({ actor: "agent", type: LogEventType.DocumentEdited, payload: { removed: ev.removedIds } });
+  } else if (ev.changed && acceptance === "review" && bodyChanged) {
+    await store.setProposed(current);
+    await store.saveDoc(canonicalText);
+    await channel.append({ actor: "agent", type: LogEventType.AgentRevisionProposed, payload: { bytes: current.length } });
+  } else if (ev.changed) {
+    await store.setCanonical(current);
+    await store.clearProposed();
+    await channel.append({ actor: "agent", type: LogEventType.DocumentEdited, payload: { bytes: current.length } });
+  }
+  await channel.append({ actor: "agent", type: LogEventType.AgentRevised });
+  const lockToken = `${process.pid}-${Date.now()}`;
+  await channel.claimLock(lockToken);
+  for (const sig of ["SIGTERM", "SIGHUP", "SIGINT"]) {
+    process.on(sig, () => {
+      backend.logExit(`signal:${sig}`);
+      process.exit(0);
+    });
+  }
+  const cadence = cadenceFrom(history);
+  const isActionable = wakePredicate(cadence);
+  const result = await waitForActions({ channel, cursor, debounceMs, pollMs, isActionable, token: lockToken });
+  if (result.superseded) {
+    backend.logExit("superseded");
+    output({ status: "superseded" });
+    return;
+  }
+  await channel.setCursor(result.cursor);
+  if (backend.onSaveLocally && result.entries.some((e) => e.type === LogEventType.SaveLocallyRequested)) {
+    backend.logExit("save_locally");
+    await backend.onSaveLocally();
+    return;
+  }
+  const navEntry = result.entries.find((e) => e.type === LogEventType.NavigatedTo);
+  if (navEntry) {
+    const path = navEntry.payload?.path;
+    backend.logExit("navigated");
+    output({ status: "navigated", ...path ? { path } : {}, cursor: result.cursor, closed: false });
+    return;
+  }
+  const closeEntry = result.entries.find((e) => e.type === LogEventType.SessionClosed);
+  let status;
+  let reason;
+  if (closeEntry) {
+    status = "closed";
+    reason = closeEntry.payload?.reason ?? "completed";
+  } else if (result.editorGone) {
+    status = "closed";
+    reason = "crashed_or_killed";
+  } else {
+    status = cadence === "turn" ? "your_turn" : "activity";
+  }
+  backend.logExit(`status:${status}${reason ? `/${reason}` : ""}`);
+  output({
+    status,
+    mode: cadence,
+    humanLocked: status === "your_turn",
+    // Materialized current settings (global file + this session's settings_changed),
+    // so the agent always has them without scanning the log history.
+    settings: settingsFromEntries(history),
+    // The canonical name the agent should author comments under (model-qualified
+    // when --model was passed), so presence + authorship stay consistent.
+    agentAuthor: agentAuthorFor(model),
+    ...reason ? { reason } : {},
+    cursor: result.cursor,
+    closed: status === "closed",
+    entries: result.entries
+  });
+}
+function doLogin(args) {
+  const url = getFlag(args, "url") ?? process.env.INPLAN_SUPABASE_URL;
+  const anonKey = getFlag(args, "anon") ?? process.env.INPLAN_SUPABASE_ANON_KEY;
+  const refreshToken = getFlag(args, "refresh");
+  if (!url || !anonKey || !refreshToken) {
+    process.stderr.write("usage: inplan login --url <url> --anon <anon-key> --refresh <refresh-token> [--email <e>]\n");
+    process.exit(64);
+  }
+  const email = getFlag(args, "email");
+  saveAuth({ url, anonKey, refreshToken, ...email ? { email } : {} });
+  output({ status: "logged_in", url, ...email ? { email } : {} });
+}
+async function runRemote(cmd, docId, explicitCursor, confirmed, rest, localFile, model) {
+  const backend = await remoteBackend(docId, "cli-agent");
+  if (!backend) {
+    process.stderr.write("inplan: not logged in (or session expired) \u2014 run `inplan login`\n");
+    process.exit(1);
+  }
+  if (cmd === "signal") {
+    if (hasFlag(rest, "done")) {
+      await backend.channel.append({ actor: "agent", type: LogEventType.AgentDoneSuggested });
+    }
+    if (hasFlag(rest, "reload")) {
+      await backend.channel.append({ actor: "agent", type: LogEventType.ReloadSuggested });
+    }
+    output({ status: "signaled" });
+    return;
+  }
+  const onSaveLocally = localFile ? async () => {
+    const body = await backend.store.loadDoc();
+    writeFileSync5(localFile, body);
+    writeStatus(docPaths(localFile).statusPath, { location: "local", originalPath: localFile, lastSyncedHash: hashBody(body) });
+    const pid = spawnApp(localFile);
+    output({ status: "moved_local", path: localFile, reopened: pid !== null });
+  } : void 0;
+  const presence = announcePresence(docId, backend.token, model);
+  try {
+    await waitCycle(
+      {
+        channel: backend.channel,
+        store: backend.store,
+        history: async () => (await backend.channel.readSince(0)).entries,
+        logExit: () => {
+        },
+        // no local sidecar for a cloud doc
+        ...onSaveLocally ? { onSaveLocally } : {}
+      },
+      explicitCursor,
+      confirmed,
+      model
+    );
+  } finally {
+    presence.destroy();
+  }
+}
+function doStatus(file) {
+  output(readStatus(docPaths(file).statusPath));
+}
+function doPromote(file, args) {
+  const cloudDocId = getFlag(args, "cloud-doc");
+  if (!cloudDocId) {
+    process.stderr.write("usage: inplan promote <file> --cloud-doc <docId> [--locator org/repo/path]\n");
+    process.exit(64);
+  }
+  const body = existsSync7(file) ? readFileSync6(file, "utf8") : "";
+  const status = { location: "cloud", cloudDocId, originalPath: file, lastSyncedHash: hashBody(body) };
+  const locator = getFlag(args, "locator");
+  if (locator) {
+    const [org, repo, ...rest] = locator.split("/");
+    if (org && repo && rest.length) status.cloudLocator = { org, repo, path: rest.join("/") };
+  }
+  writeStatus(docPaths(file).statusPath, status);
+  output({ status: "promoted", location: "cloud", cloudDocId });
+}
+async function doDemote(file, args) {
+  const p = docPaths(file);
+  const st = readStatus(p.statusPath);
+  if (st.location !== "cloud" || !st.cloudDocId) {
+    process.stderr.write("inplan demote: document is not in the cloud\n");
+    process.exit(1);
+  }
+  const backend = await remoteBackend(st.cloudDocId, "cli-agent");
+  if (!backend) {
+    process.stderr.write("inplan: not logged in (or session expired) \u2014 run `inplan login`\n");
+    process.exit(1);
+  }
+  const body = await backend.store.loadDoc();
+  const dest = st.originalPath ?? file;
+  writeFileSync5(dest, body);
+  writeStatus(p.statusPath, { location: "local", originalPath: dest, lastSyncedHash: hashBody(body) });
+  output({ status: "demoted", location: "local", path: dest });
+}
+function firstHeading(body) {
+  return body.match(/^#\s+(.+?)\s*$/m)?.[1]?.trim() || null;
+}
+async function doWhoami() {
+  const user = await currentUser();
+  if (!user) {
+    output({ signedIn: false });
+    return;
+  }
+  output({ signedIn: true, id: user.id, ...user.email ? { email: user.email } : {} });
+}
+async function doToken() {
+  const s = await authedSession();
+  output(s ? { token: s.session.access_token } : {});
+}
+function bundledSkillPath() {
+  try {
+    const p = join5(dirname6(fileURLToPath(import.meta.url)), "..", "skill", "SKILL.md");
+    return existsSync7(p) ? p : null;
+  } catch {
+    return null;
+  }
+}
+function skillTargets() {
+  const home = homedir4();
+  return [
+    { name: "Claude Code", root: join5(home, ".claude"), target: join5(home, ".claude", "skills", "inplan", "SKILL.md") },
+    { name: "Pi", root: join5(home, ".pi", "agent"), target: join5(home, ".pi", "agent", "skills", "inplan", "SKILL.md") },
+    { name: "Codex", root: join5(home, ".codex"), target: join5(home, ".codex", "skills", "inplan", "SKILL.md") }
+  ];
+}
+function doInstallSkill(args) {
+  const quiet = hasFlag(args, "quiet");
+  if (process.env.INPLAN_NO_SKILL_INSTALL) {
+    if (!quiet) output({ status: "skipped", reason: "INPLAN_NO_SKILL_INSTALL" });
+    return;
+  }
+  const src = bundledSkillPath();
+  if (!src) {
+    if (!quiet) output({ status: "unavailable" });
+    return;
+  }
+  const installed = [];
+  for (const a of skillTargets()) {
+    try {
+      if (!existsSync7(a.root)) continue;
+      if (existsSync7(a.target)) continue;
+      mkdirSync5(dirname6(a.target), { recursive: true });
+      copyFileSync(src, a.target);
+      installed.push(a.name);
+      process.stderr.write(`inplan: installed the inplan skill into ${a.name} (${a.target}). Set INPLAN_NO_SKILL_INSTALL=1 to skip.
+`);
+    } catch {
+    }
+  }
+  if (!quiet) output({ status: "ok", installed });
+}
+function doLogout() {
+  clearAuth();
+  output({ status: "logged_out" });
+}
+async function doUpload(file, args) {
+  const s = await authedSession();
+  if (!s) {
+    process.stderr.write("inplan: not logged in (or session expired) \u2014 run `inplan login`\n");
+    process.exit(1);
+  }
+  const orgSlug = getFlag(args, "org");
+  const { data: mems, error } = await s.db.from("memberships").select("org_id, role, orgs(slug, name)").in("role", ["owner", "editor"]);
+  if (error) {
+    process.stderr.write(`inplan upload: ${error.message}
+`);
+    process.exit(1);
+  }
+  const rows = mems ?? [];
+  const orgOf = (r) => (Array.isArray(r.orgs) ? r.orgs[0] : r.orgs) ?? null;
+  const pick = rows.find((r) => orgSlug ? orgOf(r)?.slug === orgSlug : true);
+  if (!pick) {
+    process.stderr.write(`inplan upload: no organization you can write to${orgSlug ? ` matching "${orgSlug}"` : ""}
+`);
+    process.exit(1);
+  }
+  const org = orgOf(pick);
+  const body = existsSync7(file) ? readFileSync6(file, "utf8") : "";
+  const prov = gitProvenance(file);
+  const repo = getFlag(args, "repo") ?? prov.repo;
+  const path = getFlag(args, "path") ?? prov.path;
+  const title = firstHeading(body) ?? basename3(path);
+  const { data: doc, error: de } = await s.db.from("documents").insert({ org_id: pick.org_id, owner_id: s.session.user.id, title, repo, path, body }).select("id").single();
+  if (de || !doc) {
+    process.stderr.write(`inplan upload: ${de?.message ?? "could not create the cloud document"}
+`);
+    process.exit(1);
+  }
+  const cloudDocId = doc.id;
+  const status = {
+    location: "cloud",
+    cloudDocId,
+    originalPath: file,
+    lastSyncedHash: hashBody(body),
+    ...org?.slug ? { cloudLocator: { org: org.slug, repo, path } } : {}
+  };
+  writeStatus(docPaths(file).statusPath, status);
+  output({ status: "uploaded", cloudDocId, ...org?.slug ? { locator: { org: org.slug, repo, path } } : {} });
+}
+function routeFor(file, cmd, args) {
+  const p = docPaths(file);
+  const status = readStatus(p.statusPath);
+  if (status.location !== "cloud" || !status.cloudDocId) return { kind: "local" };
+  const docId = status.cloudDocId;
+  if (cmd === "signal" || !existsSync7(file)) return { kind: "cloud", docId };
+  const local = readFileSync6(file, "utf8");
+  const diverged = status.lastSyncedHash !== void 0 && hashBody(local) !== status.lastSyncedHash;
+  if (!diverged || hasFlag(args, "use-cloud")) return { kind: "cloud", docId };
+  if (hasFlag(args, "continue-locally")) {
+    writeStatus(p.statusPath, { location: "local", originalPath: file, lastSyncedHash: hashBody(local) });
+    return { kind: "local" };
+  }
+  return { kind: "reconcile", docId };
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  if (cmd === "--version" || cmd === "-v") {
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  if (cmd === "login") {
+    doLogin(argv.slice(1));
+    return;
+  }
+  if (cmd === "whoami") {
+    await doWhoami();
+    return;
+  }
+  if (cmd === "token") {
+    await doToken();
+    return;
+  }
+  if (cmd === "install-skill") {
+    doInstallSkill(argv.slice(1));
+    return;
+  }
+  if (cmd === "logout") {
+    doLogout();
+    return;
+  }
+  if (cmd === "update") {
+    const updArgs = argv.slice(1);
+    const pkg = getFlag(updArgs, "pkg") ?? UPDATE_PKG;
+    if (hasFlag(updArgs, "check")) {
+      output({ status: "update_check", pkg, ...await checkForUpdate({ pkg, current: VERSION }) });
+    } else {
+      const r = await selfUpdate(pkg);
+      output({ status: r.ok ? "updated" : "update_failed", pkg, output: r.output });
+    }
+    return;
+  }
+  const args = argv.slice(1);
+  const cursorFlag = getFlag(args, "cursor");
+  const explicitCursor = cursorFlag !== void 0 ? Number(cursorFlag) : null;
+  const model = getFlag(args, "model");
+  const confirmed = new Set(
+    (getFlag(args, "confirmed-comment-deletion") ?? "").split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  if (!cmd || !["open", "wait", "signal", "status", "promote", "demote", "upload"].includes(cmd)) {
+    process.stderr.write(
+      "usage: inplan <open|wait|signal> <file|--remote DOC_ID> [--model NAME] [--cursor N] [--confirmed-comment-deletion=a,b] [--done] [--reload]\n       inplan status  <file>\n       inplan upload  <file> [--org <slug>] [--repo <name>] [--path <p>]   (Collaborate on Cloud)\n       inplan promote <file> --cloud-doc <docId> [--locator org/repo/path]\n       inplan demote  <file>\n       inplan login --url <url> --anon <anon-key> --refresh <refresh-token> [--email <e>]\n       inplan whoami | logout\n"
+    );
+    process.exit(64);
+  }
+  const remoteDocId = getFlag(args, "remote");
+  if (remoteDocId) {
+    await runRemote(cmd, remoteDocId, explicitCursor, confirmed, args, void 0, model);
+    return;
+  }
+  const file = argv[1] ? resolve2(argv[1]) : argv[1];
+  if (!file) {
+    process.stderr.write(`inplan ${cmd}: missing <file>
+`);
+    process.exit(64);
+  }
+  if (cmd === "status") {
+    doStatus(file);
+    return;
+  }
+  if (cmd === "upload") {
+    await doUpload(file, args);
+    return;
+  }
+  if (cmd === "promote") {
+    doPromote(file, args);
+    return;
+  }
+  if (cmd === "demote") {
+    await doDemote(file, args);
+    return;
+  }
+  const route = routeFor(file, cmd, args);
+  if (route.kind === "reconcile") {
+    output({
+      status: "reconcile_required",
+      message: "Local file differs from the last cloud sync. Re-run with --continue-locally to switch this doc back to local, or --use-cloud to keep collaborating in the cloud.",
+      path: file,
+      cloudDocId: route.docId
+    });
+    return;
+  }
+  if (route.kind === "cloud") {
+    await runRemote(cmd, route.docId, explicitCursor, confirmed, args, file, model);
+    return;
+  }
+  if (cmd === "signal") {
+    const p = docPaths(file);
+    mkdirSync5(p.controlDir, { recursive: true });
+    const channel = new FsControlChannel(p);
+    if (hasFlag(args, "done")) {
+      await channel.append({ actor: "agent", type: LogEventType.AgentDoneSuggested });
+    }
+    if (hasFlag(args, "reload")) {
+      await channel.append({ actor: "agent", type: LogEventType.ReloadSuggested });
+    }
+    output({ status: "signaled" });
+    return;
+  }
+  if (!existsSync7(file)) {
+    process.stderr.write(`inplan ${cmd}: file not found: ${file}
+`);
+    process.exit(1);
+  }
+  if (cmd === "open") {
+    const p = docPaths(file);
+    mkdirSync5(p.controlDir, { recursive: true });
+    const existing = runningEditorPid(p.logPath);
+    if (existing !== null) {
+      process.stderr.write(`[inplan] an editor is already open for this document (pid ${existing}); attaching without launching another window
+`);
+    } else {
+      const pid = spawnApp(file);
+      if (pid !== null) {
+        await new FsControlChannel(p).append({ actor: "agent", type: LogEventType.EditorPid, payload: { pid, v: CONTROL_LOG_VERSION } });
+      }
+    }
+  }
+  await waitCycle(fsBackend(file), explicitCursor, confirmed, model);
+}
+main().catch((err) => {
+  process.stderr.write(`inplan: ${err.message}
+`);
+  process.exit(1);
+});