@korso/shepherd-ui 0.2.0 → 0.2.2

package/dist/test/setup.d.ts

@@ -1 +0,0 @@
-import "@testing-library/jest-dom/vitest";

package/dist/test/setup.js

@@ -1,2 +0,0 @@
-// Testing Library matchers (toBeInTheDocument, etc.) for the jsdom lane.
-import "@testing-library/jest-dom/vitest";

package/dist/views/Chat.d.ts

@@ -1,5 +0,0 @@
-export interface ChatProps {
-    /** The workspace whose chat to render. Selected by the shell. */
-    workspaceId: string;
-}
-export declare function Chat({ workspaceId }: ChatProps): import("react").JSX.Element;

package/dist/views/Chat.js

@@ -1,60 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// Chat view — the team chat ported from packages/hub/public (app.js): the
-// announcement feed (oldest→newest, top→bottom) plus a composer. Reads the feed
-// from client.landscape(workspaceId) (same 5s poll as Tasks, via useLandscape)
-// and posts through client.announce, then refreshes immediately. A typed
-// @mention matching a live agent directs the message as a DM, mirroring app.js's
-// send behavior; the autocomplete POPUP UI is intentionally not ported (visual
-// polish, deferred). Task 6.3 fixed the prop signature ({ workspaceId }).
-import { useMemo, useState } from "react";
-import { useShepherdClient } from "../ShepherdProvider.js";
-import { useLandscape } from "./useLandscape.js";
-import { describeError } from "../client.js";
-import { formatRelative, initialsFor, colorForName, extractTarget } from "./wallboard.js";
-/** One message row: avatar + sender + optional target + time + body. */
-function Message({ a, nowMs }) {
-    const cls = "msg" +
-        (a.targetAgentName || a.toAdmin ? " msg--targeted" : "") +
-        (a.fromAdmin ? " msg--me" : "");
-    return (_jsxs("div", { className: cls, children: [_jsx("div", { className: "msg__avatar", style: { background: colorForName(a.fromAgentName) }, children: initialsFor(a.fromAgentName) }), _jsxs("div", { className: "msg__body", children: [_jsxs("div", { className: "msg__head", children: [_jsx("span", { className: "msg__who", style: { color: colorForName(a.fromAgentName) }, children: a.fromAgentName }), a.fromHuman && _jsx("span", { className: "msg__human", children: a.fromHuman }), a.targetAgentName ? (_jsx("span", { className: "msg__to", children: `→ @${a.targetAgentName}` })) : a.toAdmin ? (_jsx("span", { className: "msg__to", children: "\u2192 admin" })) : null, _jsx("span", { className: "msg__time", children: formatRelative(a.createdAt, nowMs) })] }), _jsx("div", { className: "msg__text", children: a.body })] })] }));
-}
-export function Chat({ workspaceId }) {
-    const client = useShepherdClient();
-    const { data, error, loading, refresh } = useLandscape(workspaceId);
-    const [draft, setDraft] = useState("");
-    const [sending, setSending] = useState(false);
-    const [sendError, setSendError] = useState(null);
-    const nowMs = data ? Date.parse(data.serverTime) : Date.now();
-    // Memoised on `data` so they don't recompute on every composer keystroke
-    // (each `draft` change re-renders this component).
-    // The API returns newest-first; a chat reads oldest→newest, top→bottom.
-    const messages = useMemo(() => (data ? [...data.announcements].reverse() : []), [data]);
-    // Live agents are addressable by @mention (the canonical names extractTarget
-    // resolves against), matching app.js's mention pool.
-    const liveNames = useMemo(() => (data?.agents ?? [])
-        .filter((agent) => agent.presence === "live")
-        .map((agent) => agent.name), [data]);
-    async function send(e) {
-        e.preventDefault();
-        const body = draft.trim();
-        if (!body || sending)
-            return;
-        // The first @mention matching a live agent directs the message; otherwise it
-        // broadcasts (no repo scoping here — the repo selector was not ported).
-        const targetAgentName = extractTarget(body, liveNames);
-        setSending(true);
-        setSendError(null);
-        try {
-            await client.announce(workspaceId, { body, targetAgentName });
-            setDraft("");
-            await refresh(); // reflect the just-sent message without waiting for the tick
-        }
-        catch (err) {
-            setSendError(describeError(err));
-        }
-        finally {
-            setSending(false);
-        }
-    }
-    return (_jsxs("section", { "aria-labelledby": "chat-heading", children: [_jsx("h2", { id: "chat-heading", children: "Chat" }), error && (_jsx("p", { role: "alert", className: "status status--error", children: `Couldn't refresh the chat — reconnecting… (${error})` })), _jsxs("div", { className: "chat-wrap", children: [_jsx("div", { className: "chat", id: "chat", children: loading && !data ? (_jsx("div", { className: "empty", children: "Loading\u2026" })) : messages.length === 0 ? (_jsx("div", { className: "empty", children: "No announcements yet \u2014 agents will post here as they coordinate." })) : (messages.map((a) => (_jsx(Message, { a: a, nowMs: nowMs }, `${a.fromAgentName}|${a.createdAt}|${a.body}`)))) }), _jsxs("div", { className: "composer", children: [_jsxs("form", { className: "chat-form", onSubmit: send, children: [_jsx("input", { className: "chat-input", type: "text", autoComplete: "off", "aria-label": "Message the team", placeholder: "Message the team\u2026 use @name to direct it", value: draft, onChange: (e) => setDraft(e.target.value) }), _jsx("button", { className: "chat-send", type: "submit", disabled: sending || !draft.trim(), children: "Send" })] }), sendError && (_jsx("p", { role: "alert", className: "status status--error", children: sendError }))] })] })] }));
-}

