@quantiya/codevibe-claude-plugin 2.0.101 → 2.0.103

package/node_modules/@quantiya/codevibe-core/dist/local-executor/binary-classifier.d.ts

@@ -18,6 +18,14 @@ export type FileClass = {
     kind: 'other';
     format: 'audio' | 'video' | 'archive' | 'other_binary';
 };
+/** P63 Slice 3 — a captured file's class when it is not text; a diff entry without one is text (§10.1). */
+export type StoredFileClass = Exclude<FileClass, {
+    kind: 'text';
+}>;
+/** The same class — `null` / absent is text (§10.1). Compares the class a capture recorded with the class of bytes read later. */
+export declare function sameStoredClass(a: StoredFileClass | null | undefined, b: StoredFileClass | null | undefined): boolean;
+/** A well-formed stored class, exactly as `classifyFile` returns it (records are read back from disk). */
+export declare function isStoredFileClass(value: unknown): value is StoredFileClass;
 /** §10.2: per-part inflate output limit (64 MiB). */
 export declare const MAX_OFFICE_PART_BYTES: number;
 /**

package/node_modules/@quantiya/codevibe-core/dist/local-executor/blob-store.d.ts

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs/promises';
 import type { BlobRef } from './change-manifest';
+import { type FileSource, type StoredFileClass } from './binary-classifier';
 import { type StoreAnchor } from './store-dir-anchor';
 export declare const BLOB_CHUNK_BYTES: number;
 /** One instance's blob namespace in a task state directory. */
@@ -80,6 +81,10 @@ export declare function readBlobChunks(store: BlobStore, ref: BlobRef): AsyncGen
  * mismatch before anything is published). Opened no-follow; must be a regular file of exactly `ref.size` bytes.
  */
 export declare function openBlobForStreaming(store: BlobStore, ref: BlobRef): Promise<fs.FileHandle>;
+/** P63 Slice 3 — random access to one stored blob for the duration of `fn` (the blob is verified as a regular file). */
+export declare function withBlobSource<T>(store: BlobStore, ref: BlobRef, fn: (source: FileSource) => Promise<T>): Promise<T>;
+/** P63 Slice 3 (§10.1) — a blob's class, read through random access to the stored bytes; null for text. */
+export declare function classifyBlob(store: BlobStore, ref: BlobRef): Promise<StoredFileClass | null>;
 /**
  * P63 Slice 2 (§9.4) — the strict-text rule of `decodeStrictUtf8` (valid UTF-8, no NUL byte) checked while streaming,
  * for a file too large to decode whole. Throws the same "binary file changes are not supported safely" refusal.

package/node_modules/@quantiya/codevibe-core/dist/local-executor/change-manifest.d.ts

@@ -1,3 +1,4 @@
+import { type StoredFileClass } from './binary-classifier';
 import type { ShadowChangeKind } from './shadow-protocol';
 export declare const CHANGE_MANIFEST_VERSION = 1;
 export declare const CHANGE_MANIFEST_SHARD_ENTRIES = 10000;
@@ -20,6 +21,10 @@ export interface ChangeManifestEntry {
      * track's declared base mode); a single task's manifest omits it and its lines are unchanged.
      */
     base_mode?: number | null;
+    /** P63 Slice 3 (§10.1): the reviewed post-image's class when it is not text. Absent: text (every older line). */
+    file_class?: StoredFileClass;
+    /** P63 Slice 3 (§10.1): the pre-task file's class when it is not text. Absent: text. */
+    base_class?: StoredFileClass;
 }
 export interface ChangeManifestShard {
     /** SHA-256 (hex) of `bytes`; the shard's name in the store. */

package/node_modules/@quantiya/codevibe-core/dist/local-executor/local-executor-impl.d.ts

@@ -8,6 +8,7 @@ import { TrackRegistry } from './track-registry';
 import { AgentKind, AuthorityAction, ClassBInbound, GateDispatchPayload, HookEvent, ImplementorHandle, LocalExecutor, MergeGateDispatchPayload, ProbeHandle, ProcessRole, ReviewerDispatchPayload, ReviseFeedbackPayload, QueuedWorkEndedPayload, ReviewerHandle, SpawnArgs, TrackAssignedPayload, type DurableSessionResourceDisposeOptions, type WorkspaceDisposeOptions } from './types';
 import { type TeamExecution } from './team-execution-flag';
 import { type SnapshotBundlesView, type SnapshotMergeGateResult } from './snapshot-merge';
+import { type TeamMediaAsker } from './team-media-approval';
 import { type WorkspaceRootAuthority } from './workspace-authority';
 import type { RenderedConflict, TrackIntentDiff } from './wb2-review-bundle';
 import type { ConflictModelCaller } from './class2-resolver';
@@ -371,6 +372,8 @@ export interface LocalExecutorImplDeps {
     }) => Promise<void>;
     /** Optional shadow lifecycle hooks shared with implementor workspaces. */
     snapshotShadowEnv?: ShadowEnv;
