opencode-swarm 7.165.0 → 7.166.0

package/dist/db/observability-event-store.d.ts

@@ -0,0 +1,162 @@
+/**
+ * swarm.db store for the canonical observability event envelope (issue #2482,
+ * Workstream D PR 3).
+ *
+ * The durable local query authority for observability events:
+ *
+ * - Table `observability_event` — one row per emitted canonical
+ *   `ObservabilityEvent`, appended through the group-commit writer (queue ->
+ *   one txn per flush). Durability class `normal` (rebuildable telemetry
+ *   sink; the bounded `.swarm/telemetry.jsonl` stream remains the
+ *   operational legacy record — this store does NOT replace it).
+ * - The sink registers as a TELEMETRY LISTENER (`registerObservabilityEventSink`),
+ *   not as an `emit()` call site: the retention-registry writer-coverage
+ *   ratchet requires every writer module to appear in exactly one registry
+ *   row, and `src/telemetry.ts` is already owned by the `telemetry-jsonl`
+ *   row. The listener receives the canonical envelope as its third
+ *   parameter.
+ * - Zero top-level executable side effects; no DB work at plugin init. The
+ *   DB handle opens lazily on the first sink append (`getProjectDb` /
+ *   `getGroupCommitWriter` are invoked inside the listener closure, matching
+ *   the `insight-candidate-store.ts` precedent). Processes that never
+ *   register the sink (direct CLI / test scripts) simply get no SQLite sink —
+ *   fail-open, never an error.
+ * - Fail-open everywhere: sink failures are counted (bounded in-memory
+ *   counters persisted opportunistically into `observability_sink_health`)
+ *   and never propagate. The sink is non-authoritative for every decision;
+ *   observability health is surfaced through `/swarm report`.
+ * - Malformed events are QUARANTINED, not dropped: rows that cannot carry a
+ *   faithful envelope (fallback observations, oversize payloads, unparseable
+ *   legacy import lines) are stored with `quarantined = 1` plus a reason and
+ *   excluded from report timelines while remaining countable.
+ * - Rebuildable: `syncObservabilityImport` (report path only — never per
+ *   emit, never at init) incrementally imports the bounded legacy
+ *   `telemetry.jsonl(.1)` stream using deterministic per-line synthetic ids,
+ *   so deleting the imported rows and re-syncing reproduces byte-identical
+ *   content (proven by test).
+ */
+import type { ObservabilityEvent } from '../observability/envelope.js';
+import { extractWorkflowIds } from '../observability/legacy.js';
+import { getGroupCommitWriter } from './group-commit-writer.js';
+import { getProjectDb } from './project-db.js';
+/** Hard cap on retained observability rows (DELETE-based retention). */
+export declare const MAX_OBSERVABILITY_EVENT_ROWS = 50000;
+/** Rows past this many accepted events get a retention check appended. */
+export declare const RETENTION_CHECK_INTERVAL = 512;
+/** Health-counter deltas are persisted at most this often (events). */
+export declare const HEALTH_UPSERT_INTERVAL = 256;
+/** Hard cap on a single serialized payload (oversize → quarantined stub). */
+export declare const MAX_EVENT_PAYLOAD_BYTES: number;
+export type IngestedVia = 'live' | 'import';
+export interface ObservabilityEventRow {
+    rowid: number;
+    event_id: string;
+    kind: string;
+    category: string | null;
+    severity: string | null;
+    occurred_at: string;
+    writer_sequence: number | null;
+    trace_id: string | null;
+    span_id: string | null;
+    host_session_id: string | null;
+    task_id: string | null;
+    lane_id: string | null;
+    batch_id: string | null;
+    phase_id: string | null;
+    council_round_id: string | null;
+    project_ref: string | null;
+    outcome_status: string | null;
+    retry_index: number | null;
+    privacy_class: string | null;
+    sampled: number | null;
+    payload_json: string;
+    relationship_violations: string | null;
+    quarantined: number;
+    quarantine_reason: string | null;
+    ingested_via: string;
+}
+export interface ObservabilitySinkHealth {
+    accepted: number;
+    quarantined: number;
+    dropped: number;
+    last_error_category: string | null;
+    last_error_at: string | null;
+    last_flush_at: string | null;
+    updated_at: string | null;
+}
+/** Filter set for bounded report queries. Every field optional. */
+export interface ObservabilityEventFilter {
+    taskId?: string;
+    sessionId?: string;
+    traceId?: string;
+    batchId?: string;
+    /** Inclusive lower bound on `occurred_at` (ISO-8601 string compare). */
+    since?: string;
+}
+/**
+ * Register the SQLite observability sink as a telemetry listener for this
+ * project root. O(1), idempotent, never opens the DB, never throws — safe to
+ * call immediately before `initTelemetry` on the plugin init path. Registering
+ * with a DIFFERENT directory evicts the previous listener first, so exactly
+ * one sink listener is ever on the telemetry bus (per-directory counters live
+ * in their own maps and simply resume under the new binding).
+ */
+export declare function registerObservabilityEventSink(directory: string): void;
+/** Test/reset hook: drops the listener and forgets the binding. */
+export declare function resetObservabilityEventSinkForTesting(): void;
+/**
+ * Append one canonical event to the SQLite query authority via the
+ * group-commit writer (durability `normal`). Fail-open contract: throws are
+ * the CALLER's to swallow (the sink listener does). In-memory health counters
+ * track accepted/quarantined; retention + health persistence are appended to
+ * the same batch on their throttle intervals so they can never race a live
+ * append.
+ */
+export declare function appendObservabilityEventDb(directory: string, canonical: ObservabilityEvent): void;
+export interface ObservabilityImportResult {
+    imported: number;
+    quarantined: number;
+    skippedUnchanged: boolean;
+}
+/**
+ * Incrementally import the bounded legacy `telemetry.jsonl(.1)` stream into
+ * the query authority. Deterministic and idempotent: per-file markers record
+ * (size, mtime, lines_seen); append-only growth imports just the delta;
+ * rotation/shrink (or a deleted/recreated file) triggers a full rescan whose
+ * content-derived synthetic ids make every re-insert a no-op (`INSERT OR
+ * IGNORE`). Runs only from the report path — never per emit, never at init.
+ * Files are read oldest-generation first so rowid order tracks event order.
+ */
+export declare function syncObservabilityImport(directory: string): ObservabilityImportResult;
+/** Row cap for a single report query (#2048 bounded output budget). */
+export declare const MAX_REPORT_ROWS = 5000;
+export interface ObservabilityQueryResult {
+    rows: ObservabilityEventRow[];
+    truncated: boolean;
+    totalMatching: number;
+}
+/**
+ * Bounded, deterministic query over the query authority. Filters are exact
+ * bound parameters (node:sqlite strictness — counts are exact per branch);
+ * ordering is code-unit string compare on ISO timestamps plus rowid — no
+ * locale-dependent collation. Quarantined rows are excluded from timelines.
+ */
+export declare function queryObservabilityEvents(directory: string, filter: ObservabilityEventFilter): ObservabilityQueryResult;
+/** Cumulative persisted sink health (never opens a DB when absent). */
+export declare function readObservabilitySinkHealth(directory: string): ObservabilitySinkHealth | null;
+/** Coverage snapshot for report disclosure (live/imported/quarantined). */
+export interface ObservabilityCoverage {
+    liveRows: number;
+    importedRows: number;
+    quarantinedRows: number;
+    totalRows: number;
+    earliestOccurredAt: string | null;
+    latestOccurredAt: string | null;
+}
+export declare function readObservabilityCoverage(directory: string): ObservabilityCoverage | null;
+/** DI seam (repo `_internals` convention). */
+export declare const _internals: {
+    getProjectDb: typeof getProjectDb;
+    getGroupCommitWriter: typeof getGroupCommitWriter;
+    extractWorkflowIds: typeof extractWorkflowIds;
+};

