dsh-cool-session 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,30 @@
+/**
+ * Client half of the package-private bridge to the Host routes.
+ *
+ * Every route answers JSON and never rejects: a transport failure becomes an
+ * `{ ok: false }` result the dialog reports in place, so the page has exactly
+ * one failure shape to render no matter how the answer went wrong.
+ */
+import type { DeleteManyPayload, DeletePayload } from '../shared/contract.js';
+/**
+ * Ask the Host to delete one Session and every subagent Session beneath it.
+ *
+ * The Host stops running work first, then removes the artifacts.
+ *
+ * @param sessionId - the root Session to delete.
+ * @returns the deletion summary, or a coded refusal.
+ */
+export declare function deleteSession(sessionId: string): Promise<DeletePayload>;
+/**
+ * Ask the Host to delete several Sessions.
+ *
+ * The Host runs the same stop-then-remove sequence as {@link deleteSession} for
+ * each id, sequentially, and answers one result per id. When this Host half does
+ * not serve the batch route yet, the same work is done through the single route
+ * so the panel keeps working across a live plugin upgrade and a later restart.
+ *
+ * @param sessionIds - the root Sessions to delete, in request order.
+ * @returns the per-session summaries, or a request-level refusal.
+ */
+export declare function deleteSessions(sessionIds: readonly string[]): Promise<DeleteManyPayload>;
+//# sourceMappingURL=api.d.ts.map

package/lib/types/client/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/client/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AA6B7E;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAEvE;AA0BD;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAqB9F"}

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

@@ -0,0 +1,43 @@
+/**
+ * Archive and unarchive through DSH's own Workspace controller.
+ *
+ * The browser already holds a live Workspace snapshot and a generated remote
+ * namespace for it, so archival does not need a route of this plugin's own: the
+ * controller's call keeps the archive set authoritative on the Host and pushes
+ * the new set to every connected surface. The single failure worth wording
+ * separately is the Host's refusal of a Session with running work: the panel
+ * offers to stop that work and retry, exactly as the native sidebar does.
+ */
+import type { Failure } from '../shared/contract.js';
+/** One family of work that keeps a Session from being archived. */
+export interface ArchiveActivity {
+    /** Provider family: `turn`, `subagent`, `job`, `schedule`, or one this build does not know. */
+    readonly kind: string;
+    /** Number of active items the family reported. */
+    readonly count: number;
+}
+/**
+ * One archive attempt's outcome.
+ *
+ * `active` is the Host's "stop this first" answer; every other refusal is
+ * either a code the page words from its dictionary (`failure`), a missing
+ * service (`unavailable`), or raw diagnostic text (`message`).
+ */
+export interface ArchiveResult {
+    readonly ok: boolean;
+    readonly active?: readonly ArchiveActivity[];
+    readonly failure?: Failure;
+    readonly unavailable?: boolean;
+    readonly message?: string;
+}
+/**
+ * Archive or restore one Session.
+ *
+ * @param workspaces - the client Workspace service, when the composition mounts one.
+ * @param sessionId - the Session to move between the two sets.
+ * @param archived - which set it should end in.
+ * @param stopActivity - ask the Host to stop running work instead of refusing.
+ * @returns the outcome the panel renders.
+ */
+export declare function setSessionArchived(workspaces: any, sessionId: string, archived: boolean, stopActivity: boolean): Promise<ArchiveResult>;
+//# sourceMappingURL=archive.d.ts.map

package/lib/types/client/archive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../../../src/client/archive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAEpD,mEAAmE;AACnE,MAAM,WAAW,eAAe;IAC9B,+FAA+F;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAC1B;AA2BD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,GAAG,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,EACjB,YAAY,EAAE,OAAO,GACpB,OAAO,CAAC,aAAa,CAAC,CA2BxB"}

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

