@quantiya/codevibe-core 1.0.23 → 2.0.1

package/dist/structural-summary/__tests__/walker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/structural-summary/generator.d.ts

@@ -0,0 +1,8 @@
+import { type ExclusionState, type StructuralSummaryGenerator } from './types';
+export declare function createStructuralSummaryGenerator(): StructuralSummaryGenerator;
+export interface ReadmeCounters {
+    excludedAsUntracked: number;
+    excludedByGitignore: number;
+    excludedByIgnoreFile: number;
+}
+export declare function readReadmePreview(rootPath: string, exclusionState: ExclusionState, countedExactPaths: Set<string>, countedPrunedPrefixes: Set<string>, counters: ReadmeCounters): Promise<string>;

package/dist/structural-summary/index.d.ts

@@ -0,0 +1,7 @@
+export { createStructuralSummaryGenerator, readReadmePreview, } from './generator';
+export { walk as walkRepoTree } from './walker';
+export { isPathAdmissible, isPathInIgnoredPrefixes, isPathAccountedFor, matchesSecretDenyList, SECRET_DENY_LIST, } from './privacy-filter';
+export { readOptIn, addBodyPath, removeBodyPath, optInFilePath, } from './opt-in-store';
+export { compileUserIgnore, emptyUserIgnoreMatcher, } from './user-ignore-matcher';
+export type { DirectoryNode, RepoSummary, StructuralSummary, StructuralSummaryGenerator, GenerateOpts, PrivacyEnvelope, WalkResult, ExclusionState, UserIgnoreMatcher, ParsedManifest, ManifestType, OptInFile, StructuralSummaryErrorKind, } from './types';
+export { StructuralSummaryError } from './types';

package/dist/structural-summary/manifest-parsers/cargo.d.ts

@@ -0,0 +1,3 @@
+import { type ParsedManifest } from '../types';
+export declare function findManifest(rootPath: string): Promise<string | null>;
+export declare function parse(file: string): Promise<ParsedManifest>;

package/dist/structural-summary/manifest-parsers/index.d.ts

@@ -0,0 +1,7 @@
+import type { ExclusionState, ParsedManifest } from '../types';
+export interface ManifestCounters {
+    excludedAsUntracked: number;
+    excludedByGitignore: number;
+    excludedByIgnoreFile: number;
+}
+export declare function parse(rootPath: string, exclusionState: ExclusionState, countedExactPaths: Set<string>, countedPrunedPrefixes: Set<string>, counters: ManifestCounters): Promise<ParsedManifest>;

package/dist/structural-summary/manifest-parsers/npm.d.ts

@@ -0,0 +1,3 @@
+import { type ParsedManifest } from '../types';
+export declare function findManifest(rootPath: string): Promise<string | null>;
+export declare function parse(file: string): Promise<ParsedManifest>;

package/dist/structural-summary/manifest-parsers/other.d.ts

@@ -0,0 +1,17 @@
+import { type ParsedManifest } from '../types';
+export declare const pyproject: {
+    findManifest(rootPath: string): Promise<string | null>;
+    parse(file: string): Promise<ParsedManifest>;
+};
+export declare const gomod: {
+    findManifest(rootPath: string): Promise<string | null>;
+    parse(file: string): Promise<ParsedManifest>;
+};
+export declare const podfile: {
+    findManifest(rootPath: string): Promise<string | null>;
+    parse(file: string): Promise<ParsedManifest>;
+};
+export declare const gradle: {
+    findManifest(rootPath: string): Promise<string | null>;
+    parse(file: string): Promise<ParsedManifest>;
+};

package/dist/structural-summary/opt-in-store.d.ts