package/dist/git/pr.d.ts

@@ -113,13 +113,6 @@ export interface PRStatusResult {
         detailsUrl?: string;
     }>;
 }
-export interface PRCheckResult {
-    name: string;
-    bucket: string;
-    state: string;
-    startedAt: string | null;
-    completedAt: string | null;
-}
 export interface PRCommentResult {
     id: string;
     author: string;
@@ -138,28 +131,33 @@ export interface ReviewStateResult {
     /** Number of requesting reviewers (non-zero means reviews are still pending). */
     reviewRequestCount: number;
 }
+/** All per-PR data one poll cycle needs, in two gh spawns. */
+export interface PRPollSnapshot {
+    status: PRStatusResult;
+    comments: PRCommentResult[];
+    merge: MergeStateResult;
+    review: ReviewStateResult;
+}
 /**
- * Fetch PR status via gh pr view --json
- */
-export declare function getPRStatus(prNumber: number, repoFullName: string, cwd: string): Promise<PRStatusResult>;
-/**
- * Fetch CI check results via gh pr checks --json
- */
-export declare function getPRChecks(prNumber: number, repoFullName: string, cwd: string): Promise<PRCheckResult[]>;
-/**
- * Fetch PR comments since a given timestamp via gh api
- * Returns both issue comments and pull request review comments, merged together
- */
-export declare function getPRComments(prNumber: number, repoFullName: string, cwd: string, since?: string): Promise<PRCommentResult[]>;
-/**
- * Fetch merge state (mergeable + mergeStateStatus) via gh pr view --json
+ * Fetch status, merge state, review state and conversation (issue) comments
+ * with ONE `gh pr view --json` call. Previously this was three near-duplicate
+ * pr-view spawns (status/merge/review) plus two gh api spawns per PR per poll.
+ *
+ * `comments[].id` from pr-view is the GraphQL node id, NOT the numeric
+ * database id the REST endpoints return. The numeric id is recovered from the
+ * comment permalink (`#issuecomment-<id>` suffix, verified equal to the REST
+ * id on gh >= 2.92) so `lastCommentId` markers written by earlier versions
+ * keep matching; the node id remains the defensive fallback (a warn is
+ * logged if it ever fires — fallback ids change the marker space).
  */
-export declare function getMergeState(prNumber: number, repoFullName: string, cwd: string): Promise<MergeStateResult>;
+export declare function getPRPollSnapshot(prNumber: number, repoFullName: string, cwd: string): Promise<PRPollSnapshot>;
 /**
- * Fetch the current review state for a PR using `gh pr view --json reviewDecision,reviewRequests`.
- * Uses async ghExecAsync to avoid blocking the event loop.
+ * Fetch inline pull-request review comments via gh api — the review half of
+ * the old two-endpoint getPRComments (the issue-comment half now rides the
+ * pr-view snapshot). Inline review comments have no `gh pr view --json`
+ * equivalent, so this stays the second spawn of the poll cycle.
  */
-export declare function getPRReviewState(prNumber: number, repoFullName: string, cwd: string): Promise<ReviewStateResult>;
+export declare function getPRReviewComments(prNumber: number, repoFullName: string, cwd: string): Promise<PRCommentResult[]>;
 /**
  * Result of fetching a GitHub Actions run for a PR's merge group.
  */

package/dist/hooks/context-capsule-inject.d.ts

@@ -23,6 +23,7 @@ import type { PluginConfig } from '../config/index.js';
 import { buildCapsule } from '../context-map/capsule-builder.js';
 import { saveCapsule } from '../context-map/capsule-persistence.js';
 import { recordTelemetry } from '../context-map/telemetry.js';
+import { measureCitedFileTokens, recordContextSourceAttribution } from '../services/context-attribution.js';
 import type { AgentSessionState } from '../state.js';
 import type { CapsuleDelegationReason } from '../types/context-capsule.js';
 /**
@@ -58,6 +59,8 @@ export declare const _internals: {
     buildCapsule: typeof buildCapsule;
     recordTelemetry: typeof recordTelemetry;
     saveCapsule: typeof saveCapsule;
+    measureCitedFileTokens: typeof measureCitedFileTokens;
+    recordContextSourceAttribution: typeof recordContextSourceAttribution;
     getActiveAgent: (sessionID: string) => string | undefined;
     getSession: (sessionID: string) => AgentSessionState | undefined;
     getCurrentTaskId: (sessionID: string) => string | null;

package/dist/index.d.ts

@@ -12,7 +12,12 @@ import { ensureSwarmGitExcluded } from './utils/gitignore-warning';
  * unit testing of the cap invariant; used by the heartbeat throttle and
  * delegation-telemetry pairing paths below.
  */
-export declare function capSessionMap<K, V>(map: Map<K, V>, max: number): void;
+export declare function capSessionMap<K, V>(map: Map<K, V>, max: number, 
+/** #2482 / #2244: the just-inserted key must never evict itself (a re-set
+ * entry keeps its ORIGINAL insertion position, so without this guard the
+ * fresh entry can be the oldest and evict itself at the cap — mirroring
+ * the stored-input-args guard). */
+justInserted?: K): void;
 /** @internal — test-only: clears delegation-telemetry pairing state so one
  * test's unconsumed entries (e.g. a before with no matching after) cannot
  * leak into the next. Mirrors resetTelemetryForTesting / resetSwarmState. */