@qilin-agent/client-ui-sidebar-tasks 0.0.0-stage → 3.1.4

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Pure host half; the whole tab type lives in the browser export. */
+/** Host plugin body: the tasks page contributes nothing to the host tree. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/types/client/TasksBadge.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The chip's status pill: how much work this Session currently has running.
+ *
+ * The kit draws it between the chip's glyph and its title and calls it on every
+ * strip render, so it reads the two snapshots straight through the standard
+ * `useSessions` hook and derives nothing else.
+ */
+import type { ReactNode } from 'react';
+import type { JobsSnapshot } from '@qilin-agent/api-job-controller/client';
+import type { InjectFace, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { SessionId } from '@qilin-agent/session/types';
+/** The badge's injected face: the background-job roster and its watcher. */
+export interface TasksBadgeInjected {
+    hooks: {
+        /** Client jobs snapshot (rosters and observations) bound by the renderer as useJobs. */
+        jobs: {
+            getSnapshot(): JobsSnapshot;
+            subscribe(listener: () => void): () => void;
+        };
+    };
+    /**
+     * Keep this Session's roster current while the badge is mounted; returns the
+     * stop function.
+     */
+    watchRows: (sessionId: SessionId) => () => void;
+}
+/** The badge's composed props: the Session scope's standard kit and the roster face. */
+export type TasksBadgeProps = PropsRuntime<'sidebar.right.pane.tab.badge'> & InjectFace<TasksBadgeInjected>;
+/**
+ * Render the running-work count, or nothing when the Session is idle.
+ * @param props - the Session scope's standard props.
+ * @returns the count, or null when no subagent and no job is running.
+ */
+export declare function TasksBadge({ sessionId, useSessions, useJobs, watchRows }: TasksBadgeProps): ReactNode;
+//# sourceMappingURL=TasksBadge.d.ts.map

package/lib/types/client/TasksBody.d.ts

@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime, PropsStore, TranslateNS } from '@qilin-agent/client-ui-slots';
+import type { TasksInjected } from './face.ts';
+import { NS } from './locales.ts';
+import type { SubagentRow } from './rows.ts';
+import type { createTasksGraphStore } from './tasks-graph-store.ts';
+/** The store handle type the body's store share derives from. */
+type TasksGraphStore = ReturnType<typeof createTasksGraphStore>;
+/** The body's composed props: the tab it draws, its face, its store, and its copy. */
+export type TasksBodyProps = PropsRuntime<'sidebar.right.pane.tab'> & InjectFace<TasksInjected> & PropsStore<TasksGraphStore> & PropsLocale<typeof NS>;
+/** How many subagent rows an unfolded section shows before folding the rest. */
+export declare const SUBAGENT_PREVIEW = 5;
+/** How many job rows an unfolded section shows before folding the rest. */
+export declare const TASK_PREVIEW = 3;
+/** One subagent row: the open gesture across the row, the interrupt beside it. */
+export declare function SubagentRowView({ row, t, onOpen, onInterrupt }: {
+    readonly row: SubagentRow;
+    readonly t: TranslateNS<typeof NS>;
+    readonly onOpen: TasksInjected['openChild'];
+    readonly onInterrupt: TasksInjected['interruptChild'];
+}): ReactNode;
+/**
+ * The page body.
+ * @param props - the tab's runtime share, the injected face, the graph store
+ *   shares, and the copy.
+ * @returns the two sections, or the single line a Session with no work shows.
+ */
+export declare function TasksBody({ sessionId, useSessions, useJobs, useStore, actions, watchRows, openChild, refresh, interruptChild, t, }: TasksBodyProps): ReactNode;
+export {};
+//# sourceMappingURL=TasksBody.d.ts.map

