@hydraharness/harness-client-runtime 0.0.0-stage → 0.1.1-rc.7

package/lib/types/client/workspaces/manager.d.ts

@@ -0,0 +1,182 @@
+/** Workspace baseline, incremental-frame, and unary-action owner. */
+import type { HostFrame, IApiClient, RpcError, RpcRequest, RpcResult, SessionId, WorkspaceId, WorkspaceView } from '@hydraharness/harness-api-remotes/client';
+import { type WorkspaceCreateInput } from './workspace.ts';
+/** Monotone workspace-list arrival lifecycle. */
+export type WorkspaceListPhase = 'pending' | 'ready';
+/** Immutable workspace-list snapshot. */
+export interface WorkspaceListSnapshot {
+    items: readonly WorkspaceView[];
+    /**
+     * Registry-global archive set in Host order (hidden from grouping
+     * surfaces; accounting slots retained). A plain array, not a Set: public
+     * snapshot state stays in the store engine's plain-data vocabulary
+     * (immer drafts reject Sets without the MapSet plugin); membership
+     * lookups build their own transient Set where they need one.
+     */
+    archivedSessionIds: readonly SessionId[];
+    state: 'idle' | 'loading' | 'error';
+    phase: WorkspaceListPhase;
+    error: RpcError | null;
+}
+/** Workspace object cluster driven by one list baseline and changed-frame upserts. */
+export declare class WorkspaceManager {
+    private readonly api;
+    private items;
+    private itemViewsSource;
+    private itemViewsCache;
+    private archivedSessionIds;
+    private state;
+    private phase;
+    private error;
+    private inflight;
+    private refreshFrames;
+    /**
+     * True once a frame or unary echo installed the archive set while a list
+     * request was in flight: that install is newer than the pending baseline,
+     * so the baseline's (older) set must not roll it back — the archive
+     * mirror of replaying refreshFrames over the item baseline.
+     */
+    private archivedSupersedesRefresh;
+    /** Latest local reorder request; only its unary echo may install order. */
+    private orderRequestGeneration;
+    /** Increments on order frames so a later remote commit outranks an older unary echo. */
+    private orderFrameGeneration;
+    /** Last complete order accepted from a Host baseline, frame, or current unary echo. */
+    private committedOrder;
+    /**
+     * Ids this process has seen removed, kept for the connection's lifetime so
+     * a late changed frame or a stale baseline row cannot resurrect a deleted
+     * row. Correctness rests on Host ids never being reused (the registry mints
+     * a fresh `randomUUID` per record, including when the same directory is
+     * registered again) — a path-derived id scheme would turn these entries
+     * into permanent blindfolds and must clear them instead.
+     */
+    private readonly removedIds;
+    private snapshotCache;
+    private readonly notifier;
+    /** @param api - shared wire client. */
+    constructor(api: IApiClient);
+    /**
+     * Refresh from workspace.list. The first successful response establishes
+     * Host order; later responses re-establish the durable order so reconnects
+     * adopt reorders committed while this client was offline. Frames arriving
+     * during the RPC are replayed over its response.
+     * @returns the shared in-flight refresh.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Create or resolve a real Workspace, then publish its returned snapshot
+     * without waiting for the changed frame.
+     * @param input - the existing absolute path to adopt.
+     * @returns the wire result.
+     */
+    create(input: WorkspaceCreateInput): Promise<RpcResult<{
+        workspace: WorkspaceView;
+        created: boolean;
+    }>>;
+    /**
+     * Rename a Workspace, then publish its returned snapshot without waiting
+     * for the changed frame.
+     * @param workspaceId - target workspace.
+     * @param title - new display title.
+     * @returns the wire result.
+     */
+    rename(workspaceId: WorkspaceId, title: string): Promise<RpcResult<{
+        workspace: WorkspaceView;
+    }>>;
+    /**
+     * Delete a Workspace registration and remove its local projection from the
+     * unary response without waiting for the Host frame.
+     * @param workspaceId - target workspace.
+     * @returns the wire result.
+     */
+    delete(workspaceId: WorkspaceId): Promise<RpcResult<{
+        deleted: true;
+    }>>;
+    /**
+     * Move a Workspace within the registry display order and install the full
+     * returned order without waiting for the Host frame.
+     * @param workspaceId - Workspace to move.
+     * @param beforeWorkspaceId - Anchor workspace; omitted appends.
+     * @returns the wire result.
+     */
+    insertBefore(workspaceId: WorkspaceId, beforeWorkspaceId?: WorkspaceId): Promise<RpcResult<{
+        workspaceIds: WorkspaceId[];
+    }>>;
+    /**
+     * Move a session within its Workspace's manual order, then publish the
+     * returned snapshot without waiting for the changed frame.
+     * @param workspaceId - owning workspace.
+     * @param sessionId - accounted session to move.
+     * @param beforeSessionId - accounted anchor to insert before; omitted appends.
+     * @returns the wire result.
+     */
+    insertSessionBefore(workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId): Promise<RpcResult<{
+        workspace: WorkspaceView;
+    }>>;
+    /**
+     * Archive one session in the registry-global set, then install the
+     * returned full set without waiting for the changed frame.
+     * @param sessionId - session to archive.
+     * @returns the wire result.
+     */
+    archiveSession(sessionId: SessionId): Promise<RpcResult<{
+        archivedSessionIds: SessionId[];
+    }>>;
+    /**
+     * Restore one session from the registry-global archive set, then install
+     * the returned full set without waiting for the changed frame.
+     * @param sessionId - session to restore.
+     * @returns the wire result.
+     */
+    unarchiveSession(sessionId: SessionId): Promise<RpcResult<{
+        archivedSessionIds: SessionId[];
+    }>>;
+    /**
+     * Prepend a session onto a materialized Workspace account without waiting
+     * for the Host changed frame. `session.create({ workspaceId })` has already
+     * attached; New Session reads this list in the same turn for reuse and the
+     * hero composer. Live items update immediately; an in-flight `workspace.list`
+     * is not patched, so a stale baseline can drop the id until the later
+     * changed frame. Direct adopt avoids recording a full-view upsert into
+     * that refresh replay, which would replace a newer Host row.
+     * @param workspaceId - Workspace that just attached the session.
+     * @param sessionId - attached session.
+     */
+    accountSession(workspaceId: WorkspaceId, sessionId: SessionId): void;
+    /**
+     * Host-frame entry. Non-workspace frames are ignored so the runtime can
+     * fan one host stream out to both object managers.
+     * @param envelope - host stream envelope.
+     */
+    handleHostEnvelope(envelope: RpcRequest<HostFrame>): void;
+    /** Re-pull the baseline after each connection generation. */
+    handleConnected(): void;
+    /**
+     * Subscribe to workspace snapshot invalidation.
+     * @param listener - snapshot invalidation callback.
+     * @returns unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Read the cached workspace snapshot after flushing pending notifications.
+     * @returns the cached workspace snapshot.
+     */
+    getSnapshot(): WorkspaceListSnapshot;
+    private buildSnapshot;
+    /**
+     * Replace the archive set when membership actually changed (array identity
+     * backs Object.is short-circuits). Host snapshots are append-ordered, so
+     * positional comparison is exact, not merely heuristic.
+     */
+    private installArchived;
+    /** Reorder known Workspace objects, optionally recording a Host-committed sequence. */
+    private installOrder;
+    /** Upsert one Host view, optionally retaining the local object that materialized it. */
+    private upsert;
+    /** Remove one id idempotently and retain a tombstone against late echoes. */
+    private remove;
+    private installViews;
+    private itemViews;
+}
+//# sourceMappingURL=manager.d.ts.map

