opencode-swarm 7.62.1 → 7.64.0

package/dist/config/schema.d.ts

@@ -497,6 +497,7 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
     hive_max_entries: z.ZodDefault<z.ZodNumber>;
     auto_promote_days: z.ZodDefault<z.ZodNumber>;
     max_inject_count: z.ZodDefault<z.ZodNumber>;
+    delegate_max_inject_count: z.ZodDefault<z.ZodNumber>;
     inject_char_budget: z.ZodDefault<z.ZodNumber>;
     context_budget_threshold: z.ZodOptional<z.ZodNumber>;
     max_lesson_display_chars: z.ZodDefault<z.ZodNumber>;
@@ -520,6 +521,13 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
     default_max_phases: z.ZodDefault<z.ZodNumber>;
     todo_max_phases: z.ZodDefault<z.ZodNumber>;
     sweep_enabled: z.ZodDefault<z.ZodBoolean>;
+    retrieval: z.ZodOptional<z.ZodObject<{
+        mmr_lambda: z.ZodDefault<z.ZodNumber>;
+        cold_start_bonus: z.ZodDefault<z.ZodNumber>;
+        cold_start_max_age_phases: z.ZodDefault<z.ZodNumber>;
+        synonym_min_cooccurrence: z.ZodDefault<z.ZodNumber>;
+        synonym_map_max_pairs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type KnowledgeConfig = z.infer<typeof KnowledgeConfigSchema>;
 export declare const MemoryConfigSchema: z.ZodObject<{
@@ -954,6 +962,163 @@ export declare const TurboConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>], "strategy">;
 export type TurboConfig = z.infer<typeof TurboConfigSchema>;
+/** Where an external skill candidate was discovered. */
+export declare const ExternalSkillCandidateSourceTypeSchema: z.ZodEnum<{
+    github: "github";
+    url: "url";
+    collection: "collection";
+    manual_import: "manual_import";
+}>;
+export type ExternalSkillCandidateSourceType = z.infer<typeof ExternalSkillCandidateSourceTypeSchema>;
+/** Evaluation verdict for an external skill candidate. */
+export declare const ExternalSkillCandidateEvaluationVerdictSchema: z.ZodEnum<{
+    pending: "pending";
+    in_review: "in_review";
+    quarantined: "quarantined";
+    passed: "passed";
+    rejected: "rejected";
+    promoted: "promoted";
+    revoked: "revoked";
+}>;
+export type ExternalSkillCandidateEvaluationVerdict = z.infer<typeof ExternalSkillCandidateEvaluationVerdictSchema>;
+/** A single discovery source that feeds candidates into the quarantine store. */
+export declare const DiscoverySourceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        github: "github";
+        url: "url";
+        collection: "collection";
+        manual_import: "manual_import";
+    }>;
+    location: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trust_level: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>>;
+}, z.core.$strip>;
+export type DiscoverySource = z.infer<typeof DiscoverySourceSchema>;
+/**
+ * A quarantined or evaluated external skill candidate awaiting promotion.
+ * Stored in `.swarm/external-skills/` with content-addressable naming.
+ */
+export declare const ExternalSkillCandidateSchema: z.ZodObject<{
+    id: z.ZodString;
+    source_url: z.ZodString;
+    source_type: z.ZodEnum<{
+        github: "github";
+        url: "url";
+        collection: "collection";
+        manual_import: "manual_import";
+    }>;
+    publisher: z.ZodString;
+    sha256: z.ZodString;
+    fetched_at: z.ZodString;
+    skill_name: z.ZodOptional<z.ZodString>;
+    skill_description: z.ZodOptional<z.ZodString>;
+    skill_body: z.ZodString;
+    risk_flags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    evaluation_verdict: z.ZodDefault<z.ZodEnum<{
+        pending: "pending";
+        in_review: "in_review";
+        quarantined: "quarantined";
+        passed: "passed";
+        rejected: "rejected";
+        promoted: "promoted";
+        revoked: "revoked";
+    }>>;
+    evaluation_history: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        verdict: z.ZodEnum<{
+            pending: "pending";
+            in_review: "in_review";
+            quarantined: "quarantined";
+            passed: "passed";
+            rejected: "rejected";
+            promoted: "promoted";
+            revoked: "revoked";
+        }>;
+        timestamp: z.ZodString;
+        actor: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        candidate_id: z.ZodOptional<z.ZodString>;
+        original_verdict: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            in_review: "in_review";
+            quarantined: "quarantined";
+            passed: "passed";
+            rejected: "rejected";
+            promoted: "promoted";
+            revoked: "revoked";
+        }>>;
+        gate_results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            gate: z.ZodString;
+            verdict: z.ZodString;
+        }, z.core.$strip>>>;
+        risk_assessment: z.ZodOptional<z.ZodObject<{
+            total_flags: z.ZodNumber;
+            findings: z.ZodArray<z.ZodObject<{
+                severity: z.ZodEnum<{
+                    error: "error";
+                    warning: "warning";
+                }>;
+                category: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        risk_flags_count: z.ZodOptional<z.ZodNumber>;
+        provenance_snapshot: z.ZodOptional<z.ZodObject<{
+            sha256: z.ZodString;
+            source_url: z.ZodString;
+            publisher: z.ZodString;
+            fetched_at: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        target_path: z.ZodOptional<z.ZodString>;
+        promoted_content_hash: z.ZodOptional<z.ZodString>;
+        original_evaluation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ExternalSkillCandidate = z.infer<typeof ExternalSkillCandidateSchema>;
+/** Top-level configuration block for the external skills subsystem. */
+export declare const ExternalSkillsConfigSchema: z.ZodObject<{
+    curation_enabled: z.ZodDefault<z.ZodBoolean>;
+    max_candidates: z.ZodDefault<z.ZodNumber>;
+    max_bytes_per_candidate: z.ZodDefault<z.ZodNumber>;
+    eviction_policy: z.ZodDefault<z.ZodEnum<{
+        fifo: "fifo";
+    }>>;
+    ttl_days: z.ZodDefault<z.ZodNumber>;
+    evaluation_enabled: z.ZodDefault<z.ZodBoolean>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            github: "github";
+            url: "url";
+            collection: "collection";
+            manual_import: "manual_import";
+        }>;
+        location: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        trust_level: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>>;
+    }, z.core.$strip>>>;
+    max_candidates_per_discovery: z.ZodDefault<z.ZodNumber>;
+    max_concurrent_fetches: z.ZodDefault<z.ZodNumber>;
+    fetch_timeout_ms: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ExternalSkillsConfig = z.infer<typeof ExternalSkillsConfigSchema>;
+/** Default external skills configuration (all subsystems disabled). */
+export declare const DEFAULT_EXTERNAL_SKILLS_CONFIG: ExternalSkillsConfig;
+/**
+ * Resolve the external_skills config section, merging user-provided values
+ * over defaults.  Returns the default (all-disabled) config when
+ * `external_skills` is absent or undefined, ensuring callers never need
+ * null checks.
+ *
+ * Invalid source configs produce warnings via the logger but do NOT block
+ * plugin load (AGENTS.md #1 — fail-open, bounded init).
+ */
+export declare function resolveExternalSkillsConfig(input: unknown): ExternalSkillsConfig;
 export declare const PluginConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
@@ -1264,6 +1429,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         hive_max_entries: z.ZodDefault<z.ZodNumber>;
         auto_promote_days: z.ZodDefault<z.ZodNumber>;
         max_inject_count: z.ZodDefault<z.ZodNumber>;
+        delegate_max_inject_count: z.ZodDefault<z.ZodNumber>;
         inject_char_budget: z.ZodDefault<z.ZodNumber>;
         context_budget_threshold: z.ZodOptional<z.ZodNumber>;
         max_lesson_display_chars: z.ZodDefault<z.ZodNumber>;
@@ -1287,6 +1453,13 @@ export declare const PluginConfigSchema: z.ZodObject<{
         default_max_phases: z.ZodDefault<z.ZodNumber>;
         todo_max_phases: z.ZodDefault<z.ZodNumber>;
         sweep_enabled: z.ZodDefault<z.ZodBoolean>;
+        retrieval: z.ZodOptional<z.ZodObject<{
+            mmr_lambda: z.ZodDefault<z.ZodNumber>;
+            cold_start_bonus: z.ZodDefault<z.ZodNumber>;
+            cold_start_max_age_phases: z.ZodDefault<z.ZodNumber>;
+            synonym_min_cooccurrence: z.ZodDefault<z.ZodNumber>;
+            synonym_map_max_pairs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     memory: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1607,6 +1780,34 @@ export declare const PluginConfigSchema: z.ZodObject<{
             every_minutes: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    external_skills: z.ZodOptional<z.ZodObject<{
+        curation_enabled: z.ZodDefault<z.ZodBoolean>;
+        max_candidates: z.ZodDefault<z.ZodNumber>;
+        max_bytes_per_candidate: z.ZodDefault<z.ZodNumber>;
+        eviction_policy: z.ZodDefault<z.ZodEnum<{
+            fifo: "fifo";
+        }>>;
+        ttl_days: z.ZodDefault<z.ZodNumber>;
+        evaluation_enabled: z.ZodDefault<z.ZodBoolean>;
+        sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                github: "github";
+                url: "url";
+                collection: "collection";
+                manual_import: "manual_import";
+            }>;
+            location: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            trust_level: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>>;
+        }, z.core.$strip>>>;
+        max_candidates_per_discovery: z.ZodDefault<z.ZodNumber>;
+        max_concurrent_fetches: z.ZodDefault<z.ZodNumber>;
+        fetch_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;
 export type { AgentName, PipelineAgentName, QAAgentName, } from './constants';

package/dist/hooks/delegate-ack-collector.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Delegate ack collection (Swarm Learning System, Change 1 / Task 1.5).
+ *
+ * A `tool.execute.after` hook on the `Task` tool. After a delegated subagent
+ * returns, this reconciles the directives that were shown to it (recovered by
+ * parsing the `<delegate_knowledge_directives>` block out of the delegation
+ * prompt) against the ack markers in the subagent's transcript:
+ *
+ *   - For every ack whose ID was actually shown, emit a receipt event of the
+ *     matching type (applied / ignored / violated / n_a). Acks for IDs that were
+ *     never shown are DROPPED (anti-spoofing).
+ *   - For every CRITICAL directive that was shown but never acknowledged, emit a
+ *     `violated` event with reason `unacknowledged` and append an audit line to
+ *     `.swarm/unacknowledged-criticals.jsonl`.
+ *
+ * Stateless by design: it re-parses the prompt rather than relying on
+ * cross-hook mutable state, so it is safe under parallel delegations. Fail-open:
+ * never throws, never blocks.
+ */
+export interface DelegateAckInput {
+    tool: unknown;
+    agent?: unknown;
+    sessionID?: unknown;
+    args?: unknown;
+}
+export interface DelegateAckOutput {
+    output?: unknown;
+}
+export interface CollectDelegateAcksResult {
+    emitted: Array<{
+        id: string;
+        type: string;
+    }>;
+    unacknowledgedCriticals: string[];
+}
+/**
+ * Core reconciliation used by both the runtime hook and tests. Returns a summary
+ * of what was emitted. Never throws.
+ */
+export declare function collectDelegateAcks(params: {
+    directory: string;
+    prompt: string;
+    transcript: string;
+    agent: string;
+    sessionId?: string;
+    taskId?: string;
+}): Promise<CollectDelegateAcksResult>;
+/**
+ * `tool.execute.after` adapter. Reconciles delegate acks for a completed Task.
+ */
+export declare function collectDelegateAcksAfter(directory: string, input: DelegateAckInput, output: DelegateAckOutput): Promise<void>;

package/dist/hooks/delegate-directive-injection.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Architect-side delegate directive injection (Swarm Learning System, Change 1 /
+ * Task 1.4).
+ *
+ * When the architect delegates via the `Task` tool, this `tool.execute.before`
+ * hook prepends the role-scoped `<delegate_knowledge_directives>` block to the
+ * subagent's prompt so the delegate sees the directives (and the ack contract)
+ * from its very first message. It mirrors the existing skill-injection pattern
+ * in src/index.ts, which already mutates `input.args.prompt`.
+ *
+ * This is ADVISORY (prompt enrichment): it must never throw or block a
+ * delegation. A retrieval failure simply leaves the prompt unchanged.
+ *
+ * NOTE on plan deviation: the implementation plan listed `src/agents/architect.ts`
+ * as the "delegation prompt builder". The architect is prompt-driven — real
+ * delegations are constructed by the model at runtime via the Task tool, so the
+ * code-accurate interception point is this hook, not the architect prompt
+ * template. The architect's own `<swarm_knowledge_directives>` injection is
+ * untouched.
+ */
+import type { KnowledgeConfig } from './knowledge-types.js';
+export interface DelegateInjectionInput {
+    tool: unknown;
+    agent?: unknown;
+    sessionID?: unknown;
+    args?: unknown;
+}
+/**
+ * Prepend the per-delegate directive block to a Task delegation's prompt.
+ * Returns the number of directives injected (0 when nothing was injected),
+ * primarily for test assertions. Never throws.
+ */
+export declare function injectDelegateDirectivesBefore(directory: string, input: DelegateInjectionInput, config: KnowledgeConfig): Promise<number>;

package/dist/hooks/knowledge-application.d.ts

@@ -8,15 +8,16 @@
 import type { KnowledgeApplicationResult } from './knowledge-types.js';
 export declare function resolveApplicationLogPath(directory: string): string;
 /**
- * Parse explicit knowledge-acknowledgment markers from architect text.
+ * Parse explicit knowledge-acknowledgment markers from architect/delegate text.
  * Recognised forms (case-insensitive, line-anchored or inline):
  *   KNOWLEDGE_APPLIED: <id>
  *   KNOWLEDGE_IGNORED: <id> reason=<reason>
  *   KNOWLEDGE_VIOLATED: <id> reason=<reason>
+ *   KNOWLEDGE_N_A: <id> reason=<reason>   (delegate contract, Change 1)
  */
 export interface ParsedAcknowledgment {
     id: string;
-    result: 'applied' | 'ignored' | 'violated';
+    result: 'applied' | 'ignored' | 'violated' | 'n_a';
     reason?: string;
 }
 export declare function parseAcknowledgments(text: string): ParsedAcknowledgment[];
@@ -38,7 +39,7 @@ export declare function recordKnowledgeShown(directory: string, ids: string[], c
 export declare function recordAcknowledgment(directory: string, ack: ParsedAcknowledgment, ctx: RecordContext): Promise<void>;
 /** Build the dedup key. Exported so test code and the runtime integration
  *  share the exact format. */
-export declare function buildAckDedupKey(sessionId: string, id: string, result: KnowledgeApplicationResult, now?: Date): string;
+export declare function buildAckDedupKey(sessionId: string, id: string, result: KnowledgeApplicationResult | 'n_a', now?: Date): string;
 /** Acknowledgment recording with dedup. Returns whether a record was actually
  *  written (false on dedup hit). dedupSet should be swarmState.knowledgeAckDedup
  *  in production; tests can pass a fresh Set. */

package/dist/hooks/knowledge-curator.d.ts

@@ -1,10 +1,68 @@
 /** Knowledge curator hook for opencode-swarm v6.17 two-tier knowledge system. */
-import type { KnowledgeConfig } from './knowledge-types.js';
+import type { CuratorLLMDelegate } from './curator.js';
+import type { ActionableDirectiveFields, KnowledgeConfig, SwarmKnowledgeEntry } from './knowledge-types.js';
+import { type InsightCandidate } from './micro-reflector.js';
+declare const seenRetroSections: Map<string, {
+    value: string;
+    timestamp: number;
+}>;
+/**
+ * Bound seenRetroSections to MAX_TRACKED_RETRO_SECTIONS entries, evicting the
+ * oldest-timestamp entries first. Called after every insert so the map can never
+ * exceed the cap regardless of how many distinct sessions appear within the
+ * 24-hour prune window.
+ */
+declare function capSeenRetroSections(): void;
+/** Record a seen-section hash and enforce the size cap in one step. */
+declare function recordSeenRetroSection(key: string, value: string, timestamp: number): void;
 /**
  * Check if the input is a write operation targeting an evidence file.
  * Exported for testing purposes only.
  */
 export declare function isWriteToEvidenceFile(input: unknown): boolean;
+/** Build the v3-schema enrichment prompt for a single prose lesson. */
+export declare function buildV3EnrichmentPrompt(lesson: string, category: string, tags: string[]): string;
+/**
+ * Parse + validate an enrichment response. Returns the sanitized fields when
+ * the output is shape-valid AND actionable, otherwise the list of missing
+ * requirements (for the RETRY follow-up). Untrusted-input hardened: only
+ * allowlisted fields are copied, then shape-validated by
+ * validateActionableFields (length caps, name patterns, injection checks).
+ */
+export declare function parseV3EnrichmentResponse(text: string): {
+    fields: ActionableDirectiveFields;
+} | {
+    missing: string[];
+};
+export interface EnrichmentQuotaOptions {
+    maxCalls: number;
+    window: 'utc' | 'local';
+}
+/**
+ * Enrich one prose lesson with v3 actionability fields via the curator LLM.
+ * One retry on schema failure (with a RETRY message naming the missing
+ * fields). Quota-gated per call via skill-improver-quota. Returns null when
+ * enrichment is unavailable (quota exhausted) or fails twice — the caller
+ * quarantines the entry. Never throws.
+ */
+export declare function enrichLessonToV3(params: {
+    directory: string;
+    llmDelegate: CuratorLLMDelegate;
+    lesson: string;
+    category: string;
+    tags: string[];
+    quota?: EnrichmentQuotaOptions;
+}): Promise<ActionableDirectiveFields | null>;
+/** Max insight candidates folded into the store per phase boundary. */
+export declare const MESO_INSIGHT_BATCH_LIMIT = 20;
+/**
+ * Atomically consume up to `batchLimit` insight candidates from
+ * `.swarm/insight-candidates.jsonl`, writing back the unconsumed tail under the
+ * same lock so concurrent micro-reflection appends are never lost. Fail-open.
+ */
+export declare function consumeInsightCandidates(directory: string, batchLimit?: number): Promise<InsightCandidate[]>;
+/** Build a SwarmKnowledgeEntry from an already-v3-actionable insight candidate. */
+export declare function insightCandidateToEntry(cand: InsightCandidate, projectName: string, phaseNumber: number, config: KnowledgeConfig): SwarmKnowledgeEntry;
 /**
  * Curate and store swarm knowledge entries from lessons.
  * @returns Promise resolving to an object with counts of stored, skipped, and rejected lessons.
@@ -13,10 +71,19 @@ export declare function curateAndStoreSwarm(lessons: string[], projectName: stri
     phase_number: number;
 }, directory: string, config: KnowledgeConfig, options?: {
     skipAutoPromotion?: boolean;
+    /**
+     * Change 4 (Task 4.2): LLM delegate used to enrich plain-prose lessons
+     * with v3 actionability fields before the Layer-5 gate. When absent,
+     * non-actionable lessons go straight to the unactionable queue.
+     */
+    llmDelegate?: CuratorLLMDelegate;
+    /** Quota knobs for enrichment calls (defaults: 10/day, utc window). */
+    enrichmentQuota?: EnrichmentQuotaOptions;
 }): Promise<{
     stored: number;
     skipped: number;
     rejected: number;
+    quarantined: number;
 }>;
 /**
  * Auto-promote swarm entries based on phase confirmations and age.
@@ -32,4 +99,9 @@ export declare const _internals: {
     curateAndStoreSwarm: typeof curateAndStoreSwarm;
     runAutoPromotion: typeof runAutoPromotion;
     createKnowledgeCuratorHook: typeof createKnowledgeCuratorHook;
+    seenRetroSections: typeof seenRetroSections;
+    recordSeenRetroSection: typeof recordSeenRetroSection;
+    capSeenRetroSections: typeof capSeenRetroSections;
+    MAX_TRACKED_RETRO_SECTIONS: number;
 };
+export {};

package/dist/hooks/knowledge-escalator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Repeat-mistake escalator (Swarm Learning System, Change 3 / Task 3.2).
+ *
+ * When the same directive is violated >= {@link ESCALATION_THRESHOLD} times
+ * within {@link ESCALATION_WINDOW_DAYS} days (across sessions), it is
+ * auto-promoted to `directive_priority:'critical'` + `enforcement_mode:'enforce'`,
+ * its `escalation_history` gets a `repeat_violation` record, and an `escalation`
+ * event is emitted. Idempotent: an entry already at critical/enforce is never
+ * re-escalated, even on subsequent violations.
+ *
+ * Persistence goes through `rewriteKnowledge` (never a raw JSONL write). Fail-open:
+ * any error leaves the entry untouched and returns `escalated:false`.
+ */
+import type { DirectivePriority } from './knowledge-types.js';
+export declare const ESCALATION_WINDOW_DAYS = 30;
+export declare const ESCALATION_THRESHOLD = 2;
+export interface EscalationResult {
+    escalated: boolean;
+    entryId: string;
+    from?: DirectivePriority;
+    to?: DirectivePriority;
+    violationsInWindow?: number;
+    /** True when the entry was already critical/enforce (no-op, idempotent). */
+    alreadyEscalated?: boolean;
+}
+/**
+ * Evaluate and (if warranted) apply a repeat-violation escalation to a single
+ * entry. Call AFTER the triggering `violated` event has been persisted.
+ */
+export declare function maybeEscalateOnViolation(directory: string, entryId: string, now?: Date): Promise<EscalationResult>;
+export interface RecentEscalation {
+    entry_id: string;
+    from: string;
+    to: string;
+    reason: string;
+    at: string;
+}
+export declare const ESCALATION_DISPLAY_WINDOW_DAYS = 7;
+/**
+ * Read escalation events from the last `windowDays` days, newest first. Used by
+ * the architect briefing and `/swarm status`. Fail-open: returns [] on error.
+ */
+export declare function readRecentEscalations(directory: string, windowDays?: number, now?: Date): Promise<RecentEscalation[]>;
+/**
+ * Render the architect-briefing "Recently Escalated" subsection. Returns null
+ * when there is nothing to show (no empty header).
+ */
+export declare function buildEscalationBriefing(escalations: RecentEscalation[], windowDays?: number): string | null;
+/** Run the escalator for several entry IDs (deduped). Never throws. */
+export declare function escalateViolatedEntries(directory: string, entryIds: string[], now?: Date): Promise<EscalationResult[]>;

package/dist/hooks/knowledge-events.d.ts

@@ -29,7 +29,11 @@ export declare const KNOWLEDGE_EVENT_SCHEMA_VERSION = 1;
  */
 export declare const MAX_EVENT_LOG_ENTRIES = 5000;
 /** Retrieval modes that surface knowledge to an agent. */
-export type RetrievalEventMode = 'manual' | 'auto_injection' | 'coder_context' | 'review_context' | 'curator';
+export type RetrievalEventMode = 'manual' | 'auto_injection' | 'coder_context' | 'review_context' | 'curator'
+/** Per-delegate directive injection (Change 1): a delegated subagent
+ *  (coder/reviewer/test_engineer/sme/docs/designer/critic/curator) was shown
+ *  the subset of directives scoped to its role + expected tools. */
+ | 'delegate_inject';
 /** A retrieval: a query returned a ranked set of knowledge entries. */
 export interface RetrievedEvent {
     type: 'retrieved';
@@ -52,7 +56,13 @@ export interface RetrievedEvent {
 }
 /** A receipt: an agent explicitly considered a specific knowledge entry. */
 export interface ReceiptEvent {
-    type: 'acknowledged' | 'applied' | 'ignored' | 'contradicted' | 'violated';
+    type: 'acknowledged' | 'applied' | 'ignored' | 'contradicted' | 'violated'
+    /** Delegate decided a shown directive did not apply to its task (Change 1).
+     *  Recorded for auditability; never penalizes the entry's outcome signal. */
+     | 'n_a'
+    /** Architect explicitly accepted an unresolved critical violation at
+     *  phase_complete (Change 2, Task 2.4). Audit-only; never affects rollups. */
+     | 'override';
     schema_version?: number;
     event_id: string;
     trace_id: string;
@@ -63,6 +73,19 @@ export interface ReceiptEvent {
     task_id?: string;
     agent: string;
     reason?: string;
+    /**
+     * Origin discriminator (Change 2). Distinguishes reviewer-issued verdicts
+     * (`'reviewer'`) from delegate self-acks (`'delegate'`) without changing the
+     * `type`, so existing counter rollups (which switch on `type`) stay intact.
+     * A reviewer VERIFIED maps to type:'applied' with source:'reviewer'.
+     */
+    source?: 'delegate' | 'reviewer' | string;
+    /** Result of executing a directive's verification_predicate (Change 2). */
+    predicate_check?: {
+        predicate: string;
+        result: 'pass' | 'fail' | 'error';
+        detail: string;
+    };
     evidence?: {
         files?: string[];
         commands?: string[];
@@ -96,7 +119,19 @@ export interface ArchivedEvent {
     evidence?: string;
     previous_status?: string;
 }
-export type KnowledgeEvent = RetrievedEvent | ReceiptEvent | OutcomeEvent | ArchivedEvent;
+/** An escalation: a directive was auto-promoted by the repeat-mistake escalator. */
+export interface EscalationEvent {
+    type: 'escalation';
+    schema_version?: number;
+    event_id: string;
+    timestamp: string;
+    entry_id: string;
+    from: string;
+    to: string;
+    reason: string;
+    enforcement_mode?: string;
+}
+export type KnowledgeEvent = RetrievedEvent | ReceiptEvent | OutcomeEvent | ArchivedEvent | EscalationEvent;
 export type KnowledgeEventType = KnowledgeEvent['type'];
 /**
  * Event shape accepted by {@link appendKnowledgeEvent} / {@link recordKnowledgeEvent}.
@@ -154,6 +189,9 @@ export interface CounterRollup {
     ignored_count: number;
     violated_count: number;
     contradicted_count: number;
+    /** Count of explicit not-applicable decisions (Change 1). Auditable, neutral:
+     *  never contributes to the outcome ranking signal. */
+    n_a_count: number;
     succeeded_after_shown_count: number;
     failed_after_shown_count: number;
     /**
@@ -164,7 +202,15 @@ export interface CounterRollup {
     partial_after_shown_count: number;
     last_applied_at?: string;
     last_acknowledged_at?: string;
+    /**
+     * The most recent violation timestamps for this entry (ISO 8601, newest
+     * first, capped at the last {@link MAX_VIOLATION_TIMESTAMPS}). Feeds the
+     * repeat-mistake escalator (Change 3).
+     */
+    violation_timestamps: string[];
 }
+/** Cap on retained per-entry violation timestamps. */
+export declare const MAX_VIOLATION_TIMESTAMPS = 10;
 /**
  * Recompute per-entry counters deterministically from the immutable event log,
  * optionally folding in legacy `knowledge-application.jsonl` records.
@@ -189,6 +235,20 @@ export interface CounterRollup {
  * @param legacyRecords Optional legacy application records (any order).
  */
 export declare function recomputeCounters(events: KnowledgeEvent[], legacyRecords?: KnowledgeApplicationRecord[]): Map<string, CounterRollup>;
+/**
+ * Count how many of the given violation timestamps fall within `windowDays` of
+ * `now` (inclusive). Pure helper — deterministic given its inputs. Malformed
+ * timestamps are ignored.
+ */
+export declare function countViolationsInWindow(timestamps: string[], windowDays: number, now?: Date): number;
+/**
+ * Async convenience: count an entry's violations within a day-window. Counts
+ * directly from the event log + legacy application records so the result is
+ * INDEPENDENT of the {@link MAX_VIOLATION_TIMESTAMPS} display cap (the rollup's
+ * `violation_timestamps` keeps only the newest 10 and would undercount an entry
+ * with more in-window violations). Fail-open: returns 0 on error.
+ */
+export declare function countEntryViolationsInWindow(directory: string, entryId: string, windowDays: number, now?: Date): Promise<number>;
 /**
  * Fail-open rollup reader for hot paths. Search and promotion use this instead
  * of stale persisted counters so `knowledge_receipt` feedback affects ranking