@sparkelf/dsh-knowledge-base 0.1.4 → 0.1.20

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

@@ -0,0 +1,65 @@
+/**
+ * The transport an upload actually uses.
+ *
+ * Uploading with `fetch` is one request with no visibility into it: the browser reports
+ * nothing until the whole body has gone, so a progress bar built on it can only be a
+ * spinner. `XMLHttpRequest` exposes `upload.onprogress`, which is the only browser API
+ * that reports bytes sent -- that is why this exists despite `fetch` being the modern
+ * choice.
+ *
+ * Everything about the request other than the transport is unchanged: same URL, same
+ * JSON body, same content type, same failure codes. The response is returned as a small
+ * result object rather than a `Response`, because `XHR` does not produce one and every
+ * caller here only needs "did it work, with which status, and what did the body say".
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** What one upload attempt reported. */
+export interface UploadAttempt {
+    /** HTTP status, or 0 when the request never completed (offline, DNS, abort). */
+    status: number;
+    /** Parsed JSON body when it parsed, else undefined. */
+    body: unknown;
+    /** Why the attempt did not complete, when the transport itself failed. */
+    transportError?: string;
+}
+/**
+ * Report progress no more often than this.
+ *
+ * `upload.onprogress` can fire hundreds of times for a large file, and each event that
+ * reaches React is a render of the whole task list. 100 ms keeps the bar smooth (10
+ * updates a second is well past what an eye resolves) while bounding the work to ten
+ * renders per second instead of hundreds.
+ */
+export declare const PROGRESS_INTERVAL_MS = 100;
+/**
+ * Compute the integer percentage of bytes sent.
+ *
+ * Returns undefined when the total is unknown, which is a real case: a body sent without
+ * a `Content-Length` reports `lengthComputable: false`, and inventing a percentage from
+ * a missing denominator is exactly the dishonesty this module avoids.
+ * @param loaded - bytes sent so far.
+ * @param total - total bytes, when the browser knows it.
+ * @param computable - whether the browser reported a usable total.
+ * @returns 0-100, or undefined when it cannot be known.
+ */
+export declare function uploadPercent(loaded: number, total: number, computable: boolean): number | undefined;
+/**
+ * Whether enough time has passed to report another progress sample.
+ *
+ * Kept as a pure predicate so the throttle can be tested without a timer or a network.
+ * @param now - the current timestamp in milliseconds.
+ * @param last - when the last sample was reported, or undefined if none was.
+ * @returns Whether this sample should be reported.
+ */
+export declare function shouldReportProgress(now: number, last: number | undefined): boolean;
+/**
+ * Upload one JSON body, reporting byte progress as it goes.
+ * @param url - the route to post to.
+ * @param payload - the JSON-serialisable body.
+ * @param onProgress - called with 0-100 while sending; only called when a percentage is
+ *   actually known, and throttled to {@link PROGRESS_INTERVAL_MS}.
+ * @returns The attempt's outcome. Never rejects: a transport failure is a result, because
+ *   the caller has to show it either way.
+ */
+export declare function uploadJsonWithProgress(url: string, payload: unknown, onProgress: (percent: number) => void): Promise<UploadAttempt>;

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