+    /** P63 Slice 3 §9.5 — ask a team's media question once, before its merged result is applied (team-media-approval.ts). */
+    askTeamMediaApproval?: TeamMediaAsker;
     /** Mark a successfully accepted group terminal and reclaim its bundle state. */
     completeSnapshotGroup?: (taskGroupId: string) => Promise<void>;
     /** Normal-exit retirement of all ordinary durable resources from this session. */

package/node_modules/@quantiya/codevibe-core/dist/local-executor/media-metadata.d.ts

@@ -0,0 +1,16 @@
+/**
+ * P63 Slice 3 Phase B — §8.1 / §9.5: what the INDEX and the phone question say about a withheld file (audio, video,
+ * archives, other binary): its container type, and its duration where the container states one. Read through the same
+ * random-access `FileSource` as the classifier, header fields only — never the media data. Malformed or unknown input
+ * yields `unknown` / no duration; a read error from the source propagates (the store failed, not the file).
+ */
+import type { FileSource } from './binary-classifier';
+export interface MediaMetadata {
+    /** A short container name for people: "MPEG-4 (MP4)", "WAV", "ZIP", … or "unknown". */
+    container: string;
+    /** Whole seconds, when the container header states the duration (MP4/MOV/M4A `mvhd`, WAV byte rate). */
+    durationSeconds: number | null;
+}
+export declare function readMediaMetadata(source: FileSource): Promise<MediaMetadata>;
+/** "0:45", "1:04", "1:02:03". */
+export declare function formatDuration(seconds: number): string;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/shadow-protocol.d.ts

@@ -1,3 +1,4 @@
+import { type StoredFileClass } from './binary-classifier';
 import * as fs from 'node:fs/promises';
 import type { BlobRef } from './change-manifest';
 import type { ChangeManifestRecord } from './change-manifest-store';
@@ -41,6 +42,8 @@ export declare const DEFAULT_MATERIALIZER_LANES = 4;
 export declare const SHADOW_UUID_SUFFIX_RE: RegExp;
 /** §6.2's per-spawn advisory records live in the v2 state root beside the task folders, never as a task. */
 export declare const SHADOW_STATE_ADVISORY_DIR = "advisory";
+/** P63 §9.5: the open team media questions (`team-media-approval.ts`) live in the v2 state root, never as a task. */
+export declare const SHADOW_STATE_TEAM_MEDIA_DIR = "team-media-questions";
 export declare function isStateRootInfrastructureDirectory(name: string): boolean;
 export declare function taskIdFromGeneratedShadowName(name: string): string | null;
 /** Strict lifecycle-lock residue authored by `withAnchoredExclusiveLock`. */
@@ -129,7 +132,24 @@ export interface ShadowDiffFile {
      * anchored copy. Absent for deletions and for records written before Slice 2.
      */
     blob?: BlobRef;
+    /** P63 Slice 3 (§10.1) — the new version's class when it is not text (created/modified). Absent: text. */
+    file_class?: StoredFileClass;
+    /** P63 Slice 3 (§10.1) — the user's version's class when it is not text (modified/deleted). Absent: text. */
+    base_class?: StoredFileClass;
 }