@@ -0,0 +1,32 @@
+/**
+ * The plugin's icon artwork, built from `src/client/assets/*.svg`.
+ *
+ * The client bundle is one JS file the platform's module loader evaluates, so
+ * sibling asset files would never be fetched. tsdown.config.ts reads the artwork
+ * at build time and exposes it as the `__DSH_CS_ICONS__` string map this module
+ * consumes, keyed by asset filename stem — the arrangement dsh-cool-git uses.
+ *
+ * dsh-cool-git renders each asset as a React component because those glyphs live
+ * in its own trees. This plugin's glyphs have different owners: the Settings
+ * navigation cell is shell-owned DOM, so the archive artwork is exposed as the
+ * markup the patch writes into that seat (the way dsh-cool-theme installs its
+ * palette); the filter caret is drawn by this package's own page, so its markup
+ * is embedded the same way inside the trigger. Parsing still happens once, at
+ * module evaluation, with the same viewBox/inner split.
+ */
+/**
+ * The Sessions glyph as complete markup for the shell's navigation seat.
+ *
+ * It carries its own 16px size because the asset's `1em` would resolve against
+ * the nav cell's 14px text, and the stroke is `currentColor`, so the glyph takes
+ * the label's color in both appearances.
+ */
+export declare const ARCHIVE_NAV_MARKUP: string;
+/**
+ * The caret beside the panel's two filter triggers.
+ *
+ * `assets/arrow-down.svg` strokes with `currentColor`, so the trigger's label
+ * color reaches it; the fixed 12px keeps it clear of the control's 13px text.
+ */
+export declare const ARROW_DOWN_MARKUP: string;
+//# sourceMappingURL=icons.d.ts.map

package/lib/types/client/icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons.d.ts","sourceRoot":"","sources":["../../../src/client/icons.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA8CH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAuC,CAAA;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAuC,CAAA"}

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

@@ -0,0 +1,28 @@
+/**
+ * Client entry for dsh-cool-session.
+ *
+ * Contributes one native Session-menu row, the frame-wide confirmation it
+ * opens, and the Sessions section of the Settings panel. The row lives in
+ * `sidebar.workspaces.session.menu.item`; the dialog lives in `shell.overlay`,
+ * because the menu unmounts as soon as it closes and cannot own a dialog that
+ * must outlive that click; the section lives in `settings.section`, which the
+ * settings shell projects into its navigation.
+ *
+ * The section reads the shell's Session and Workspace stores directly and
+ * archives through the Workspace controller, so only deletion — the operation
+ * the client face does not expose — needs this package's own Host route.
+ */
+export declare const name = "dsh-cool-session/client";
+/**
+ * The locale service is a required collaborator rather than an optional one.
+ *
+ * The confirmation is worded entirely from this package's dictionaries, so a
+ * composition without the service could only draw the wrong language: declaring
+ * the dependency is what makes the framework apply this plugin once the service
+ * is there, and what makes `ctx.get('locale')` below answer. DSH mounts the
+ * service with the web client tree itself (`@deepseek-ai/dsh-web-app`), so
+ * nothing this menu row can run in is without it.
+ */
+export declare const inject: string[];
+export declare function apply(ctx: any): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,eAAO,MAAM,IAAI,4BAA4B,CAAA;AAE7C;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,UAAsB,CAAA;AAiBzC,wBAAgB,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAiHpC"}

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

