opencode-swarm 7.88.3 → 7.89.0

package/dist/knowledge/identity.d.ts

@@ -14,6 +14,15 @@ export interface ProjectIdentity {
  * Path: {platform-config-dir}/projects/{projectHash}/identity.json
  */
 export declare function resolveIdentityPath(projectHash: string): string;
+/**
+ * Derive a deterministic project hash from a directory.
+ * Uses git remote URL if available, otherwise falls back to absolute path.
+ *
+ * Worktrees of the same repository share a git remote, so they derive the same
+ * hash — which is what lets `/swarm link` (with no name) tie them to one shared
+ * knowledge store by default.
+ */
+export declare function deriveProjectHash(directory: string): string;
 /**
  * Read existing identity.json or return null if it doesn't exist.
  */

package/dist/memory/config.d.ts

@@ -26,12 +26,47 @@ export interface MemoryConfig {
         rejectDurableSecrets: boolean;
     };
     maintenance: {
+        /** @deprecated superseded by `maintenance.importance` (issue #1464); retained for back-compat. */
         lowUtilityMaxConfidence: number;
+        /** @deprecated superseded by `maintenance.importance` (issue #1464); retained for back-compat. */
         lowUtilityMinAgeDays: number;
         autoCompactEveryNRecalls?: number;
+        /** Importance-formula weights + low-utility threshold (DD-11). */
+        importance: ImportanceConfig;
     };
+    /** Reflection / consolidation pass (issue #1464, Phase 3). */
+    consolidation: ConsolidationConfig;
     hardDelete: boolean;
 }
+export interface ImportanceConfig {
+    wRecency: number;
+    wFrequency: number;
+    wFreshness: number;
+    wConfidence: number;
+    lambda: number;
+    mu: number;
+    n: number;
+    /** A memory is low-utility when importance < threshold. */
+    threshold: number;
+}
+export interface ConsolidationConfig {
+    /** Run episodic→semantic consolidation at phase_complete. Gated by `enabled` too. */
+    enabled: boolean;
+    /** Max LLM-distilled clusters processed per pass (cost control). */
+    maxClustersPerPass: number;
+    /** Jaccard token-overlap threshold for lexical clustering. */
+    jaccardThreshold: number;
+    /** Distilled facts below this confidence are filed as proposals, not auto-applied. */
+    autoApplyMinConfidence: number;
+    /**
+     * Kind-specific decay half-lives in days. A value of 0 means "never auto-expire"
+     * (the issue's "365+ days, no decay unless superseded" durable kinds).
+     */
+    decayHalfLifeDays: Record<MemoryKind, number>;
+}
+export declare const DEFAULT_DECAY_HALF_LIFE_DAYS: Record<MemoryKind, number>;
+export declare const DEFAULT_IMPORTANCE_CONFIG: ImportanceConfig;
+export declare const DEFAULT_CONSOLIDATION_CONFIG: ConsolidationConfig;
 export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
 export declare const DURABLE_MEMORY_KINDS: ReadonlySet<MemoryKind>;
 export declare const EVIDENCE_REQUIRED_KINDS: ReadonlySet<MemoryKind>;

package/dist/memory/consolidation-log.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Durable, append-only record of a completed consolidation pass. Persisted to
+ * `.swarm/memory/consolidation-log.jsonl` (invariant #4: runtime state stays
+ * under `.swarm/`). Serves two purposes:
+ *  - idempotency: a pass for a `phaseNumber` already present here is a no-op;
+ *  - observability: the `/swarm memory consolidation-log` CLI reads it.
+ */
+export interface ConsolidationLogRecord {
+    phaseNumber: number;
+    /** Session/run that produced this pass, for multi-session observability.
+     * Idempotency remains keyed on phaseNumber (the memory store is per
+     * directory), so this is informational only. */
+    runId?: string;
+    startedAt: string;
+    completedAt: string;
+    clusterCount: number;
+    clustersDeferred: number;
+    decisionsEmitted: number;
+    added: number;
+    superseded: number;
+    contradictionsDetected: number;
+    deduped: number;
+    proposed: number;
+    memoriesDecayed: number;
+    errored: number;
+    processedProposalIds: string[];
+}
+export declare function readConsolidationLog(directory: string): Promise<ConsolidationLogRecord[]>;
+export declare function appendConsolidationLog(directory: string, record: ConsolidationLogRecord): Promise<void>;

