@quantiya/codevibe-core 2.0.0 → 2.0.2

package/dist/__tests__/cp-5-baseline-invariants.test.d.ts

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

package/dist/__tests__/prompt-parser.test.d.ts

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

package/dist/adapter/__tests__/capabilities.test.d.ts

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

package/dist/adapter/__tests__/contract-conformance.test.d.ts

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

package/dist/adapter/__tests__/packets.test.d.ts

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

package/dist/adapter/__tests__/progress.test.d.ts

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

package/dist/adapter/__tests__/registry.test.d.ts

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

package/dist/adapter/__tests__/smoke/claude.smoke.test.d.ts

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

package/dist/adapter/__tests__/smoke/codex.smoke.test.d.ts

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

package/dist/adapter/__tests__/smoke/gemini.smoke.test.d.ts

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

package/dist/adapter/capabilities.d.ts

@@ -0,0 +1,68 @@
+import type { AgentKind, ProcessRole } from '../local-executor/types';
+import type { ProbeResult, ProbeRole } from './types';
+export interface AdapterCapabilities {
+    agentKind: AgentKind;
+    installed: boolean;
+    authHealth: 'ok' | 'expired' | 'unknown' | 'unauthorized';
+    quotaHealth: 'ok' | 'low' | 'exhausted' | 'unknown';
+    supportedRoles: ProcessRole[];
+    supportedTools: string[];
+    modelTier: 'free' | 'pro' | 'enterprise' | 'unknown';
+    repoAccess: 'workspace' | 'workspace_plus_git' | 'unknown';
+    knownLimitations: string[];
+}
+export declare const SUPPORTED_TOOLS: Record<AgentKind, string[]>;
+export type ProbeFn = (agent: AgentKind, role: ProbeRole) => Promise<ProbeResult>;
+export declare class CapabilityRegistry {
+    private readonly cache;
+    private probeFn;
+    constructor(probeFn?: ProbeFn);
+    /**
+     * Wire the probe callback post-construction. Used by
+     * `createDefaultAdapterRegistry` (or a follow-up wave's factory
+     * refactor) when the registry construction order forces
+     * CapabilityRegistry to exist before AdapterRegistry.
+     */
+    setProbeFn(fn: ProbeFn): void;
+    /**
+     * Returns the cached capability record for `agent`. If no cached
+     * record exists, returns a default record derived from
+     * `detectInstalledAgents()` with all dimensions 'unknown' except
+     * `installed` (from PATH).
+     *
+     * NEVER throws — the §6.3 / §7.4 fail-fast machinery relies on
+     * `get()` always returning a populated 9-field record so the
+     * dispatcher can branch on `installed` / `authHealth` /
+     * `quotaHealth` without first-call special-casing. The first
+     * per-spawn auth re-check (`refreshCapabilities` at registry.ts:98)
+     * upgrades the 'unknown' → concrete values before the assert.
+     */
+    get(agent: AgentKind): AdapterCapabilities;
+    /**
+     * Refresh the capability record for `agent` by running the
+     * configured probe. Per LOCK #C5-C-2:
+     *   - `auth_probe` within 5 minutes of the last probe is a no-op
+     *     (returns cached record without re-probing).
+     *   - `health_probe` / `model_probe` always re-run.
+     *
+     * Throws if no probe callback has been wired (fail-loud — better
+     * than silently returning a default record on a degraded-health
+     * call site).
+     */
+    refresh(agent: AgentKind, role: ProbeRole): Promise<AdapterCapabilities>;
+    /**
+     * High-level refresh that satisfies §3 row 43 test (7) verbatim —
+     * re-runs BOTH the auth probe AND the quota (model) probe and
+     * returns the merged record. `installed` is sticky (NOT re-probed
+     * from PATH) per LOCK #C5-C-2 case (a). The 5-min cache gate at
+     * LOCK #C5-C-2 case (c) applies only to the auth-probe leg —
+     * `model_probe` always re-runs because quota state changes faster
+     * than the auth window.
+     *
+     * Production call sites that need a complete refresh (shell-start
+     * baseline, on-demand "force-refresh" from mobile or `/codevibe-test
+     * agents`) should call this method rather than driving the
+     * role-specific `refresh` primitive twice.
+     */
+    refreshCapabilities(agent: AgentKind): Promise<AdapterCapabilities>;
+}

package/dist/adapter/index.d.ts