@@ -0,0 +1,24 @@
+import { type OptInFile } from './types';
+import type { Tier } from '../orchestration-shell/types';
+export declare function optInFilePath(): string;
+/**
+ * Per Stage 2 r1 Gemini M-1: reader takes `currentTier`. If
+ * `parsed.tierAtOptIn !== currentTier`, returns `null` (graceful tier-
+ * downgrade invalidation — no error throw).
+ */
+export declare function readOptIn(currentTier: Tier): Promise<OptInFile | null>;
+/**
+ * Per Stage 2 r1 Gemini H-3 option (a): widen to `Tier` so callers can
+ * pass `args.tier` directly without an unsafe type narrow. Runtime gate
+ * inside the function is authoritative; non-MAX throws `tier_gate`.
+ *
+ * Stage 2 r2 fix (H-1, Codex): validates that `bodyPath` is absolute
+ * BEFORE any persistence work. Normalises via `path.resolve()`
+ * (defense-in-depth — strips any residual `..` segments) and resolves
+ * symlinks via `fs.realpath()`. The realpath result is what gets
+ * persisted, so a future `cd` that lands the user in a different repo
+ * cannot trip a relative-path match. Throws `StructuralSummaryError(
+ * 'invalid_path')` for non-absolute or unresolvable inputs.
+ */
+export declare function addBodyPath(bodyPath: string, currentTier: Tier): Promise<OptInFile>;
+export declare function removeBodyPath(bodyPath: string): Promise<OptInFile>;

package/dist/structural-summary/privacy-filter.d.ts

