@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.8

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/command-intent.d.ts

@@ -0,0 +1,56 @@
+import type { AgentKind as LocalExecutorAgentKind } from '../local-executor/types';
+type SupportedCommandAgent = Exclude<LocalExecutorAgentKind, 'GEMINI'>;
+export type CommandIntentTarget = SupportedCommandAgent | 'ALL';
+export interface AgentMentionIntent {
+    target: CommandIntentTarget;
+    rawMention: string;
+    isLeadingControlToken: boolean;
+    /**
+     * Remove only a leading control token (`@claude do X` -> `do X`). Mentions in
+     * the middle of natural prose are preserved so the model/agent still gets the
+     * full user sentence (`please ask @claude to...` stays intact).
+     */
+    promptForPlanning: string;
+    tokenStartUtf16: number;
+    tokenEndUtf16: number;
+}
+export interface CommandIntentEnvelope {
+    schema: 'codevibe.command_intent';
+    version: 1;
+    target: {
+        kind: 'all';
+    } | {
+        kind: 'agent';
+        agent: SupportedCommandAgent;
+    };
+    mention: {
+        raw: string;
+        normalized: '@all' | '@claude' | '@codex' | '@agy';
+        startUtf16: number;
+        endUtf16: number;
+        leadingControlToken: boolean;
+    };
+}
+export type CommandIntentMetadata = Record<string, unknown> & {
+    command_intent: CommandIntentEnvelope;
+};
+export declare function agentMentionTarget(value: string): CommandIntentTarget | null;
+export declare function normalizedMentionForTarget(target: CommandIntentTarget): CommandIntentEnvelope['mention']['normalized'];
+export declare function extractAgentMentionIntent(text: string): AgentMentionIntent | null;
+/**
+ * [#637] Global-flag variant of `extractAgentMentionIntent`: EVERY `@`-mention
+ * in the turn, in text order, de-duplicated by target (first occurrence wins,
+ * so `@agy … @antigravity` yields one ANTIGRAVITY intent). Element 0 equals the
+ * single-extract result wherever the frozen single matcher matches at the same
+ * position; this variant ADDITIONALLY admits `,`/`;`-adjacent mentions
+ * (`@codex,@agy` — Stage-2 R5 MED), which the frozen extractor deliberately
+ * does not. The list widens ONLY the LOCAL brainstorm-panel active set on a
+ * multi-mention turn — the FROZEN `CommandIntentEnvelope`
+ * (`buildCommandIntentEnvelope`) keeps carrying the single matcher's FIRST
+ * mention untouched.
+ */
+export declare function extractAllAgentMentionIntents(text: string): AgentMentionIntent[];
+export declare function stripLeadingAgentControlToken(text: string): string;
+export declare function buildCommandIntentEnvelope(intent: AgentMentionIntent): CommandIntentEnvelope;
+export declare function buildCommandIntentMetadata(text: string): CommandIntentMetadata | undefined;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/components/InputBar.d.ts

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import type { MentionSuggestion } from '../mention-suggest';
 import type { SlashCommandInfo } from '../slash-router';
 /**
  * Worst-case dropdown height in rows: the window (MAX_SUGGESTIONS) + a
@@ -118,5 +119,10 @@ export interface InputBarProps {
      * streams / a gate is pinned) → no dropdown.
      */
     slashCommands?: SlashCommandInfo[];
+    /**
+     * Agent mention autocomplete catalog. When supplied, typing `@` offers
+     * `@all` plus the local agents detected for this signed-in user/device.
+     */
+    mentionSuggestions?: MentionSuggestion[];
 }
 export declare function InputBar(props: InputBarProps): React.ReactElement;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/components/OrchestrationApp.d.ts

@@ -42,6 +42,8 @@ export interface OrchestrationAppProps {
      * CP-1.a callers) → falls back to the live process.cwd().
      */
     cwd?: string;