package/lib/types/client/TasksGraphView.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import type { PropsLocale, PropsStore } from '@qilin-agent/client-ui-slots';
+import type { NS } from './locales.ts';
+import type { TaskNodeVM, TasksGraphModel } from './tasks-graph-model.ts';
+import type { createTasksGraphStore } from './tasks-graph-store.ts';
+/** The store handle type the view's props share derives from. */
+type TasksGraphStore = ReturnType<typeof createTasksGraphStore>;
+/** The view's composed props: the model, the node gesture, the copy, and the store shares. */
+export type TasksGraphViewProps = {
+    /** The view model the canvas lays out. */
+    readonly model: TasksGraphModel;
+    /** One node activation, already routed by the page. */
+    readonly onNodeClick: (node: TaskNodeVM) => void;
+} & PropsLocale<typeof NS> & PropsStore<TasksGraphStore>;
+/**
+ * The tasks graph canvas.
+ * @param props - the model, the node gesture, the copy, and the store shares.
+ * @returns the canvas and its control cluster.
+ */
+export declare function TasksGraphView({ model, onNodeClick, useStore, actions, t, }: TasksGraphViewProps): ReactNode;
+export {};
+//# sourceMappingURL=TasksGraphView.d.ts.map

package/lib/types/client/definition.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Stage one of this package's registration: what the `tasks` tab type IS.
+ *
+ * The type is a page, not a viewer: it claims no address, so a tab of this kind
+ * is opened by kind alone — from the guide page's entry box, or from anywhere
+ * that calls `ctx.sidebarRight.openTab('tasks')`.
+ */
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+import type { SidebarRightTabDefinition } from '@qilin-agent/client-ui-sidebar-right/client';
+/** The tab kind this package owns; `ctx.sidebarRight.openTab` names it. */
+export declare const TASKS_KIND = "tasks";
+/** This implementation's identity in the tab system, and the key its body registers under. */
+export declare const TASKS_ID = "@qilin-agent/client-ui-sidebar-tasks";
+/**
+ * The tasks type's registry definition.
+ * @param t - namespace-bound translate, read fresh on every label call.
+ * @returns the definition to register.
+ */
+export declare function tasksDefinition(t: TranslateNS<'sidebarTasks'>): SidebarRightTabDefinition;
+//# sourceMappingURL=definition.d.ts.map