@@ -0,0 +1,110 @@
+import type { ExclusionState } from './types';
+/**
+ * Stage 2 IMPL r2 fix (H-3, Codex H-2): strict path-containment helper.
+ *
+ * Returns true iff `rel` (the output of `path.relative(root, target)`)
+ * denotes a path OUTSIDE `root` via parent-directory traversal. Required
+ * because the naive `rel.startsWith('..')` form falsely classifies valid
+ * child names that happen to BEGIN with `..` (e.g., `..scratch/file.ts`,
+ * `..hidden`, `..foo/bar`) as outside the root.
+ *
+ * Correct semantics:
+ *   rel === '..'                       → outside (parent of root)
+ *   rel === '..' + path.sep + 'sib'    → outside (sibling of root)
+ *   rel === '..' + '/' + 'sib'         → outside (POSIX form, used by
+ *                                        git output / forward-slash
+ *                                        callers on Windows)
+ *   rel === '..foo'                    → INSIDE (child whose name
+ *                                        starts with `..`)
+ *
+ * Used in: walker.ts `buildExclusionState` (realRootPath outside-repo
+ * check + untracked subtree filter) and privacy-filter.ts
+ * `isPathAdmissible` (relative-to-realRootPath admission).
+ */
+export declare function isOutsideRoot(rel: string): boolean;
+/**
+ * Static secret-file deny-list. Matches `.env`, `.env.*`, `.aws/credentials`,
+ * and assorted private-key formats. Matched against absolute-path basename
+ * and a few suffix patterns. Per §4.3 step 2 first match.
+ */
+export declare const SECRET_DENY_LIST: readonly string[];
+/**
+ * Pure path test — returns true if `absolutePath` matches any secret
+ * deny-list pattern. The walker uses this to skip secret files silently
+ * (no counter increment per §4.3 hard-caps audit-quality note).
+ */
+export declare function matchesSecretDenyList(absolutePath: string): boolean;
+/**
+ * Helper exported alongside `isPathAdmissible`: returns true if
+ * `absolutePath` is either:
+ *   (a) an exact entry in `exactPaths` — file-level gitignore match,
+ *       O(1) `Set.has(p)`; OR
+ *   (b) equal to OR a descendant of an entry in `dirPrefixes` —
+ *       directory-level gitignore match, implemented via check-then-step
+ *       ancestor-walk:
+ *
+ *       let p = absolutePath;
+ *       while (true) {
+ *         if (dirPrefixes.has(p)) return true;
+ *         const parent = path.dirname(p);
+ *         if (parent === p) return false;   // filesystem root reached
+ *         p = parent;
+ *       }
+ *
+ * Key properties (per round-7 revision Codex r6 H-1 + Gemini r6 H-1/M-2):
+ *
+ *   1. **Signature is 3-arg** `(absolutePath, exactPaths, dirPrefixes)`.
+ *      The helper does NOT receive `realRootPath`. The walk MUST proceed
+ *      past `realRootPath` because `git ls-files --directory` may report
+ *      an ignored ancestor ABOVE the launch root (e.g., parent
+ *      `.gitignore` ignores `sub/` when launch root is `repo/sub/inner`).
+ *   2. **Check-then-step semantics**: check `dirPrefixes.has(p)` BEFORE
+ *      advancing `p`. This handles the case where `absolutePath` is
+ *      itself an entry in `dirPrefixes` (e.g., Step 0.5 root admission
+ *      tests `realRootPath` directly when it is itself ignored).
+ *   3. **Loop termination**: when `path.dirname(p) === p` (POSIX `/`,
+ *      Windows `C:\`). NO early termination at `realRootPath`.
+ *
+ * Lookup cost is O(absolute filesystem depth) (typically <30 on any sane
+ * mount tree), independent of `|dirPrefixes|`.
+ */
+export declare function isPathInIgnoredPrefixes(absolutePath: string, exactPaths: Set<string>, dirPrefixes: Set<string>): boolean;
+/**
+ * INTERNAL helper (not exported from the module index, but exported here
+ * so the manifest dispatcher + README reader can import it). Returns true
+ * iff `realFile` is already accounted for in the walker's two-set ledger
+ * (exact match OR equal-to-or-descendant-of an entry in pruned prefixes).
+ *
+ * Same canonical algorithm as `isPathInIgnoredPrefixes` — 3-arg signature,
+ * check-then-step, filesystem-root termination. Per round-7 revision
+ * Gemini r6 M-1 + Codex r6 H-1 + Gemini r6 M-2.
+ */
+export declare function isPathAccountedFor(realFile: string, countedExactPaths: Set<string>, countedPrunedPrefixes: Set<string>): boolean;
+/**
+ * Order of checks (mirrors §4.3 step 2, first match wins):
+ *   1. secret (deny-list path-glob match — operates on basename + suffix).
+ *   2. untracked (`state.untrackedSet.has(absolutePath)`; SKIPPED if
+ *      notInGitRepo).
+ *   3. gitignore (`isPathInIgnoredPrefixes(...)`; SKIPPED if notInGitRepo).
+ *   4. userIgnore (`state.userIgnoreMatcher.ignores(path.relative(
+ *      realRootPath, absolutePath), isDir)`).
+ *
+ * Pure in-memory check; consults only the pre-built `state`. No I/O.
+ *
+ * `isDir` (Stage 2 r2 fix, M-2 Gemini M-1): walker passes
+ * `entry.isDirectory()` here. File-only callers (manifest dispatcher,
+ * README reader) accept the default `false`. The flag is consumed by
+ * `userIgnoreMatcher.ignores()` to honour trailing-slash `dir/` rules.
+ *
+ * Caller is responsible for incrementing the appropriate counter on
+ * `privacyEnvelope` when `admissible === false` (so audit signal is
+ * preserved). `reason === 'secret'` is silent (no counter — per §4.3
+ * hard-caps audit-quality note).
+ */
+export declare function isPathAdmissible(absolutePath: string, state: ExclusionState, isDir?: boolean): {
+    admissible: true;
+} | {
+    admissible: false;
+    reason: 'secret' | 'untracked' | 'gitignore' | 'userIgnore';
+};
+export type { ExclusionState } from './types';

package/dist/structural-summary/safe-file-read.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TOCTOU-safe text file read. Returns the file contents as UTF-8 or
+ * `null` on any refusal / error. See module JSDoc for the syscall
+ * sequence + threat model.
+ *
+ * @param absPath Absolute filesystem path. Caller is responsible for
+ *                path absolutism + admission-oracle checks BEFORE
+ *                invoking this function; this helper only guards the
+ *                lstat→open transition.
+ */
+export declare function safeReadTextFile(absPath: string): Promise<string | null>;

package/dist/structural-summary/types.d.ts