+/** P63 Slice 3 — the class fields of a stored diff entry are well formed and sit on the change kinds they describe. */
+export declare function assertDiffFileClasses(file: {
+    change_kind: unknown;
+    content?: unknown;
+    blob?: unknown;
+    file_class?: unknown;
+    base_class?: unknown;
+}, label: string): void;
+/** P63 Slice 3 — a change that is binary on either side: whole-file, never decoded as text or line-merged (§10.3). */
+export declare function isBinaryDiffFile(file: {
+    file_class?: unknown;
+    base_class?: unknown;
+}): boolean;
 /**
  * P63 Slice 2 (§9.4) — a diff entry's optional blob reference is well formed and agrees with its inline content:
  * never on a deletion, a 64-hex SHA-256 and a byte size equal to the content's UTF-8 length.
@@ -138,6 +158,8 @@ export declare function assertDiffBlobRef(file: {
     change_kind: unknown;
     content: unknown;
     blob?: unknown;
+    file_class?: unknown;
+    base_class?: unknown;
 }, label: string): void;
 /**
  * P63 Slice 2 (§9.4) — text above this many bytes is carried as a blob reference only (`content: ''`): it is never

package/node_modules/@quantiya/codevibe-core/dist/local-executor/shadow-slice3-cleanups.d.ts

@@ -0,0 +1,15 @@
+import { type ShadowEnv } from './shadow-protocol';
+import type { WorkspaceRootAuthority } from './workspace-authority';
+/** F-P0-1 — remove the state directory a failed create made, by its creation identity and only when it is empty. */
+export declare function removeEmptyCreatedStateDir(createdStateDir: WorkspaceRootAuthority | null, taskId: string): Promise<void>;
+/**
+ * §11 / §16 G2 — a task's capture dirs whose task no longer exists are removed by exact path: the task has no state
+ * directory and is not kept by this desktop. A link is never followed; anything that is not a real directory is left.
+ * The task folder goes too when that leaves it empty.
+ */
+export declare function removeOrphanCaptureDirs(keepTaskIds: ReadonlySet<string>, env?: ShadowEnv): Promise<string[]>;
+/**
+ * The orphan reap's last step: once, against this desktop's own (v2) roots, after every pass decided what it keeps. Not
+ * after an aborted or failed sweep (`skip`). Never fatal to the sweep.
+ */
+export declare function sweepOrphanCaptureDirs(keepTaskIds: ReadonlySet<string>, skip: boolean, env?: ShadowEnv): Promise<void>;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/snapshot-merge.d.ts

@@ -4,6 +4,8 @@ import { type MetadataBudget } from './bounded-directory';
 import type { PromoteManifestInput, RevertManifestEntry, RevertManifestStore, SnapshotPromotionJournalV1 } from './durable-store';
 import { WorkspaceShadow, type ReviewedShadowDiffFile, type ShadowEnv } from './workspace-shadow';
 import { type BlobStore } from './blob-store';