package/dist/memory/consolidation.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { type MemoryConfig } from './config';
+import type { ConsolidationLogRecord } from './consolidation-log';
+import type { ProposeMemoryInput } from './gateway';
+import type { MemoryRunLogEvent } from './run-log';
+import type { AppliedMemoryChange, CuratorMemoryDecision, MemoryListFilter, MemoryProposal, MemoryRecord } from './types';
+/** Agent role stamped on consolidation-emitted proposals (used to exclude them
+ * from the engine's own episodic input — see reviewer finding #3). The
+ * fire-and-forget wrapper sets this as the gateway context's agentRole. */
+export declare const CONSOLIDATION_AGENT_ROLE = "curator_consolidation";
+/** Narrow gateway surface the engine depends on (MemoryGateway satisfies it). */
+export interface ConsolidationGateway {
+    isEnabled(): boolean;
+    listProposals(filter?: {
+        status?: MemoryProposal['status'];
+        limit?: number;
+    }): Promise<MemoryProposal[]>;
+    listMemories(filter?: MemoryListFilter): Promise<MemoryRecord[]>;
+    propose(input: ProposeMemoryInput): Promise<MemoryProposal>;
+    applyCuratorDecision(decision: CuratorMemoryDecision): Promise<AppliedMemoryChange>;
+    upsertCurated(record: MemoryRecord): Promise<MemoryRecord>;
+}
+export type DistillLLMDelegate = (systemPrompt: string, userInput: string, signal?: AbortSignal) => Promise<string>;
+export interface ConsolidationDeps {
+    gateway: ConsolidationGateway;
+    llmDelegate?: DistillLLMDelegate;
+    now: () => Date;
+    logEvent: (event: MemoryRunLogEvent) => Promise<void>;
+    readLog: () => Promise<ConsolidationLogRecord[]>;
+    appendLog: (record: ConsolidationLogRecord) => Promise<void>;
+    signal?: AbortSignal;
+}
+export interface ConsolidationInput {
+    directory: string;
+    phaseNumber: number;
+    runId?: string;
+    config: MemoryConfig;
+}
+export interface ConsolidationResult {
+    skipped: boolean;
+    skipReason?: 'disabled' | 'already_consolidated' | 'no_llm_delegate_decay_only' | 'aborted';
+    phaseNumber: number;
+    clusterCount: number;
+    clustersDeferred: number;
+    decisionsEmitted: number;
+    added: number;
+    superseded: number;
+    contradictionsDetected: number;
+    deduped: number;
+    proposed: number;
+    memoriesDecayed: number;
+    errored: number;
+}
+declare const DistilledFactSchema: z.ZodObject<{
+    text: z.ZodString;
+    kind: z.ZodEnum<{
+        evidence: "evidence";
+        user_preference: "user_preference";
+        project_fact: "project_fact";
+        architecture_decision: "architecture_decision";
+        repo_convention: "repo_convention";
+        api_finding: "api_finding";
+        code_pattern: "code_pattern";
+        test_pattern: "test_pattern";
+        failure_pattern: "failure_pattern";
+        security_note: "security_note";
+        todo: "todo";
+        scratch: "scratch";
+    }>;
+    confidence: z.ZodNumber;
+    contradictsMemoryId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DistilledFact = z.infer<typeof DistilledFactSchema>;
+/**
+ * Parse the curator LLM's distillation output. Tolerant of ```json fences and
+ * surrounding prose. Returns [] on any parse/validation failure (caller counts
+ * the cluster as skipped rather than aborting the pass).
+ */
+export declare function parseDistillationOutput(raw: string): DistilledFact[];
+export type DecisionPlan = {
+    type: 'add';
+    fact: DistilledFact;
+} | {
+    type: 'supersede';
+    fact: DistilledFact;
+    oldMemoryId: string;
+} | {
+    type: 'proposal';
+    fact: DistilledFact;
+    reason: string;
+} | {
+    type: 'dedup';
+    fact: DistilledFact;
+    duplicateOf: string;
+} | {
+    type: 'skip';
+    fact: DistilledFact;
+    reason: string;
+};
+/**
+ * Pure decision derivation for a single distilled fact against existing items.
+ * Encapsulates the auto-apply eligibility rules so they are unit-testable
+ * without a gateway:
+ *  - sentinel-bearing text is skipped (defense in depth; the write guard also
+ *    rejects it);
+ *  - `scratch` is never promoted to semantic memory;
+ *  - only DURABLE_MEMORY_KINDS, ≤500-char, ≥autoApplyMinConfidence facts are
+ *    auto-applied; everything else is filed as a pending proposal;
+ *  - a contradiction (explicit `contradictsMemoryId` that resolves to an
+ *    existing active memory) becomes a supersede;
+ *  - a near-duplicate (Jaccard ≥ threshold) becomes a no-op dedup.
+ */
+export declare function deriveDecision(fact: DistilledFact, existing: MemoryRecord[], options: {
+    autoApplyMinConfidence: number;
+    jaccardThreshold: number;
+}): DecisionPlan;
+/**
+ * Run one episodic→semantic consolidation pass for a completed phase.
+ * Idempotent per `phaseNumber` (a completed log record short-circuits a rerun).
+ * All IO is injected via {@link ConsolidationDeps} so the orchestration is
+ * deterministically testable with a fake gateway and fake LLM delegate.
+ */
+export declare function runConsolidationPass(input: ConsolidationInput, deps: ConsolidationDeps): Promise<ConsolidationResult>;
+export {};

package/dist/memory/decay.d.ts

@@ -0,0 +1,24 @@
+import type { MemoryKind, MemoryRecord } from './types';
+/**
+ * Compute the kind-specific decay expiry for a memory (issue #1464).
+ *
+ * Returns the new `expiresAt` ISO string to apply, or `undefined` when no
+ * change should be made. Rules:
+ *  - `scratch` is never re-decayed here — it already receives a ≤7-day expiry
+ *    at creation time and is bounded by `validateMemoryRecordRules`.
+ *  - A half-life of `0` means "never auto-expire" (the durable 365+ kinds).
+ *  - Decay sets `expiresAt = createdAt + halfLifeDays`, but never SHORTENS an
+ *    existing earlier expiry (a memory already set to expire sooner keeps that
+ *    sooner expiry).
+ *
+ * Pure and deterministic: callers pass the existing record and apply the
+ * returned expiry by patching only `expiresAt` (preserving id/hash/timestamps).
+ */
+export declare function computeDecayExpiry(memory: Pick<MemoryRecord, 'kind' | 'createdAt' | 'expiresAt'>, halfLifeDays: Record<MemoryKind, number>, _now?: Date): string | undefined;
+/**
+ * Check whether a record's natural half-life date is in the past (i.e., the record
+ * is older than its decay horizon). Used to guard against upgrade-time auto-expiry
+ * when migrating from pre-decay code: a record written under a previous config
+ * without decay should not be silently expired on the first consolidation pass.
+ */
+export declare function isPastDecayHorizon(memory: Pick<MemoryRecord, 'kind' | 'createdAt'>, halfLifeDays: Record<MemoryKind, number>, now?: Date): boolean;

package/dist/memory/gateway.d.ts

@@ -1,6 +1,6 @@
 import { type MemoryConfig } from './config';
-import type { MemoryProposalStore, MemoryProvider } from './provider';
-import type { AppliedMemoryChange, CuratorMemoryDecision, MemoryContext, MemoryKind, MemoryProposal, MemoryRecord, MemoryScopeRef, MemorySource, RecallBundle, RecallMode } from './types';
+import type { MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent, MemoryRecallUsageFilter } from './provider';
+import type { AppliedMemoryChange, CuratorMemoryDecision, MemoryContext, MemoryKind, MemoryListFilter, MemoryProposal, MemoryRecord, MemoryScopeRef, MemorySource, RecallBundle, RecallMode } from './types';
 export interface MemoryGatewayOptions {
     config?: Partial<MemoryConfig>;
     provider?: MemoryProvider & Partial<MemoryProposalStore>;
@@ -39,6 +39,18 @@ export declare class MemoryGateway {
     deriveAllowedScopes(): MemoryScopeRef[];
     recall(input: RecallMemoryInput): Promise<RecallBundle>;
     propose(input: ProposeMemoryInput): Promise<MemoryProposal>;
+    /**
+     * Read-only passthroughs used by the consolidation engine. They assert the
+     * feature is enabled and that the underlying provider supports the
+     * capability (mirroring the `createProposal` guard), so the engine can
+     * depend on a stable gateway surface rather than the `Partial` provider.
+     */
+    listMemories(filter?: MemoryListFilter): Promise<MemoryRecord[]>;
+    listProposals(filter?: {
+        status?: MemoryProposal['status'];
+        limit?: number;
+    }): Promise<MemoryProposal[]>;
+    listRecallUsage(filter?: MemoryRecallUsageFilter): Promise<MemoryRecallUsageEvent[]>;
     upsertCurated(record: MemoryRecord): Promise<MemoryRecord>;
     applyCuratorDecision(decision: CuratorMemoryDecision): Promise<AppliedMemoryChange>;
     createRecord(input: {

package/dist/memory/maintenance.d.ts

@@ -1,5 +1,19 @@
 import type { MemoryProposalStore, MemoryProvider } from './provider';
+import { type ImportanceWeights } from './scoring';
 import type { MemoryProposal, MemoryRecord } from './types';
+/**
+ * Default importance-formula weights (issue #1464). Match the zod and runtime
+ * config defaults; used when the maintenance report is built without explicit
+ * importance options (e.g. legacy callers).
+ */
+export declare const DEFAULT_IMPORTANCE_WEIGHTS: ImportanceWeights;
+/**
+ * A never-recalled memory's importance is driven by freshness+confidence
+ * (recency/frequency terms are 0). 0.2 keeps high-confidence durable facts
+ * above the line regardless of age (the DD-11 fix) while still flagging
+ * low-confidence and very stale never-recalled memories. Pinned by tests.
+ */
+export declare const DEFAULT_IMPORTANCE_THRESHOLD = 0.2;
 export interface MemoryRecallUsageByMemory {
     memoryId: string;
     count: number;
@@ -38,6 +52,10 @@ export interface MemoryMaintenanceReportOptions {
     limit?: number;
     lowUtilityMaxConfidence?: number;
     lowUtilityMinAgeDays?: number;
+    /** Importance-formula weights (DD-11). Defaults to DEFAULT_IMPORTANCE_WEIGHTS. */
+    importanceWeights?: ImportanceWeights;
+    /** A memory is low-utility when importance < threshold. Defaults to DEFAULT_IMPORTANCE_THRESHOLD. */
+    importanceThreshold?: number;
 }
 type ObservableProvider = MemoryProvider & Partial<MemoryProposalStore> & {
     listRecallUsage?: MemoryProvider['listRecallUsage'];

package/dist/memory/run-log.d.ts

@@ -1,4 +1,4 @@
-export type MemoryRunLogEventName = 'recall_requested' | 'recall_returned' | 'prompt_injection_skipped' | 'prompt_injected' | 'proposal_created' | 'proposal_rejected_by_validation' | 'curator_decision_applied' | 'curator_decision_rejected_by_validation';
+export type MemoryRunLogEventName = 'recall_requested' | 'recall_returned' | 'prompt_injection_skipped' | 'prompt_injected' | 'proposal_created' | 'proposal_rejected_by_validation' | 'curator_decision_applied' | 'curator_decision_rejected_by_validation' | 'consolidation_started' | 'cluster_count' | 'decisions_emitted' | 'contradictions_detected' | 'memories_decayed' | 'consolidation_completed';
 export interface MemoryRunLogEvent {
     event: MemoryRunLogEventName;
     runId: string;
@@ -11,6 +11,13 @@ export interface MemoryRunLogEvent {
     proposalId?: string;
     rejectionReason?: string;
     timestamp?: string;
+    /** Consolidation pass identifier (phase boundary that triggered the pass). */
+    phaseNumber?: number;
+    /** Consolidation metrics (issue #1464). */
+    clusterCount?: number;
+    decisionsEmitted?: number;
+    contradictionsDetected?: number;
+    memoriesDecayed?: number;
     metadata?: Record<string, unknown>;
 }
 export declare function appendMemoryRunLog(directory: string, runId: string | undefined, event: MemoryRunLogEvent): Promise<void>;

package/dist/memory/schema.d.ts

@@ -27,7 +27,6 @@ export declare const MemoryScopeRefSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const MemoryKindSchema: z.ZodEnum<{
     evidence: "evidence";
-    todo: "todo";
     user_preference: "user_preference";
     project_fact: "project_fact";
     architecture_decision: "architecture_decision";
@@ -37,6 +36,7 @@ export declare const MemoryKindSchema: z.ZodEnum<{
     test_pattern: "test_pattern";
     failure_pattern: "failure_pattern";
     security_note: "security_note";
+    todo: "todo";
     scratch: "scratch";
 }>;
 export declare const MemorySourceSchema: z.ZodObject<{
@@ -78,7 +78,6 @@ export declare const MemoryRecordSchema: z.ZodObject<{
     }, z.core.$strict>;
     kind: z.ZodEnum<{
         evidence: "evidence";
-        todo: "todo";
         user_preference: "user_preference";
         project_fact: "project_fact";
         architecture_decision: "architecture_decision";
@@ -88,6 +87,7 @@ export declare const MemoryRecordSchema: z.ZodObject<{
         test_pattern: "test_pattern";
         failure_pattern: "failure_pattern";
         security_note: "security_note";
+        todo: "todo";
         scratch: "scratch";
     }>;
     text: z.ZodString;
@@ -156,7 +156,6 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         }, z.core.$strict>;
         kind: z.ZodEnum<{
             evidence: "evidence";
-            todo: "todo";
             user_preference: "user_preference";
             project_fact: "project_fact";
             architecture_decision: "architecture_decision";
@@ -166,6 +165,7 @@ export declare const MemoryProposalSchema: z.ZodObject<{
             test_pattern: "test_pattern";
             failure_pattern: "failure_pattern";
             security_note: "security_note";
+            todo: "todo";
             scratch: "scratch";
         }>;
         text: z.ZodString;

package/dist/memory/scoring.d.ts

@@ -25,6 +25,51 @@ export declare const SCORING_WEIGHTS: {
     readonly roleBoost: 0.05;
     readonly confidence: 0.08;
 };
+export declare function tokenize(text: string): Set<string>;
+/**
+ * True Jaccard similarity |A∩B| / |A∪B| over two token sets. Distinct from the
+ * recall-scoring `overlap` helper (which is a precision-like |A∩B|/max(|A|,|B|)).
+ * Consolidation clustering uses Jaccard per the issue spec (threshold 0.30).
+ */
+export declare function jaccard(a: Set<string>, b: Set<string>): number;
+/**
+ * Single-pass greedy lexical clustering by Jaccard token overlap. Each item is
+ * compared against the representative (first member) of each existing cluster;
+ * it joins the first cluster whose representative meets `threshold`, else seeds
+ * a new cluster. Deterministic for a given input order. Sufficient for v1
+ * (embedding-based clustering is Phase 4, out of scope).
+ */
+export declare function clusterByJaccard<T>(items: T[], getText: (item: T) => string, threshold: number): T[][];
+/**
+ * Continuous importance score in [0, sum-of-weights]. Replaces the boolean
+ * `isLowUtility` heuristic (DD-11). Implements the issue formula:
+ *
+ *   importance = w_recency  · exp(-λ · days_since_last_recall)
+ *              + w_frequency · log1p(retrieval_count) / log1p(N)
+ *              + w_freshness · exp(-μ · days_since_created)
+ *              + w_confidence · confidence
+ *
+ * A never-recalled memory contributes 0 to the recency and frequency terms
+ * (days_since_last_recall is null, retrieval_count is 0), so for never-recalled
+ * items importance is driven by freshness and confidence — which is exactly why
+ * a high-confidence, never-recalled, aged memory is no longer mislabeled
+ * low-utility under the old OR condition.
+ */
+export interface ImportanceWeights {
+    wRecency: number;
+    wFrequency: number;
+    wFreshness: number;
+    wConfidence: number;
+    lambda: number;
+    mu: number;
+    n: number;
+}
+export declare function importanceScore(input: {
+    confidence: number;
+    retrievalCount: number;
+    daysSinceLastRecall: number | null;
+    daysSinceCreated: number;
+}, weights: ImportanceWeights): number;
 export declare function sameScope(a: MemoryScopeRef, b: MemoryScopeRef): boolean;
 export declare function scopeAllowed(recordScope: MemoryScopeRef, allowedScopes: MemoryScopeRef[]): boolean;
 export declare function scoreMemoryRecord(record: MemoryRecord, request: RecallRequest): RecallResultItem | null;

package/dist/memory/sentinel.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Single source of truth for the recall-injection sentinel header.
+ *
+ * DEPENDENCY-FREE leaf module. The injector emits this header to mark an
+ * injected "## Retrieved Swarm Memory" block, and `messagesContainRecall`
+ * uses it to avoid double-injection. Because that check trusts the substring,
+ * stored memory text must never be allowed to contain it (DD-14): a memory
+ * whose text embeds the sentinel, once injected, would make a later injection
+ * believe recall already happened and silently skip it.
+ *
+ * Both the emitter (`prompt-block.ts`) and the write-time guard
+ * (`schema.ts:validateMemoryRecordRules`) import from here so the header and
+ * the guard can never drift apart.
+ */
+export declare const MEMORY_RECALL_SENTINEL = "## Retrieved Swarm Memory";

package/dist/services/memory-consolidation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Memory consolidation trigger (issue #1464, Phase 3).
+ *
+ * Thin, fail-open wrapper that runs the episodic→semantic consolidation engine
+ * at a phase boundary. Mirrors `runSkillConsolidationFireAndForget`: it is
+ * launched off the phase_complete success path, holds a per-directory in-flight
+ * guard, and never throws into the caller.
+ *
+ * Cancellation is cooperative: a deadline aborts an AbortController whose signal
+ * the engine checks before each write, and the wrapper always AWAITS the pass to
+ * settle before disposing the gateway and releasing the in-flight guard. This
+ * avoids orphaning the pass (using the gateway after dispose / racing a second
+ * pass on the same store) that a bare Promise.race timeout would cause.
+ */
+import type { MemoryConfig } from '../memory/config.js';
+import { type ConsolidationResult } from '../memory/consolidation.js';
+export interface MemoryConsolidationRequest {
+    directory: string;
+    config: MemoryConfig;
+    phase: number;
+    sessionId?: string;
+}
+export interface MemoryConsolidationOutcome {
+    started: boolean;
+    reason?: string;
+    result?: ConsolidationResult;
+}
+export declare function runMemoryConsolidation(req: MemoryConsolidationRequest): Promise<MemoryConsolidationOutcome>;
+export declare function runMemoryConsolidationFireAndForget(req: MemoryConsolidationRequest, onComplete?: (outcome: MemoryConsolidationOutcome) => void, onError?: (error: unknown) => void): void;
+export declare const _internals: {
+    runningByDirectory: Map<string, Promise<MemoryConsolidationOutcome>>;
+};

package/dist/services/skill-generator.d.ts

@@ -80,6 +80,7 @@ export interface GenerateResult {
         path: string;
         mode: GenerateMode;
         sourceKnowledgeIds: string[];
+        missingSourceKnowledgeIds?: string[];
         preserved: boolean;
         evaluation?: SkillEvaluationResult;
     }>;
@@ -95,8 +96,14 @@ export declare function generateSkills(req: GenerateRequest): Promise<GenerateRe
  * `generated_skill_path` metadata. Refactored in Phase G′ to take
  * `(directory, slug, ids)` so it can be called both from direct active-mode
  * generation AND from `activateProposal` after parsing the draft frontmatter.
+ *
+ * Returns the IDs that were successfully stamped and the IDs that were not
+ * found in swarm/hive knowledge (so callers can surface staleness).
  */
-declare function stampSourceEntries(directory: string, slug: string, ids: string[]): Promise<void>;
+declare function stampSourceEntries(directory: string, slug: string, ids: string[]): Promise<{
+    stamped: string[];
+    missing: string[];
+}>;
 /**
  * Bounded YAML frontmatter parser for generated drafts. Recognises the exact
  * shape we emit in renderSkillMarkdown — no full YAML lib required.

package/dist/session/worktree-link-suggestion.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Worktree link suggestion (auto-detect + manual confirm).
+ *
+ * When a session starts in a repository that has more than one git worktree and
+ * this worktree is NOT yet linked to a shared knowledge store, emit a one-time,
+ * non-blocking suggestion to run `/swarm link`. Detection is advisory only —
+ * sharing is never enabled automatically; the user confirms with `/swarm link`.
+ *
+ * Safety (AGENTS.md Invariants 1, 3, 8):
+ * - Fully fail-open: any error is swallowed; never throws.
+ * - Bounded subprocess: array-form `git`, explicit `-C <dir>`, timeout, no shell.
+ * - Off the init critical path: callers invoke this fire-and-forget (not awaited).
+ * - Suggested-once per session, tracked in a FIFO-bounded module map.
+ */
+/** Count worktrees via `git worktree list --porcelain`. Returns 0 on any failure. */
+declare function countWorktrees(directory: string): Promise<number>;
+/**
+ * Best-effort, once-per-session suggestion to link this worktree. Never throws.
+ * Intended to be called fire-and-forget (not awaited) from the session-start path.
+ */
+export declare function maybeSuggestWorktreeLink(directory: string, sessionId: string): Promise<void>;
+export declare const _internals: {
+    maybeSuggestWorktreeLink: typeof maybeSuggestWorktreeLink;
+    countWorktrees: typeof countWorktrees;
+    resetSuggested: () => void;
+};
+export {};

package/dist/state.d.ts

@@ -316,6 +316,7 @@ export declare const swarmState: {
     curatorInitAgentNames: string[];
     curatorPhaseAgentNames: string[];
     curatorPostmortemAgentNames: string[];
+    curatorConsolidationAgentNames: string[];
     /** All registered skill_improver / spec_writer agent names across swarms,
      * mirroring curatorInitAgentNames so the LLM delegate factory can resolve
      * the correct prefixed agent under multi-swarm configs. */
@@ -369,11 +370,12 @@ export declare function resetSwarmState(): void;
  * The preserved fields are:
  * - opencodeClient (SDK client for curator/full-auto delegation)
  * - fullAutoEnabledInConfig (config flag read at init)
- * - curatorInitAgentNames, curatorPhaseAgentNames, curatorPostmortemAgentNames (curator registry)
+ * - curatorInitAgentNames, curatorPhaseAgentNames, curatorPostmortemAgentNames,
+ *   curatorConsolidationAgentNames (curator registry)
  * - skillImproverAgentNames, specWriterAgentNames (skill/spec registry)
  * - generatedAgentNames (full-auto delegation guard registry)
  *
- * Implementation: save all 8 to locals, call resetSwarmState(), restore all 8.
+ * Implementation: save all to locals, call resetSwarmState(), restore all.
  * Synchronous (matches resetSwarmState contract). Errors from resetSwarmState
  * propagate to caller (no try/catch wrapper).
  */

package/package.json

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