@@ -0,0 +1,143 @@
+/**
+ * The confirmation's copy, in the two locales DSH ships.
+ *
+ * Every sentence the dialog draws lives here rather than at the point it is
+ * drawn, for two reasons. The page is what knows the language to read in — the
+ * Host does not — so a refusal reaches it as a code (see `shared/contract.ts`)
+ * and is worded from the `error.<code>` entry below; and the locale service
+ * re-renders the dialog when the language is switched, which only works if the
+ * copy is looked up at render time through the `t` seat rather than captured in
+ * a constant.
+ *
+ * The two dictionaries must carry exactly the same keys: `zh` is typed as
+ * `typeof en`, so a key added to one and forgotten in the other is a compile
+ * error rather than a dialog that falls back mid-sentence.
+ *
+ * Count-bearing sentences come in the `.one` / `.other` pair the shipped
+ * dictionaries use. The locale service interpolates `{name}` placeholders but
+ * does not choose plural forms, so the caller picks the spelling from the count
+ * through {@link countKey}; Chinese spells both variants the same way.
+ */
+import type { FailureCode } from '../shared/contract.js';
+/** The dictionary namespace this page owns. */
+export declare const NS = "coolSession";
+/**
+ * The messages whose wording follows a count.
+ *
+ * Each base owns a `.one` and an `.other` entry; nothing else may be drawn from
+ * it, so a missing plural spelling is a compile error like any other key.
+ */
+export type PluralBase = 'sessions.bulkPartial' | 'sessions.bulkStopped' | 'sessions.bulkArchivePartial' | 'sessions.bulkArchiveFailed' | 'sessions.activitySubagents' | 'sessions.activityJobs' | 'sessions.activitySchedules' | 'sessions.activityOther';
+/** The copy of the menu row, the Settings page, the confirmations, and their refusals. */
+type UiKey = 
+/** The native Session menu's row. */
+'action.delete'
+/** The Settings navigation entry and the page behind it. */
+ | 'settings.nav' | 'settings.title' | 'settings.description'
+/** The management panel's controls. */
+ | 'sessions.search' | 'sessions.searchPlaceholder' | 'sessions.allWorkspaces' | 'sessions.noWorkspace' | 'sessions.allSessions' | 'sessions.unarchived' | 'sessions.archived' | 'sessions.running' | 'sessions.selectAll' | 'sessions.selectOne' | 'sessions.archiveSelected' | 'sessions.deleteSelected' | 'sessions.selectedCount' | 'sessions.columnTitle' | 'sessions.columnStatus' | 'sessions.columnActions' | 'sessions.archive' | 'sessions.unarchive' | 'sessions.delete'
+/** The management panel's list states. */
+ | 'sessions.loading' | 'sessions.empty' | 'sessions.noMatches' | 'sessions.loadFailed' | 'sessions.retry' | 'sessions.unavailable' | 'sessions.actionFailed'
+/** The panel's delete confirmation. */
+ | 'sessions.deleteSelectedTitle' | 'sessions.deleteBatchDescription'
+/** The panel's stop-and-archive confirmation. */
+ | 'sessions.archiveStopTitle' | 'sessions.archiveStopDescription' | 'sessions.archiveActivity' | 'sessions.activityTurn' | 'sessions.archiveStopAction' | 'sessions.archiveStopPending'
+/** The count-bearing messages, in their singular and plural spellings. */
+ | `${PluralBase}.one` | `${PluralBase}.other`
+/** The native menu's confirmation and both dialogs' buttons. */
+ | 'action.cancel' | 'action.close' | 'delete.title' | 'delete.description' | 'delete.pending' | 'delete.confirm'
+/** A Host half that has not reloaded the new delete route yet. */
+ | 'error.host-stale';
+/** Every key the page draws from, including the refusal codes. */
+export type MessageKey = UiKey | `error.${FailureCode}`;
+/**
+ * The translate seat the page draws through.
+ *
+ * A key and its placeholder values, read at call time: the function a locale
+ * switch hands out is a new one, which is what re-renders the dialog.
+ */
+export type Translate = (key: MessageKey, params?: Readonly<Record<string, string | number>>) => string;
+/**
+ * Pick the singular or plural spelling of a count-bearing message.
+ *
+ * @param base - the message family, whose `.one` and `.other` entries exist.
+ * @param count - the number the sentence reports.
+ * @returns the key to translate.
+ */
+export declare function countKey(base: PluralBase, count: number): MessageKey;
+/** The English copy, which is also the fallback every lookup ends at. */
+export declare const en: {
+    'action.delete': string;
+    'action.cancel': string;
+    'action.close': string;
+    'settings.nav': string;
+    'settings.title': string;
+    'settings.description': string;
+    'sessions.search': string;
+    'sessions.searchPlaceholder': string;
+    'sessions.allWorkspaces': string;
+    'sessions.noWorkspace': string;
+    'sessions.allSessions': string;
+    'sessions.unarchived': string;
+    'sessions.archived': string;
+    'sessions.running': string;
+    'sessions.selectAll': string;
+    'sessions.selectOne': string;
+    'sessions.archiveSelected': string;
+    'sessions.deleteSelected': string;
+    'sessions.selectedCount': string;
+    'sessions.columnTitle': string;
+    'sessions.columnStatus': string;
+    'sessions.columnActions': string;
+    'sessions.archive': string;
+    'sessions.unarchive': string;
+    'sessions.delete': string;
+    'sessions.loading': string;
+    'sessions.empty': string;
+    'sessions.noMatches': string;
+    'sessions.loadFailed': string;
+    'sessions.retry': string;
+    'sessions.unavailable': string;
+    'sessions.actionFailed': string;
+    'sessions.bulkPartial.one': string;
+    'sessions.bulkPartial.other': string;
+    'sessions.bulkStopped.one': string;
+    'sessions.bulkStopped.other': string;
+    'sessions.bulkArchivePartial.one': string;
+    'sessions.bulkArchivePartial.other': string;
+    'sessions.bulkArchiveFailed.one': string;
+    'sessions.bulkArchiveFailed.other': string;
+    'sessions.deleteSelectedTitle': string;
+    'sessions.deleteBatchDescription': string;
+    'sessions.archiveStopTitle': string;
+    'sessions.archiveStopDescription': string;
+    'sessions.archiveActivity': string;
+    'sessions.activityTurn': string;
+    'sessions.activitySubagents.one': string;
+    'sessions.activitySubagents.other': string;
+    'sessions.activityJobs.one': string;
+    'sessions.activityJobs.other': string;
+    'sessions.activitySchedules.one': string;
+    'sessions.activitySchedules.other': string;
+    'sessions.activityOther.one': string;
+    'sessions.activityOther.other': string;
+    'sessions.archiveStopAction': string;
+    'sessions.archiveStopPending': string;
+    'delete.title': string;
+    'delete.description': string;
+    'delete.pending': string;
+    'delete.confirm': string;
+    'error.host-stale': string;
+    'error.missing-session': string;
+    'error.unknown-session': string;
+    'error.subagent-delete': string;
+    'error.delete-failed': string;
+    'error.delete-unsupported': string;
+    'error.delete-active': string;
+    'error.session-live': string;
+    'error.delete-partial': string;
+};
+/** The Chinese copy, key for key the same page. */
+export declare const zh: typeof en;
+export {};
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,+CAA+C;AAC/C,eAAO,MAAM,EAAE,gBAAgB,CAAA;AAE/B;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAClB,sBAAsB,GACtB,sBAAsB,GACtB,6BAA6B,GAC7B,4BAA4B,GAC5B,4BAA4B,GAC5B,uBAAuB,GACvB,4BAA4B,GAC5B,wBAAwB,CAAA;AAE5B,0FAA0F;AAC1F,KAAK,KAAK;AACR,qCAAqC;AACnC,eAAe;AACjB,4DAA4D;GAC1D,cAAc,GACd,gBAAgB,GAChB,sBAAsB;AACxB,uCAAuC;GACrC,iBAAiB,GACjB,4BAA4B,GAC5B,wBAAwB,GACxB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,mBAAmB,GACnB,kBAAkB,GAClB,oBAAoB,GACpB,oBAAoB,GACpB,0BAA0B,GAC1B,yBAAyB,GACzB,wBAAwB,GACxB,sBAAsB,GACtB,uBAAuB,GACvB,wBAAwB,GACxB,kBAAkB,GAClB,oBAAoB,GACpB,iBAAiB;AACnB,0CAA0C;GACxC,kBAAkB,GAClB,gBAAgB,GAChB,oBAAoB,GACpB,qBAAqB,GACrB,gBAAgB,GAChB,sBAAsB,GACtB,uBAAuB;AACzB,uCAAuC;GACrC,8BAA8B,GAC9B,iCAAiC;AACnC,iDAAiD;GAC/C,2BAA2B,GAC3B,iCAAiC,GACjC,0BAA0B,GAC1B,uBAAuB,GACvB,4BAA4B,GAC5B,6BAA6B;AAC/B,0EAA0E;GACxE,GAAG,UAAU,MAAM,GACnB,GAAG,UAAU,QAAQ;AACvB,gEAAgE;GAC9D,eAAe,GACf,cAAc,GACd,cAAc,GACd,oBAAoB,GACpB,gBAAgB,GAChB,gBAAgB;AAClB,kEAAkE;GAChE,kBAAkB,CAAA;AAEtB,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,WAAW,EAAE,CAAA;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,CACtB,GAAG,EAAE,UAAU,EACf,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,KAC/C,MAAM,CAAA;AAEX;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAEpE;AAED,yEAAyE;AACzE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EuB,CAAA;AAEtC,mDAAmD;AACnD,eAAO,MAAM,EAAE,EAAE,OAAO,EA8EvB,CAAA"}