@@ -0,0 +1,72 @@
+/**
+ * The knowledge tree's row ordering, remembered per browser.
+ *
+ * Sorting is a VIEW preference: it decides how one reader scans a list, not what is in the
+ * tree. That makes the browser the right place for it -- there is nothing to share with
+ * another machine, and a round trip before the list reorders would make a one-click control
+ * feel broken. (The list/grid layout, by contrast, lives in the view directory because it
+ * was built as a document-level preference; sorting deliberately does not copy that.)
+ *
+ * The stored key carries the panel id so two different knowledge panels -- or two
+ * deployments mounted on one origin -- cannot read each other's choice.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/**
+ * The orderings the tree offers.
+ *
+ * `mtime` first because it is the default: a folder is usually opened to find what was
+ * just worked on. `name` is the host's own order, `type` groups by extension, `size`
+ * surfaces the large documents.
+ */
+export type TreeSortKey = 'mtime' | 'name' | 'type' | 'size';
+/** Every ordering, in the order the menu lists them. */
+export declare const TREE_SORT_KEYS: readonly TreeSortKey[];
+/** Most recently modified first. */
+export declare const DEFAULT_TREE_SORT: TreeSortKey;
+/** What the rail gets back. */
+export interface TreeSortStore {
+    /** The current ordering. */
+    key: TreeSortKey;
+    /** Choose another ordering; written through to storage. */
+    setKey: (key: TreeSortKey) => void;
+}
+/**
+ * Whether a value is one of the orderings.
+ * @param value - the candidate.
+ * @returns Whether it is a known key.
+ */
+export declare function isTreeSortKey(value: unknown): value is TreeSortKey;
+/**
+ * Build the storage key for one panel.
+ *
+ * Exported so the test can assert the shape rather than duplicate the string.
+ * @param panelId - the mounting panel's identity, may be empty.
+ * @returns The localStorage key.
+ */
+export declare function treeSortStorageKey(panelId: string): string;
+/**
+ * Read the stored ordering.
+ *
+ * Any failure -- no storage (a privacy mode, a server render), an unknown value from an
+ * older build -- answers the default rather than throwing: a preference that cannot be read
+ * must not take the tree down with it.
+ * @param panelId - the mounting panel's identity.
+ * @returns The stored ordering, or the default.
+ */
+export declare function readTreeSort(panelId: string): TreeSortKey;
+/**
+ * Persist the ordering.
+ *
+ * A write failure is swallowed for the same reason: the reader's click should still take
+ * effect for this session even when the browser refuses to remember it.
+ * @param panelId - the mounting panel's identity.
+ * @param key - the ordering to store.
+ */
+export declare function writeTreeSort(panelId: string, key: TreeSortKey): void;
+/**
+ * Read and write the tree's ordering.
+ * @param panelId - the mounting panel's identity, used to scope the stored key.
+ * @returns The store.
+ */
+export declare function useTreeSort(panelId: string): TreeSortStore;

package/lib/types/client/workflows/WorkflowPlaza.d.ts