+    /** Local agents detected for this shell session; used for `@agent` autocomplete. */
+    detectedAgents?: string[];
     /** Hook called when `<InputBar>` submits text AND there is no active
      * gate-prompt. The host wires this to the slash router / planner
      * classifier. Gate-prompt submits are intercepted internally per

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/context-compaction.d.ts

@@ -0,0 +1,264 @@
+import { type ContextItem, type ContextItemSensitivity, type ContextItemProjectionRole } from './context-items';
+/**
+ * §6 Trigger (the HARD mid-task requirement) — the safety valve fires when
+ * the UNCOMPACTED tail of the on-disk log exceeds this many bytes (an O(1)
+ * `fs.stat` check against the watermark offset — no per-append log read).
+ * 128 KiB of sealed lines is far below any window limit but large enough
+ * that boundary compaction normally wins (§6: boundary preferred).
+ */
+export declare const COMPACTION_SAFETY_VALVE_TAIL_BYTES: number;
+/**
+ * §6 — a SAFETY-VALVE compaction keeps this many most-recent items HOT
+ * (mid-task, the immediate context must survive in the hot view); a
+ * TASK-BOUNDARY compaction compacts the whole tail (the finished task
+ * distills cleanly).
+ */
+export declare const COMPACTION_KEEP_HOT_RECENT_ITEMS = 16;
+/**
+ * §6 Eviction/GC — the LOCAL retention window for per-session log dirs:
+ * a session whose newest file is older than this is swept (TTL-only — no
+ * LRU cap, and NEVER the active session). 30 days comfortably exceeds the
+ * hosted 7-day session TTL; chosen here (design leaves the number open).
+ */
+export declare const CONTEXT_ITEMS_RETENTION_MS: number;
+/** The rendered session-context section's own budget (inside the F6 total). */
+export declare const SESSION_CONTEXT_SECTION_MAX_CHARS = 2000;
+/**
+ * A1f Stage-1 R1 HIGH + Stage-2 R1 (H1/M2/M3/M5) — one distilled FACT:
+ *  - `body` — the source item's COMPLETE typed payload, verbatim (M3:
+ *    truncation is render-time only);
+ *  - `source_id` — the source item's content address (M5: lets a later
+ *    answer/supersession event retire this fact by ref, cross-range);
+ *  - `sensitivity`/`visible_to` — the emitter-assigned labels VERBATIM
+ *    (Stage-1 HIGH: the §5 floor applies per fact at rehydration);
+ *  - `task_id?`/`track_id?` — the §4 scope, carried verbatim (H1: dispatch-
+ *    scoped rehydration excludes other tasks'/tracks' facts).
+ * The cache stays role/scope-agnostic (one cache serves every consumer);
+ * every filter applies at rehydration.
+ */
+export interface DistilledFact {
+    source_id: string;
+    body: unknown;
+    sensitivity: ContextItemSensitivity;
+    visible_to: ContextItemProjectionRole[];
+    task_id?: string;
+    track_id?: string;
+}
+/**
+ * §6 Form — one distilled range: `{task_spec, outcome, artifact_refs[],
+ * surviving_decisions[], surviving_open_questions[]}` + the range bookkeeping
+ * that makes the cache auditable/reconstructable. Every fact is LABELED +
+ * SCOPED (Stage-1 HIGH / Stage-2 H1) so rehydration can enforce the same §5
+ * floor + dispatch scope the hot tail gets.
+ */
+export interface DistilledTaskSummary {
+    /** The compacted range (inclusive), in `seq` order. */
+    range_from_seq: string;
+    range_to_seq: string;
+    /** How many raw items the range covered (audit/telemetry). */
+    item_count: number;
+    /** What fired this compaction. */
+    reason: 'task-boundary' | 'safety-valve';
+    /**
+     * Stage-2 R2 N1 — the range's task_specs, ONE PER SCOPE (per task_id +
+     * the session-scoped slot; last-wins within a scope only) so sibling
+     * tracks compacted together each keep their own spec — `scopePermits`
+     * selects the right one at rehydration.
+     */
+    task_specs: DistilledFact[];
+    /** The range's outcomes (the LAST verdict PER SCOPE — same N1 rule). */
+    outcomes: DistilledFact[];
+    artifact_refs: DistilledFact[];
+    surviving_decisions: DistilledFact[];
+    surviving_open_questions: DistilledFact[];
+    compacted_at: string;
+}
+/**
+ * The per-session sidecar cache (sealed at rest, atomic-written).
+ *
+ * `schemaVersion: 4` (Stage-2 R2 N1 — v3 had single global spec/outcome
+ * slots; v2 facts lacked payloads/scope/anchor; v1 lacked labels): the
+ * loader accepts ONLY v4; any older cache is a CACHE MISS (everything-hot —
+ * always correct, the miss is free).
+ */
+export interface SessionCompactionCache {
+    schemaVersion: 4;
+    sessionId: string;
+    /**
+     * High-watermark `seq` — every item with `seq <= compactedThroughSeq` is
+     * covered by `distilled`. `null` = nothing compacted yet. This is ALSO
+     * the §6 startup/multi-device "local high-watermark seq ULID" (the LOCAL
+     * half — the hosted `seq > watermark` incremental pull rides with the
+     * hosted upload path, which does not exist yet; flagged in the A1f
+     * report).
+     */
+    compactedThroughSeq: string | null;
+    /**
+     * Stage-2 R1 M2 — the CHAIN ANCHOR: the content-address `id` of the item
+     * at `compactedThroughSeq`. A cache is honored ONLY when the VERIFIED log
+     * still contains this exact `(seq, id)` pair — a deleted/rotated log with
+     * a fresh chain must reject the old cache (EMPTY_CACHE degrade), or the
+     * cache would become an independent source of truth (§3 violation).
+     * `null` iff `compactedThroughSeq` is null.
+     */
+    compactedThroughId: string | null;
+    /**
+     * The log file's byte size AT the last compaction — the O(1) safety-valve
+     * check compares the live size against this (never a per-append read).
+     * Stage-2 R1 M4 — ALSO bumped on a valve-triggered nothing-to-compact, so
+     * an oversized-but-few-items tail cannot re-trigger the expensive
+     * verified read on every turn.
+     */
+    logSizeAtCompaction: number;
+    distilled: DistilledTaskSummary[];
+    updatedAt: string;
+}
+export interface CompactionResult {
+    compacted: boolean;
+    reason?: 'chain-unverified' | 'nothing-to-compact' | 'cache-write-skipped' | 'compacted';
+    /** The distilled entry appended (when `compacted`). */
+    entry?: DistilledTaskSummary;
+}
+/** The §6 rehydrated hot working set. `null` = unverifiable chain (fail-closed). */
+export interface RehydratedSessionContext {
+    /** The compacted prefix (the distillation cache), oldest first. */
+    distilled: DistilledTaskSummary[];
+    /** The verified, role-filtered hot tail (`seq > compactedThroughSeq`). */
+    hot: ContextItem[];
+}
+/** Exported for tests + diagnostics. */
+export declare function compactionCachePath(sessionId: string): string;
+/**
+ * Load the session's compaction cache. EVERY failure mode (missing file,
+ * undecryptable envelope, plaintext bytes, parse/shape/session mismatch) is
+ * a CACHE MISS → the empty cache, i.e. "everything is hot" — which is
+ * always CORRECT (the log is the source of truth; the cache only trims the
+ * hot view). Never throws.
+ */
+export declare function loadCompactionCache(sessionId: string): Promise<SessionCompactionCache>;
+/**
+ * Stage-2 R1 H1 — the dispatch-scope predicate, applied IDENTICALLY to hot
+ * items and distilled facts (composes WITH the §5 label floor, never
+ * instead of it): a SESSION-scoped entry (no `task_id`) is always in scope;
+ * a task/track-scoped entry is in scope ONLY for a dispatch of that same
+ * task (§5 — an implementor never sees another track's context). A
+ * scope-less consumer (the decomposer, which runs before any task exists)
+ * sees ONLY session-scoped entries.
+ */
+export interface DispatchScope {
+    taskId?: string;
+}
+/**
+ * §6 Form — distill a VERIFIED item range into the typed shape
+ * `{task_spec, outcome, artifact_refs[], surviving_decisions[],
+ * surviving_open_questions[]}`. EXPLICIT type-based policy (compact, don't
+ * wipe — no heuristics, no prose summarization):
+ *
+ *  - `task_spec`  → the LAST task_spec PER SCOPE (Stage-2 R2 N1: per
+ *    task_id + the session-scoped slot — last-wins WITHIN a scope only, so
+ *    sibling tracks compacted together each keep their own spec);
+ *  - `verdict`    → the LAST verdict PER SCOPE (same N1 rule);
+ *  - `artifact_ref` / `decision` / `open_question` → kept verbatim
+ *    (bounded), excluding §4.3-superseded/invalidated items;
+ *  - `turn` / `rationale` → leave the hot view (they remain in the lossless
+ *    log — that is the entire compression);
+ *  - `repo_state` → not distilled here (it has its own latest-wins §8.3
+ *    freshness projection).
+ *
+ * Pure + exported for direct testing.
+ */
+export declare function distillItems(items: readonly ContextItem[], reason: DistilledTaskSummary['reason']): DistilledTaskSummary | null;
+/**
+ * Stage-1 R1 HIGH + Stage-2 R1 (H1/M5) — apply, to ONE distilled entry, the
+ * SAME predicates the hot tail gets:
+ *  - the §5 label floor (`labelPermitsRole` — one floor, two halves);
+ *  - the H1 dispatch scope (`scopePermits` — other tasks'/tracks' facts
+ *    excluded; session-scoped facts shared);
+ *  - the M5 retirement set (an open question whose `source_id` was ref'd by
+ *    a later item — e.g. its answer — is no longer "surviving").
+ * Returns `null` when NO fact survives.
+ */
+export declare function projectDistilledForRole(entry: DistilledTaskSummary, role: ContextItemProjectionRole, clearance: ContextItemSensitivity, scope?: DispatchScope, retiredIds?: ReadonlySet<string>): DistilledTaskSummary | null;
+/**
+ * Compact the session's uncompacted tail into the distillation cache.
+ *
+ *  - `task-boundary` — compacts the WHOLE tail (a finished task distills
+ *    cleanly, §6 preferred trigger).
+ *  - `safety-valve` — the §6 HARD mid-task requirement: compacts the tail
+ *    EXCEPT the `COMPACTION_KEEP_HOT_RECENT_ITEMS` most recent items (the
+ *    immediate working context stays hot).
+ *
+ * LOSSLESS: the log is never touched — only the sidecar cache advances.
+ * Fail-closed: an unverifiable chain compacts nothing. Never throws.
+ */
+export declare function compactSessionContext(deps: {
+    sessionId: string;
+    reason: DistilledTaskSummary['reason'];
+}): Promise<CompactionResult>;
+/**
+ * §6 Trigger — the O(1) MID-TASK safety-valve check (the design's hard
+ * requirement): compares the live log size against the watermark offset via
+ * `fs.stat` (no log read, safe to call at every authoring chokepoint) and
+ * fires a background compaction when the uncompacted tail exceeds
+ * `COMPACTION_SAFETY_VALVE_TAIL_BYTES`. Fire-and-forget safe; per-session
+ * in-flight dedup; never throws.
+ */
+export declare function maybeFireCompactionSafetyValve(sessionId: string): Promise<void>;
+/**
+ * §6 Rehydration — pull the session's context back into a hot working set:
+ * the compacted-prefix distillations (the cache) + the VERIFIED hot tail,
+ * passed through the §5 emitter-labeled projection floor
+ * (`projectItemsForRole`) for the consuming role. A TYPED query only
+ * (OQ-REHYDRATE-RELEVANCE: embeddings are a measured post-GA add-on).
+ *
+ * `null` = the chain failed verification — fail-closed, rehydrate NOTHING
+ * (the A1e projection contract).
+ */
+export declare function rehydrateSessionContext(deps: {
+    sessionId: string;
+    role: ContextItemProjectionRole;
+    clearance: ContextItemSensitivity;
+    /**
+     * Stage-2 R1 H1 — the dispatch scope: session-scoped entries always
+     * project; task/track-scoped entries project ONLY for their own task's
+     * dispatch. ABSENT (e.g. the decomposer, pre-task) → session-scoped only.
+     */
+    scope?: DispatchScope;
+}): Promise<RehydratedSessionContext | null>;
+/**
+ * Render the rehydrated session context as ONE bounded prompt section (fed
+ * to `composeDispatchContextBlock`'s `renderSessionContextFn` seam —
+ * counted inside the F6 total budget there, and additionally self-capped
+ * here). Also runs the §6 safety-valve check opportunistically (rehydration
+ * happens at dispatch — a natural mid-task boundary). Returns `''` when
+ * there is nothing to render or the chain is unverifiable. Never throws.
+ */
+export declare function renderRehydratedSessionContext(deps: {
+    sessionId: string;
+    role: ContextItemProjectionRole;
+    clearance: ContextItemSensitivity;
+    /** Stage-2 R1 H1 — the dispatch scope (see `rehydrateSessionContext`). */
+    scope?: DispatchScope;
+}): Promise<string>;
+/**
+ * §6 Eviction/GC — TTL-only retention sweep of the per-session log dirs
+ * under `~/.codevibe/context-items/`: a session dir whose NEWEST file mtime
+ * is older than `CONTEXT_ITEMS_RETENTION_MS` is deleted (log + compaction
+ * cache together). Deliberately NO LRU cap (the log is the authoritative
+ * store's local half, not an evictable cache — only the bounded retention
+ * window applies) and NEVER the active session. At most once per process,
+ * fired-and-forgotten from shell boot.
+ */
+export declare function scheduleContextItemsGc(activeSessionId: string): void;
+/** The sweep body — exported for direct testing. */
+export declare function gcContextItemLogs(deps: {
+    activeSessionId: string;
+}): Promise<void>;
+/**
+ * The TASK-BOUNDARY hook (§6 preferred trigger): flush the session's
+ * buffered transients (Finding-2 — a task terminal is a natural boundary)
+ * and run a task-boundary compaction. Fire-and-forget safe; never throws.
+ */
+export declare function onTaskBoundary(sessionId: string): Promise<void>;
+/** Test seam — reset module state (vitest-gated, the established pattern). */
+export declare function resetContextCompactionProcessStateForTests(): void;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/context-items-hosted-sync.d.ts

@@ -0,0 +1,19 @@
+import { type ContextItemWireRow } from './context-items';
+export interface ContextItemsHostedSyncDeps {
+    sessionId: string;
+    sessionKeyBase64: string;
+    /** Authenticated AppSync mutation adapter. Resolves only on acceptance. */
+    upload: (row: ContextItemWireRow) => Promise<void>;
+}
+export declare function contextItemsHostedSyncStatePath(sessionId: string): string;
+export declare function configureContextItemsHostedSync(deps: ContextItemsHostedSyncDeps): void;
+export declare function wakeContextItemsHostedSync(sessionId: string): void;
+export declare function drainContextItemsHostedSync(sessionId: string): Promise<void>;
+export declare function clearContextItemsHostedSync(sessionId: string): void;
+/** Vitest-only strict-durability fault seam. */
+export declare function setContextItemsHostedSyncFaultInjectionForTests(faults: {
+    failNextDirectorySync?: boolean;
+    failNextParentDirectorySync?: boolean;
+} | null): void;
+/** Vitest-only process-state reset. */
+export declare function resetContextItemsHostedSyncForTests(): void;