@@ -0,0 +1,7 @@
+export type { AdapterCapabilities, } from './capabilities';
+export { CapabilityRegistry } from './capabilities';
+export type { AcceptedPacketReceipt, AdapterErrorDetails, AdapterPacket, BoundedPlannerContext, ContinuationPacket, ReviewerPacket, TaskPacket, } from './packets';
+export { AdapterError } from './packets';
+export type { AdapterProgressCommandIntent, AdapterProgressEnvelope, AdapterProgressFailureSignal, AdapterProgressFileChange, AdapterProgressHooks, AdapterProgressToolUse, } from './progress';
+export { AdapterRegistry, createDefaultAdapterRegistry } from './registry';
+export type { AgentAdapter, ProbeResult, ProbeRole, } from './types';

package/dist/adapter/packets.d.ts

@@ -0,0 +1,129 @@
+import type { AuthorityScope } from '../local-executor/authority';
+import type { AgentKind, ProcessRole } from '../local-executor/types';
+import type { ReviewerRole } from '../reviewer/types';
+export type AdapterPacket = TaskPacket | ContinuationPacket | ReviewerPacket | BoundedPlannerContext;
+export interface TaskPacket {
+    kind: 'task';
+    taskId: string;
+    agentKind: AgentKind;
+    repoState: {
+        workingDir: string;
+        gitBranch: string | null;
+        gitDirtyDigest: string | null;
+    };
+    writeScope: AuthorityScope;
+    plannerDecisionId: string | null;
+    structuralSummaryDigest: string | null;
+}
+export interface ContinuationPacket {
+    kind: 'continuation';
+    taskId: string;
+    fromAgentKind: AgentKind;
+    toAgentKind: AgentKind;
+    repoState: {
+        workingDir: string;
+        gitBranch: string | null;
+        gitDirtyDigest: string | null;
+    };
+    packetUri: string;
+    fidelityNote: string | null;
+}
+export interface ReviewerPacket {
+    kind: 'reviewer';
+    agentKind: AgentKind;
+    gateId: string;
+    seatId: number;
+    role: ReviewerRole;
+    artifact: {
+        contentHash: string;
+        uri: string;
+        mime: string;
+    };
+    lineageRefs: string[];
+}
+export interface BoundedPlannerContext {
+    kind: 'bounded_planner_context';
+    agentKind: AgentKind;
+    plannerDecisionId: string;
+    packetUri: string;
+}
+export interface AcceptedPacketReceipt {
+    receiptId: string;
+    packetKind: AdapterPacket['kind'];
+    packetHashSha256: string;
+    acceptedAt: string;
+    agentKind: AgentKind;
+    processRole: ProcessRole;
+}
+export type AdapterErrorDetails = {
+    kind: 'unregistered_agent';
+    agent: string;
+} | {
+    kind: 'agent_unavailable';
+    agent: AgentKind;
+    reason: 'not_installed' | 'auth_expired' | 'auth_unauthorized' | 'quota_exhausted' | 'unknown';
+} | {
+    kind: 'malformed_packet';
+    variant: AdapterPacket['kind'];
+    missingFields: string[];
+    agent: AgentKind;
+};
+export declare class AdapterError extends Error {
+    readonly details: AdapterErrorDetails;
+    constructor(details: AdapterErrorDetails);
+}
+/**
+ * Validate a TaskPacket. REQUIRED fields per §8.1:
+ *   - kind === 'task'
+ *   - taskId (non-empty string)
+ *   - agentKind (CLAUDE | GEMINI | CODEX)
+ *   - repoState.workingDir (non-empty string)
+ *   - repoState.gitBranch (string | null)
+ *   - repoState.gitDirtyDigest (string | null)
+ *   - writeScope (AuthorityScope — 5 fields)
+ *   - plannerDecisionId (string | null)
+ *   - structuralSummaryDigest (string | null)
+ *
+ * Returns the input narrowed to `TaskPacket` on success; throws AdapterError
+ * with `variant: 'task'` on failure.
+ */
+export declare function validateTaskPacket(packet: unknown): TaskPacket;
+/**
+ * Validate a ContinuationPacket. REQUIRED fields per §8.1:
+ *   - kind === 'continuation'
+ *   - taskId, fromAgentKind, toAgentKind
+ *   - repoState.{workingDir,gitBranch,gitDirtyDigest}
+ *   - packetUri (non-empty string)
+ *   - fidelityNote (string | null)
+ */
+export declare function validateContinuationPacket(packet: unknown): ContinuationPacket;
+/**
+ * Validate a ReviewerPacket. REQUIRED fields per §8.1:
+ *   - kind === 'reviewer'
+ *   - agentKind, gateId, seatId (number)
+ *   - role (ReviewerRole snake_case wire form per `reviewer/types.ts:52`)
+ *   - artifact.{contentHash,uri,mime}
+ *   - lineageRefs (string[])
+ */
+export declare function validateReviewerPacket(packet: unknown): ReviewerPacket;
+/**
+ * Validate a BoundedPlannerContext. REQUIRED fields per §8.1:
+ *   - kind === 'bounded_planner_context'
+ *   - agentKind
+ *   - plannerDecisionId (non-empty string)
+ *   - packetUri (non-empty string)
+ */
+export declare function validateBoundedPlannerContext(packet: unknown): BoundedPlannerContext;
+/**
+ * Top-level dispatcher per LOCK #C5-D-3. Inspects `packet.kind` and routes
+ * to the variant-specific validator. Unknown `kind` (or missing/non-string)
+ * throws `AdapterError({ kind: 'malformed_packet', variant: <closest-known>,
+ * missingFields: ['kind'], agent: UNKNOWN_AGENT_SENTINEL })`.
+ *
+ * For the unknown-kind case we widen the `variant` discriminant with a
+ * `'task'` fallback (the most common variant) so the closed-set
+ * `AdapterErrorDetails.malformed_packet.variant` type still type-checks.
+ * The `missingFields: ['kind']` entry tells audit consumers that the
+ * discriminator itself was bad.
+ */
+export declare function validateAdapterPacket(packet: unknown): AdapterPacket;

