codetrellis 0.0.0-stage → 0.3.0

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
+});

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

@@ -0,0 +1,98 @@
+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_budget_exports = {};
+__export(mobile_budget_exports, {
+  BUDGET_METHODS: () => BUDGET_METHODS,
+  handleBudgetMethod: () => handleBudgetMethod,
+  phoneBudget: () => phoneBudget
+});
+module.exports = __toCommonJS(mobile_budget_exports);
+var budgetService = __toESM(require("./budget-service"));
+var import_plan_service = require("./plan-service");
+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_budget_words = require("../../shared/lib/budget-words");
+const BUDGET_METHODS = ["budget.get", "budget.acknowledge"];
+async function handleBudgetMethod(method, params, peer) {
+  switch (method) {
+    case "budget.get":
+      return phoneBudget(requirePlan(params));
+    case "budget.acknowledge":
+      return acknowledge(requirePlan(params), params.changeId, peer);
+    default:
+      throw new Error(`Unknown budget method: ${method}`);
+  }
+}
+function requirePlan(params) {
+  const planUid = params.planUid;
+  if (typeof planUid !== "string" || !planUid) throw new Error("planUid is required");
+  if (!(0, import_plan_service.getPlan)(planUid)) throw new Error("Plan not found");
+  return planUid;
+}
+function phoneBudget(planUid) {
+  const report = budgetService.getBudgetReport(planUid);
+  return {
+    planUid,
+    budget: report.budget ? { minutes: report.budget.minutes, costUsd: report.budget.costUsd, exempt: report.budget.exempt } : null,
+    spentMinutes: report.spentMinutes,
+    spentCostUsd: report.spentCostUsd,
+    flaggedChanges: report.flaggedChanges.map((c) => ({
+      id: c.id,
+      by: c.actor,
+      byType: c.actorType,
+      words: (0, import_budget_words.describeBudgetChange)(c.before, c.after),
+      at: c.at
+    }))
+  };
+}
+function acknowledge(planUid, changeId, peer) {
+  if (typeof changeId !== "number" || !Number.isInteger(changeId)) throw new Error("changeId must be a number");
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Marking a budget change seen needs a pairing confirmed on the desktop");
+  }
+  const change = budgetService.acknowledgeBudgetChange(planUid, changeId, (0, import_settings_service.getAuthorKey)("human"));
+  if (!change) throw new Error("No such budget change on this plan");
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "budget.acknowledge",
+    detail: `saw budget change ${changeId} on plan ${planUid}`
+  });
+  peer.broadcast?.("plan-budget-changed", { planUid, acknowledged: changeId });
+  return phoneBudget(planUid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUDGET_METHODS,
+  handleBudgetMethod,
+  phoneBudget
+});

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

@@ -0,0 +1,106 @@
+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_freeze_exports = {};
+__export(mobile_freeze_exports, {
+  FREEZE_METHODS: () => FREEZE_METHODS,
+  handleFreezeMethod: () => handleFreezeMethod,
+  phoneFreeze: () => phoneFreeze
+});
+module.exports = __toCommonJS(mobile_freeze_exports);
+var freezeService = __toESM(require("./freeze-service"));
+var import_plan_service = require("./plan-service");
+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_trusted_roots = require("./trusted-roots");
+var import_freeze_words = require("../../shared/lib/freeze-words");
+const FREEZE_METHODS = ["freeze.get", "freeze.acknowledge"];
+async function handleFreezeMethod(method, params, peer) {
+  switch (method) {
+    case "freeze.get":
+      return phoneFreeze(requirePlan(params));
+    case "freeze.acknowledge":
+      return acknowledge(requirePlan(params), params.changeId, peer);
+    default:
+      throw new Error(`Unknown freeze method: ${method}`);
+  }
+}
+function requirePlan(params) {
+  const planUid = params.planUid;
+  if (typeof planUid !== "string" || !planUid) throw new Error("planUid is required");
+  if (!(0, import_plan_service.getPlan)(planUid)) throw new Error("Plan not found");
+  return planUid;
+}
+function projectOf(planUid) {
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan?.projectPath) throw new Error("This plan is not in a project");
+  return (0, import_trusted_roots.resolveTrustedProjectRoot)(plan.projectPath, "plan.projectPath");
+}
+function phoneFreeze(planUid) {
+  const status = freezeService.getFreezeStatus(projectOf(planUid));
+  return {
+    planUid,
+    active: status.active,
+    reason: status.reason,
+    until: status.until,
+    planExempt: status.allowedPlanUids.includes(planUid),
+    flaggedChanges: status.flaggedChanges.map((c) => ({
+      id: c.id,
+      by: c.actor,
+      byType: c.actorType,
+      words: (0, import_freeze_words.describeFreezeChange)(c.before, c.after),
+      at: c.at
+    }))
+  };
+}
+function acknowledge(planUid, changeId, peer) {
+  if (typeof changeId !== "number" || !Number.isInteger(changeId)) throw new Error("changeId must be a number");
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Marking a freeze change seen needs a pairing confirmed on the desktop");
+  }
+  const projectPath = projectOf(planUid);
+  const change = freezeService.acknowledgeFreezeChange(projectPath, changeId, (0, import_settings_service.getAuthorKey)("human"));
+  if (!change) throw new Error("No such freeze change on this project");
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "freeze.acknowledge",
+    detail: `saw freeze change ${changeId} on ${projectPath}`
+  });
+  peer.broadcast?.("freeze-changed", { projectRoot: projectPath, acknowledged: changeId });
+  return phoneFreeze(planUid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FREEZE_METHODS,
+  handleFreezeMethod,
+  phoneFreeze
+});

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