package/dist/views/Chat.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/views/Chat.test.js

@@ -1,92 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, screen, waitFor } from "@testing-library/react";
-import { userEvent } from "@testing-library/user-event";
-import { ShepherdProvider } from "../ShepherdProvider.js";
-import { Chat } from "./Chat.js";
-import { makeMockClient } from "../test/mockClient.js";
-// ---------------------------------------------------------------------------
-// Chat — the ported team chat (announcement feed + composer). Reads the feed
-// from client.landscape(workspaceId), posts via client.announce. DB-free.
-// ---------------------------------------------------------------------------
-const WORKSPACE_ID = "ws_1";
-function landscape(over = {}) {
-    return {
-        serverTime: "2026-06-29T01:00:00.000Z",
-        agents: [],
-        tasks: [],
-        announcements: [],
-        ...over,
-    };
-}
-describe("Chat", () => {
-    let client;
-    beforeEach(() => {
-        client = makeMockClient();
-    });
-    function renderChat() {
-        return render(_jsx(ShepherdProvider, { client: client, children: _jsx(Chat, { workspaceId: WORKSPACE_ID }) }));
-    }
-    it("renders announcements from the landscape feed", async () => {
-        client.landscape = vi.fn().mockResolvedValue(landscape({
-            announcements: [
-                {
-                    fromAgentName: "RedDragon",
-                    fromHuman: "daichi",
-                    body: "shipping the parser fix",
-                    targetAgentName: null,
-                    repo: "acme/web",
-                    fromAdmin: false,
-                    toAdmin: false,
-                    createdAt: "2026-06-29T00:50:00.000Z",
-                },
-            ],
-        }));
-        renderChat();
-        await waitFor(() => expect(client.landscape).toHaveBeenCalledWith(WORKSPACE_ID));
-        await waitFor(() => expect(screen.getByText("shipping the parser fix")).toBeInTheDocument());
-        expect(screen.getByText("RedDragon")).toBeInTheDocument();
-    });
-    it("posts a composed message via announce, then refreshes the feed", async () => {
-        client.landscape = vi.fn().mockResolvedValue(landscape());
-        client.announce = vi.fn().mockResolvedValue({ ok: true, announcementIds: ["a_1"] });
-        renderChat();
-        await waitFor(() => expect(client.landscape).toHaveBeenCalledTimes(1));
-        await userEvent.type(screen.getByRole("textbox"), "hello team");
-        await userEvent.click(screen.getByRole("button", { name: /send/i }));
-        await waitFor(() => expect(client.announce).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({ body: "hello team" })));
-        // Refresh after send: landscape re-fetched.
-        await waitFor(() => expect(client.landscape.mock.calls.length).toBeGreaterThan(1));
-    });
-    it("directs the message to the first @mention matching a live agent", async () => {
-        client.landscape = vi.fn().mockResolvedValue(landscape({
-            agents: [
-                {
-                    name: "RedDragon",
-                    human: "daichi",
-                    program: "claude",
-                    model: "opus",
-                    repo: "acme/web",
-                    branch: "main",
-                    lastHeartbeatAt: "2026-06-29T00:59:00.000Z",
-                    presence: "live",
-                },
-            ],
-        }));
-        client.announce = vi.fn().mockResolvedValue({ ok: true, announcementIds: ["a_1"] });
-        renderChat();
-        await waitFor(() => expect(client.landscape).toHaveBeenCalled());
-        await userEvent.type(screen.getByRole("textbox"), "@reddragon ping");
-        await userEvent.click(screen.getByRole("button", { name: /send/i }));
-        await waitFor(() => expect(client.announce).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({ body: "@reddragon ping", targetAgentName: "RedDragon" })));
-    });
-    it("renders a non-crashing error state when landscape fails", async () => {
-        client.landscape = vi.fn().mockRejectedValue(new Error("boom"));
-        renderChat();
-        await waitFor(() => expect(screen.getByRole("alert")).toBeInTheDocument());
-        expect(screen.getByRole("heading", { name: /chat/i })).toBeInTheDocument();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-});

