codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/mobile-approvals.js

@@ -0,0 +1,306 @@
+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_approvals_exports = {};
+__export(mobile_approvals_exports, {
+  APPROVAL_METHODS: () => APPROVAL_METHODS,
+  PREVIEW_CHUNK_CHARS: () => PREVIEW_CHUNK_CHARS,
+  PREVIEW_IMAGE_BYTES: () => PREVIEW_IMAGE_BYTES,
+  PREVIEW_TEXT_CHARS: () => PREVIEW_TEXT_CHARS,
+  SHEET_CONTEXT: () => SHEET_CONTEXT,
+  buildPreview: () => buildPreview,
+  handleApprovalMethod: () => handleApprovalMethod,
+  sanitiseLocator: () => sanitiseLocator,
+  setPreviewImageScaler: () => setPreviewImageScaler,
+  toPhone: () => toPhone
+});
+module.exports = __toCommonJS(mobile_approvals_exports);
+var import_node_path = __toESM(require("node:path"));
+var criteriaService = __toESM(require("./criteria-service"));
+var import_artefact_service = require("./artefact-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_task_grounding = require("./task-grounding");
+var import_human_decision = require("./human-decision");
+var import_settings_service = require("./settings-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_sensor_bridge_service = require("./sensor-bridge-service");
+var import_reader_host = require("./material-reader/reader-host");
+var import_locator = require("../../shared/lib/locator");
+var import_xlsx_xml = require("../../shared/lib/xlsx-xml");
+const PREVIEW_TEXT_CHARS = 4e4;
+const PREVIEW_IMAGE_BYTES = 3 * 1024 * 1024;
+const PREVIEW_CHUNK_CHARS = 16e3;
+const SHEET_CONTEXT = { rows: 6, cols: 3 };
+const TRANSFER_ID = /^[A-Za-z0-9-]{8,64}$/;
+let scaler = null;
+function setPreviewImageScaler(fn) {
+  scaler = fn;
+}
+const APPROVAL_METHODS = ["criteria.awaiting", "criteria.list", "criterion.decide", "artefact.preview"];
+async function handleApprovalMethod(method, params, peer) {
+  switch (method) {
+    case "criteria.awaiting":
+      return awaiting(params);
+    case "criteria.list":
+      return criteriaForItem(requireUid(params, "itemUid"));
+    case "criterion.decide":
+      return decide(requireUid(params, "criterionUid"), params, peer);
+    case "artefact.preview":
+      return preview(params, peer);
+    default:
+      throw new Error(`Unknown approval method: ${method}`);
+  }
+}
+function awaiting(params) {
+  const limit = typeof params.limit === "number" && params.limit > 0 ? Math.min(params.limit, 200) : 100;
+  return {
+    entries: criteriaService.listAwaitingPerson(limit).map((a) => ({
+      ...toPhone(a.criterion),
+      itemTitle: a.itemTitle,
+      planUid: a.planUid,
+      planTitle: a.planTitle
+    }))
+  };
+}
+async function criteriaForItem(itemUid) {
+  const item = (0, import_plan_item_service.getItem)(itemUid);
+  if (!item) throw new Error("Item not found");
+  await (0, import_artefact_service.refreshArtefactHashes)(itemUid).catch(() => []);
+  const g = await (0, import_task_grounding.taskGrounding)(itemUid);
+  return {
+    item: { uid: item.uid, title: item.title, planUid: item.planUid },
+    criteria: criteriaService.listCriteria(itemUid).map(toPhone),
+    grounding: g && g.total ? { words: g.words, grounded: g.grounded, grades: Object.fromEntries(g.criteria.map((c) => [c.uid, { grade: c.grade, why: c.why }])) } : null
+  };
+}
+async function decide(criterionUid, params, peer) {
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Approving needs a pairing confirmed on the desktop");
+  }
+  const before = criteriaService.getCriterion(criterionUid);
+  if (!before) throw new criteriaService.CriterionError("Criterion not found", 404);
+  await (0, import_artefact_service.refreshArtefactHashes)(before.itemUid).catch(() => []);
+  const criterion = criteriaService.decideCriterion(
+    criterionUid,
+    { decision: params.decision, note: params.note, anchor: params.anchor },
+    (0, import_human_decision.issueHumanDecision)("phone", (0, import_settings_service.getAuthorKey)("human"), device.alias)
+  );
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "criterion.decide",
+    detail: `${params.decision === "approved" ? "approved" : "sent back"} criterion ${criterionUid}`
+  });
+  const planUid = (0, import_plan_item_service.getItem)(criterion.itemUid)?.planUid ?? null;
+  if (planUid) (0, import_sensor_bridge_service.resolveCriterionNotices)(planUid, criterionUid);
+  peer.broadcast?.("plan-item-criteria-changed", { planUid, itemUid: criterion.itemUid });
+  return { criterion: toPhone(criterion) };
+}
+async function preview(params, peer) {
+  const transferId = params.transferId;
+  if (typeof transferId !== "string" || !TRANSFER_ID.test(transferId)) {
+    throw new Error("transferId must be 8\u201364 letters, digits or dashes");
+  }
+  const attachmentUid = requireUid(params, "attachmentUid");
+  const artefact = (0, import_artefact_service.getArtefact)(attachmentUid);
+  if (!artefact) throw new Error("No evidence file with that uid");
+  const built = await buildPreview(attachmentUid, sanitiseLocator(params.locator));
+  const body = JSON.stringify(built);
+  const total = Math.max(1, Math.ceil(body.length / PREVIEW_CHUNK_CHARS));
+  for (let seq = 0; seq < total; seq++) {
+    peer.send({
+      mcp: true,
+      cmd: "preview.chunk",
+      id: transferId,
+      seq,
+      total,
+      data: body.slice(seq * PREVIEW_CHUNK_CHARS, (seq + 1) * PREVIEW_CHUNK_CHARS)
+    });
+  }
+  return { transferId, total, chars: body.length, kind: built.kind };
+}
+async function buildPreview(attachmentUid, locator, read = import_reader_host.readMaterial) {
+  const artefact = (0, import_artefact_service.getArtefact)(attachmentUid);
+  const ext = artefact ? import_node_path.default.extname(artefact.path).slice(1).toLowerCase() : "";
+  const isImage = ["png", "jpg", "jpeg", "gif", "webp"].includes(ext);
+  let readAt = isImage ? null : locator;
+  let grid;
+  if ((ext === "xlsx" || ext === "xlsm") && locator) {
+    const cited = locator.range ? (0, import_locator.parseRange)(String(locator.range)) : null;
+    if (cited) {
+      const firstRow = Math.max(1, cited.from.row - SHEET_CONTEXT.rows);
+      const firstCol = Math.max(1, cited.from.col - SHEET_CONTEXT.cols);
+      const lastRow = cited.to.row + SHEET_CONTEXT.rows;
+      const lastCol = cited.to.col + SHEET_CONTEXT.cols;
+      readAt = { ...locator, range: `${(0, import_xlsx_xml.colLetters)(firstCol)}${firstRow}:${(0, import_xlsx_xml.colLetters)(lastCol)}${lastRow}` };
+      grid = { firstRow, firstCol, cited };
+    } else if (!locator.text) {
+      grid = { firstRow: 1, firstCol: 1, cited: null };
+    }
+  }
+  const result = await read(attachmentUid, readAt);
+  if (!result.ok) return { kind: "unavailable", name: result.name ?? null, reason: result.reason };
+  if (result.kind === "image") {
+    const original = Buffer.from(result.base64, "base64");
+    const scaled = scaler ? safeScale(original, result.mimeType) : null;
+    if (scaled) return { kind: "image", name: result.name, mime: scaled.mime, base64: scaled.bytes.toString("base64"), scaled: true };
+    if (original.length > PREVIEW_IMAGE_BYTES) {
+      return {
+        kind: "unavailable",
+        name: result.name,
+        reason: `${result.name} is larger than the ${PREVIEW_IMAGE_BYTES / 1024 / 1024} MB the phone is sent \u2014 open it on the desktop`
+      };
+    }
+    return { kind: "image", name: result.name, mime: result.mimeType, base64: result.base64, scaled: false };
+  }
+  const { reply } = result;
+  const notes = [...reply.notes];
+  let budget = PREVIEW_TEXT_CHARS;
+  const sections = [];
+  for (const s of reply.sections) {
+    if (budget <= 0) break;
+    if (s.body.length > budget) {
+      sections.push({ heading: s.heading, body: s.body.slice(0, budget) });
+      notes.push("Cut short for the phone \u2014 the whole of it is on the desktop.");
+      budget = 0;
+      break;
+    }
+    sections.push(s);
+    budget -= s.body.length;
+  }
+  if (sections.length < reply.sections.length && !notes.some((n) => n.startsWith("Cut short"))) {
+    notes.push("Cut short for the phone \u2014 the whole of it is on the desktop.");
+  }
+  if (grid) {
+    return {
+      kind: "text",
+      name: result.name,
+      format: reply.format,
+      // The place that was cited, not the wider area read around it.
+      where: (0, import_locator.describeLocator)(locator) || reply.where,
+      outline: reply.outline,
+      sections: sections.map((sec) => ({ ...sec, heading: sec.heading.replace(/,\s*[A-Z]+\d+:[A-Z]+\d+$/, "").replace(/ from A1$/, "") })),
+      notes,
+      grid
+    };
+  }
+  return {
+    kind: "text",
+    name: result.name,
+    format: reply.format,
+    where: reply.where,
+    outline: reply.outline,
+    sections,
+    notes
+  };
+}
+function safeScale(bytes, mime) {
+  try {
+    return scaler?.(bytes, mime) ?? null;
+  } catch (err) {
+    console.warn("[Approvals] Could not scale an image for the phone:", err);
+    return null;
+  }
+}
+function requireUid(params, key) {
+  const v = params[key];
+  if (typeof v !== "string" || !/^[A-Za-z0-9-]{8,64}$/.test(v)) throw new Error(`${key} is required`);
+  return v;
+}
+function sanitiseLocator(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const l = raw;
+  const out = {};
+  const str = (v) => typeof v === "string" && v.length > 0 && v.length <= 200 ? v : void 0;
+  const span = (v) => {
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+    if (Array.isArray(v) && v.length === 2 && v.every((n) => typeof n === "number")) return `${v[0]}-${v[1]}`;
+    return str(v);
+  };
+  out.sheet = str(l.sheet);
+  out.range = str(l.range);
+  out.page = span(l.page);
+  out.lines = span(l.lines);
+  out.text = str(l.text);
+  for (const k of Object.keys(out)) if (out[k] === void 0) delete out[k];
+  return Object.keys(out).length > 0 ? out : null;
+}
+function toEvidence(e) {
+  const artefact = e.attachmentUid ? (0, import_artefact_service.getArtefact)(e.attachmentUid) : null;
+  const name = artefact ? import_node_path.default.basename(artefact.path) : null;
+  return {
+    attachmentUid: e.attachmentUid,
+    name,
+    ext: name ? import_node_path.default.extname(name).slice(1).toLowerCase() || null : null,
+    locator: e.locator,
+    where: (0, import_locator.describeLocator)(e.locator),
+    note: e.note,
+    submittedBy: e.submittedBy,
+    submittedAt: e.submittedAt
+  };
+}
+function toPhone(c) {
+  const signoff = c.latestSignoff;
+  let changedFiles = [];
+  if (c.state === "stale" && signoff?.evidenceHashes) {
+    const recorded = signoff.evidenceHashes;
+    changedFiles = Object.keys(recorded).filter((uid) => ((0, import_artefact_service.getArtefact)(uid)?.sha256 ?? null) !== recorded[uid]).map((uid) => (0, import_artefact_service.getArtefact)(uid)?.path ?? uid);
+  }
+  return {
+    uid: c.uid,
+    itemUid: c.itemUid,
+    text: c.text,
+    kind: c.kind,
+    policy: c.policy,
+    state: c.state,
+    evidence: c.latestSubmission.map(toEvidence),
+    lastDecision: signoff ? { decision: signoff.decision, actor: signoff.actor, channel: signoff.channel, note: signoff.note, at: signoff.createdAt } : null,
+    changedFiles,
+    // The desktop's rule, the same here (CriteriaBlock): approve anything
+    // not already met; send back what was submitted, or take back an
+    // approval.
+    canApprove: c.state !== "met",
+    canSendBack: c.state === "submitted" || c.state === "met"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPROVAL_METHODS,
+  PREVIEW_CHUNK_CHARS,
+  PREVIEW_IMAGE_BYTES,
+  PREVIEW_TEXT_CHARS,
+  SHEET_CONTEXT,
+  buildPreview,
+  handleApprovalMethod,
+  sanitiseLocator,
+  setPreviewImageScaler,
+  toPhone
+});

