@cerebriline/core 4.100.246 → 4.100.247

package/dist/extensions/tools/team/runtime.d.ts

@@ -2,5 +2,5 @@ export { type AgentSlotGate, type AgentSlotGateRegistry, agentEndpointKey, agent
 export { buildDelegatedAgentConfig, createDelegatedAgent, createDelegatedAgentConfigProvider, type DelegatedAgentConfigProvider, type DelegatedAgentConnectionConfig, type DelegatedAgentKind, type DelegatedAgentRuntimeConfig, type DelegatedPrepareTurnTarget, } from "./delegated-agent";
 export { buildSubagentLayout, pinConversationHead, SUBAGENT_BASE_PROMPT, type SubagentKnowledge, type SubagentLayout, } from "./subagent-layout";
 export { createSpawnAgentTool, type SpawnAgentInput, type SpawnAgentOutput, type SpawnAgentToolConfig, type SubAgentEndContext, type SubAgentStartContext, } from "./spawn-agent-tool";
-export { type AgentTask, AgentTeam, AgentTeamsRuntime, type AgentTeamsRuntimeOptions, createAgentTeam, createWorkerReviewerTeam, type SpawnTeammateOptions, type TaskResult, type TeamEvent, type TeamMemberConfig, } from "./multi-agent";
+export { type AgentTask, AgentTeam, AgentTeamsRuntime, type AgentTeamsRuntimeOptions, createAgentTeam, createWorkerReviewerTeam, type SpawnTeammateOptions, type TaskResult, type TeamEvent, type TeamMemberConfig, type TeamRuntimeStateDelta, } from "./multi-agent";
 export { type BootstrapAgentTeamsOptions, type BootstrapAgentTeamsResult, bootstrapAgentTeams, type CreateAgentTeamsToolsOptions, createAgentTeamsTools, reviveTeamStateDates, sanitizeTeamName, type TeamTeammateRuntimeConfig, } from "./team-tools";

package/dist/extensions/tools/team/sanitize-team-name.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Normalizes a team name into a safe storage key: lowercase, runs of
+ * disallowed characters collapsed to `-`, leading/trailing `-` trimmed.
+ */
+export declare function sanitizeTeamName(name: string): string;

package/dist/extensions/tools/team/team-tools.d.ts

@@ -1,3 +1,4 @@
+export { sanitizeTeamName } from "./sanitize-team-name";
 import { type AgentTool, type TeamTeammateSpec } from "@cerebriline/shared";
 import { type DelegatedAgentConfigProvider, type DelegatedAgentRuntimeConfig } from "./delegated-agent";
 import type { AgentTeamsRuntime } from "./multi-agent";
@@ -53,4 +54,3 @@ export declare const TEAMMATE_TEAM_TOOL_NAMES: ReadonlySet<string>;
 export declare function bootstrapAgentTeams(options: BootstrapAgentTeamsOptions): BootstrapAgentTeamsResult;
 export declare function createAgentTeamsTools(options: CreateAgentTeamsToolsOptions): AgentTool[];
 export { reviveTeamStateDates } from "./team-state-dates";
-export declare function sanitizeTeamName(name: string): string;

package/dist/hooks/checkpoint-hooks.d.ts

@@ -1,5 +1,20 @@
-import type { AgentHooks, BasicLogger } from "@cerebriline/shared";
+import type { AgentHooks, BasicLogger, ITelemetryService } from "@cerebriline/shared";
 export declare function isCheckpointStashMessage(message: string): boolean;
+/**
+ * Per-session scratch directory holding the persistent `GIT_INDEX_FILE` used
+ * to snapshot untracked files. Persisting the index across turns lets git's
+ * stat cache skip re-reading (and re-hashing) untracked files that have not
+ * changed since the previous checkpoint — without it, every turn re-hashes
+ * every untracked byte in the workspace.
+ *
+ * Lives under the user's Cline data dir (never the world-shared OS tmpdir:
+ * the index and pathspec files enumerate workspace paths) and is keyed by a
+ * hash of cwd + session id: hashing avoids sanitization collisions between
+ * distinct ids, and folding in cwd keeps a session restored against a
+ * different workspace from inheriting a foreign index. Removed by
+ * `deleteCheckpointRefs` and by the age-based reaper.
+ */
+export declare function checkpointScratchDir(cwd: string, sessionId: string): string;
 export interface CheckpointEntry {
     ref: string;
     createdAt: number;
@@ -26,6 +41,13 @@ type CreateCheckpointHooksOptions = {
         sessionId: string;
         runCount: number;
     }) => Promise<CheckpointEntry | undefined> | CheckpointEntry | undefined;
+    /**
+     * Emits one `checkpoint.snapshot` event per built-in snapshot attempt so
+     * snapshot cost and degradations (HEAD fallbacks, skipped turns) are
+     * observable in the field, not only in local logs. Properties carry
+     * outcome and duration — never file paths or contents.
+     */
+    telemetry?: Pick<ITelemetryService, "capture">;
 };
 /**
  * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that

package/dist/hooks/hook-file-hooks.d.ts

@@ -1,4 +1,19 @@
 import type { AgentExtension, AgentHooks, BasicLogger, WorkspaceInfo } from "@cerebriline/shared";
+import { type HookEventName } from "./subprocess";
+/**
+ * Reports how long a fire-and-forget hook actually ran, once per hook. Hosts
+ * use it to learn the real runtime distribution of detached hooks —
+ * unmeasurable while nothing awaits them — before deciding to run any of them
+ * blocking. `exited: false` is a censored observation (the hook was still
+ * running after the observation window, so it ran at least `durationMs`),
+ * which is what keeps the sample from covering only hooks that finish.
+ */
+export type HookRuntimeObserver = (event: {
+    hookName: HookEventName;
+    durationMs: number;
+    exitCode: number | null;
+    exited: boolean;
+}) => void;
 type HookRuntimeOptions = {
     cwd: string;
     workspacePath: string;
@@ -7,6 +22,18 @@ type HookRuntimeOptions = {
     toolCallTimeoutMs?: number;
     /** Keep asynchronous hooks attached until exit. Intended for deterministic tests. */
     detachAsyncHooks?: boolean;
+    /**
+     * Run agent_start/agent_resume hooks blocking, honoring their control
+     * output (cancel, contextModification). Off by default: these hooks have
+     * always been fire-and-forget with stdio ignored, so an existing
+     * long-running script would otherwise stall every run start until the
+     * timeout. A host that flips this on must tell hook authors that
+     * long-running run-start hooks need to background themselves (spawn a
+     * detached child and exit).
+     */
+    blockingRunStartHooks?: boolean;
+    /** Observes how long detached hooks run. See {@link HookRuntimeObserver}. */
+    onHookRuntime?: HookRuntimeObserver;
     /** Structured git + path metadata forwarded into every hook payload. */
     workspaceInfo?: WorkspaceInfo;
 };

package/dist/hooks/subprocess-runner.d.ts

@@ -9,6 +9,29 @@ export interface RunSubprocessEventOptions {
         pid?: number;
         detached: boolean;
     }) => void;
