codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/mobile-rpc-service.js

@@ -0,0 +1,1289 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_rpc_service_exports = {};
+__export(mobile_rpc_service_exports, {
+  mobileConnected: () => mobileConnected,
+  navigateMobile: () => navigateMobile,
+  requestMobileScreenshot: () => requestMobileScreenshot,
+  sendMobileCommand: () => sendMobileCommand,
+  startMobileRpc: () => startMobileRpc,
+  stopMobileRpc: () => stopMobileRpc
+});
+module.exports = __toCommonJS(mobile_rpc_service_exports);
+var import_types = require("../../shared/types");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_confined_fs = require("./confined-fs");
+var import_trusted_roots = require("./trusted-roots");
+var import_plan_review_service = require("./plan-review-service");
+var import_review_queue_service = require("./review-queue-service");
+var import_stack_service = require("./stack-service");
+var import_play_forward = require("./play-forward");
+var import_planned_overlap_actions = require("./planned-overlap-actions");
+var import_plan_status = require("./plan-status");
+var import_pr_draft_service = require("./pr-draft-service");
+var import_snapshot_compare_service = require("./snapshot-compare-service");
+var import_webrtc_service = require("./webrtc-service");
+var planService = __toESM(require("./plan-service"));
+var planItemService = __toESM(require("./plan-item-service"));
+var channelEventService = __toESM(require("./channel-event-service"));
+var deviationService = __toESM(require("./deviation-service"));
+var terminalService = __toESM(require("./terminal-service"));
+var recentProjectsService = __toESM(require("./recent-projects-service"));
+var remoteInteractionService = __toESM(require("./remote-interaction-service"));
+var planPhasesService = __toESM(require("./plan-phases-service"));
+var planDocumentsService = __toESM(require("./plan-documents-service"));
+var commentService = __toESM(require("./comment-service"));
+var externalRefsService = __toESM(require("./external-refs-service"));
+var taskAttachmentsService = __toESM(require("./task-attachments-service"));
+var terminalHistoryService = __toESM(require("./terminal-history-service"));
+var import_database = require("./database");
+var import_cross_system_service = require("./cross-system-service");
+var import_diff_engine = require("./diff-engine");
+var import_projection_service = require("./projection-service");
+var import_settings_service = require("./settings-service");
+var import_power_service = require("./power-service");
+var systemDocsService = __toESM(require("./system-docs-service"));
+var planTemplates = __toESM(require("./plan-templates"));
+var planTemplatesService = __toESM(require("./plan-templates-service"));
+var planFileService = __toESM(require("./plan-file-service"));
+var import_server = require("../server");
+var import_mobile_breakpoints = require("./mobile-breakpoints");
+var import_mobile_proposals = require("./mobile-proposals");
+var import_mobile_awareness = require("./mobile-awareness");
+var import_mobile_workstreams = require("./mobile-workstreams");
+var import_plan_vocab = require("../../shared/lib/plan-vocab");
+var import_grant_guard = require("./grant-guard");
+var import_prompt_builders = require("../mcp/prompt-builders");
+var import_mobile_approvals = require("./mobile-approvals");
+var import_mobile_budget = require("./mobile-budget");
+var import_mobile_freeze = require("./mobile-freeze");
+var import_recurring_service = require("./recurring-service");
+var import_recurring_agent = require("./recurring-agent");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_os = __toESM(require("node:os"));
+let running = false;
+let unsubMessage = null;
+function startMobileRpc() {
+  if (running) return;
+  running = true;
+  unsubMessage = (0, import_webrtc_service.onChannelMessage)(import_types.DATA_CHANNELS.CONTROL, handleControlMessage);
+  console.log("[MobileRPC] Started");
+}
+function stopMobileRpc() {
+  if (!running) return;
+  running = false;
+  if (unsubMessage) {
+    unsubMessage();
+    unsubMessage = null;
+  }
+  console.log("[MobileRPC] Stopped");
+}
+function phonePerson() {
+  return { author: (0, import_settings_service.getAuthorKey)("human"), authorType: "human" };
+}
+function phoneActor() {
+  return { actor: (0, import_settings_service.getAuthorKey)("human"), actorType: "human", channel: "phone" };
+}
+function handleControlMessage(fingerprint, data) {
+  try {
+    const text = typeof data === "string" ? data : data.toString("utf-8");
+    const msg = JSON.parse(text);
+    if (msg.mcp && msg.cmd === "screenshot.chunk" && msg.id) {
+      const pend = pendingScreenshots.get(msg.id);
+      if (!pend) return;
+      let acc = screenshotChunks.get(msg.id);
+      if (!acc) {
+        acc = { parts: new Array(msg.total), total: msg.total, received: 0, mime: msg.mime || "image/jpeg" };
+        screenshotChunks.set(msg.id, acc);
+      }
+      if (typeof msg.seq === "number" && acc.parts[msg.seq] === void 0) {
+        acc.parts[msg.seq] = typeof msg.data === "string" ? msg.data : "";
+        acc.received++;
+      }
+      if (acc.received >= acc.total) {
+        clearTimeout(pend.timer);
+        pendingScreenshots.delete(msg.id);
+        screenshotChunks.delete(msg.id);
+        pend.resolve({ data: acc.parts.join(""), mime: acc.mime });
+      }
+      return;
+    }
+    if (msg.mcp && msg.cmd === "screenshot.result" && msg.id) {
+      const pend = pendingScreenshots.get(msg.id);
+      if (pend) {
+        clearTimeout(pend.timer);
+        pendingScreenshots.delete(msg.id);
+        screenshotChunks.delete(msg.id);
+        if (msg.error) pend.reject(new Error(String(msg.error)));
+        else pend.resolve({ data: typeof msg.data === "string" ? msg.data : "", mime: msg.mime || "image/png" });
+      }
+      return;
+    }
+    if (!msg.rpc || !msg.id) return;
+    const req = msg;
+    handleRpc(fingerprint, req);
+  } catch {
+  }
+}
+const pendingScreenshots = /* @__PURE__ */ new Map();
+const screenshotChunks = /* @__PURE__ */ new Map();
+let commandSeq = 0;
+function mobileConnected() {
+  return (0, import_webrtc_service.connectedPeerCount)() > 0;
+}
+function sendMobileCommand(cmd, params = {}) {
+  return (0, import_webrtc_service.broadcastToAllPeers)(
+    import_types.DATA_CHANNELS.CONTROL,
+    JSON.stringify({ mcp: true, cmd, ...params })
+  );
+}
+function navigateMobile(route) {
+  return sendMobileCommand("navigate", { route });
+}
+function requestMobileScreenshot(timeoutMs = 2e4) {
+  const id = `mss-${++commandSeq}-${Date.now()}`;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pendingScreenshots.delete(id);
+      screenshotChunks.delete(id);
+      reject(new Error("Mobile screenshot timed out \u2014 is a phone connected and on screen?"));
+    }, timeoutMs);
+    pendingScreenshots.set(id, { resolve, reject, timer });
+    const reached = (0, import_webrtc_service.broadcastToAllPeers)(
+      import_types.DATA_CHANNELS.CONTROL,
+      JSON.stringify({ mcp: true, cmd: "screenshot", id })
+    );
+    if (reached === 0) {
+      clearTimeout(timer);
+      pendingScreenshots.delete(id);
+      reject(new Error("No mobile device connected."));
+    }
+  });
+}
+async function handleRpc(fingerprint, req) {
+  const startedAt = Date.now();
+  try {
+    const device = (0, import_paired_device_service.getPairedDevice)(fingerprint);
+    const capability = (0, import_peer_capabilities.assertPeerMayCall)(req.method, device?.capabilities ?? import_peer_capabilities.DEFAULT_GRANTS, {
+      confirmed: Boolean(device?.confirmedAt),
+      alias: device?.alias
+    });
+    if (capability === "terminal") {
+      (0, import_peer_audit_service.recordPeerAudit)({
+        kind: "terminal-access",
+        fingerprint,
+        alias: device?.alias ?? "unknown device",
+        method: req.method,
+        detail: (0, import_peer_audit_service.terminalAuditDetail)(req.params ?? {})
+      });
+    }
+    const result = await routeMethod(req.method, req.params ?? {}, fingerprint);
+    sendResponse(fingerprint, { result, id: req.id, rpc: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof import_peer_capabilities.PeerAuthorizationError) {
+      console.warn(
+        `[MobileRPC][Authz] REFUSED peer=${fingerprint.slice(0, 12)}\u2026 method=${req.method} \u2014 ${message}`
+      );
+      const refusedDevice = (0, import_paired_device_service.getPairedDevice)(fingerprint);
+      (0, import_peer_audit_service.recordPeerAudit)({
+        kind: "refused",
+        fingerprint,
+        alias: refusedDevice?.alias ?? "unknown device",
+        method: req.method,
+        detail: message
+      });
+    }
+    const durationMs = Date.now() - startedAt;
+    console.warn(
+      `[MobileRPC][Lifecycle] rpc_failure peer=${fingerprint.slice(0, 12)}\u2026 method=${req.method} id=${req.id} durationMs=${durationMs} message=${JSON.stringify(message)}`
+    );
+    sendResponse(fingerprint, { error: message, id: req.id, rpc: true });
+  }
+}
+function sendResponse(fingerprint, response) {
+  (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(response));
+}
+function peerProjectRoot(params, opts = {}) {
+  const nominated = params.projectPath;
+  if (typeof nominated === "string" && nominated.trim().length > 0) {
+    return (0, import_trusted_roots.resolveTrustedProjectRoot)(nominated, "projectPath");
+  }
+  const fallback = (0, import_server.getActiveProjectPath)() || recentProjectsService.listRecentProjects()[0]?.path;
+  if (!fallback && opts.required) {
+    throw new Error("No active project on the desktop");
+  }
+  return fallback ?? void 0;
+}
+function planProjectRoot(planUid) {
+  const plan = planService.getPlan(planUid);
+  if (!plan?.projectPath) {
+    throw new Error(`Plan ${planUid} is not associated with a project`);
+  }
+  return (0, import_trusted_roots.resolveTrustedProjectRoot)(plan.projectPath, "plan.projectPath");
+}
+async function routeMethod(method, params, fingerprint = "") {
+  switch (method) {
+    // --- Approvals (Phase 31 §12) ---------------------------------------------
+    case "criteria.awaiting":
+    case "criteria.list":
+    case "criterion.decide":
+    case "artefact.preview":
+      return (0, import_mobile_approvals.handleApprovalMethod)(method, params, {
+        fingerprint,
+        send: (message) => (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(message)),
+        broadcast: import_server.broadcast
+      });
+    // --- A plan's budget, and marking an agent's change seen -----------------
+    case "budget.get":
+    case "budget.acknowledge":
+      return (0, import_mobile_budget.handleBudgetMethod)(method, params, {
+        fingerprint,
+        send: (message) => (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(message)),
+        broadcast: import_server.broadcast
+      });
+    // --- A project's freeze, and marking an agent's change seen (0.4k) -------
+    case "freeze.get":
+    case "freeze.acknowledge":
+      return (0, import_mobile_freeze.handleFreezeMethod)(method, params, {
+        fingerprint,
+        send: (message) => (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(message)),
+        broadcast: import_server.broadcast
+      });
+    // --- What is held for the person, answered from the phone (B4.4) --------
+    case "breakpoint.waiting":
+    case "breakpoint.answer":
+      return (0, import_mobile_breakpoints.handleBreakpointMethod)(method, params, {
+        fingerprint,
+        send: (message) => (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(message)),
+        broadcast: import_server.broadcast
+      }, { who: phonePerson(), projectRoot: (0, import_server.getActiveProjectPath)() });
+    // --- A proposed spec change, decided from the phone (B7.6) --------------
+    case "proposal.list":
+    case "proposal.get":
+    case "proposal.decide":
+      return (0, import_mobile_proposals.handleProposalMethod)(method, params, {
+        fingerprint,
+        send: (message) => (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(message)),
+        broadcast: import_server.broadcast
+      }, { who: phonePerson(), projectRoot: (0, import_server.getActiveProjectPath)() });
+    // --- What overlaps, answered and replied to from the phone (A4.2) -------
+    case "awareness.needsYou":
+    case "awareness.signal":
+    case "awareness.answer":
+    case "awareness.reply":
+      return (0, import_mobile_awareness.handleAwarenessMethod)(method, params, {
+        fingerprint,
+        send: (message) => (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(message)),
+        broadcast: import_server.broadcast
+      }, { who: phoneActor(), projectRoot: (0, import_server.getActiveProjectPath)(), reply: import_server.replyToSignalAsPerson });
+    // --- The lines of work, as the strip shows them (A4.3) ------------------
+    case "workstreams.list":
+    case "workstreams.detail":
+      return (0, import_mobile_workstreams.handleWorkstreamMethod)(method, params, {
+        fingerprint,
+        send: (message) => (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(message)),
+        broadcast: import_server.broadcast
+      }, { projectRoot: (0, import_server.getActiveProjectPath)() });
+    // --- Plans ---------------------------------------------------------------
+    case "plan.list": {
+      const projectPath = typeof params.projectPath === "string" && params.projectPath ? (0, import_trusted_roots.resolveTrustedProjectRoot)(params.projectPath, "projectPath") : void 0;
+      return planService.listPlans(projectPath).map((p) => {
+        const items = planItemService.listAllItems(p.uid);
+        return {
+          uid: p.uid,
+          title: p.title,
+          status: p.status,
+          projectPath: p.projectPath,
+          itemCount: items.length,
+          doneCount: items.filter((i) => i.status === "done").length,
+          inProgressCount: items.filter((i) => i.status === "in_progress" || i.status === "assigned").length,
+          updatedAt: p.updatedAt,
+          createdAt: p.createdAt
+        };
+      });
+    }
+    case "plan.get": {
+      const uid = requireString(params, "uid");
+      const plan = planService.getPlan(uid);
+      if (!plan) throw new Error(`Plan not found: ${uid}`);
+      const items = planItemService.listAllItems(uid);
+      const deviations = deviationService.getDeviations(uid);
+      const phases = safe(() => planPhasesService.listPhases(uid), []);
+      const documents = safe(() => planDocumentsService.listPlanDocumentSummaries(uid), []);
+      const externalRefs = safe(() => externalRefsService.getExternalRefsByPlan(uid), []);
+      const comments = safe(() => commentService.getComments(uid), []);
+      return { plan, items, deviations, phases, documents, externalRefs, comments };
+    }
+    case "plan.document": {
+      const docUid = requireString(params, "docUid");
+      const doc = planDocumentsService.getPlanDocument(docUid);
+      if (!doc) throw new Error(`Document not found: ${docUid}`);
+      return doc;
+    }
+    case "plan.items": {
+      const planUid = requirePlan(params, "planUid");
+      return planItemService.listAllItems(planUid);
+    }
+    case "plan.update": {
+      const uid = requirePlan(params, "uid");
+      const updates = {};
+      if (params.title !== void 0) updates.title = params.title;
+      if (params.status !== void 0) updates.status = params.status;
+      if (params.description !== void 0) updates.description = params.description;
+      const done = (0, import_server.updatePlanAsPerson)(uid, updates, phonePerson());
+      return { ok: true, ...done.plannedOverlaps.length ? { plannedOverlaps: done.plannedOverlaps } : {} };
+    }
+    case "plan.create": {
+      const title = requireString(params, "title");
+      const projectPath = peerProjectRoot(params, { required: true });
+      const plan = planService.createPlan(
+        { title, description: params.description || "", tasks: [] },
+        phonePerson().author,
+        phonePerson().authorType,
+        projectPath
+      );
+      const exported = planFileService.exportIfSharedByDefault(plan.uid, projectPath);
+      (0, import_server.broadcast)("plan-created", { plan, exported });
+      return plan;
+    }
+    case "plan.delete": {
+      const uid = requirePlan(params, "uid");
+      const { diskRemoved } = (0, import_server.deletePlanAsPerson)(uid);
+      return { ok: true, diskRemoved };
+    }
+    case "plan.copyAsPrompt": {
+      const uid = requireString(params, "uid");
+      const plan = planService.getPlan(uid);
+      if (!plan) throw new Error(`Plan not found: ${uid}`);
+      const items = planItemService.listAllItems(uid);
+      const refs = safe(() => externalRefsService.getExternalRefsByPlan(uid), []);
+      const prompt = (0, import_prompt_builders.buildPlanPrompt)(plan, items, refs);
+      return { prompt };
+    }
+    case "plan.item.get": {
+      const uid = requireString(params, "uid");
+      const item = planItemService.getItem(uid);
+      if (!item) throw new Error(`Item not found: ${uid}`);
+      const comments = safe(() => commentService.listItemComments(uid), []);
+      const externalRefs = safe(() => externalRefsService.getExternalRefs(uid), []);
+      const attachments = safe(() => taskAttachmentsService.listItemAttachments(uid), []);
+      return { item, comments, externalRefs, attachments };
+    }
+    case "plan.item.update": {
+      const uid = requireString(params, "uid");
+      const updates = {};
+      if (params.status !== void 0) updates.status = params.status;
+      if (params.title !== void 0) updates.title = params.title;
+      if (params.assignee !== void 0) updates.assignee = params.assignee;
+      if (params.body !== void 0) updates.body = params.body;
+      if (params.blockedReason !== void 0) updates.blockedReason = params.blockedReason;
+      if (params.progressPercent !== void 0) updates.progressPercent = params.progressPercent;
+      if (updates.status !== void 0 && !(0, import_plan_vocab.isTaskStatus)(updates.status)) {
+        throw new Error(`status must be one of: ${import_plan_vocab.TASK_STATUSES.join(", ")}`);
+      }
+      const updated = planItemService.updateItem(uid, { ...updates, ...phonePerson() });
+      if (!updated) throw new Error(`Item not found: ${uid}`);
+      (0, import_server.broadcast)("plan-item-updated", { planUid: updated.planUid, itemUid: updated.uid, kind: updated.kind, changes: updates });
+      return updated;
+    }
+    case "plan.item.create": {
+      const planUid = requirePlan(params, "planUid");
+      const title = requireString(params, "title");
+      const kind = params.kind === "object" ? "object" : "action";
+      const created = planItemService.createItem({
+        planUid,
+        kind,
+        title,
+        parentUid: params.parentUid || null,
+        body: params.body || void 0,
+        ...phonePerson()
+      });
+      (0, import_server.broadcast)("plan-item-created", { planUid: created.planUid, item: created });
+      return created;
+    }
+    case "comment.add": {
+      const targetUid = requireString(params, "targetUid");
+      const body = requireString(params, "body");
+      const targetType = params.targetType === "plan" ? "plan" : "item";
+      const kind = params.kind || "note";
+      const parentUid = params.parentUid || void 0;
+      const item = targetType === "item" ? planItemService.getItem(targetUid) : null;
+      if (targetType === "item" && !item) throw new Error(`Item not found: ${targetUid}`);
+      if (targetType === "plan" && !planService.getPlan(targetUid)) throw new Error(`Plan not found: ${targetUid}`);
+      const comment = commentService.addComment(
+        targetType,
+        targetUid,
+        phonePerson().author,
+        phonePerson().authorType,
+        body,
+        { kind, parentUid }
+      );
+      if (item) (0, import_server.broadcast)("plan-item-comment-added", { planUid: item.planUid, itemUid: item.uid, comment });
+      else (0, import_server.broadcast)("comment-added", { comment });
+      return comment;
+    }
+    // --- External references (links) on a plan item --------------------------
+    case "item.ref.add": {
+      const itemUid = requireString(params, "itemUid");
+      const url = requireString(params, "url");
+      if (!planItemService.getItem(itemUid)) throw new Error(`Item not found: ${itemUid}`);
+      const ref = externalRefsService.createExternalRef({
+        itemUid,
+        url,
+        title: params.title || void 0,
+        kind: params.kind || void 0,
+        ...phonePerson()
+      });
+      (0, import_server.broadcast)("external-ref-added", { ref });
+      return ref;
+    }
+    case "item.ref.remove": {
+      const uid = requireString(params, "uid");
+      if (!externalRefsService.getExternalRef(uid)) throw new Error(`Link not found: ${uid}`);
+      externalRefsService.deleteExternalRef(uid);
+      (0, import_server.broadcast)("external-ref-deleted", { uid });
+      return { ok: true };
+    }
+    // --- Deviations ----------------------------------------------------------
+    case "deviation.list": {
+      const planUid = requirePlan(params, "planUid");
+      return deviationService.getDeviations(planUid);
+    }
+    case "deviation.resolve": {
+      const id = params.id;
+      const resolution = params.resolution;
+      if (!id || !resolution) throw new Error("id and resolution required");
+      const planUid = deviationService.planOfDeviation(id);
+      if (!planUid) throw new Error(`No deviation ${id}`);
+      deviationService.reconcileDeviations(planUid, [{ id, action: resolution }], phoneActor());
+      return { ok: true };
+    }
+    // --- Projects ------------------------------------------------------------
+    case "project.list": {
+      return recentProjectsService.listRecentProjects();
+    }
+    case "project.open": {
+      const projectPath = requireString(params, "projectPath");
+      (0, import_server.broadcast)("ui-open-project", { path: projectPath });
+      const result = await (0, import_server.scanProject)(projectPath);
+      return result;
+    }
+    case "project.active": {
+      const activePath = (0, import_server.getActiveProjectPath)();
+      if (!activePath) return null;
+      return recentProjectsService.getRecentProject(activePath);
+    }
+    case "project.close": {
+      const projectPath = requireRecentProject(requireString(params, "projectPath"));
+      (0, import_server.broadcast)("ui-close-project", { path: projectPath });
+      return { ok: true };
+    }
+    case "project.pin": {
+      const projectPath = requireRecentProject(requireString(params, "projectPath"));
+      const pinned = params.pinned !== false;
+      recentProjectsService.setRecentProjectPinned(projectPath, pinned);
+      return recentProjectsService.getRecentProject(projectPath);
+    }
+    case "project.remove": {
+      const projectPath = requireRecentProject(requireString(params, "projectPath"));
+      recentProjectsService.removeRecentProject(projectPath);
+      return { ok: true };
+    }
+    case "project.alias": {
+      const projectPath = requireRecentProject(requireString(params, "projectPath"));
+      const alias = requireString(params, "alias");
+      return recentProjectsService.setProjectAlias(projectPath, alias);
+    }
+    case "project.rescan": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      const result = await (0, import_server.scanProject)(projectPath);
+      return result;
+    }
+    // --- Settings ------------------------------------------------------------
+    case "settings.get": {
+      return (0, import_settings_service.getSettings)();
+    }
+    case "settings.update": {
+      const patch = {};
+      if (params.identity !== void 0) patch.identity = params.identity;
+      if (params.plans !== void 0) patch.plans = params.plans;
+      if (params.device !== void 0) patch.device = params.device;
+      if (params.power !== void 0) patch.power = params.power;
+      const grant = (0, import_grant_guard.grantChange)(patch, (0, import_settings_service.getSettings)());
+      if (grant) throw new Error((0, import_grant_guard.grantRefusal)(grant.field, grant.where));
+      const updated = (0, import_settings_service.updateSettings)(patch);
+      if (params.power !== void 0) (0, import_power_service.notifyPowerSettingsChanged)();
+      (0, import_server.broadcast)("settings-changed", { settings: updated });
+      return updated;
+    }
+    // Session-persistence plan / Track A — runtime status (shouldBlock,
+    // reason, ac, platform). Phone polls every 4s to render the awake
+    // indicator + gate the macOS-only lid-close toggle. Distinct from
+    // `settings.get` which returns configuration; this returns the
+    // power-service's *current decision* state.
+    case "power.status": {
+      return (0, import_power_service.getCurrentPowerStatus)();
+    }
+    // Plan 11.2 — mobile ships its in-RAM diagnostics ring buffer to
+    // the desktop logger so cross-side `[Lifecycle]` greps work
+    // end-to-end. `installFileLogger` already captures every
+    // console.log/warn into the daily log file, so the RPC just
+    // routes each entry through console.log with a peer-tag prefix.
+    case "diagnostics.flush": {
+      const entries = Array.isArray(params.entries) ? params.entries : [];
+      const fpTag = `mobile:${fingerprint.slice(0, 8)}`;
+      let wrote = 0;
+      for (const e of entries) {
+        if (typeof e?.text !== "string") continue;
+        const tag = typeof e.kind === "string" ? `[${e.kind}]` : "";
+        const dataStr = e.data ? " " + JSON.stringify(e.data) : "";
+        const tsIso = new Date(e.ts).toISOString();
+        console.log(`[${fpTag}] [${tsIso}] [Lifecycle]${tag} ${e.text}${dataStr}`);
+        wrote++;
+      }
+      return { wrote };
+    }
+    // --- System docs ---------------------------------------------------------
+    case "sysdoc.list": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      const search = params.search;
+      return search ? systemDocsService.searchSystemDocs(projectPath, search) : systemDocsService.listSystemDocs(projectPath);
+    }
+    case "sysdoc.read": {
+      const uid = requireString(params, "uid");
+      const doc = systemDocsService.getSystemDoc(uid);
+      if (!doc) throw new Error(`Doc not found: ${uid}`);
+      const freshness = safe(() => systemDocsService.getFreshness(uid), null);
+      return { doc, freshness };
+    }
+    case "sysdoc.create": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      const title = requireString(params, "title");
+      const doc = systemDocsService.createSystemDoc({
+        projectPath,
+        title,
+        body: params.body || "",
+        owner: params.owner || null,
+        tags: params.tags || [],
+        ...phonePerson()
+      });
+      (0, import_server.broadcast)("system-doc-created", { uid: doc.uid, projectPath: doc.projectPath });
+      return doc;
+    }
+    case "sysdoc.update": {
+      const uid = requireString(params, "uid");
+      const updates = { ...phonePerson() };
+      if (params.title !== void 0) updates.title = params.title;
+      if (params.body !== void 0) updates.body = params.body;
+      if (params.owner !== void 0) updates.owner = params.owner;
+      if (params.tags !== void 0) updates.tags = params.tags;
+      const doc = systemDocsService.updateSystemDoc(uid, updates);
+      if (!doc) throw new Error(`Doc not found: ${uid}`);
+      (0, import_server.broadcast)("system-doc-updated", { uid: doc.uid, projectPath: doc.projectPath });
+      return doc;
+    }
+    case "sysdoc.delete": {
+      const uid = requireString(params, "uid");
+      if (!systemDocsService.deleteSystemDoc(uid)) throw new Error(`Doc not found: ${uid}`);
+      (0, import_server.broadcast)("system-doc-removed", { uid });
+      return { ok: true };
+    }
+    case "sysdoc.verify": {
+      const uid = requireString(params, "uid");
+      const doc = systemDocsService.verifySystemDoc(uid);
+      if (!doc) throw new Error(`Doc not found: ${uid}`);
+      (0, import_server.broadcast)("system-doc-verified", { uid: doc.uid, capturedAgainstCommit: doc.capturedAgainstCommit });
+      return doc;
+    }
+    // --- Plan templates + file import/export ---------------------------------
+    case "plan.template.list": {
+      const projectRoot = peerProjectRoot(params);
+      return planTemplates.listTemplates(projectRoot);
+    }
+    case "plan.template.create": {
+      const templateId = requireString(params, "templateId");
+      const projectPath = peerProjectRoot(params, { required: true });
+      const result = planTemplatesService.applyTemplate({
+        templateId,
+        projectPath,
+        title: params.title || void 0,
+        description: params.description || void 0,
+        placeholderValues: params.placeholderValues || void 0,
+        ...phonePerson()
+      });
+      (0, import_server.broadcast)("plan-created", { plan: result.plan });
+      return { plan: result.plan, itemCount: result.items.length, version: result.version };
+    }
+    case "plan.file.export": {
+      const planUid = requirePlan(params, "planUid");
+      const projectRoot = params.projectPath !== void 0 ? peerProjectRoot(params, { required: true }) : planProjectRoot(planUid);
+      const result = planFileService.exportPlan(planUid, projectRoot);
+      (0, import_server.broadcast)("plan-exported", { planUid, planDir: result.planDir, files: result.files.length });
+      return { planDir: result.planDir, fileCount: result.files.length };
+    }
+    case "plan.file.discover": {
+      const projectRoot = peerProjectRoot(params, { required: true });
+      const dirs = planFileService.discoverPlanDirs(projectRoot);
+      return dirs.map((d) => ({ dir: d, name: import_node_path.default.basename(d) }));
+    }
+    case "plan.file.import": {
+      const planDir = (0, import_trusted_roots.resolveTrustedPlanDir)(requireString(params, "planDir"));
+      const result = planFileService.importPlan(planDir);
+      if (result.plan) (0, import_server.broadcast)("plan-imported", { planUid: result.plan.uid, source: planDir });
+      return { plan: result.plan, warnings: result.warnings };
+    }
+    // --- Terminals -----------------------------------------------------------
+    case "terminal.list": {
+      return terminalService.listTerminals();
+    }
+    case "terminal.create": {
+      const preset = params.preset || "shell";
+      const cwd = params.cwd || (0, import_server.getActiveProjectPath)() || recentProjectsService.listRecentProjects()[0]?.path || void 0;
+      const title = params.title;
+      const term = terminalService.createTerminal({
+        preset,
+        cwd,
+        title
+      });
+      try {
+        (0, import_server.broadcast)("terminal-created", { session: term, focus: true });
+      } catch {
+      }
+      return term;
+    }
+    // A terminal that is not there is an error, not `{ ok: false }` or a
+    // null the phone renders as an empty screen: typing into one looked like
+    // it worked (0.4j).
+    case "terminal.write": {
+      const id = requireString(params, "id");
+      const data = requireString(params, "data");
+      if (!terminalService.writeTerminal(id, data)) throw new Error(`Terminal not found: ${id}`);
+      return { ok: true };
+    }
+    case "terminal.kill": {
+      const id = requireString(params, "id");
+      if (!terminalService.killTerminal(id)) throw new Error(`Terminal not found: ${id}`);
+      try {
+        (0, import_server.broadcast)("terminal-killed", { id });
+      } catch {
+      }
+      return { ok: true };
+    }
+    case "terminal.read": {
+      const id = requireString(params, "id");
+      const lines = params.lines ?? 100;
+      const output = terminalService.readTerminalOutput(id, lines, true);
+      if (output === null) throw new Error(`Terminal not found: ${id}`);
+      return { output };
+    }
+    case "terminal.stream": {
+      const id = requireString(params, "id");
+      const since = typeof params.since === "number" ? params.since : void 0;
+      const delta = terminalService.readTerminalDelta(id, since);
+      if (delta === null) throw new Error(`Terminal not found: ${id}`);
+      return delta;
+    }
+    case "terminal.resize": {
+      const id = requireString(params, "id");
+      const cols = params.cols ?? 80;
+      const rows = params.rows ?? 24;
+      if (!Number.isInteger(cols) || cols < 10 || cols > 500 || !Number.isInteger(rows) || rows < 4 || rows > 300) {
+        throw new Error("cols must be a whole number from 10 to 500, and rows from 4 to 300");
+      }
+      if (!terminalService.resizeTerminal(id, cols, rows)) throw new Error(`Terminal not found: ${id}`);
+      return { ok: true };
+    }
+    // Session-persistence plan §7.6 — paginated read of the
+    // persistent on-disk terminal history. Clients pass `before` from
+    // the previous response's `prevOffset` to walk backwards through
+    // the log; omit it to start at the tail. The data is raw ANSI —
+    // safe to feed straight into xterm.
+    case "terminal.history": {
+      const id = requireString(params, "id");
+      const before = typeof params.before === "number" ? params.before : void 0;
+      const limit = typeof params.limit === "number" ? params.limit : 64 * 1024;
+      return terminalHistoryService.getHistoryChunk(id, before, limit);
+    }
+    // --- Channel events ------------------------------------------------------
+    case "channel.events": {
+      const planUid = requireString(params, "planUid");
+      const limit = params.limit ?? 50;
+      return channelEventService.listChannelEvents(planUid, { limit });
+    }
+    case "channel.eventsSinceSeq": {
+      const planUid = requireString(params, "planUid");
+      const sinceSeq = params.sinceSeq ?? 0;
+      const limit = params.limit ?? 200;
+      return channelEventService.getChannelEventsSinceSeq(planUid, sinceSeq, limit);
+    }
+    case "channel.post": {
+      const planUid = requireString(params, "planUid");
+      const eventType = requireString(params, "eventType");
+      return (0, import_server.postChannelEventAsPerson)({
+        planUid,
+        eventType,
+        message: typeof params.message === "string" ? params.message : "",
+        itemUid: typeof params.itemUid === "string" ? params.itemUid : null,
+        respondsTo: params.parentUid || null,
+        by: phonePerson().authorType
+      });
+    }
+    case "channel.resolve": {
+      const uid = requireString(params, "uid");
+      const status = params.status ?? "resolved";
+      return (0, import_server.setChannelEventStatusAsPerson)(uid, status);
+    }
+    case "channel.thread": {
+      const rootUid = requireString(params, "rootUid");
+      return channelEventService.listThread(rootUid);
+    }
+    case "channel.get": {
+      const uid = requireString(params, "uid");
+      const event = channelEventService.getChannelEvent(uid);
+      if (!event) throw new Error(`Channel event not found: ${uid}`);
+      return event;
+    }
+    // --- Input requests ------------------------------------------------------
+    case "input.respond": {
+      const requestId = requireString(params, "requestId");
+      const response = requireString(params, "response");
+      if (!remoteInteractionService.respondToInputRequest(requestId, response, phoneActor())) {
+        throw new Error(`No pending input request ${requestId}`);
+      }
+      return { ok: true };
+    }
+    // --- Graph ---------------------------------------------------------------
+    case "graph.overview": {
+      const summary = (0, import_database.getArchitectureSummary)();
+      const d = (0, import_database.getDb)();
+      let enrichedMostImported = summary.mostImported;
+      try {
+        const r = d.exec(`
+          SELECT i.resolved_path, COUNT(DISTINCT i.file_id) AS cnt
+          FROM imports i
+          WHERE i.resolved_path IS NOT NULL
+          GROUP BY i.resolved_path
+          ORDER BY cnt DESC
+          LIMIT 10
+        `);
+        if (r[0]?.values.length) {
+          enrichedMostImported = r[0].values.map((row) => ({
+            path: row[0],
+            importerCount: row[1]
+          }));
+        }
+      } catch {
+      }
+      return { ...summary, mostImported: enrichedMostImported };
+    }
+    case "graph.directory": {
+      const dir = requireString(params, "dir");
+      return getDirectoryFiles(dir);
+    }
+    case "graph.file": {
+      const filePath = requireString(params, "filePath");
+      const symbols = (0, import_database.getFileSymbols)(filePath);
+      const deps = (0, import_database.getFileDependencies)(filePath);
+      const d = (0, import_database.getDb)();
+      let language = "unknown";
+      try {
+        const r = d.exec(`SELECT language FROM files WHERE path = ?`, [filePath]);
+        if (r[0]?.values[0]) language = r[0].values[0][0];
+      } catch {
+      }
+      let crossSystemOut = [];
+      let crossSystemIn = [];
+      try {
+        const edges = (0, import_cross_system_service.listCrossSystemEdges)();
+        crossSystemOut = edges.filter((e) => e.source === filePath).map((e) => ({ path: e.target, relativePath: e.targetRelative, protocol: e.protocol, label: e.label }));
+        crossSystemIn = edges.filter((e) => e.target === filePath).map((e) => ({ path: e.source, relativePath: e.sourceRelative, protocol: e.protocol, label: e.label }));
+      } catch {
+      }
+      return { filePath, language, symbols, ...deps, crossSystemOut, crossSystemIn };
+    }
+    case "graph.fileSource": {
+      const filePath = requireString(params, "filePath");
+      const roots = (0, import_trusted_roots.listTrustedRoots)();
+      const owningRoot = roots.find((r) => (0, import_confined_fs.isWithin)(r, filePath));
+      if (!owningRoot) {
+        throw new Error("File is outside every opened project");
+      }
+      const confinedBuffer = (0, import_confined_fs.readFileWithin)(owningRoot, filePath, "graph.fileSource");
+      const MAX = 200 * 1024;
+      const truncated = confinedBuffer.length > MAX;
+      const content = (truncated ? confinedBuffer.subarray(0, MAX) : confinedBuffer).toString("utf-8");
+      const lineCount = content.split("\n").length;
+      let language = "unknown";
+      try {
+        const r = (0, import_database.getDb)().exec(`SELECT language FROM files WHERE path = ?`, [filePath]);
+        if (r[0]?.values[0]) language = r[0].values[0][0];
+      } catch {
+      }
+      const git = safe(
+        () => (0, import_server.computeGitLineAnnotations)(owningRoot, import_node_path.default.resolve(filePath), lineCount),
+        null
+      );
+      const lineStatus = git?.annotations ?? null;
+      const deletedBefore = git?.deletedBefore ?? null;
+      return { content, language, truncated, lineCount, lineStatus, deletedBefore };
+    }
+    case "graph.fileSearch": {
+      const query = requireString(params, "query").toLowerCase();
+      const pattern = `%${query.replace(/[\\%_]/g, (c) => `\\${c}`)}%`;
+      const d = (0, import_database.getDb)();
+      const out = [];
+      try {
+        const r = d.exec(
+          `SELECT path, relative_path FROM files WHERE LOWER(relative_path) LIKE ? ESCAPE '\\' ORDER BY relative_path LIMIT 40`,
+          [pattern]
+        );
+        for (const row of r[0]?.values ?? []) {
+          const p = row[0];
+          out.push({ path: p, relativePath: row[1], name: import_node_path.default.basename(p) });
+        }
+      } catch {
+      }
+      return out;
+    }
+    // --- Changes / diff -------------------------------------------------------
+    // --- Review (Phase 29 mobile flow) ---------------------------------------
+    //
+    // Phase 25 built the review surface and shipped it REST + MCP only.
+    // Phase 29 §4.13 gave it a desktop panel; none of it was ever bridged
+    // to the phone, so a user watching an agent from their phone could
+    // read the plan and the channel but never ask "did it do what it
+    // said". These four methods are that question.
+    //
+    // All read-only. `buildPrDraft` in particular never touches the
+    // repository — CodeTrellis supplies the body an agent cannot write
+    // and the agent does the git with its own credentials.
+    case "review.get": {
+      const planUid = requireString(params, "planUid");
+      const projectPath = planProjectRoot(planUid);
+      const result = (0, import_plan_review_service.reviewPlan)({
+        planUid,
+        projectPath,
+        before: params.before,
+        after: params.after
+      });
+      if (!result.ok) throw new Error(result.error);
+      return (0, import_plan_review_service.withArchitecture)(result.review, projectPath);
+    }
+    case "review.prDraft": {
+      const planUid = requireString(params, "planUid");
+      const projectPath = planProjectRoot(planUid);
+      const result = (0, import_pr_draft_service.buildPrDraft)({
+        planUid,
+        projectPath,
+        before: params.before,
+        after: params.after,
+        architecture: await (0, import_pr_draft_service.draftArchitecture)(projectPath, params.before, params.after)
+      });
+      if (!result.ok) throw new Error(result.error ?? "Could not build a PR draft");
+      return result.draft;
+    }
+    case "review.comparands": {
+      const planUid = params.planUid;
+      const projectPath = planUid ? planProjectRoot(planUid) : peerProjectRoot(params, { required: true });
+      return (0, import_snapshot_compare_service.listComparands)(projectPath, void 0, await (0, import_snapshot_compare_service.comparandBranches)(projectPath));
+    }
+    case "review.compare": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      const before = params.before || "baseline";
+      const after = params.after || "live";
+      const result = (0, import_snapshot_compare_service.compareSnapshots)(before, after, projectPath);
+      if (!result.ok) throw new Error(result.error);
+      return result.result;
+    }
+    // The review queue (Phase 32 A5.6, over A5.4): every line of work with plan
+    // items, where it stands against the main checkout's branch, and the
+    // suggested merge order with its reasons. The same answer as
+    // `/api/review-queue`, for an opened project only.
+    case "review.queue": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      return (0, import_review_queue_service.reviewQueue)(projectPath);
+    }
+    // The stack (Phase 32 B6.6, over B6.2): every plan under way, with who is
+    // on what, what waits on what across plans, and where plans meet. The same
+    // answer as `/api/stack`, for an opened project only; the phone summarises.
+    case "stack.summary": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      return (0, import_stack_service.buildStack)(projectPath);
+    }
+    // Play-forward (Phase 32 B9.3b): what every active plan will change and
+    // where two will meet, as the desktop's bar says it, and a person on the
+    // phone deciding one: re-sequence, tell the agents, or leave it.
+    case "playForward.summary": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      return { ...(0, import_play_forward.buildPlayForward)(projectPath), notices: (0, import_planned_overlap_actions.approvalNotices)(projectPath) };
+    }
+    case "playForward.decide": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      const overlapId = requireString(params, "overlapId");
+      const action = requireString(params, "action");
+      const who = phonePerson();
+      let result = {};
+      if (action === "resequence") {
+        const r = (0, import_planned_overlap_actions.resequence)(projectPath, overlapId, requireString(params, "first"), who);
+        for (const t of r.waiting) (0, import_server.broadcast)("plan-item-updated", { planUid: planItemService.getItem(t.uid)?.planUid, itemUid: t.uid, kind: "action", changes: { dependencies: true } });
+        result = { waiting: r.waiting };
+      } else if (action === "tell") {
+        result = (0, import_planned_overlap_actions.tellAgents)(projectPath, overlapId, who);
+      } else if (action === "leave") {
+        (0, import_planned_overlap_actions.leaveOverlap)(projectPath, overlapId, who);
+      } else {
+        throw new Error("action must be resequence, tell or leave");
+      }
+      (0, import_server.broadcast)("play-forward-changed", { project: projectPath });
+      return { ...result, playForward: (0, import_play_forward.buildPlayForward)(projectPath) };
+    }
+    // Recurring playbooks (Phase 32 C4.3a): the series as the plans list shows
+    // them, and starting the run due now. Starting is anyone's, as making a
+    // plan is, and twice is one run; setting a rule stays the app window's.
+    case "recurring.list": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      return { series: (0, import_recurring_service.seriesFor)(projectPath) };
+    }
+    case "recurring.start": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      const ruleId = requireString(params, "ruleId");
+      const run = (0, import_recurring_service.startRun)(projectPath, ruleId, phonePerson());
+      const mayOpen = ((0, import_paired_device_service.getPairedDevice)(fingerprint)?.capabilities ?? []).includes("terminal") ? true : "this phone is not allowed to open terminals (Settings \u2192 Devices)";
+      const agent = run.created ? (0, import_recurring_agent.startRunAgent)(projectPath, ruleId, run.plan, mayOpen, (session) => (0, import_server.broadcast)("terminal-created", { session })) : null;
+      if (run.created) {
+        (0, import_server.broadcast)("plan-created", { plan: run.plan });
+        (0, import_server.broadcast)("recurring-changed", { project: projectPath });
+      }
+      return { planUid: run.plan.uid, title: run.plan.title, created: run.created, recurrence: run.info, agent, series: (0, import_recurring_service.seriesFor)(projectPath) };
+    }
+    // The plan's status (Phase 32 C2.4): every item's state with its source,
+    // and the one view — progress, waiting, in progress, lineage. The same
+    // answer as `/api/plans/:uid/status` and get_plan's `status`.
+    case "plan.status": {
+      const planUid = requirePlan(params, "planUid");
+      const status = await (0, import_plan_status.planStatusFresh)(planUid);
+      if (!status) throw new Error(`Plan not found: ${planUid}`);
+      return status;
+    }
+    // What to work on next. `getNextTask` reads plan_items for a V2 plan
+    // and falls back to the legacy tasks table (Phase 29 §4.14), so the
+    // phone gets the same answer the desktop strip shows.
+    case "plan.nextItem": {
+      const planUid = requireString(params, "planUid");
+      const next = planService.getNextTask(planUid);
+      return next ?? { none: true };
+    }
+    case "changes.summary": {
+      const projectPath = peerProjectRoot(params, { required: true });
+      const git = (0, import_server.getGitWorkingTreeStatus)(projectPath);
+      let arch = null;
+      const baseline = (0, import_diff_engine.getBaseline)();
+      if (baseline) {
+        try {
+          const currentEdges = (0, import_database.getDependencyEdges)();
+          const fileData = (0, import_server.readFilesSnapshot)(projectPath);
+          arch = (0, import_diff_engine.computeDiff)((0, import_diff_engine.captureSnapshot)(fileData, currentEdges));
+        } catch {
+        }
+      }
+      const changed = /* @__PURE__ */ new Set();
+      if (git) {
+        for (const f of [
+          ...git.stagedAdded,
+          ...git.stagedModified,
+          ...git.stagedDeleted,
+          ...git.unstagedModified,
+          ...git.unstagedDeleted,
+          ...git.untracked
+        ]) changed.add(f);
+      }
+      if (arch) {
+        for (const f of [...arch.addedFiles, ...arch.modifiedFiles]) changed.add(f);
+      }
+      return {
+        hasBaseline: !!baseline,
+        git,
+        arch,
+        changedFiles: [...changed]
+      };
+    }
+    case "graph.search": {
+      const query = requireString(params, "query");
+      return (0, import_database.searchSymbols)(query);
+    }
+    // --- Filesystem browse (open a folder as a project from mobile) -----------
+    case "fs.browse": {
+      const dir = params.dir || import_node_os.default.homedir();
+      return browseDirectory(dir);
+    }
+    // --- Renderable graph scene (cluster nodes + edges + planned/diverged) ----
+    case "graph.scene": {
+      const planUid = params.planUid || void 0;
+      const mode = params.mode || "live";
+      const granularity = params.granularity === "file" ? "file" : "cluster";
+      return buildGraphScene(mode, planUid, granularity);
+    }
+    default:
+      throw new Error(`Unknown RPC method: ${method}`);
+  }
+}
+function requireRecentProject(projectPath) {
+  if (!recentProjectsService.getRecentProject(projectPath)) {
+    throw new Error(`${projectPath} is not a recent project`);
+  }
+  return projectPath;
+}
+function requirePlan(params, key) {
+  const uid = requireString(params, key);
+  if (!planService.getPlan(uid)) throw new Error(`Plan not found: ${uid}`);
+  return uid;
+}
+function requireString(params, key) {
+  const val = params[key];
+  if (typeof val !== "string" || !val) {
+    throw new Error(`Missing required string parameter: ${key}`);
+  }
+  return val;
+}
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+const PROJECT_MARKERS = ["package.json", "Cargo.toml", "pom.xml", "go.mod", "pyproject.toml", "composer.json", "build.gradle"];
+function browseDirectory(dir) {
+  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", ".next", ".cache", "target", ".venv", "venv", "__pycache__", "Library", ".Trash"]);
+  let entries = [];
+  try {
+    const dirents = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+    entries = dirents.filter((e) => e.isDirectory() && !SKIP.has(e.name) && (!e.name.startsWith(".") || e.name === ".codetrellis")).map((e) => {
+      const full = import_node_path.default.join(dir, e.name);
+      return {
+        name: e.name,
+        path: full,
+        isGitRepo: safe(() => import_node_fs.default.existsSync(import_node_path.default.join(full, ".git")), false),
+        hasProjectMarker: safe(() => PROJECT_MARKERS.some((m) => import_node_fs.default.existsSync(import_node_path.default.join(full, m))), false)
+      };
+    }).sort((a, b) => {
+      const ap = a.isGitRepo || a.hasProjectMarker ? 0 : 1;
+      const bp = b.isGitRepo || b.hasProjectMarker ? 0 : 1;
+      return ap - bp || a.name.localeCompare(b.name);
+    });
+  } catch {
+  }
+  const parent = import_node_path.default.dirname(dir);
+  return {
+    path: dir,
+    parent: parent === dir ? null : parent,
+    home: import_node_os.default.homedir(),
+    entries
+  };
+}
+function clusterKey(rel) {
+  const parts = rel.split("/");
+  if (parts.length <= 1) return "(root)";
+  if (parts.length === 2) return parts[0];
+  return `${parts[0]}/${parts[1]}`;
+}
+const MAX_FILE_NODES = 140;
+function buildGraphScene(mode, planUid, granularity = "cluster") {
+  const projectPath = (0, import_server.getActiveProjectPath)() || recentProjectsService.listRecentProjects()[0]?.path || null;
+  const depEdges = safe(() => (0, import_database.getDependencyEdges)(), []);
+  const fileMode = granularity === "file";
+  const keyFn = (rel) => fileMode ? rel : clusterKey(rel);
+  const labelFn = (key) => fileMode ? key.split("/").pop() || key : key;
+  const clusters = /* @__PURE__ */ new Map();
+  const ensure = (key) => {
+    let c = clusters.get(key);
+    if (!c) {
+      c = { fileCount: 0, files: /* @__PURE__ */ new Set(), state: "normal" };
+      clusters.set(key, c);
+    }
+    return c;
+  };
+  const addFile = (rel) => {
+    const c = ensure(keyFn(rel));
+    if (!c.files.has(rel)) {
+      c.files.add(rel);
+      c.fileCount++;
+    }
+  };
+  const edgeAgg = /* @__PURE__ */ new Map();
+  for (const e of depEdges) {
+    addFile(e.sourceRelative);
+    addFile(e.targetRelative);
+    const s = keyFn(e.sourceRelative);
+    const t = keyFn(e.targetRelative);
+    if (s === t) continue;
+    const key = `${s}->${t}`;
+    const agg = edgeAgg.get(key);
+    if (agg) agg.weight++;
+    else edgeAgg.set(key, { source: s, target: t, weight: 1 });
+  }
+  let changedCount = 0;
+  if (mode === "diff" || mode === "live") {
+    const changed = /* @__PURE__ */ new Set();
+    if (projectPath) {
+      const git = safe(() => (0, import_server.getGitWorkingTreeStatus)(projectPath), null);
+      if (git) {
+        for (const f of [
+          ...git.stagedAdded,
+          ...git.stagedModified,
+          ...git.stagedDeleted,
+          ...git.unstagedModified,
+          ...git.unstagedDeleted,
+          ...git.untracked
+        ]) changed.add(f);
+      }
+      const baseline = safe(() => (0, import_diff_engine.getBaseline)(), null);
+      if (baseline) {
+        const arch = safe(() => {
+          const currentEdges = (0, import_database.getDependencyEdges)();
+          const fileData = (0, import_server.readFilesSnapshot)(projectPath);
+          return (0, import_diff_engine.computeDiff)((0, import_diff_engine.captureSnapshot)(fileData, currentEdges));
+        }, null);
+        if (arch) for (const f of [...arch.addedFiles, ...arch.modifiedFiles]) changed.add(f);
+      }
+    }
+    for (const f of changed) {
+      const c = clusters.get(keyFn(f));
+      if (c && c.state === "normal") {
+        c.state = "changed";
+      }
+    }
+    changedCount = changed.size;
+  }
+  let plannedCount = 0;
+  if ((mode === "planned" || planUid) && planUid) {
+    const proj = safe(() => (0, import_projection_service.computeProjection)(planUid), null);
+    if (proj) {
+      const mark = (relPath, state, ghostOk) => {
+        const key = keyFn(relPath);
+        let c = clusters.get(key);
+        if (!c && ghostOk) {
+          c = ensure(key);
+        }
+        if (c) c.state = state;
+      };
+      for (const g of proj.ghostFiles) {
+        ensure(keyFn(g.path)).state = "planned_add";
+      }
+      for (const m of proj.modifiedFiles) mark(m.path, "planned_modify", false);
+      for (const r of proj.removedFiles) mark(r.path, "planned_remove", false);
+      plannedCount = proj.ghostFiles.length + proj.modifiedFiles.length + proj.removedFiles.length;
+    }
+  }
+  let nodes = [...clusters.entries()].map(([id, c]) => ({
+    id,
+    label: labelFn(id),
+    fileCount: c.fileCount,
+    state: c.state
+  }));
+  let edges = [...edgeAgg.values()];
+  let truncated = false;
+  if (fileMode && nodes.length > MAX_FILE_NODES) {
+    const degree = /* @__PURE__ */ new Map();
+    for (const e of edges) {
+      degree.set(e.source, (degree.get(e.source) ?? 0) + e.weight);
+      degree.set(e.target, (degree.get(e.target) ?? 0) + e.weight);
+    }
+    const ranked = [...nodes].sort((a, b) => {
+      const fa = a.state !== "normal" ? 1 : 0;
+      const fb = b.state !== "normal" ? 1 : 0;
+      if (fa !== fb) return fb - fa;
+      return (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0);
+    });
+    const keep = new Set(ranked.slice(0, MAX_FILE_NODES).map((n) => n.id));
+    nodes = nodes.filter((n) => keep.has(n.id));
+    edges = edges.filter((e) => keep.has(e.source) && keep.has(e.target));
+    truncated = true;
+  }
+  return {
+    mode,
+    granularity,
+    projectPath,
+    nodes,
+    edges,
+    counts: { nodes: nodes.length, edges: edges.length, changed: changedCount, planned: plannedCount },
+    truncated
+  };
+}
+function getDirectoryFiles(dir) {
+  const d = (0, import_database.getDb)();
+  const prefix = dir.endsWith("/") ? dir : `${dir}/`;
+  const filesResult = d.exec(`
+    SELECT f.path, f.relative_path, f.language,
+      (SELECT COUNT(*) FROM symbols s WHERE s.file_id = f.id AND s.parent_symbol_id IS NULL) AS sym_count,
+      (SELECT COUNT(*) FROM imports i WHERE i.file_id = f.id) AS import_count,
+      (SELECT COUNT(DISTINCT i2.file_id) FROM imports i2 WHERE i2.resolved_path = f.path) AS imported_by_count
+    FROM files f
+    WHERE f.relative_path LIKE ? AND f.relative_path NOT LIKE ?
+    ORDER BY f.relative_path
+  `, [`${prefix}%`, `${prefix}%/%`]);
+  const files = (filesResult[0]?.values ?? []).map((row) => ({
+    path: row[0],
+    relativePath: row[1],
+    language: row[2],
+    symbolCount: row[3],
+    importCount: row[4],
+    importedByCount: row[5]
+  }));
+  const subdirResult = d.exec(`
+    SELECT
+      SUBSTR(f.relative_path, LENGTH(?) + 1,
+        INSTR(SUBSTR(f.relative_path, LENGTH(?) + 1), '/') - 1
+      ) AS subdir,
+      COUNT(*) AS cnt
+    FROM files f
+    WHERE f.relative_path LIKE ?
+      AND SUBSTR(f.relative_path, LENGTH(?) + 1) LIKE '%/%'
+    GROUP BY subdir
+    HAVING subdir != ''
+    ORDER BY cnt DESC
+  `, [prefix, prefix, `${prefix}%`, prefix]);
+  const subdirectories = (subdirResult[0]?.values ?? []).map((row) => ({
+    name: row[0],
+    fileCount: row[1]
+  }));
+  return { dir, files, subdirectories };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mobileConnected,
+  navigateMobile,
+  requestMobileScreenshot,
+  sendMobileCommand,
+  startMobileRpc,
+  stopMobileRpc
+});