package/src/backend/services/mobile-awareness.js

@@ -0,0 +1,180 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_awareness_exports = {};
+__export(mobile_awareness_exports, {
+  AWARENESS_METHODS: () => AWARENESS_METHODS,
+  handleAwarenessMethod: () => handleAwarenessMethod,
+  phoneChecks: () => phoneChecks,
+  phoneNeedsYou: () => phoneNeedsYou,
+  phoneSignal: () => phoneSignal
+});
+module.exports = __toCommonJS(mobile_awareness_exports);
+var import_awareness_service = require("./awareness-service");
+var import_awareness_notices = require("./awareness-notices");
+var import_awareness_replies = require("./awareness-replies");
+var import_workstream_service = require("./workstream-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_awareness_digest = require("../../shared/lib/awareness-digest");
+var import_check_runs = require("./check-runs");
+var import_check_run_record = require("./task-records/check-run-record");
+var import_open_findings = require("../../shared/lib/open-findings");
+var import_check_words = require("../../shared/lib/check-words");
+var import_signal_words = require("../../shared/lib/signal-words");
+var import_workstream_words = require("../../shared/lib/workstream-words");
+var import_types = require("../../shared/types");
+const AWARENESS_METHODS = ["awareness.needsYou", "awareness.signal", "awareness.answer", "awareness.reply"];
+const PHONE_FINDINGS = 3;
+function phoneChecks(projectRoot) {
+  return (0, import_open_findings.blockingRuns)((0, import_check_runs.listCheckRuns)(projectRoot)).map((r) => {
+    const failing = r.findings.filter((f) => f.failing);
+    return {
+      id: r.id,
+      who: r.who,
+      ranIn: r.ranIn,
+      scope: r.scope,
+      at: r.at,
+      outcome: (0, import_check_run_record.outcomeWords)(r.outcome),
+      findings: failing.slice(0, PHONE_FINDINGS).map((f) => ({ where: `${f.path} ${(0, import_check_words.reachWords)(f.imports)}`, rule: f.rule, fix: f.fix })),
+      more: Math.max(0, failing.length - PHONE_FINDINGS)
+    };
+  });
+}
+async function handleAwarenessMethod(method, params, peer, ctx) {
+  switch (method) {
+    case "awareness.needsYou":
+      return phoneNeedsYou(ctx.projectRoot);
+    case "awareness.signal":
+      return { signal: await phoneSignal(ctx.projectRoot, idOf(params)) };
+    case "awareness.answer":
+      return answer(params, peer, ctx);
+    case "awareness.reply":
+      return reply(params, peer, ctx);
+    default:
+      throw new Error(`Unknown awareness method: ${method}`);
+  }
+}
+const RANK = { high: 0, medium: 1, low: 2 };
+async function phoneNeedsYou(projectRoot) {
+  const empty = { projectRoot, digest: { needsYou: 0, low: 0, moreLines: 0, lines: [] }, signals: [], checks: [] };
+  if (!projectRoot) return empty;
+  const workstreams = await workstreamsOf(projectRoot);
+  const label = (root) => (0, import_workstream_words.sideLabel)(root, workstreams);
+  const signals = (0, import_awareness_notices.withTold)((0, import_awareness_service.listSignals)(projectRoot));
+  const d = (0, import_awareness_digest.buildDigest)(signals, label);
+  const inPlay = signals.filter((s) => s.severity !== "low" && (s.state === "open" || s.state === "acknowledged")).sort((a, b) => Number(a.state !== "open") - Number(b.state !== "open") || RANK[a.severity] - RANK[b.severity] || b.lastSeen - a.lastSeen);
+  return {
+    projectRoot,
+    digest: {
+      needsYou: d.needsYou,
+      low: d.low,
+      moreLines: d.moreLines,
+      lines: d.lines.map((l) => ({ text: l.text, question: l.question, told: l.told, signalIds: l.signalIds }))
+    },
+    signals: inPlay.map((s) => toPhoneSignal(s, label)),
+    checks: phoneChecks(projectRoot)
+  };
+}
+async function phoneSignal(projectRoot, id) {
+  if (!projectRoot) throw new Error("No project is open on the desktop");
+  const workstreams = await workstreamsOf(projectRoot);
+  const s = (0, import_awareness_replies.withReplies)((0, import_awareness_notices.withTold)((0, import_awareness_service.listSignals)(projectRoot))).find((x) => x.id === id);
+  if (!s) throw new Error("No such open signal in this project");
+  const label = (root) => (0, import_workstream_words.sideLabel)(root, workstreams);
+  return {
+    ...toPhoneSignal(s, label),
+    sideWords: (0, import_signal_words.sideWords)(s, label),
+    files: filesOf(s),
+    told: (s.told ?? []).map((t) => ({ agentType: t.agentType, toldAt: t.toldAt, ...t.note ? { note: t.note } : {} })),
+    replies: s.replies ?? [],
+    ...s.stateBy ? { stateBy: s.stateBy, stateAt: s.stateAt } : {},
+    ...s.reopened ? { reopened: s.reopened } : {}
+  };
+}
+function toPhoneSignal(s, label) {
+  return {
+    id: s.id,
+    kind: s.kind,
+    severity: s.severity,
+    state: s.state,
+    heading: (0, import_signal_words.kindWords)(s),
+    summary: s.summary,
+    sides: (0, import_signal_words.sideWords)(s, label).map((x) => x.name),
+    ...s.subject.material ? { material: s.subject.material } : {},
+    firstSeen: s.firstSeen,
+    lastSeen: s.lastSeen
+  };
+}
+function filesOf(s) {
+  const files = /* @__PURE__ */ new Set();
+  if (s.subject.material) files.add(s.subject.material);
+  if (s.subject.file) files.add(s.subject.file);
+  for (const f of s.subject.files ?? []) files.add(f);
+  for (const f of s.subject.importers ?? []) files.add(f);
+  return [...files];
+}
+function idOf(params) {
+  const id = params.id;
+  if (typeof id !== "string" || !id) throw new Error("id is required");
+  return id;
+}
+function confirmedDevice(peer, what) {
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) throw new import_peer_capabilities.PeerAuthorizationError(`${what} needs a pairing confirmed on the desktop`);
+  return device;
+}
+async function answer(params, peer, ctx) {
+  const id = idOf(params);
+  const state = params.state;
+  if (!import_types.SETTABLE_SIGNAL_STATES.includes(state)) throw new Error(`state must be one of ${import_types.SETTABLE_SIGNAL_STATES.join(", ")}`);
+  const device = confirmedDevice(peer, "Answering a signal");
+  if (!ctx.projectRoot) throw new Error("No project is open on the desktop");
+  const updated = (0, import_awareness_service.setSignalState)(ctx.projectRoot, id, state, ctx.who);
+  if (!updated) throw new Error("No such open signal in this project");
+  (0, import_peer_audit_service.recordPeerAudit)({ kind: "decision", fingerprint: peer.fingerprint, alias: device.alias, method: "awareness.answer", detail: `${state} on signal ${id}` });
+  peer.broadcast?.("awareness-changed", { projectRoot: ctx.projectRoot });
+  return { signal: await phoneSignal(ctx.projectRoot, id) };
+}
+async function reply(params, peer, ctx) {
+  const id = idOf(params);
+  const message = (0, import_awareness_replies.cleanReply)(params.message);
+  if (!message) throw new Error(`message must be 1\u2013${import_awareness_replies.MAX_REPLY} characters`);
+  const device = confirmedDevice(peer, "Replying to the agents");
+  if (!ctx.projectRoot) throw new Error("No project is open on the desktop");
+  const sent = ctx.reply(ctx.projectRoot, id, message, ctx.who);
+  if (!sent) throw new Error("No such open signal in this project");
+  (0, import_peer_audit_service.recordPeerAudit)({ kind: "decision", fingerprint: peer.fingerprint, alias: device.alias, method: "awareness.reply", detail: `reply on signal ${id}` });
+  const { signalId: _s, steers, ...kept } = sent;
+  return { reply: kept, steers: steers.length, signal: await phoneSignal(ctx.projectRoot, id) };
+}
+async function workstreamsOf(projectRoot) {
+  try {
+    return await (0, import_workstream_service.listWorkstreams)(projectRoot, { includeIdle: true });
+  } catch {
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AWARENESS_METHODS,
+  handleAwarenessMethod,
+  phoneChecks,
+  phoneNeedsYou,
+  phoneSignal
+});