@@ -0,0 +1,215 @@
+import type { Tier } from '../orchestration-shell/types';
+/**
+ * The 6 manifest kinds detected by the first slice (§4.4), plus `other`
+ * (parser found a candidate but parsing failed) and `none` (no manifest
+ * found at this rootPath).
+ *
+ * Matches the locked `RepoSummary.manifestType` enum at CP-0 §10.S.7 line 145.
+ */
+export type ManifestType = 'npm' | 'cargo' | 'pyproject' | 'go' | 'podfile' | 'gradle' | 'other' | 'none';
+export interface ParsedManifest {
+    type: ManifestType;
+    packageName?: string;
+    dependencies: string[];
+}
+/**
+ * One directory in the walked tree. Mirrors CP-0 §10.S.7:153-160; the
+ * Max-tier `body` + `bodyTruncated` fields are `[ADDITIVE WIDENING — CP-1.d]`
+ * per Hendry-locked round-1 Q1. `truncatedByDepth` is set when the walker
+ * hits `maxDepth = 12` on this node's subtree (§4.7).
+ */
+export interface DirectoryNode {
+    path: string;
+    fileCount: number;
+    bytes: number;
+    children: DirectoryNode[];
+    inferredLanguage?: string;
+    /** `[ADDITIVE WIDENING — CP-1.d]` Q1 LOCKED — Max-tier opt-in only. */
+    body?: string;
+    /** `[ADDITIVE WIDENING — CP-1.d]` Q1 LOCKED — true if `body` truncated or skipped due to per-file 512 KiB cap or shared 64 MiB body budget. */
+    bodyTruncated?: boolean;
+    /** True if walker stopped recursing here because `maxDepth = 12` was hit on a descendant. */
+    truncatedByDepth?: boolean;
+}
+/**
+ * One repo's portion of the assembled summary. The `rootPath` ECHOES the
+ * caller-supplied (possibly symlinked) path so the user-visible digest
+ * stays stable; the walker uses `realRootPath` for internal admission
+ * checks (§4.3 step 2 step 0).
+ */
+export interface RepoSummary {
+    rootPath: string;
+    manifestType: ManifestType;
+    packageName?: string;
+    dependencies: string[];
+    inferredLanguages: string[];
+    readmePreview: string;
+    directoryTree: DirectoryNode;
+}
+/**
+ * Privacy envelope counters + status flags. All but the first 3 fields are
+ * `[ADDITIVE WIDENING — CP-1.d]` extensions to the CP-0 §10.S.7:136-140
+ * 3-field sketch (per Stage 2 r1 Codex H-1 + Gemini H-1 + Hendry-locked Q2).
+ */
+export interface PrivacyEnvelope {
+    bodyInclusionPaths: string[];
+    excludedByGitignore: number;
+    excludedByIgnoreFile: number;
+    /** `[ADDITIVE WIDENING — CP-1.d]` Stage 2 r1 Codex H-1. */
+    excludedAsUntracked?: number;
+    /** `[ADDITIVE WIDENING — CP-1.d]` Q2 LOCKED — covers both file-count AND body-byte budgets. */
+    budgetExceeded?: boolean;
+    /** `[ADDITIVE WIDENING — CP-1.d]` Stage 2 r1 Gemini H-1 — disambiguates which budget tripped first. */
+    budgetReason?: 'fileCount' | 'bodyBytes';
+    /** `[ADDITIVE WIDENING — CP-1.d]` Stage 2 r1 Codex H-1 — graceful non-git fallback marker. */
+    notInGitRepo?: boolean;
+}
+/**
+ * The top-level structural summary returned by `generate()`. CP-1.b
+ * consumes `sha256` as an opaque cache key.
+ */
+export interface StructuralSummary {
+    generatedAt: string;
+    rootPaths: string[];
+    repos: RepoSummary[];
+    totalFileCount: number;
+    totalBytes: number;
+    privacyEnvelope: PrivacyEnvelope;
+    /**
+     * Hex-encoded SHA-256 over the canonical-JSON serialization of the
+     * summary EXCLUDING BOTH the `sha256` field AND the `generatedAt`
+     * field. `generatedAt` is excluded so identical repo content →
+     * identical sha256 across runs (the CP-1.b reproducibility contract);
+     * a wall-clock timestamp would defeat that.
+     *
+     * Canonical-JSON definition: `JSON.stringify(hashPayload, canonicalReplacer)`
+     * where `canonicalReplacer` sorts object keys lexicographically.
+     * Arrays preserve order, so any input array (e.g., `directoryTree.children`,
+     * `inferredLanguages`) must be sorted deterministically upstream — see
+     * `walker.ts` (children byte-wise sort) and `generator.ts:inferLanguages`
+     * (count + name byte-wise tie-break).
+     *
+     * See `generator.ts:~200-220` for the canonical hash-payload
+     * construction. The previous co-location in `assembler.ts` no longer
+     * applies (Stage 2 IMPL r2 — assembly inlined into `generator.ts`).
+     */
+    sha256: string;
+}
+/**
+ * Caller-supplied options. Mirrors PHASE-CP-1-DESIGN.md:1590-1596.
+ *
+ * `_test_caps` is a test-only escape hatch (note the underscore prefix
+ * + the `__INTERNAL__` doc tag). Production callers MUST NOT pass it;
+ * unit tests use it to trip the file-count + body-byte budget paths
+ * without authoring 50,000-file fixtures. Added by Stage 1 r1 M-3
+ * fix to support the design §5 line 1173 test row.
+ */
+export interface GenerateOpts {
+    rootPaths: string[];
+    ignoreFile?: string;
+    includeBodies?: string[];
+    userId: string;
+    tier: Tier;
+    /** __INTERNAL__ test-only seam — see JSDoc above. */
+    _test_caps?: {
+        fileCountCap?: number;
+        bodyByteCap?: number;
+    };
+}
+export interface StructuralSummaryGenerator {
+    generate(opts: GenerateOpts): Promise<StructuralSummary>;
+}
+/**
+ * Walker return value. Carries the assembled `directoryTree` + per-rootPath
+ * audit + the exclusion state + the two-set walker-accounting ledger.
+ *
+ * `countedExactPaths` + `countedPrunedPrefixes` (round-6 split per Codex r5 M-1)
+ * are the explicit ledger the manifest dispatcher + README reader consult via
+ * `isPathAccountedFor()` to avoid double-counting. See §4.3 step 6.
+ */
+export interface WalkResult {
+    directoryTree: DirectoryNode;
+    fileExtensions: Map<string, number>;
+    excludedByGitignore: number;
+    excludedByIgnoreFile: number;
+    excludedAsUntracked: number;
+    truncated: boolean;
+    bodyBudgetExceeded: boolean;
+    notInGitRepo: boolean;
+    exclusionState: ExclusionState;
+    /**
+     * Exact absolute paths the walker enumerated + already incremented an
+     * `excludedBy*` counter for (any of gitignore/userIgnore/untracked —
+     * NOT secret, which is silent).
+     */
+    countedExactPaths: Set<string>;
+    /**
+     * Absolute directory paths the walker pruned upfront without enumerating
+     * (Step 0.5 root admission OR Step 2 child-directory prune-during-descent).
+     * Counter was incremented once per prefix.
+     */
+    countedPrunedPrefixes: Set<string>;
+}
+/**
+ * Minimal gitignore-format matcher signature — the user-ignore file is
+ * matched against this. Kept as an interface so the implementation can swap
+ * between an in-process matcher and the `ignore` npm package later without
+ * surface churn.
+ */
+export interface UserIgnoreMatcher {
+    /**
+     * Returns true if the gitignore-style ruleset matches `relativePath`.
+     * `relativePath` is path.relative(realRootPath, absolutePath), with forward
+     * slashes on POSIX.
+     *
+     * Stage 2 r2 widening (M-2, Gemini M-1): `isDir` is consulted by rules
+     * with trailing `/` (e.g., `dist/`) — they MUST NOT match a regular
+     * file. Defaults to `false`; only the walker has cheap `Dirent.isDirectory()`
+     * info and threads it through. File-only callers (manifest dispatcher,
+     * README reader) get correct semantics with the default.
+     */
+    ignores(relativePath: string, isDir?: boolean): boolean;
+}
+/**
+ * Per-rootPath exclusion state, built ONCE at walker startup. See §4.3a.
+ *
+ * `ignoredExactPaths` + `ignoredDirPrefixes` (round-6 trailing-slash partition
+ * per Codex r5 H-1) replace round-5's conflated single `ignoredPrefixes` set.
+ * `realRootPath` (round-4 Codex H-1 + Gemini H-1) canonicalises the launch
+ * root through `fs.realpath()` so symlinked launch roots produce correct
+ * subtree-membership filters.
+ */
+export interface ExclusionState {
+    rootPath: string;
+    realRootPath: string;
+    notInGitRepo: boolean;
+    repoTopLevel: string;
+    untrackedSet: Set<string>;
+    ignoredExactPaths: Set<string>;
+    ignoredDirPrefixes: Set<string>;
+    userIgnoreMatcher: UserIgnoreMatcher;
+    secretDenyList: readonly string[];
+}
+/**
+ * On-disk schema for `~/.codevibe/structural-summary.opt-in.json`. Locked
+ * at §4.6.
+ */
+export interface OptInFile {
+    schemaVersion: 1;
+    bodyInclusionPaths: string[];
+    lastUpdatedAt: string;
+    tierAtOptIn: 'MAX';
+}
+export type StructuralSummaryErrorKind = 'tier_gate' | 'fs_unreadable' | 'budget_exceeded' | 'manifest_parse'
+/**
+ * `[ADDITIVE WIDENING — CP-1.d]` Stage 2 r2 Codex H-1.
+ * Thrown when a body-inclusion opt-in path is not absolute, or when
+ * realpath resolution fails (ENOENT etc.) — prevents PRIVACY REGRESSION
+ * where a relative opt-in could leak raw bodies from an unrelated
+ * repo's directory of the same name on a future `cd`.
+ */
+ | 'invalid_path';
+export declare class StructuralSummaryError extends Error {
+    readonly kind: StructuralSummaryErrorKind;
+    constructor(message: string, kind: StructuralSummaryErrorKind);
+}

