opencode-swarm 7.181.2 → 7.181.4

package/dist/memory/index.d.ts

@@ -7,6 +7,7 @@ export type { MemoryGatewayOptions, ProposeMemoryInput, RecallMemoryInput, Recor
 export { createConfiguredMemoryProvider, createConfiguredMemoryProviderForRoot, createMemoryGateway, MemoryGateway, } from './gateway';
 export { type HeldoutRecallCorpusCase, type HeldoutRecallCorpusManifest, type LoadedHeldoutRecallScenario, loadHeldoutRecallEvaluationCorpus, loadHeldoutRecallEvaluationScenarios, validateHeldoutRecallCorpusManifest, } from './heldout-evaluation-corpus';
 export { createMemoryLifecycleHooks, type MemoryLifecycleHookOptions, type MemoryLifecycleHooks, } from './injector';
+export { DEFAULT_INSTRUCTION_PAIRING_TASKS, type InstructionPairingArmResult, type InstructionPairingDirectivePriority, type InstructionPairingOptions, type InstructionPairingPair, type InstructionPairingRecord, type InstructionPairingReport, type InstructionPairingTask, runInstructionSelectionPairing, } from './instruction-pairing';
 export { backupLegacyJsonl, getLegacyJsonlFileStatus, getLegacyOutcomeJsonlSignature, type JsonlBackupResult, type JsonlImportPayload, type JsonlInvalidRow, type JsonlMigrationReport, LEGACY_JSONL_MIGRATION_NAME, LEGACY_JSONL_MIGRATION_VERSION, LEGACY_JSONL_OUTCOME_META_KEY, readLegacyJsonl, readMigrationReport, resolveMemoryStorageDir, resolveSqliteDatabasePath, writeJsonlExport, writeMigrationReport, } from './jsonl-migration';
 export { LocalJsonlMemoryProvider } from './local-jsonl-provider';
 export { buildMemoryMaintenanceReport, type MemoryMaintenanceReport, type MemoryMaintenanceReportOptions, type MemoryRecallUsageByMemory, type MemoryRecallUsageByRole, type MemorySupersededChain, shouldCompactMemory, } from './maintenance';

package/dist/memory/instruction-pairing.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Paired cached-vs-uncached outcome evidence for instruction selection (#2672).
+ *
+ * Runs the REAL knowledge-injector hook (the plugin's instruction-selection and
+ * instruction-cache surface) over deterministic, offline fixture tasks and
+ * reports paired per-task outcomes: quality (which directive labels survive
+ * selection), latency per arm, cache reads, uncached cost, and the rendered
+ * prefix length at the host-renderable carrier boundary.
+ *
+ * Contract discipline (issue #2672):
+ * - Same task/model/budget on both arms; the uncached arm is the regeneration
+ *   reference and the cached arm replays byte-identical context on a warm
+ *   per-instance cache.
+ * - Negative results are RETAINED rows (`negative_result: true` when the
+ *   cached arm did not improve the paired quality outcome). On the offline
+ *   deterministic corpus both arms run the same selection algorithm over the
+ *   same records, so `quality_outcome` is 'identical' by design — the honest
+ *   "caching did not change instruction quality" negative result.
+ * - NO percentage or savings claim exists anywhere in the report: deltas are
+ *   absolute numbers and every quantity names its denominator in `measurement`.
+ * - `identity.instruction_set_digest` is the evidence handle a HarnessOpt
+ *   lineage record (#2503) can reference; this module never modifies the
+ *   harness-optimizer — #2503 remains the broad held-out comparison owner.
+ */
+export type InstructionPairingDirectivePriority = 'critical' | 'high' | 'medium' | 'low';
+export interface InstructionPairingRecord {
+    /**
+     * Stable identifier recovered from the rendered prefix. Constrained to
+     * `[A-Za-z0-9-]` (PRR-012): other characters still reach the fixture
+     * store verbatim but can never be matched back by the sentinel pattern,
+     * silently undercounting `quality.expected_hit_count` for that record.
+     */
+    label: string;
+    lesson: string;
+    directivePriority?: InstructionPairingDirectivePriority;
+    tags?: string[];
+}
+export interface InstructionPairingTask {
+    id: string;
+    lastUserMessage: string;
+    expectedLabels: string[];
+    records: InstructionPairingRecord[];
+}
+export interface InstructionPairingOptions {
+    /**
+     * Project directory context. Fixture stores live in disposable temp roots
+     * (never under the caller's `.swarm/`); when `writeReport` is set, the
+     * durable report artifact is written under this directory's
+     * `.swarm/memory/`.
+     */
+    directory: string;
+    /** Omitted falls back to the deterministic DEFAULT_INSTRUCTION_PAIRING_TASKS. */
+    tasks?: InstructionPairingTask[];
+    modelId?: string;
+    injectCharBudget?: number;
+    /** Explicit report destination; overrides the `writeReport` default path. */
+    reportPath?: string;
+    /** Write the report to `<directory>/.swarm/memory/instruction-pairing-report.json`. */
+    writeReport?: boolean;
+}
+export interface InstructionPairingArmResult {
+    latency_ms: number;
+    /** Injections served from the warm context cache in the measured invocation (0 or 1). */
+    cache_reads: number;
+    /** How cache_reads was determined ('events-file-delta' = observed, 'protocol-assumed' = identical-context replay). */
+    cache_reads_basis: string;
+    rendered_prefix_chars: number;
+    /** The paired uncached arm's regeneration latency, reported on both arms (paired attribution, absolute ms). */
+    uncached_cost: number;
+    quality: {
+        expected_hit_count: number;
+        expected_total: number;
+        selected_labels: string[];
+    };
+}
+export interface InstructionPairingPair {
+    task: {
+        id: string;
+    };
+    arm_cached: InstructionPairingArmResult;
+    arm_uncached: InstructionPairingArmResult;
+    quality_outcome: 'identical' | 'improved' | 'degraded';
+    negative_result: boolean;
+}
+export interface InstructionPairingReport {
+    schema_version: 1;
+    generated_at: string;
+    identity: {
+        task_set_id: string;
+        model_id: string;
+        budget_chars: number;
+        instruction_set_digest: string;
+    };
+    pairs: InstructionPairingPair[];
+    measurement: {
+        latency_denominator: string;
+        cost_denominator: string;
+        prefix_denominator: string;
+    };
+    negative_results_retained: boolean;
+    cache_invalidation: {
+        verified: boolean;
+        detail: string;
+    };
+}
+/** Deterministic offline corpus used when `options.tasks` is omitted. */
+export declare const DEFAULT_INSTRUCTION_PAIRING_TASKS: InstructionPairingTask[];
+/**
+ * Runs the paired cached-vs-uncached control over the task set and returns the
+ * report. Deterministic and offline (lexical store, hive disabled, real hook).
+ */
+export declare function runInstructionSelectionPairing(options: InstructionPairingOptions): Promise<InstructionPairingReport>;

package/dist/services/model-preflight.d.ts

@@ -1,18 +1,21 @@
 /**
- * Agent model-resolution preflight (issue #2271 bug 4).
+ * Agent model-resolution preflight (issue #2271 bug 4; issue #2680).
  *
- * Agent model strings (DEFAULT_MODELS plus user `agents.<role>.model`
- * overrides) are handed to the OpenCode host unvalidated. When one does not
- * resolve ("Model not found", "Forbidden"), dispatch-lanes classifies the
- * failure as permanent, the affected agent never runs, and the plan-critic
- * gate wedges into manual `approve_plan_critic` overrides because no APPROVED
- * verdict is ever produced.
+ * Agent model strings (DEFAULT_MODELS plus user `agents.<role>.model` /
+ * `swarms.<id>.agents.<role>.model` overrides) are handed to the OpenCode host
+ * unvalidated. When one does not resolve ("Model not found", "Forbidden"),
+ * dispatch-lanes classifies the failure as permanent, the affected agent never
+ * runs, and the plan-critic gate wedges into manual `approve_plan_critic`
+ * overrides because no APPROVED verdict is ever produced.
  *
- * This module validates configured model IDs against the live provider
- * catalog (`client.provider.list()`). Every check is FAIL-OPEN: if the catalog
- * is unreachable or malformed, results come back `unknown` and callers must
- * proceed — the preflight only acts on a POSITIVE confirmation that a model
- * does not resolve.
+ * This module validates the FINAL effective model selection for every ENABLED
+ * legacy and prefixed multi-swarm role (issue #2680) against the live provider
+ * catalog (`client.provider.list()`), reusing the exact-name resolution
+ * helpers from src/config/agent-model.ts. Every check is FAIL-OPEN: if the
+ * catalog is unreachable or malformed, results come back `unknown` and callers
+ * must proceed — the preflight only acts on a POSITIVE confirmation that a
+ * model does not resolve (or that no final selection exists at all, the
+ * catalog-independent `missing-selection` class).
  */
 import type { OpencodeClient } from '@opencode-ai/sdk';
 import type { PluginConfig } from '../config/schema.js';
@@ -21,12 +24,17 @@ export declare const PROVIDER_LIST_TIMEOUT_MS = 2000;
 export interface ConfiguredAgentModel {
     /** Agent role the model is configured for. */
     agent: string;
-    /** Full model id in `provider/model` form. */
+    /** Full model id in `provider/model` form. Empty when no final selection exists. */
     model: string;
     /** Where the value came from. */
     source: 'default' | 'override' | 'fallback';
+    /**
+     * Issue #2680: whether the entry's role is registered as a primary agent
+     * (OpenCode's UI owns its model selection) or a dispatchable subagent.
+     */
+    mode?: 'primary' | 'subagent';
 }
-export type ModelResolutionStatus = 'ok' | 'unresolved' | 'unknown';
+export type ModelResolutionStatus = 'ok' | 'unresolved' | 'unknown' | 'missing-selection' | 'host-controlled';
 export interface ModelResolution {
     agent: string;
     model: string;
@@ -34,6 +42,7 @@ export interface ModelResolution {
     status: ModelResolutionStatus;
     /** Human-readable explanation for non-ok statuses. */
     detail?: string;
+    mode?: ConfiguredAgentModel['mode'];
 }
 export interface ModelPreflightResult {
     /** False when the catalog could not be fetched — every entry is `unknown`. */
@@ -53,29 +62,102 @@ export declare function splitModelId(model: string): {
  * Collect every model id the swarm could dispatch with: DEFAULT_MODELS
  * entries, user agent overrides, and declared fallback_models. Overriding one
  * role replaces its default (mirrors getModelForAgent precedence).
+ *
+ * Superseded by collectEnabledAgentModels (issue #2680): this legacy view
+ * enumerates the top-level config plus a blanket DEFAULT_MODELS pass and
+ * cannot see multi-swarm per-swarm selections or enabled-role gating. Retained
+ * unchanged for API compatibility; runModelPreflight no longer consumes it.
  */
 export declare function collectConfiguredAgentModels(config?: PluginConfig): ConfiguredAgentModel[];
+/**
+ * Issue #2680: compute the generated agent names the plugin would register for
+ * this configuration — the "enabled role" domain the preflight must validate.
+ * Mirrors createAgents' generation rules (legacy single default swarm vs
+ * per-swarm prefixing; object-level top-level merge; disabled exclusion;
+ * feature-gated roles only while their flag is on). The live
+ * swarmState.generatedAgentNames registry stays authoritative when available;
+ * this computation is the config-only fallback (doctor, unit tests) and is
+ * drift-guarded by the parity test.
+ */
+export declare function enumerateEnabledAgentRoles(config?: PluginConfig): string[];
+/** Options for the enabled-role preflight (issue #2680). */
+export interface EnabledAgentPreflightOptions {
+    /**
+     * The live registry of generated agent names the host actually registered
+     * (swarmState.generatedAgentNames). Authoritative when provided; the
+     * config-only enumeration is the fallback.
+     */
+    generatedAgentNames?: readonly string[];
+    /**
+     * The registered agents map (name → { model, mode }) as produced by
+     * createAgents/getAgentConfigs. When provided, `mode` comes from it;
+     * otherwise primaries are derived via resolvePrimaryAgentNames.
+     */
+    registeredAgents?: Record<string, {
+        model?: unknown;
+        mode?: unknown;
+    }>;
+}
+/**
+ * Issue #2680: collect the FINAL effective model selection for every enabled
+ * legacy and prefixed multi-swarm role, plus each role's explicitly configured
+ * fallback entries. Final selections are computed with the shipped exact-name
+ * helpers (resolveRegisteredAgentModel / resolveConfiguredAgentModel) so
+ * defaults, swarm prefixes, and the object-level merge match dispatch reality.
+ *
+ * Outcome classes (see resolveAgainstCatalog):
+ * - an explicitly configured but blank model, or a registry name that resolves
+ *   to no target at all, yields an EMPTY model — the distinct
+ *   `missing-selection` class (never silently treated as a successful default);
+ * - primary roles are tagged `mode: 'primary'` → `host-controlled` (OpenCode's
+ *   UI owns their selection);
+ * - fallback entries appear only when explicitly configured and recorded —
+ *   never synthesized (curator roles inherit explorer's chain at runtime via
+ *   resolveFallbackModel; that inheritance is documented, not duplicated here).
+ */
+export declare function collectEnabledAgentModels(config?: PluginConfig, opts?: EnabledAgentPreflightOptions): ConfiguredAgentModel[];
 /** Provider catalog snapshot: provider id → set of model ids. */
 export type ProviderCatalog = Map<string, Set<string>>;
 /** Test/gate seam: drop the cached catalogs (used after config changes and denials). */
 export declare function invalidateProviderCatalogCache(): void;
+/**
+ * PR #2782 review PRR-001: neutralize control characters before interpolating
+ * config- or host-sourced strings (model ids, agent names, provider detail)
+ * into console.warn / thrown-Error text. Newlines forge multi-line
+ * plugin-looking output and ESC sequences drive the terminal; control runs
+ * collapse to a single space (same policy as the doctor's stripControlChars).
+ */
+export declare function sanitizePreflightText(value: string): string;
 /**
  * Fetch the provider catalog. Returns null when the catalog cannot be
  * obtained or parsed — callers fail open on null.
  */
 export declare function fetchProviderCatalog(client: OpencodeClient | null): Promise<ProviderCatalog | null>;
 /**
- * Validate collected models against a catalog. A model whose provider is
- * absent from the catalog, or whose provider exists but does not list the
- * model, is `unresolved` — but only when the catalog itself was successfully
- * fetched (callers must treat a null catalog as fail-open, never unresolved).
+ * Validate collected models against a catalog. Classification order (issue
+ * #2680): an EMPTY model is the catalog-independent `missing-selection` class;
+ * a primary role is `host-controlled` (OpenCode's UI owns its selection —
+ * never a preflight failure and never a consumer-default warning); otherwise
+ * the catalog decides — a model whose provider is absent from the catalog, or
+ * whose provider exists but does not list the model, is `unresolved` — but
+ * only when the catalog itself was successfully fetched (callers must treat a
+ * null catalog as fail-open, never unresolved).
  */
 export declare function resolveAgainstCatalog(models: ConfiguredAgentModel[], catalog: ProviderCatalog | null): ModelPreflightResult;
 /**
- * End-to-end preflight: collect configured models, fetch the catalog, and
- * resolve. Fail-open on every catalog error.
+ * Issue #2680: render the operator warning for a preflight result. Reports
+ * ONLY actionable classes (`unresolved`, `missing-selection`) — ok/unknown
+ * entries and host-controlled primaries stay silent, so disabled, optional,
+ * and merely-uninvoked roles never produce consumer-default noise. Returns
+ * null when there is nothing to report.
+ */
+export declare function formatModelPreflightWarning(result: ModelPreflightResult): string | null;
+/**
+ * End-to-end preflight: collect the FINAL effective selection for every
+ * enabled role (issue #2680), fetch the catalog, and resolve. Fail-open on
+ * every catalog error.
  */
-export declare function runModelPreflight(config: PluginConfig | undefined, client: OpencodeClient | null): Promise<ModelPreflightResult>;
+export declare function runModelPreflight(config: PluginConfig | undefined, client: OpencodeClient | null, opts?: EnabledAgentPreflightOptions): Promise<ModelPreflightResult>;
 /**
  * Resolves a single model id against the live catalog for gate preflights.
  * Returns 'unknown' whenever the catalog cannot be fetched — gates must only

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.181.2",
+	"version": "7.181.4",
 	"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",

package/dist/cli/curator-drift-hz3j3fad.js

@@ -1,297 +0,0 @@
-// @bun
-import {
-  canonicalProjectKey,
-  getGlobalEventBus,
-  getGroupCommitWriter,
-  importLegacyJsonFiles
-} from "./index-et7tg13p.js";
-import {
-  readEffectiveSpecSync
-} from "./index-m779twtf.js";
-import"./index-kzmd4gs7.js";
-import {
-  readSwarmFileAsync
-} from "./index-gc6h1fmf.js";
-import"./index-2s7dvzff.js";
-import"./index-0725jpp7.js";
-import {
-  DURABILITY_CLASSES,
-  getProjectDb,
-  projectDbExists
-} from "./index-vvgpgcyn.js";
-import"./index-rdm3px0g.js";
-import"./index-ry16d01s.js";
-import"./index-1xnse449.js";
-import"./index-c1ggtmpm.js";
-import"./index-ejhxgyvm.js";
-import"./index-7g4c7s5r.js";
-import"./index-989v83pb.js";
-import"./index-n5a9dq5s.js";
-import"./index-zxdawwc7.js";
-import"./index-5hxv1er2.js";
-import"./index-2t21pv2v.js";
-import"./index-bk5tah7q.js";
-import"./index-gknz3bv1.js";
-import"./index-zpsr8rpc.js";
-import {
-  init_logger,
-  warn
-} from "./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-
-// src/db/phase-report-store.ts
-import { readdirSync } from "fs";
-import { join } from "path";
-var PHASE_REPORT_LEGACY_PREFIXES = {
-  curator_drift: "drift-report-phase-",
-  design_doc_drift: "doc-drift-phase-"
-};
-var importedRoots = new Set;
-function hasAnyPhaseReportState(directory) {
-  if (projectDbExists(directory))
-    return true;
-  const root = canonicalProjectKey(directory);
-  let entries;
-  try {
-    entries = readdirSync(join(root, ".swarm"));
-  } catch {
-    return false;
-  }
-  for (const prefix of Object.values(PHASE_REPORT_LEGACY_PREFIXES)) {
-    if (entries.some((name) => name.startsWith(prefix) && name.endsWith(".json") && !name.includes(".imported"))) {
-      return true;
-    }
-  }
-  return false;
-}
-function kindCount(db, kind) {
-  return db.query("SELECT COUNT(*) as count FROM phase_report WHERE kind = ?").get(kind)?.count ?? 0;
-}
-function ensurePhaseReportsImported(directory) {
-  const root = canonicalProjectKey(directory);
-  if (importedRoots.has(root))
-    return;
-  for (const kind of Object.keys(PHASE_REPORT_LEGACY_PREFIXES)) {
-    importLegacyJsonFiles(directory, {
-      filePrefix: PHASE_REPORT_LEGACY_PREFIXES[kind],
-      kind,
-      kindCount: (db) => kindCount(db, kind),
-      upsertRow: (db, phase, payload) => {
-        db.run(`INSERT INTO phase_report (kind, phase, payload, updated_at)
-					VALUES (?, ?, ?, datetime('now'))
-					ON CONFLICT(kind, phase) DO UPDATE SET
-						payload = excluded.payload,
-						updated_at = datetime('now')`, [kind, phase, payload]);
-      }
-    });
-  }
-  importedRoots.add(root);
-}
-async function upsertPhaseReportDb(directory, kind, phase, payload) {
-  ensurePhaseReportsImported(directory);
-  const writer = getGroupCommitWriter(directory);
-  writer.enqueue({
-    durability: DURABILITY_CLASSES.phase_report,
-    run: (db) => {
-      db.run(`INSERT INTO phase_report (kind, phase, payload, updated_at)
-				VALUES (?, ?, ?, datetime('now'))
-				ON CONFLICT(kind, phase) DO UPDATE SET
-					payload = excluded.payload,
-					updated_at = datetime('now')`, [kind, phase, payload]);
-    }
-  });
-  await writer.flush();
-}
-function readPhaseReportsDb(directory, kind) {
-  if (!hasAnyPhaseReportState(directory))
-    return [];
-  ensurePhaseReportsImported(directory);
-  const db = getProjectDb(directory);
-  return db.query("SELECT phase, payload FROM phase_report WHERE kind = ? ORDER BY phase").all(kind).map((row) => ({ phase: row.phase, payload: row.payload }));
-}
-function phaseReportLocator(kind, phase) {
-  return `swarm.db:phase_report(${kind},${phase})`;
-}
-
-// src/hooks/curator-drift.ts
-init_logger();
-async function readPriorDriftReports(directory) {
-  const reports = [];
-  try {
-    for (const row of readPhaseReportsDb(directory, "curator_drift")) {
-      try {
-        const report = JSON.parse(row.payload);
-        if (typeof report.phase !== "number" || typeof report.alignment !== "string" || typeof report.timestamp !== "string" || typeof report.drift_score !== "number" || typeof report.schema_version !== "number" || !Array.isArray(report.compounding_effects)) {
-          warn(`[curator-drift] Skipping corrupt drift report: phase ${row.phase}`);
-          continue;
-        }
-        reports.push(report);
-      } catch {
-        warn(`[curator-drift] Skipping unreadable drift report: phase ${row.phase}`);
-      }
-    }
-  } catch {
-    return [];
-  }
-  reports.sort((a, b) => a.phase - b.phase);
-  return reports;
-}
-async function writeDriftReport(directory, report) {
-  const locator = phaseReportLocator("curator_drift", report.phase);
-  try {
-    await upsertPhaseReportDb(directory, "curator_drift", report.phase, JSON.stringify(report, null, 2));
-  } catch (err) {
-    throw new Error(`[curator-drift] Failed to write drift report to ${locator}: ${String(err)}`);
-  }
-  return locator;
-}
-var _internals = {
-  readPriorDriftReports,
-  writeDriftReport,
-  runDeterministicDriftCheck,
-  buildDriftInjectionText
-};
-function extractRequirementIds(text) {
-  const matches = text.match(/(?:[A-Za-z0-9][A-Za-z0-9._-]*\/)?FR-\d{3}/g);
-  return matches ? [...new Set(matches)] : [];
-}
-function bareSuffixCovers(specId, refId) {
-  return refId === specId || !refId.includes("/") && specId.endsWith(`/${refId}`);
-}
-async function runDeterministicDriftCheck(directory, phase, curatorResult, config, injectAdvisory) {
-  try {
-    const planMd = await readSwarmFileAsync(directory, "plan.md");
-    const specMd = readEffectiveSpecSync(directory)?.content ?? null;
-    const priorReports = await _internals.readPriorDriftReports(directory);
-    const complianceCount = curatorResult.compliance.length;
-    const warningCompliance = curatorResult.compliance.filter((obs) => obs.severity === "warning");
-    let alignment = "ALIGNED";
-    let driftScore = 0;
-    const specRequirements = specMd ? extractRequirementIds(specMd) : [];
-    const planRequirements = planMd ? extractRequirementIds(planMd) : [];
-    const digestRequirements = extractRequirementIds(JSON.stringify(curatorResult.digest) + JSON.stringify(curatorResult.compliance) + JSON.stringify(curatorResult.knowledge_recommendations ?? []));
-    if (!planMd) {
-      alignment = "MINOR_DRIFT";
-      driftScore = 0.3;
-    } else if (specRequirements.length > 0) {
-      const coveredInPlan = specRequirements.filter((fr) => planRequirements.some((ref) => bareSuffixCovers(fr, ref)));
-      const coveredInDigest = specRequirements.filter((fr) => digestRequirements.some((ref) => bareSuffixCovers(fr, ref)));
-      const specCoverageRatio = coveredInPlan.length / specRequirements.length;
-      const implementationRatio = coveredInDigest.length / specRequirements.length;
-      if (specCoverageRatio < 0.5) {
-        alignment = "MAJOR_DRIFT";
-        driftScore = Math.min(0.9, 0.6 + (1 - specCoverageRatio) * 0.3);
-      } else if (warningCompliance.length >= 3) {
-        alignment = "MAJOR_DRIFT";
-        driftScore = Math.min(0.9, 0.5 + warningCompliance.length * 0.1);
-      } else if (warningCompliance.length >= 1 || complianceCount >= 3) {
-        alignment = "MINOR_DRIFT";
-        driftScore = Math.min(0.49, 0.2 + complianceCount * 0.05);
-      } else if (implementationRatio < 0.5) {
-        alignment = "MINOR_DRIFT";
-        driftScore = Math.min(0.6, 0.2 + (1 - implementationRatio) * 0.3);
-      }
-    } else {
-      if (warningCompliance.length >= 3) {
-        alignment = "MAJOR_DRIFT";
-        driftScore = Math.min(0.9, 0.5 + warningCompliance.length * 0.1);
-      } else if (warningCompliance.length >= 1 || complianceCount >= 3) {
-        alignment = "MINOR_DRIFT";
-        driftScore = Math.min(0.49, 0.2 + complianceCount * 0.05);
-      }
-    }
-    const keyCorrections = warningCompliance.map((obs) => obs.description);
-    const firstDeviation = warningCompliance.length > 0 ? {
-      phase,
-      task: "unknown",
-      description: warningCompliance[0]?.description ?? ""
-    } : null;
-    const requirementsChecked = curatorResult.digest.tasks_total;
-    const requirementsSatisfied = curatorResult.digest.tasks_completed;
-    const coverageNote = specRequirements.length > 0 ? ` [${digestRequirements.filter((ref) => specRequirements.some((fr) => bareSuffixCovers(fr, ref))).length}/${specRequirements.length} FRs covered]` : "";
-    const injectionSummaryRaw = `Phase ${phase}: ${alignment} (${driftScore.toFixed(2)})${coverageNote} \u2014 ${firstDeviation ? firstDeviation.description : "all requirements on track"}.${keyCorrections.length > 0 ? `Correction: ${keyCorrections[0] ?? ""}.` : ""}`;
-    const injectionSummary = injectionSummaryRaw.slice(0, config.drift_inject_max_chars);
-    const report = {
-      schema_version: 1,
-      phase,
-      timestamp: new Date().toISOString(),
-      alignment,
-      drift_score: driftScore,
-      first_deviation: firstDeviation,
-      compounding_effects: priorReports.filter((r) => r.alignment !== "ALIGNED").map((r) => `Phase ${r.phase}: ${r.alignment}`).slice(0, 5),
-      corrections: keyCorrections.slice(0, 5),
-      requirements_checked: requirementsChecked,
-      requirements_satisfied: requirementsSatisfied,
-      scope_additions: [],
-      injection_summary: injectionSummary
-    };
-    const reportPath = await _internals.writeDriftReport(directory, report);
-    getGlobalEventBus().publish("curator.drift.completed", {
-      phase,
-      alignment,
-      drift_score: driftScore,
-      report_path: reportPath
-    });
-    if (injectAdvisory && alignment !== "ALIGNED" && driftScore > 0) {
-      try {
-        const advisoryText = `CURATOR DRIFT DETECTED (phase ${phase}, score ${driftScore.toFixed(2)}): ${injectionSummary.slice(0, 300)}. Review the phase-${phase} drift report stored in .swarm/swarm.db (${phaseReportLocator("curator_drift", phase)}) and address spec alignment before proceeding. Consider running critic_drift_verifier before phase completion to get a proper drift review.`;
-        injectAdvisory(advisoryText);
-      } catch {}
-    }
-    const injectionText = injectionSummary;
-    return {
-      phase,
-      report,
-      report_path: reportPath,
-      injection_text: injectionText
-    };
-  } catch (err) {
-    getGlobalEventBus().publish("curator.error", {
-      operation: "drift",
-      phase,
-      error: String(err)
-    });
-    const defaultReport = {
-      schema_version: 1,
-      phase,
-      timestamp: new Date().toISOString(),
-      alignment: "ALIGNED",
-      drift_score: 0,
-      first_deviation: null,
-      compounding_effects: [],
-      corrections: [],
-      requirements_checked: 0,
-      requirements_satisfied: 0,
-      scope_additions: [],
-      injection_summary: `Phase ${phase}: drift analysis unavailable (${String(err)})`
-    };
-    return {
-      phase,
-      report: defaultReport,
-      report_path: "",
-      injection_text: ""
-    };
-  }
-}
-function buildDriftInjectionText(report, maxChars) {
-  if (maxChars <= 0) {
-    return "";
-  }
-  let text;
-  if (report.alignment === "ALIGNED" && report.drift_score < 0.1) {
-    text = `<drift_report>Phase ${report.phase}: ALIGNED, all requirements on track.</drift_report>`;
-  } else {
-    const keyFinding = report.first_deviation?.description ?? "no deviation recorded";
-    const score = report.drift_score ?? 0;
-    const correctionClause = report.corrections?.[0] ? `Correction: ${report.corrections[0]}.` : "";
-    text = `<drift_report>Phase ${report.phase}: ${report.alignment} (${score.toFixed(2)}) \u2014 ${keyFinding}. ${correctionClause}</drift_report>`;
-  }
-  return text.slice(0, maxChars);
-}
-export {
-  writeDriftReport,
-  runDeterministicDriftCheck,
-  readPriorDriftReports,
-  buildDriftInjectionText,
-  _internals
-};