@quantiya/codevibe-codex-plugin 2.0.110 → 2.0.112

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/advisory-fingerprint/git-availability.d.ts

@@ -0,0 +1,30 @@
+import { type ProcessRunner } from './git-runner';
+export type HandOffGit = {
+    kind: 'available';
+    bin: string;
+} | {
+    kind: 'unavailable';
+    why: string;
+};
+/** A transient failure (spawn pressure, signal, deadline): fail this probe, ask again next time. */
+export declare class GitAvailabilityTransient extends Error {
+}
+export declare const MACOS_GIT_SHIM = "/usr/bin/git";
+export interface AvailabilityDeps {
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    /**
+     * a regular file that is executable (`stat` + `access(X_OK)`); a directory is never executable here. A definitive
+     * absence (ENOENT, ENOTDIR, EACCES, ELOOP, ENAMETOOLONG) is `false`; any other filesystem error throws, and the
+     * resolver treats it as transient (never cached).
+     */
+    isExecutable(p: string): Promise<boolean>;
+    realpath(p: string): Promise<string>;
+    readlink(p: string): Promise<string>;
+}
+export declare const defaultAvailabilityDeps: AvailabilityDeps;
+/** Decide the hand-off git. Definitive answers resolve; transient ones throw `GitAvailabilityTransient`. */
+export declare function resolveHandOffGit(runner: ProcessRunner, deps: AvailabilityDeps): Promise<HandOffGit>;
+export declare function handOffGit(runner: ProcessRunner, deps?: AvailabilityDeps): Promise<HandOffGit>;
+/** Tests only. */
+export declare function resetHandOffGitCacheForTests(): void;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/advisory-fingerprint/git-classify.d.ts

@@ -0,0 +1,34 @@
+export declare const errnoCode: (err: unknown) => string;
+/**
+ * git's own "not a repository" failure: exit status 128 with that diagnostic as git's `fatal:` line (`LC_ALL=C`) —
+ * the ONLY stderr line that starts with `fatal: `. `GIT_TRACE`/`GIT_TRACE2` output and `warning:` lines can come before
+ * it, and a path git prints can carry a newline followed by text of our choosing (a folder named
+ * "d\nfatal: not a git repository: x"), so a `fatal: `-prefixed line is not necessarily git's diagnostic. git's `die()`
+ * always prints its own `fatal: ` line, so when exactly one line has the prefix it is git's; when several do, which one
+ * is git's cannot be told and the failure is not classified (fail closed). git has two forms:
+ * `fatal: not a git repository (or any of the parent directories): .git` (discovery found nothing) and
+ * `fatal: not a git repository: <gitdir>` (a `.git` file, or `GIT_DIR`, naming something that is not a repository — a
+ * linked worktree whose repository is gone, a submodule folder copied out of its project). Matching the phrase
+ * anywhere in stderr would also match a path quoted inside another diagnostic or a trace line — "invalid gitfile
+ * format: <path>" under a folder named "not a git repository" — and a timeout or a signal is never "not a repository".
+ */
+export declare function isNotAGitRepositoryFailure(err: unknown): boolean;
+/**
+ * git's "detected dubious ownership in repository at '<path>'" refusal (`safe.directory`), classified by the same
+ * single-`fatal:`-line rule: git prints the path, so the phrase alone could be planted by a folder name.
+ */
+export declare function isDubiousOwnershipFailure(err: unknown): boolean;
+/**
+ * For a folder with a `.git` marker: is it really inside a repository? A `.git` that git itself does not
+ * accept (an empty or stale `.git` folder, a gitfile of a removed worktree) or a missing `git` binary is
+ * `not-a-repository`, so the folder is walked like any other; any other git failure is `error`.
+ */
+export declare function classifyGitWorkspace(workspaceRoot: string, timeoutMs: number): Promise<'repository' | 'not-a-repository' | 'error'>;
+/** Variables that make git use a repository other than the one in its working folder. */
+export declare const REPOSITORY_LOCATING_GIT_ENV: readonly ["GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_OBJECT_DIRECTORY", "GIT_INDEX_FILE", "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_NAMESPACE", "GIT_CEILING_DIRECTORIES", "GIT_DISCOVERY_ACROSS_FILESYSTEM"];
+/** The launch folder's environment (today's, as `probeWorkspaceTreeFingerprint` uses). */
+export declare function launchGitEnv(): NodeJS.ProcessEnv;
+/** The environment for a repository found by the walk, or nested in one: no repository-locating variable. */
+export declare function repositoryScrubbedEnv(): NodeJS.ProcessEnv;
+/** Leading arguments of every advisory git call: no fsmonitor daemon, no optional index writes. */
+export declare const ADVISORY_GIT_PREFIX: readonly ["-c", "core.fsmonitor=false", "--no-optional-locks"];

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/advisory-fingerprint/git-runner.d.ts