package/dist/views/Config.d.ts

@@ -1,12 +0,0 @@
-import type { WorkspaceSummaryT } from "@shepherd/shared";
-export interface ConfigProps {
-    workspaces: WorkspaceSummaryT[];
-    selected: WorkspaceSummaryT | null;
-    /** The DIRECT Hub URL embedded in the agent install command (decision #2). */
-    hubUrl?: string;
-    /** Refetch the workspace list after a create/join. */
-    onChanged: () => void;
-    /** Switch the active workspace. */
-    onSelect?: (workspaceId: string) => void;
-}
-export declare function Config({ workspaces, selected, hubUrl, onChanged, onSelect }: ConfigProps): import("react").JSX.Element;

package/dist/views/Config.js

@@ -1,6 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { ConnectAgent } from "../config/ConnectAgent.js";
-import { Workspaces } from "../config/Workspaces.js";
-export function Config({ workspaces, selected, hubUrl, onChanged, onSelect }) {
-    return (_jsxs("section", { "aria-labelledby": "config-heading", children: [_jsx("h2", { id: "config-heading", children: "Config" }), _jsx(Workspaces, { workspaces: workspaces, selected: selected, onChanged: onChanged, onSelect: onSelect }), selected && _jsx(ConnectAgent, { workspaceId: selected.id, hubUrl: hubUrl })] }));
-}

package/dist/views/Tasks.d.ts

@@ -1,5 +0,0 @@
-export interface TasksProps {
-    /** The workspace whose wallboard to render. Selected by the shell. */
-    workspaceId: string;
-}
-export declare function Tasks({ workspaceId }: TasksProps): import("react").JSX.Element;

package/dist/views/Tasks.js