+import type { ShadowDiffFile } from './shadow-protocol';
+import type { WithheldMediaChange } from './withheld-media';
 import { type WorkspaceRootAuthority } from './workspace-authority';
 export declare const SNAPSHOT_TRACK_BUNDLE_VERSION: 2;
 export interface SnapshotTrackBundle {
@@ -90,6 +92,8 @@ export interface RunSnapshotMergeGateArgs {
      */
     beforePromotionMutation?: (operationHash: string, files: readonly ReviewedShadowDiffFile[], workspaceRootAuthority: WorkspaceRootAuthority) => Promise<void>;
     markPromotionApplied: (operationHash: string) => Promise<void>;
+    /** P63 Slice 3 §9.5 — a team's media question, before anything is journaled; false applies nothing (team-media-approval.ts). */
+    approveMedia?: (files: readonly ReviewedShadowDiffFile[], withheldOf?: (files: readonly ShadowDiffFile[]) => Promise<WithheldMediaChange[]>) => Promise<boolean>;
     timeoutMs?: number;
     /** @internal deterministic merge-planning aggregate-work ceiling for tests. */
     mergePlanMaxWork?: number;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/task-group-types.d.ts

@@ -158,7 +158,9 @@ export interface TrackChangedFiles {
 /** MergeGate result discriminator (§2.1). SCREAMING wire values. */
 export type MergeResult = 'PASS' | 'FAIL';
 /** The 6-class MergeGate failure classification (§2.1, #C12-8). */
-export type MergeFailureClass = 'SHARED_FILE_CONFLICT' | 'INTEGRATION_FAILURE' | 'REVIEWER_DISAGREEMENT' | 'SCOPE_VIOLATION' | 'DIRTY_REPO_STATE' | 'BUDGET_EXHAUSTED';
+export type MergeFailureClass = 'SHARED_FILE_CONFLICT' | 'INTEGRATION_FAILURE' | 'REVIEWER_DISAGREEMENT' | 'SCOPE_VIOLATION' | 'DIRTY_REPO_STATE' | 'BUDGET_EXHAUSTED'
+/** P63 Slice 3 §9.5 — the user declined the team's media question; nothing applied (engine: no escalation). */
+ | 'USER_DECLINED_MEDIA';
 /** Retry-target kind discriminator (§2.1). SCREAMING wire values. */
 export type MergeRetryTargetKind = 'TRACK' | 'SERIAL_OWNER' | 'NONE';
 /**

package/node_modules/@quantiya/codevibe-core/dist/local-executor/team-media-approval.d.ts

@@ -0,0 +1,78 @@
+import type { BlobStore } from './blob-store';
+import type { ShadowDiffFile } from './shadow-protocol';
+import type { TaskGroupHaltedPayload } from './types';
+import { type WithheldMediaChange } from './withheld-media';
+/** Ask the team's question; resolves true only on "yes". */
+export type TeamMediaAsker = (taskGroupId: string, withheld: readonly WithheldMediaChange[]) => Promise<boolean>;
+export declare function takeTeamMediaDeclined(owner: object, taskGroupId: string): boolean;
+/** The longest a team group lives (engine TTL, F2 TM-2: 7 days from creation; 30 days once PROMOTE is authorized,
+ * which a group waiting on this question has not reached). An older record names a group the engine has ended. */
+export declare const TEAM_MEDIA_RECORD_MAX_AGE_MS: number;
+/** The engine's halt reason for the user's "no" (core-rs `GROUP_USER_DECLINED_MEDIA`). */
+export declare const GROUP_USER_DECLINED_MEDIA = "group_user_declined_media";
+/**
+ * Engine gate D-1: the engine writes no `TaskGroupHalted` row for the user's own "no", so the desktop that submitted the
+ * decline runs the group's halt teardown itself — the same `haltTaskGroup` a halt packet drives, with no choices (a v2
+ * group's desktop notice is informational; the user has already decided).
+ */
+export declare function declinedTeardownPayload(taskGroupId: string, decisionProtocolVersion: unknown): TaskGroupHaltedPayload;
+/** The media in a merged change, from the classes the reviewed bundles carry (§10.1). */
+export declare function teamWithheldMedia(files: readonly ShadowDiffFile[], store: BlobStore | undefined): Promise<WithheldMediaChange[]>;
+/** The durable record of an open team question (a JSON file per group under `<state root>/team-media-questions/`). */
+export interface OpenTeamMediaQuestion {
+    version: 1;
+    taskGroupId: string;
+    /** The session that asked; only that session (resumed) may end the group. */
+    sessionId: string;
+    /** The MergeGateDispatch the verdict answers (persisted because the engine does not re-deliver it). */
+    payload: Record<string, unknown>;
+    gateKinds: string[];
+    openedAt: string;
+}
+/** Registered as state-root infrastructure (`shadow-protocol.ts`), so no state-root walker treats it as a task folder. */
+export declare function teamMediaQuestionDir(stateRoot: string): string;
+/**
+ * Durable (SF-6, X-1 restart drill 2026-11-09: an abrupt stop within the file system's commit interval lost an unsynced
+ * record): the bytes are synced before the rename, and the folder (and, when it was just created, its parent) after it.
+ */
+export declare function writeOpenTeamMediaQuestion(stateRoot: string, q: OpenTeamMediaQuestion): Promise<void>;
+/** Durable too: a record that came back after a crash would end a group whose question was already answered. */
+export declare function removeOpenTeamMediaQuestion(stateRoot: string, taskGroupId: string): Promise<void>;
+export declare function listOpenTeamMediaQuestions(stateRoot: string): Promise<OpenTeamMediaQuestion[]>;
+/**
+ * The merge hook. `true` = apply the merged result; `false` = apply nothing (a decline is remembered for the FAIL
+ * verdict; an abort is not a decline). No asker in this session: nothing is applied and it counts as declined, so the
+ * group ends instead of waiting for an answer that cannot come.
+ */
+export declare function approveTeamMedia(args: {
+    owner: object;
+    taskGroupId: string;
+    files: readonly ShadowDiffFile[];
+    /** S2R1-F3: the integration snapshot's own withheld check, bound to the merge base's pre-task bytes. */
+    withheldOf?: (files: readonly ShadowDiffFile[]) => Promise<WithheldMediaChange[]>;
+    store: BlobStore | undefined;
+    ask: TeamMediaAsker | undefined;
+    signal?: AbortSignal;
+    record?: {
+        stateRoot: string;
+        sessionId: string;
+        payload: Record<string, unknown>;
+        gateKinds: string[];
+    };
+}): Promise<boolean>;
+/**
+ * At start (Hendry 2026-11-09, "Engine ends orphaned groups"; F2 TM-10 was disproven): a resumed session runs under a
+ * NEW session id, which the engine rejects for the old group, so the desktop never submits a verdict here. A question
+ * the PREDECESSOR session left open is closed locally: its record is removed and the user is told nothing was applied —
+ * the engine ends that group by itself once the predecessor's session has ended (`session_end_sweep`; a resume is only
+ * admitted after it has). Another session's record is left alone (it may still be asking) unless it is older than the
+ * group lifetime, when it is removed.
+ */
+export declare function recoverOpenTeamMediaQuestions(args: {
+    stateRoot: string;
+    /** The session this one resumed from (`Session.resumedFromSessionId`); undefined for a fresh session. */
+    resumedFromSessionId?: string;
+    nowMs?: number;
+    notify: (text: string) => void;
+    warn: (message: string, details?: unknown) => void;
+}): Promise<void>;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/withheld-media.d.ts

@@ -0,0 +1,14 @@
+import type { StoredFileClass } from './binary-classifier';
+import { type BlobStore } from './blob-store';
+import type { PreTaskHashes, ShadowDiffFile } from './shadow-protocol';
+export interface WithheldMediaChange {
+    path: string;
+    change_kind: ShadowDiffFile['change_kind'];
+    cls: StoredFileClass;
+    size: number | null;
+    container: string;
+    durationSeconds: number | null;
+}
+export declare function withheldMediaChanges(store: BlobStore, preTaskHashes: PreTaskHashes, files: readonly ShadowDiffFile[], 
+/** S2R1-F3: copies the user's current original of `rel` into `store` (the shadow's anchored base read). */
+readLiveBase?: (rel: string) => Promise<unknown>): Promise<WithheldMediaChange[]>;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/workspace-shadow.d.ts

@@ -6,6 +6,8 @@ import { type CopySpaceVerdict } from './shadow-free-space';
 import { type TaskIntent } from './shadow-task-intent';
 import { type BlobStore } from './blob-store';
 import type { BlobRef } from './change-manifest';
+import { type StoredFileClass } from './binary-classifier';
+import { type WithheldMediaChange } from './withheld-media';
 import type { CasRecoveryAuthority } from './shadow-protocol';
 import { RecoveredShadow } from './shadow-recovery';
 export { MAX_CHANGE_SET_FILE_COUNT, MAX_CHANGE_SET_PATH_BYTES, MAX_TRACKED_FILE_LOGICAL_BYTES, MAX_TRACKED_WORKSPACE_LOGICAL_BYTES, MAX_TRACKED_FILE_COUNT, MAX_TRACKED_PATH_BYTES, MAX_REVIEW_FILE_BYTES, MAX_PROMOTION_PREIMAGE_AGGREGATE_BYTES, MAX_STATE_MARKER_BYTES, DEFAULT_SHADOW_TTL_MS, } from './shadow-protocol';
@@ -255,13 +257,12 @@ export declare class WorkspaceShadow {
         };
     };
     /**
-     * P63 Slice 2 R1-F1 — the user's file a change modifies or deletes is text: its current bytes are streamed through the
-     * anchored copy into this task's blob store and checked as strict UTF-8, so a binary original (a deleted `clip.mp4`, a
-     * `logo.png` overwritten with text) stops the task with the binary reason before any review, as the strict decode of
-     * the promote preflight did before Slice 2 — and its bytes never reach a review bundle. `required`: the file must
-     * exist (a deletion); for a modification a file the user removed meanwhile is left to the conflict check.
+     * P63 Slice 2 R1-F1, Slice 3 — the user's file a change modifies or deletes: its current bytes are streamed through the
+     * anchored copy into this task's blob store (where the review bundle reuses them as the base version) and classified
+     * (§10.1); a binary original is recorded as `base_class`, never refused. `required`: the file must exist (a deletion);
+     * for a modification a file the user removed meanwhile is left to the conflict check (null).
      */
-    private assertRealBaseIsText;
+    private realBaseClass;
     /**
      * P63 Slice 2 (§8.1) — the verified blob sources of a review bundle for `files`: each new version from this instance's
      * blob store (`ownPostImageBlob`), each base version copied from the real file through the anchored helper and kept
@@ -288,7 +289,11 @@ export declare class WorkspaceShadow {
             size: number | null;
             changed: boolean;
         };
+        afterClass?: StoredFileClass;
+        beforeClass?: StoredFileClass;
     }>>;
+    /** P63 Slice 3 (§9.5) — the changes the user must approve before anything is applied (withheld-media.ts). */
+    withheldMediaChanges(files: readonly ShadowDiffFile[]): Promise<WithheldMediaChange[]>;
     /** §9.4 — this instance's blob store (a team bundle's source when it is published to the group's content store). */
     contentBlobStore(): BlobStore;
     /**

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/agent-turn-degrade.d.ts

@@ -0,0 +1,14 @@
+import type { BrainstormPanelActiveAgent } from './brainstorm-quorum';
+import type { ShellEventEmitResult } from './emit-shell-event';
+export declare const AGENT_TURN_DESKTOP_ONLY_DEGRADE_NOTICE = "Note: companion sync was unavailable for this turn; response shown on desktop only.";
+export interface AgentTurnCellSection {
+    readonly authorAgent: BrainstormPanelActiveAgent;
+    readonly boundedBody: string;
+}
+export declare function shouldDegradeAgentTurnOnPreEmitFailure(promptResult: ShellEventEmitResult, meta: {
+    readonly sessionId: string;
+    readonly route: string;
+    readonly turnId: string;
+}): boolean;
+export declare function formatAgentTurnCellsMarkdown(cells: ReadonlyArray<AgentTurnCellSection>, formatDisplayName: (agent: BrainstormPanelActiveAgent) => string): string;
+export declare function renderDegradedAgentTurnOnDesktop(cells: ReadonlyArray<AgentTurnCellSection>, formatDisplayName: (agent: BrainstormPanelActiveAgent) => string, dispatchAdvisory: (text: string) => void): void;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/binary-retry-brief.d.ts

@@ -0,0 +1,8 @@
+/**
+ * P63 Slice 3 (WORKSPACE-HARDENING-DESIGN §10.1; F-S3-RETRY-BRIEF-BINARY) — in the P46a retry brief, a collided file that
+ * is a binary on either side has no text to show: it is named with its class and left to the copy, never decoded.
+ * Extracted from quorum-loop.ts (a frozen monolith), which keeps a two-line delegation.
+ */
+import { type ShadowDiffFile } from '../local-executor/shadow-protocol';
+/** The brief's lines for a binary collision, or null for text (the caller shows the reviewed text). */
+export declare function binaryRetryBriefLines(filePath: string, who: string, reviewedFile: ShadowDiffFile | undefined): string[] | null;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/brainstorm-quorum.d.ts

@@ -75,7 +75,9 @@ export declare function agentIdForAuthor(agent: BrainstormPanelActiveAgent): 'cl
  * The display names come from the caller (index.ts `agentDisplayName`) so the
  * mapping stays single-sourced.
  */
-export declare function renderBrainstormPanelHeader(activeAgents: readonly BrainstormPanelActiveAgent[], displayName: (agent: BrainstormPanelActiveAgent) => string): string;
+export declare function renderBrainstormPanelHeader(activeAgents: readonly BrainstormPanelActiveAgent[], displayName: (agent: BrainstormPanelActiveAgent) => string, options?: {
+    readonly hasWebContext?: boolean;
+}): string;
 /**
  * Below Max: the frontier panel is fenced, but the local model still
  * brainstorms. No frontier agent was called and no code was changed.