package/dist/structural-summary/user-ignore-matcher.d.ts

@@ -0,0 +1,9 @@
+import type { UserIgnoreMatcher } from './types';
+/**
+ * Builds a matcher from a gitignore-format text blob.
+ */
+export declare function compileUserIgnore(text: string): UserIgnoreMatcher;
+/**
+ * Returns a no-op matcher (no rules — admits everything).
+ */
+export declare function emptyUserIgnoreMatcher(): UserIgnoreMatcher;

package/dist/structural-summary/walker.d.ts

@@ -0,0 +1,20 @@
+import type { WalkResult } from './types';
+export interface WalkOpts {
+    rootPath: string;
+    ignoreFile?: string;
+    includeBodies: string[];
+    maxDepth: number;
+    /** Shared file-count budget (mutated in-place across rootPaths). */
+    fileCountBudget: {
+        remaining: number;
+    };
+    /** Shared body-byte budget (mutated in-place across rootPaths). */
+    bodyBudget: {
+        remaining: number;
+    };
+}
+/**
+ * Walks `rootPath` and returns a `WalkResult`. Mutates the shared
+ * `fileCountBudget` + `bodyBudget` counters.
+ */
+export declare function walk(opts: WalkOpts): Promise<WalkResult>;

package/dist/types/events.d.ts