@@ -1,75 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-// Tasks view — the wallboard ported from packages/hub/public (app.js): a crew
-// strip of live agents + two columns, Active (grouped live claims) and Done
-// (finished/dropped history). Driven by client.landscape(workspaceId) on mount
-// and on a 5s poll via useLandscape. Functional parity with the old page; visual
-// polish is deferred. Task 6.3 fixed the prop signature ({ workspaceId }); this
-// fills the body without changing it.
-import { useMemo } from "react";
-import { useLandscape } from "./useLandscape.js";
-import { formatRelative, statusLabel, formatActiveDuration, dayBucket, initialsFor, colorForName, groupActiveClaims, } from "./wallboard.js";
-/** Avatar bubble: two initials on the name's deterministic hue (as in app.js). */
-function Avatar({ name, className }) {
-    return (_jsx("div", { className: className, style: { background: colorForName(name) }, children: initialsFor(name) }));
-}
-/** A claim's body: intent + territory globs + a meta line (started/finished). */
-function ClaimBody({ task, meta }) {
-    return (_jsxs(_Fragment, { children: [_jsx("div", { className: "task__intent", children: task.intent }), _jsxs("div", { className: "terr", children: [_jsx("span", { className: "terr__lbl", children: "territory" }), task.pathGlobs.map((g) => (_jsx("span", { className: "glob", children: g }, g)))] }), _jsx("div", { className: "task__meta", children: meta })] }));
-}
-/** A lone agent/claim — the classic single card. */
-function PlainCard({ task, nowMs }) {
-    return (_jsxs("div", { className: "task", children: [_jsxs("div", { className: "task__r1", children: [_jsx("span", { className: "task__who", children: task.agentName }), (task.model || task.program) && (_jsx("span", { className: "task__tag", children: task.model || task.program })), _jsx("span", { className: "livedot", title: "active" })] }), _jsx(ClaimBody, { task: task, meta: `started ${formatRelative(task.createdAt, nowMs)}` })] }));
-}
-/** An agent with multiple live claims: header + primaries + folded narrower set. */
-function GroupCard({ group, nowMs }) {
-    const count = group.primaries.length + group.narrower.length;
-    return (_jsxs("div", { className: "grp", children: [_jsxs("div", { className: "grp__head", children: [_jsx("span", { className: "grp__who", children: group.agentName }), (group.model || group.program) && (_jsx("span", { className: "grp__tag", children: group.model || group.program })), _jsx("span", { className: "grp__count", children: `· ${count} active` }), _jsx("span", { className: "grp__dot", title: "live" })] }), _jsx("div", { className: "claims", children: group.primaries.map((c) => (_jsx("div", { className: "claim", children: _jsx(ClaimBody, { task: c, meta: `started ${formatRelative(c.createdAt, nowMs)}` }) }, `${c.agentName}|${c.repo}|${c.createdAt}`))) }), group.narrower.length > 0 && (_jsxs("details", { className: "fold", children: [_jsx("summary", { children: `+${group.narrower.length} narrower claim${group.narrower.length > 1 ? "s" : ""}` }), _jsx("div", { className: "fold__body", children: group.narrower.map((c) => (_jsxs("div", { className: "claim", children: [_jsx(ClaimBody, { task: c, meta: `started ${formatRelative(c.createdAt, nowMs)}` }), _jsx("div", { className: "covered", children: "\u2282 covered by a claim above" })] }, `${c.agentName}|${c.repo}|${c.createdAt}`))) })] }))] }));
-}
-/** Crew strip: live agents, those with an active claim first, then alphabetical. */
-function Crew({ agents, tasks }) {
-    const live = agents.filter((a) => a.presence === "live");
-    const active = new Set(tasks.filter((t) => t.status === "active").map((t) => t.agentName));
-    const ordered = [...live].sort((x, y) => {
-        const ax = active.has(x.name), ay = active.has(y.name);
-        if (ax !== ay)
-            return ax ? -1 : 1;
-        return x.name.localeCompare(y.name);
-    });
-    return (_jsx("div", { className: "crew", children: ordered.map((a) => (_jsxs("div", { className: "person" + (active.has(a.name) ? "" : " person--idle"), children: [_jsx(Avatar, { name: a.name, className: "avatar" }), _jsx("span", { className: "person__name", children: a.name })] }, a.name))) }));
-}
-export function Tasks({ workspaceId }) {
-    const { data, error, loading } = useLandscape(workspaceId);
-    const nowMs = data ? Date.parse(data.serverTime) : Date.now();
-    const tasks = data?.tasks ?? [];
-    const agents = data?.agents ?? [];
-    const active = tasks.filter((t) => t.status === "active");
-    const done = tasks.filter((t) => t.status !== "active");
-    // Grouping is the only non-trivial derivation here; memoise it on `data` (the
-    // sole source of `tasks`) so it recomputes only when the snapshot changes,
-    // not on unrelated re-renders.
-    const groups = useMemo(() => groupActiveClaims((data?.tasks ?? []).filter((t) => t.status === "active")), [data]);
-    return (_jsxs("section", { "aria-labelledby": "tasks-heading", children: [_jsx("h2", { id: "tasks-heading", children: "Tasks" }), _jsx("span", { "data-testid": "tasks-workspace-id", hidden: true, children: workspaceId }), error && (_jsx("p", { role: "alert", className: "status status--error", children: `Couldn't refresh the workspace — reconnecting… (${error})` })), loading && !data ? (_jsx("p", { className: "empty", children: "Loading\u2026" })) : (_jsxs(_Fragment, { children: [_jsx(Crew, { agents: agents, tasks: tasks }), _jsxs("div", { className: "board", children: [_jsxs("div", { className: "col", children: [_jsxs("div", { className: "colhead", children: [_jsx("h3", { children: "Active" }), _jsx("span", { className: "n", children: active.length })] }), _jsx("div", { id: "active-list", children: active.length === 0 ? (_jsx("div", { className: "empty", children: "Nothing active right now." })) : (groups.map((g) => {
-                                            const single = g.primaries.length === 1 && g.narrower.length === 0;
-                                            const key = `${g.agentName}|${g.repo}`;
-                                            return single ? (_jsx(PlainCard, { task: g.primaries[0], nowMs: nowMs }, key)) : (_jsx(GroupCard, { group: g, nowMs: nowMs }, key));
-                                        })) })] }), _jsxs("div", { className: "col", children: [_jsxs("div", { className: "colhead", children: [_jsx("h3", { children: "Done" }), _jsx("span", { className: "n", children: done.length })] }), _jsx("div", { id: "done-list", children: done.length === 0 ? (_jsx("div", { className: "empty", children: "No finished tasks yet." })) : (_jsx(DoneList, { tasks: done, nowMs: nowMs })) })] })] })] }))] }));
-}
-/** The Done column with day buckets + per-row status chip and meta, as in app.js. */
-function DoneList({ tasks, nowMs }) {
-    let lastDay = null;
-    const rows = [];
-    for (const t of tasks) {
-        const day = dayBucket(t.endedAt || t.createdAt, nowMs);
-        if (day !== lastDay) {
-            rows.push(_jsx("div", { className: "day", children: day }, `day|${day}|${t.createdAt}`));
-            lastDay = day;
-        }
-        const meta = t.status === "dropped"
-            ? `went offline ${formatRelative(t.endedAt ?? t.createdAt, nowMs)} — no done signal`
-            : `finished ${formatRelative(t.endedAt ?? t.createdAt, nowMs)}${formatActiveDuration(t.createdAt, t.endedAt)
-                ? " · " + formatActiveDuration(t.createdAt, t.endedAt)
-                : ""}`;
-        rows.push(_jsxs("div", { className: "task", children: [_jsxs("div", { className: "task__r1", children: [_jsx("span", { className: "task__who", children: t.agentName }), _jsx("span", { className: "task__stat" + (t.status === "dropped" ? " task__stat--drop" : ""), children: statusLabel(t.status) })] }), _jsx(ClaimBody, { task: t, meta: meta })] }, `${t.agentName}|${t.repo}|${t.createdAt}`));
-    }
-    return _jsx(_Fragment, { children: rows });
-}

