opencode-swarm 7.136.0 → 7.136.2

package/dist/services/skill-optimizer/store.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Append-only lifecycle store for the governed skill optimizer (issue #1822).
+ *
+ * Storage layout (all under `.swarm/`, AGENTS.md invariant #4):
+ *   .swarm/evolution/skills/<skillSlug>/<candidateId>/lifecycle.jsonl   (authoritative)
+ *   .swarm/evolution/skills/<skillSlug>/<candidateId>/state.json        (derived projection)
+ *   .swarm/evolution/skills/<skillSlug>/<candidateId>/baseline.md       (frozen baseline snapshot)
+ *   .swarm/evolution/skills/<skillSlug>/<candidateId>/candidate.md      (drafted candidate)
+ *   .swarm/evolution/skills/<skillSlug>/<candidateId>/diff.patch        (computed diff)
+ *   .swarm/evolution/skills/<skillSlug>/<candidateId>/rollback.md       (pre-activation snapshot)
+ *   .swarm/evolution/skills/lifecycle-quarantine.<ts>.<hash>            (corrupt-tail salvage)
+ *
+ * Integrity model mirrors `src/plan/ledger.ts`:
+ *   - fsync+rename atomic append, gated by an evidence lock;
+ *   - replay stops at the first unparseable line, sets `truncated`, captures
+ *     the bad suffix, and quarantines it WITHOUT rewriting the canonical ledger;
+ *   - hash-before/hash-after chain (reuses the plan-ledger field semantics —
+ *     no parallel "previousStateHash");
+ *   - partial/corrupt writes never count as acceptance (replay-after-write
+ *     verification in `recordTransition`, lifecycle.ts).
+ *
+ * IDs are collision-resistant and filesystem-safe (`crypto.randomUUID()`).
+ */
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { withEvidenceLock } from '../../evidence/lock.js';
+/** Lifecycle states (issue #1822 durable lifecycle). */
+export type SkillOptState = 'discovered' | 'drafted' | 'smoke_validated' | 'validation_running' | 'accepted_pending_approval' | 'rejected' | 'inconclusive' | 'activated' | 'expired' | 'rolled_back';
+/** A single append-only lifecycle event. Hash chain reuses plan-ledger semantics. */
+export interface SkillOptEvent {
+    seq: number;
+    timestamp: string;
+    candidateId: string;
+    skillSlug: string;
+    eventType: string;
+    fromState: SkillOptState | null;
+    toState: SkillOptState;
+    actor: string;
+    origin: string;
+    contentHashBefore: string | null;
+    contentHashAfter: string | null;
+    hashBefore: string;
+    hashAfter: string;
+    reason: string;
+    evidenceRefs: string[];
+    payload?: Record<string, unknown>;
+}
+export interface ReplayResult {
+    events: SkillOptEvent[];
+    state: SkillOptState | null;
+    truncated: boolean;
+    badSuffix: string | null;
+    /** Sequence number of the last complete (hash-verified) event. */
+    lastCompleteSeq: number;
+}
+/** SHA-256 over canonical JSON of an arbitrary value. */
+export declare function computeStateHash(value: unknown): string;
+/** SHA-256 of raw text content (a SKILL.md body). */
+export declare function computeContentHash(content: string): string;
+export declare function isValidSkillSlug(slug: string): boolean;
+/** Validate a candidate ID is filesystem-safe (uuid or equivalent). */
+export declare function isValidCandidateId(id: string): boolean;
+/** Mint a fresh collision-resistant candidate ID. */
+export declare function mintCandidateId(): string;
+/**
+ * Fsync-then-rename atomic write (mirrors `writeFileFsyncedThenRename` in
+ * `src/plan/ledger.ts:169`). fsync guarantees the bytes hit durable storage
+ * before the rename makes the file visible.
+ */
+declare function writeFileFsyncedThenRename(tempPath: string, targetPath: string, data: string): void;
+/** DI seam for test injection (AGENTS.md invariant #7 — preferred over mock.module). */
+export declare const _internals: {
+    withEvidenceLock: typeof withEvidenceLock;
+    writeFileFsyncedThenRename: typeof writeFileFsyncedThenRename;
+    writeFileSync: typeof writeFileSync;
+    readFileSync: typeof readFileSync;
+    renameSync: typeof renameSync;
+    unlinkSync: typeof unlinkSync;
+    existsSync: typeof existsSync;
+    statSync: import("node:fs").StatSyncFn;
+};
+/**
+ * Append a lifecycle event atomically. Computes the hash chain from the
+ * current replayed state, fsync+rename under an evidence lock, then verifies
+ * the append by re-reading. Returns the persisted event.
+ *
+ * Throws if the post-write replay does not contain the appended event at the
+ * expected seq — a partial/corrupt write never counts as a successful
+ * transition.
+ */
+export declare function appendEvent(directory: string, eventInput: Omit<SkillOptEvent, 'seq' | 'timestamp' | 'hashBefore' | 'hashAfter'> & {
+    timestamp?: string;
+}): Promise<SkillOptEvent>;
+/**
+ * Replay a candidate's lifecycle ledger. Mirrors `readLedgerEventsWithIntegrity`
+ * in `src/plan/ledger.ts:1105`: stops at the first unparseable line, marks the
+ * replay `truncated`, and surfaces the bad suffix for quarantine. The canonical
+ * ledger is NEVER rewritten or truncated by this read.
+ */
+export declare function replayCandidate(directory: string, skillSlug: string, candidateId: string): ReplayResult;
+/**
+ * Quarantine a corrupt ledger suffix. Writes the bad suffix to a unique side
+ * file under `.swarm/evolution/skills/`. NEVER rewrites or truncates the
+ * canonical `lifecycle.jsonl`. Mirrors `quarantineLedgerSuffix` in
+ * `src/plan/ledger.ts:1188`.
+ */
+export declare function quarantineSuffix(directory: string, skillSlug: string, badSuffix: string): string;
+/**
+ * Derive the projection `state.json` from the ledger replay. Derived, not
+ * authoritative — callers must always re-derive from the ledger rather than
+ * trust a stale projection. Writes atomically (temp+rename).
+ */
+export declare function writeStateProjection(directory: string, skillSlug: string, candidateId: string, replay: ReplayResult): void;
+/** Snapshot a text file (baseline/candidate/rollback) atomically. */
+export declare function writeArtifact(directory: string, skillSlug: string, candidateId: string, fileName: string, content: string): string;
+/** Read a snapshot artifact, returning null if absent. */
+export declare function readArtifact(directory: string, skillSlug: string, candidateId: string, fileName: string): string | null;
+export declare const SKILL_OPT_STORE_SCHEMA_VERSION = "1";
+export {};

package/dist/tools/write-pr-review-trigger-eval.d.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
-import { resolveExactMergeBase, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
+import { resolveExactMergeBase, resolvePrWorkflowRevisionDigest, resolvePrWorkflowRevisionDigestAsync } from '../background/workspace-snapshot.js';
 import { createSwarmTool } from './create-tool';
 export { PR_REVIEW_TRIGGER_DEFINITIONS } from '../background/pr-review-trigger-contract.js';
 export declare const _internals: {
     resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    resolvePrWorkflowRevisionDigestAsync: typeof resolvePrWorkflowRevisionDigestAsync;
     resolveMergeBase: typeof resolveExactMergeBase;
 };
 declare const WritePrReviewTriggerEvalArgsSchema: z.ZodObject<{

package/dist/utils/stable-stringify.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Stable JSON serialization helpers.
+ *
+ * # Why this exists
+ *
+ * Several subsystems hash tool-call arguments for repetition / spiral
+ * detection. Two requirements make naive `JSON.stringify(value)` incorrect:
+ *
+ * 1. **Key-order independence.** Two semantically identical objects whose
+ *    keys were inserted in different order (`{a:1,b:2}` vs `{b:2,a:1}`) must
+ *    hash equally, otherwise a genuine repetition loop whose args happen to
+ *    be built with reordered keys is missed.
+ *
+ * 2. **No nested-key loss.** A `JSON.stringify(value, sortedKeysArray)`
+ *    property-list replacer looks like it sorts keys — and it does, but only
+ *    for the top level. At every deeper object it acts as a *filter*,
+ *    dropping any key not present in the (top-level-derived) list. For nested
+ *    args like `{todos:[{content,status}]}` every todo collapses to `{}`,
+ *    re-introducing the exact false-collision class this is meant to prevent.
+ *
+ * `stableCanonicalStringify` rebuilds each object with sorted keys at every
+ * depth (no filtering) and serializes arrays element-wise, producing a stable
+ * canonical string suitable for hashing.
+ *
+ * Originally introduced for the adversarial-detector spiral hash
+ * (issue #2060) and shared with `file-authority.hashArgs` so both code paths
+ * use one correct implementation.
+ */
+/**
+ * Recursively produces a canonical JSON string with object keys sorted at
+ * EVERY depth (not just the top level). Arrays are serialized element-wise in
+ * index order.
+ *
+ * Why not `JSON.stringify(value, sortedKeysArray)`: a property-list replacer
+ * array acts as a KEY FILTER at every object depth, not just the top level, so
+ * any key not in the (top-level-derived) list is silently dropped from nested
+ * objects. For tool args like `{todos:[{content,status}]}`, that collapses
+ * every todo to `{}`, re-introducing the exact false-collision class this
+ * function exists to eliminate. Sorting must be done by rebuilding each object
+ * with sorted keys before serialization.
+ *
+ * Throws on cyclic structures (infinite recursion) and on values that
+ * `JSON.stringify` cannot represent (BigInt); callers should wrap in try/catch
+ * and fall back to a stable coarse hash.
+ */
+export declare function stableCanonicalStringify(value: unknown): string;

package/evaluation-fixtures/skill-eval/scoring/score-skill-eval.cjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/*
+ * Skill-eval project scorer wrapper (issue #1822 — D1, critic C1).
+ *
+ * The evaluation substrate invokes `kind:'project'` scorers as isolated
+ * subprocesses (runner.ts:175-228), passing:
+ *   - SWARM_EVAL_TASK_ID, SWARM_EVAL_CANDIDATE_ID, SWARM_EVAL_SEED
+ *   - SWARM_EVAL_ARTIFACT_DIR (contains model-output.json with the candidate's
+ *     generated text under { v: 1, text: "..." })
+ *   - argv: [<this-script>, <phrase-spec-path>]
+ *
+ * The scorer reads the candidate text from model-output.json, reads the phrase
+ * spec (required_phrases / forbidden_phrases), and emits a ScorerOutputV1 line:
+ *   { "v": 1, "score": <0..1>, "cost": { "source": "unavailable" } }
+ *
+ * The scoring arithmetic is the SAME as `scoreSkillPhrases` in
+ * src/services/skill-evaluator.ts (the source of truth). A parity test
+ * (tests/unit/services/skill-evaluator-refactor.test.ts) proves the two agree,
+ * so there is no duplicate scorer — one authoritative function, one thin
+ * subprocess mirror that must match.
+ *
+ * Score = requiredHits / max(1, required.length), minus a 1-point penalty if
+ * any forbidden phrase is present, clamped to >= 0. Phrase matching is
+ * case-insensitive substring.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function readArtifact() {
+	const dir = process.env.SWARM_EVAL_ARTIFACT_DIR;
+	if (!dir) throw new Error('missing SWARM_EVAL_ARTIFACT_DIR');
+	const file = path.join(dir, 'model-output.json');
+	const raw = fs.readFileSync(file, 'utf8');
+	const parsed = JSON.parse(raw);
+	if (!parsed || typeof parsed.text !== 'string') {
+		throw new Error('model-output.json missing text field');
+	}
+	return parsed.text;
+}
+
+function readPhraseSpec(specPath) {
+	if (!specPath || !fs.existsSync(specPath)) {
+		return { required: [], forbidden: [] };
+	}
+	const parsed = JSON.parse(fs.readFileSync(specPath, 'utf8'));
+	return {
+		required: Array.isArray(parsed.required_phrases) ? parsed.required_phrases : [],
+		forbidden: Array.isArray(parsed.forbidden_phrases) ? parsed.forbidden_phrases : [],
+	};
+}
+
+function includesPhrase(content, phrase) {
+	return content.toLowerCase().includes(String(phrase).toLowerCase());
+}
+
+function scoreSkillPhrases(content, spec) {
+	const required = spec.required;
+	const forbidden = spec.forbidden;
+	let requiredHits = 0;
+	for (const phrase of required) {
+		if (includesPhrase(content, phrase)) requiredHits++;
+	}
+	const requiredScore = required.length === 0 ? 1 : requiredHits / Math.max(1, required.length);
+	const forbiddenPenalty = forbidden.some((p) => includesPhrase(content, p)) ? 1 : 0;
+	return Math.max(0, requiredScore - forbiddenPenalty);
+}
+
+function main() {
+	const specPath = process.argv[2];
+	const content = readArtifact();
+	const spec = readPhraseSpec(specPath);
+	const score = scoreSkillPhrases(content, spec);
+	process.stdout.write(
+		JSON.stringify({ v: 1, score, cost: { source: 'unavailable' } }) + '\n',
+	);
+}
+
+try {
+	main();
+} catch (err) {
+	// ScorerFailure 'malformed' — the runner treats non-zero exit / bad JSON as a
+	// task failure rather than a candidate score. Emit a zero-score with a
+	// metadata reason so the run records the failure deterministically.
+	process.stderr.write(`score-skill-eval failed: ${err && err.message ? err.message : String(err)}\n`);
+	process.stdout.write(
+		JSON.stringify({
+			v: 1,
+			score: 0,
+			cost: { source: 'unavailable' },
+			metadata: { failure: 'scorer-error', reason: String(err && err.message ? err.message : err).slice(0, 200) },
+		}) + '\n',
+	);
+	process.exitCode = 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.136.0",
+	"version": "7.136.2",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",