package/lib/types/client/nav-icon.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The archive glyph on the Settings panel's Sessions entry.
+ *
+ * A section registration carries a label, not an icon: the shipped settings
+ * shell picks its navigation glyph from the section id (`navIcon(row.id)` in
+ * ui-settings-general), and every id it does not know — a plugin's id included —
+ * gets the generic gear. The entry therefore owns its glyph the only way a
+ * plugin can: after the cell renders, hide the shell's gear and put the parsed
+ * `assets/archive.svg` artwork in the seat beside the label. dsh-cool-theme
+ * patches its palette into the same seat for the same reason.
+ *
+ * Matching is by the rendered label rather than by class hash, because the
+ * shell's CSS module hashes rotate between releases. The observer only watches
+ * child-list changes: opening and closing Settings replaces the cell's children,
+ * while typing elsewhere in the page usually edits text nodes and must not
+ * trigger a scan.
+ */
+import { type Translate } from './locales.js';
+/**
+ * Keep the Sessions entry's glyph patched for the plugin's lifetime.
+ *
+ * Runs once for a panel that is already open and again whenever the shell mounts
+ * or re-renders the navigation. The disposer removes the inserted spans and
+ * restores the gears, so an HMR update does not leave two glyphs in the seat.
+ *
+ * @param t - the plugin's translate seat, for the current locale's label.
+ * @returns the disposer that stops observation and restores the shell's DOM.
+ */
+export declare function installSessionNavIcon(t: Translate): () => void;
+//# sourceMappingURL=nav-icon.d.ts.map