@@ -0,0 +1,100 @@
+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_proposals_exports = {};
+__export(mobile_proposals_exports, {
+  PROPOSAL_METHODS: () => PROPOSAL_METHODS,
+  handleProposalMethod: () => handleProposalMethod,
+  toPhoneProposal: () => toPhoneProposal
+});
+module.exports = __toCommonJS(mobile_proposals_exports);
+var import_spec_proposals_service = require("./spec-proposals-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_proposal_words = require("../../shared/lib/proposal-words");
+const PROPOSAL_METHODS = ["proposal.list", "proposal.get", "proposal.decide"];
+async function handleProposalMethod(method, params, peer, ctx) {
+  switch (method) {
+    case "proposal.list":
+      return { proposals: (0, import_spec_proposals_service.listProposals)({ status: "open", ...ctx.projectRoot ? { projectPath: ctx.projectRoot } : {} }).reverse().map(toPhoneProposal) };
+    case "proposal.get": {
+      const p = typeof params.uid === "string" ? (0, import_spec_proposals_service.getProposal)(params.uid) : null;
+      if (!p) throw new Error("No such proposal");
+      return { proposal: toPhoneProposal(p) };
+    }
+    case "proposal.decide":
+      return decide(params, peer, ctx);
+    default:
+      throw new Error(`Unknown proposal method: ${method}`);
+  }
+}
+function toPhoneProposal(p) {
+  return {
+    uid: p.uid,
+    hitRef: p.hitRef,
+    status: p.status,
+    headline: (0, import_proposal_words.proposalHeadline)(p),
+    where: (0, import_proposal_words.proposalWhere)(p),
+    why: p.why,
+    evidence: (0, import_proposal_words.evidenceWords)(p.evidence),
+    before: p.beforeText,
+    proposed: p.proposedText,
+    replies: (0, import_proposal_words.repliesLine)(p),
+    impacts: p.impacts.map((i) => ({ impact: i.impact, label: (0, import_proposal_words.impactLabel)(i), who: (0, import_proposal_words.impactWho)(i), words: i.words })),
+    pageChangedSince: p.pageChangedSince,
+    guardNote: p.pageBreakpoint?.note ?? null,
+    guarded: !!p.pageBreakpoint,
+    createdAt: p.createdAt,
+    decidedAt: p.decidedAt,
+    decisionNote: p.decisionNote
+  };
+}
+function decide(params, peer, ctx) {
+  const uid = params.uid;
+  if (typeof uid !== "string" || !uid) throw new Error("uid is required");
+  const decision = params.decision;
+  if (decision !== "accept" && decision !== "reject") throw new Error("On the phone a proposal is accepted or rejected; amending it is done in the window.");
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Deciding a spec change needs a pairing confirmed on the desktop");
+  }
+  const existing = (0, import_spec_proposals_service.getProposal)(uid);
+  if (!existing) throw new Error("No such proposal");
+  if (existing.status !== "open") return { proposal: toPhoneProposal(existing), alreadyDecided: true };
+  const input = { uid, decision, note: typeof params.note === "string" ? params.note : void 0 };
+  const problem = (0, import_spec_proposals_service.decisionProblem)(input);
+  if (problem) throw new Error(problem);
+  const { proposal, flagged } = (0, import_spec_proposals_service.decideProposal)(input, ctx.who);
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "proposal.decide",
+    detail: `${decision} on spec proposal ${uid}`
+  });
+  peer.broadcast?.("spec-proposal-decided", { uid: proposal.uid, status: proposal.status, pageUid: proposal.pageUid });
+  if (proposal.hitRef) peer.broadcast?.("breakpoint-answered", { ref: proposal.hitRef, planUid: proposal.planUid, decision: proposal.status === "rejected" ? "stop" : "continue" });
+  if (proposal.status === "accepted") peer.broadcast?.("plan-item-updated", { planUid: proposal.planUid, itemUid: proposal.pageUid, kind: "object", changes: { body: true } });
+  return { proposal: toPhoneProposal(proposal), flagged: flagged.length };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROPOSAL_METHODS,
+  handleProposalMethod,
+  toPhoneProposal
+});