@felixdotgo/aidlc-kit 0.1.1 → 0.3.0

package/dist/assets/ui/dashboard.js

@@ -0,0 +1,77 @@
+/*
+ * Loop dashboard page: kanban/list view toggle, client-side filters, and the
+ * collapsible done column. Loaded after common.js (uses its `live` hooks).
+ */
+/* ---- Dashboard view state (re-applied after every live update) ---- */
+const viewKey = "aidlc-view";
+const applyView = (view) => {
+  document.documentElement.setAttribute("data-view", view === "list" ? "list" : "kanban");
+  document.querySelectorAll("[data-view-toggle]").forEach((el) => {
+    const active = el.getAttribute("data-view-toggle") === view;
+    el.classList.toggle("is-active", active);
+    el.setAttribute("aria-pressed", String(active));
+  });
+};
+const currentView = () => (localStorage.getItem(viewKey) === "list" ? "list" : "kanban");
+const expandedColumns = new Set();
+// Client-side filtering over server-rendered cards and rows (no extra API calls).
+// Columns with data-collapse show that many cards unless expanded or filtering.
+const applyFilter = () => {
+  const search = document.getElementById("task-search");
+  const statusFilter = document.getElementById("filter-status");
+  const riskFilter = document.getElementById("filter-risk");
+  const resultCount = document.getElementById("result-count");
+  const terms = (search ? search.value : "").toLowerCase().split(/\s+/).filter(Boolean);
+  const status = statusFilter ? statusFilter.value : "";
+  const risk = riskFilter ? riskFilter.value : "";
+  const filtered = !!(terms.length || status || risk);
+  const matches = (el) => (!status || el.getAttribute("data-status") === status) && (!risk || el.getAttribute("data-risk") === risk) && terms.every((term) => (el.getAttribute("data-search") || "").includes(term));
+  let visible = 0;
+  document.querySelectorAll("#kanban-view [data-task-item]").forEach((el) => { const show = matches(el); el.hidden = !show; if (show) visible += 1; });
+  document.querySelectorAll("#list-view [data-task-item]").forEach((el) => { el.hidden = !matches(el); });
+  document.querySelectorAll("[data-phase-column]").forEach((column) => {
+    const shown = [...column.querySelectorAll("[data-task-item]")].filter((el) => !el.hidden);
+    const limit = Number(column.getAttribute("data-collapse") || 0);
+    const expanded = expandedColumns.has(column.getAttribute("data-phase-column"));
+    const extra = limit && !filtered ? Math.max(0, shown.length - limit) : 0;
+    if (extra && !expanded) shown.slice(limit).forEach((el) => { el.hidden = true; });
+    const more = column.querySelector("[data-column-more]");
+    if (more) { more.hidden = extra === 0; more.textContent = expanded ? "Show less" : "Show " + extra + " more"; more.setAttribute("aria-expanded", String(expanded)); }
+    const badge = column.querySelector("[data-column-count]");
+    if (badge) badge.textContent = String(shown.length);
+    const empty = column.querySelector("[data-column-empty]");
+    if (empty) empty.hidden = shown.length > 0;
+  });
+  const total = document.querySelectorAll("#kanban-view [data-task-item]").length;
+  if (resultCount) resultCount.textContent = filtered ? visible + " of " + total + " tasks" : total + (total === 1 ? " task" : " tasks");
+  document.querySelectorAll("[data-no-match]").forEach((el) => el.classList.toggle("is-visible", filtered && visible === 0));
+};
+const clearFilters = () => {
+  ["task-search", "filter-status", "filter-risk"].forEach((id) => { const el = document.getElementById(id); if (el) el.value = ""; });
+  applyFilter();
+};
+live.hooks.push(() => { applyView(currentView()); applyFilter(); });
+
+document.addEventListener("click", (event) => {
+  const target = event.target instanceof Element ? event.target : null;
+  if (!target) return;
+  const viewToggle = target.closest("[data-view-toggle]");
+  if (viewToggle) { const view = viewToggle.getAttribute("data-view-toggle"); localStorage.setItem(viewKey, view); applyView(view); return; }
+  const columnMore = target.closest("[data-column-more]");
+  if (columnMore) {
+    const column = columnMore.closest("[data-phase-column]");
+    const name = column ? column.getAttribute("data-phase-column") : "";
+    if (expandedColumns.has(name)) expandedColumns.delete(name); else expandedColumns.add(name);
+    applyFilter();
+    return;
+  }
+  if (target.closest("#filter-clear")) { clearFilters(); return; }
+});
+document.addEventListener("input", (event) => {
+  const target = event.target instanceof Element ? event.target : null;
+  if (target && target.matches("#task-search, #filter-status, #filter-risk")) applyFilter();
+});
+document.addEventListener("DOMContentLoaded", () => {
+  applyView(currentView());
+  applyFilter();
+});

