opencode-swarm 7.87.3 → 7.88.1

package/dist/background/candidate-parser.d.ts

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+declare const ArtifactInputSchema: z.ZodObject<{
+    output_ref: z.ZodString;
+    batchId: z.ZodString;
+    laneId: z.ZodString;
+    agent: z.ZodString;
+    role: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    parentSessionId: z.ZodOptional<z.ZodString>;
+    digest: z.ZodString;
+    text: z.ZodString;
+    transcriptIncomplete: z.ZodOptional<z.ZodBoolean>;
+    artifact_status: z.ZodEnum<{
+        ok: "ok";
+        "ref-not-found": "ref-not-found";
+        "artifact-corrupted": "artifact-corrupted";
+    }>;
+    source: z.ZodEnum<{
+        dispatch_lanes: "dispatch_lanes";
+        collect_lane_results: "collect_lane_results";
+    }>;
+    produced_at: z.ZodString;
+}, z.core.$strict>;
+declare const ParseFlagsSchema: z.ZodObject<{
+    accept_partial: z.ZodBoolean;
+    accept_degraded: z.ZodBoolean;
+    degraded: z.ZodBoolean;
+    row_format_version: z.ZodNumber;
+    producer: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ArtifactInput = z.infer<typeof ArtifactInputSchema>;
+export type ParseFlags = z.infer<typeof ParseFlagsSchema>;
+/**
+ * The two supported pipe-delimited format families produced by lane agents.
+ */
+export type RowFormatFamily = 'base_explorer' | 'micro_lane';
+/**
+ * A single parsed candidate record extracted from lane text.
+ */
+export interface CandidateRecord {
+    record_type: 'candidate';
+    row_format_family: RowFormatFamily;
+    row_format_version: number;
+    record_version: {
+        major: number;
+        minor: number;
+    };
+    source_output_ref: string;
+    source_batch_id: string;
+    source_lane_id: string;
+    source_agent: string;
+    source_digest: string;
+    extracted_from_partial_source: boolean;
+    sessionId?: string;
+    parentSessionId?: string;
+    producer?: string;
+    candidate_id: string;
+    lane: string | null;
+    micro_lane: string | null;
+    severity: string | null;
+    category: string | null;
+    file_line: string | null;
+    claim: string | null;
+    evidence_summary: string | null;
+    impact_context: string | null;
+    invariant_violated: string | null;
+    confidence: string | null;
+}
+/**
+ * One invocation-envelope record per parseCandidates call.
+ * Part of the return value but not persisted to a sidecar in this phase.
+ */
+export interface InvocationEnvelope {
+    record_type: 'invocation';
+    source_output_ref: string;
+    source_batch_id: string;
+    source_lane_id: string;
+    source_agent: string;
+    source_digest: string;
+    row_format_version: number;
+    producer?: string;
+    produced_at: string;
+    record_version: {
+        major: number;
+        minor: number;
+    };
+    sessionId?: string;
+    parentSessionId?: string;
+    format_families_detected: string[];
+    candidate_count: number;
+    parse_errors: number;
+    malformed_rows: number;
+}
+/**
+ * Detail record for a required-field violation inside a data row.
+ */
+export interface ParseErrorDetail {
+    row_index: number;
+    field: string;
+    message: string;
+}
+/**
+ * Warning record for a candidate_id that occurs more than once.
+ */
+export interface DuplicateIdWarning {
+    candidate_id: string;
+    occurrences: number;
+}
+/**
+ * Aggregate diagnostics returned alongside every parse result.
+ */
+export interface DiagnosticsSummary {
+    candidate_count: number;
+    parse_errors: number;
+    parse_error_details: ParseErrorDetail[];
+    malformed_rows: number;
+    duplicate_id_count: number;
+    duplicate_id_warnings: DuplicateIdWarning[];
+    degraded_source_count: number;
+    incomplete_source_count: number;
+    format_families_detected: string[];
+}
+/**
+ * Top-level return value from parseCandidates.
+ */
+export interface ParseResult {
+    error?: string;
+    error_code?: string;
+    candidates: CandidateRecord[];
+    invocation_envelope: InvocationEnvelope;
+    diagnostics: DiagnosticsSummary;
+}
+/**
+ * Options for the parse-and-persist path.
+ */
+export interface ParsePersistOptions {
+    /** Project root directory (OpenCode process working directory). */
+    projectRoot: string;
+    /** Override the batch digest. When omitted, SHA-256(batchId) is used. */
+    batchDigest?: string;
+    /**
+     * Passed through to the sidecar store's `useLockfile` option.
+     * When true, a proper-lockfile lock is acquired on the batch directory
+     * before the append; on lock failure `sidecar_write_error` is set.
+     * Default: false (no lock — existing append-only pattern).
+     */
+    useLockfile?: boolean;
+}
+/**
+ * ParseResult extended with an optional sidecar write error.
+ * When sidecar_write_error is present, the parse succeeded but the
+ * sidecar append failed; the caller should treat the parse as valid
+ * and log/report the write error separately.
+ */
+export interface ParseResultWithSidecar extends ParseResult {
+    sidecar_write_error?: string;
+}
+/**
+ * Parse candidate records from structured lane-output text.
+ *
+ * This is a pure function: no filesystem writes, no store lookups, no I/O.
+ * The caller is responsible for store lookup, constructing the ArtifactInput,
+ * and setting artifact_status based on lookup outcome.
+ *
+ * @param input  Structured artifact metadata and raw text.
+ * @param flags  Caller-controlled acceptance flags and format version.
+ * @returns      Parsed candidates, invocation envelope, and diagnostics.
+ */
+export declare function parseCandidates(input: ArtifactInput, flags: ParseFlags): ParseResult;
+/**
+ * Parse candidates and append the invocation envelope + candidate records
+ * to the sidecar JSONL file.
+ *
+ * parseCandidates remains pure (no I/O). This wrapper adds sidecar
+ * persistence: on success the envelope + candidates are appended to
+ * `.swarm/lane-results/{batchDigest}/candidates.jsonl`; on append
+ * failure the parse still succeeds and sidecar_write_error is populated
+ * (SC-023).
+ *
+ * batchDigest is derived as SHA-256(batchId) when not explicitly provided
+ * in options (Option A — consistent with lane-output-store.ts internals).
+ *
+ * @param input   Structured artifact metadata and raw text.
+ * @param flags   Caller-controlled acceptance flags and format version.
+ * @param options Persistence options (projectRoot, optional batchDigest).
+ * @returns       Parse result with optional sidecar_write_error field.
+ */
+export declare function parseAndPersist(input: ArtifactInput, flags: ParseFlags, options: ParsePersistOptions): ParseResultWithSidecar;
+export {};

package/dist/background/candidate-sidecar-store.d.ts

@@ -0,0 +1,56 @@
+export interface SidecarStoreOptions {
+    /** Project root directory (the OpenCode process working directory). */
+    projectRoot: string;
+    /** Override the batch digest. When omitted, SHA-256(batchId) is used. */
+    batchDigest?: string;
+    /**
+     * When true, acquire a `proper-lockfile` lock on the batch directory
+     * before the append and release it afterwards.  Default: false (no lock —
+     * matches the existing append-only pattern the codebase already uses).
+     *
+     * On lock acquisition failure the function throws; the caller
+     * (`parseAndPersist`) catches and records `sidecar_write_error`.
+     */
+    useLockfile?: boolean;
+}
+/**
+ * Sanitize a single string value for sidecar persistence.
+ *
+ * Transformations applied in order:
+ * 1. NUL bytes (`\x00`) → `\u0000` escape (preserves information).
+ * 2. ANSI escape sequences (`\x1B[...]`) → entire sequence stripped.
+ *    Handles CSI (`ESC [ params intermediate final`), OSC (`ESC ] ... BEL/ST`),
+ *    and two-character escape sequences.
+ * 3. Unicode bidi markers (U+202A–U+202E, U+2066–U+2069) → stripped.
+ *
+ * All other characters pass through unchanged.
+ *
+ * @param value - Raw string value (may contain NUL bytes, ANSI, bidi markers).
+ * @returns Sanitized string safe for JSONL persistence.
+ */
+export declare function sanitizeString(value: string): string;
+/**
+ * Append an invocation envelope followed by zero or more candidate records
+ * to the sidecar JSONL file for the given batch.
+ *
+ * The envelope is always the first record in the append batch (SC-015).
+ * Cross-skill coexistence is enabled via the `producer` field on the
+ * envelope (FR-019).
+ *
+ * Content sanitization (FR-021) is applied to the persisted copy: NUL bytes
+ * are escaped to `\u0000`, ANSI ESC bytes are stripped, and Unicode bidi
+ * markers are stripped.  The caller's in-memory records are NOT mutated.
+ *
+ * Concurrency safety (FR-014): when `options.useLockfile` is true, a
+ * `proper-lockfile` lock is acquired on the batch directory before the
+ * append and released afterwards.  Lock acquisition failures propagate as
+ * throws.  Default behaviour (useLockfile omitted or false) is lockless
+ * append — the existing pattern used throughout the codebase.
+ *
+ * @param options  Store configuration (projectRoot, optional batchDigest, useLockfile).
+ * @param batchId  The batch identifier (used to derive batchDigest when not provided).
+ * @param envelope The invocation envelope record (validated before write).
+ * @param candidates Candidate records to append after the envelope (validated before write).
+ * @throws If schema validation fails, lock acquisition fails, or the filesystem write fails.
+ */
+export declare function appendToSidecar(options: SidecarStoreOptions, batchId: string, envelope: unknown, candidates: unknown[]): void;

package/dist/cli/{config-doctor-6h64pn8n.js → config-doctor-jzbgpbdh.js}

@@ -12,8 +12,8 @@ import {
   shouldRunOnStartup,
   writeBackupArtifact,
   writeDoctorArtifact
-} from "./index-1cb4wxnm.js";
-import"./index-q9h0wb04.js";
+} from "./index-819xp49y.js";
+import"./index-0asbrmdx.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{guardrail-explain-2q9myk7c.js → guardrail-explain-995zavv8.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-amwa268r.js";
-import"./index-kz1bmebr.js";
-import"./index-5hvbw5xh.js";
+} from "./index-tt5aehrb.js";
+import"./index-4td9ef53.js";
+import"./index-g00qm2gf.js";
 import"./index-yhsmmv2z.js";
 import"./index-32axfg6h.js";
 import"./index-e8pk68cc.js";
-import"./index-1cb4wxnm.js";
-import"./index-q9h0wb04.js";
+import"./index-819xp49y.js";
+import"./index-0asbrmdx.js";
 import"./index-8y7qetpg.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";

package/dist/cli/{guardrail-log-eegabqcp.js → guardrail-log-c7egm5km.js}

@@ -1,9 +1,9 @@
 // @bun
 import {
   handleGuardrailLog
-} from "./index-5vpe6vq9.js";
-import"./index-5hvbw5xh.js";
-import"./index-q9h0wb04.js";
+} from "./index-vjsr9bqt.js";
+import"./index-g00qm2gf.js";
+import"./index-0asbrmdx.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{index-q9h0wb04.js → index-0asbrmdx.js}

@@ -187,6 +187,10 @@ var TOOL_METADATA = {
       "test_engineer"
     ]
   },
+  parse_lane_candidates: {
+    description: "Parse [CANDIDATE] rows from a dispatch_lanes or collect_lane_results artifact (by output_ref), produce structured records with provenance, optionally persist to a per-batch sidecar JSONL. Pure-parser variant exists as internal module.",
+    agents: ["architect"]
+  },
   test_runner: {
     description: "auto-detect and run tests",
     agents: ["architect", "reviewer", "test_engineer"]