codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/play-forward.js

@@ -0,0 +1,256 @@
+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 play_forward_exports = {};
+__export(play_forward_exports, {
+  buildPlayForward: () => buildPlayForward,
+  decisionsFor: () => decisionsFor,
+  playForwardOf: () => playForwardOf
+});
+module.exports = __toCommonJS(play_forward_exports);
+var import_node_crypto = require("node:crypto");
+var import_plan_dependencies = require("./plan-dependencies");
+var import_stack_service = require("./stack-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_database = require("./database");
+var import_confined_fs = require("./confined-fs");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function list(names) {
+  if (names.length <= 1) return names.join("");
+  return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+const idOf = (kind, subject, plans) => (0, import_node_crypto.createHash)("sha256").update(`${kind}\0${subject}\0${[...plans].sort().join("\0")}`).digest("hex").slice(0, 16);
+function sequencing(plans, itemOf) {
+  const waits = (a, b) => a.tasks.some((t) => (itemOf(t.uid)?.dependencies ?? []).some((d) => b.tasks.some((o) => o.uid === d)));
+  let all = true;
+  let words = null;
+  for (let i = 0; i < plans.length; i++) {
+    for (let j = i + 1; j < plans.length; j++) {
+      const ab = waits(plans[i], plans[j]);
+      const ba = waits(plans[j], plans[i]);
+      if (!ab && !ba) all = false;
+      else if (plans.length === 2) words = ab ? `${plans[i].label} waits on ${plans[j].label}` : `${plans[j].label} waits on ${plans[i].label}`;
+    }
+  }
+  return { sequenced: all, words: all ? words ?? "each waits on another" : null };
+}
+function playForwardOf(project, plans, existingFiles, materialsOf) {
+  const items = /* @__PURE__ */ new Map();
+  for (const p of plans) for (const i of p.items) items.set(i.uid, i);
+  const itemOf = (uid) => items.get(uid);
+  const files = /* @__PURE__ */ new Map();
+  const touch = (path2, by, change) => {
+    const f = files.get(path2) ?? { path: path2, change: "modify", by: [] };
+    if (!f.by.some((b) => b.taskUid === by.taskUid && b.change === change)) f.by.push({ ...by, change });
+    files.set(path2, f);
+  };
+  const newEdges = /* @__PURE__ */ new Map();
+  const removedEdges = /* @__PURE__ */ new Map();
+  const symbols = /* @__PURE__ */ new Map();
+  const summary = [];
+  for (const plan of plans) {
+    const ahead = plan.items.filter((i) => i.kind === "action" && !(0, import_plan_dependencies.isSettled)(i));
+    summary.push({ uid: plan.uid, label: plan.label, ahead: ahead.length });
+    for (const item of ahead) {
+      const by = { planUid: plan.uid, planLabel: plan.label, taskUid: item.uid, taskTitle: item.title };
+      for (const spec of item.fileSpecs ?? []) {
+        if (spec.isDir || !spec.path) continue;
+        if (spec.action === "move") {
+          touch(spec.path, by, "move");
+          if (spec.moveTo) touch(spec.moveTo, by, "create");
+        } else {
+          touch(spec.path, by, spec.action ?? "modify");
+        }
+      }
+      for (const s of item.symbolSpecs ?? []) {
+        if (!s.name) continue;
+        const key = s.filePath ? `${s.filePath}#${s.name}` : s.name;
+        const entry = symbols.get(key) ?? { name: s.name, file: s.filePath ?? null, by: /* @__PURE__ */ new Map() };
+        entry.by.set(plan.uid, [...entry.by.get(plan.uid) ?? [], by]);
+        symbols.set(key, entry);
+        if (s.filePath) touch(s.filePath, by, "modify");
+      }
+      for (const c of item.newConnections ?? []) newEdges.set(`${c.from}\0${c.to}`, { from: c.from, to: c.to, taskUid: item.uid });
+      for (const c of item.removedConnections ?? []) removedEdges.set(`${c.from}\0${c.to}`, { from: c.from, to: c.to, taskUid: item.uid });
+    }
+  }
+  const projection = { ghostFiles: [], modifiedFiles: [], removedFiles: [], newEdges: [...newEdges.values()], removedEdges: [...removedEdges.values()] };
+  for (const f of files.values()) {
+    const first = f.by[0];
+    if (f.by.some((b) => b.change === "delete" || b.change === "move")) {
+      f.change = "delete";
+      projection.removedFiles.push({ path: f.path, taskUid: first.taskUid });
+    } else if (f.by.some((b) => b.change === "create") || !existingFiles.has(f.path)) {
+      f.change = "create";
+      projection.ghostFiles.push({ path: f.path, taskUid: first.taskUid, taskDescription: first.taskTitle });
+    } else {
+      projection.modifiedFiles.push({ path: f.path, taskUid: first.taskUid });
+    }
+  }
+  const overlaps = [];
+  const plansOf = (by) => {
+    const out = /* @__PURE__ */ new Map();
+    for (const b of by) {
+      const p = out.get(b.planUid) ?? { uid: b.planUid, label: b.planLabel, tasks: [] };
+      if (!p.tasks.some((t) => t.uid === b.taskUid)) p.tasks.push({ uid: b.taskUid, title: b.taskTitle, change: b.change ?? null });
+      out.set(b.planUid, p);
+    }
+    return [...out.values()];
+  };
+  const finish = (o, words2) => {
+    const seq = sequencing(o.plans, itemOf);
+    return {
+      ...o,
+      id: idOf(o.kind, o.subject, o.plans.map((p) => p.uid)),
+      decisions: [],
+      left: false,
+      sequenced: seq.sequenced,
+      words: `\u25C7 planned overlap: ${words2}${seq.words ? ` \xB7 sequenced: ${seq.words}` : ""}`
+    };
+  };
+  const both = (n2) => n2 === 2 ? "both" : "all";
+  const symbolFiles = /* @__PURE__ */ new Set();
+  for (const [key, s] of symbols) {
+    if (s.by.size < 2) continue;
+    const plansHere = plansOf([...s.by.values()].flat());
+    const where = s.file ? ` in ${s.file}` : "";
+    if (s.file) symbolFiles.add(`${s.file}\0${plansHere.map((p) => p.uid).sort().join("\0")}`);
+    overlaps.push(finish(
+      { kind: "symbol", subject: key, file: s.file, plans: plansHere, serious: true },
+      `${list(plansHere.map((p) => p.label))} ${both(plansHere.length)} plan to change ${s.name}${where}`
+    ));
+  }
+  for (const f of files.values()) {
+    const plansHere = plansOf(f.by);
+    if (plansHere.length < 2) continue;
+    if (symbolFiles.has(`${f.path}\0${plansHere.map((p) => p.uid).sort().join("\0")}`)) continue;
+    const removers = plansHere.filter((p) => p.tasks.some((t) => t.change === "delete" || t.change === "move"));
+    const others = plansHere.filter((p) => !removers.includes(p));
+    let words2;
+    let serious = false;
+    if (removers.length && others.length) {
+      serious = true;
+      const verb = removers[0].tasks.some((t) => t.change === "delete") ? "delete" : "move";
+      words2 = `${list(removers.map((p) => p.label))} ${removers.length === 1 ? "plans" : "plan"} to ${verb} ${f.path}, which ${list(others.map((p) => p.label))} ${others.length === 1 ? "plans" : "plan"} to change`;
+    } else {
+      words2 = `${list(plansHere.map((p) => p.label))} ${both(plansHere.length)} plan to ${f.change === "create" ? "create" : "change"} ${f.path}`;
+    }
+    overlaps.push(finish({ kind: "file", subject: f.path, file: f.path, plans: plansHere, serious }, words2));
+  }
+  const briefItems = plans.flatMap((p) => p.items.some((i) => i.kind === "action" && !(0, import_plan_dependencies.isSettled)(i)) ? p.items.filter((i) => i.kind === "object" || i.kind === "action" && !(0, import_plan_dependencies.isSettled)(i)).map((i) => i.uid) : []);
+  const declared = materialsOf(briefItems);
+  const material = /* @__PURE__ */ new Map();
+  const planOfItem = /* @__PURE__ */ new Map();
+  for (const p of plans) for (const i of p.items) planOfItem.set(i.uid, p);
+  const inBrief = new Set(briefItems);
+  for (const [itemUid, paths] of declared) {
+    if (!inBrief.has(itemUid)) continue;
+    const plan = planOfItem.get(itemUid);
+    const item = itemOf(itemUid);
+    if (!plan || !item) continue;
+    for (const path2 of paths) {
+      material.set(path2, [...material.get(path2) ?? [], { planUid: plan.uid, planLabel: plan.label, taskUid: item.uid, taskTitle: item.title, change: null }]);
+    }
+  }
+  for (const [path2, by] of material) {
+    const plansHere = plansOf(by);
+    if (plansHere.length < 2) continue;
+    overlaps.push(finish(
+      { kind: "material", subject: path2, file: null, plans: plansHere, serious: false },
+      `${list(plansHere.map((p) => p.label))} ${both(plansHere.length)} rely on ${path2}`
+    ));
+  }
+  overlaps.sort((a, b) => Number(b.serious) - Number(a.serious) || Number(a.sequenced) - Number(b.sequenced) || a.subject.localeCompare(b.subject));
+  const fileList = [...files.values()].sort((a, b) => a.path.localeCompare(b.path));
+  const n = (c) => fileList.filter((f) => f.change === c).length;
+  const open = overlaps.filter((o) => !o.sequenced).length;
+  const parts = [
+    n("modify") ? `${plural(n("modify"), "file")} to change` : null,
+    n("create") ? `${n("create")} to create` : null,
+    n("delete") ? `${n("delete")} to remove` : null
+  ].filter(Boolean);
+  const words = plans.length === 0 ? "No active plans: nothing is planned." : fileList.length === 0 && overlaps.length === 0 ? `Planned by ${plural(plans.length, "active plan")} \xB7 none of their tasks name a file or a material yet` : [
+    `Planned by ${plural(plans.length, "active plan")}`,
+    parts.length ? parts.join(", ") : null,
+    overlaps.length ? `${plural(overlaps.length, "planned overlap")}${open < overlaps.length ? ` (${overlaps.length - open} sequenced)` : ""}` : "no planned overlaps"
+  ].filter(Boolean).join(" \xB7 ");
+  return { project, plans: summary, files: fileList, projection, overlaps, words };
+}
+function decisionsFor(projectRoot) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of (0, import_database.getDb)().exec(
+    "SELECT overlap_id, action, words, by_name, by_type, at FROM planned_overlap_decisions WHERE project_root = ? ORDER BY at, id",
+    [projectRoot]
+  )[0]?.values ?? []) {
+    const id = String(r[0]);
+    out.set(id, [...out.get(id) ?? [], { action: r[1], words: String(r[2]), by: String(r[3]), byType: String(r[4]), at: Number(r[5]) }]);
+  }
+  return out;
+}
+function materialsFromDb(itemUids) {
+  const out = /* @__PURE__ */ new Map();
+  if (!itemUids.length) return out;
+  const res = (0, import_database.getDb)().exec(
+    `SELECT target_uid, value FROM attachments WHERE role = 'material' AND target_uid IN (${itemUids.map(() => "?").join(",")})`,
+    [...itemUids]
+  );
+  for (const [uid, value] of res[0]?.values ?? []) out.set(String(uid), [.../* @__PURE__ */ new Set([...out.get(String(uid)) ?? [], String(value)])]);
+  return out;
+}
+function existingOf(projectPath, paths) {
+  const out = /* @__PURE__ */ new Set();
+  for (const rel of paths) {
+    try {
+      if (import_node_fs.default.lstatSync((0, import_confined_fs.resolveWithin)(projectPath, import_node_path.default.join(projectPath, rel), "planned file")).isFile()) out.add(rel);
+    } catch {
+    }
+  }
+  return out;
+}
+function buildPlayForward(projectPath) {
+  const stack = (0, import_stack_service.buildStack)(projectPath);
+  const plans = stack.plans.map((p) => ({ uid: p.uid, label: p.label, items: (0, import_plan_item_service.listAllItems)(p.uid) }));
+  const planned = plans.flatMap((p) => p.items.flatMap((i) => [
+    ...(i.fileSpecs ?? []).flatMap((f) => [f.path, f.moveTo]),
+    ...(i.symbolSpecs ?? []).map((s) => s.filePath)
+  ])).filter((x) => !!x);
+  const forward = playForwardOf(projectPath, plans, existingOf(projectPath, new Set(planned)), materialsFromDb);
+  const decided = decisionsFor(projectPath);
+  for (const o of forward.overlaps) {
+    o.decisions = decided.get(o.id) ?? [];
+    o.left = o.decisions[o.decisions.length - 1]?.action === "leave";
+  }
+  return forward;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPlayForward,
+  decisionsFor,
+  playForwardOf
+});