package/dist/assets/ui/detail.js

@@ -0,0 +1,159 @@
+/*
+ * Task detail page: gate feedback and approval. Handlers are delegated (the
+ * controls are re-rendered by live updates) and read the task and gate from the
+ * current DOM, never from values baked in at page load. Loaded after common.js.
+ */
+const detailTask = () => document.body.getAttribute("data-task") || "";
+// Feedback: keeps the task at this gate; the lead revises and re-presents it.
+const onFeedbackSend = (button) => {
+  const panel = document.getElementById("feedback-panel");
+  const field = document.getElementById("feedback");
+  const result = document.getElementById("feedback-result");
+  if (!panel || !field) return;
+  if (result) result.textContent = "";
+  if (!field.value.trim()) { toast("Write the feedback first", "warning", "It is sent to the loop lead as guidance; the task stays at this gate."); field.focus(); return; }
+  const label = panel.getAttribute("data-gate-label") || "";
+  withLoading(button, async () => {
+    const res = await post("/api/gate/feedback", { taskId: detailTask(), feedback: field.value });
+    if (res.status >= 200 && res.status < 300) {
+      field.value = "";
+      toast("Feedback sent — task stays at " + label, "success", "The lead will revise the review artifact and re-present this gate.");
+      await liveRefresh();
+    } else failureToast(res, "Feedback failed");
+  });
+};
+// Approve: the button only opens the confirmation dialog; "Confirm approve" sends.
+const onApproveOpen = () => {
+  const note = document.getElementById("source");
+  const result = document.getElementById("approve-result");
+  if (!note) return;
+  if (result) result.textContent = "";
+  if (!note.value.trim()) { toast("Add an approval note first", "warning", "It is recorded as the approval source. To request changes, use Feedback instead."); note.focus(); return; }
+  const quote = document.getElementById("approve-modal-note");
+  if (quote) quote.textContent = note.value.trim();
+  openModal("approve-modal");
+};
+const onApproveConfirm = (button) => {
+  const panel = document.getElementById("approve-panel");
+  const note = document.getElementById("source");
+  if (!panel || !note) return;
+  const gate = panel.getAttribute("data-gate") || "";
+  const label = panel.getAttribute("data-gate-label") || gate;
+  withLoading(button, async () => {
+    // The gate shown is sent along; the server refuses if the task has moved on since.
+    const res = await post("/api/gate/approve", { taskId: detailTask(), gate, source: note.value });
+    closeAllModals();
+    if (res.status >= 200 && res.status < 300) {
+      const next = res.body && res.body.result && res.body.result.nextAction;
+      note.value = "";
+      toast("Approved " + label, "success", next && next.classification ? "Next: " + next.classification + (next.phase ? " · " + next.phase : "") : "");
+      await liveRefresh();
+    } else failureToast(res, "Approval failed");
+  });
+};
+/* ---- Container log viewer (Containers panel) -------------------------------
+ * The viewer (#container-log, [data-live-ignore]) is client-owned: a Log button
+ * fetches the raw tail of that assignment's log and, while Follow is on and the row
+ * still reports the container as running, re-fetches at the Settings live interval
+ * (fallback 1.5 s; never while polling is paused). The running state is read from
+ * the row's button on every tick, which live updates keep current. */
+const containerLog = { assignment: "", timer: 0, inflight: null, follow: true };
+const containerViewer = () => document.getElementById("container-log");
+const containerSettings = () => (window.aidlcSettings && window.aidlcSettings.get()) || {};
+const containerInterval = () => { const value = Number(containerSettings().livePoll); return Number.isFinite(value) ? value : 1500; };
+const containerButton = () => {
+  if (!containerLog.assignment) return null;
+  for (const button of document.querySelectorAll("[data-container-log]")) if (button.getAttribute("data-container-log") === containerLog.assignment) return button;
+  return null;
+};
+const containerRunning = () => { const button = containerButton(); return !!button && button.getAttribute("data-container-running") === "1"; };
+const fetchContainerLog = async () => {
+  const el = containerViewer();
+  if (!el || !containerLog.assignment) return;
+  if (containerLog.inflight) return containerLog.inflight;
+  const assignment = containerLog.assignment;
+  containerLog.inflight = (async () => {
+    const body = el.querySelector("[data-container-log-body]");
+    const state = el.querySelector("[data-container-log-state]");
+    try {
+      const kb = Number(containerSettings().logTailKb) || 64;
+      const url = "/api/tasks/" + encodeURIComponent(detailTask()) + "/containers/" + encodeURIComponent(assignment) + "/log?tail=" + (kb * 1024);
+      const response = await fetch(url, { cache: "no-store" });
+      const text = await response.text();
+      if (assignment !== containerLog.assignment) return;
+      if (!response.ok) { if (body) body.textContent = text || ("HTTP " + response.status); if (state) state.textContent = "unavailable"; return; }
+      const atBottom = body ? body.scrollHeight - body.scrollTop - body.clientHeight < 8 : false;
+      if (body) body.textContent = text || "(no output yet)";
+      const size = Number(response.headers.get("x-aidlc-log-size")) || 0;
+      if (state) state.textContent = (size >= 1024 ? Math.round(size / 1024) + " KiB" : size + " B") + (response.headers.get("x-aidlc-log-truncated") === "1" ? " · tail" : "") + (containerRunning() ? " · running" : " · ended");
+      if (body && (containerLog.follow || atBottom)) body.scrollTop = body.scrollHeight;
+    } catch (error) {
+      if (state) state.textContent = "unreachable";
+    } finally { containerLog.inflight = null; }
+  })();
+  return containerLog.inflight;
+};
+const scheduleContainerLog = () => {
+  clearTimeout(containerLog.timer);
+  containerLog.timer = 0;
+  const el = containerViewer();
+  if (!el || el.hidden || !containerLog.assignment || !containerLog.follow) return;
+  const interval = containerInterval();
+  if (!interval) return; // live updates paused in Settings
+  if (!containerRunning()) return; // the container ended: the last fetch was final
+  containerLog.timer = setTimeout(async () => { await fetchContainerLog(); scheduleContainerLog(); }, interval);
+};
+const openContainerLog = (button) => {
+  const el = containerViewer();
+  if (!el) return;
+  containerLog.assignment = button.getAttribute("data-container-log") || "";
+  containerLog.follow = true;
+  const name = el.querySelector("[data-container-log-name]");
+  if (name) name.textContent = (button.getAttribute("data-container-name") || containerLog.assignment) + " · " + containerLog.assignment;
+  const follow = el.querySelector("[data-container-follow]");
+  if (follow) follow.setAttribute("aria-pressed", "true");
+  const body = el.querySelector("[data-container-log-body]");
+  if (body) body.textContent = "loading…";
+  el.hidden = false;
+  el.scrollIntoView({ block: "nearest" });
+  fetchContainerLog().then(scheduleContainerLog);
+};
+const closeContainerLog = () => {
+  const el = containerViewer();
+  clearTimeout(containerLog.timer);
+  containerLog.timer = 0;
+  containerLog.assignment = "";
+  if (el) el.hidden = true;
+};
+const toggleContainerFollow = (button) => {
+  containerLog.follow = button.getAttribute("aria-pressed") !== "true";
+  button.setAttribute("aria-pressed", containerLog.follow ? "true" : "false");
+  if (containerLog.follow) fetchContainerLog().then(scheduleContainerLog); else scheduleContainerLog();
+};
+if (window.aidlcSettings) window.aidlcSettings.onChange((settings, changed) => { if (changed.includes("livePoll")) scheduleContainerLog(); });
+// A live update that re-renders the row (container ended) stops the follow loop on the next tick.
+document.addEventListener("keydown", (event) => {
+  if (event.key !== "Escape") return;
+  const el = containerViewer();
+  if (!el || el.hidden) return;
+  // common.js answers Escape for the notifications dropdown, modals, and the side panel first.
+  if (typeof notifyOpen === "function" && notifyOpen()) return;
+  if (typeof modalOpen === "function" && modalOpen()) return;
+  if (typeof drawerOpen === "function" && drawerOpen()) return;
+  closeContainerLog();
+});
+
+document.addEventListener("click", (event) => {
+  const target = event.target instanceof Element ? event.target : null;
+  if (!target) return;
+  const feedback = target.closest("#feedback-button");
+  if (feedback) { onFeedbackSend(feedback); return; }
+  if (target.closest("#approve-button")) { onApproveOpen(); return; }
+  const confirm = target.closest("#approve-confirm");
+  if (confirm) { onApproveConfirm(confirm); return; }
+  const log = target.closest("[data-container-log]");
+  if (log && !log.disabled) { openContainerLog(log); return; }
+  const follow = target.closest("[data-container-follow]");
+  if (follow) { toggleContainerFollow(follow); return; }
+  if (target.closest("[data-container-close]")) closeContainerLog();
+});