@@ -0,0 +1,146 @@
+/**
+ * The 「工作流广场」 body: built-in workflow templates and their subscribe flow.
+ *
+ * The plaza is a TEMPLATE SHELF. It renders cards from the static registry and turns a
+ * subscription into an ordinary DSH Schedule through the existing agent tool, following
+ * the same path the product's own 「新建任务」 button uses (create a Session, ask the model
+ * to schedule the work, confirm the task exists). Nothing here schedules anything
+ * itself, and nothing here talks to DataOps: a workflow that touches knowledge
+ * documents goes through the knowledge API when it runs, where permissions already
+ * apply.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/workflows/WorkflowPlaza
+ */
+import { type ReactNode } from 'react';
+import { type WorkflowDefinition } from './registry.ts';
+import { type SubscribedTaskView } from './dedupe.ts';
+import { type SubscribeFailure } from './subscribe.ts';
+import { type PublishedWorkflowView } from './published.ts';
+import { type WorkflowModelCatalogView, type WorkflowModelSelection } from './modelChoice.ts';
+/** Copy the plaza needs, injected so this module owns no dictionary. */
+export interface WorkflowPlazaCopy {
+    readonly title: string;
+    readonly subscribe: string;
+    readonly subscribed: string;
+    readonly unsubscribe: string;
+    readonly frequency: string;
+    readonly daily: string;
+    readonly weekly: string;
+    readonly monthly: string;
+    readonly custom: string;
+    readonly cronLabel: string;
+    readonly cronInvalid: string;
+    /** Labels for the two interval shortcuts. */
+    readonly everyHours: string;
+    readonly everyMinutes: string;
+    /** Count-field labels, one per interval unit. */
+    readonly hoursCount: string;
+    readonly minutesCount: string;
+    /** Reasons a cron expression cannot be submitted, by rejection code. */
+    readonly cronReason: (reason: string) => string;
+    /** Range message for an out-of-bounds or non-integer interval count. */
+    readonly intervalInvalid: (min: number, max: number) => string;
+    readonly subscribing: string;
+    readonly plazaTab: string;
+    readonly reviewTab: string;
+    readonly mineTab: string;
+    readonly mineEmpty: string;
+    readonly mineUpdated: string;
+    readonly mineReviewNote: string;
+    readonly mineResubmit: string;
+    readonly mineUnpublish: string;
+    readonly mineDetails: string;
+    readonly mineActionFailed: string;
+    readonly mineStatusPending: string;
+    readonly mineStatusApproved: string;
+    readonly mineStatusRejected: string;
+    readonly mineStatusUnpublished: string;
+    readonly mineScopeGlobal: string;
+    readonly mineScopePrivate: string;
+    readonly mineScopeDepartment: (name: string) => string;
+    readonly reviewEmpty: string;
+    readonly reviewLoading: string;
+    readonly reviewFailed: string;
+    readonly reviewAuthor: string;
+    readonly reviewCreated: string;
+    readonly reviewPromptLabel: string;
+    readonly reviewNotePlaceholder: string;
+    readonly reviewApprove: string;
+    readonly reviewReject: string;
+    readonly model: string;
+    readonly modelLoading: string;
+    readonly modelUnavailable: string;
+    readonly modelDefault: string;
+    readonly effort: string;
+    readonly dialogTitle: string;
+    readonly dialogConfirm: string;
+    readonly dialogCancel: string;
+    readonly retry: string;
+    readonly alreadySubscribed: string;
+    readonly failure: (reason: string) => string;
+    readonly reason: (failure: SubscribeFailure) => string;
+    /** Card title and description, resolved per workflow id by the host. */
+    readonly cardTitle: (workflow: WorkflowDefinition) => string;
+    readonly cardDescription: (workflow: WorkflowDefinition) => string;
+}
+/** What the plaza needs from the Host, all injected so the component stays testable. */
+export interface WorkflowPlazaDeps {
+    /** Read the authoritative task list. */
+    readonly listTasks: () => Promise<readonly SubscribedTaskView[]>;
+    /** Create a Session and return its id. */
+    readonly createSession: () => Promise<string>;
+    /** Send one prompt into a Session. */
+    readonly sendPrompt: (sessionId: string, text: string) => Promise<boolean>;
+    /** Remove one task. */
+    readonly removeTask: (taskId: string, sessionId: string) => Promise<boolean>;
+    /** The Session's own turn failure, so a failed attempt states the real cause. */
+    readonly readSessionFailure?: (sessionId: string) => Promise<string | undefined>;
+    /** Open a Session, so a failed attempt can be inspected. */
+    readonly openSession?: (sessionId: string) => void;
+    /** Load the Host model catalog; omitted in tests that do not exercise model choice. */
+    readonly loadModels?: () => Promise<WorkflowModelCatalogView>;
+    /** Install the chosen model on a newly created Session. */
+    readonly selectModel?: (sessionId: string, selection: WorkflowModelSelection) => Promise<boolean>;
+    /** Persist the choice for the next dialog open. */
+    readonly rememberModel?: (selection: WorkflowModelSelection) => void;
+    /** Read the previous choice; defaults to localStorage. */
+    readonly readRememberedModel?: () => WorkflowModelSelection | undefined;
+    /** Approved published workflows to append to the built-in shelf. */
+    readonly loadPublished?: () => Promise<readonly PublishedWorkflowView[]>;
+    /** Whether this caller may see the review tab. */
+    readonly loadReviewAccess?: () => Promise<boolean>;
+    /** Pending workflows for the review tab. */
+    readonly loadPending?: () => Promise<readonly PublishedWorkflowView[]>;
+    /** Approve or reject one pending workflow. */
+    readonly reviewPublished?: (id: string, decision: 'approve' | 'reject', note?: string) => Promise<boolean>;
+    /** The caller's own shared workflows (all statuses). */
+    readonly loadMine?: () => Promise<readonly PublishedWorkflowView[]>;
+    /** Unpublish one of the caller's approved workflows. */
+    readonly unpublishMine?: (id: string) => Promise<boolean>;
+    /** Resubmit one rejected/unpublished workflow for review. */
+    readonly resubmitMine?: (id: string) => Promise<boolean>;
+}
+/** Props for the plaza body. */
+export interface WorkflowPlazaProps {
+    readonly copy: WorkflowPlazaCopy;
+    readonly deps: WorkflowPlazaDeps;
+    /**
+     * Child-slot renderer supplied by the slot system when this component's registration
+     * declares `workflow-plaza.actions`. Tests and non-slot uses omit it; the header
+     * actions simply do not render.
+     */
+    readonly renderSlot?: (key: 'workflow-plaza.actions', owner: Record<string, never>) => ReactNode;
+}
+/** What the slot's `inject` supplies: the copy and the Host wiring. */
+export type WorkflowPlazaInjected = WorkflowPlazaProps;
+/** The card grid plus the subscribe dialog. */
+export declare function WorkflowPlaza({ copy, deps, renderSlot }: WorkflowPlazaProps): ReactNode;
+/**
+ * The plaza as a standalone panel page.
+ *
+ * The automation-task page's `schedule.manager.tabs` seat is contributed at runtime;
+ * on a Host that does not declare that child slot the registration is simply inert.
+ * This page gives the same body a sidebar-reachable home on every Host, so the feature
+ * is never invisible just because the surrounding page is older.
+ */
+export declare function WorkflowPlazaPage({ copy, deps, renderSlot }: WorkflowPlazaInjected): ReactNode;