package/dist/views/Tasks.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/views/Tasks.test.js

@@ -1,115 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, screen, waitFor, act } from "@testing-library/react";
-import { ShepherdProvider } from "../ShepherdProvider.js";
-import { Tasks } from "./Tasks.js";
-import { makeMockClient } from "../test/mockClient.js";
-// ---------------------------------------------------------------------------
-// Tasks — the ported wallboard (crew strip + Active/Done columns), driven by
-// client.landscape(workspaceId) on mount and on a 5s poll. DB-free.
-// ---------------------------------------------------------------------------
-const WORKSPACE_ID = "ws_1";
-function landscape(over = {}) {
-    return {
-        serverTime: "2026-06-29T01:00:00.000Z",
-        agents: [],
-        tasks: [],
-        announcements: [],
-        ...over,
-    };
-}
-describe("Tasks", () => {
-    let client;
-    beforeEach(() => {
-        client = makeMockClient();
-    });
-    function renderTasks() {
-        return render(_jsx(ShepherdProvider, { client: client, children: _jsx(Tasks, { workspaceId: WORKSPACE_ID }) }));
-    }
-    it("calls landscape(workspaceId) on mount and renders agents, claims, and history", async () => {
-        client.landscape = vi.fn().mockResolvedValue(landscape({
-            agents: [
-                {
-                    name: "RedDragon",
-                    human: "daichi",
-                    program: "claude",
-                    model: "opus",
-                    repo: "acme/web",
-                    branch: "main",
-                    lastHeartbeatAt: "2026-06-29T00:59:00.000Z",
-                    presence: "live",
-                },
-            ],
-            tasks: [
-                {
-                    agentName: "RedDragon",
-                    program: "claude",
-                    model: "opus",
-                    repo: "acme/web",
-                    intent: "refactor the parser",
-                    pathGlobs: ["src/parser/**"],
-                    status: "active",
-                    createdAt: "2026-06-29T00:30:00.000Z",
-                    endedAt: null,
-                },
-                {
-                    agentName: "BlueWolf",
-                    program: "codex",
-                    model: null,
-                    repo: "acme/web",
-                    intent: "fixed the build",
-                    pathGlobs: ["build/**"],
-                    status: "done",
-                    createdAt: "2026-06-29T00:00:00.000Z",
-                    endedAt: "2026-06-29T00:20:00.000Z",
-                },
-            ],
-        }));
-        renderTasks();
-        await waitFor(() => expect(client.landscape).toHaveBeenCalledWith(WORKSPACE_ID));
-        // Live agent's name appears (crew strip + the active claim card).
-        await waitFor(() => expect(screen.getAllByText("RedDragon").length).toBeGreaterThan(0));
-        // Active claim's intent.
-        expect(screen.getByText("refactor the parser")).toBeInTheDocument();
-        expect(screen.getByText("src/parser/**")).toBeInTheDocument();
-        // Done/history entry.
-        expect(screen.getByText("fixed the build")).toBeInTheDocument();
-        expect(screen.getByText("done")).toBeInTheDocument();
-    });
-    it("re-polls landscape on the interval and stops after unmount", async () => {
-        vi.useFakeTimers();
-        try {
-            client.landscape = vi.fn().mockResolvedValue(landscape());
-            let unmount = () => { };
-            await act(async () => {
-                ({ unmount } = renderTasks());
-            });
-            // Initial mount fetch.
-            expect(client.landscape).toHaveBeenCalledTimes(1);
-            // Advance one poll interval (5s) → a second fetch.
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(5000);
-            });
-            expect(client.landscape).toHaveBeenCalledTimes(2);
-            // Unmount clears the interval: no further calls.
-            unmount();
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(15000);
-            });
-            expect(client.landscape).toHaveBeenCalledTimes(2);
-        }
-        finally {
-            vi.useRealTimers();
-        }
-    });
-    it("renders a non-crashing error state when landscape fails", async () => {
-        client.landscape = vi.fn().mockRejectedValue(new Error("boom"));
-        renderTasks();
-        await waitFor(() => expect(screen.getByRole("alert")).toBeInTheDocument());
-        // The heading still renders — the view did not crash.
-        expect(screen.getByRole("heading", { name: /tasks/i })).toBeInTheDocument();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-});