package/lib/types/client/nav-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nav-icon.d.ts","sourceRoot":"","sources":["../../../src/client/nav-icon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AA6DrD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,IAAI,CA8B9D"}

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

@@ -0,0 +1,24 @@
+/**
+ * One Host answer's refusal, as the sentence a page shows.
+ *
+ * A coded refusal is worded here from the page's dictionary, so the same answer
+ * reads in the active language; diagnostics another program wrote stay verbatim.
+ * Both the native menu's dialog and the management panel render their failures
+ * through this one function, which keeps the two surfaces agreeing about a
+ * partial deletion's detail line.
+ */
+import type { DeletePayload } from '../shared/contract.js';
+import type { MessageKey, Translate } from './locales.js';
+/** The refusal fragment any Host answer may carry. */
+type Refusal = Pick<DeletePayload, 'failure' | 'error'>;
+/**
+ * Word one refused answer.
+ *
+ * @param t - the page's translate seat.
+ * @param payload - the Host answer.
+ * @param fallback - the entry to state when the answer carried no reason.
+ * @returns the reason to show.
+ */
+export declare function reasonOf(t: Translate, payload: Refusal, fallback: MessageKey): string;
+export {};
+//# sourceMappingURL=reason.d.ts.map

package/lib/types/client/reason.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reason.d.ts","sourceRoot":"","sources":["../../../src/client/reason.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAEzD,sDAAsD;AACtD,KAAK,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,OAAO,CAAC,CAAA;AAEvD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,CAYrF"}