package/lib/types/client/face.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The page's actions, bound to the Session service and the subagent Remote.
+ *
+ * The component awaits nothing: it calls `openChild`, `refresh`, and
+ * `interruptChild`, and this face performs the service and Remote calls behind
+ * them. Each action resolves what it needs at call time, never at render time.
+ */
+import type { JobsSnapshot } from '@qilin-agent/api-job-controller/client';
+import type { SessionTarget } from '@qilin-agent/api-session-controller/client';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { SubagentInterruptReceipt } from '@qilin-agent/subagent/client';
+import type { RemoteResult } from '@qilin-agent/typert-protocol';
+/** The `ctx.sessions` reads the page's actions perform. */
+export interface TasksSessionActions {
+    /**
+     * Reveal one Session as the current one: a catalog child through its
+     * durable address, or a bare id (the graph's main card).
+     * @param target - the Session to open.
+     */
+    openSubagent(target: SessionTarget): void;
+    /**
+     * Re-read one parent's direct-child catalog.
+     * @param parentSessionId - catalog owner.
+     * @returns completion of the current or newly started read.
+     */
+    refreshProjections(parentSessionId: SessionId): Promise<void>;
+}
+/** One child interrupt, as the Host's generated `subagents.interruptByParent` declares it. */
+export type InterruptByParent = (childSessionId: SessionId, parentSessionId: SessionId, mode: 'continuable') => Promise<RemoteResult<SubagentInterruptReceipt>>;
+/** The slice of the Client Remote face the page calls. */
+export interface TasksSubagentsRemote {
+    /**
+     * Stop one continuable child through its durable parent address.
+     * @param childSessionId - the child being stopped.
+     * @param parentSessionId - the child's direct parent.
+     * @param mode - the delivery mode the address must carry.
+     * @returns the Host's receipt, or its failure.
+     */
+    interruptByParent: InterruptByParent;
+}
+/** The page's injected business face, as the body receives it. */
+export interface TasksInjected {
+    /**
+     * Reveal one Session as the current one: a row's catalog address, or the
+     * graph's bare main id.
+     * @param target - the Session to open.
+     */
+    readonly openChild: (target: SessionTarget) => void;
+    /**
+     * Re-read one parent's direct-child catalog.
+     * @param parentSessionId - catalog owner.
+     */
+    readonly refresh: (parentSessionId: SessionId) => void;
+    /**
+     * Stop one running continuable child through its durable parent address. The
+     * call is fire-and-forget: a rejected interrupt leaves the row exactly as the
+     * catalog reports it until the next refresh.
+     * @param childSessionId - the child being stopped.
+     * @param parentSessionId - the child's direct parent.
+     */
+    readonly interruptChild: (childSessionId: SessionId, parentSessionId: SessionId) => void;
+    /** The client jobs roster the page draws, bound by the renderer as useJobs. */
+    readonly hooks: {
+        readonly jobs: {
+            getSnapshot(): JobsSnapshot;
+            subscribe(listener: () => void): () => void;
+        };
+    };
+    /**
+     * Keep this Session's roster current while the page is mounted; returns the
+     * stop function.
+     * @param sessionId - the Session whose visible jobs to mirror.
+     */
+    readonly watchRows: (sessionId: SessionId) => () => void;
+}
+/** The background-job roster and watcher the page draws from. */
+export interface TasksJobsFace {
+    readonly hooks: {
+        readonly jobs: {
+            getSnapshot(): JobsSnapshot;
+            subscribe(listener: () => void): () => void;
+        };
+    };
+    readonly watchRows: (sessionId: SessionId) => () => void;
+}
+/**
+ * Bind the page's actions to the service and Remote they call.
+ * @param sessions - the Client Session service's navigation and catalog reads.
+ * @param subagents - the generated `subagents` Remote namespace.
+ * @param jobs - the client jobs roster and its watcher.
+ * @returns the Slot `inject` face the body receives.
+ */
+export declare function tasksFace(sessions: TasksSessionActions, subagents: TasksSubagentsRemote, jobs: TasksJobsFace): TasksInjected;
+//# sourceMappingURL=face.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Browser half: register `tasks` as a right-Sidebar tab type.
+ *
+ * The public two-stage path, unmodified: the type into `ctx.sidebarRightTabs`,
+ * the body into the keyed `sidebar.right.pane.tab` seat, and the strip's status
+ * pill into the keyed `sidebar.right.pane.tab.badge` seat, all under the type's
+ * `id`.
+ *
+ * The split is this package's layering: what the type IS (`definition.tsx`),
+ * what it says (`locales.ts`), the pure projections of the two snapshots
+ * (`rows.ts`, `lineage.ts`), the graph's pure model and layout
+ * (`tasks-graph-model.ts`, `tasks-graph-layout.ts`), what it keeps
+ * (`tasks-graph-store.ts`), the actions it performs (`face.ts`), what it draws
+ * (`TasksBody.tsx`, `TasksGraphView.tsx`, `TasksBadge.tsx`), and this module,
+ * which wires them.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+export type { SidebarTasksKey } from './locales.ts';
+export type { InterruptByParent, TasksInjected, TasksSessionActions, TasksSubagentsRemote } from './face.ts';
+export type { SubagentDescendantSummary } from './lineage.ts';
+export type { SubagentRow } from './rows.ts';
+export type { TaskNodeKind, TaskNodeVM, TasksGraphModel } from './tasks-graph-model.ts';
+export type { NodeOffsets, TaskLayoutMode } from './tasks-graph-layout.ts';
+export type { TasksGraphCamera, TasksGraphState } from './tasks-graph-store.ts';
+export type { TasksBadgeProps } from './TasksBadge.tsx';
+export type { TasksBodyProps } from './TasksBody.tsx';
+/**
+ * Required browser services: the tab registry, the keyed seats, the Session
+ * service and its subagent Remote, and copy.
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the type, its dictionaries, its body, and the
+ * chip's status pill.
+ * @param ctx - client root context carrying the registry, the slots, the Session service, and the Remote face.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/lineage.d.ts

@@ -0,0 +1,21 @@
+/** UI Sidebar Tasks-owned projection of descendant counts from Session summaries. */
+import type { SessionId } from '@qilin-agent/session/types';
+interface LineageEntry {
+    readonly id: SessionId;
+    readonly parentId?: SessionId;
+    readonly origin?: 'subagent';
+    readonly running: boolean;
+}
+/** Descendant counts for one possible parent Session. */
+export interface SubagentDescendantSummary {
+    readonly count: number;
+    readonly runningCount: number;
+}
+/**
+ * Index uninterrupted subagent descendants under each ancestor.
+ * @param summaries - Session summaries keyed by id.
+ * @returns descendant totals keyed by possible parent id.
+ */
+export declare function indexSubagentDescendants(summaries: Readonly<Record<SessionId, LineageEntry>>): ReadonlyMap<SessionId, SubagentDescendantSummary>;
+export {};
+//# sourceMappingURL=lineage.d.ts.map

