@xrkseek/harness 0.5.13 → 0.5.18

package/node_modules/@xrkseek/server-face/dist/session-status.js

@@ -1,1061 +0,0 @@
-/**
- * Shared session Status snapshot — Hermes-style single field set for `/status`
- * slash text and the Overview Status tab (`session.status` Face RPC).
- */
-import { listPendingAdmits, readSessionEvents, sessionEventCount, } from "@xrkseek/core-session";
-import { foldPlanMode } from "@xrkseek/protocol";
-import { readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { formatPermissionStatusLabel, permissionSelectFromEvents, } from "./permissions.js";
-import { resolveSessionModelSelection } from "./model-catalog.js";
-import { resolveSessionCwd } from "./session-cwd.js";
-import { buildFaceChannelDiscover, resolveImGatewayWired, } from "./process-channels.js";
-import { appearanceLookWire } from "./agent-roster-store.js";
-import { dressingFromPresence } from "./presence-dressing.js";
-import { costMeterGetState } from "./cost-meter-store.js";
-import { resolveSubagentQuota } from "./subagent-tools.js";
-import { isChildSessionActive } from "./external-agent-runtime.js";
-import { effectiveSessionAgentPreset } from "./session-agent-preset.js";
-import { describeChildOutcome, formatDescribedChildOutcome, } from "./adapt/subagent-notice.js";
-function jobRow(view) {
-    return {
-        id: view.id,
-        status: view.status,
-        ...(view.label ? { label: view.label } : {}),
-    };
-}
-function teamTaskRow(task, runtime) {
-    const lease = task.worktreeId !== undefined
-        ? runtime.managedWorktrees.get(task.worktreeId)
-        : undefined;
-    const externalResume = task.childSessionId
-        ? runtime.externalAgents.resumeState(task.childSessionId)
-        : undefined;
-    return {
-        id: task.id,
-        title: task.title,
-        status: task.status,
-        revision: task.revision,
-        ...(task.childSessionId ? { childSessionId: task.childSessionId } : {}),
-        ...(task.role ? { role: task.role } : {}),
-        ...(task.humanOwned ? { humanOwned: true } : {}),
-        ...(task.schemaValid !== undefined
-            ? { schemaValid: task.schemaValid }
-            : {}),
-        ...(task.worktreePath ? { worktreePath: task.worktreePath } : {}),
-        ...(task.worktreeBranch ? { worktreeBranch: task.worktreeBranch } : {}),
-        ...(task.worktreeId ? { worktreeId: task.worktreeId } : {}),
-        ...(lease?.status ? { worktreeLeaseStatus: lease.status } : {}),
-        ...(task.resultPreview ? { resultPreview: task.resultPreview } : {}),
-        ...(externalResume ? { externalResume } : {}),
-    };
-}
-const ZERO_BUCKETS = {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    reasoning: 0,
-    cost: 0,
-};
-function asBuckets(raw) {
-    if (!raw || typeof raw !== "object")
-        return ZERO_BUCKETS;
-    const v = raw;
-    const n = (k) => typeof v[k] === "number" && Number.isFinite(v[k]) ? (v[k]) : 0;
-    return {
-        input: n("input"),
-        output: n("output"),
-        cacheRead: n("cacheRead"),
-        cacheWrite: n("cacheWrite"),
-        reasoning: n("reasoning"),
-        cost: n("cost"),
-    };
-}
-function asBucketMap(raw) {
-    if (!raw || typeof raw !== "object")
-        return {};
-    const out = {};
-    for (const [key, value] of Object.entries(raw)) {
-        if (!key.trim())
-            continue;
-        out[key] = asBuckets(value);
-    }
-    return out;
-}
-function dayTokens(buckets) {
-    return (buckets.input +
-        buckets.output +
-        buckets.cacheRead +
-        buckets.cacheWrite +
-        buckets.reasoning);
-}
-/** Rank map rows by cost, then tokens (Hermes insights-style top models). */
-export function rankCostModelRows(map, limit = 8) {
-    return Object.entries(map)
-        .map(([key, b]) => ({
-        key,
-        input: b.input,
-        output: b.output,
-        cost: b.cost,
-        _tokens: dayTokens(b),
-    }))
-        .sort((a, b) => b.cost - a.cost ||
-        b._tokens - a._tokens ||
-        a.key.localeCompare(b.key))
-        .slice(0, Math.max(0, limit))
-        .map(({ key, input, output, cost }) => ({ key, input, output, cost }));
-}
-function costFromProjection(costRaw) {
-    return {
-        input: costRaw?.input ?? 0,
-        output: costRaw?.output ?? 0,
-        cacheRead: costRaw?.cacheRead ?? 0,
-        cacheWrite: costRaw?.cacheWrite ?? 0,
-        reasoning: costRaw?.reasoning ?? 0,
-        cost: costRaw?.cost ?? 0,
-        byModel: asBucketMap(costRaw?.byModel),
-        byProviderModel: asBucketMap(costRaw?.byProviderModel),
-    };
-}
-function billingFromLedger() {
-    try {
-        const state = costMeterGetState();
-        const month = state.month;
-        const history = [...(state.history ?? [])].sort((a, b) => a.date.localeCompare(b.date));
-        const dailyTrend = history.slice(-14).map((day) => ({
-            date: day.date,
-            cost: day.cost,
-            tokens: dayTokens(day),
-        }));
-        return {
-            todayCost: state.today.cost,
-            monthCost: month.cost,
-            totalCost: state.total.cost,
-            todayTokens: dayTokens(state.today),
-            monthTokens: dayTokens(month),
-            byModel: rankCostModelRows(asBucketMap(month.byModel)),
-            byProviderModel: rankCostModelRows(asBucketMap(month.byProviderModel)),
-            dailyTrend,
-        };
-    }
-    catch {
-        return {
-            todayCost: 0,
-            monthCost: 0,
-            totalCost: 0,
-            todayTokens: 0,
-            monthTokens: 0,
-            byModel: [],
-            byProviderModel: [],
-            dailyTrend: [],
-        };
-    }
-}
-function channelAlertsFromDiscover(channels) {
-    const alerts = [];
-    const stubIm = channels.im.filter((im) => im.wired === "bridge" ||
-        im.wired === "stub" ||
-        im.wired === "discover");
-    if (stubIm.length > 0) {
-        const gateway = channels.imGatewayWired?.trim() || "bridge";
-        alerts.push({
-            id: "im:discover-stubs",
-            severity: "info",
-            message: `${stubIm.length} IM Face ids are discover stubs (Host gateway=${gateway}; not native vendor SDKs)`,
-        });
-    }
-    if (channels.process.length === 0 && stubIm.length === channels.im.length) {
-        alerts.push({
-            id: "channels:empty",
-            severity: "info",
-            message: "No process channels; IM entries are discover stubs only",
-        });
-    }
-    if (channels.note.trim()) {
-        alerts.push({
-            id: "channels:note",
-            severity: "info",
-            message: channels.note.trim().slice(0, 160),
-        });
-    }
-    return alerts.slice(0, 8);
-}
-function buildFleet(input) {
-    const runningJobs = input.jobs.filter((j) => j.status === "running").length;
-    const runningSubagents = input.live.filter((s) => s.activity === "running").length;
-    const queuedInbox = input.live.reduce((n, s) => n + (s.queued ?? 0) + (s.steering ?? 0), 0);
-    const alerts = [...input.channelAlerts];
-    if (input.quota.slotsFree <= 0 && input.quota.maxActive > 0) {
-        alerts.unshift({
-            id: "fleet:slots",
-            severity: "warn",
-            message: `Subagent slots full (${input.quota.active}/${input.quota.maxActive})`,
-        });
-    }
-    if (queuedInbox > 0) {
-        alerts.unshift({
-            id: "fleet:inbox",
-            severity: "warn",
-            message: `${queuedInbox} child inbox admit(s) waiting (queue/steer)`,
-        });
-    }
-    // Depth-at-cap is a lineage fact, not a live fault: once a session has ever
-    // delegated to its badge's max depth, `depth` stays there forever (the
-    // parent→child link survives the child finishing). Raising critical on the
-    // bare comparison would keep an idle session permanently "critical". Only
-    // escalate while there is real pressure — an active child or a queued inbox
-    // — and otherwise report the ceiling as a warn so the operator still sees
-    // that the session is at its depth cap.
-    if (input.quota.depth >= input.quota.maxDepth && input.quota.maxDepth > 0) {
-        const underPressure = runningSubagents > 0 || queuedInbox > 0 || input.turnActive;
-        alerts.unshift({
-            id: "fleet:depth",
-            severity: underPressure ? "critical" : "warn",
-            message: `Delegation depth at cap (${input.quota.depth}/${input.quota.maxDepth})`,
-        });
-    }
-    let health = "ok";
-    if (alerts.some((a) => a.severity === "critical"))
-        health = "critical";
-    else if (alerts.some((a) => a.severity === "warn"))
-        health = "warn";
-    return {
-        health,
-        runningJobs,
-        runningSubagents,
-        slotsFree: input.quota.slotsFree,
-        queuedInbox,
-        channelAlerts: input.channelAlerts.length,
-        alerts: alerts.slice(0, 12),
-    };
-}
-function injectSourceLabel(ev) {
-    if (ev.name)
-        return `${ev.source ?? ev.form ?? "inject"}:${ev.name}`;
-    if (ev.source)
-        return ev.source;
-    if (ev.form)
-        return ev.form;
-    return "inject";
-}
-const SPILL_PREVIEW_BUDGET = 480;
-/**
- * Peek a spill file for Status/Context browse (basename · bytes · head/tail).
- * Missing files still return a path+name row so the operator can see the locator.
- */
-export function peekSpillEntry(filePath, options) {
-    const name = path.basename(filePath) || filePath;
-    const tool = options?.tool?.trim();
-    const budget = Math.max(80, options?.previewBudget ?? SPILL_PREVIEW_BUDGET);
-    try {
-        const bytes = statSync(filePath).size;
-        const text = readFileSync(filePath, "utf8");
-        let preview = text;
-        if (Buffer.byteLength(preview, "utf8") > budget) {
-            const head = text.slice(0, Math.floor(budget / 3));
-            const tail = text.slice(-Math.floor(budget / 3));
-            preview = `${head}\n…\n${tail}`;
-        }
-        preview = preview.trim();
-        if (preview.length > 600)
-            preview = `${preview.slice(0, 600)}…`;
-        return {
-            path: filePath,
-            name,
-            bytes,
-            ...(preview ? { preview } : {}),
-            ...(tool ? { tool } : {}),
-        };
-    }
-    catch {
-        return {
-            path: filePath,
-            name,
-            ...(tool ? { tool } : {}),
-        };
-    }
-}
-function summarizeTimelineEvents(events) {
-    const injectSources = [];
-    const seen = new Set();
-    let lastCompactReason;
-    let lastShadowedTokens;
-    let spillCount = 0;
-    let pruneCount = 0;
-    let summaryCount = 0;
-    const spillPathList = [];
-    const spillPathSeen = new Set();
-    // Per-turn markers for prune-first → summary pairing (DSH soft-budget order).
-    const turnPrune = new Set();
-    const turnSummary = new Map();
-    let lastStageTurn = -1;
-    for (const ev of events ?? []) {
-        if (ev.kind === "inject") {
-            const label = injectSourceLabel(ev);
-            if (!seen.has(label)) {
-                seen.add(label);
-                injectSources.push(label);
-            }
-            continue;
-        }
-        if (ev.kind === "compaction") {
-            summaryCount += 1;
-            lastCompactReason = ev.reason;
-            if (typeof ev.shadowedTokenCount === "number") {
-                lastShadowedTokens = ev.shadowedTokenCount;
-            }
-            turnSummary.set(ev.turn, ev.reason);
-            if (ev.turn >= lastStageTurn)
-                lastStageTurn = ev.turn;
-            continue;
-        }
-        if (ev.kind === "prune") {
-            pruneCount += 1;
-            if (ev.spill)
-                spillCount += 1;
-            const filePath = typeof ev.spillPath === "string" ? ev.spillPath.trim() : "";
-            if (filePath && !spillPathSeen.has(filePath)) {
-                spillPathSeen.add(filePath);
-                spillPathList.push(peekSpillEntry(filePath, {
-                    ...(ev.tool ? { tool: ev.tool } : {}),
-                }));
-            }
-            turnPrune.add(ev.turn);
-            if (ev.turn >= lastStageTurn)
-                lastStageTurn = ev.turn;
-        }
-    }
-    let pipeline = "none";
-    const stages = [];
-    if (lastStageTurn >= 0) {
-        const hadPrune = turnPrune.has(lastStageTurn);
-        const hadSummary = turnSummary.has(lastStageTurn);
-        if (hadPrune && hadSummary) {
-            pipeline = "prune→summary";
-            stages.push("prune", "summary");
-        }
-        else if (hadPrune) {
-            pipeline = "prune";
-            stages.push("prune");
-        }
-        else if (hadSummary) {
-            pipeline = "summary";
-            stages.push("summary");
-        }
-    }
-    return {
-        injectSources,
-        ...(lastCompactReason ? { lastCompactReason } : {}),
-        ...(lastShadowedTokens !== undefined
-            ? { lastShadowedTokens }
-            : {}),
-        spillCount,
-        pruneCount,
-        summaryCount,
-        pipeline,
-        stages,
-        spillPaths: spillPathList.slice(-12),
-    };
-}
-function deliveryNote(input) {
-    if (input.turnActive) {
-        const q = input.queued > 0
-            ? `queue ${input.queued} waiting`
-            : "queue accepts";
-        const s = input.steering > 0
-            ? ` · steer ${input.steering}`
-            : " · steer ok while turn runs";
-        return `turn active · compact blocked · ${q}${s}`;
-    }
-    if (input.compactBlockedByTurn) {
-        return "idle · drain settling · compact blocked · queue accepts";
-    }
-    if (input.queued > 0 || input.steering > 0) {
-        return `idle · queue ${input.queued} · steer ${input.steering} (steer needs an active turn)`;
-    }
-    return "idle · queue accepts · compact available when agent idle";
-}
-function liveLineText(events) {
-    for (let i = events.length - 1; i >= 0; i--) {
-        const ev = events[i];
-        if (ev.type === "assistant/chunk") {
-            if (ev.kind === "tool-call" && ev.toolName) {
-                return { tool: ev.toolName };
-            }
-            const text = ev.text?.trim();
-            if (text) {
-                return { text: text.length > 120 ? `${text.slice(0, 120)}…` : text };
-            }
-            continue;
-        }
-        if (ev.type === "tool/call") {
-            return { tool: ev.call?.name || "tool" };
-        }
-        if (ev.type === "assistant/message") {
-            const content = ev.content;
-            const text = typeof content === "string"
-                ? content
-                : Array.isArray(content)
-                    ? content
-                        .map((p) => p && typeof p === "object" && "text" in p
-                        ? String((p).text)
-                        : "")
-                        .join("")
-                    : "";
-            const trimmed = text.trim();
-            if (trimmed) {
-                return {
-                    text: trimmed.length > 120 ? `${trimmed.slice(0, 120)}…` : trimmed,
-                };
-            }
-        }
-    }
-    return {};
-}
-/**
- * Child Overview ball. A child with no roster look still gets a default
- * blob/cream (no kit) so the client does not fall back to home Settings
- * (shape / color / 装扮).
- */
-function companionBallForChild(link, stickers = []) {
-    if (!link)
-        return undefined;
-    const look = link.appearance;
-    const shape = typeof look?.shape === "string" && look.shape ? look.shape : "blob";
-    const color = typeof look?.color === "string" && look.color ? look.color : "cream";
-    return appearanceLookWire({
-        shape: shape,
-        color: color,
-        ...(typeof look?.kit === "string" && look.kit ? { kit: look.kit } : {}),
-        ...(typeof look?.kitHat === "string" && look.kitHat ? { kitHat: look.kitHat } : {}),
-        ...(typeof look?.kitGlasses === "string" && look.kitGlasses ? { kitGlasses: look.kitGlasses } : {}),
-        ...(typeof look?.kitHeld === "string" && look.kitHeld ? { kitHeld: look.kitHeld } : {}),
-        ...(look?.overlayHat || look?.face
-            ? { overlayHat: look.overlayHat ?? look.face }
-            : {}),
-        ...(look?.overlayGlasses ? { overlayGlasses: look.overlayGlasses } : {}),
-        ...(look?.overlayHeld ? { overlayHeld: look.overlayHeld } : {}),
-    }, stickers);
-}
-/**
- * Build the Status snapshot for one session.
- * Same facts feed `/status` text and Face `session.status`.
- */
-export function buildSessionStatusSnapshot(runtime, sessionId) {
-    const events = readSessionEvents(runtime.store, sessionId);
-    const badge = effectiveSessionAgentPreset(runtime, sessionId);
-    const permission = permissionSelectFromEvents(events).currentValue;
-    const plan = foldPlanMode(events) ? "on" : "off";
-    const model = resolveSessionModelSelection(runtime, sessionId);
-    const cwd = resolveSessionCwd(runtime, sessionId);
-    const jobs = (runtime.jobViewsFor(sessionId) ?? []).map(jobRow);
-    // Whole delegated subtree, not just direct children: a grandchild that is
-    // still draining must not read as "done" behind a parent that already parked
-    // after handing work down. A node counts as running while anything below it
-    // runs, and quotes the deepest live descendant's last line (an idle parent's
-    // own text would be stale).
-    //
-    // Two sources describe that tree and either can be a subset: the registry
-    // holds links in memory, the team graph is a durable sidecar that survives a
-    // stale restart or a lost write. Walk their union — activity comes from
-    // drain / external state, never from link presence, so a node the graph
-    // still lists keeps a real verdict instead of carrying no signal at all.
-    const team = runtime.agentTeams.view(sessionId);
-    const latchHeld = runtime.drain.isActive(sessionId);
-    const turnActive = latchHeld && !runtime.isTurnUiIdle(sessionId);
-    const childrenOf = new Map();
-    const addChild = (parent, node) => {
-        const bucket = childrenOf.get(parent);
-        if (bucket === undefined)
-            childrenOf.set(parent, [node]);
-        else if (!bucket.some((n) => n.id === node.id))
-            bucket.push(node);
-    };
-    for (const link of runtime.subagents.entries()) {
-        if (link.mode === "fork")
-            continue;
-        addChild(link.parentSessionId, {
-            id: link.childSessionId,
-            mode: link.mode,
-            ...(link.label ? { label: link.label } : {}),
-        });
-    }
-    for (const edge of team.edges) {
-        if (edge.kind !== "delegates")
-            continue;
-        const known = runtime.subagents.get(edge.from, edge.to);
-        const label = known?.label || edge.label;
-        addChild(edge.from, {
-            id: edge.to,
-            mode: known?.mode ?? "delegated",
-            ...(label ? { label } : {}),
-        });
-    }
-    const levels = [];
-    const seen = new Set([sessionId]);
-    let frontier = [sessionId];
-    while (frontier.length > 0) {
-        const level = [];
-        const next = [];
-        for (const id of frontier) {
-            for (const node of childrenOf.get(id) ?? []) {
-                if (seen.has(node.id))
-                    continue;
-                seen.add(node.id);
-                level.push(node);
-                next.push(node.id);
-            }
-        }
-        if (level.length === 0)
-            break;
-        levels.push(level);
-        frontier = next;
-    }
-    // `live` lists this session's own descendants, but the board is also opened
-    // on a child (one-shot preview), where the parent and its siblings sit in
-    // the same tree and still carry their own live signal. Post-order the whole
-    // tree so those nodes get a real verdict, then propagate upward: a node is
-    // running while itself or anything below it runs.
-    const activeSource = new Map();
-    const ordered = [];
-    const walked = new Set([sessionId]);
-    const walk = (id) => {
-        for (const node of childrenOf.get(id) ?? []) {
-            if (walked.has(node.id))
-                continue;
-            walked.add(node.id);
-            walk(node.id);
-        }
-        ordered.push(id);
-    };
-    walk(sessionId);
-    const childIdSet = new Set();
-    for (const bucket of childrenOf.values()) {
-        for (const node of bucket)
-            childIdSet.add(node.id);
-    }
-    for (const node of team.nodes) {
-        if (!childIdSet.has(node.id))
-            walk(node.id);
-    }
-    for (const id of ordered) {
-        if (isChildSessionActive(runtime, id))
-            activeSource.set(id, id);
-        for (const child of childrenOf.get(id) ?? []) {
-            const source = activeSource.get(child.id);
-            if (source)
-                activeSource.set(id, activeSource.get(id) ?? source);
-        }
-    }
-    const live = [];
-    for (const level of levels) {
-        for (const node of level) {
-            if (!runtime.store.has(node.id))
-                continue;
-            const childEvents = readSessionEvents(runtime.store, node.id);
-            const source = activeSource.get(node.id);
-            const activity = source ? "running" : "inactive";
-            const line = source
-                ? liveLineText(source === node.id
-                    ? childEvents
-                    : readSessionEvents(runtime.store, source))
-                : {};
-            const pending = listPendingAdmits(childEvents, node.id);
-            let queued = 0;
-            let steering = 0;
-            for (const admit of pending) {
-                if (admit.delivery === "steer")
-                    steering += 1;
-                else
-                    queued += 1;
-            }
-            const externalKind = runtime.externalAgents.kind(node.id);
-            const externalResume = runtime.externalAgents.resumeState(node.id);
-            // An external child's model belongs to its own CLI; reporting a Face
-            // route there would be a claim Face cannot back.
-            const childModel = externalKind
-                ? undefined
-                : resolveSessionModelSelection(runtime, node.id);
-            live.push({
-                id: node.id,
-                activity,
-                outcome: describeChildOutcome(childEvents),
-                mode: node.mode,
-                ...(childModel ? { model: `${childModel.provider}/${childModel.model}` } : {}),
-                ...(node.label ? { label: node.label } : {}),
-                ...(line.text ? { liveText: line.text } : {}),
-                ...(line.tool ? { liveTool: line.tool } : {}),
-                ...(queued > 0 ? { queued } : {}),
-                ...(steering > 0 ? { steering } : {}),
-                ...(externalKind ? { externalKind } : {}),
-                ...(externalResume ? { externalResume } : {}),
-            });
-        }
-    }
-    // Concurrency caps stay direct-child scoped — they gate this session's slots.
-    const quota = resolveSubagentQuota(runtime, sessionId);
-    const graph = {
-        nodes: team.nodes.map((n) => {
-            // Every node carries a verdict. The current session's own turn counts,
-            // and so does any descendant still draining — a parked parent waiting
-            // on a live child must not render as the client's "inactive → 已完成"
-            // fallback.
-            const running = (n.id === sessionId && turnActive) || activeSource.has(n.id);
-            return {
-                id: n.id,
-                label: n.label,
-                ...(n.role ? { role: n.role } : {}),
-                ...(n.depth !== undefined ? { depth: n.depth } : {}),
-                activity: running ? "running" : "inactive",
-            };
-        }),
-        edges: team.edges.map((e) => ({
-            from: e.from,
-            to: e.to,
-            kind: e.kind,
-            ...(e.label ? { label: e.label } : {}),
-        })),
-    };
-    const teamTasks = runtime.agentTeamTasks
-        .list(sessionId)
-        .slice(0, 24)
-        .map((t) => teamTaskRow(t, runtime));
-    const snap = runtime.projections.snapshot(sessionId);
-    const costRaw = snap.values.costUsage;
-    const cost = costFromProjection(costRaw);
-    const billing = billingFromLedger();
-    const tlRaw = snap.values.contextTimeline;
-    const current = tlRaw?.current;
-    const eventSummary = summarizeTimelineEvents(tlRaw?.events);
-    const timeline = {
-        total: current?.total ?? 0,
-        system: current?.system ?? 0,
-        tools: current?.tools ?? 0,
-        user: current?.user ?? 0,
-        inject: current?.inject ?? 0,
-        assistant: current?.assistant ?? 0,
-        tool: current?.tool ?? 0,
-        requestCount: tlRaw?.requests?.length ?? 0,
-        eventCount: tlRaw?.events?.length ?? 0,
-        ...(tlRaw?.model ? { model: tlRaw.model } : {}),
-        ...(tlRaw?.provider ? { provider: tlRaw.provider } : {}),
-        ...(tlRaw?.contextWindow !== undefined
-            ? { contextWindow: tlRaw.contextWindow }
-            : {}),
-        injectSources: eventSummary.injectSources,
-        ...(eventSummary.lastCompactReason
-            ? { lastCompactReason: eventSummary.lastCompactReason }
-            : {}),
-        ...(eventSummary.lastShadowedTokens !== undefined
-            ? { lastShadowedTokens: eventSummary.lastShadowedTokens }
-            : {}),
-        spillCount: eventSummary.spillCount,
-        pruneCount: eventSummary.pruneCount,
-    };
-    const pending = listPendingAdmits(events, sessionId);
-    let queued = 0;
-    let steering = 0;
-    for (const admit of pending) {
-        if (admit.delivery === "steer")
-            steering += 1;
-        else
-            queued += 1;
-    }
-    const loopValue = runtime.settingsNamespaces.view("agent-loop").value;
-    const strategyRaw = String(loopValue.compactionStrategy ?? "").trim();
-    const strategy = strategyRaw === "prune-summary" ||
-        strategyRaw === "prune-only" ||
-        strategyRaw === "summary-only" ||
-        strategyRaw === "off"
-        ? strategyRaw
-        : "prune-summary";
-    const compaction = {
-        pipeline: eventSummary.pipeline,
-        stages: eventSummary.stages,
-        strategy,
-        ...(eventSummary.lastCompactReason
-            ? { lastReason: eventSummary.lastCompactReason }
-            : {}),
-        ...(eventSummary.lastShadowedTokens !== undefined
-            ? { lastShadowedTokens: eventSummary.lastShadowedTokens }
-            : {}),
-        pruneCount: eventSummary.pruneCount,
-        summaryCount: eventSummary.summaryCount,
-        spillCount: eventSummary.spillCount,
-        ...(eventSummary.spillPaths.length > 0
-            ? { spillPaths: eventSummary.spillPaths }
-            : {}),
-        phase: turnActive ? "busy" : "idle",
-    };
-    const delivery = {
-        turnActive,
-        queued,
-        steering,
-        compactBlockedByTurn: latchHeld,
-        queueAcceptedWhileBusy: true,
-        steerRequiresActiveTurn: true,
-        note: deliveryNote({
-            turnActive,
-            compactBlockedByTurn: latchHeld,
-            queued,
-            steering,
-        }),
-    };
-    const discover = buildFaceChannelDiscover(runtime.plugins, {
-        imGatewayWired: resolveImGatewayWired(),
-    });
-    const channelAlertRows = channelAlertsFromDiscover({
-        process: discover.process,
-        im: discover.im,
-        note: discover.note,
-        imGatewayWired: discover.imGatewayWired,
-    });
-    const channels = {
-        process: discover.process.map((p) => ({
-            pluginId: p.pluginId,
-            channelId: p.channelId,
-            ...(p.displayName ? { displayName: p.displayName } : {}),
-        })),
-        im: discover.im.map((c) => ({
-            channelId: c.channelId,
-            displayName: c.displayName,
-            wired: c.wired,
-        })),
-        note: discover.note,
-        alerts: channelAlertRows,
-    };
-    const fleet = buildFleet({
-        jobs,
-        live,
-        quota,
-        channelAlerts: channelAlertRows,
-        turnActive,
-    });
-    const mem = runtime.curatedMemoryConsolidate;
-    const curatedMemory = mem
-        ? {
-            sessionId: mem.sessionId,
-            at: mem.at,
-            phase1Written: mem.phase1Written,
-            phase2: mem.phase2,
-            phase2Written: mem.phase2Written,
-            ...(mem.skipped ? { skipped: mem.skipped } : {}),
-            ...(mem.providerKind ? { providerKind: mem.providerKind } : {}),
-        }
-        : undefined;
-    const listedPresence = (id) => {
-        const row = runtime.presence.get(id);
-        if (!row)
-            return undefined;
-        return {
-            emotionId: row.emotionId,
-            source: row.source,
-            updatedAt: row.updatedAt,
-            ...(row.tips ? { tips: row.tips } : {}),
-        };
-    };
-    const presence = listedPresence(sessionId);
-    const childLink = runtime.subagents.getByChild(sessionId);
-    const parentLink = childLink
-        ? runtime.subagents.getByChild(childLink.parentSessionId)
-        : undefined;
-    const dressing = dressingFromPresence(runtime.settingsNamespaces.view("ui-presence").value);
-    const companionBall = companionBallForChild(childLink, dressing.stickers);
-    const parentCompanionBall = companionBallForChild(parentLink, dressing.stickers);
-    const homeId = childLink?.parentSessionId ??
-        team.edges.find((e) => e.kind === "delegates" && e.to === sessionId)?.from;
-    const parentPresence = homeId ? listedPresence(homeId) : undefined;
-    const parentDelivery = homeId
-        ? (() => {
-            const parentLatch = runtime.drain.isActive(homeId);
-            const parentTurn = parentLatch && !runtime.isTurnUiIdle(homeId);
-            const parentEvents = runtime.store.has(homeId)
-                ? readSessionEvents(runtime.store, homeId)
-                : [];
-            const parentPending = listPendingAdmits(parentEvents, homeId);
-            let parentQueued = 0;
-            let parentSteering = 0;
-            for (const admit of parentPending) {
-                if (admit.delivery === "steer")
-                    parentSteering += 1;
-                else
-                    parentQueued += 1;
-            }
-            return {
-                turnActive: parentTurn,
-                queued: parentQueued,
-                steering: parentSteering,
-                runningSubs: (childrenOf.get(homeId) ?? []).filter((n) => activeSource.has(n.id)).length,
-            };
-        })()
-        : undefined;
-    const delegate = childLink
-        ? {
-            parentSessionId: childLink.parentSessionId,
-            childLabel: childLink.label,
-            ...(parentLink?.label ? { parentLabel: parentLink.label } : {}),
-        }
-        : undefined;
-    return {
-        sessionId,
-        badge,
-        permission,
-        plan,
-        theme: runtime.uiSettings.theme,
-        model: { provider: model.provider, model: model.model },
-        cwd,
-        events: sessionEventCount(runtime.store, sessionId),
-        jobs,
-        subagents: { live, graph, quota },
-        teamTasks,
-        cost,
-        billing,
-        fleet,
-        ...(presence ? { presence } : {}),
-        ...(parentPresence ? { parentPresence } : {}),
-        ...(parentDelivery ? { parentDelivery } : {}),
-        ...(companionBall ? { companionBall } : {}),
-        ...(parentCompanionBall ? { parentCompanionBall } : {}),
-        ...(delegate ? { delegate } : {}),
-        timeline,
-        compaction,
-        delivery,
-        channels,
-        ...(curatedMemory ? { curatedMemory } : {}),
-    };
-}
-/** Format the shared snapshot as `/status` command text. */
-export function formatSessionStatusText(snap) {
-    const lines = [
-        `badge: ${snap.badge}`,
-        `permission: ${formatPermissionStatusLabel(snap.permission)}`,
-        ...(snap.permission === "auto"
-            ? [
-                "auto-review classifiers: heuristic | http | session-llm (URL/env → http; Host LLM → session-llm; else heuristic)",
-            ]
-            : []),
-        `plan: ${snap.plan} (toggle with /plan · /plan off)`,
-        `theme: ${snap.theme} (/theme light|dark|system)`,
-        `model: ${snap.model.provider}/${snap.model.model}`,
-        `cwd: ${snap.cwd}`,
-        `events: ${snap.events}`,
-    ];
-    if (snap.presence) {
-        lines.push(`presence: ${snap.presence.emotionId}` +
-            (snap.presence.tips ? ` (${snap.presence.tips})` : "") +
-            ` [tool @ ${snap.presence.updatedAt}]`);
-    }
-    else {
-        lines.push("presence: (auto — Overview derives from delivery/fleet)");
-    }
-    if (snap.delegate) {
-        const from = snap.delegate.parentLabel ?? snap.delegate.parentSessionId;
-        lines.push(`delegate: ${from} → ${snap.delegate.childLabel} (${snap.delegate.parentSessionId})`);
-    }
-    const runningJobs = snap.jobs.filter((j) => j.status === "running");
-    lines.push(`jobs: ${snap.jobs.length} total` +
-        (runningJobs.length > 0 ? ` (${runningJobs.length} running)` : ""));
-    for (const job of snap.jobs.slice(0, 8)) {
-        lines.push(`  - ${job.id}${job.label ? ` (${job.label})` : ""} [${job.status}]`);
-    }
-    const runningSubs = snap.subagents.live.filter((s) => s.activity === "running");
-    const q = snap.subagents.quota;
-    const queuedSubs = snap.subagents.live.reduce((n, s) => n + (s.queued ?? 0) + (s.steering ?? 0), 0);
-    lines.push(`subagents: ${snap.subagents.live.length} delegated` +
-        (runningSubs.length > 0 ? `, ${runningSubs.length} live` : "") +
-        ` · quota depth ${q.depth}/${q.maxDepth} active ${q.active}/${q.maxActive}` +
-        ` · slots_free ${q.slotsFree}` +
-        (queuedSubs > 0 ? ` · child_inbox ${queuedSubs}` : "") +
-        `; graph ${snap.subagents.graph.nodes.length} nodes / ${snap.subagents.graph.edges.length} edges`);
-    for (const node of snap.subagents.graph.nodes.slice(0, 12)) {
-        if (node.id === snap.sessionId && snap.subagents.graph.nodes.length > 1) {
-            continue;
-        }
-        const bits = [
-            node.role ?? "node",
-            node.depth !== undefined ? `d=${node.depth}` : undefined,
-            node.activity,
-        ].filter(Boolean);
-        lines.push(`  · ${node.label}${bits.length ? ` [${bits.join(" · ")}]` : ""}`);
-    }
-    for (const sub of runningSubs.slice(0, 8)) {
-        const tip = sub.liveTool
-            ? `tool:${sub.liveTool}`
-            : sub.liveText
-                ? sub.liveText
-                : sub.mode;
-        const inbox = (sub.queued ?? 0) > 0 || (sub.steering ?? 0) > 0
-            ? ` q=${sub.queued ?? 0}/steer=${sub.steering ?? 0}`
-            : "";
-        const ext = sub.externalKind
-            ? ` · ext:${sub.externalKind}${sub.externalResume ? `/${sub.externalResume}` : ""}`
-            : "";
-        lines.push(`  - ${sub.label ?? sub.id} [${tip}]${inbox}${ext}`);
-    }
-    for (const sub of snap.subagents.live
-        .filter((s) => s.activity !== "running" &&
-        (s.externalResume === "cold" ||
-            (s.queued ?? 0) > 0 ||
-            (s.steering ?? 0) > 0 ||
-            (s.outcome !== undefined &&
-                s.outcome.kind !== "completed" &&
-                s.outcome.kind !== "none")))
-        .slice(0, 4)) {
-        const ext = sub.externalKind
-            ? ` · ext:${sub.externalKind}${sub.externalResume ? `/${sub.externalResume}` : ""}`
-            : "";
-        const verdict = sub.outcome
-            ? formatDescribedChildOutcome(sub.outcome)
-            : "idle";
-        lines.push(`  - ${sub.label ?? sub.id} [idle · ${verdict} · q=${sub.queued ?? 0}/steer=${sub.steering ?? 0}]${ext}`);
-    }
-    const openTasks = snap.teamTasks.filter((t) => t.status === "pending" ||
-        t.status === "in_progress" ||
-        t.status === "paused");
-    lines.push(`team tasks: ${snap.teamTasks.length} total` +
-        (openTasks.length > 0 ? ` (${openTasks.length} open)` : ""));
-    for (const task of snap.teamTasks.slice(0, 8)) {
-        const bits = [
-            task.status,
-            task.role ? `role:${task.role}` : null,
-            task.humanOwned ? "human" : null,
-            task.externalResume ? `ext/${task.externalResume}` : null,
-            task.childSessionId ? `child:${task.childSessionId}` : null,
-            task.worktreeBranch ? `wt:${task.worktreeBranch}` : null,
-            task.schemaValid === false
-                ? "schema!"
-                : task.schemaValid === true
-                    ? "schema_ok"
-                    : null,
-        ].filter(Boolean);
-        lines.push(`  - ${task.title} [${bits.join(" · ")}] (${task.id})`);
-        if (task.resultPreview) {
-            lines.push(`      result: ${task.resultPreview}`);
-        }
-        if (task.worktreePath) {
-            lines.push(`      worktree: ${task.worktreePath}`);
-        }
-        if (task.worktreeLeaseStatus) {
-            lines.push(`      worktree_lease: ${task.worktreeLeaseStatus}` +
-                (task.worktreeLeaseStatus === "retained"
-                    ? " (ff-only merge blocked — lease kept; Status「合回」或 Face worktree.merge)"
-                    : task.worktreeLeaseStatus === "active"
-                        ? " (Status「合回」→ Face worktree.merge)"
-                        : ""));
-        }
-    }
-    lines.push(`cost: $${snap.cost.cost.toFixed(4)} (in ${snap.cost.input} · out ${snap.cost.output}` +
-        (snap.cost.cacheRead ? ` · cacheR ${snap.cost.cacheRead}` : "") +
-        (snap.cost.reasoning ? ` · reason ${snap.cost.reasoning}` : "") +
-        ")");
-    const sessionModels = rankCostModelRows(snap.cost.byProviderModel, 6);
-    if (sessionModels.length > 0) {
-        lines.push("  by model (this session):");
-        for (const row of sessionModels) {
-            lines.push(`    - ${row.key}: $${row.cost.toFixed(4)} (in ${row.input} · out ${row.output})`);
-        }
-    }
-    lines.push(`billing: today $${snap.billing.todayCost.toFixed(4)}` +
-        ` · month $${snap.billing.monthCost.toFixed(4)}` +
-        ` · total $${snap.billing.totalCost.toFixed(4)}` +
-        ` (cross-session ledger)`);
-    if (snap.billing.dailyTrend.length > 0) {
-        const recent = snap.billing.dailyTrend.slice(-7);
-        lines.push(`  daily: ${recent.map((d) => `${d.date.slice(5)}=$${d.cost.toFixed(2)}`).join(" · ")}`);
-    }
-    if (snap.billing.byProviderModel.length > 0) {
-        lines.push("  by model (month ledger):");
-        for (const row of snap.billing.byProviderModel.slice(0, 6)) {
-            lines.push(`    - ${row.key}: $${row.cost.toFixed(4)} (in ${row.input} · out ${row.output})`);
-        }
-    }
-    lines.push(`fleet: ${snap.fleet.health}` +
-        ` · jobs ${snap.fleet.runningJobs} running` +
-        ` · subs ${snap.fleet.runningSubagents} live` +
-        ` · slots_free ${snap.fleet.slotsFree}` +
-        (snap.fleet.queuedInbox > 0 ? ` · inbox ${snap.fleet.queuedInbox}` : "") +
-        (snap.fleet.channelAlerts > 0
-            ? ` · channel_alerts ${snap.fleet.channelAlerts}`
-            : ""));
-    for (const alert of snap.fleet.alerts.slice(0, 6)) {
-        lines.push(`  - [${alert.severity}] ${alert.message}`);
-    }
-    lines.push(`timeline: total ${snap.timeline.total}` +
-        ` (sys ${snap.timeline.system} · tools ${snap.timeline.tools}` +
-        ` · user ${snap.timeline.user} · inject ${snap.timeline.inject}` +
-        ` · asst ${snap.timeline.assistant} · tool ${snap.timeline.tool})` +
-        `; ${snap.timeline.requestCount} requests · ${snap.timeline.eventCount} ctx events`);
-    if (snap.timeline.injectSources.length > 0) {
-        lines.push(`  inject sources: ${snap.timeline.injectSources.slice(0, 8).join(", ")}` +
-            (snap.timeline.injectSources.length > 8
-                ? ` (+${snap.timeline.injectSources.length - 8})`
-                : ""));
-    }
-    if (snap.timeline.lastCompactReason) {
-        lines.push(`  last compact: ${snap.timeline.lastCompactReason}` +
-            (snap.timeline.lastShadowedTokens !== undefined
-                ? ` · shadowed ${snap.timeline.lastShadowedTokens}`
-                : ""));
-    }
-    if (snap.timeline.pruneCount > 0 || snap.timeline.spillCount > 0) {
-        lines.push(`  prune: ${snap.timeline.pruneCount} · spill: ${snap.timeline.spillCount}`);
-    }
-    const stageLabel = snap.compaction.stages.length > 0
-        ? snap.compaction.stages.join("→")
-        : snap.compaction.pipeline;
-    lines.push(`compaction: ${snap.compaction.phase}` +
-        ` · pipeline ${stageLabel}` +
-        (snap.compaction.strategy
-            ? ` · strategy ${snap.compaction.strategy}`
-            : "") +
-        (snap.compaction.lastReason
-            ? ` · last ${snap.compaction.lastReason}`
-            : "") +
-        (snap.compaction.lastShadowedTokens !== undefined
-            ? ` · shadowed ${snap.compaction.lastShadowedTokens}`
-            : "") +
-        ` · prune ${snap.compaction.pruneCount}` +
-        ` · summary ${snap.compaction.summaryCount}` +
-        (snap.compaction.spillCount > 0
-            ? ` · spill ${snap.compaction.spillCount}`
-            : ""));
-    if (snap.compaction.spillPaths && snap.compaction.spillPaths.length > 0) {
-        for (const entry of snap.compaction.spillPaths.slice(-6)) {
-            const bits = [
-                entry.name,
-                entry.tool ? `tool:${entry.tool}` : null,
-                entry.bytes !== undefined ? `${entry.bytes}B` : null,
-            ].filter(Boolean);
-            lines.push(`  spill: ${bits.join(" · ")} · ${entry.path}`);
-            if (entry.preview) {
-                const oneLine = entry.preview.replace(/\s+/g, " ").slice(0, 120);
-                lines.push(`      preview: ${oneLine}`);
-            }
-        }
-    }
-    lines.push(`delivery: ${snap.delivery.note}` +
-        ` · queued ${snap.delivery.queued}` +
-        ` · steering ${snap.delivery.steering}` +
-        (snap.delivery.compactBlockedByTurn ? " · compact↔turn exclusive" : ""));
-    if (snap.curatedMemory) {
-        const m = snap.curatedMemory;
-        lines.push(`curated-memory: phase1 +${m.phase1Written}` +
-            ` · phase2 ${m.phase2}` +
-            (m.phase2Written > 0 ? ` +${m.phase2Written}` : "") +
-            (m.skipped ? ` · skipped ${m.skipped}` : "") +
-            (m.providerKind ? ` · provider ${m.providerKind}` : "") +
-            ` · at ${new Date(m.at).toISOString()}`);
-    }
-    const wiredIm = snap.channels.im.filter((c) => c.wired !== "bridge" && c.wired !== "discover");
-    lines.push(`channels: ${snap.channels.process.length} process` +
-        ` · ${snap.channels.im.length} im discover` +
-        (wiredIm.length > 0
-            ? ` (native-wired: ${wiredIm.map((c) => `${c.channelId}=${c.wired}`).join(", ")})`
-            : " (stubs · Host gateway via env)"));
-    if (snap.channels.note.trim()) {
-        lines.push(`  note:${snap.channels.note.trim()}`);
-    }
-    return lines.join("\n");
-}
-//# sourceMappingURL=session-status.js.map