package/lib/types/client/session-menu.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The native Session menu's delete row and its confirmation overlay.
+ *
+ * The row is contributed to `sidebar.workspaces.session.menu.item` by builds
+ * that have no `contextMenus` service; the client entry registers a plain-data
+ * action instead wherever that service exists, because the shipped Archive row
+ * is a footer action and only a footer action can follow it. Menus unmount as
+ * soon as they close, so either row only records a request; the frame-wide
+ * `shell.overlay` entry owns the dialog's state and the Host call. That split is
+ * also what lets the dialog survive the menu's portal disappearing on click.
+ *
+ * Deletion is permanent, so the confirmation is the only path: it asks before
+ * the Host stops running work and removes the artifacts, and disables itself
+ * while that happens.
+ */
+import { type ReactElement } from 'react';
+import type { Translate } from './locales.js';
+/**
+ * Open the delete confirmation for one Session.
+ *
+ * @param sessionId - the Session the menu row belongs to.
+ */
+export declare function requestDeleteSession(sessionId: string): void;
+/** Dismiss the confirmation without deleting. */
+export declare function clearDeleteRequest(): void;
+/**
+ * Stop drawing the legacy Slot row.
+ *
+ * The client entry installs that row when `apply` runs before `contextMenus` is
+ * mounted; the service then contributes Delete as a footer action so it can
+ * follow Archive. This flag keeps the two paths from drawing the row twice.
+ */
+export declare function retireLegacyDeleteRow(): void;
+/** The menu row's owner share and the slot's menu-open hook. */
+interface DeleteMenuItemProps {
+    readonly sessionId: string;
+    readonly useMenuOpenState: () => readonly [boolean, (open: boolean) => void];
+    readonly t: Translate;
+}
+/**
+ * The legacy delete row for builds without `contextMenus`, placed after Copy
+ * Session ID and separated from the shipped group. Selecting it closes the menu
+ * and raises the confirmation overlay.
+ *
+ * @param props - the row identity, menu hook, and locale seat.
+ * @returns the menu row, or null once the menu service owns it.
+ */
+export declare function SessionDeleteMenuItem({ sessionId, useMenuOpenState, t, }: DeleteMenuItemProps): ReactElement | null;
+/** The dialog's injected callback, supplied by the client entry. */
+interface DeleteDialogProps {
+    readonly t: Translate;
+    /** Called after a successful deletion so the shell can clear its main view. */
+    readonly onDeleted?: (sessionId: string) => void;
+}
+/**
+ * The frame-wide confirmation entry, drawn with DSH's own `Modal` primitive so
+ * its chrome, blurred mask, focus trap, and Escape handling match the rest of
+ * the product instead of being re-implemented here.
+ *
+ * @param props - the locale seat and the post-delete callback.
+ * @returns the dialog, or null while no delete is pending.
+ */
+export declare function SessionDeleteDialog({ t, onDeleted }: DeleteDialogProps): ReactElement | null;
+export {};
+//# sourceMappingURL=session-menu.d.ts.map

package/lib/types/client/session-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-menu.d.ts","sourceRoot":"","sources":["../../../src/client/session-menu.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAA6C,KAAK,YAAY,EAAE,MAAM,OAAO,CAAA;AAIpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAyB7C;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAG5D;AAED,iDAAiD;AACjD,wBAAgB,kBAAkB,IAAI,IAAI,CAIzC;AAKD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,gEAAgE;AAChE,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,CAAA;IAC5E,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAA;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,gBAAgB,EAChB,CAAC,GACF,EAAE,mBAAmB,GAAG,YAAY,GAAG,IAAI,CAiB3C;AAED,oEAAoE;AACpE,UAAU,iBAAiB;IACzB,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAA;IACrB,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;CACjD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,EAAE,iBAAiB,GAAG,YAAY,GAAG,IAAI,CAmE5F"}

package/lib/types/client/settings-section.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The Sessions page of the Settings panel: list, search, filter, selection,
+ * archive, and deletion.
+ *
+ * The list itself is not fetched here. DSH already keeps the Host-authoritative
+ * Session catalog and Workspace archive set in the two client stores the shell
+ * exposes to every slot (`useSessions` / `useWorkspaces`), and every archive is
+ * a Workspace-controller call whose reply updates those stores. Reading them
+ * directly means this page shares the sidebar's rows and running states instead
+ * of maintaining a second, drifting catalog; deletion is the one operation the
+ * client face does not expose, so it still crosses this package's own Host
+ * route.
+ *
+ * Search is deliberately title-only: the row's title is the display title the
+ * shell computes (durable title, then project directory name, then id), so the
+ * text a reader can see in the row is exactly the text the box matches.
+ */
+import { type ReactElement } from 'react';
+import type { ArchiveResult } from './archive.js';
+import { type Translate } from './locales.js';
+/** The selector-hook shape DSH hands every slot component. */
+type SelectorHook = (selector: (state: any) => any) => any;
+/** The section's injected share: the locale seat plus the Host-backed actions. */
+export interface SessionsSectionProps {
+    readonly t: Translate;
+    readonly useSessions: SelectorHook;
+    readonly useWorkspaces: SelectorHook;
+    /** Archive or restore one Session through the Workspace controller. */
+    readonly setArchived?: (sessionId: string, archived: boolean, stopActivity: boolean) => Promise<ArchiveResult>;
+    /** Ask the Session catalog to refresh after a deletion. */
+    readonly refresh?: () => void;
+    /** Clear the shell's main view when its Session disappeared. */
+    readonly onDeleted?: (sessionId: string) => void;
+}
+/**
+ * Render the Sessions page.
+ *
+ * @param props - the locale seat, the two catalog hooks, and the injected actions.
+ * @returns the management surface and its confirmations.
+ */
+export declare function SessionsSection({ t, useSessions, useWorkspaces, setArchived, refresh, onDeleted, }: SessionsSectionProps): ReactElement;
+export {};
+//# sourceMappingURL=settings-section.d.ts.map

