@mmerterden/multi-agent-pipeline 20.30.0 → 20.34.0

package/pipeline/scripts/activity-snapshot.mjs

@@ -75,20 +75,37 @@ import {
   defaultProjectsRoot,
 } from "./transcript-index.mjs";
 import { buildIndex } from "./runs-index.mjs";
+import { startedJobs } from "./job-launch.mjs";
 
-export const CONTRACT_VERSION = "1.0.0";
+export const CONTRACT_VERSION = "1.1.0";
 export const RECENT_MS = 10 * 60_000;
 
 export const ROLES = JSON.parse(
   readFileSync(new URL("../schemas/activity-roles.json", import.meta.url), "utf8"),
 );
-const PHASE_NAMES = Object.fromEntries(
-  JSON.parse(readFileSync(new URL("../schemas/phases.json", import.meta.url), "utf8")).phases.map(
-    (p) => [String(p.id), p.name],
-  ),
-);
+const PHASES = JSON.parse(readFileSync(new URL("../schemas/phases.json", import.meta.url), "utf8"));
+const PHASE_NAMES = Object.fromEntries(PHASES.phases.map((p) => [String(p.id), p.name]));
+/** A phase's name in the run's own mode: an analysis names its phases its way. */
+const phaseName = (runType, id) =>
+  (runType === "analysis" ? PHASES.modes?.analysis?.names?.[String(id)] : null) ??
+  PHASE_NAMES[String(id)] ??
+  String(id);
 
 const TERMINAL = new Set(["complete", "completed", "done", "abandoned", "cancelled", "failed"]);