package/dist/adapter/progress.d.ts

@@ -0,0 +1,93 @@
+import type { AuthorityScope } from '../local-executor/authority';
+import type { AgentKind, FailureClass, ProcessExitedInfo, ProcessRole, ProcessSpawnedInfo } from '../local-executor/types';
+import type { AcceptedPacketReceipt } from './packets';
+export type AdapterProgressEnvelope = AdapterProgressToolUse | AdapterProgressCommandIntent | AdapterProgressFileChange | AdapterProgressFailureSignal;
+export interface AdapterProgressToolUse {
+    envelope_kind: 'ADAPTER_PROGRESS_TOOL_USE';
+    pid: number;
+    agentKind: AgentKind;
+    processRole: ProcessRole;
+    toolName: string;
+    toolInputDigest: string;
+    emittedAt: string;
+    coalesceCount: number;
+}
+export interface AdapterProgressCommandIntent {
+    envelope_kind: 'ADAPTER_PROGRESS_COMMAND_INTENT';
+    pid: number;
+    agentKind: AgentKind;
+    processRole: ProcessRole;
+    commandTextDigest: string;
+    requestedAuthorityScope: AuthorityScope;
+    emittedAt: string;
+}
+export interface AdapterProgressFileChange {
+    envelope_kind: 'ADAPTER_PROGRESS_FILE_CHANGE';
+    pid: number;
+    agentKind: AgentKind;
+    processRole: ProcessRole;
+    filePathRelative: string;
+    changeKind: 'created' | 'modified' | 'deleted';
+    byteDelta: number;
+    emittedAt: string;
+    coalesceCount: number;
+}
+export interface AdapterProgressFailureSignal {
+    envelope_kind: 'ADAPTER_PROGRESS_FAILURE_SIGNAL';
+    pid: number;
+    agentKind: AgentKind;
+    processRole: ProcessRole;
+    failureClass: FailureClass;
+    signalReason: string;
+    emittedAt: string;
+}
+export interface AdapterProgressHooks {
+    onSpawned: (info: ProcessSpawnedInfo & {
+        packetReceipt: AcceptedPacketReceipt;
+    }) => void;
+    onExited: (info: ProcessExitedInfo) => void;
+}
+export declare function canonicalJsonStringify(value: unknown): string;
+export declare function sha256OfCanonicalJson(value: unknown): string;
+export declare function isAbsoluteFilePath(p: string): boolean;
+export interface AdapterProgressSink {
+    emit(envelope: AdapterProgressEnvelope): void;
+}
+export declare class ProgressCoalescer {
+    private readonly sink;
+    private tokens;
+    private lastRefillMs;
+    private readonly pending;
+    private readonly nowMs;
+    private readonly setTimeoutFn;
+    private readonly clearTimeoutFn;
+    constructor(sink: AdapterProgressSink, opts?: {
+        now?: () => number;
+        setTimeoutFn?: (cb: () => void, ms: number) => ReturnType<typeof setTimeout>;
+        clearTimeoutFn?: (h: ReturnType<typeof setTimeout>) => void;
+    });
+    /**
+     * Submit a progress envelope. Routes by `envelope_kind`:
+     *   - ToolUse / FileChange → coalesce within 200ms window.
+     *   - CommandIntent / FailureSignal → emit immediately (no coalesce).
+     * In all cases the rate-limit token bucket gates the actual sink.emit().
+     * On rate-limit exhaustion the envelope is dropped silently (the drop
+     * is permanent — `coalesceCount` does NOT roll over to a future slot;
+     * the audit downstream interprets the count on a coalesced envelope as
+     * "≥ N occurrences in the window" per §9.3, and a gap as drops).
+     */
+    submit(envelope: AdapterProgressEnvelope): void;
+    /**
+     * Flush any open coalescing windows immediately. Call at process-exit
+     * cleanup to avoid losing pending coalesced envelopes. Idempotent.
+     */
+    flush(): void;
+    private refillTokens;
+    private consumeToken;
+    private emitWithRateLimit;
+    private coalesceToolUseOrFileChange;
+    private emitCoalescedSlot;
+}
+export declare const PROGRESS_COALESCE_WINDOW_MS = 200;
+export declare const PROGRESS_RATE_LIMIT_EVENTS_PER_SECOND = 10;
+export declare const PROGRESS_RATE_LIMIT_BURST = 20;

