opencode-swarm 7.168.1 → 7.170.0

package/dist/config/schema.d.ts

@@ -882,6 +882,62 @@ export declare const ConsensusConfigSchema: z.ZodObject<{
     report_retention: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type ConsensusConfig = z.infer<typeof ConsensusConfigSchema>;
+/**
+ * Opt-in remote OTLP/OpenInference observability export (issue #2485).
+ *
+ * Disabled by default: local operation — plugin init, the SQLite sink, the
+ * legacy telemetry stream, /swarm report — is fully independent of the
+ * exporter and of any collector/network. When enabled, the exporter
+ * registers as a telemetry listener (the same O(1) shape as the SQLite
+ * observability sink), persists privacy-filtered records in a bounded
+ * spool under `.swarm/otlp-export/`, and ships them as OTLP/HTTP JSON to
+ * `endpoint` with bounded retry/backoff and a cooldown circuit. Endpoint
+ * policy: `https:` required for remote collectors; plain `http:` is
+ * accepted only for loopback test collectors.
+ */
+export declare const OtlpExportConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    endpoint: z.ZodDefault<z.ZodString>;
+    convention: z.ZodDefault<z.ZodEnum<{
+        genai: "genai";
+        openinference: "openinference";
+    }>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    flushIntervalMs: z.ZodDefault<z.ZodNumber>;
+    requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    spoolMaxBytes: z.ZodDefault<z.ZodNumber>;
+    spoolMaxAgeMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    backoffBaseMs: z.ZodDefault<z.ZodNumber>;
+    backoffMaxMs: z.ZodDefault<z.ZodNumber>;
+    circuitThreshold: z.ZodDefault<z.ZodNumber>;
+    circuitCooldownMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type OtlpExportConfig = z.infer<typeof OtlpExportConfigSchema>;
+/** Observability block. Only the opt-in remote export today. */
+export declare const ObservabilityConfigSchema: z.ZodObject<{
+    export: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        endpoint: z.ZodDefault<z.ZodString>;
+        convention: z.ZodDefault<z.ZodEnum<{
+            genai: "genai";
+            openinference: "openinference";
+        }>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        batchSize: z.ZodDefault<z.ZodNumber>;
+        flushIntervalMs: z.ZodDefault<z.ZodNumber>;
+        requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        spoolMaxBytes: z.ZodDefault<z.ZodNumber>;
+        spoolMaxAgeMs: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffBaseMs: z.ZodDefault<z.ZodNumber>;
+        backoffMaxMs: z.ZodDefault<z.ZodNumber>;
+        circuitThreshold: z.ZodDefault<z.ZodNumber>;
+        circuitCooldownMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ObservabilityConfig = z.infer<typeof ObservabilityConfigSchema>;
 export declare const MemoryConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     provider: z.ZodDefault<z.ZodEnum<{
@@ -2563,6 +2619,27 @@ export declare const PluginConfigSchema: z.ZodObject<{
             latencyBudgetMs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    observability: z.ZodOptional<z.ZodObject<{
+        export: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            endpoint: z.ZodDefault<z.ZodString>;
+            convention: z.ZodDefault<z.ZodEnum<{
+                genai: "genai";
+                openinference: "openinference";
+            }>>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            batchSize: z.ZodDefault<z.ZodNumber>;
+            flushIntervalMs: z.ZodDefault<z.ZodNumber>;
+            requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            spoolMaxBytes: z.ZodDefault<z.ZodNumber>;
+            spoolMaxAgeMs: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            backoffBaseMs: z.ZodDefault<z.ZodNumber>;
+            backoffMaxMs: z.ZodDefault<z.ZodNumber>;
+            circuitThreshold: z.ZodDefault<z.ZodNumber>;
+            circuitCooldownMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     learning: z.ZodOptional<z.ZodObject<{
         realtime_admission: z.ZodPrefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/evaluation/index.d.ts

@@ -12,6 +12,7 @@ export { createEvaluationModelDispatcher, resolveEvaluationAgentName, } from './
 export * from './pr-review-recovery.js';
 export * from './public-api.js';
 export * from './retention.js';
+export { type AggregateExactMeasurement, type ExactMeasurement, evaluateHeldoutGraphRetrievalQuality, type HeldoutGraphQualityCase, type HeldoutGraphQualityReport, type RetrievalQualityOptions, type RetrievalQualityResourceCaps, type RetrievalQualityStatus, type RetrievalRouteMeasurement, } from './retrieval-quality.js';
 export type { EvaluationExecutor, EvaluationExecutorResult, RunEvaluationOptions, } from './runner.js';
 export { createModelEvaluationExecutor, runEvaluation, } from './runner.js';
 export * from './statistics.js';

package/dist/evaluation/retrieval-quality.d.ts

@@ -0,0 +1,116 @@
+import { buildWorkspaceGraphAsync } from '../tools/repo-graph/builder';
+export declare const _internals: {
+    buildWorkspaceGraphAsync: typeof buildWorkspaceGraphAsync;
+};
+export interface RetrievalQualityResourceCaps {
+    max_files: number;
+    walk_budget_ms: number;
+    max_tokens: number;
+    top_n: number;
+}
+export interface RetrievalQualityOptions {
+    corpusDirectory: string;
+    resourceCaps?: Partial<RetrievalQualityResourceCaps>;
+    /** Test-only diagnostic escape hatch. Production callers must clean up. */
+    keepTempRoot?: boolean;
+}
+export type RetrievalQualityStatus = 'complete' | 'degraded' | 'skipped';
+export interface ExactMeasurement {
+    expected: string[];
+    observed: string[];
+    true_positive_count: number;
+    false_negative: string[];
+    false_positive: string[];
+    precision: number;
+    recall: number;
+}
+export interface RetrievalRouteMeasurement {
+    status: RetrievalQualityStatus;
+    provenance: 'direct-source-fallback' | 'fresh-indexed-subgraph' | 'unavailable';
+    degradation_reason?: string;
+    graph_hit: boolean;
+    positive_hit: boolean;
+    fallback_reason: string | null;
+    actions: string[];
+    matched_resource_count: number;
+}
+export interface HeldoutGraphQualityCase {
+    id: string;
+    language: string;
+    analyzer: {
+        declared_id: string | null;
+        implementation: 'extractFileSymbols';
+    };
+    source: {
+        hash: string;
+        provenance: 'direct-source';
+    };
+    status: RetrievalQualityStatus;
+    degradation_reason?: string;
+    symbols: ExactMeasurement;
+    edges: ExactMeasurement;
+    known_misses: {
+        declared: string[];
+        matching_measured_false_negatives: string[];
+    };
+    spurious_edges: {
+        declared: string[];
+        matching_measured_false_positives: string[];
+    };
+    paraphrase: {
+        query: string;
+        direct_source: RetrievalRouteMeasurement;
+        indexed_control: RetrievalRouteMeasurement;
+    };
+    latency_ms: number;
+}
+export interface HeldoutGraphQualityReport {
+    schema_version: 1;
+    corpus: {
+        id: string;
+        version: string | null;
+        hash: string;
+        split: 'heldout';
+    };
+    generated_at: string;
+    status: RetrievalQualityStatus;
+    degradation_reasons: string[];
+    resource_caps: RetrievalQualityResourceCaps;
+    resource_usage: {
+        case_count: number;
+        graph_node_count: number;
+        graph_edge_count: number;
+        indexed_storage_available: boolean;
+    };
+    summary: {
+        symbols: AggregateExactMeasurement;
+        edges: AggregateExactMeasurement;
+        complete_case_count: number;
+        direct_source_fallback_complete_count: number;
+        direct_source_fallback_positive_hit_count: number;
+        fresh_indexed_control_complete_count: number;
+    };
+    thresholds: Record<string, number>;
+    uncertainty: {
+        method: 'deterministic-heldout-corpus';
+        confidence: 0.95;
+        sample_count: number;
+    };
+    cases: HeldoutGraphQualityCase[];
+}
+export interface AggregateExactMeasurement {
+    expected_count: number;
+    observed_count: number;
+    true_positive_count: number;
+    false_negative_count: number;
+    false_positive_count: number;
+    precision: number;
+    recall: number;
+}
+/**
+ * Measure the repository graph and retrieval router against the immutable
+ * multilingual held-out corpus. This intentionally owns a disposable project
+ * root: graph persistence remains under that root's `.swarm/`, never beside a
+ * source fixture or a caller workspace.
+ */
+export declare function evaluateHeldoutGraphRetrievalQuality(options: RetrievalQualityOptions): Promise<HeldoutGraphQualityReport>;

package/dist/failures/invocation-failure.d.ts

@@ -32,10 +32,29 @@ export interface ToolFailureClassificationInput {
 }
 /**
  * Redacts secrets/URLs and strips control chars for terminal/display safety.
- * Redaction runs FIRST against the raw value so `\b` sees genuine boundaries;
- * control-char stripping runs LAST so it can't interfere with matching. See
- * the FILL doc comment above for why control chars and whitespace are both
- * treated as tolerated fill throughout the redaction patterns.
+ * Order of operations (each step exists to keep a prior fix closed):
+ *   1. slice to MAX_SANITIZE_INPUT_CHARS (regex-work bound)
+ *   2. neutralize ANSI CSI sequences to a single space (#2369 Gap 2 — an SGR
+ *      final byte `m` is a word character and defeated `\b`; substituting a
+ *      separator can only create boundaries, never remove one, so the #2363
+ *      split/join fixes stay closed)
+ *   3. redact URLs (against the CSI-neutralized view)
+ *   4. redact credential KV pairs — keyword match is UNANCHORED and tolerant
+ *      of glued key names and identifier suffixes (#2369 Gap 1), and the
+ *      value matcher tolerates a fill-tolerant auth scheme word (Basic,
+ *      Digest, …) between separator and credential so `Authorization: Basic
+ *      <base64>` redacts the credential, not just the scheme
+ *   5. redact SCREAMING_CASE KV pairs (unchanged shape)
+ *   6. strip residual control/format/DI runs to spaces
+ *   7. sweep residual over-long bare `[<params>m` SGR bodies (the >32-char
+ *      CSI tail the bounded pre-pass cannot match)
+ *   8. trim + 512-byte UTF-8 bound
+ *
+ * Best-effort defense-in-depth for a log-display string, NOT a security
+ * boundary: combining marks (U+0300 class) still defeat keyword matching and
+ * are deliberately not fixed (#2369 Gap 3 — sweeping `\p{Mn}` would over-redact
+ * every legitimate combining accent in non-Latin diagnostics). Glued-key
+ * matching (Gap 1) and the CSI pre-pass (Gap 2) were added by #2485.
  */
 export declare function sanitizeFailureEvidenceDisplay(value: string): string;
 declare function isNeutralExitOne(command: string): boolean;

package/dist/hooks/gate-denial-tracker.d.ts

@@ -8,21 +8,18 @@
  *
  * This module owns that counter. `noteGateDenial` is called from the single
  * catch site wrapping the fail-closed chain in `src/index.ts`. It:
- *   1. classifies the denial by the leading code token of the error message,
- *   2. increments a per-(sessionID, toolName, discriminator, code) streak,
+ *   1. classifies the denial by its bounded structured cause (falling back to
+ *      the leading code token of the error message),
+ *   2. increments a per-(sessionID, invocationID, stable action, cause) streak,
  *   3. APPENDS (never rewrites) escalating guidance to the error message so the
  *      model reads it in the tool-rejection text, and
  *   4. at the hard rung, pushes an advisory + emits telemetry.
  *
- * The DISCRIMINATOR (reviewer round-4 REQUIRED 2) is the canonicalized
- * `subagent_type` of a `Task` call, and the empty string for every other tool.
- * Without it the reset was too wide: `resetGateDenialStreaks` drops a whole
- * (session, tool) prefix on any successful completion of that tool, so ONE
- * successful `Task` → `explorer` erased a 4-deep `ACCEPTANCE_FIELD_REQUIRED`
- * streak on `Task` → `coder`. Under the interleaving the loop actually
- * exhibits — deny coder, delegate an explorer to investigate, deny coder again —
- * the STOP rung was unreachable. Sub-scoping both the count and the reset by
- * dispatch target makes a success clear only what plausibly succeeded.
+ * The action projection intentionally retains only stable routing fields. It
+ * canonicalizes the `Task` role and target aliases, while omitting prompts,
+ * command content, and other retry-varying payloads. The same projection is
+ * used by note, reset, and the test peek/expiry seams, so a success can clear
+ * only what plausibly succeeded.
  *
  * Invariants this module must not break:
  *   - The caller ALWAYS rethrows. Decoration is append-only, so the leading
@@ -82,6 +79,13 @@ export declare function gateDenialDiscriminator(tool: string, args: unknown): st
  * a per-occurrence key.
  */
 export declare function deriveGateDenialCode(message: string): string;
+/**
+ * Resolve a denial cause from an own data property only. Accessors and
+ * inherited values are intentionally ignored so a hostile/frozen error cannot
+ * make tracking invoke arbitrary code. The message parser remains the
+ * trajectory logger's message-only boundary.
+ */
+export declare function deriveStructuredGateDenialCode(err: unknown): string | undefined;
 /**
  * True when the thrown value is a user/host abort rather than a policy denial.
  * Aborts must not count toward a denial streak AND must not reset one: a user
@@ -94,7 +98,7 @@ export declare function gateDenialWarnText(count: number, code: string): string;
  * The append-only hard rung, modelled on `nonTransientHardStopMessage`
  * (src/hooks/guardrails/nontransient-circuit.ts:336-354).
  */
-export declare function gateDenialStopText(count: number, code: string, tool: string): string;
+export declare function gateDenialStopText(count: number, code: string, tool: string, actionPattern?: string): string;
 export interface GateDenialOptions {
     /**
      * `guardrails.enabled`. The thresholds live in the `guardrails` config block
@@ -169,7 +173,7 @@ export declare const _test_exports: {
     readonly MAX_DISCRIMINATOR_LENGTH: 64;
     readonly streakCount: () => number;
     /** Read a streak length without mutating it. */
-    readonly peekStreak: (sessionID: string, tool: string, code: string, discriminator?: string) => number;
+    readonly peekStreak: (sessionID: string, tool: string, code: string, target?: unknown) => number;
     /** Force a streak's TTL into the past so eviction can be tested. */
-    readonly expireStreak: (sessionID: string, tool: string, code: string, discriminator?: string) => void;
+    readonly expireStreak: (sessionID: string, tool: string, code: string, target?: unknown) => void;
 };

package/dist/hooks/init-orphan-recovery.d.ts

@@ -72,6 +72,13 @@ export interface InitOrphanRecoveryResult {
         reason: string;
     };
 }
+/**
+ * Issue #2527: resolves the worktree bases this project enumerates for
+ * reclamation — the project-internal default base plus every configured
+ * `worktree_dir` override. The LEGACY parent-level shared base is never
+ * enumerated for deletion (it is only read by the migration pass).
+ */
+export declare function resolveWorktreeEnumerationBases(directory: string): string[];
 /**
  * Runs bounded orphan cleanup at plugin init time.
  *

package/dist/hooks/pr-workflow-gate.d.ts

@@ -914,6 +914,8 @@ export declare function abortPrWorkflow(directory: string, sessionID: string, op
 }): Promise<{
     mode: PrWorkflowMode;
     prHeadSha?: string;
+    /** Remote branch head observed while cancelling a publication generation. */
+    observedRemoteHead?: string | null;
     openLanes: number;
     presumedStaleLanes?: string[];
     presumedStaleDisclosure?: string;
@@ -1280,9 +1282,13 @@ export declare function recordPrFeedbackPushAttemptResult(directory: string, inp
  * appends the audit event, and NEVER manufactures push authority. Used only
  * by `abortPrWorkflow`'s explicit `cancelPublication` arm. Returns the NEW
  * state revision when a state write landed (the abort clear must CAS against
- * it), or null when the generation state was absent/unreadable.
+ * it), and the exact remote-head observation (including null when it could not
+ * be resolved).
  */
-declare function cancelPrFeedbackPublication(directory: string, sessionID: string, reason: string): Promise<number | null>;
+declare function cancelPrFeedbackPublication(directory: string, sessionID: string, reason: string): Promise<{
+    revision: number | null;
+    observedRemoteHead: string | null;
+}>;
 export declare function resolvePrReviewWriterRunId(directory: string, sessionID: string, requestedRunId?: string): Promise<string>;
 export declare function markPrReviewTriggerEvaluationComplete(directory: string, sessionID: string, runId: string, artifactPath: string): Promise<PrWorkflowGateState>;
 /** Freeze one exact inline trigger ledger across every micro dispatch. */