package/lib/types/client/workflows/cron.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Cron handling for the workflow plaza: shortcut mapping and shape checking ONLY.
+ *
+ * This module deliberately does NOT parse or interpret cron. The DSH Schedule owns the
+ * expression's meaning, and a second implementation here would be a second opinion
+ * about when a task runs -- exactly the "two answers for one fact" defect this codebase
+ * keeps removing. What the dialog needs is narrower:
+ *
+ * - map a frequency shortcut to the expression it stands for, and
+ * - tell the reader whether what they typed has the right SHAPE, so a typo is caught
+ *   while they are still looking at the field instead of failing a minute later.
+ *
+ * Anything beyond that is handed to the Schedule verbatim.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/workflows/cron
+ */
+/** Number of space-separated fields a standard five-field cron expression has. */
+export declare const CRON_FIELD_COUNT = 5;
+/** Why a custom expression was rejected, or that it is usable. */
+export type CronCheck = {
+    readonly ok: true;
+    readonly cron: string;
+} | {
+    readonly ok: false;
+    readonly reason: CronRejection;
+};
+/** Why an expression cannot be submitted. */
+export type CronRejection = 'empty' | 'fieldCount'
+/** An interval count that is not a whole number. */
+ | 'notInteger'
+/** An interval count outside the range the shortcut allows. */
+ | 'outOfRange';
+/**
+ * Check the SHAPE of a custom cron expression.
+ *
+ * Only the field count is checked: it is the mistake a reader actually makes (typing
+ * four fields, or pasting a six-field expression with seconds), and it is the one that
+ * the Schedule rejects outright. Ranges, steps and names are left alone -- judging those
+ * would mean interpreting the expression, which is the Schedule's job.
+ *
+ * Whitespace is normalised to single spaces so the value stored matches what the reader
+ * would see in the task detail.
+ *
+ * @param raw - exactly what the reader typed.
+ * @returns the normalised expression, or the reason it cannot be submitted.
+ */
+export declare function checkCustomCron(raw: string): CronCheck;
+/**
+ * The expression a frequency shortcut stands for.
+ *
+ * @param frequencyId - shortcut chosen in the dialog.
+ * @param workflow - whose frequencies are offered.
+ * @param customRaw - the custom field's text, used only for `custom`.
+ * @param intervalRaw - the count field's text, used only for the interval shortcuts.
+ * @returns the expression to submit, or undefined when a custom value is not usable yet.
+ */
+export declare function resolveCron(frequencyId: string, workflow: {
+    readonly frequencies: readonly {
+        readonly id: string;
+        readonly cron?: string;
+    }[];
+}, customRaw: string, intervalRaw?: string): CronCheck;
+/** Which counter an interval shortcut edits. */
+export type IntervalUnit = 'hours' | 'minutes';
+/** The id of the two interval shortcuts, as stored in a workflow definition. */
+export type IntervalFrequencyId = 'everyHours' | 'everyMinutes';
+/** One interval shortcut: its bounds and the count it starts from. */
+export interface IntervalSpec {
+    readonly id: IntervalFrequencyId;
+    readonly unit: IntervalUnit;
+    /** Smallest accepted count, inclusive. */
+    readonly min: number;
+    /** Largest accepted count, inclusive. */
+    readonly max: number;
+    /** Count the dialog starts on; never blank, so the field is always usable. */
+    readonly defaultCount: number;
+}
+/**
+ * The interval shortcuts every built-in workflow offers.
+ *
+ * Hourly stops at 23 and minutely at 59 because a larger count is not a shorter
+ * interval -- it is a different rule, and a 90-minute step would silently mean something
+ * the reader did not ask for. Rejecting keeps the generated expression honest.
+ *
+ * (Cron examples are kept out of these comments on purpose: the two-character sequence
+ * that begins a step value also ends a block comment.)
+ */
+export declare const INTERVAL_SPECS: Readonly<Record<IntervalFrequencyId, IntervalSpec>>;
+/** Whether a frequency id selects an interval shortcut. */
+export declare function isIntervalFrequency(id: string): id is IntervalFrequencyId;
+/**
+ * Build the expression an interval stands for.
+ *
+ * Hourly pins the minute field to 0, so the task runs on the hour rather than sixty
+ * times at an arbitrary offset. Minutely has no such anchor and steps the minute field
+ * directly.
+ *
+ * The count is validated rather than clamped: a reader who types 25 hours gets told the
+ * range instead of quietly being given 23, because a silently altered schedule is a
+ * schedule they did not choose.
+ *
+ * @param spec - which shortcut, and the bounds it accepts.
+ * @param raw - the count exactly as it appears in the field.
+ * @returns the expression, or why the count cannot be used.
+ */
+export declare function intervalCron(spec: IntervalSpec, raw: string): CronCheck;
+/** A frequency shortcut as the dialog renders it: id, cron, and a locale key for its label. */
+export interface FrequencyChoice {
+    readonly id: string;
+    readonly cron: string | undefined;
+    readonly labelKey: string;
+}
+/**
+ * Build the dialog's frequency radio list for one workflow.
+ *
+ * @param workflow - whose frequencies to present.
+ * @param defaultCron - the workflow's prefilled expression, used for `custom`'s field.
+ * @returns one entry per shortcut, in the workflow's declared order.
+ */
+export declare function frequencyChoices(workflow: {
+    readonly frequencies: readonly {
+        readonly id: string;
+        readonly cron?: string;
+    }[];
+}, defaultCron: string): FrequencyChoice[];