package/dist/adapter/registry.d.ts

@@ -0,0 +1,91 @@
+import type { AuthorityScope } from '../local-executor/authority';
+import type { AgentKind, ImplementorHandle, ProcessRole } from '../local-executor/types';
+import type { SubstrateHandle } from '../substrate/types';
+import { ReviewerRegistry } from '../reviewer/registry';
+import type { ReviewerSpec } from '../reviewer/provider';
+import type { ReviewerVerdict } from '../reviewer/types';
+import { CapabilityRegistry, type AdapterCapabilities } from './capabilities';
+import { type AcceptedPacketReceipt, type AdapterPacket, type ContinuationPacket, type TaskPacket } from './packets';
+import type { AdapterProgressHooks } from './progress';
+import type { AgentAdapter, ProbeResult, ProbeRole } from './types';
+/**
+ * CP-7 PART F — the structural substrate-engager seam (mirrors
+ * `SubstrateLaunch.engageSubstrate` / the LE's `SubstrateEngager`). OPTIONAL on
+ * the AdapterRegistry: when wired, the single-track (CP-5.b) implementor launch
+ * engages the trusted-execution moat; when absent, the legacy spawn path is
+ * byte-identical (§7 non-regression). Declared structurally so the adapter
+ * module stays decoupled from substrate-launch.
+ */
+export type AdapterSubstrateEngager = (input: {
+    taskId: string;
+    agentKind: AgentKind;
+    workdir: string;
+    role: ProcessRole;
+}) => Promise<{
+    mode: 'substrate';
+    tier: 'docker' | 'sandbox_exec';
+    reducedTrust: boolean;
+    reducedTrustReason?: string;
+    substrateHandle: SubstrateHandle;
+    refreshBrokerToken(): Promise<void>;
+    teardown(): Promise<void>;
+} | {
+    mode: 'reduced_trust';
+    reducedTrust: true;
+    reducedTrustReason: string;
+    teardown(): Promise<void>;
+}>;
+/**
+ * CP-7 PART F (Stage-2 H-2) — the prominent reduced-trust BADGE sink. The
+ * AdapterRegistry has no shell-event channel of its own; the orchestration shell
+ * injects this so a reduced-trust / coarse implementor launch surfaces the SAME
+ * user-visible NOTIFICATION + structured `reducedTrust: true` flag the LE-level
+ * path emits — NOT a bare log. `tier: 'none'` = moat OFF (legacy spawn); a real
+ * tier = coarse (engaged but weakened). When ABSENT, the registry STILL refuses
+ * to run a reduced-trust implementor on only a log — see `launchImplementor`
+ * (it fails closed rather than spawn un-badged).
+ */
+export type ReducedTrustNotifier = (badge: {
+    agentKind: AgentKind;
+    reducedTrustReason: string;
+    tier: 'none' | 'docker' | 'sandbox_exec';
+}) => Promise<void> | void;
+export declare class AdapterRegistry implements AgentAdapter {
+    private readonly scope;
+    private readonly reviewers;
+    private readonly capabilityRegistry;
+    private readonly substrateEngager?;
+    private readonly notifyReducedTrust?;
+    constructor(scope: AuthorityScope, reviewers: ReviewerRegistry, capabilityRegistry: CapabilityRegistry, substrateEngager?: AdapterSubstrateEngager | undefined, notifyReducedTrust?: ReducedTrustNotifier | undefined);
+    capabilities(agent: AgentKind): AdapterCapabilities;
+    acceptPacket(packet: AdapterPacket, processRole: ProcessRole): AcceptedPacketReceipt;
+    launchImplementor(scope: AuthorityScope, packet: TaskPacket | ContinuationPacket, hooks: AdapterProgressHooks): Promise<ImplementorHandle>;
+    /**
+     * Stage-2 H-2 — surface the PROMINENT reduced-trust badge: a WARN log AND
+     * (when a notifier is wired) the user-visible NOTIFICATION carrying the
+     * structured `reducedTrust: true` flag. The moat being OFF / weakened is
+     * VISIBLE + auditable, never a bare log.
+     *
+     * W2 Stage-2 HIGH — DELIVERY DISCIPLINE per tier:
+     *   - `tier: 'none'` (moat fully OFF — the agent runs unsandboxed with ambient
+     *     creds reachable): the badge MUST be DELIVERED. A `notifyReducedTrust`
+     *     throw PROPAGATES (we do NOT swallow it) so `launchImplementor` fails
+     *     closed and never spawns an un-badged unsandboxed implementor. The WARN
+     *     log alone is NOT sufficient. (The `launchImplementor` call site already
+     *     fails closed when NO notifier is wired; this extends that to "notifier
+     *     present but delivery failed".)
+     *   - `tier: 'sandbox_exec' | 'docker'` (still SANDBOXED): best-effort — a
+     *     notifier throw is logged + swallowed (the agent is contained, so a
+     *     missed coarse badge does not warrant crashing the launch).
+     */
+    private surfaceReducedTrust;
+    evaluateReviewer(spec: ReviewerSpec, gateId: string): Promise<ReviewerVerdict>;
+    probe(agent: AgentKind, role: ProbeRole): Promise<ProbeResult>;
+    refreshCapabilities(agent: AgentKind, role?: ProbeRole): Promise<AdapterCapabilities>;
+    private assertAgentAvailable;
+    private spawnArgsForProbe;
+}
+export declare function createDefaultAdapterRegistry(scope: AuthorityScope, opts?: {
+    substrateEngager?: AdapterSubstrateEngager;
+    notifyReducedTrust?: ReducedTrustNotifier;
+}): AdapterRegistry;

