@quantiya/codevibe-core 2.0.0 → 2.0.2

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

@@ -0,0 +1,28 @@
+/** Exposed for the single log line in createEvent. */
+export declare const CLIENT_THROTTLE_EVENTS_PER_WINDOW: number;
+interface RateWindow {
+    windowStartMs: number;
+    count: number;
+    toolUseAboveThreshold: number;
+    suppressed: number;
+    logged: boolean;
+}
+/**
+ * Decide whether this outbound event should be suppressed (not sent).
+ * Deterministic given (sessionId, type, now) and prior counter state.
+ * Exported for unit tests; resetThrottleState() clears the module map.
+ */
+export declare function shouldSuppressEvent(sessionId: string, type: string, now: number): boolean;
+/**
+ * Returns the session's rate window exactly once per window — the first time the
+ * throttle engages — for a single log line; later calls in the same window
+ * return undefined. Keeps logging out of the hot path.
+ */
+export declare function consumeThrottleLogOnce(sessionId: string): RateWindow | undefined;
+/** Test-only: clears the per-process rate map. */
+export declare function resetThrottleState(): void;
+/** Test-only: current size of the per-process rate map (eviction-bound check). */
+export declare function throttleMapSize(): number;
+/** Test-only: whether a session is currently tracked (eviction assertions). */
+export declare function throttleMapHas(sessionId: string): boolean;
+export {};

package/dist/appsync/index.d.ts

@@ -1,2 +1,5 @@
-export { AppSyncClient, DownloadUrlResponse } from './appsync-client';
+export { AppSyncClient, AppSyncGraphQLError, DownloadUrlResponse } from './appsync-client';
+export { coerceAwsJsonObject } from './appsync-client';
+export type { ClassBPacketEnvelopeMeta } from './appsync-client';
+export type { TaskReviewSummary, TaskReviewSummaryRound, TaskReviewSummaryReviewer, TaskGroupStatusResult, } from './appsync-client';
 export { queries, mutations, subscriptions } from './queries';

package/dist/appsync/queries.d.ts