package/lib/types/client/workspaces/path.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolve a workspace-relative path into the Host-facing spelling used by openPath.
+ * @param cwd - session workspace root, when known.
+ * @param path - absolute or workspace-relative path.
+ * @returns an absolute path when a workspace root is available, otherwise the original path.
+ */
+export declare function resolveWorkspacePath(cwd: string | undefined, path: string): string;
+/**
+ * Display-only POSIX home abbreviation. Windows drive and UNC paths stay
+ * verbatim, including when `home` itself is a Windows path. A missing, empty,
+ * or filesystem-root `home` leaves `path` unchanged so `/` cannot become `~`.
+ * @param path - absolute or already-short display path.
+ * @param home - host account home from `host.describe`; absent skips abbreviation.
+ * @returns `~` or `~/…` for the POSIX home and its descendants, otherwise `path`.
+ */
+export declare function abbreviateHomePath(path: string, home?: string): string;
+//# sourceMappingURL=path.d.ts.map

package/lib/types/client/workspaces/service.d.ts

@@ -0,0 +1,179 @@
+/** WorkspaceRuntime projects the Workspace object manager for UI consumers. */
+import type { Context } from '@hydraharness/cordis';
+import type { DirectoryListing, IApiClient, RpcError, SessionId, WorkspaceId, WorkspaceView } from '@hydraharness/harness-api-remotes/client';
+import type { SnapshotStore } from '../contract/store.ts';
+import type { SessionsPort } from '../contract/sessions-port.ts';
+import type { IWorkspaces } from '../contract/workspaces.ts';
+import { WorkspaceManager, type WorkspaceListPhase } from './manager.ts';
+/** Workspace list plus the two-baseline readiness and default-target projection. */
+export interface WorkspaceListState {
+    items: readonly WorkspaceView[];
+    /**
+     * Registry-global archive set in Host order: grouping surfaces hide these
+     * sessions everywhere (workspace groups and the ungrouped bucket) while
+     * their session logs and workspace accounting slots remain. A plain array
+     * (store-engine vocabulary; immer drafts reject Sets) — membership lookups
+     * build their own transient Set.
+     */
+    archivedSessionIds: readonly SessionId[];
+    state: 'idle' | 'loading' | 'error';
+    phase: WorkspaceListPhase;
+    error: RpcError | null;
+    /** True only after both workspace.list and session.list have succeeded. */
+    baselinesReady: boolean;
+    /** Most recently active Workspace, derived without changing `items` order. */
+    recentWorkspaceId: WorkspaceId | undefined;
+}
+/** Structured create failure for UI flows that distinguish Host business errors. */
+export declare class WorkspaceCreateError extends Error {
+    readonly rpcError: RpcError;
+    constructor(rpcError: RpcError);
+}
+/** Structured browse failure so the directory browser can branch on Host business codes. */
+export declare class DirectoryBrowseError extends Error {
+    readonly rpcError: RpcError;
+    constructor(rpcError: RpcError);
+}
+/** Real Workspace object layer and Host actions. */
+export declare class WorkspaceRuntime implements IWorkspaces {
+    private readonly api;
+    private readonly sessions;
+    /** UI-facing immutable projection; the manager remains wire truth. */
+    readonly list: SnapshotStore<WorkspaceListState>;
+    /** Workspace baseline and frame owner. */
+    private readonly manager;
+    /** In-flight blank-session connects keyed by workspace (reuse or create). */
+    private readonly connecting;
+    /** Guards the runtime-owned one-shot initial-selection subscription. */
+    private initialSelectionStarted;
+    /**
+     * @param ctx - client root context.
+     * @param api - shared wire client.
+     * @param sessions - cross-domain sessions face used for recency and blank-session reuse.
+     */
+    constructor(ctx: Context, api: IApiClient, sessions: SessionsPort);
+    /**
+     * Resolve the session a New Session flow lands in once this Workspace is
+     * chosen: explicitly adopt the workspace's existing blank session when one
+     * is in the list mirror, else create a fresh one on the host
+     * (`session.create` births or resumes the full Session+Agent — the client
+     * holds no intermediate state). The adoption tells optional default owners
+     * that this exact session passed the reuse checks.
+     * caller owns navigation: take the returned id to `sessions.open`.
+     * Resolution guarantee (both arms): the returned id is already in the list
+     * store and `sessions.binding(id)` resolves synchronously — draft hand-off
+     * may write the new scope's machine before opening. The create arm also
+     * fills the session row's cwd from the Workspace path and prepends the id
+     * onto that Workspace's local `sessionIds` before resolving, so the hero
+     * composer and a follow-up reuse scan do not wait for Host frames.
+     * @param workspaceId - chosen Workspace (must be in the workspace list).
+     * @returns the reused or newly created session id.
+     */
+    connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId>;
+    /**
+     * Follow the first complete Workspace/Session baseline and select a default
+     * session exactly once. A restored current session wins; otherwise the most
+     * recent Workspace is connected (reusing or creating its blank session).
+     * Later explicit clears stay cleared instead of retriggering this startup
+     * policy. A failed connect may retry on the next baseline projection.
+     * @returns disposer for the baseline subscription; late work cannot navigate after disposal.
+     */
+    startInitialSelection(): () => void;
+    /**
+     * The shared New Session action behind the shell entry points (sidebar
+     * button, workspace browser): resolve the target Workspace — explicit wins,
+     * then the current Session's Workspace, then the recent-Workspace
+     * projection — connect its blank session and navigate there; with no
+     * Workspace at all, clear the selection into the New Session view state.
+     * Connect failures are non-fatal (console diagnostics; the current view
+     * stays usable).
+     * @param workspaceId - explicit target Workspace for scoped actions.
+     */
+    startSession(workspaceId?: WorkspaceId): void;
+    /**
+     * Register an existing path as a Workspace.
+     * @param input - the Host create payload.
+     * @returns the created or idempotently resolved Workspace.
+     */
+    create(input: {
+        path: string;
+    }): Promise<WorkspaceView>;
+    /**
+     * Open the Host's native directory picker (the `native` capability).
+     * @returns the selected path, or null when the user cancelled.
+     */
+    pickDirectory(): Promise<string | null>;
+    /**
+     * List one directory level through the Host's `browse` capability.
+     * @param path - absolute directory to list; absent lists the Host home directory.
+     * @param signal - aborts the wire request (and the Host's scan) when the caller supersedes it.
+     * @returns the level's listing with breadcrumb ancestry.
+     */
+    listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
+    /**
+     * Create one child directory through the Host's `browse` capability.
+     * @param path - absolute existing parent directory.
+     * @param name - single non-blank path segment.
+     * @returns the created directory's absolute path.
+     */
+    createDirectory(path: string, name: string): Promise<string>;
+    /**
+     * Open a filesystem path with the Host operating system's default application.
+     * @param path - absolute or host-resolvable path.
+     */
+    openPath(path: string): Promise<void>;
+    /**
+     * Rename a Workspace.
+     * @param workspaceId - target workspace.
+     * @param title - new display title (trimmed non-empty by the Host).
+     * @returns the renamed Workspace view.
+     */
+    rename(workspaceId: WorkspaceId, title: string): Promise<WorkspaceView>;
+    /**
+     * Delete one Workspace registration. Sessions, session logs, and the
+     * directory remain Host-owned outside this operation.
+     * @param workspaceId - target workspace.
+     */
+    delete(workspaceId: WorkspaceId): Promise<void>;
+    /**
+     * Move a Workspace within the durable registry display order.
+     * @param workspaceId - Workspace to move.
+     * @param beforeWorkspaceId - Anchor workspace; omitted appends.
+     */
+    insertBefore(workspaceId: WorkspaceId, beforeWorkspaceId?: WorkspaceId): Promise<void>;
+    /**
+     * Archive a session into the registry-global set. Clearing an archived
+     * current selection is the projection sweep's job (one rule for the local
+     * echo and a remote tab's frame alike).
+     * @param sessionId - session to archive.
+     */
+    archiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Restore a session from the registry-global archive set. Its retained
+     * Workspace account makes it reappear under the same Workspace.
+     * @param sessionId - session to restore.
+     */
+    unarchiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Move a session within its Workspace's manual order (DOM-insertBefore-like).
+     * @param workspaceId - owning workspace.
+     * @param sessionId - accounted session to move.
+     * @param beforeSessionId - accounted anchor to insert before; omitted appends.
+     * @returns the updated Workspace view.
+     */
+    insertSessionBefore(workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId): Promise<WorkspaceView>;
+    /**
+     * Refresh the workspace baseline, reusing an in-flight pull.
+     * @returns completion of the current or newly started workspace baseline pull.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Route a Host stream envelope into the Workspace object layer.
+     * @param envelope - validated Host stream envelope.
+     */
+    handleHostEnvelope(envelope: Parameters<WorkspaceManager['handleHostEnvelope']>[0]): void;
+    /** Rebuild the Workspace baseline after connection. */
+    handleConnected(): void;
+    private project;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/types/client/workspaces/workspace.d.ts

@@ -0,0 +1,65 @@
+/** React-free Workspace entity with a client-local materialization lifecycle. */
+import type { IApiClient, RpcResult, WorkspaceView } from '@hydraharness/harness-api-remotes/client';
+import type { ObservableSnapshot } from '../contract/store.ts';
+/** Host input retained by a local Workspace until materialization succeeds. */
+export type WorkspaceCreateInput = {
+    path: string;
+};
+/** Observable state of a client-local Workspace intent. */
+export interface WorkspaceIntentSnapshot {
+    name: string;
+    phase: 'ready' | 'creating';
+    error?: string;
+}
+/** A Workspace is either a local intent or a materialized Host view. */
+export interface WorkspaceSnapshot {
+    view: WorkspaceView | undefined;
+    intent: WorkspaceIntentSnapshot | undefined;
+}
+/**
+ * Observable Workspace object whose identity survives Host materialization.
+ * Local instances retain their create input and failure state; materialized
+ * instances expose the latest Host view.
+ */
+export declare class Workspace implements ObservableSnapshot<WorkspaceSnapshot> {
+    private readonly api;
+    private view;
+    private intent;
+    private materialization;
+    private snapshotCache;
+    private readonly notifier;
+    /**
+     * @param api - shared wire client.
+     * @param source - local create input or an existing Host Workspace view.
+     */
+    constructor(api: IApiClient, source: WorkspaceCreateInput | WorkspaceView);
+    /**
+     * Materialize this local Workspace through the Host create API.
+     * Re-entry shares the in-flight completion; a materialized instance returns undefined.
+     * @returns the Host result, or undefined when this Workspace is already materialized.
+     */
+    materialize(): Promise<RpcResult<{
+        workspace: WorkspaceView;
+        created: boolean;
+    }>> | undefined;
+    /**
+     * Adopt a Host view without replacing this Workspace object.
+     * An existing materialized identity accepts updates only for the same Workspace id.
+     * @param view - latest Host projection.
+     */
+    adopt(view: WorkspaceView): void;
+    /**
+     * Subscribe to Workspace snapshot invalidation.
+     * @param listener - snapshot invalidation callback.
+     * @returns unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Read the cached Workspace snapshot after flushing pending notifications.
+     * @returns the cached Workspace snapshot.
+     */
+    getSnapshot(): WorkspaceSnapshot;
+    private completeMaterialization;
+    private buildSnapshot;
+}
+//# sourceMappingURL=workspace.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+/** Host loader entry for the browser runtime exported from `./client` and `./loader`. */
+/** Host plugin body — no host-side behavior for the runtime plugin. */
+export declare function apply(_ctx: unknown): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@hydraharness/harness-client-runtime`.
+ * @module @hydraharness/harness-client-runtime/invariant
+ */
+import type { Context } from '@hydraharness/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-runtime-invariant";
+/** Service required before the companion can register. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/package.json

@@ -1,6 +1,97 @@
 {
   "name": "@hydraharness/harness-client-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Client core services: SlotRegistry, SessionRuntime (scope tree + object layer)",
+  "version": "0.1.1-rc.7",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MaiHongPhong1902/Hydra-Harness.git",
+    "directory": "packages/client/runtime"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "hydra": {
+    "plugin": {
+      "application": "Keep the interface's session and workspace state synchronized with Host updates."
+    },
+    "client": {
+      "inject": [
+        "@hydraharness/harness-client-connection",
+        "@hydraharness/harness-typert-registry",
+        "@hydraharness/harness-api-remotes"
+      ],
+      "platform": "web",
+      "immediately": true
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "immer": "^11.1.18",
+    "zustand": "~4.4.7"
+  },
+  "peerDependencies": {
+    "@hydraharness/cordis": "^4.0.2",
+    "@hydraharness/harness-api-remotes": "^0.1.1-rc.7",
+    "@hydraharness/harness-invariants": "^0.1.1-rc.7",
+    "@hydraharness/harness-typert-registry": "^0.1.1-rc.7",
+    "@hydraharness/harness-typert-protocol": "^0.1.1-rc.7",
+    "@hydraharness/harness-agent": "^0.1.1-rc.7",
+    "@hydraharness/harness-attachment": "^0.1.1-rc.7",
+    "@hydraharness/harness-client-connection": "^0.1.1-rc.7",
+    "@hydraharness/harness-commands": "^0.1.1-rc.7",
+    "@hydraharness/harness-llm-retry": "^0.1.1-rc.7",
+    "@hydraharness/harness-host-apiproxy": "^0.1.1-rc.7",
+    "@hydraharness/harness-llm": "^0.1.1-rc.7",
+    "@hydraharness/harness-session": "^0.1.1-rc.7",
+    "@hydraharness/harness-session-projection": "^0.1.1-rc.7",
+    "@hydraharness/harness-session-title": "^0.1.1-rc.7",
+    "@hydraharness/harness-tools": "^0.1.1-rc.7"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0",
+    "@hydraharness/cordis": "^4.0.2",
+    "@hydraharness/harness-invariants": "^0.1.1-rc.7",
+    "@hydraharness/harness-timeout": "^0.1.1-rc.7",
+    "@hydraharness/harness-typert-protocol": "^0.1.1-rc.7",
+    "@hydraharness/harness-typert-registry": "^0.1.1-rc.7",
+    "@hydraharness/harness-api-remotes": "^0.1.1-rc.7",
+    "@hydraharness/harness-client-ui-slots": "^0.1.1-rc.7",
+    "@hydraharness/harness-agent": "^0.1.1-rc.7",
+    "@hydraharness/harness-attachment": "^0.1.1-rc.7",
+    "@hydraharness/harness-client-connection": "^0.1.1-rc.7",
+    "@hydraharness/harness-commands": "^0.1.1-rc.7",
+    "@hydraharness/harness-llm": "^0.1.1-rc.7",
+    "@hydraharness/harness-host-apiproxy": "^0.1.1-rc.7",
+    "@hydraharness/harness-session": "^0.1.1-rc.7",
+    "@hydraharness/harness-session-projection": "^0.1.1-rc.7",
+    "@hydraharness/harness-tools": "^0.1.1-rc.7",
+    "@hydraharness/harness-session-title": "^0.1.1-rc.7",
+    "@hydraharness/harness-llm-retry": "^0.1.1-rc.7"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ]
 }