@songsid/agend 2.2.1 → 2.3.0-beta.10

package/dist/ui/effect-trial-offer.js

@@ -0,0 +1,31 @@
+/** #1629: closed host display metadata. Neither this object nor its token grants a trial read. */
+const KEYS = ["v", "offer", "id", "title", "expiresAt"], ID = /^[0-9a-f]{32}$/;
+const FORBIDDEN = /(?!\u200d)[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+const VISIBLE = /[^\p{M}\p{C}\p{Z}\u115f\u1160\u3164\uffa0\u2800]/u;
+let graphemes = null;
+export function checkEffectTrialOffer(value) {
+  try {
+    if (!value || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return null;
+    const keys = Reflect.ownKeys(value);
+    if (keys.length !== KEYS.length || keys.some(k => typeof k !== "string" || !KEYS.includes(k))) return null;
+    const x = Object.create(null);
+    for (const key of KEYS) {
+      const d = Object.getOwnPropertyDescriptor(value, key);
+      if (!d || !("value" in d) || !d.enumerable) return null;
+      x[key] = d.value;
+    }
+    if (x.v !== 1 || typeof x.offer !== "string" || !ID.test(x.offer) || typeof x.id !== "string" || !ID.test(x.id)
+      || typeof x.title !== "string" || x.title.length > 400 || x.title.normalize("NFC") !== x.title || x.title.trim() !== x.title
+      || FORBIDDEN.test(x.title) || !VISIBLE.test(x.title) || !Number.isSafeInteger(x.expiresAt) || x.expiresAt < 0) return null;
+    graphemes ??= new Intl.Segmenter(undefined, { granularity: "grapheme" });
+    let count = 0; for (const _part of graphemes.segment(x.title)) if (++count > 40) return null;
+    if (count < 1) return null;
+    return Object.freeze({ v: 1, offer: x.offer, id: x.id, title: x.title, expiresAt: x.expiresAt });
+  } catch { return null; }
+}
+/** Role and sender are host fields, never inferred from a message's text. Start must separately authorize. */
+export function effectTrialMessage(message) {
+  if (!message || message.role !== "status" || message.sender !== "agend" || typeof message.instance !== "string"
+    || message.instance.length < 1 || message.instance.length > 128) return null;
+  return checkEffectTrialOffer(message.effectTrial);
+}

package/dist/ui/effect-trial-panel.js

@@ -0,0 +1,40 @@
+/** #1629: fixed host producer. Creates no frame or request; the admitted app controller owns its lease. */
+import { html, useLayoutEffect, useRef } from "/assets/app-html.js";
+import { register, t } from "/assets/app-i18n.js";
+import { createEffectTrialShadow } from "/assets/effect-trial-shadow.js";
+import { createEffectTrialStage } from "/assets/effect-trial-stage.js";
+register("effectTrial", {
+  en: { label: "Trial", stop: "Stop trial", close: "Close", note: "A bounded sample. Nothing is applied or saved." },
+  "zh-TW": { label: "試播", stop: "停止試播", close: "關閉", note: "僅在此區塊試播，不會套用或儲存。" },
+});
+/** The caller owns authenticated admission, lease/deadline and shared pool. No script/HTML is rendered here. */
+export function EffectTrialPanel({ window: host = globalThis.window, binding, title, current, onStage, onStop, onClose }) {
+  const panel = useRef(null), life = useRef(null), latest = useRef(null);
+  latest.current = { current, onStage, onStop, onClose };
+  const stop = close => {
+    const entry = life.current; if (!entry || (close ? entry.closed : entry.dead)) return;
+    if (close) entry.closed = true;
+    if (!entry.dead) { entry.dead = true; entry.api?.dispose(); }
+    try { (close ? entry.onClose : entry.onStop)?.("stopped"); } catch { /* lease already ended */ }
+  };
+  useLayoutEffect(() => {
+    const entry = { dead: false, closed: false, api: null, shadow: null, onStop, onClose }; life.current = entry;
+    const ended = reason => { if (entry.dead) return; entry.dead = true; try { entry.onStop?.(reason); } catch { /* never revive */ } };
+    try {
+      entry.shadow = createEffectTrialShadow({ window: host, panel: panel.current, title,
+        labels: { label: t("effectTrial.label"), close: t("effectTrial.close"), stop: t("effectTrial.stop"), note: t("effectTrial.note") },
+        onStop: () => stop(false), onClose: () => stop(true), onError: ended,
+        onReady(shell) {
+          if (entry.dead || life.current !== entry) return;
+          entry.api = createEffectTrialStage({ window: host, panel: panel.current, stage: shell.stage, binding,
+            current: own => !entry.dead && life.current === entry && latest.current.current?.(own) === true, onStop: ended });
+          if (!entry.api) ended("stage_unavailable");
+          else { try { latest.current.onStage?.(entry.api); } catch { entry.api.dispose(); ended("stage_unavailable"); } }
+        } });
+      if (!entry.shadow) ended("stage_unavailable");
+    } catch { entry.api?.dispose(); ended("stage_unavailable"); }
+    return () => { entry.api?.dispose(); ended("stopped"); entry.shadow?.dispose(); entry.dead = true; if (life.current === entry) life.current = null; };
+  }, [host, binding]);
+  useLayoutEffect(() => { life.current?.shadow?.text(title, { label: t("effectTrial.label"), close: t("effectTrial.close"), stop: t("effectTrial.stop"), note: t("effectTrial.note") }); });
+  return html`<aside ref=${panel} data-trust="preview" class="pv-panel effect-trial-panel" aria-label=${t("effectTrial.label")}></aside>`;
+}

package/dist/ui/fleet-cache.js

@@ -31,6 +31,11 @@ register("cache", {
     shared: "shares its working directory with {0}; their transcripts cannot be told apart",
     empty: "No instances", emptyHint: "Instances show here once the fleet has them.",
     b0: "≤5m", b1: "≤30m", b2: "≤1h", b3: "≤2h", b4: "≤6h", b5: "≤24h", b6: ">24h", tokensUnit: "input-token equivalents",
+    writeMix: "Cache writes 5 min / 1 h", effectiveTtl: "Behaves as", gapMiss: "{0} of {1} 5–60 min gaps rewrote it", gapMissNone: "no 5–60 min gaps yet",
+    effMeasured: "{0} (measured)", effLabel: "{0} (as written)", effUnproven: "not known yet",
+    fleetSwitch: "Switch to 1-hour cache",
+    switchTo1h: "Its 5-minute cache really expires: {0} of {1} gaps of 5–60 minutes rewrote it. Set prompt_cache_ttl: \"1h\" for this instance (backend_options.claude-code) rather than keep-warm.",
+    unproven: "Written with a 5-minute TTL, but only {0} gaps of 5–60 minutes so far — too few to tell how long it really lasts. The keep-warm figures assume 5 minutes.",
   },
   "zh-TW": {
     title: "快取", w24h: "24 小時", w7d: "7 天", w30d: "30 天", window: "期間",
@@ -53,6 +58,11 @@ register("cache", {
     shared: "與 {0} 共用工作目錄，無法分辨各自的 transcript",
     empty: "沒有 instance", emptyHint: "fleet 有 instance 後會顯示在這裡。",
     b0: "≤5分", b1: "≤30分", b2: "≤1時", b3: "≤2時", b4: "≤6時", b5: "≤24時", b6: ">24時", tokensUnit: "輸入 token 當量",
+    writeMix: "快取寫入 5 分 / 1 時", effectiveTtl: "實際存活", gapMiss: "{1} 個 5–60 分鐘空檔中有 {0} 個重寫", gapMissNone: "還沒有 5–60 分鐘的空檔",
+    effMeasured: "{0}（實測）", effLabel: "{0}（依寫入標記）", effUnproven: "尚無法判斷",
+    fleetSwitch: "建議改用 1 小時快取",
+    switchTo1h: "它的 5 分鐘快取確實會過期：{1} 個 5–60 分鐘空檔中有 {0} 個重寫。請為這個 instance 設定 prompt_cache_ttl: \"1h\"（backend_options.claude-code），而不是保溫。",
+    unproven: "以 5 分鐘 TTL 寫入，但目前只有 {0} 個 5–60 分鐘空檔，太少，無法判斷實際存活多久。保溫的數字以 5 分鐘估算。",
   },
 });
 const tc = (k, ...v) => t(`cache.${k}`, ...v);
@@ -79,6 +89,8 @@ const pct = (x) => `${x >= 0.1 ? Math.round(x * 100) : (x * 100).toFixed(1)}%`;
 export function reasonText(a) {
   const r = a.recommendation, ttl = ttlText(a.ttlSec);
   if (r.reason === "quiet") return tc("quiet");
+  if (r.reason === "switch_to_1h") return tc("switchTo1h", a.effectiveTtl.misses, a.effectiveTtl.sample);
+  if (r.reason === "insufficient_evidence") return tc("unproven", a.effectiveTtl.sample);
   if (r.reason === "never_expired") {
     if (a.sim.pastTtl) return tc("survived", a.sim.pastTtl, ttl);
     return a.sim.tailPings ? tc("onlyIdle", a.sim.tailPings.toLocaleString("en-US")) : tc("neverExpired", ttl);
@@ -107,6 +119,12 @@ function Histogram({ buckets, ttlSec }) {
   </svg>`;
 }
 
+/** #2010: what the TTL behaves as — measured, as written, or not known yet. */
+export function effectiveText(e) {
+  if (e.ttlSec === null) return tc("effUnproven");
+  return e.basis === "measured" ? tc("effMeasured", ttlText(e.ttlSec)) : tc("effLabel", ttlText(e.ttlSec));
+}
+
 function Metric({ label, value, sub }) {
   return html`<div class="ch-metric"><dt>${label}</dt><dd>${value}${sub ? html`<span class="ch-sub">${sub}</span>` : null}</dd></div>`;
 }
@@ -130,8 +148,11 @@ function InstanceCard({ r }) {
       <${Metric} label=${tc("pings")} value=${(s.pings + s.tailPings).toLocaleString("en-US")} sub=${s.tailPings ? tc("pingsAfter", s.tailPings) : null} />
       <${Metric} label=${tc("pingCost")} value=${$(s.pingCost + s.tailCost)} />
       <${Metric} label=${tc("net")} value=${a.priced ? `${s.net >= 0 ? "+" : "−"}${money(Math.abs(s.net))}` : "—"} />
+      ${a.writeMix["5m"] + a.writeMix["1h"] > 0 ? html`<${Metric} label=${tc("writeMix")} value=${`${tokens(a.writeMix["5m"])} / ${tokens(a.writeMix["1h"])}`} />` : null}
+      ${r.backend === "claude-code" ? html`<${Metric} label=${tc("effectiveTtl")} value=${effectiveText(a.effectiveTtl)}
+        sub=${a.effectiveTtl.sample ? tc("gapMiss", a.effectiveTtl.misses, a.effectiveTtl.sample) : tc("gapMissNone")} />` : null}
     </dl>
-    <${Histogram} buckets=${a.gapBuckets} ttlSec=${a.ttlSec} />
+    <${Histogram} buckets=${a.gapBuckets} ttlSec=${a.effectiveTtl.basis === "measured" && a.effectiveTtl.ttlSec !== null ? a.effectiveTtl.ttlSec : a.ttlSec} />
   </article>`;
 }
 
@@ -154,6 +175,7 @@ export function CacheReport({ report, win, setWin, refresh }) {
       <${Metric} label=${tc("fleetExpiry")} value=${money(f.expiryCost)} />
       <${Metric} label=${tc("fleetSaving")} value=${money(f.saving)} />
       <${Metric} label=${tc("fleetRecommended")} value=${tc("ofN", f.recommended, f.analysed)} />
+      ${f.switchTo1h ? html`<${Metric} label=${tc("fleetSwitch")} value=${tc("ofN", f.switchTo1h, f.analysed)} />` : null}
     </section>` : html`<${Empty} icon="chart" title=${tc("empty")} hint=${tc("emptyHint")} />`}
     <div class="ch-notes note">
       <p>${tc("pricesNote", report.pricesChecked)} ${tc("quotaNote")}</p>

package/dist/ui/fleet-canvas-layout.js

@@ -0,0 +1,111 @@
+// #1918: the org canvas's layout (fleet-canvas.js draws it; fleet-traffic.js routes lines through its empty lanes).
+// Fixed slots, no layout engine: the same structure always gives the same picture.
+
+/** Sizes in canvas units. NW×NH a member card, LW×LH a General card; FOLDED a folded (or empty) team's height. */
+export const OC = { NW: 184, NH: 56, GAP: 18, PAD: 24, HEAD: 34, TEAM_GAP: 56, ROW_GAP: 96, ROW_MAX: 1400, ROW_MAX_NARROW: 460, LW: 232, LH: 68, TOP_Y: 20, BUS: 44, FOLDED: 64, TRUNK: -30 };
+const colsFor = (n, narrow) => (n <= 1 ? 1 : n <= 4 || narrow ? 2 : 3);
+/** The key a team folds by (per device): its name; the instances in no team have one of their own no team name can be. */
+export const REST_KEY = "\u0000rest";
+
+/**
+ * Where everything goes, from buildOrgView's answer and the folded teams' keys: `tops` (General's cards), `boxes`
+ * (each team: its slot, its header, its member cells unless folded), the tree lines (`tree`: SVG path data) and the
+ * size of the whole. `narrow`: a phone's packing.
+ */
+export function canvasLayout(view, folded = new Set(), { narrow = false, label = (s, n) => `${n} ${s}` } = {}) {
+  const { NW, NH, GAP, PAD, HEAD } = OC;
+  const groups = [...view.teams.map((tm) => ({ key: tm.name, name: tm.name, loose: false, nodes: tm.nodes, counts: tm.counts })),
+    ...(view.rest.nodes.length ? [{ key: REST_KEY, name: null, loose: true, nodes: view.rest.nodes, counts: view.rest.counts }] : [])];
+  const rows = [];
+  let row = [], x = 0;
+  for (const g of groups) {
+    const n = g.nodes.length, cols = colsFor(n, narrow), lines = Math.ceil(n / cols);
+    const w = PAD * 2 + cols * NW + (cols - 1) * GAP;
+    const fullH = n ? HEAD + PAD + lines * NH + (lines - 1) * GAP + PAD : OC.FOLDED;
+    if (row.length && x + w > (narrow ? OC.ROW_MAX_NARROW : OC.ROW_MAX)) { rows.push(row); row = []; x = 0; }
+    row.push({ ...g, cols, w, fullH, x });
+    x += w + OC.TEAM_GAP;
+  }
+  if (row.length) rows.push(row);
+  const boxes = [];
+  let y = view.top.length ? OC.TOP_Y + OC.LH + 100 : OC.BUS + 16;
+  for (const r of rows) {
+    const slotH = Math.max(...r.map((b) => b.fullH));
+    for (const b of r) {
+      const isFolded = b.nodes.length > 0 && folded.has(b.key);
+      // Folded: its members' states in rows that fit the box (never wider; never taller than its open slot).
+      const summary = isFolded ? summaryRows(b.counts, b.w, label) : [];
+      const box = { key: b.key, name: b.name, loose: b.loose, nodes: b.nodes, counts: b.counts, cols: b.cols, x: b.x, y, w: b.w,
+        h: isFolded ? Math.min(b.fullH, Math.max(OC.FOLDED, HEAD + 10 + summary.length * SUM_LINE)) : b.fullH, slotH, folded: isFolded, summary,
+        busY: y - OC.BUS, cells: [] };
+      if (!isFolded) b.nodes.forEach((node, i) => box.cells.push({ node, key: `${b.key}/${node.name}`,
+        x: b.x + PAD + (i % b.cols) * (NW + GAP), y: y + HEAD + PAD + Math.floor(i / b.cols) * (NH + GAP), w: NW, h: NH }));
+      boxes.push(box);
+    }
+    y += slotH + OC.ROW_GAP;
+  }
+  const rowsW = boxes.length ? Math.max(...boxes.map((b) => b.x + b.w)) : 0;
+  const topW = view.top.length * OC.LW + Math.max(0, view.top.length - 1) * GAP;
+  const width = Math.max(rowsW, topW);
+  const tops = view.top.map((node, i) => ({ node, key: `\u0000top/${node.name}`, x: width / 2 - topW / 2 + i * (OC.LW + GAP), y: OC.TOP_Y, w: OC.LW, h: OC.LH }));
+  const height = boxes.length ? y - OC.ROW_GAP : tops.length ? OC.TOP_Y + OC.LH : 0;
+  return { tops, boxes, width, height, tree: treeLines(tops, boxes) };
+}
+
+/** A folded team's summary line height, and a label's width estimate (canvas units: wide for CJK, narrow otherwise). */
+export const SUM_LINE = 20;
+const textWidth = (s) => [...s].reduce((w, ch) => w + (ch.codePointAt(0) >= 0x2e80 ? 12 : 6.6), 0);
+/**
+ * A folded team's states as rows of { s, n, label, dx } that fit a box `w` wide (dx from the box's left), most pressing
+ * first; an item never splits, and one wider than a row has the row to itself.
+ */
+export function summaryRows(counts, w, label) {
+  const rows = [];
+  let row = [], x = 14;
+  for (const [s, n] of counts) {
+    const text = label(s, n), iw = 24 + textWidth(text);
+    if (row.length && x + iw > w - 14) { rows.push(row); row = []; x = 14; }
+    row.push({ s, n, label: text, dx: x });
+    x += iw;
+  }
+  if (row.length) rows.push(row);
+  return rows;
+}
+
+/** General's stem, a bus over each row of teams, the trunk joining the rows at the left, one drop per team. */
+function treeLines(tops, boxes) {
+  const d = [];
+  const teamed = boxes.filter((b) => !b.loose);
+  if (!teamed.length) return d;
+  const buses = [...new Set(teamed.map((b) => b.busY))].sort((a, b) => a - b);
+  const first = buses[0], last = buses[buses.length - 1];
+  let stemX = null;
+  if (tops.length) {
+    const cx = tops.map((tp) => tp.x + tp.w / 2), bottom = tops[0].y + tops[0].h;
+    stemX = (Math.min(...cx) + Math.max(...cx)) / 2;
+    if (tops.length > 1) {
+      const joinY = bottom + 16;
+      for (const x of cx) d.push(`M${x} ${bottom} V${joinY}`);
+      d.push(`M${Math.min(...cx)} ${joinY} H${Math.max(...cx)}`, `M${stemX} ${joinY} V${first}`);
+    } else d.push(`M${stemX} ${bottom} V${first}`);
+  }
+  if (last > first) d.push(`M${OC.TRUNK} ${first} V${last}`);
+  for (const busY of buses) {
+    const xs = teamed.filter((b) => b.busY === busY).map((b) => b.x + b.w / 2);
+    const ends = busY === first ? [...xs, ...(stemX === null ? [] : [stemX]), ...(last > first ? [OC.TRUNK] : [])] : [...xs, OC.TRUNK];
+    d.push(`M${Math.min(...ends)} ${busY} H${Math.max(...ends)}`);
+  }
+  for (const b of teamed) d.push(`M${b.x + b.w / 2} ${b.busY} V${b.y}`);
+  return d;
+}
+
+/** The region the canvas opens on: General and the first row of teams (the whole canvas when there is neither). */
+export function openingRegion(L) {
+  const firstBus = L.boxes.length ? Math.min(...L.boxes.map((b) => b.busY)) : null;
+  // The trunk at the left joins the rows: in view too, not cut by the edge.
+  const trunk = L.boxes.some((b) => b.busY !== firstBus) ? [{ x: OC.TRUNK - 8, y: firstBus, w: 1, h: 1 }] : [];
+  const parts = [...L.tops, ...L.boxes.filter((b) => b.busY === firstBus).map((b) => ({ x: b.x, y: b.y, w: b.w, h: b.slotH })), ...trunk];
+  if (!parts.length) return { x: 0, y: 0, w: Math.max(1, L.width), h: Math.max(1, L.height) };
+  const x0 = Math.min(...parts.map((p) => p.x)), y0 = Math.min(...parts.map((p) => p.y));
+  return { x: x0, y: y0, w: Math.max(...parts.map((p) => p.x + p.w)) - x0, h: Math.max(...parts.map((p) => p.y + p.h)) - y0 };
+}