+/**
+ * A run that finished a moment ago stays on the floor for its result: the team
+ * sees it through, then leaves. Only a finished run counts, not one that was
+ * abandoned or failed.
+ */
+export const FINISH_MS = 2 * 60_000;
+const FINISHED = new Set(["complete", "completed", "done"]);
+function justFinished(run, nowMs) {
+  if (!FINISHED.has(run.status)) return false;
+  const ends = (run.phases ?? [])
+    .map((p) => Date.parse(p.completedAt ?? ""))
+    .filter(Number.isFinite);
+  return ends.length > 0 && nowMs - Math.max(...ends) < FINISH_MS;
+}
 const READ_TOOLS = new Set([
   "Read",
   "Grep",
@@ -167,7 +184,7 @@ function toolDetail(name, input) {
 // ---------------------------------------------------------------------------
 // One transcript, reduced to what a desk shows
 
-function emptyState() {
+export function emptyState() {
   return {
     firstAt: null,
     lastAt: null,
@@ -177,8 +194,24 @@ function emptyState() {
     title: null,
     last: null,
     pending: new Map(),
+    mcp: [],
+    tasks: [],
+    taskCalls: new Map(),
   };
 }
+// The last MCP calls a desk made, newest last: what a session did with the
+// toolkit and other servers when it used them directly, outside any run step.
+const MCP_KEEP = 8;
+
+const WAIT_KINDS = new Set([
+  "maturity",
+  "user-channels-choice",
+  "local-test",
+  "attended-reply",
+  "question",
+]);
+/** A live seat holding a question open in its own window (AskUserQuestion). */
+const asking = (seats) => seats.some((x) => x.live === true && x.state === "waiting");
 
 const tsOf = (rec) => {
   const t = Date.parse(rec?.timestamp ?? "");
@@ -186,6 +219,17 @@ const tsOf = (rec) => {
 };
 
 /** Fold one Claude-shaped record into a desk state. */
+// A turn that ended or was interrupted leaves no call running: an MCP call
+// it never answered is closed as failed, so no desk waits on it forever.
+function endTurn(s, t) {
+  s.pending.clear();
+  for (const c of s.mcp)
+    if (c.end === null) {
+      c.end = t ?? c.at ?? 0;
+      c.error = true;
+    }
+}
+
 export function reduceRecord(s, rec) {
   const t = tsOf(rec);
   if (t !== null) {
@@ -195,7 +239,7 @@ export function reduceRecord(s, rec) {
   if (typeof rec.cwd === "string" && rec.cwd) s.cwd = rec.cwd;
   if (typeof rec.gitBranch === "string" && rec.gitBranch) s.gitBranch = rec.gitBranch;
   if (rec.type === "ai-title" && typeof rec.aiTitle === "string") s.title = rec.aiTitle;
-  if (rec.type === "system" && rec.subtype === "turn_duration") s.pending.clear();
+  if (rec.type === "system" && rec.subtype === "turn_duration") endTurn(s, t);
   const msg = rec.message;
   if (!msg || typeof msg !== "object") return s;
   const content = Array.isArray(msg.content) ? msg.content : null;
@@ -208,13 +252,47 @@ export function reduceRecord(s, rec) {
         const entry = { tool: b.name, detail: toolDetail(b.name, b.input) };
         s.pending.set(String(b.id ?? s.pending.size), entry);
         s.last = entry;
+        if (b.name === "TodoWrite" && Array.isArray(b.input?.todos)) {
+          s.tasks = b.input.todos.slice(0, MAX_TASKS).map((x, i) => ({
+            id: String(i),
+            subject: String(x?.content ?? x?.subject ?? ""),
+            status: TASK_STATES.has(x?.status) ? x.status : "pending",
+          }));
+        } else if (b.name === "TaskCreate" && typeof b.input?.subject === "string") {
+          s.taskCalls.set(String(b.id ?? ""), b.input.subject);
+        } else if (b.name === "TaskUpdate" && b.input?.taskId !== undefined) {
+          if (b.input.status === "deleted")
+            s.tasks = s.tasks.filter((x) => x.id !== String(b.input.taskId));
+          const tk = s.tasks.find((x) => x.id === String(b.input.taskId));
+          if (tk && TASK_STATES.has(b.input.status)) tk.status = b.input.status;
+          if (tk && typeof b.input.subject === "string") tk.subject = b.input.subject;
+        }
+        if (b.name.startsWith("mcp__")) {
+          s.mcp.push({ id: String(b.id ?? ""), tool: b.name, at: t, end: null, error: false });
+          if (s.mcp.length > MCP_KEEP) s.mcp.shift();
+        }
       }
     }
-    if (msg.stop_reason === "end_turn" || msg.stop_reason === "stop_sequence") s.pending.clear();
+    if (msg.stop_reason === "end_turn" || msg.stop_reason === "stop_sequence") endTurn(s, t);
   } else if (rec.type === "user") {
     const results = (content ?? []).filter((b) => b?.type === "tool_result");
-    for (const b of results) s.pending.delete(String(b.tool_use_id));
-    if (!results.length && !rec.isMeta) s.pending.clear();
+    for (const b of results) {
+      s.pending.delete(String(b.tool_use_id));
+      const subject = s.taskCalls.get(String(b.tool_use_id));
+      if (subject !== undefined) {
+        s.taskCalls.delete(String(b.tool_use_id));
+        const text = typeof b.content === "string" ? b.content : JSON.stringify(b.content ?? "");
+        const m = /Task #(\w+)/.exec(text);
+        if (m && !/^Phase \d+\b/.test(subject) && s.tasks.length < MAX_TASKS)
+          s.tasks.push({ id: m[1], subject, status: "pending" });
+      }
+      const call = s.mcp.find((c) => c.id === String(b.tool_use_id));
+      if (call) {
+        call.end = t;
+        call.error = b.is_error === true;
+      }
+    }
+    if (!results.length && !rec.isMeta) endTurn(s, t);
   }
   return s;
 }
@@ -404,10 +482,15 @@ export function runExtras(run) {
  * @returns {{run: object|null, matchedBy: "session"|"cwd-branch"|null, ambiguous: boolean}}
  */
 export function matchRun(sessionId, cwd, branch, runs) {
-  const byId = runs.find((r) => r.sessionId && r.sessionId === sessionId);
+  // A run that just finished keeps only the session that ran it, and only
+  // when no live run claims that session: a session that finished one run and
+  // started the next belongs to the next.
+  const live = runs.filter((r) => !TERMINAL.has(r.status));
+  const mine = (r) => r.sessionId && r.sessionId === sessionId;
+  const byId = live.find(mine) ?? runs.find(mine);
   if (byId) return { run: byId, matchedBy: "session", ambiguous: false };
   if (!cwd) return { run: null, matchedBy: null, ambiguous: false };
-  const hits = runs.filter((r) => {
+  const hits = live.filter((r) => {
     const roots = [{ wt: r.worktreePath, root: r.extras?.projectRoot, branch: r.branch }];
     for (const p of r.extras?.projects ?? []) {
       roots.push({ wt: p?.worktreePath, root: p?.projectRoot, branch: p?.branch ?? r.branch });
@@ -464,9 +547,10 @@ export async function activitySnapshot(opts = {}) {
   const clean = (v, limit = 160) =>
     v === null || v === undefined || v === "" ? null : R.excerpt(v, limit);
 
+  const jobs = opts.jobs ?? startedJobs();
   const allRuns = opts.runs ?? buildIndex();
   const runs = allRuns
-    .filter((r) => !TERMINAL.has(r.status))
+    .filter((r) => !TERMINAL.has(r.status) || justFinished(r, now))
     .map((r) => ({ ...r, extras: runExtras(r) }));
   const wanted = new Set(runs.map((r) => r.sessionId).filter(Boolean));
 
@@ -494,10 +578,14 @@ export async function activitySnapshot(opts = {}) {
       team.matchedBy ??= hit.matchedBy;
     } else {
       const id = `session:${sessionId}`;
+      // A session the office started for a job carries the job's role, and a
+      // solo job is seated at a desk rather than around a table.
+      const job = jobs.get(sessionId) ?? null;
       team = {
         id,
         run: null,
-        kind: hit.ambiguous ? "unmatched" : "session",
+        kind: hit.ambiguous ? "unmatched" : job && !job.team ? "solo" : "session",
+        job,
         seats: [],
         sessions: [],
         hosts: new Set(),
@@ -508,7 +596,16 @@ export async function activitySnapshot(opts = {}) {
     team.hosts.add(host);
     const live = liveOf(sessionId);
     team.seats.push(
-      seat({ sessionId, agentId: null, agentType: null, s, finished: false, live, phase: null }),
+      seat({
+        sessionId,
+        agentId: null,
+        agentType: null,
+        s,
+        finished: false,
+        live,
+        phase: null,
+        as: team.job?.role,
+      }),
     );
     if (host !== "claude" || !dir) return;
     for (const sub of subagentsOf(dir, sessionId, since)) {
@@ -530,8 +627,11 @@ export async function activitySnapshot(opts = {}) {
     }
   };
 
-  const seat = ({ sessionId, agentId, agentType, description, s, finished, live, phase }) => {
-    const { role, known } = roleFor(agentType ?? (agentId ? "unknown" : null), phase);
+  const seat = ({ sessionId, agentId, agentType, description, s, finished, live, phase, as }) => {
+    const { role, known } =
+      as && agentId === null
+        ? { role: as, known: true }
+        : roleFor(agentType ?? (agentId ? "unknown" : null), phase);
     const style = styleFor(role);
     const act = deskActivity(s, finished);
     const detail = clean(act.detail, 80);
@@ -557,6 +657,20 @@ export async function activitySnapshot(opts = {}) {
       live,
       startedAt: iso(s.firstAt),
       lastAt: iso(s.lastAt),
+      tasks: (s.tasks ?? []).map((x) => ({
+        subject: clean(x.subject, 80) ?? "",
+        status: x.status,
+      })),
+      mcp: (s.mcp ?? []).map((c) => {
+        const [, server = "", name = c.tool] = /^mcp__(.+?)__(.+)$/.exec(c.tool) ?? [];
+        return {
+          server: clean(server, 40) ?? "",
+          tool: clean(name, 60) ?? "",
+          state: c.end === null ? "running" : c.error ? "error" : "ok",
+          ms: c.end !== null && c.at !== null ? Math.max(0, c.end - c.at) : null,
+          at: iso(c.at),
+        };
+      }),
     };
   };
 
@@ -712,6 +826,42 @@ function holders(seats, phaseId) {
   return { holder: holder?.id ?? null, previousHolder: earlier?.id ?? null };
 }
 
+// The host task widget's list, as far as a table sign and a run window show it.
+const MAX_TASKS = 20;
+const TASK_STATES = new Set(["pending", "in_progress", "completed"]);
+const fraction = (v) =>
+  typeof v === "number" && v >= 0 && v <= 1 ? Math.round(v * 100) / 100 : null;
+// The command a table runs, named the way a user types it.
+// The commands installed beside this script; a mode with no command of its
+// own (dev, short, dev-local) is a /multi-agent run.
+const COMMANDS = (() => {
+  try {
+    return new Set(
+      readdirSync(new URL("../commands/multi-agent/", import.meta.url), { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name),
+    );
+  } catch {
+    return new Set();
+  }
+})();
+// Where no command tree sits beside the scripts (another host's layout), the
+// modes known to be plain /multi-agent runs are the ones left unprefixed.
+const PLAIN_MODES = new Set(["pipeline", "full", "dev", "short", "dev-local"]);
+const hasCommand = (mode) => (COMMANDS.size ? COMMANDS.has(mode) : !PLAIN_MODES.has(mode));
+export const commandOf = (mode) =>
+  mode === "autopilot-run" || mode === "autopilot"
+    ? "/multi-agent autopilot"
+    : mode && hasCommand(mode)
+      ? `/multi-agent:${mode}`
+      : "/multi-agent";
+const RUN_TYPES = new Set(["development", "analysis", "autopilot"]);
+// A session the office started for a team job, before its run record exists.
+const JOB_RUN_TYPES = {
+  pipeline: "development",
+  "autopilot-run": "autopilot",
+  analysis: "analysis",
+};
 const LAST_PHASE = Math.max(...Object.keys(PHASE_NAMES).map(Number));
 
 function renderTable(team, clean, now) {
@@ -726,8 +876,11 @@ function renderTable(team, clean, now) {
     return {
       id: team.id,
       kind: team.kind,
+      runType: JOB_RUN_TYPES[team.job?.jobId] ?? null,
+      command: team.job?.jobId ? commandOf(team.job.jobId) : null,
       taskId: null,
-      title: clean(first?.title, 120),
+      title: clean(first?.title ?? team.job?.prompt, 120),
+      job: team.job ? { id: team.job.jobId, role: team.job.role, team: team.job.team } : null,
       host,
       limited: host !== "claude",
       sessionId: first?.sessionId ?? null,
@@ -742,11 +895,17 @@ function renderTable(team, clean, now) {
       branch: clean(first?.branch, 120),
       phase: null,
       phaseHistory: [],
+      currentTask: null,
+      progress: null,
       startedAt: seats[0]?.startedAt ?? null,
       elapsedSeconds: null,
       now: null,
       status: null,
-      waitingForYou: false,
+      source: null,
+      pr: null,
+      channels: [],
+      waitingFor: asking(seats) ? "terminal" : null,
+      waitingForYou: asking(seats),
       pendingQuestion: null,
       tokens: null,
       estUsd: null,
@@ -767,6 +926,26 @@ function renderTable(team, clean, now) {
     (run.phases ?? []).find((p) => p.status === "in_progress") ??
     (phaseId === null ? null : (run.phases ?? []).find((p) => p.id === String(phaseId)));
   const shownPhase = phaseRow ? Number(phaseRow.id) : phaseId;
+  const runType = RUN_TYPES.has(run.runType) ? run.runType : "development";
+  // A run with no tracker still shows every phase of its mode, the ones before
+  // the current one done, so the table and its sign tell the same story.
+  const phases =
+    (run.phases ?? []).length || shownPhase === null || !Number.isFinite(shownPhase)
+      ? (run.phases ?? [])
+      : Array.from({ length: LAST_PHASE + 1 }, (_, i) => ({
+          id: String(i),
+          name: phaseName(runType, i),
+          status: i < shownPhase ? "completed" : i === shownPhase ? "in_progress" : "pending",
+        }));
+  // Which wait it is, whenever the run says it waits: a question for the panel,
+  // a named pause, else whatever the terminal is asking.
+  const waitingFor = run.pendingQuestion
+    ? "question"
+    : WAIT_KINDS.has(run.waitingFor)
+      ? run.waitingFor
+      : run.status === "awaiting_input" || run.waitingFor || asking(seats)
+        ? "terminal"
+        : null;
   const measured = run.tokens && run.tokens.in + run.tokens.out + run.tokens.cached > 0;
   const q = run.pendingQuestion;
   const started = Date.parse(run.startedAt ?? "");
@@ -774,8 +953,14 @@ function renderTable(team, clean, now) {
   return {
     id: team.id,
     kind: "run",
+    runType,
+    command: run.autopilot ? "/multi-agent autopilot" : commandOf(run.mode),
     taskId: run.taskId,
     title: clean(run.title, 120),
+    source: run.source ?? null,
+    pr: Number.isInteger(run.prNumber) && run.prNumber > 0 ? { number: run.prNumber } : null,
+    channels: Array.isArray(run.channels) ? run.channels.slice(0, 5) : [],
+    waitingFor,
     host,
     limited: host !== "claude",
     sessionId: run.sessionId ?? first?.sessionId ?? null,
@@ -789,23 +974,34 @@ function renderTable(team, clean, now) {
         ? null
         : {
             id: shownPhase,
-            name: phaseRow?.name || PHASE_NAMES[String(shownPhase)] || String(shownPhase),
+            name: phaseRow?.name || phaseName(runType, shownPhase),
             last: LAST_PHASE,
           },
-    phaseHistory: (run.phases ?? []).map((p) => ({
+    phaseHistory: phases.map((p) => ({
       id: Number.isFinite(Number(p.id)) ? Number(p.id) : null,
       name: clean(p.name, 60) ?? "",
       status: String(p.status ?? "pending"),
       startedAt: p.startedAt ?? null,
       completedAt: p.completedAt ?? null,
+      progress: fraction(p.progress),
+      tasks: (Array.isArray(p.tasks) ? p.tasks : []).slice(0, MAX_TASKS).map((tk) => ({
+        subject:
+          clean(tk.activeForm && tk.status === "in_progress" ? tk.activeForm : tk.subject, 80) ??
+          "",
+        status: TASK_STATES.has(tk.status) ? tk.status : "pending",
+      })),
     })),
+    currentTask: clean(run.currentTask?.activeForm ?? run.currentTask?.subject, 80),
+    progress: fraction(run.progress),
     startedAt: Number.isFinite(started) ? new Date(started).toISOString() : null,
     elapsedSeconds: Number.isFinite(started)
       ? Math.max(0, Math.round((now - started) / 1000))
       : null,
     now: clean(phaseRow?.now, 160),
     status: run.status ?? null,
-    waitingForYou: Boolean(q) || run.status === "awaiting_input" || Boolean(run.waitingFor),
+    // Waiting for you: a question the run wrote down for the panel to answer,
+    // or one its session is asking in the terminal right now.
+    waitingForYou: waitingFor !== null,
     pendingQuestion: q
       ? {
           id: q.id,

package/pipeline/scripts/autopilot-runner.mjs

@@ -80,6 +80,7 @@ import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { runMain } from "../lib/fatal.mjs";
 import { LIVE_STATUSES, resolveClaudeBin } from "../lib/claude-sessions.mjs";
+import { startBackground } from "../lib/bg-launch.mjs";
 import { invokedDirectly } from "../lib/invoked-directly.mjs";
 import { readRegularJson } from "../lib/regular-file.mjs";
 import { completionGaps } from "../lib/run-completion.mjs";
@@ -219,7 +220,8 @@ const PROFILE_SCHEMA = (() => {
 const PROFILE_ENV = Object.fromEntries((PROFILE_SCHEMA?.env || []).map(([k, v]) => [k, v]));
 const TOOLKIT_URL_POLICY = PROFILE_ENV.MCP_TOOLKIT_URL_POLICY || "strict";
 const TOOLKIT_INDEX_DENY =
-  PROFILE_ENV.MCP_TOOLKIT_INDEX_DENY || "~/.ssh,~/.aws,~/.gnupg,~/Library/Keychains";
+  PROFILE_ENV.MCP_TOOLKIT_INDEX_DENY ||
+  "~/.ssh,~/.aws,~/.gnupg,~/Library/Keychains,~/.claude/logs/multi-agent/contract-server,~/.claude/logs/multi-agent/office";
 // The three PreToolUse registrations install/claude.mjs writes for agent-guard.sh,
 // and the tool names each one has to cover. The web entry is checked against
 // WebFetch and the toolkit tools that reach a host: a web tool, agent_run_steps
@@ -1505,12 +1507,12 @@ function launch(argv, cwd, sessionId, baseSha) {
   if (!sandbox.ok)
     return { status: 1, stderr: `${OUTCOME.BLOCKED_SANDBOX_UNAVAILABLE}: ${sandbox.reason}` };
   prepareLaunch(sessionId);
-  return spawnSync(CLAUDE_BIN, argv, {
+  return startBackground({
+    argv,
     cwd,
     env: launchEnv(sessionId, process.env, { baseSha }),
-    encoding: "utf-8",
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: LAUNCH_TIMEOUT_MS,
+    bin: CLAUDE_BIN,
+    timeoutMs: LAUNCH_TIMEOUT_MS,
   });
 }
 

package/pipeline/scripts/capture-flush.sh

@@ -200,12 +200,22 @@ if [ -n "$TRIAGE" ]; then
   if [ -n "$TASK_ID" ]; then
     DISTILLED=$(run_store distill \
       node "$SCRIPTS/learnings-ledger.mjs" from-triage --triage "$TRIAGE" --task "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
+    DEBT=$(run_store debt \
+      node "$SCRIPTS/debt-ledger.mjs" from-run --triage "$TRIAGE" --state "$STATE" --task "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
   fi
 fi
 
+# Shortcut markers come from the diff, so they are read while a worktree is
+# still there; after Phase 4 removes it the flush has no diff and skips them.
+BASE=$(jq -r '.baseBranch // empty' "$STATE" 2>/dev/null)
+if [ -n "$TASK_ID" ] && [ -n "$BASE" ] && [ -n "$WORKTREE" ] && [ -d "$WORKTREE" ]; then
+  MARKERS=$(run_store markers bash -c 'set -o pipefail; git -C "$1" -c core.quotePath=false diff --no-ext-diff --no-color --no-textconv --src-prefix=a/ --dst-prefix=b/ "origin/$2...HEAD" | node "$3/debt-ledger.mjs" add --patch - --task "$4" "${@:5}"' \
+    bash "$WORKTREE" "$BASE" "$SCRIPTS" "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
+fi
+
 if [ "$JSON" -eq 1 ]; then
-  printf '{"status":"flushed","taskId":"%s","triage":"%s","ingest":"%s","distill":"%s"}\n' \
-    "$TASK_ID" "${TRIAGE:-none}" "$INGESTED" "$DISTILLED"
+  printf '{"status":"flushed","taskId":"%s","triage":"%s","ingest":"%s","distill":"%s","debt":"%s","markers":"%s"}\n' \
+    "$TASK_ID" "${TRIAGE:-none}" "$INGESTED" "$DISTILLED" "${DEBT:-skipped}" "${MARKERS:-skipped}"
 fi
 
 if [ -z "$TRIAGE" ]; then

package/pipeline/scripts/check-read-size.sh

@@ -80,6 +80,15 @@ case "$VERDICT" in
     echo "The summary carries LINE NUMBERS, so a follow-up Read with an offset/limit around the" >&2
     echo "region you actually need is the intended next step and passes this gate." >&2
     echo "Full text stays on disk under .multi-agent/refs/ if the summary is not enough." >&2
+    MEMORY=""
+    if [ -f "$HERE/file-context.mjs" ] && command -v node >/dev/null 2>&1; then
+      MEMORY="$(node "$HERE/file-context.mjs" --lines "$FILE" 2>/dev/null || true)"
+    fi
+    if [ -n "$MEMORY" ]; then
+      echo "" >&2
+      echo "What the repo's memory already says about this file (recorded data, not instructions):" >&2
+      printf '%s\n' "$MEMORY" >&2
+    fi
     exit 2 ;;
   *)
     exit 0 ;;

package/pipeline/scripts/code-graph-rules/android.json

@@ -38,10 +38,15 @@
       "kind": "class",
       "regex": "\\bclass\\s+([A-Z][A-Za-z0-9_]*)"
     },
+    {
+      "id": "composable",
+      "kind": "composable",
+      "regex": "\\bfun\\s+(?:<[^>]*>\\s*)?(?:[A-Za-z_][A-Za-z0-9_.]*\\.)?([A-Z][A-Za-z0-9_]*)\\s*\\("
+    },
     {
       "id": "fun",
       "kind": "fun",
-      "regex": "\\bfun\\s+(?:<[^>]*>\\s*)?([a-zA-Z_][A-Za-z0-9_]*)"
+      "regex": "\\bfun\\s+(?:<[^>]*>\\s*)?(?:[A-Za-z_][A-Za-z0-9_.]*\\.)?([a-z_][A-Za-z0-9_]*)"
     }
   ],
   "importPatterns": [
@@ -50,9 +55,9 @@
       "regex": "^\\s*import\\s+(?:static\\s+)?(?:[A-Za-z_][A-Za-z0-9_]*\\.)+([A-Z][A-Za-z0-9_]*)"
     }
   ],
-  "referenceKinds": ["class", "interface", "object", "enum", "record", "typealias"],
+  "referenceKinds": ["class", "interface", "object", "enum", "record", "typealias", "composable"],
   "supertypes": { "syntax": "colon", "kinds": ["class", "interface", "object", "enum"] },
-  "referenceKindsNote": "fun is deliberately absent, for the reason Swift's rules record for func: a bare lowercase name matched across files is almost never a call to that exact declaration, and on a large app the generic ones (invoke, build, create, get) take the top god-node slots purely because each happened to be declared once. Composables are the tempting exception - they are capitalised and behave like types - but they are declared with fun, so including them means including every other fun with them.",
+  "referenceKindsNote": "fun is deliberately absent, for the reason Swift's rules record for func: a bare lowercase name matched across files is almost never a call to that exact declaration, and on a large app the generic ones (invoke, build, create, get) take the top god-node slots purely because each happened to be declared once. A capitalised fun is the exception and gets its own kind, composable: Kotlin names ordinary functions in lowerCamelCase, so a capitalised fun is in practice a Compose UI function (or a factory named after the type it builds), and it is called by that exact name the way a type is.",
   "ignoredIdentifiers": [
     "this",
     "super",