@@ -0,0 +1,24 @@
+/** No process is started once fewer than this many milliseconds remain before the deadline. */
+export declare const MIN_SPAWN_BUDGET_MS = 50;
+/** A failed run: same fields `execFile` failures carry, so the git-classify readers work on both. */
+export declare class ProcessRunError extends Error {
+    readonly code: number | string | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly killed: boolean;
+    readonly stderr: string;
+    /** the deadline ended the run (or no time was left to start it) */
+    readonly timedOut: boolean;
+    constructor(message: string, code: number | string | null, signal: NodeJS.Signals | null, killed: boolean, stderr: string, 
+    /** the deadline ended the run (or no time was left to start it) */
+    timedOut: boolean);
+}
+export interface ProcessRunner {
+    /** Resolves with stdout on exit 0; rejects with `ProcessRunError` otherwise. */
+    run(bin: string, args: readonly string[], opts: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): Promise<string>;
+    /** Process-group ids this runner spawned (diagnostics and tests). */
+    readonly spawnedGroups: readonly number[];
+}
+export declare function createProcessRunner(deadline: number, concurrency?: number): ProcessRunner;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/advisory-fingerprint/repo-record.d.ts

@@ -0,0 +1,47 @@
+import type { ProcessRunner } from './git-runner';
+export declare const ADVISORY_FINGERPRINT_MAX_REPOSITORIES = 128;
+/**
+ * A failure that ends the whole probe with this reason (fail closed). `dir` (absolute) and a bounded `category`
+ * (`timeout`, `exit-<code>`, `signal-<sig>`, `spawn-<errno>`, or a fixed step name) are for the desktop log only — never
+ * git's stderr.
+ */
+export declare class ProbeFailure extends Error {
+    readonly reason: string;
+    readonly dir?: string | undefined;
+    readonly category?: string | undefined;
+    constructor(reason: string, dir?: string | undefined, category?: string | undefined);
+}
+export interface RecordContext {
+    runner: ProcessRunner;
+    git: string;
+    env: NodeJS.ProcessEnv;
+    /** absolute repository path → its control set, from the before-turn probe (after-turn probe only) */
+    before: Readonly<Record<string, string>> | null;
+    /** filled with every 3B repository's control set (absolute path → set) */
+    controlSets: Record<string, string>;
+    repositories: number;
+}
+/** A bounded failure category from a process-runner failure (never its message, which names the binary path). */
+export declare function failureCategory(err: unknown): string;
+/** `mode : size : mtime rounded to the nearest second : inode` — the walk's stamp, plus mode. */
+export declare function stamp(p: string): Promise<string>;
+export type RootTest = {
+    kind: 'root';
+    gitDir: string;
+    commonDir: string;
+} | {
+    kind: 'walk';
+};
+/** Is `dir` (which has a `.git` entry) a repository ROOT? Not a repository / dubious ownership / not a root → walk it. */
+export declare function repositoryRoot(dir: string, ctx: RecordContext): Promise<RootTest>;
+/** 3B: a repository found by the walk (or nested in one). */
+export declare function walkFoundRecord(dir: string, info: {
+    gitDir: string;
+    commonDir: string;
+}, ctx: RecordContext, depth?: number): Promise<string>;
+/**
+ * 3A: the launch repository (today's coverage plus HEAD). Nested records use the scrubbed environment. A nested entry
+ * that git does not accept as a repository root (not a repository, dubious ownership, a different top level) keeps its
+ * status line only — today's coverage; an unclassified git failure fails the probe (step 2).
+ */
+export declare function launchRecord(top: string, ctx: RecordContext, nestedEnv: NodeJS.ProcessEnv, depth?: number): Promise<string>;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/advisory-fingerprint/walk.d.ts