package/dist/views/useLandscape.d.ts

@@ -1,14 +0,0 @@
-import type { WorkspaceLandscapeResponseT } from "@shepherd/shared";
-/** The wallboard poll cadence, matching app.js's POLL_MS. */
-export declare const POLL_MS = 5000;
-export interface LandscapeState {
-    /** Last good snapshot, or null before the first successful load. */
-    data: WorkspaceLandscapeResponseT | null;
-    /** A non-fatal error message from the most recent failed fetch, else null. */
-    error: string | null;
-    /** True until the first fetch settles (success or failure). */
-    loading: boolean;
-    /** Re-pull immediately (used after a mutation). Resolves when the fetch settles. */
-    refresh: () => Promise<void>;
-}
-export declare function useLandscape(workspaceId: string): LandscapeState;

package/dist/views/useLandscape.js

@@ -1,74 +0,0 @@
-import { useEffect, useRef, useState, useCallback } from "react";
-import { useShepherdClient } from "../ShepherdProvider.js";
-import { describeError } from "../client.js";
-// ---------------------------------------------------------------------------
-// useLandscape — the shared poll loop behind both Tasks and Chat. Mirrors the
-// old app.js `poll()` cadence (5s) and its "keep the last good snapshot on a
-// transient failure" behavior: a failed fetch surfaces `error` but leaves the
-// previous `data` on screen, so the board doesn't blank out while reconnecting.
-//
-// Lifecycle safety (the 6.3 review flagged the absence of guards as a footgun):
-//   - a `cancelled` ref gates every setState so a fetch that resolves after the
-//     view unmounts (or after workspaceId changes) is dropped,
-//   - the interval is cleared on unmount AND re-established when workspaceId
-//     changes (it's in the effect deps),
-//   - `refresh()` lets a mutation (e.g. Chat's announce) re-pull immediately
-//     without waiting for the next tick — the same as app.js awaiting poll().
-// ---------------------------------------------------------------------------
-/** The wallboard poll cadence, matching app.js's POLL_MS. */
-export const POLL_MS = 5000;
-export function useLandscape(workspaceId) {
-    const client = useShepherdClient();
-    const [data, setData] = useState(null);
-    const [error, setError] = useState(null);
-    const [loading, setLoading] = useState(true);
-    // Guards setState after unmount / workspace change. A ref (not state) so the
-    // async fetch closure reads the live value, not the value at fetch-start.
-    const cancelled = useRef(false);
-    // Stable across renders so the poll effect doesn't re-subscribe each tick.
-    // Reads `workspaceId`/`client` via the deps; `cancelled` via the live ref.
-    const load = useCallback(async () => {
-        try {
-            const snapshot = await client.landscape(workspaceId);
-            if (cancelled.current)
-                return;
-            setData(snapshot);
-            setError(null);
-        }
-        catch (err) {
-            if (cancelled.current)
-                return;
-            // Keep the last good snapshot on screen; just note the failure.
-            setError(describeError(err));
-        }
-        finally {
-            if (!cancelled.current)
-                setLoading(false);
-        }
-    }, [client, workspaceId]);
-    useEffect(() => {
-        cancelled.current = false;
-        setLoading(true);
-        void load();
-        // Skip the periodic fetch while the tab is hidden — a backgrounded wallboard
-        // doesn't need to poll. We resume below on `visibilitychange`.
-        const id = setInterval(() => {
-            if (document.visibilityState === "hidden")
-                return;
-            void load();
-        }, POLL_MS);
-        // On returning to a visible tab, re-pull immediately so the board catches up
-        // without waiting for the next tick.
-        const onVisible = () => {
-            if (document.visibilityState === "visible")
-                void load();
-        };
-        document.addEventListener("visibilitychange", onVisible);
-        return () => {
-            cancelled.current = true;
-            clearInterval(id);
-            document.removeEventListener("visibilitychange", onVisible);
-        };
-    }, [load]);
-    return { data, error, loading, refresh: load };
-}