package/dist/assets/ui/live-log.js

@@ -0,0 +1,332 @@
+/*
+ * Live log: streams /api/events?task-id=<task> (SSE) into every [data-live-log]
+ * element. The task page shows the full log (data-log-mode="full": lines grouped
+ * under turn headers, an Important/All filter, a Raw JSON switch); the task side
+ * panel shows a compact one (data-log-mode="compact": the last data-log-limit
+ * lines, Important only). Log elements are client-owned ([data-live-ignore]):
+ * live morphs never touch them. A MutationObserver starts logs that appear later
+ * (the side panel is injected and re-rendered), stops the stream of a log that is
+ * removed or hidden (closed side panel), and restarts it when shown again.
+ * Event data only ever reaches the DOM through textContent.
+ * Loaded after common.js (uses its `liveRefresh` when present).
+ */
+(() => {
+  /* ---- Formatting: event → human sentence (pure; exposed for tests) ---- */
+  const DEFAULT_GATES = { G0_confirm: "Confirm requirements", G1_review: "Approve plan", G2_codereview: "Review implementation" };
+  const str = (value) => typeof value === "string" ? value : "";
+  const two = (n) => String(n).padStart(2, "0");
+  const clock = (iso) => { const d = new Date(iso); return isNaN(d) ? "--:--:--" : two(d.getHours()) + ":" + two(d.getMinutes()) + ":" + two(d.getSeconds()); };
+  const firstLine = (text) => (text.split("\n").find((line) => line.trim()) || "").trim();
+  const shortSha = (sha) => str(sha).slice(0, 7);
+  const duration = (ms) => { const s = Math.max(0, Math.round(Number(ms || 0) / 1000)); return s < 60 ? s + "s" : Math.floor(s / 60) + "m" + (s % 60 ? " " + (s % 60) + "s" : ""); };
+  const code = (value) => ({ code: value });
+  // Driver events without an actor (older logs) come from the lead's turn.
+  const LEAD_TYPES = /^(agent_|turn_|lifecycle_command$)/;
+  const actorOf = (e) => str(e.actor) || (LEAD_TYPES.test(e.type) ? "lead" : "loop");
+  // Hidden in Important mode: bookkeeping that does not tell the reader what happened.
+  const NOISE = new Set(["turn_completed", "daemon_poll", "agent_event", "resume", "context_changed", "jobs_active", "daemon_start", "resync"]);
+  // Outcome and loop events stand on their own instead of nesting under a turn.
+  const SYSTEM = new Set(["gate", "waiting", "daemon_turn", "daemon_turn_error", "loop_stopped", "job_integrated", "job_scheduled", "build_deferred", "diagnostic", "daemon_start", "daemon_poll", "daemon_poll_error", "worker_image_build", "resume", "context_changed", "jobs_active", "release_failed", "resync"]);
+  const TOOL_VERBS = [
+    [/^(bash|shell|command|command_execution|exec|run|local_shell)/i, "ran"],
+    [/^(edit|multiedit|write|apply_patch|patch|notebookedit|file_change|str_replace)/i, "edited"],
+    [/^(read|view|cat)/i, "read"],
+    [/^(grep|glob|search|find|ls|list|websearch|webfetch|fetch)/i, "searched"],
+  ];
+  const toolSentence = (e) => {
+    const tool = str(e.tool) || "tool";
+    const summary = str(e.summary);
+    if (!summary) return ["used tool ", code(tool)];
+    const verb = (TOOL_VERBS.find(([pattern]) => pattern.test(tool)) || [])[1];
+    return verb ? [verb + " ", code(summary)] : ["used " + tool + " ", code(summary)];
+  };
+  const toneOfStatus = (status) => /fail|error/.test(status) ? "error" : /pause|block|stop|stall|gate|handoff/.test(status) ? "warn" : /done|complete|success/.test(status) ? "ok" : "muted";
+
+  /**
+   * Describes one event: `parts` is the sentence (strings, `{code}` spans, `{link, href}`),
+   * `tone` one of error|warn|ok|muted|"", `full` the untruncated text when `parts` shows
+   * only its first line, `turn` the header label of a turn start, `noise` hides it in
+   * Important mode, `system` keeps it out of turn groups.
+   */
+  const describe = (e, ctx = {}) => {
+    const gates = ctx.gates || DEFAULT_GATES;
+    const gateName = (gate) => gates[gate] || str(gate) || "a gate";
+    const taskId = str(e.taskId) || str(ctx.taskId);
+    const actor = actorOf(e);
+    const info = { actor, parts: [], tone: "", noise: NOISE.has(e.type), system: SYSTEM.has(e.type) };
+    const turnLabel = (agent) => ["Turn " + (Number(e.iteration || 0) + 1), str(e.phase), actor + (agent ? "/" + agent : ""), e.itemId ? "item " + e.itemId : ""].filter(Boolean).join(" · ");
+    switch (e.type) {
+      case "turn_start":
+        info.turn = turnLabel(str(e.agent));
+        info.parts = ["started turn " + (Number(e.iteration || 0) + 1) + (e.phase ? " · " + e.phase : "") + (e.agent ? " · " + e.agent : "")];
+        break;
+      case "worker_turn_start":
+        info.turn = turnLabel(str(e.agent));
+        info.parts = [e.summary ? "worker " + e.summary : "worker started turn " + (Number(e.iteration || 0) + 1)];
+        break;
+      case "turn_end": info.parts = ["turn " + (Number(e.iteration || 0) + 1) + " finished"]; info.tone = "ok"; break;
+      case "turn_completed": info.parts = ["agent finished its reply"]; info.tone = "muted"; break;
+      case "agent_text": {
+        const text = str(e.text).trim();
+        info.parts = [firstLine(text)];
+        if (text !== firstLine(text)) info.full = text;
+        break;
+      }
+      case "agent_tool": info.parts = toolSentence(e); break;
+      case "lifecycle_command": {
+        const exit = e.exitCode;
+        const failed = (Number.isInteger(exit) && exit !== 0) || e.status === "failed";
+        const outcome = Number.isInteger(exit) ? " → exit " + exit : e.status === "in_progress" ? " → running" : " → " + (str(e.status) || "unknown");
+        info.parts = e.summary ? ["command ", code(str(e.summary)), outcome] : ["command" + outcome];
+        info.tone = failed ? "error" : Number.isInteger(exit) ? "ok" : "";
+        break;
+      }
+      case "gate":
+      case "waiting":
+        info.parts = ["waiting for your review at " + gateName(e.gate) + " · ", { link: "open review", href: "/tasks/" + encodeURIComponent(taskId) + "#approve-panel" }];
+        info.tone = "warn";
+        break;
+      case "daemon_turn": {
+        const status = str(e.status) || "unknown";
+        info.parts = status === "gate" && e.gate ? ["loop paused at " + gateName(e.gate)] : ["loop run ended: " + status + (e.reason ? " · " + e.reason : "")];
+        info.tone = toneOfStatus(status);
+        break;
+      }
+      case "daemon_turn_error":
+        info.parts = ["loop turn failed: " + (str(e.message) || "error") + " — retry" + (e.failures ? " #" + e.failures : "") + " in " + duration(e.retryInMs)];
+        info.tone = "error";
+        break;
+      case "daemon_poll_error": info.parts = ["daemon poll failed: " + (str(e.message) || "error")]; info.tone = "error"; break;
+      case "loop_stopped": info.parts = ["loop stopped" + (e.reason ? ": " + e.reason : "")]; info.tone = "warn"; break;
+      case "build_deferred": info.parts = ["deferred item ", code(str(e.itemId) || "?"), e.reason ? ": " + e.reason : ""]; info.tone = "warn"; break;
+      case "worker_image_build": info.parts = ["building worker image ", code(str(e.image) || "?"), e.provider ? " (" + e.provider + ")" : ""]; info.tone = "muted"; break;
+      case "worker_reported": {
+        const count = Array.isArray(e.changedPaths) ? e.changedPaths.length : 0;
+        info.parts = ["worker reported " + count + " file" + (count === 1 ? "" : "s") + (e.commit ? " (" + shortSha(e.commit) + ")" : "")];
+        if (count) info.title = e.changedPaths.filter((path) => typeof path === "string").join("\n");
+        info.tone = "ok";
+        break;
+      }
+      case "job_integrated": {
+        const sha = shortSha(e.commit || e.commitSha);
+        info.parts = ["integrated item ", code(str(e.itemId) || "?"), sha ? " (" + sha + ")" : ""];
+        info.tone = "ok";
+        break;
+      }
+      case "job_scheduled": info.parts = ["scheduled item ", code(str(e.itemId) || "?")]; info.tone = "muted"; break;
+      case "diagnostic": info.parts = [str(e.message) || str(e.summary) || "diagnostic"]; info.tone = "warn"; break;
+      case "daemon_start": info.parts = ["daemon started" + (e.pid ? " (pid " + e.pid + ")" : "")]; info.tone = "muted"; break;
+      case "daemon_poll": info.parts = ["daemon poll · " + (Array.isArray(e.actionable) ? e.actionable.length : 0) + " actionable"]; info.tone = "muted"; break;
+      case "resume": info.parts = ["resumed the loop"]; info.tone = "muted"; break;
+      case "context_changed": info.parts = [str(e.message) || "task context changed"]; info.tone = "muted"; break;
+      case "agent_event": info.parts = ["provider event"]; info.tone = "muted"; break;
+      default:
+        info.parts = [str(e.message) || str(e.summary) || String(e.type)];
+        info.tone = /error|fail/.test(e.type) ? "error" : "";
+    }
+    return info;
+  };
+  window.aidlcLiveLog = { describe, clock };
+
+  /* ---- Rendering ---- */
+  // Page-level filter/raw choice; until the user picks one here, the Settings defaults
+  // (`logFilter`, `logRaw` in window.aidlcSettings) apply.
+  const PREFS_KEY = "aidlc-live-log";
+  const settingsDefaults = () => {
+    const settings = window.aidlcSettings && typeof window.aidlcSettings.get === "function" ? window.aidlcSettings.get() : {};
+    return { filter: settings.logFilter === "all" ? "all" : "important", raw: settings.logRaw === true };
+  };
+  const readPrefs = () => {
+    const fallback = settingsDefaults();
+    try {
+      const saved = JSON.parse(localStorage.getItem(PREFS_KEY) || "{}");
+      return {
+        filter: saved.filter === "all" || saved.filter === "important" ? saved.filter : fallback.filter,
+        raw: typeof saved.raw === "boolean" ? saved.raw : fallback.raw,
+      };
+    } catch (error) { return fallback; }
+  };
+  const prefs = readPrefs();
+  const savePrefs = () => { try { localStorage.setItem(PREFS_KEY, JSON.stringify(prefs)); } catch (error) { /* storage disabled */ } };
+  const node = (tag, className, text) => { const el = document.createElement(tag); if (className) el.className = className; if (text !== undefined) el.textContent = text; return el; };
+  const appendParts = (target, parts) => {
+    for (const part of parts) {
+      if (typeof part === "string") { if (part) target.append(part); }
+      else if (part && part.code !== undefined) target.append(node("code", "ad-log-code", part.code));
+      else if (part && part.link) { const a = node("a", "ad-log-link", part.link); a.href = part.href; target.append(a); }
+    }
+  };
+  const actorClass = (actor) => {
+    if (actor === "lead") return "is-lead";
+    if (actor === "loop") return "is-loop";
+    let hash = 0;
+    for (const char of actor) hash = (hash * 31 + char.charCodeAt(0)) >>> 0;
+    return "is-worker-" + (hash % 4);
+  };
+  // Events that usually mean the canonical task changed: refresh the page regions
+  // now (debounced) instead of waiting for the next poll.
+  const STATE_EVENTS = new Set(["turn_end", "lifecycle_command", "gate", "waiting", "daemon_turn", "daemon_turn_error", "loop_stopped", "job_integrated"]);
+  let refreshTimer = 0;
+  const refreshSoon = () => {
+    if (typeof liveRefresh !== "function") return;
+    clearTimeout(refreshTimer);
+    refreshTimer = setTimeout(() => liveRefresh(), 150);
+  };
+
+  const instances = new Map();
+  const createLog = (root) => {
+    const compact = root.getAttribute("data-log-mode") === "compact";
+    const limit = Math.max(1, Math.min(2000, Number(root.getAttribute("data-log-limit")) || (compact ? 20 : 2000)));
+    const taskId = root.getAttribute("data-task-id") || document.body.getAttribute("data-task") || "";
+    let gates = DEFAULT_GATES;
+    try { gates = Object.assign({}, DEFAULT_GATES, JSON.parse(root.getAttribute("data-gate-labels") || "{}")); } catch (error) { /* defaults */ }
+    const body = root.querySelector("[data-log-body]");
+    const stateEl = root.querySelector("[data-log-state]");
+    const followBtn = root.querySelector("[data-log-follow]");
+    let source = null;
+    let follow = true;
+    let entries = [];
+    let block = null; // current turn group: { actor, body }
+    const turns = new Map(); // actor -> label of its latest turn
+    const view = () => compact ? { filter: "important", raw: false } : prefs;
+    const setState = (text) => { if (stateEl) stateEl.textContent = text; };
+    const placeholder = (text) => { body.textContent = ""; body.append(node("span", "ad-log-muted", text)); };
+    const scroll = () => { if (follow) body.scrollTop = body.scrollHeight; };
+
+    const lineFor = (entry, current) => {
+      const line = node("div", "ad-log-line");
+      if (!entry.event) { line.classList.add("is-unparsed"); line.textContent = entry.raw; return line; }
+      const info = entry.info;
+      if (info.tone) line.classList.add("is-" + info.tone);
+      line.setAttribute("data-type", entry.event.type);
+      const actor = node("span", "ad-log-actor " + actorClass(info.actor), info.actor);
+      actor.title = "actor: " + info.actor;
+      const text = node("span", "ad-log-text");
+      if (current.raw) { text.classList.add("is-json"); text.textContent = entry.raw; }
+      else if (info.full && current.filter === "all") text.textContent = info.full;
+      else if (info.full && !compact) {
+        const more = node("details", "ad-log-more");
+        const summary = node("summary");
+        appendParts(summary, info.parts);
+        more.append(summary, node("div", "ad-log-full", info.full));
+        text.append(more);
+      } else appendParts(text, info.parts);
+      if (info.title) text.title = info.title;
+      line.append(node("span", "ad-log-time", clock(entry.event.at)), actor, text);
+      return line;
+    };
+    const openGroup = (actor, label, entry) => {
+      const group = node("div", "ad-log-turn");
+      const head = node("div", "ad-log-turn-head");
+      head.append(node("span", "ad-log-time", entry ? clock(entry.event.at) : ""), node("span", "ad-log-actor " + actorClass(actor), actor), node("span", "ad-log-turn-label", label));
+      const groupBody = node("div", "ad-log-turn-body");
+      group.append(head, groupBody);
+      body.append(group);
+      block = { actor, body: groupBody };
+      return head;
+    };
+    // Appends one entry to the DOM (when the current view shows it); returns its node.
+    const render = (entry) => {
+      const current = view();
+      const info = entry.info;
+      if (info && info.noise && current.filter === "important") return null;
+      if (compact || current.raw || !info) { const line = lineFor(entry, current); body.append(line); return line; }
+      if (info.turn) { turns.set(info.actor, info.turn); return openGroup(info.actor, info.turn, entry); }
+      if (info.system) { block = null; const line = lineFor(entry, current); body.append(line); return line; }
+      if (!block || block.actor !== info.actor) openGroup(info.actor, (turns.get(info.actor) || info.actor) + " · continued", null);
+      const line = lineFor(entry, current);
+      block.body.append(line);
+      if (entry.event.type === "turn_end") block = null;
+      return line;
+    };
+    const drop = (entry) => {
+      const el = entry.node;
+      if (!el) return;
+      const group = el.closest(".ad-log-turn");
+      el.remove();
+      if (group && !group.querySelector(".ad-log-line, .ad-log-turn-head")) group.remove();
+    };
+    const rerender = () => {
+      body.textContent = "";
+      block = null;
+      turns.clear();
+      for (const entry of entries) entry.node = render(entry);
+      if (!entries.length) placeholder("No events for this task yet.");
+      if (compact) trimCompact();
+      scroll();
+    };
+    // Compact: only the last `limit` shown lines stay in the DOM.
+    const trimCompact = () => { while (body.querySelectorAll(".ad-log-line").length > limit) body.querySelector(".ad-log-line").remove(); };
+    const append = (raw) => {
+      if (!entries.length) body.textContent = "";
+      setState("streaming");
+      let event = null;
+      try { event = JSON.parse(raw); } catch (error) { event = null; }
+      if (!event || typeof event !== "object" || typeof event.type !== "string") event = null;
+      const entry = { raw, event, info: event ? describe(event, { taskId, gates }) : null, node: null };
+      entries.push(entry);
+      entry.node = render(entry);
+      const cap = compact ? Math.max(limit * 10, 200) : limit;
+      while (entries.length > cap) { const old = entries.shift(); if (!compact) drop(old); }
+      if (compact) trimCompact();
+      if (event && STATE_EVENTS.has(event.type)) refreshSoon();
+      scroll();
+    };
+    const clear = () => { entries = []; block = null; turns.clear(); placeholder("No events for this task yet."); };
+
+    const syncControls = () => {
+      root.querySelectorAll("[data-log-filter]").forEach((button) => button.setAttribute("aria-pressed", String(button.getAttribute("data-log-filter") === prefs.filter)));
+      root.querySelectorAll("[data-log-raw]").forEach((button) => button.setAttribute("aria-pressed", String(prefs.raw)));
+    };
+    root.addEventListener("click", (event) => {
+      const target = event.target instanceof Element ? event.target : null;
+      if (!target) return;
+      const filter = target.closest("[data-log-filter]");
+      if (filter) { prefs.filter = filter.getAttribute("data-log-filter") === "all" ? "all" : "important"; savePrefs(); instances.forEach((log) => log.refreshView()); return; }
+      if (target.closest("[data-log-raw]")) { prefs.raw = !prefs.raw; savePrefs(); instances.forEach((log) => log.refreshView()); return; }
+      if (target.closest("[data-log-follow]")) { follow = !follow; followBtn?.setAttribute("aria-pressed", String(follow)); scroll(); return; }
+      if (target.closest("[data-log-clear]")) { clear(); }
+    });
+    syncControls();
+
+    return {
+      refreshView: () => { syncControls(); if (!compact) rerender(); },
+      running: () => source !== null,
+      start: () => {
+        if (source || !body) return;
+        clear();
+        placeholder("connecting…");
+        setState("connecting…");
+        source = new EventSource("/api/events?task-id=" + encodeURIComponent(taskId));
+        source.onopen = () => { if (!entries.length) { setState("connected · waiting for events"); placeholder("No events for this task yet."); } };
+        source.onmessage = (message) => append(message.data);
+        // The server replays the log from the start of its window: drop what is shown.
+        source.addEventListener("reset", () => clear());
+        source.onerror = () => {
+          const closed = source && source.readyState === 2;
+          setState(closed ? "unavailable" : entries.length ? "reconnecting…" : "unavailable");
+          if (!entries.length) placeholder("Log stream unavailable (loop not running or log missing).");
+        };
+      },
+      stop: () => { if (source) { source.close(); source = null; setState("paused"); } },
+    };
+  };
+
+  // Starts logs that are attached and visible; stops removed or hidden ones.
+  const scan = () => {
+    document.querySelectorAll("[data-live-log]").forEach((root) => { if (!instances.has(root)) instances.set(root, createLog(root)); });
+    for (const [root, log] of instances) {
+      if (!root.isConnected) { log.stop(); instances.delete(root); continue; }
+      if (root.closest("[hidden]")) log.stop(); else log.start();
+    }
+  };
+  let scheduled = false;
+  const scheduleScan = () => { if (scheduled) return; scheduled = true; queueMicrotask(() => { scheduled = false; scan(); }); };
+  // Mutations inside a log (its lines, its state text) never add or remove logs.
+  const insideLog = (record) => { const el = record.target.nodeType === 1 ? record.target : record.target.parentElement; return !!el && !!el.closest("[data-live-log]"); };
+  new MutationObserver((records) => { if (records.some((record) => !insideLog(record))) scheduleScan(); })
+    .observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ["hidden"] });
+  window.addEventListener("pagehide", () => instances.forEach((log) => log.stop()));
+  window.addEventListener("pageshow", (event) => { if (event.persisted) scan(); });
+  scan();
+})();