package/src/backend/services/mobile-breakpoints.js

@@ -0,0 +1,115 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_breakpoints_exports = {};
+__export(mobile_breakpoints_exports, {
+  BREAKPOINT_METHODS: () => BREAKPOINT_METHODS,
+  handleBreakpointMethod: () => handleBreakpointMethod,
+  phoneWaiting: () => phoneWaiting,
+  toPhoneHit: () => toPhoneHit
+});
+module.exports = __toCommonJS(mobile_breakpoints_exports);
+var import_breakpoint_service = require("./breakpoint-service");
+var import_signal_breakpoints = require("./signal-breakpoints");
+var import_workstream_service = require("./workstream-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_breakpoint_words = require("../../shared/lib/breakpoint-words");
+var import_workstream_words = require("../../shared/lib/workstream-words");
+const BREAKPOINT_METHODS = ["breakpoint.waiting", "breakpoint.answer"];
+async function handleBreakpointMethod(method, params, peer, ctx) {
+  switch (method) {
+    case "breakpoint.waiting":
+      return { hits: await phoneWaiting(ctx.projectRoot) };
+    case "breakpoint.answer":
+      return answer(params, peer, ctx);
+    default:
+      throw new Error(`Unknown breakpoint method: ${method}`);
+  }
+}
+async function phoneWaiting(projectRoot) {
+  if (projectRoot) {
+    try {
+      (0, import_signal_breakpoints.releaseSettled)(projectRoot);
+    } catch {
+    }
+  }
+  const workstreams = await workstreamsOf(projectRoot);
+  return (0, import_breakpoint_service.listHits)({ state: "waiting" }).map((h) => toPhoneHit(h, workstreams));
+}
+async function answer(params, peer, ctx) {
+  const ref = params.ref;
+  if (typeof ref !== "string" || !ref) throw new Error("ref is required");
+  const decision = params.decision;
+  if (!import_breakpoint_service.DECISIONS.includes(decision)) throw new Error(`decision must be one of ${import_breakpoint_service.DECISIONS.join(", ")}`);
+  if (decision === "steer" && !(0, import_breakpoint_service.cleanNote)(params.note)) throw new Error("A steer needs a note for the agent");
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Answering a breakpoint needs a pairing confirmed on the desktop");
+  }
+  const hit = (0, import_breakpoint_service.getHit)(ref);
+  if (!hit) throw new Error("No such breakpoint hit");
+  if (hit.kind === "proposal") throw new Error("A spec proposal is decided on the proposal: accept or reject it (proposal.decide).");
+  if (hit.answeredAt !== null) return { hit: toPhoneHit(hit, await workstreamsOf(ctx.projectRoot)), alreadyAnswered: true };
+  const answered = (0, import_breakpoint_service.answerHit)({ ref, decision, note: params.note, by: ctx.who.author, byType: ctx.who.authorType });
+  if (!answered) return { hit: toPhoneHit((0, import_breakpoint_service.getHit)(ref) ?? hit, await workstreamsOf(ctx.projectRoot)), alreadyAnswered: true };
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "breakpoint.answer",
+    detail: `${decision} on breakpoint hit ${ref}`
+  });
+  peer.broadcast?.("breakpoint-answered", { ref: answered.ref, planUid: answered.planUid, decision: answered.decision });
+  return { hit: toPhoneHit(answered, await workstreamsOf(ctx.projectRoot)) };
+}
+function toPhoneHit(hit, workstreams) {
+  const where = hit.workstreamRoot ? (0, import_workstream_words.sideLabel)(hit.workstreamRoot, workstreams) : null;
+  return {
+    ref: hit.ref,
+    breach: hit.breach,
+    headline: (0, import_breakpoint_words.hitHeadline)(hit, where),
+    why: (0, import_breakpoint_words.hitWhy)(hit),
+    labels: (0, import_breakpoint_words.decisionLabels)(hit),
+    breakpointNote: hit.breakpointNote,
+    proposalUid: hit.kind === "proposal" ? hit.breakpointTarget : null,
+    agent: hit.agent,
+    planUid: hit.planUid,
+    itemUid: hit.itemUid,
+    path: hit.path,
+    hitAt: hit.hitAt,
+    decision: hit.decision,
+    note: hit.note,
+    answeredAt: hit.answeredAt
+  };
+}
+async function workstreamsOf(projectRoot) {
+  if (!projectRoot) return [];
+  try {
+    return await (0, import_workstream_service.listWorkstreams)(projectRoot, { includeIdle: true });
+  } catch {
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BREAKPOINT_METHODS,
+  handleBreakpointMethod,
+  phoneWaiting,
+  toPhoneHit
+});