@@ -1,5 +1,11 @@
 /**
- * Event types matching GraphQL schema
+ * Event types matching GraphQL schema.
+ *
+ * 1.x values come first. CP-1 adds 9 new values per
+ * `codevibe-backend/docs/2.0/PHASE-CP-1-DESIGN.md` §3 lines 138-148 +
+ * §16 Stage A LOCK. Emission of CP-1 values is gated by the
+ * `new-event-types-enabled` cohort flag (default OFF — Phase 4 flips
+ * per-user once mobile decoders ship).
  */
 export declare enum EventType {
     USER_PROMPT = "USER_PROMPT",
@@ -8,7 +14,16 @@ export declare enum EventType {
     NOTIFICATION = "NOTIFICATION",
     INTERACTIVE_PROMPT = "INTERACTIVE_PROMPT",
     PROMPT_RESPONSE = "PROMPT_RESPONSE",
-    REASONING = "REASONING"
+    REASONING = "REASONING",
+    MODE_SELECTED = "MODE_SELECTED",
+    PLANNER_DECISION = "PLANNER_DECISION",
+    PLANNER_CACHE_HIT = "PLANNER_CACHE_HIT",
+    PLANNER_DEGRADED = "PLANNER_DEGRADED",
+    PLANNER_OUTAGE = "PLANNER_OUTAGE",
+    PLANNER_RECOVERED = "PLANNER_RECOVERED",
+    SLASH_COMMAND_INVOKED = "SLASH_COMMAND_INVOKED",
+    STRUCTURAL_SUMMARY_GENERATED = "STRUCTURAL_SUMMARY_GENERATED",
+    LOCAL_AUTHORITY_REFUSAL = "LOCAL_AUTHORITY_REFUSAL"
 }
 export declare enum EventSource {
     DESKTOP = "DESKTOP",

package/dist/types/index.d.ts

@@ -2,3 +2,4 @@ export * from './events';
 export * from './session';
 export * from './encryption';
 export * from './auth';
+export * from './reviewer';

package/dist/types/reviewer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Review lens a reviewer seat evaluates through. Mirrors
+ * codevibe-policy::ReviewerRole in the Rust engine.
+ *
+ * **Append-only post-launch** per the 2026-04-23 memory lock — these
+ * string values are cryptographically bound into the audit hash chain
+ * once used. Renaming or removing a value would break chain verification
+ * on every prior entry. Add new values freely; never rename or remove.
+ *
+ * UPPERCASE here (matches AppSync GraphQL enum convention). The Lambda
+ * translates to snake_case before writing to the audit chain / Rust
+ * engine wire.
+ */
+export declare enum ReviewerRole {
+    ARCHITECTURE = "ARCHITECTURE",
+    CORRECTNESS = "CORRECTNESS",
+    SECURITY = "SECURITY",
+    ACCURACY = "ACCURACY",
+    CLARITY = "CLARITY",
+    COMPLETENESS = "COMPLETENESS",
+    ARCHITECTURE_AND_ACCURACY = "ARCHITECTURE_AND_ACCURACY",
+    CORRECTNESS_AND_CLARITY = "CORRECTNESS_AND_CLARITY",
+    SECURITY_AND_COMPLETENESS = "SECURITY_AND_COMPLETENESS"
+}
+/**
+ * One seat in a user's reviewer panel. `seat_id` is the panel position
+ * (0-indexed: Pro has seats 0–1, Max has 0–2). `role` is the review lens
+ * — unique within a policy. `agent` (CLAUDE | GEMINI | CODEX) may repeat
+ * across seats — single-vendor users get multiple same-kind seats with
+ * distinct roles.
+ */
+export interface ReviewerAgentSpec {
+    seatId: number;
+    role: ReviewerRole;
+    agent: 'CLAUDE' | 'GEMINI' | 'CODEX';
+    modelHint?: string | null;
+}
+export interface ReviewerAgentSpecInput {
+    seatId: number;
+    role: ReviewerRole;
+    agent: 'CLAUDE' | 'GEMINI' | 'CODEX';
+    modelHint?: string | null;
+}
+/**
+ * Input for updateReviewerPolicy. Fields are independent:
+ * - orchestrationEnabledDefault: set to true/false to persist the user's
+ *   opt-in preference for new sessions. Null = leave unchanged.
+ * - reviewerSeats: non-empty array sets a custom panel. Empty array
+ *   resets to tier defaults. Null = leave unchanged.
+ */
+export interface UpdateReviewerPolicyInput {
+    orchestrationEnabledDefault?: boolean | null;
+    reviewerSeats?: ReviewerAgentSpecInput[] | null;
+}
+/**
+ * User record returned by updateAvailableAgents and updateReviewerPolicy.
+ * Subset of the full AppSync User type — only the fields the two mutations
+ * return. Use this in the AppSyncClient response typing, not as a general
+ * "User" replacement.
+ */
+export interface UserReviewerPolicySnapshot {
+    userId: string;
+    availableAgents?: Array<'CLAUDE' | 'GEMINI' | 'CODEX'> | null;
+    orchestrationEnabledDefault?: boolean | null;
+    reviewerSeats?: ReviewerAgentSpec[] | null;
+    updatedAt: string;
+}

package/dist/types/session.d.ts

@@ -32,6 +32,12 @@ export interface Session {
     creatorDeviceId?: string;
     encryptionVersion?: number;
     lastHeartbeatAt?: string;
+    /**
+     * Quorum 2.0 opt-in flag (2f.0.a.3). True routes the session to the
+     * 2.0 orchestration flow once 2f.3 Lambda is live; null/false keeps
+     * the 1.0 companion flow.
+     */
+    orchestrationEnabled?: boolean | null;
 }
 /**
  * GraphQL input for creating sessions
@@ -47,6 +53,11 @@ export interface CreateSessionInput {
     creatorDeviceId?: string;
     isEncrypted?: boolean;
     encryptionVersion?: number;
+    /**
+     * Quorum 2.0 (2f.0.a.3). Null/absent = server reads
+     * User.orchestrationEnabledDefault (option 6a auto-populate).
+     */
+    orchestrationEnabled?: boolean;
 }
 /**
  * GraphQL input for updating sessions
@@ -56,4 +67,9 @@ export interface UpdateSessionInput {
     status?: SessionStatus;
     metadata?: Record<string, any>;
     lastHeartbeatAt?: string;
+    /**
+     * Quorum 2.0 (2f.0.a.3). Per-session override for the orchestration
+     * opt-in. Plugin CLI --orchestration/--no-orchestration sets this.
+     */
+    orchestrationEnabled?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "1.0.23",
+  "version": "2.0.1",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,29 +10,46 @@
   "files": [
     "dist/**/*.d.ts",
     "dist/index.js",
+    "dist/orchestration-shell/cli.js",
     "bin"
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",
     "emit-types": "tsc --emitDeclarationOnly",
-    "build": "rm -rf dist && npm run emit-types && esbuild src/index.ts --bundle --platform=node --target=node18 --minify --packages=external --outfile=dist/index.js",
+    "build": "rm -rf dist && npm run emit-types && esbuild src/index.ts --bundle --platform=node --target=node18 --minify --packages=external --outfile=dist/index.js && esbuild src/orchestration-shell/cli.ts --bundle --platform=node --target=node18 --packages=external --outfile=dist/orchestration-shell/cli.js --banner:js=\"#!/usr/bin/env node\"",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build",
-    "test": "echo \"No tests yet\" && exit 0"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:live": "QUORUM_LIVE_SMOKE=1 vitest run"
   },
   "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@npmcli/package-json": "^5.2.1",
+    "gradient-string": "^3.0.0",
+    "ink": "^5.2.1",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^18.3.1",
+    "ulid": "^3.0.0",
     "uuid": "^9.0.0",
-    "ws": "^8.14.0"
+    "ws": "^8.14.0",
+    "zod": "^3.23.0"
   },
   "optionalDependencies": {
     "keytar": "^7.9.0"
   },
   "devDependencies": {
+    "@types/gradient-string": "^1.1.6",
     "@types/node": "^20.0.0",
+    "@types/react": "^18.3.0",
     "@types/uuid": "^9.0.0",
     "@types/ws": "^8.5.0",
     "esbuild": "^0.28.0",
-    "typescript": "^5.0.0"
+    "ink-testing-library": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.6.1"
   },
   "engines": {
     "node": ">=18.0.0"