package/lib/types/client/settings-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-section.d.ts","sourceRoot":"","sources":["../../../src/client/settings-section.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAwC,KAAK,YAAY,EAAE,MAAM,OAAO,CAAA;AAO/E,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,cAAc,CAAA;AAClE,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAGxE,8DAA8D;AAC9D,KAAK,YAAY,GAAG,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG,CAAA;AAkC1D,kFAAkF;AAClF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAA;IAClC,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAA;IACpC,uEAAuE;IACvE,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;IAC9G,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;CACjD;AA8LD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAC9B,CAAC,EACD,WAAW,EACX,aAAa,EACb,WAAW,EACX,OAAO,EACP,SAAS,GACV,EAAE,oBAAoB,GAAG,YAAY,CA4jBrC"}

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

@@ -0,0 +1,26 @@
+/**
+ * Package-owned stylesheet for the plugin's three surfaces.
+ *
+ * The native Session menu row and both confirmations are drawn by DSH's own
+ * primitives, so this sheet only adds the danger tint on the legacy menu row and
+ * on the dialogs' confirm action, the inline refusal blocks, and the Settings
+ * page's own controls and table. (Where the menu service carries Delete, its
+ * `danger` flag supplies the red row instead.) The section follows the shipped
+ * sections' heading and row rhythm. Every color is a `--dsw-*` theme token, so
+ * every surface follows the active light or dark appearance — including
+ * third-party theme presets — instead of forcing a palette of its own.
+ */
+/**
+ * Insert the stylesheet once for the plugin lifetime.
+ *
+ * The tag carries the platform's style-ownership record — `data-plugin` with this
+ * package's id, which is what every DSH bundle writes on the tags it injects. A
+ * tag carrying no attribute is claimed by whichever module materializes next and
+ * deleted with it, so naming the owner here keeps the sheet this plugin's own:
+ * only a reload of `dsh-cool-session` retires it, and this effect's disposer
+ * removes it then anyway.
+ *
+ * @returns disposer that removes exactly this element.
+ */
+export declare function insertStyles(): () => void;
+//# sourceMappingURL=styles.d.ts.map

package/lib/types/client/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/client/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAyGH;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,IAAI,MAAM,IAAI,CASzC"}

package/lib/types/host/deletion.d.ts

@@ -0,0 +1,26 @@
+/**
+ * On-disk Session deletion, including the subagent Sessions beneath one root.
+ *
+ * DSH exposes no deletion command of its own, so this Host module treats the
+ * Session artifact as the unit of removal. It first stops whatever the Session
+ * still runs, retires the live Session entry, and only then removes the
+ * header-verified directory. Paths never come from the request: every directory
+ * is derived from the persistence backend's own `locate()` answer and checked
+ * to be exactly one Session directory below the configured root.
+ *
+ * The operation is intentionally fail-closed. A descendant scan that cannot be
+ * completed, a directory that leaves the root, a symlink, an artifact whose
+ * header names another Session, or a Session that cannot be retired all abort
+ * the delete before the first `rm`. A failure after some descendants were
+ * already removed is reported as `delete-partial`, with the remaining ids.
+ */
+import type { DeletePayload } from '../shared/contract.js';
+/**
+ * Delete one Session and every subagent Session beneath it.
+ *
+ * @param ctx - the Host plugin context.
+ * @param sessionId - the root Session to delete.
+ * @returns the deletion summary, or one coded refusal.
+ */
+export declare function deleteSession(ctx: any, sessionId: string): Promise<DeletePayload>;
+//# sourceMappingURL=deletion.d.ts.map