@@ -2,6 +2,25 @@ export declare const queries: {
     getSession: string;
     listEvents: string;
     listUserDeviceKeys: string;
+    listServiceDeviceKeys: string;
+    /**
+     * Minimal session listing used by the orphan-sweep path. Only the
+     * fields needed to decide whether a session row is stale — sessionId
+     * for the INACTIVE mutation, agentType for the per-plugin filter,
+     * status to skip non-ACTIVE rows, and lastHeartbeatAt for the age
+     * check.
+     */
+    listSessions: string;
+    getSubscriptionStatus: string;
+    queryAudit: string;
+    verifyContinuationPacketWritten: string;
+    getReviewerPrompt: string;
+    getClassBSigningPublicKey: string;
+    getInReviewAssignments: string;
+    getTaskGroupTracks: string;
+    getInFlightTeamTracks: string;
+    getTaskGroupStatus: string;
+    getTaskReviewSummary: string;
 };
 export declare const mutations: {
     createSession: string;
@@ -12,9 +31,24 @@ export declare const mutations: {
     grantSessionKey: string;
     getAttachmentDownloadUrl: string;
     updateAvailableAgents: string;
+    updateAdapterCapabilities: string;
     updateReviewerPolicy: string;
+    classifyPlannerPrompt: string;
+    pingPlanner: string;
+    applyUserDecision: string;
+    recordContinuationPacketWritten: string;
+    createTaskGroup: string;
+    submitMergeGateVerdict: string;
+    submitTrackVerificationOutcome: string;
+    claimGroupDecision: string;
+    startTask: string;
+    submitImplementorOutput: string;
+    submitReviewerVerdict: string;
 };
 export declare const subscriptions: {
     onEventCreated: string;
     onDeviceKeyRegistered: string;
+    onSessionUpdated: string;
+    onClassBPacket: string;
+    onApplyUserDecision: string;
 };

package/dist/audit-keys/index.d.ts

@@ -39,3 +39,35 @@ export declare function dedupKeyForDestructiveActionEscalated(gateId: Uuid, acti
  * passed alongside).
  */
 export declare function dedupKeyForFlagBadApproval(flaggedEntryId: Uuid): string;
+/**
+ * `ModelCall` (CP-7 §3.5) — pre-forward strict audit row.
+ * Identity: `(task_id, "model_call", model_call_id)`.
+ */
+export declare function dedupKeyForModelCall(taskId: Uuid, modelCallId: string): string;
+/**
+ * `ModelCallResult` (CP-7 §3.5) — post-response enrichment row.
+ * Identity: `(task_id, "model_call_result", model_call_id)`. Shares the
+ * `model_call_id` FK with its pre-forward {@link dedupKeyForModelCall}
+ * row; framing keeps the two rows on DISTINCT keys despite the prefix
+ * overlap.
+ */
+export declare function dedupKeyForModelCallResult(taskId: Uuid, modelCallId: string): string;
+/**
+ * `EgressDenied` (CP-7 §3.5) — egress-proxy deny row.
+ * Identity: `(task_id, "egress_denied", caller_event_id)`.
+ */
+export declare function dedupKeyForEgressDenied(taskId: Uuid, callerEventId: string): string;
+/**
+ * `ModelContextScrubbed` (CP-7 §3.5) — I2 scrub row.
+ * Identity: `(task_id, "model_context_scrubbed", model_call_id, field,
+ * pattern_class)`. `field` is a canonical JSONPath; `patternClass` lets
+ * one field tripping two heuristics record both. This multi-string
+ * identity is exactly what the legacy unframed concatenation could not
+ * encode injectively.
+ */
+export declare function dedupKeyForModelContextScrubbed(taskId: Uuid, modelCallId: string, field: string, patternClass: string): string;
+/**
+ * `BrokerCredentialLoaded` (CP-7 §3.5) — keychain vendor-key load row.
+ * Identity: `(task_id, "broker_credential_loaded", credential_issuance_id)`.
+ */
+export declare function dedupKeyForBrokerCredentialLoaded(taskId: Uuid, credentialIssuanceId: string): string;

package/dist/auth/__tests__/auth-telemetry.test.d.ts

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

package/dist/auth/auth-service.d.ts

@@ -1,4 +1,28 @@
+import * as http from 'http';
 import { TokenData } from '../types';
+export declare const PRIMARY_PORT = 8080;
+export declare const PORT_RANGE_SIZE = 20;
+/**
+ * Bind an HTTP server to the first available port in
+ * PRIMARY_PORT..PRIMARY_PORT+PORT_RANGE_SIZE-1.
+ *
+ * Retries at the `.listen()` level (no separate probe) to avoid TOCTOU races.
+ * Installs a persistent post-bind error listener to prevent process crash on
+ * later server errors (e.g., EMFILE during connection accept).
+ *
+ * @param handler - the request handler
+ * @returns { server, port } once the server is successfully listening
+ * @throws Error with code='EADDRINUSE_ALL' if ALL ports in range are in use
+ * @throws Original error if a non-EADDRINUSE error fires (EACCES, etc.)
+ *
+ * Callers MUST wrap this in try/catch to fire the appropriate auth-failure
+ * beacon BEFORE rejecting — otherwise the outer auth-cli fallback downgrades
+ * the failure to `unknown` and we lose port_range_exhausted telemetry.
+ */
+export declare function bindOAuthServer(handler: http.RequestListener): Promise<{
+    server: http.Server;
+    port: number;
+}>;
 /**
  * Authentication service for OAuth flows
  */
@@ -51,11 +75,17 @@ export declare class AuthService {
      */
     private generateState;
     /**
-     * Build authorization URL
+     * Build authorization URL with dynamic redirect_uri (port-range fix).
      */
     private buildAuthUrl;
     /**
-     * Exchange authorization code for tokens
+     * Exchange authorization code for tokens.
+     *
+     * `redirectUri` MUST match the one passed to buildAuthUrl earlier — Cognito
+     * compares them at the token endpoint and rejects mismatches. This is the
+     * load-bearing change for the port-range fix to work end-to-end: if the
+     * authorize URL used port 8081 and the token POST uses 8080, Cognito
+     * returns redirect_uri_mismatch.
      */
     private exchangeCodeForTokens;
     /**

package/dist/auth/auth-telemetry.d.ts

@@ -1,16 +1,20 @@
 /**
  * Typed taxonomy of auth-flow failure reasons.
  *
- * Every value is a sanitized enum literal — never a raw error message,
- * never a truncated user input, never any byte from Cognito's response.
- * Adding a new failure mode means extending this union; the compiler
- * then forces every emit site to either use a known value or produce
- * a type error.
+ * Every value in THIS union is a sanitized enum literal — never a raw
+ * error message, never a truncated user input, never any byte from
+ * Cognito's response. Adding a new failure mode means extending this
+ * union; the compiler then forces every emit site to either use a known
+ * value or produce a type error.
+ *
+ * (Note: the `error_fragment` parameter on the auth_failed beacon DOES
+ * carry redacted error material — see `sanitizeAuthErrorFragment`. The
+ * `reason` taxonomy below remains the analytics-safe primary key.)
  *
  * Keep values snake_case to match GA4 custom-dimension conventions
  * used elsewhere in the codebase (`step`, `source`, `reason`).
  */
-export type AuthFailureReason = 'port_in_use' | 'server_listen_failed' | 'browser_open_failed' | 'login_timeout' | 'cognito_rejected' | 'state_mismatch' | 'no_authorization_code' | 'token_exchange_failed' | 'token_exchange_network_error' | 'keychain_write_failed' | 'user_aborted' | 'unknown';
+export type AuthFailureReason = 'port_in_use' | 'port_range_exhausted' | 'server_listen_failed' | 'browser_open_failed' | 'login_timeout' | 'cognito_rejected' | 'state_mismatch' | 'no_authorization_code' | 'token_exchange_failed' | 'token_exchange_network_error' | 'keychain_write_failed' | 'user_aborted' | 'unknown';
 /**
  * Auth flow stage the failure occurred in. Useful for GA4 faceting;
  * each reason has an implicit stage but keeping it as a distinct
@@ -29,6 +33,20 @@ export type AuthStage = 'server_start' | 'browser_open' | 'awaiting_callback' |
  * address.
  */
 export declare function fireAuthCompletedBeacon(userId: string): Promise<void>;
+/**
+ * Bytes 0-99 of the sanitized fragment (GA4 dim: error_fragment).
+ * See `sanitizeAuthErrorFragmentFull` for the redaction contract.
+ */
+export declare function sanitizeAuthErrorFragment(msg: string): string;
+/**
+ * Bytes 100-199 of the sanitized fragment (GA4 dim: error_fragment_2).
+ * Returns empty string when the redacted message is ≤100 chars (the
+ * typical short-error case), which is what we want — no
+ * `error_fragment_2` param fires unless there's something past byte
+ * 100 worth carrying. Works around GA4 Measurement Protocol's 100-char
+ * per-param limit.
+ */
+export declare function sanitizeAuthErrorFragmentTail(msg: string): string;
 /**
  * Fire the `auth_failed` failure beacon with a sanitized `reason`
  * literal. Optional `httpStatus` captures the numeric HTTP status
@@ -40,11 +58,48 @@ export declare function fireAuthCompletedBeacon(userId: string): Promise<void>;
  * `reason` is constrained to the `AuthFailureReason` union — this
  * is the ONLY input path; passing a raw error message is a compile
  * error.
+ *
+ * Optional `errorFragment` is a diagnostic dimension reserved for
+ * `reason: 'unknown'`. The outer `auth-cli` catch passes the first
+ * portion of `error.message` here so the next analytics pass can
+ * see what's hiding in `unknown` and we can ship a typed reason in
+ * a follow-up. Sanitized inside via `sanitizeAuthErrorFragment` (head)
+ * + `sanitizeAuthErrorFragmentTail` (tail) — ANSI stripped, $HOME /
+ * USERPROFILE / `/Users/<name>/` / `/home/<name>/` / email substrings
+ * redacted (Windows backslashes normalized first so `C:\Users\Alice\…`
+ * matches the same path regex as POSIX form), control + non-ASCII
+ * bytes dropped, then split into two GA4 dimensions to work around the
+ * Measurement Protocol 100-char per-param limit:
+ *   - `error_fragment`   = bytes 0-99
+ *   - `error_fragment_2` = bytes 100-199 (only set when input >100 chars)
+ * Reports concatenate both dims for display. Mirrors the install.sh
+ * `sanitize_fragment` / `sanitize_fragment_tail` shell helpers so
+ * fragments fired from either path follow the same redaction +
+ * slicing contract.
  */
 export declare function fireAuthFailedBeacon(reason: AuthFailureReason, extra?: {
     httpStatus?: number;
     stage?: AuthStage;
+    errorFragment?: string;
 }): Promise<void>;
+/**
+ * Coarse reason a machine fell back to file-based credential storage.
+ * - `no_keyring_service`: keytar's native addon LOADED but there's no OS
+ *   keyring service to talk to (structurally-headless Linux — no D-Bus session).
+ * - `keytar_load_failed`: keytar's native addon failed to load AND the machine
+ *   is structurally headless (libsecret absent on a no-keyring box).
+ */
+export type KeychainFallbackReason = 'no_keyring_service' | 'keytar_load_failed';
+/**
+ * Fire the `keychain_file_fallback` beacon when keychain-backend auto-selects
+ * the file backend on a structurally-headless machine. Deliberately a DISTINCT
+ * event from `auth_failed` — this is a successful, working fallback, not a
+ * failure. Lets analytics see the headless cohort and confirm the headless fix
+ * is reaching the field (the old `keychain_write_failed` signal goes quiet for
+ * these users, so we need a positive beacon, not just an absence). No PII: only
+ * platform / source / the coarse reason literal.
+ */
+export declare function fireKeychainFileFallbackBeacon(reason: KeychainFallbackReason): Promise<void>;
 /**
  * Attach the reason + beaconed marker to an Error. Non-enumerable so
  * the symbols don't serialize if the error object is ever JSON'd.
@@ -54,3 +109,59 @@ export declare function markErrorBeaconed(err: Error, reason: AuthFailureReason)
 export declare function errorWasBeaconed(err: unknown): boolean;
 /** Retrieve the tagged reason from a previously-marked error, if any. */
 export declare function getErrorReason(err: unknown): AuthFailureReason | undefined;
+export type DeviceCountBucket = '0' | '1' | '2-5' | '6+';
+/**
+ * Bucket a raw device count into a coarse range to prevent device-count
+ * fingerprinting via GA4 client_id stickiness. The `'0'` bucket exists as
+ * a safe default for callers that may pass 0; no current emitter actually
+ * fires with count 0 in production paths.
+ */
+export declare function bucketDeviceCount(count: number): DeviceCountBucket;
+/**
+ * SHA-256-truncate a sessionId for cross-beacon correlation without leaking
+ * the raw UUID. 8 hex chars = 32 bits ⇒ no practical reverse lookup absent
+ * a GA4 + DDB join.
+ */
+export declare function hashSessionId(sessionId: string): string;
+/**
+ * Bug B per-device: fired inside `createSessionKey`'s per-device catch.
+ * `session_hash` is optional because keychain-manager intentionally does
+ * not know which session is being keyed — the per-session aggregate in
+ * `fireSessionEncryptionPartialSuccessBeacon` provides the correlation.
+ */
+export declare function fireSessionEncryptionDeviceSkippedBeacon(params: {
+    skipped_count_bucket: DeviceCountBucket;
+    session_hash?: string;
+}): Promise<void>;
+/**
+ * Bug B per-session: fired once per session creation when at least one
+ * device was skipped. Caller MUST gate on `skippedDeviceIds.length > 0`.
+ */
+export declare function fireSessionEncryptionPartialSuccessBeacon(params: {
+    session_hash: string;
+    encrypted_count_bucket: DeviceCountBucket;
+    skipped_count_bucket: DeviceCountBucket;
+}): Promise<void>;
+/**
+ * Bug A2: fired when `rekeySessionForNewDevices` grants ≥1 device on resume.
+ * Caller MUST gate on `grantedCount > 0`.
+ */
+export declare function fireSessionEncryptionCatchUpGrantBeacon(params: {
+    session_hash: string;
+    granted_count_bucket: DeviceCountBucket;
+}): Promise<void>;
+/** Bug A1: fired when we enter the self-rekey path (our deviceId missing). */
+export declare function fireSessionEncryptionSelfRekeyRequestBeacon(params: {
+    session_hash: string;
+    other_device_count_bucket: DeviceCountBucket;
+}): Promise<void>;
+/** Bug A1: fired when polling resolves with our entry + decrypt succeeds. */
+export declare function fireSessionEncryptionSelfRekeySuccessBeacon(params: {
+    session_hash: string;
+    attempt_count: number;
+}): Promise<void>;
+/** Bug A1: fired when polling exhausts maxAttempts without our entry. */
+export declare function fireSessionEncryptionSelfRekeyTimeoutBeacon(params: {
+    session_hash: string;
+    attempt_count: number;
+}): Promise<void>;

package/dist/auth/index.d.ts

@@ -1,3 +1,4 @@
 export { AuthService, authService } from './auth-service';
+export { bindOAuthServer, PRIMARY_PORT, PORT_RANGE_SIZE } from './auth-service';
 export { runAuthCli } from './auth-cli';
 export { fireAuthCompletedBeacon, fireAuthFailedBeacon, markErrorBeaconed, errorWasBeaconed, getErrorReason, type AuthFailureReason, type AuthStage, } from './auth-telemetry';

package/dist/companion-mode/__tests__/persist-preference.test.d.ts

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

package/dist/companion-mode/__tests__/resolve-agent.test.d.ts

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

package/dist/companion-mode/agent-picker.d.ts

@@ -0,0 +1,9 @@
+import { DetectedAgent } from './resolve-agent';
+export interface PickAgentArgs {
+    healthy: DetectedAgent[];
+    defaultIndex: number;
+    /** Test seam — override stdin/stdout. */
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function pickAgent(args: PickAgentArgs): Promise<DetectedAgent>;

package/dist/companion-mode/index.d.ts

@@ -0,0 +1,55 @@
+import { DetectableAgent } from '../orchestration/detect-agents';
+import type { ShellEventEmit } from '../orchestration-shell/emit-shell-event';
+import type { Session } from '../types';
+export declare class NoAgentInstalledError extends Error {
+    constructor(message: string);
+}
+export interface CompanionArgs {
+    /** Optional `--agent <kind>` CLI override. */
+    agent?: DetectableAgent;
+    /** Args to pass through to the agent wrapper. */
+    passthrough: string[];
+    /** When set, clears the persisted preference before resolving. */
+    forgetAgent?: boolean;
+    /**
+     * Session context for §3 emitShellEvent fan-out. When provided
+     * together with `emitter`, MODE_SELECTED is emitted before the exec
+     * handoff. When either is omitted, the emit is skipped — Companion
+     * Mode is functional without it because the cohort flag gates every
+     * emit anyway (CP-1.a default OFF). Per Stage 1 r1 HIGH-3.
+     */
+    session?: Session;
+    /**
+     * Bound emitter (typically `createShellEventEmitter(appsyncClient)`).
+     * Required for the MODE_SELECTED emit when `session` is also set.
+     */
+    emitter?: (args: ShellEventEmit) => Promise<void>;
+    /** Test seam — override the `execFileSync` handoff. */
+    execFile?: (binPath: string, args: string[], options: {
+        stdio: 'inherit';
+    }) => void;
+    /** Test seam — override `detectInstalledAgents`. */
+    detect?: () => DetectableAgent[];
+    /** Test seam — override bin-path resolver (real impl uses `command -v`). */
+    resolveBinPath?: (kind: DetectableAgent) => string | null;
+    /**
+     * Test seam — override the `<wrapper> --version` 2s health-probe
+     * (§4 line 280). Real impl spawns the wrapper with a SIGKILL on
+     * timeout. Per Stage 2 r1 Codex MEDIUM-2.
+     */
+    versionProbe?: (binPath: string) => Promise<boolean>;
+}
+/**
+ * §4 LOCK lines 232-273. Detect → resolve → persist → exec.
+ *
+ * On a TTY with multiple agents, this calls `pickAgent` for the
+ * interactive readline picker. The function does NOT mount the Ink
+ * TUI — Companion Mode does not need it (the picker hands terminal
+ * control directly to the wrapper).
+ *
+ * NOTE: the function returns when the test seam `execFile` is
+ * provided; in production the `execFileSync` call replaces the process
+ * (`stdio: 'inherit'`) so `process.exit(0)` is unreachable but kept
+ * as a defensive fallback (§4 line 273).
+ */
+export declare function runCompanionMode(args: CompanionArgs): Promise<void>;

package/dist/companion-mode/persist-preference.d.ts

@@ -0,0 +1,24 @@
+export declare function companionPreferenceFilePath(): string;
+export interface CompanionPreference {
+    lastAgent: 'CLAUDE' | 'GEMINI' | 'CODEX' | 'ANTIGRAVITY';
+    lastUsedAt: string;
+}
+/**
+ * §4 lines 304-316 LOCK. Reads + validates the preference file.
+ * Returns `null` on every failure mode named in the design:
+ *   - file missing
+ *   - loose permissions (any group/world bits set)
+ *   - malformed JSON
+ *   - schema mismatch
+ */
+export declare function readCompanionPreference(): Promise<CompanionPreference | null>;
+/**
+ * Writes the preference file with mode 0600. Creates parent dir if
+ * missing. Self-heals loose perms (writes 0o600 explicitly on every
+ * write).
+ */
+export declare function persistCompanionPreference(pref: CompanionPreference): Promise<void>;
+/**
+ * Clears the preference file (used by `--forget-agent` flag per §4).
+ */
+export declare function clearCompanionPreference(): Promise<void>;

package/dist/companion-mode/resolve-agent.d.ts

@@ -0,0 +1,41 @@
+import { DetectableAgent } from '../orchestration/detect-agents';
+export interface DetectedAgent {
+    kind: DetectableAgent;
+    binPath: string;
+    healthy: boolean;
+}
+export interface ResolveAgentArgs {
+    /** Healthy agents detected on PATH. */
+    healthy: DetectedAgent[];
+    /** `--agent` CLI flag override (if any). */
+    flag?: DetectableAgent;
+    /** Persisted preference from `readCompanionPreference()` (if any). */
+    preferred?: DetectableAgent;
+}
+export interface ResolveAgentResult {
+    /** When a single resolved agent exists. */
+    agent?: DetectedAgent;
+    /** When multiple healthy agents exist and the picker should run. */
+    needsPicker?: {
+        healthy: DetectedAgent[];
+        defaultIndex: number;
+    };
+    /** When the flag asked for an agent that's not healthy. */
+    flagMissing?: {
+        requested: DetectableAgent;
+    };
+}
+/**
+ * §4 resolution order LOCK:
+ *   1. flag > preference > picker > single-agent fast-path
+ *
+ *   - If `flag` is set and a matching healthy agent exists → return it.
+ *   - If `flag` is set and no matching healthy agent → `flagMissing`.
+ *   - Single-agent fast-path: exactly 1 healthy agent → return it
+ *     (regardless of preference).
+ *   - Multiple healthy + `preferred` set + matches → picker with that
+ *     row pre-selected (caller may decide to auto-accept).
+ *   - Multiple healthy + no preference → picker with first row
+ *     pre-selected.
+ */
+export declare function resolveAgent(args: ResolveAgentArgs): ResolveAgentResult;

package/dist/config/config.d.ts

@@ -1,7 +1,14 @@
 /**
  * Environment type
+ *
+ * 'experiment' is a separate AWS environment for CodeVibe 2.0 testing —
+ * isolated DDB/Cognito/AppSync/Lambda stacks in us-east-1, manual-deploy
+ * only (NOT in the codevibe-backend pipeline). Plugins/mobile clients
+ * opt in by setting `ENVIRONMENT=experiment`. See
+ * `codevibe-backend/docs/2.0/PHASE-INFRA-EXPERIMENT-ENV-DESIGN.md`
+ * LOCK #IE-5.
  */
-export type Environment = 'development' | 'production';
+export type Environment = 'development' | 'production' | 'experiment';
 /**
  * Configuration interface
  */

package/dist/continuation/__tests__/dirty-state-collector.test.d.ts

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

package/dist/continuation/__tests__/integration.test.d.ts

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

package/dist/continuation/__tests__/packet-reader.test.d.ts

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

package/dist/continuation/__tests__/packet-writer.test.d.ts

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

package/dist/continuation/__tests__/parity.test.d.ts

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

package/dist/continuation/__tests__/status-cli.test.d.ts

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

package/dist/continuation/dirty-state-collector.d.ts

@@ -0,0 +1,46 @@
+import type { AuthorityScope } from '../local-executor/authority';
+import type { RepoState } from './types';
+export interface KnownRepo {
+    /** repo basename (e.g., `codevibe-backend`). */
+    repo: string;
+    /** absolute filesystem path of repo root. */
+    path: string;
+}
+export interface GitExecOptions {
+    /** `cwd` for the git invocation. */
+    cwd: string;
+    /** Wall-clock timeout in milliseconds. */
+    timeoutMs?: number;
+}
+export type GitExecFn = (args: string[], options: GitExecOptions) => Promise<string>;
+/**
+ * Default `git` executor. Honors `cwd` + timeout, scrubs the env.
+ * Returns stdout as utf8. Throws on non-zero exit / timeout / spawn
+ * failure — caller catches and emits the `"unknown"` sentinel row.
+ */
+export declare const defaultGitExec: GitExecFn;
+export interface DirtyStateCollector {
+    collect(): Promise<RepoState[]>;
+}
+export interface DirtyStateCollectorOptions {
+    gitExec?: GitExecFn;
+    timeoutMs?: number;
+}
+/**
+ * §4.7 LOCK #C6-A-7 — enumerate `knownRepos`, clamp to authority,
+ * collect git metadata for each in-scope repo. Sentinel-friendly:
+ * missing git, non-git dirs, and timeouts each produce a row with
+ * `"unknown"` strings instead of throwing.
+ */
+export declare function collectRepoStates(authority: AuthorityScope, knownRepos: KnownRepo[], options?: DirtyStateCollectorOptions): Promise<RepoState[]>;
+/**
+ * Factory that produces a `DirtyStateCollector` bound to a known-repo
+ * snapshot + authority scope. Used by `createContinuationPacketWriter`
+ * to inject the collector as a dependency (test seam).
+ */
+export declare function createDirtyStateCollector(deps: {
+    authority: AuthorityScope;
+    knownRepos: KnownRepo[];
+    gitExec?: GitExecFn;
+    timeoutMs?: number;
+}): DirtyStateCollector;

package/dist/continuation/index.d.ts

@@ -0,0 +1,8 @@
+export type { AgentKind, HandoffReason, GateState, RepoState, ContinuationPacket, PacketWriteInput, PacketWriteResult, PacketListEntry, ContinuationPacketReadResult, } from './types';
+export { PacketFidelityError, PacketIoError, PacketHashMismatch, PacketAuditEmitError, PacketNotFound, PacketUnverified, FrontmatterMalformed, SchemaInvalid, PacketPermissionsLoose, } from './types';
+export { createContinuationPacketWriter, buildContinuationPacket, computePacketHash, renderPacketMarkdown, getPacketFilePath, getTaskDirectoryPath, } from './packet-writer';
+export type { ContinuationPacketWriter, ContinuationPacketWriterDeps, } from './packet-writer';
+export { createContinuationPacketReader, splitFrontmatter, validatePacketSchema, } from './packet-reader';
+export type { ContinuationPacketReader, ContinuationPacketReaderDeps, } from './packet-reader';
+export { collectRepoStates, createDirtyStateCollector, defaultGitExec, } from './dirty-state-collector';
+export type { DirtyStateCollector, DirtyStateCollectorOptions, GitExecFn, GitExecOptions, KnownRepo, } from './dirty-state-collector';

package/dist/continuation/packet-reader.d.ts

@@ -0,0 +1,33 @@
+import type { AppSyncClient } from '../appsync/appsync-client';
+import type { ContinuationPacket, PacketListEntry, RepoState } from './types';
+export interface ContinuationPacketReaderDeps {
+    appsync: AppSyncClient;
+    /** Test seam — override the home directory. Defaults to `os.homedir()`. */
+    homeDir?: string;
+}
+export interface ContinuationPacketReader {
+    read(taskId: string, expectedHash?: string): Promise<ContinuationPacket>;
+    list(): Promise<PacketListEntry[]>;
+}
+/**
+ * Split a markdown body into YAML frontmatter + prose body. Returns
+ * `null` for the frontmatter when the body is missing the leading
+ * `---` fence.
+ */
+export declare function splitFrontmatter(body: string): {
+    yaml: string | null;
+    prose: string;
+};
+/**
+ * Validate that a parsed YAML object matches the 17-field
+ * `ContinuationPacket` schema per LOCK #C6-A-1. Returns the typed
+ * packet on success; throws `SchemaInvalid` with a list of issues
+ * otherwise.
+ */
+export declare function validatePacketSchema(parsed: unknown): ContinuationPacket;
+/**
+ * Factory for the CP-6 packet reader.
+ */
+export declare function createContinuationPacketReader(deps: ContinuationPacketReaderDeps): ContinuationPacketReader;
+export { getPacketFilePath, getTaskDirectoryPath } from './packet-writer';
+export type { RepoState };