@quantiya/codevibe-codex-plugin 2.0.111 → 2.0.112

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/brainstorm-quorum.d.ts

@@ -97,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:";