package/lib/types/host/deletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deletion.d.ts","sourceRoot":"","sources":["../../../src/host/deletion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,uBAAuB,CAAA;AA4ahF;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAsGvF"}

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

@@ -0,0 +1,20 @@
+/**
+ * Host entry for dsh-cool-session.
+ *
+ * The browser half owns the native Session-menu row and its confirmation; this
+ * half owns the one destructive artifact operation behind that confirmation.
+ * Every question the page asks crosses a same-origin HTTP route served by the
+ * `webServer` carrier, because an out-of-tree bundle cannot generate a
+ * `ctx.remote` namespace and its Client half never sees the Host Cordis context.
+ *
+ * The Session and Agent capabilities are read per request rather than declared
+ * as hard dependencies: a composition without them still loads the plugin and
+ * answers one clear refusal instead of failing the menu row.
+ */
+export declare const name = "dsh-cool-session";
+/** The web carrier is a hard dependency: without it there is no route to serve. */
+export declare const inject: string[];
+/** The route table, exported so a probe or test can address the route by name. */
+export { ROUTES } from './routes.js';
+export declare function apply(ctx: any): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/host/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/host/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,eAAO,MAAM,IAAI,qBAAqB,CAAA;AAEtC,mFAAmF;AACnF,eAAO,MAAM,MAAM,UAAgB,CAAA;AAEnC,kFAAkF;AAClF,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,wBAAgB,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAIpC"}

package/lib/types/host/refusal.d.ts

@@ -0,0 +1,25 @@
+/**
+ * How one Host answer refuses, in the two forms the payloads carry.
+ *
+ * A refusal this plugin can name travels as a code, because the page is what
+ * knows the language to word it in: `shared/contract.ts` defines the code and
+ * its params, and `client/locales.ts` owns the sentences. Anything else is text
+ * another program wrote — a DSH service message above all — which no dictionary
+ * can own, so it travels verbatim.
+ */
+import type { Failure, FailureCode } from '../shared/contract.js';
+/** One refusal, as an `ok: false` payload carries it. */
+export type Refusal = {
+    readonly failure: Failure;
+} | {
+    readonly error: string;
+};
+/**
+ * One coded refusal, shaped as a payload carries it.
+ *
+ * @param code - the refusal, whose sentence the page owns.
+ * @param params - the values that sentence interpolates, when it has any.
+ * @returns the payload fragment to spread into an `ok: false` answer.
+ */
+export declare function coded(code: FailureCode, params?: Readonly<Record<string, string | number>>): Refusal;
+//# sourceMappingURL=refusal.d.ts.map

package/lib/types/host/refusal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusal.d.ts","sourceRoot":"","sources":["../../../src/host/refusal.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEjE,yDAAyD;AACzD,MAAM,MAAM,OAAO,GACf;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9B;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,GAAG,OAAO,CAEpG"}

package/lib/types/host/routes.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The Host half's HTTP surface.
+ *
+ * The browser half has no Cordis context and no remote namespace of its own, so
+ * the destructive command crosses same-origin routes registered on the
+ * `webServer` carrier: one Session per request from the native menu, and one
+ * selection per request from the management panel. The routes answer JSON and
+ * never reject: a transport, service, or filesystem failure becomes an
+ * `{ ok: false }` result the page reports in place.
+ *
+ * The Host stays authoritative about *what* is deleted. A request names a
+ * Session id but never a directory or an Agent: the artifact path is derived and
+ * verified by `deletion.ts`, never by the caller. That keeps the page a
+ * management surface over DSH's own state rather than a second source of truth.
+ */
+/** Route table, kept in one place so the two halves cannot drift. */
+export declare const ROUTES: {
+    readonly delete: "/dsh-cool-session/api/delete";
+    readonly deleteMany: "/dsh-cool-session/api/delete-many";
+};
+/**
+ * Serve the deletion routes for one plugin instance.
+ *
+ * @param ctx - the Host plugin context.
+ * @returns a disposer that unregisters exactly this route.
+ */
+export declare function registerRoutes(ctx: any): () => void;
+//# sourceMappingURL=routes.d.ts.map

package/lib/types/host/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../src/host/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,qEAAqE;AACrE,eAAO,MAAM,MAAM;;;CAGT,CAAA;AAqIV;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,IAAI,CAwCnD"}