package/lib/types/client/workflows/dedupe.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Deciding whether a workflow is already subscribed.
+ *
+ * The plaza must not offer a second subscription for a workflow that already has a
+ * task, and the answer has to survive a page refresh -- so it is read from the
+ * authoritative Schedule list every time, never from component state. A local flag
+ * would be a second opinion that starts lying the moment the page reloads.
+ *
+ * ## Why two ways of recognising a task
+ *
+ * A subscription is marked by putting `[workflow:<id>]` inside the Schedule's prompt.
+ * That marker is written by our own code, but the prompt also passes through a model
+ * that is asked to reproduce it verbatim -- and a model sometimes paraphrases. If
+ * recognition depended on the marker alone, one paraphrased prompt would make a
+ * subscribed workflow look unsubscribed, and the reader could subscribe twice.
+ *
+ * So recognition is deliberately generous: the marker OR the workflow's own title
+ * appearing in the task's prompt/name counts. A false "already subscribed" is a much
+ * smaller problem than a duplicate nightly job that reorganises someone's documents.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/workflows/dedupe
+ */
+import { type WorkflowDefinition } from './registry.ts';
+/** The part of a Schedule task this module needs, so it can be tested without one. */
+export interface SubscribedTaskView {
+    /** Task identity, used to unsubscribe. */
+    readonly id: string;
+    /** Session the task belongs to; deletion is routed through it. */
+    readonly sessionId?: string;
+    /** The task's prompt, which is where a subscription leaves its mark. */
+    readonly prompt?: string;
+    /** The task's display name, when the list reports one. */
+    readonly name?: string;
+}
+/** One workflow found to be already subscribed. */
+export interface ExistingSubscription<T extends SubscribedTaskView = SubscribedTaskView> {
+    /** The workflow id that was found. */
+    readonly workflowId: string;
+    /** The task that represents it. */
+    readonly task: T;
+    /**
+     * How it was recognised. `marker` is the reliable path; `title` means the marker was
+     * lost and the title match carried it. Presented so a reader can be told the
+     * subscription was found by name rather than by its tag.
+     */
+    readonly via: 'marker' | 'title';
+}
+/**
+ * Find every workflow already represented among the scheduled tasks.
+ *
+ * @param tasks - the authoritative task list.
+ * @param workflows - workflows the plaza offers.
+ * @returns one entry per subscribed workflow, in the workflows' own order.
+ */
+export declare function findSubscriptions<T extends SubscribedTaskView>(tasks: readonly T[], workflows: readonly WorkflowDefinition[]): Array<ExistingSubscription<T>>;
+/**
+ * Whether one workflow is already subscribed, and by which task.
+ *
+ * @param workflow - workflow the reader wants to subscribe.
+ * @param tasks - the authoritative task list, read immediately before subscribing.
+ * @returns the existing subscription, or undefined when there is none.
+ */
+export declare function findSubscription<T extends SubscribedTaskView>(workflow: WorkflowDefinition, tasks: readonly T[]): ExistingSubscription<T> | undefined;
+/**
+ * Index subscriptions by workflow id, for rendering card state.
+ *
+ * @param subscriptions - result of {@link findSubscriptions}.
+ * @returns workflow id -> subscription, so a card asks one question instead of scanning.
+ */
+export declare function subscriptionIndex<T extends SubscribedTaskView>(subscriptions: readonly ExistingSubscription<T>[]): Map<string, ExistingSubscription<T>>;