@@ -0,0 +1,34 @@
+import { type AvailabilityDeps } from './git-availability';
+/** Budget of the whole probe (walk and every git call); past it the probe fails (fail closed). */
+export declare const ADVISORY_WALK_FINGERPRINT_TIMEOUT_MS = 10000;
+/** Entry cap of the walk (a repository handed to git counts as one entry); past it the probe fails (fail closed). */
+export declare const ADVISORY_WALK_FINGERPRINT_MAX_ENTRIES = 200000;
+/** git processes the probe runs at once. */
+export declare const ADVISORY_GIT_CONCURRENCY = 4;
+export type AdvisoryWorkspaceFingerprintProbe = {
+    kind: 'fingerprint';
+    /** `git`: launch inside a repository; `walk`: no repository handed to git; `walk+git`: some were */
+    method: 'git' | 'walk' | 'walk+git';
+    value: string;
+    entries: number;
+    durationMs: number;
+    /** control sets of repositories found by the walk (absolute path → set), for the after-turn pre-check */
+    controlSets?: Readonly<Record<string, string>>;
+} | {
+    kind: 'probe-failed';
+    method: 'git' | 'walk' | 'marker';
+    reason: string;
+    durationMs: number;
+};
+export interface AdvisoryProbeOptions {
+    timeoutMs?: number;
+    maxEntries?: number;
+    /** the before-turn result; its control sets gate any git run in a repository the walk finds */
+    before?: AdvisoryWorkspaceFingerprintProbe;
+    /** timeout of the launch-folder classification call (`git rev-parse --show-toplevel`) */
+    classifyTimeoutMs?: number;
+    /** git processes run at once (default ADVISORY_GIT_CONCURRENCY) */
+    gitConcurrency?: number;
+    availability?: AvailabilityDeps;
+}
+export declare function probeAdvisoryWorkspaceFingerprintImpl(workspaceRoot: string, options?: AdvisoryProbeOptions): Promise<AdvisoryWorkspaceFingerprintProbe>;

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.
@@ -95,12 +97,22 @@ export declare function brainstormAllQuotaWalledMessage(walled: readonly Brainst
  * `logger.warn` (the WIRE is what the ZK invariant governs, NOT the local log
  * file, which never leaves the machine). The invariant is stricter than
  * ZK-on-wire (the mirror is E2E-encrypted regardless): only a BOUNDED enum label
- * is surfaced on the wire, never the agent's diagnostic. Three labels only —
- * quota-wall vs timeout vs generic failure — so no free-form detail can leak
- * through. [#635] the `'quota_walled'`/`'failed'` strings are preserved VERBATIM
+ * is surfaced on the wire, never the agent's diagnostic. Five closed labels —
+ * quota-wall, timeout, the two workspace-check outcomes (repo-aware fingerprint
+ * design r6), and generic failure — so no free-form detail can leak through. [#635] the `'quota_walled'`/`'failed'` strings are preserved VERBATIM
  * from the prior 2-label version; only `'timed_out'` is new.
  */
-export type BrainstormPanelFailureReason = 'quota_walled' | 'timed_out' | 'failed';
+export type BrainstormPanelFailureReason = 'quota_walled' | 'timed_out' | 'workspace_unverifiable' | 'workspace_changed' | 'failed';
+/** The user-facing text for a read-only turn refused by the workspace check, or null for any other reason. */
+export declare function workspaceVerificationMessage(unavailableReason: string | null | undefined): string | null;
+/** Map a failed advisory result to its closed panel label: quota wall > timeout > workspace check > generic. */
+export declare function brainstormPanelFailureReasonFor(result: {
+    quotaWalled: boolean;
+    timedOut: boolean;
+    usage: {
+        unavailableReason?: string | null;
+    };
+}): BrainstormPanelFailureReason;
 export declare function brainstormPanelFailureNotice(reason: BrainstormPanelFailureReason): string;
 export declare const BRAINSTORM_PRIOR_CONTEXT_LABEL = "Prior brainstorm context (idea so far + open questions):";
 export declare const BRAINSTORM_REQUEST_LABEL = "Current brainstorm request:";