+    /**
+     * Reports a detached hook's runtime exactly once. The run never waits on
+     * this: detached hooks are fire-and-forget by contract, and this only
+     * observes them so hosts can measure how long they actually take.
+     *
+     * `exited: true` means the hook finished and `durationMs` is its runtime.
+     * `exited: false` is a censored observation: the hook was still running
+     * after the observation window, and `durationMs` is that window, so read
+     * it as "ran at least this long" and count these separately — the
+     * case that matters most, since those are the hooks that would stall a
+     * blocking run. Without it the sample would only contain hooks that
+     * finished.
+     *
+     * Nothing is reported if the parent exits before either happens.
+     */
+    onDetachedSettled?: (event: {
+        command: string[];
+        durationMs: number;
+        exitCode: number | null;
+        exited: boolean;
+    }) => void;
+    /** Overrides the censoring window for `onDetachedSettled`. */
+    detachedObservationMs?: number;
 }
 export interface RunSubprocessEventResult {
     exitCode: number | null;

package/dist/hooks/subprocess.d.ts

@@ -49,6 +49,16 @@ export interface SubprocessHooksOptions {
     workspaceInfo?: WorkspaceInfo;
     env?: NodeJS.ProcessEnv;
     timeoutMs?: number;
+    /**
+     * Run agent_start/agent_resume hooks blocking, honoring their control
+     * output (cancel, contextModification). Off by default: these hooks have
+     * always been fire-and-forget with stdio ignored, so an existing
+     * long-running script would otherwise stall every run start until the
+     * timeout. A host that flips this on must tell hook authors that
+     * long-running run-start hooks need to background themselves (spawn a
+     * detached child and exit).
+     */
+    blockingRunStartHooks?: boolean;
     onDispatchError?: (error: Error, payload: HookEventPayload) => void;
     onDispatch?: (event: {
         payload: HookEventPayload;

package/dist/hub/client/index.d.ts

@@ -1,13 +1,33 @@
 import { type HubClientRegistration, type HubCommandEnvelope, type HubEventEnvelope, type HubReplyEnvelope } from "@cerebriline/shared";
 import { type HubOwnerContext } from "../discovery";
+type HubCommandOptions = {
+    timeoutMs?: number | null;
+    /** Synchronous local guard, checked after connection before each dispatch. */
+    beforeDispatch?: () => void;
+    /** Observes this attempt's correlation id after the local guard, before sending.
+     * Dispatch alone does not confirm that the server accepted the command. */
+    onDispatch?: (requestId: string) => void;
+};
 export interface HubClientOptions {
     url: string;
     clientId?: string;
     clientType?: string;
     displayName?: string;
+    /** Version reported to the hub; defaults to the @cline/core version. */
+    clientVersion?: string;
+    /** Additional registration metadata; version and pid are owned by the client. */
+    metadata?: Record<string, unknown>;
     workspaceRoot?: string;
     cwd?: string;
+    /** Hub token sent with the `cline-hub-auth.*` WebSocket subprotocol. */
     authToken?: string;
+    /**
+     * Resolves HTTP headers for each new WebSocket, including reconnects.
+     * This Node-only transport option is mutually exclusive with `authToken`.
+     * Resolver failures are surfaced by `connect()` and `getConnectionError()`;
+     * `Sec-WebSocket-Protocol` must be configured through `authToken` instead.
+     */
+    resolveConnectionHeaders?: () => Readonly<Record<string, string>> | Promise<Readonly<Record<string, string>>>;
     capabilities?: HubClientRegistration["capabilities"];
 }
 export interface LocalHubResolutionOptions {
@@ -15,6 +35,11 @@ export interface LocalHubResolutionOptions {
     strategy?: "prefer-hub" | "require-hub";
     workspaceRoot?: string;
     cwd?: string;
+    /**
+     * Called with the error when starting a detached Hub fails. The function
+     * still resolves `undefined` in that case; this lets a caller report why.
+     */
+    onStartupError?: (error: unknown) => void;
 }
 export type HubTransportErrorCode = "hub_connect_timeout" | "hub_connect_failed" | "hub_connection_closed" | "hub_connection_not_open";
 export declare class HubTransportError extends Error {
@@ -57,6 +82,7 @@ export declare class NodeHubClient {
     private reconnectTimer;
     private reconnectAttempt;
     private closedByClient;
+    private connectGeneration;
     private lastCloseError;
     private sawSocketClose;
     private registered;
@@ -68,12 +94,11 @@ export declare class NodeHubClient {
     getConnectionError(): HubTransportError | null;
     updateCapabilities(capabilities: NonNullable<HubClientRegistration["capabilities"]>): Promise<void>;
     connect(): Promise<void>;
+    private openSocket;
     subscribe(listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;
     }): () => void;
-    command(command: HubCommandEnvelope["command"], payload?: Record<string, unknown>, sessionId?: string, options?: {
-        timeoutMs?: number | null;
-    }): Promise<HubReplyEnvelope>;
+    command(command: HubCommandEnvelope["command"], payload?: Record<string, unknown>, sessionId?: string, options?: HubCommandOptions): Promise<HubReplyEnvelope>;
     private commandOnce;
     private recoverLocalHubTransport;
     private hasActiveSubscriptions;
@@ -144,3 +169,4 @@ export declare function restartLocalHubIfIdleAfterStartupTimeout(options: {
     workspaceRoot?: string;
     cwd?: string;
 }): Promise<string | undefined>;
+export {};

package/dist/hub/client/session-client.d.ts

@@ -56,11 +56,8 @@ export interface HubTeamProgressHandlers {
     onError?: (error: Error) => void;
 }
 export declare class HubSessionClient {
-    private readonly options;
     private readonly client;
-    private metadataApplied;
     constructor(options: HubSessionClientOptions);
-    private ensureMetadataApplied;
     connect(): Promise<void>;
     private taskCommand;
     close(): void;

package/dist/hub/daemon/bind-diagnostics.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Best-effort description of who holds the Hub port when the daemon dies with
+ * `EADDRINUSE`. The daemon takes the owner instance lock before binding, so an
+ * occupant on the port is never a live Hub for this owner; these details tell
+ * us what it actually is (an older pre-lock Hub, a leaked handle, another
+ * owner context, or an unrelated program) so the fix can target that case.
+ */
+import type { TelemetryProperties } from "@cerebriline/shared";
+/** `lsof -Fpc` emits `p<pid>` then `c<command>` per process. */
+export declare function parseLsofOwners(output: string): string[];
+/** Telemetry context for a `hub.daemon.startup` failure caused by `EADDRINUSE`. */
+export declare function describeAddressInUse(error: unknown, endpoint: {
+    host: string;
+    port: number;
+    pathname: string;
+}): Promise<TelemetryProperties>;