package/lib/types/client/locales.d.ts

@@ -0,0 +1,133 @@
+declare module '@qilin-agent/client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Tasks page type name, guide entry, section copy, and job status words. */
+        sidebarTasks: SidebarTasksKey;
+    }
+}
+/** Dictionary namespace owned by this plugin. */
+export declare const NS = "sidebarTasks";
+/** Simplified Chinese dictionary and key-set source of truth. */
+export declare const zh: {
+    'type.label': string;
+    'guide.title': string;
+    'guide.description': string;
+    empty: string;
+    'subagents.title': string;
+    'subagents.count.one': string;
+    'subagents.count.other': string;
+    'subagents.loading': string;
+    'subagents.empty': string;
+    'subagents.failed': string;
+    'subagents.retry': string;
+    'subagents.refresh': string;
+    'subagents.interrupt': string;
+    'subagents.mode.oneShot': string;
+    'subagents.mode.continuable': string;
+    'subagents.diagnostic.corrupt': string;
+    'subagents.diagnostic.unsupported': string;
+    'subagents.diagnostic.unavailable': string;
+    'tasks.title': string;
+    'tasks.count.one': string;
+    'tasks.count.other': string;
+    'tasks.empty': string;
+    'tasks.status.running': string;
+    'tasks.status.stopping': string;
+    'tasks.status.completed': string;
+    'tasks.status.killed': string;
+    'tasks.status.failed': string;
+    'tasks.duration.seconds': string;
+    'tasks.duration.minutes': string;
+    'tasks.duration.hours': string;
+    'tasks.duration.live': string;
+    'tasks.duration.done': string;
+    'more.expand': string;
+    'more.collapse': string;
+    'graph.toggle': string;
+    'graph.view': string;
+    'graph.list': string;
+    'graph.zoomIn': string;
+    'graph.zoomOut': string;
+    'graph.fit': string;
+    'graph.arrange': string;
+    'graph.mode.tree': string;
+    'graph.mode.compact': string;
+    'graph.mode.grid': string;
+    'graph.resetLayout': string;
+    'graph.status.running': string;
+    'graph.status.idle': string;
+    'graph.loading': string;
+    'graph.unphased': string;
+    'graph.badge.main': string;
+    'graph.badge.subagent': string;
+    'graph.badge.done': string;
+    'graph.badge.standby': string;
+    'graph.badge.placeholder': string;
+    'graph.badge.diagnostic': string;
+    'graph.badge.run': string;
+    'graph.badge.phase': string;
+    'graph.badge.member': string;
+};
+/** Tasks dictionary key union. */
+export type SidebarTasksKey = keyof typeof zh;
+/** English dictionary, checked against the Chinese key set. */
+export declare const en: {
+    'type.label': string;
+    'guide.title': string;
+    'guide.description': string;
+    empty: string;
+    'subagents.title': string;
+    'subagents.count.one': string;
+    'subagents.count.other': string;
+    'subagents.loading': string;
+    'subagents.empty': string;
+    'subagents.failed': string;
+    'subagents.retry': string;
+    'subagents.refresh': string;
+    'subagents.interrupt': string;
+    'subagents.mode.oneShot': string;
+    'subagents.mode.continuable': string;
+    'subagents.diagnostic.corrupt': string;
+    'subagents.diagnostic.unsupported': string;
+    'subagents.diagnostic.unavailable': string;
+    'tasks.title': string;
+    'tasks.count.one': string;
+    'tasks.count.other': string;
+    'tasks.empty': string;
+    'tasks.status.running': string;
+    'tasks.status.stopping': string;
+    'tasks.status.completed': string;
+    'tasks.status.killed': string;
+    'tasks.status.failed': string;
+    'tasks.duration.seconds': string;
+    'tasks.duration.minutes': string;
+    'tasks.duration.hours': string;
+    'tasks.duration.live': string;
+    'tasks.duration.done': string;
+    'more.expand': string;
+    'more.collapse': string;
+    'graph.toggle': string;
+    'graph.view': string;
+    'graph.list': string;
+    'graph.zoomIn': string;
+    'graph.zoomOut': string;
+    'graph.fit': string;
+    'graph.arrange': string;
+    'graph.mode.tree': string;
+    'graph.mode.compact': string;
+    'graph.mode.grid': string;
+    'graph.resetLayout': string;
+    'graph.status.running': string;
+    'graph.status.idle': string;
+    'graph.loading': string;
+    'graph.unphased': string;
+    'graph.badge.main': string;
+    'graph.badge.subagent': string;
+    'graph.badge.done': string;
+    'graph.badge.standby': string;
+    'graph.badge.placeholder': string;
+    'graph.badge.diagnostic': string;
+    'graph.badge.run': string;
+    'graph.badge.phase': string;
+    'graph.badge.member': string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/rows.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Pure projections of the two snapshots the page draws: this Session's
+ * direct-child subagent catalogs and its background-job list.
+ *
+ * Nothing here subscribes, requests, or reads a clock it does not take as a
+ * parameter: each function maps a snapshot the Session list already holds onto
+ * the rows the page renders. Descendant totals come from the summary lineage
+ * (`indexSubagentDescendants`), the only projection that sees subagents below
+ * the direct children a catalog reports.
+ */
+import type { SessionProjectionSnapshot } from '@qilin-agent/api-session-controller/client';
+import type { JobView } from '@qilin-agent/jobs/view';
+import type { StateDotState } from '@qilin-agent/client-ui-primitives';
+import type { TranslateNS } from '@qilin-agent/client-ui-slots';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { SubagentAddress } from '@qilin-agent/subagent/client';
+import type { SubagentDescendantSummary } from './lineage.ts';
+import { NS } from './locales.ts';
+/** Stable empty job list, so a Session without jobs keeps one array identity. */
+export declare const NO_JOBS: readonly JobView[];
+/**
+ * One row of a parent's direct-child catalog as the page draws it: a described
+ * child, or a candidate the Host could not describe.
+ */
+export type CatalogRow = {
+    readonly kind: 'child';
+    readonly id: SessionId;
+    readonly mode: SubagentAddress['mode'];
+    readonly label?: string;
+    /** Whether the Session list currently reports the child as running. */
+    readonly activity: 'running' | 'inactive';
+    /** Whether a catalog below this child has yet to prove it childless. */
+    readonly hasChildren: boolean;
+} | {
+    readonly kind: 'diagnostic';
+    readonly id: SessionId;
+    readonly reason: 'corrupt' | 'unsupported' | 'unavailable';
+};
+/** One parent's direct-child catalog and the state of its explicit read. */
+export interface CatalogSnapshot {
+    readonly state: 'loading' | 'ready' | 'error';
+    readonly error: {
+        readonly message: string;
+    } | null;
+    readonly entries: readonly CatalogRow[];
+}
+/** Direct-child catalogs keyed by the Session they describe. */
+export type Catalogs = Readonly<Record<SessionId, CatalogSnapshot>>;
+/**
+ * Project the shared per-Session projection snapshots into the catalogs the page draws.
+ * @param projections - projection snapshots keyed by Session id.
+ * @param running - whether the Session list currently reports a Session as running.
+ * @returns one catalog per projected Session.
+ */
+export declare function catalogsOf(projections: Readonly<Record<SessionId, SessionProjectionSnapshot>>, running: (id: SessionId) => boolean): Catalogs;
+/** One row the subagents section draws: a catalog child, or a child whose durable record could not be read. */
+export type SubagentRow = {
+    readonly kind: 'child';
+    /** The child's Session id, and the row's stable key. */
+    readonly id: SessionId;
+    /** The durable direct-parent address every action on this row travels through. */
+    readonly address: SubagentAddress;
+    readonly label: string;
+    /** Nesting level under the section's root Session. */
+    readonly depth: number;
+    readonly running: boolean;
+} | {
+    readonly kind: 'diagnostic';
+    readonly id: SessionId;
+    readonly depth: number;
+    readonly reason: 'corrupt' | 'unsupported' | 'unavailable';
+};
+/**
+ * Flatten one Session's subagent topology from the catalogs in hand.
+ *
+ * A level is one parent's catalog, and the walk descends only into children
+ * whose own catalog has been read; a child the page has never opened
+ * contributes its own row and no rows below it. Siblings are newest-first
+ * because the Host orders a catalog by durable creation time. The seen set
+ * makes a repeated or cyclic parent an ordinary skip rather than an endless
+ * walk.
+ * @param catalogs - direct-child catalogs keyed by parent Session id.
+ * @param rootSessionId - the Session the section is rooted at.
+ * @returns rows in display order, depth-first.
+ */
+export declare function subagentRows(catalogs: Catalogs, rootSessionId: SessionId): SubagentRow[];
+/**
+ * How many rows the subagents section counts as children. A diagnostic row is a
+ * child the Host could not describe, so it is drawn but never counted.
+ * @param rows - the section's rows.
+ * @returns the number of child rows.
+ */
+export declare function childRowCount(rows: readonly SubagentRow[]): number;
+/**
+ * The subagents section's stated total: the direct children the catalog
+ * reports, or the descendants the summary lineage records, whichever is
+ * greater.
+ *
+ * The lineage reaches subagents below the direct children, and the catalog is
+ * authoritative while the lineage is still converging, so taking the greater
+ * of the two is never an undercount during that window.
+ * @param children - child rows the catalog reports.
+ * @param descendants - lineage totals keyed by possible parent.
+ * @param rootSessionId - the Session the section is rooted at.
+ * @returns the total the section header states.
+ */
+export declare function subagentTotal(children: number, descendants: ReadonlyMap<SessionId, SubagentDescendantSummary>, rootSessionId: SessionId): number;
+/**
+ * Whether a job remains active in the registry.
+ * @param job - the Session job row.
+ * @returns whether the job is running or stopping.
+ */
+export declare function isLive(job: JobView): boolean;
+/**
+ * Live rows first in start order, then settled rows newest-first. Two jobs that
+ * settled in the same millisecond fall back to the later start, which is the
+ * same newest-first reading the settled order already uses, so the sort never
+ * depends on the Host's map iteration.
+ * @param jobs - the Session's job rows.
+ * @returns a new array in display order.
+ */
+export declare function orderedJobs(jobs: readonly JobView[]): JobView[];
+/**
+ * Elapsed milliseconds for one job row.
+ * @param job - the job.
+ * @param now - the clock sample a live duration measures against.
+ * @returns its span so far while it runs, its own span once it settled.
+ */
+export declare function jobElapsed(job: JobView, now: number): number;
+/**
+ * Elapsed time in at most two adjacent units. A background job that outlives an
+ * hour is already exceptional, so hours is the widest unit.
+ * @param elapsedMs - elapsed milliseconds.
+ * @param t - namespace-bound translate.
+ * @returns the duration as the dictionary phrases it.
+ */
+export declare function formatDuration(elapsedMs: number, t: TranslateNS<typeof NS>): string;
+/**
+ * Human status word for a row that carries no producer detail.
+ * @param status - the wire status.
+ * @param t - namespace-bound translate.
+ * @returns the word the row shows.
+ */
+export declare function jobStatusLabel(status: JobView['status'], t: TranslateNS<typeof NS>): string;
+/**
+ * Status marker semantics. `stopping` and `killed` share the attention colour:
+ * both mean the work ended (or is ending) on request rather than on its own.
+ * @param status - the wire status.
+ * @returns the state the dot draws.
+ */
+export declare function jobDotState(status: JobView['status']): StateDotState;
+/**
+ * The work a chip badge counts for one Session: direct-child catalog rows whose
+ * activity is `running`, plus the jobs the registry still holds open.
+ *
+ * A chip re-renders on every strip pass, so this reads the two snapshots
+ * directly instead of walking the summary lineage; a running grandchild implies
+ * its parent is running too, so the direct children already account for work
+ * below them.
+ * @param catalogs - direct-child catalogs keyed by parent Session id.
+ * @param jobs - the Session's job rows.
+ * @param sessionId - the Session the chip belongs to.
+ * @returns the count, zero when nothing is active.
+ */
+export declare function activeWorkCount(catalogs: Catalogs, jobs: readonly JobView[], sessionId: SessionId): number;
+//# sourceMappingURL=rows.d.ts.map