package/dist/views/useLandscape.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/views/useLandscape.test.js

@@ -1,101 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import { ShepherdProvider } from "../ShepherdProvider.js";
-import { useLandscape, POLL_MS } from "./useLandscape.js";
-import { makeMockClient } from "../test/mockClient.js";
-// ---------------------------------------------------------------------------
-// useLandscape — the shared 5s poll behind Tasks/Chat. This covers the subtlest
-// lifecycle behavior: cancel-on-unmount (no setState after teardown) and the
-// workspace-change re-subscribe (a new workspaceId re-pulls immediately).
-// ---------------------------------------------------------------------------
-describe("useLandscape", () => {
-    let client;
-    beforeEach(() => {
-        client = makeMockClient();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.restoreAllMocks();
-    });
-    function wrapper({ children }) {
-        return _jsx(ShepherdProvider, { client: client, children: children });
-    }
-    it("fetches on mount, re-polls on the interval, and clears the interval on unmount", async () => {
-        vi.useFakeTimers();
-        client.landscape = vi.fn().mockResolvedValue({
-            agents: [],
-            tasks: [],
-            announcements: [],
-            serverTime: "2026-06-29T00:00:00.000Z",
-        });
-        let unmount = () => { };
-        await act(async () => {
-            ({ unmount } = renderHook(() => useLandscape("ws_1"), { wrapper }));
-        });
-        // Initial mount fetch.
-        expect(client.landscape).toHaveBeenCalledTimes(1);
-        expect(client.landscape).toHaveBeenLastCalledWith("ws_1");
-        // One poll interval → a second fetch.
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(POLL_MS);
-        });
-        expect(client.landscape).toHaveBeenCalledTimes(2);
-        // Unmount cancels the loop: no further calls.
-        act(() => unmount());
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(POLL_MS * 3);
-        });
-        expect(client.landscape).toHaveBeenCalledTimes(2);
-    });
-    it("re-subscribes (re-pulls) when workspaceId changes", async () => {
-        vi.useFakeTimers();
-        client.landscape = vi.fn().mockResolvedValue({
-            agents: [],
-            tasks: [],
-            announcements: [],
-            serverTime: "2026-06-29T00:00:00.000Z",
-        });
-        let rerender = () => { };
-        await act(async () => {
-            ({ rerender } = renderHook(({ id }) => useLandscape(id), {
-                wrapper,
-                initialProps: { id: "ws_1" },
-            }));
-        });
-        expect(client.landscape).toHaveBeenLastCalledWith("ws_1");
-        const afterMount = client.landscape.mock.calls.length;
-        // Switching workspace re-runs the effect: an immediate fetch for the new id.
-        await act(async () => {
-            rerender({ id: "ws_2" });
-        });
-        expect(client.landscape.mock.calls.length).toBeGreaterThan(afterMount);
-        expect(client.landscape).toHaveBeenLastCalledWith("ws_2");
-    });
-    it("does not poll while the tab is hidden, and refetches on becoming visible", async () => {
-        vi.useFakeTimers();
-        client.landscape = vi.fn().mockResolvedValue({
-            agents: [],
-            tasks: [],
-            announcements: [],
-            serverTime: "2026-06-29T00:00:00.000Z",
-        });
-        await act(async () => {
-            renderHook(() => useLandscape("ws_1"), { wrapper });
-        });
-        expect(client.landscape).toHaveBeenCalledTimes(1); // mount fetch
-        // Hide the tab: the interval tick should skip the fetch.
-        const visibility = vi.spyOn(document, "visibilityState", "get");
-        visibility.mockReturnValue("hidden");
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(POLL_MS);
-        });
-        expect(client.landscape).toHaveBeenCalledTimes(1);
-        // Becoming visible again re-pulls immediately.
-        visibility.mockReturnValue("visible");
-        await act(async () => {
-            document.dispatchEvent(new Event("visibilitychange"));
-        });
-        expect(client.landscape).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/views/wallboard.d.ts