package/lib/types/client/workflows/deps.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Wiring the workflow plaza to the Host's real services.
+ *
+ * Split out from the component so the component stays a pure view: everything that
+ * touches sessions or Schedules lives here, and the orchestration in `subscribe.ts`
+ * only ever sees plain functions.
+ *
+ * ## The asymmetry this module exists to absorb
+ *
+ * DSH exposes Schedules to the browser as READ and DELETE only; creating one is an
+ * agent tool (`schedule_create`). So "is this workflow already subscribed" is answered
+ * from `remote.schedule.catalog()`, "unsubscribe" is `remote.schedule.delete`, and
+ * "subscribe" is a prompt into a new Session. That is not a shortcut taken here: the
+ * task manager page documents the same design ("The page deliberately has no creation
+ * form of its own").
+ *
+ * `remote.schedule.list` is deliberately NOT used: it is scoped to one Session
+ * (`{ sessionId }`), so it cannot answer "does any task already represent this
+ * workflow". `catalog()` is the cross-Session read and is what deduplication needs.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/workflows/deps
+ */
+import type { WorkflowPlazaDeps } from './WorkflowPlaza.tsx';
+import type { PublishedWorkflowView } from './published.ts';
+import { type RawModelCatalog, type WorkflowModelSelection } from './modelChoice.ts';
+/** One Schedule row as the catalog reports it, narrowed to what dedupe reads. */
+export interface ScheduleCatalogRow {
+    readonly id: string;
+    /** Session that owns the task; required to delete it. */
+    readonly sessionId?: string;
+    /** The standing instruction this task delivers; the marker lives here. */
+    readonly prompt?: string;
+    /** Human title, when the row carries one. */
+    readonly name?: string;
+}
+/** The parts of a remote result this module reads. */
+interface RemoteResultLike<T> {
+    readonly ok: boolean;
+    readonly value?: T;
+}
+/**
+ * The narrow slice of DSH client services this module needs.
+ *
+ * Typed structurally rather than importing the concrete service classes, so a test can
+ * pass plain objects and a Host upgrade that reshapes a class does not silently change
+ * what this file promises.
+ */
+export interface WorkflowPlazaHost {
+    /** Create a Session in the current workspace; resolves its id. */
+    readonly createSession: () => Promise<string>;
+    /** Send one text prompt into an existing Session; resolves false when refused. */
+    readonly sendPrompt: (sessionId: string, text: string) => Promise<boolean>;
+    /** Read every retained task, across Sessions. */
+    readonly readCatalog: () => Promise<RemoteResultLike<readonly ScheduleCatalogRow[]>>;
+    /** Delete one task by id. */
+    readonly deleteSchedule: (taskId: string, sessionId: string) => Promise<RemoteResultLike<unknown>>;
+    /**
+     * Read the Session's own turn failure, once it has one.
+     *
+     * Optional because only a Host holding the `sessions` service can answer it; a caller
+     * without that wiring keeps the plain verification poll.
+     */
+    readonly readSessionFailure?: (sessionId: string) => Promise<string | undefined>;
+    /** Focus an existing Session, used to explain a failed attempt. */
+    readonly openSession?: (sessionId: string) => void;
+    /** Read the Host model catalog, grouped by provider. */
+    readonly readModelCatalog?: () => Promise<RemoteResultLike<RawModelCatalog>>;
+    /** Install one model selection on a Session before its first prompt. */
+    readonly selectSessionModel?: (sessionId: string, selection: WorkflowModelSelection) => Promise<boolean>;
+    /** Approved published workflows. */
+    readonly readPublished?: () => Promise<RemoteResultLike<{
+        workflows: readonly PublishedWorkflowView[];
+    }>>;
+    /** Whether the caller may review pending workflows. */
+    readonly readReviewAccess?: () => Promise<boolean>;
+    /** Pending workflows for the review tab. */
+    readonly readPending?: () => Promise<RemoteResultLike<{
+        workflows: readonly PublishedWorkflowView[];
+    }>>;
+    /** Approve or reject one pending workflow. */
+    readonly reviewWorkflow?: (id: string, decision: 'approve' | 'reject', note?: string) => Promise<boolean>;
+    /** The caller's own shared workflows. */
+    readonly readMine?: () => Promise<RemoteResultLike<{
+        workflows: readonly PublishedWorkflowView[];
+    }>>;
+    /** Unpublish one of the caller's workflows. */
+    readonly unpublishMine?: (id: string) => Promise<boolean>;
+    /** Resubmit one rejected/unpublished workflow. */
+    readonly resubmitMine?: (id: string) => Promise<boolean>;
+}
+/**
+ * Build the plaza's dependencies from Host services.
+ *
+ * Both reads are total: a failed remote call becomes an empty-or-unchanged answer the
+ * caller can react to, never a thrown error inside a render.
+ *
+ * @param host - the wiring described by {@link WorkflowPlazaHost}.
+ * @returns dependencies the plaza and its orchestration consume.
+ */
+export declare function workflowPlazaDeps(host: WorkflowPlazaHost): WorkflowPlazaDeps;
+export {};