package/dist/services/aidlc-coordination/Dockerfile

@@ -1,10 +1,18 @@
-FROM node:24-bookworm-slim
+FROM node:24-bookworm-slim AS build
 WORKDIR /app
 RUN apt-get update && apt-get install -y --no-install-recommends python3 make g++ && rm -rf /var/lib/apt/lists/*
 COPY package.json package-lock.json ./
 RUN npm ci --omit=dev
-COPY src ./src
-RUN mkdir -p /data
+
+FROM node:24-bookworm-slim
+WORKDIR /app
+ENV NODE_ENV=production
 ENV MCP_STATE_HOST=0.0.0.0 MCP_STATE_PORT=8787 MCP_STATE_SQLITE_PATH=/data/mcp-state.db
+COPY --from=build /app/node_modules ./node_modules
+COPY package.json package-lock.json ./
+COPY src ./src
+RUN mkdir -p /data && chown -R node:node /data
+USER node
 EXPOSE 8787
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 CMD node -e "fetch('http://127.0.0.1:8787/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
 CMD ["node", "src/server.mjs"]

package/dist/services/aidlc-coordination/compose.yaml

@@ -9,6 +9,12 @@ services:
       MCP_STATE_DATABASE: sqlite
       MCP_STATE_SQLITE_PATH: /data/mcp-state.db
       MCP_STATE_AUTH_TOKEN: ${MCP_STATE_AUTH_TOKEN:?set MCP_STATE_AUTH_TOKEN in .env before starting the service}
+    healthcheck:
+      test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:8787/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"]
+      interval: 30s
+      timeout: 3s
+      start_period: 5s
+      retries: 3
 
   postgres:
     image: postgres:16-alpine
@@ -40,6 +46,12 @@ services:
       MCP_FLEET_LEAD_TOKEN: ${MCP_FLEET_LEAD_TOKEN:?set MCP_FLEET_LEAD_TOKEN in .env}
       MCP_FLEET_REVIEWER_TOKEN: ${MCP_FLEET_REVIEWER_TOKEN:?set MCP_FLEET_REVIEWER_TOKEN in .env}
       MCP_FLEET_WORKER_TOKENS: ${MCP_FLEET_WORKER_TOKENS:?set MCP_FLEET_WORKER_TOKENS JSON in .env}
+    healthcheck:
+      test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:8787/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"]
+      interval: 30s
+      timeout: 3s
+      start_period: 5s
+      retries: 3
 
 volumes:
   aidlc-coordination-data:

package/dist/services/aidlc-coordination/package-lock.json

@@ -4,7 +4,9 @@
   "requires": true,
   "packages": {
     "": {
-      "bin": { "aidlc-fleet": "src/fleet-run.mjs" },
+      "bin": {
+        "aidlc-fleet": "src/fleet-run.mjs"
+      },
       "dependencies": {
         "@modelcontextprotocol/express": "^2.0.0",
         "@modelcontextprotocol/node": "^2.0.0",