@@ -1,46 +0,0 @@
-import type { WorkspaceTaskT, TaskStatusT } from "@shepherd/shared";
-/** Human "N ago" for a past ISO timestamp, relative to nowMs (epoch ms). */
-export declare function formatRelative(iso: string, nowMs: number): string;
-/**
- * Deterministic chat color for an agent name — same name always maps to the
- * same hue, so each speaker reads consistently across the announcement thread.
- */
-export declare function colorForName(name: string): string;
-/**
- * Up to two initials for an avatar. Prefers the capital letters of a CamelCase
- * agent name (RedDragon → RD); otherwise the first two letters (alice → AL).
- */
-export declare function initialsFor(name: string): string;
-/** Human label for a history task's status. */
-export declare function statusLabel(status: TaskStatusT): string;
-/** "active Nm/Nh" for the created->ended span; "" when the task hasn't ended. */
-export declare function formatActiveDuration(createdIso: string, endedIso: string | null): string;
-/** Local-day bucket label: "Today" / "Yesterday" / "Mon D". */
-export declare function dayBucket(iso: string, nowMs: number): string;
-/**
- * Does glob set `outer` fully cover glob set `inner`? Conservative: unsure → false,
- * so a claim only folds when it is certainly contained. Empty `inner` is covered.
- */
-export declare function globsCover(outer: string[], inner: string[]): boolean;
-/** One agent's grouped active claims: visible primaries + folded narrower claims. */
-export interface ClaimGroup {
-    agentName: string;
-    model: string | null;
-    program: string;
-    repo: string;
-    primaries: WorkspaceTaskT[];
-    narrower: WorkspaceTaskT[];
-}
-/**
- * Group active claims by agent for the board. Within an agent's claims, one that
- * is STRICTLY covered by a broader sibling folds into `narrower`; everything else
- * stays a visible `primary`. Groups + claims are newest-first; header fields come
- * from the group's newest claim. Pure — no DOM, no clock.
- */
-export declare function groupActiveClaims(tasks: WorkspaceTaskT[]): ClaimGroup[];
-/**
- * The first `@mention` in `text` matching a known agent name, returned in the
- * name's canonical casing (`@reddragon` → `RedDragon`), or null when none match.
- * An unmatched `@foo` is plain text and the message broadcasts.
- */
-export declare function extractTarget(text: string, knownNames: string[]): string | null;