package/dist/adapter/types.d.ts

@@ -0,0 +1,22 @@
+import type { AuthorityScope } from '../local-executor/authority';
+import type { AgentKind, FailureClass, ImplementorHandle, ProcessRole } from '../local-executor/types';
+import type { ReviewerSpec } from '../reviewer/provider';
+import type { ReviewerVerdict } from '../reviewer/types';
+import type { AdapterCapabilities } from './capabilities';
+import type { AcceptedPacketReceipt, AdapterPacket, ContinuationPacket, TaskPacket } from './packets';
+import type { AdapterProgressHooks } from './progress';
+export type ProbeRole = 'health_probe' | 'auth_probe' | 'model_probe';
+export interface ProbeResult {
+    exitCode: number;
+    failureClass: FailureClass;
+    stdout: string;
+    stderr: string;
+    runtimeMs: number;
+}
+export interface AgentAdapter {
+    capabilities(agent: AgentKind): AdapterCapabilities;
+    acceptPacket(packet: AdapterPacket, processRole: ProcessRole): AcceptedPacketReceipt;
+    launchImplementor(scope: AuthorityScope, packet: TaskPacket | ContinuationPacket, hooks: AdapterProgressHooks): Promise<ImplementorHandle>;
+    evaluateReviewer(spec: ReviewerSpec, gateId: string): Promise<ReviewerVerdict>;
+    probe(agent: AgentKind, role: ProbeRole): Promise<ProbeResult>;
+}

package/dist/appsync/__tests__/appsync-client-apply-user-decision.test.d.ts

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

package/dist/appsync/__tests__/appsync-client-classb.test.d.ts

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

package/dist/appsync/__tests__/appsync-client-event-source-filter.test.d.ts

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

package/dist/appsync/__tests__/appsync-client-planner.test.d.ts

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

package/dist/appsync/__tests__/appsync-client-task-group.test.d.ts

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

package/dist/appsync/__tests__/appsync-client.test.d.ts

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

package/dist/appsync/__tests__/cleanup-subscription.test.d.ts

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

package/dist/appsync/__tests__/coerce-awsjson-and-review-summary.test.d.ts

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

package/dist/appsync/__tests__/cp1f-quorum-sdk.test.d.ts

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

package/dist/appsync/__tests__/event-throttle.test.d.ts

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