package/src/backend/services/playback-service.js

@@ -0,0 +1,117 @@
+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 playback_service_exports = {};
+__export(playback_service_exports, {
+  buildPlaybackSequence: () => buildPlaybackSequence
+});
+module.exports = __toCommonJS(playback_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_snapshot_compare_service = require("./snapshot-compare-service");
+var import_diff_engine = require("./diff-engine");
+const MAX_FILES_PER_FRAME = 200;
+function commitTimes(projectPath, limit) {
+  const times = /* @__PURE__ */ new Map();
+  try {
+    const out = (0, import_node_child_process.execFileSync)("git", ["log", `-${limit}`, "--format=%h	%ct"], {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    for (const line of out.split("\n")) {
+      const [sha, ts] = line.split("	");
+      if (sha && ts) times.set(`commit:${sha}`, Number(ts) * 1e3);
+    }
+  } catch {
+  }
+  return times;
+}
+function buildPlaybackSequence(params) {
+  const limit = Math.min(Math.max(params.limit ?? 20, 2), 100);
+  const notes = [];
+  const comparands = (0, import_snapshot_compare_service.listComparands)(params.projectPath, limit);
+  const times = commitTimes(params.projectPath, limit);
+  const points = comparands.filter((c) => {
+    if (c.kind === "commit") return true;
+    if (c.kind === "checkpoint") return params.includeCheckpoints !== false;
+    return false;
+  }).map((c) => ({ ...c, timestamp: times.get(c.spec) ?? c.timestamp ?? null }));
+  points.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+  const commits = points.filter((p) => p.kind === "commit");
+  const keptCommits = new Set(commits.slice(-limit).map((p) => p.spec));
+  const kept = points.filter((p) => p.kind !== "commit" || keptCommits.has(p.spec));
+  if (commits.length > keptCommits.size) {
+    notes.push(
+      `Showing the ${keptCommits.size} most recent commits of ${commits.length}; raise \`limit\` for more.`
+    );
+  }
+  const ordered = [...kept, { spec: "live", label: "Live (working tree)", kind: "live", timestamp: null }];
+  const frames = [];
+  let previous = null;
+  for (const point of ordered) {
+    const resolved = (0, import_snapshot_compare_service.resolveComparand)(point.spec, params.projectPath);
+    if (!resolved) {
+      notes.push(`Skipped ${point.spec}: could not be resolved.`);
+      continue;
+    }
+    let delta = null;
+    let changedFiles = [];
+    let truncated = false;
+    if (previous) {
+      const diff = (0, import_diff_engine.diffSnapshots)(previous.snapshot, resolved.snapshot);
+      const edgesComparable = previous.edgesKnown && resolved.edgesKnown;
+      delta = {
+        added: diff.addedFiles.length,
+        removed: diff.removedFiles.length,
+        modified: diff.modifiedFiles.length,
+        // Null rather than zero: a commit whose edges could not be built
+        // (too many files differ to parse) contributes none, and
+        // reporting "0 edges changed" for a comparison that never looked
+        // at edges would read as a finding rather than an absence.
+        edgesAdded: edgesComparable ? diff.addedEdges.length : null,
+        edgesRemoved: edgesComparable ? diff.removedEdges.length : null
+      };
+      const all = [...diff.addedFiles, ...diff.modifiedFiles, ...diff.removedFiles];
+      truncated = all.length > MAX_FILES_PER_FRAME;
+      changedFiles = all.slice(0, MAX_FILES_PER_FRAME);
+    }
+    frames.push({
+      spec: point.spec,
+      label: resolved.label,
+      kind: point.kind,
+      timestamp: point.timestamp,
+      delta,
+      changedFiles,
+      truncated
+    });
+    previous = resolved;
+  }
+  if (frames.length < 2) {
+    notes.push(
+      "Not enough history to play back. A repository needs at least two points \u2014 commits or checkpoints \u2014 before there is anything to scrub through."
+    );
+  }
+  if (frames.some((f) => f.delta?.edgesAdded === null)) {
+    notes.push(
+      "Edge counts are omitted for some commit frames: too many files differ from the working tree at those commits to parse for their dependencies."
+    );
+  }
+  return { frames, notes };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPlaybackSequence
+});

package/src/backend/services/power-service.js

@@ -0,0 +1,167 @@
+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 power_service_exports = {};
+__export(power_service_exports, {
+  evaluatePower: () => evaluatePower,
+  getCurrentPowerStatus: () => getCurrentPowerStatus,
+  notifyPowerSettingsChanged: () => notifyPowerSettingsChanged,
+  onPowerStatusChange: () => onPowerStatusChange,
+  setAcState: () => setAcState,
+  setAgentActive: () => setAgentActive,
+  setMobileConnected: () => setMobileConnected,
+  startPowerService: () => startPowerService,
+  stopPowerService: () => stopPowerService
+});
+module.exports = __toCommonJS(power_service_exports);
+var import_settings_service = require("./settings-service");
+const DEBOUNCE_MS = 5e3;
+let mobileConnected = false;
+let agentActive = false;
+let acState = "unknown";
+const listeners = /* @__PURE__ */ new Set();
+let lastEmitted = null;
+let pendingEval = null;
+function detectPlatform() {
+  if (!process.versions.electron) return "web";
+  switch (process.platform) {
+    case "darwin":
+      return "darwin";
+    case "win32":
+      return "win32";
+    case "linux":
+      return "linux";
+    default:
+      return "web";
+  }
+}
+const PLATFORM = detectPlatform();
+function evaluatePower(inputs) {
+  const { settings, mobileConnected: mob, agentActive: agt, ac, platform } = inputs;
+  let reason = null;
+  if (settings.triggers.always) {
+    reason = "always";
+  } else if (settings.triggers.whileMobileConnected && mob) {
+    reason = "mobile-connected";
+  } else if (settings.triggers.whileAgentActive && agt) {
+    reason = "agent-active";
+  }
+  let shouldBlock = reason !== null;
+  if (shouldBlock && settings.onlyWhenOnAC && ac === "battery") {
+    shouldBlock = false;
+    reason = null;
+  }
+  return {
+    shouldBlock,
+    reason,
+    ac,
+    platform,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function evaluate() {
+  return evaluatePower({
+    settings: (0, import_settings_service.getSettings)().power,
+    mobileConnected,
+    agentActive,
+    ac: acState,
+    platform: PLATFORM
+  });
+}
+function statusEqual(a, b) {
+  if (!a) return false;
+  return a.shouldBlock === b.shouldBlock && a.reason === b.reason && a.ac === b.ac && a.platform === b.platform;
+}
+function emit(status) {
+  lastEmitted = status;
+  for (const cb of listeners) {
+    try {
+      cb(status);
+    } catch (err) {
+      console.warn("[Power] subscriber error:", err);
+    }
+  }
+}
+function scheduleEvaluate() {
+  if (pendingEval) clearTimeout(pendingEval);
+  pendingEval = setTimeout(() => {
+    pendingEval = null;
+    const next = evaluate();
+    if (!statusEqual(lastEmitted, next)) {
+      emit(next);
+    }
+  }, DEBOUNCE_MS);
+}
+function setMobileConnected(value) {
+  if (mobileConnected === value) return;
+  mobileConnected = value;
+  scheduleEvaluate();
+}
+function setAgentActive(value) {
+  if (agentActive === value) return;
+  agentActive = value;
+  scheduleEvaluate();
+}
+function setAcState(value) {
+  if (acState === value) return;
+  acState = value;
+  scheduleEvaluate();
+}
+function notifyPowerSettingsChanged() {
+  scheduleEvaluate();
+}
+function getCurrentPowerStatus() {
+  return lastEmitted ?? evaluate();
+}
+function onPowerStatusChange(cb) {
+  listeners.add(cb);
+  if (lastEmitted) {
+    try {
+      cb(lastEmitted);
+    } catch (err) {
+      console.warn("[Power] subscriber error:", err);
+    }
+  }
+  return () => {
+    listeners.delete(cb);
+  };
+}
+function startPowerService() {
+  if (lastEmitted) return;
+  const initial = evaluate();
+  emit(initial);
+}
+function stopPowerService() {
+  if (pendingEval) {
+    clearTimeout(pendingEval);
+    pendingEval = null;
+  }
+  listeners.clear();
+  lastEmitted = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  evaluatePower,
+  getCurrentPowerStatus,
+  notifyPowerSettingsChanged,
+  onPowerStatusChange,
+  setAcState,
+  setAgentActive,
+  setMobileConnected,
+  startPowerService,
+  stopPowerService
+});

package/src/backend/services/power-signals.js

@@ -0,0 +1,81 @@
+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 power_signals_exports = {};
+__export(power_signals_exports, {
+  startPowerSignals: () => startPowerSignals,
+  stopPowerSignals: () => stopPowerSignals
+});
+module.exports = __toCommonJS(power_signals_exports);
+var import_webrtc_service = require("./webrtc-service");
+var import_power_service = require("./power-service");
+var import_server = require("../server");
+const AGENT_ACTIVE_WINDOW_MS = 5 * 60 * 1e3;
+let teardowns = [];
+let running = false;
+function wireMobileConnected() {
+  const recompute = () => {
+    (0, import_power_service.setMobileConnected)((0, import_webrtc_service.connectedPeerCount)() > 0);
+  };
+  recompute();
+  return (0, import_webrtc_service.onConnectionStateChange)(() => recompute());
+}
+function wireAgentActive() {
+  let resetTimer = null;
+  const unsub = (0, import_server.addBroadcastTarget)(({ type, payload }) => {
+    if (type !== "agent-event") return;
+    const evt = payload;
+    if (!evt || evt.type !== "tool_call" && evt.type !== "tool_error") return;
+    (0, import_power_service.setAgentActive)(true);
+    if (resetTimer) clearTimeout(resetTimer);
+    resetTimer = setTimeout(() => {
+      (0, import_power_service.setAgentActive)(false);
+      resetTimer = null;
+    }, AGENT_ACTIVE_WINDOW_MS);
+  });
+  return () => {
+    unsub();
+    if (resetTimer) {
+      clearTimeout(resetTimer);
+      resetTimer = null;
+    }
+    (0, import_power_service.setAgentActive)(false);
+  };
+}
+function startPowerSignals() {
+  if (running) return;
+  running = true;
+  teardowns.push(wireMobileConnected());
+  teardowns.push(wireAgentActive());
+}
+function stopPowerSignals() {
+  if (!running) return;
+  running = false;
+  for (const fn of teardowns) {
+    try {
+      fn();
+    } catch (err) {
+      console.warn("[PowerSignals] teardown error:", err);
+    }
+  }
+  teardowns = [];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startPowerSignals,
+  stopPowerSignals
+});