opencode-swarm 7.0.0-beta.1 → 7.0.0

package/dist/hooks/guardrails.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Guardrails Hook Module
+ *
+ * Circuit breaker for runaway LLM agents. Monitors tool usage via OpenCode Plugin API hooks
+ * and implements two-layer protection:
+ * - Layer 1 (Soft Warning @ warning_threshold): Sets warning flag for messagesTransform to inject warning
+ * - Layer 2 (Hard Block @ 100%): Throws error in toolBefore to block further calls, injects STOP message
+ */
+import * as path from 'node:path';
+import { type AuthorityConfig, type GuardrailsConfig } from '../config/schema';
+import { type FileZone } from '../context/zone-classifier';
+/**
+ * Retrieves stored input args for a given callID.
+ * Used by other hooks (e.g., delegation-gate) to access tool input args.
+ * @param callID The callID to look up
+ * @returns The stored args or undefined if not found
+ */
+export declare function getStoredInputArgs(callID: string): unknown | undefined;
+/**
+ * Stores input args for a given callID.
+ * Used by guardrails toolBefore hook; may be used by other hooks if needed.
+ * @param callID The callID to store args under
+ * @param args The tool input args to store
+ */
+export declare function setStoredInputArgs(callID: string, args: unknown): void;
+/**
+ * Deletes stored input args for a given callID (cleanup after retrieval).
+ * @param callID The callID to delete
+ */
+export declare function deleteStoredInputArgs(callID: string): void;
+/**
+ * Redacts sensitive values from a shell command string before audit logging.
+ * Covers env-var assignments, CLI flags, Bearer/Basic auth, and -H header flags.
+ * Conservative: only redacts patterns with well-known secret-bearing names.
+ * Export allows unit testing without spinning up a full hooks factory.
+ */
+export declare function redactShellCommand(cmd: string): string;
+/**
+ * Creates guardrails hooks for circuit breaker protection
+ * @param directory Working directory from plugin init context (required)
+ * @param directoryOrConfig Guardrails configuration object (when passed as second arg, replaces legacy config param)
+ * @param config Guardrails configuration (optional)
+ * @returns Tool before/after hooks and messages transform hook
+ */
+export declare function createGuardrailsHooks(directory: string, directoryOrConfig?: string | GuardrailsConfig, config?: GuardrailsConfig, authorityConfig?: AuthorityConfig): {
+    toolBefore: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    toolAfter: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args?: Record<string, unknown>;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    messagesTransform: (input: Record<string, never>, output: {
+        messages?: Array<{
+            info: {
+                role: string;
+                agent?: string;
+                sessionID?: string;
+            };
+            parts: Array<{
+                type: string;
+                text?: string;
+                [key: string]: unknown;
+            }>;
+        }>;
+    }) => Promise<void>;
+};
+/**
+ * Hashes tool arguments for repetition detection
+ * @param args Tool arguments to hash
+ * @returns Numeric hash (0 if hashing fails)
+ */
+export declare function hashArgs(args: unknown): number;
+/** A record of an agent attesting to (resolving/suppressing/deferring) a finding. */
+export interface AttestationRecord {
+    findingId: string;
+    agent: string;
+    attestation: string;
+    action: 'resolve' | 'suppress' | 'defer';
+    timestamp: string;
+}
+/**
+ * Validates that an attestation string meets the minimum length requirement.
+ */
+export declare function validateAttestation(attestation: string, _findingId: string, _agent: string, _action: 'resolve' | 'suppress' | 'defer'): {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+};
+/**
+ * Appends an attestation record to `.swarm/evidence/attestations.jsonl`.
+ */
+export declare function recordAttestation(dir: string, record: AttestationRecord): Promise<void>;
+/**
+ * Validates an attestation and, on success, records it; on failure, logs a rejection event.
+ */
+export declare function validateAndRecordAttestation(dir: string, findingId: string, agent: string, attestation: string, action: 'resolve' | 'suppress' | 'defer'): Promise<{
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+}>;
+/**
+ * Clears all guardrails caches.
+ * Use this for test isolation or when guardrails config reloads at runtime.
+ */
+export declare function clearGuardrailsCaches(): void;
+type AgentRule = {
+    readOnly?: boolean;
+    blockedExact?: string[];
+    allowedExact?: string[];
+    blockedPrefix?: string[];
+    allowedPrefix?: string[];
+    blockedZones?: FileZone[];
+    blockedGlobs?: string[];
+    allowedGlobs?: string[];
+};
+export declare const DEFAULT_AGENT_AUTHORITY_RULES: Record<string, AgentRule>;
+/**
+ * Checks whether a write target path (or any ancestor strictly inside cwd)
+ * is a symlink. Writing through a symlink can redirect the write to a
+ * location outside the working directory, bypassing scope containment.
+ *
+ * The walk stops at cwd — cwd itself is NOT lstat'd. A user's chosen
+ * working directory may legitimately be reached via a symlink (e.g.,
+ * macOS's /tmp → /private/tmp), and that symlink does not constitute a
+ * redirect *within* the workspace. Only attacker-plantable symlinks
+ * BELOW cwd are relevant to this guard.
+ *
+ * ENOENT on any node in the chain is allowed — the file/dir doesn't exist yet.
+ * Any other lstat error (EPERM, EACCES, ENAMETOOLONG, …) fails closed:
+ * an unverifiable ancestor must not be written through, even if the OS
+ * would eventually reject the write. Defense-in-depth over optimism.
+ *
+ * @returns A block reason string if a symlink is detected, null if all clear.
+ */
+export declare function checkWriteTargetForSymlink(targetPath: string, cwd: string): string | null;
+/**
+ * Returns true when `targetAbsolute` and `cwdAbsolute` resolve to different
+ * filesystem roots. On POSIX this is always false (single root `/`); on
+ * Windows it is true when the two paths sit on different drive letters or
+ * different UNC roots — the symptom Codex flagged on PR #501, where
+ * `path.relative('C:\\repo', 'D:\\secret.txt')` returns the absolute
+ * `'D:\\secret.txt'` and slips past `startsWith('../')` containment.
+ *
+ * Exposed (and accepts an injectable `pathLib`) so the cross-drive guard
+ * is falsifiable on Linux CI without depending on a Windows runner: tests
+ * pass `path.win32` / `path.posix` directly.
+ */
+export declare function isOnDifferentFilesystemRoot(targetAbsolute: string, cwdAbsolute: string, pathLib?: Pick<typeof path, 'parse'>): boolean;
+/**
+ * Checks whether the given agent is authorised to write to the given file path.
+ */
+export declare function checkFileAuthority(agentName: string, filePath: string, cwd: string, authorityConfig?: AuthorityConfig, options?: {
+    declaredScope?: string[] | null;
+}): {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: string;
+    zone?: FileZone;
+};
+export {};

package/dist/hooks/hive-promoter.d.ts

@@ -0,0 +1,40 @@
+/** Hive promoter hook for opencode-swarm v6.17 two-tier knowledge system. */
+import type { KnowledgeConfig, SwarmKnowledgeEntry } from './knowledge-types.js';
+/** Hive promotion summary for curator state */
+export interface HivePromotionSummary {
+    timestamp: string;
+    new_promotions: number;
+    encounters_incremented: number;
+    advancements: number;
+    total_hive_entries: number;
+}
+/**
+ * Main promotion logic: checks swarm entries and promotes eligible ones to hive.
+ * Also updates existing hive entries with new project confirmations.
+ * Returns a summary of the promotion activity for curator state.
+ *
+ * @note The 'hive-fast-track' tag is treated as privileged — it bypasses the
+ *   3-phase confirmation requirement. It should only be set by authorized tooling
+ *   (inferTags() never produces it automatically).
+ */
+export declare function checkHivePromotions(swarmEntries: SwarmKnowledgeEntry[], config: KnowledgeConfig): Promise<HivePromotionSummary>;
+/**
+ * Create a hook that promotes swarm entries to the hive.
+ * The hook fires unconditionally - the caller decides when to invoke it.
+ */
+export declare function createHivePromoterHook(directory: string, config: KnowledgeConfig): (input: unknown, output: unknown) => Promise<void>;
+/**
+ * Promote a lesson directly to the hive (manual promotion).
+ * @param directory - Project directory
+ * @param lesson - The lesson text to promote
+ * @param category - Optional category (defaults to 'process')
+ * @returns Confirmation message
+ */
+export declare function promoteToHive(directory: string, lesson: string, category?: string): Promise<string>;
+/**
+ * Promote a lesson from swarm knowledge to hive.
+ * @param directory - Project directory
+ * @param lessonId - The ID of the lesson to promote from swarm
+ * @returns Confirmation message
+ */
+export declare function promoteFromSwarm(directory: string, lessonId: string): Promise<string>;

package/dist/hooks/incremental-verify.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Incremental verification hook — runs a typecheck after each coder Task delegation.
+ * Fires in tool.execute.after when input.tool === 'Task' and the delegated agent was 'coder'.
+ * Advisory only — never blocks. 30-second hard timeout. Uses directory from context.
+ */
+import type { IncrementalVerifyConfig } from '../config/schema';
+export type { IncrementalVerifyConfig };
+export { detectTypecheckCommand };
+export interface IncrementalVerifyHook {
+    toolAfter: (input: {
+        tool: string;
+        sessionID: string;
+        args?: unknown;
+    }, output: {
+        output?: unknown;
+        args?: unknown;
+    }) => Promise<void>;
+}
+/** For test isolation — call in beforeEach/afterEach */
+export declare function resetAdvisoryDedup(): void;
+/**
+ * Detect the typecheck/build check command for the project.
+ * Returns { command, language } where command is null if no default checker exists,
+ * or null overall if no supported language is detected.
+ * Checks in order: TypeScript (package.json) → Go (go.mod) → Rust (Cargo.toml)
+ * → Python (pyproject.toml/requirements.txt/setup.py) → C# (*.csproj/*.sln)
+ * First match wins; package.json only short-circuits when TypeScript markers are present.
+ * Otherwise the function falls through to Go/Rust/Python/C# detection.
+ */
+declare function detectTypecheckCommand(projectDir: string): {
+    command: string[] | null;
+    language: string;
+} | null;
+export declare function createIncrementalVerifyHook(config: IncrementalVerifyConfig, projectDir: string, injectMessage: (sessionId: string, message: string) => void): IncrementalVerifyHook;

package/dist/hooks/incremental-verify.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,20 @@
+export { createAgentActivityHooks } from './agent-activity';
+export { createCompactionCustomizerHook } from './compaction-customizer';
+export { createContextBudgetHandler } from './context-budget';
+export { createCuratorLLMDelegate } from './curator-llm-factory';
+export { createDelegationGateHook } from './delegation-gate';
+export { createDelegationSanitizerHook } from './delegation-sanitizer';
+export { createDelegationTrackerHook } from './delegation-tracker';
+export { extractCurrentPhase, extractCurrentPhaseFromPlan, extractCurrentTask, extractCurrentTaskFromPlan, extractDecisions, extractIncompleteTasks, extractIncompleteTasksFromPlan, extractPatterns, } from './extractors';
+export { createFullAutoInterceptHook } from './full-auto-intercept';
+export { checkFileAuthority, createGuardrailsHooks, DEFAULT_AGENT_AUTHORITY_RULES, } from './guardrails';
+export { classifyMessage, classifyMessages, containsPlanContent, isDuplicateToolRead, isStaleError, isToolResult, MessagePriority, type MessagePriorityType, type MessageWithParts, } from './message-priority';
+export { consolidateSystemMessages } from './messages-transform';
+export { extractModelInfo, NATIVE_MODEL_LIMITS, PROVIDER_CAPS, resolveModelLimit, } from './model-limits';
+export { type CuratorDelegateFactory, createPhaseMonitorHook, } from './phase-monitor';
+export { createPipelineTrackerHook } from './pipeline-tracker';
+export { createRepoGraphBuilderHook, type RepoGraphBuilderHook, } from './repo-graph-builder';
+export { buildApprovedReceipt, buildReceiptContextForDrift, buildRejectedReceipt, persistReviewReceipt, readAllReceipts, readReceiptsByScopeHash, } from './review-receipt';
+export { createSystemEnhancerHook } from './system-enhancer';
+export { createToolSummarizerHook, resetSummaryIdCounter, } from './tool-summarizer';
+export { composeHandlers, estimateTokens, readSwarmFileAsync, safeHook, validateSwarmPath, } from './utils';

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

@@ -0,0 +1,27 @@
+/** Knowledge curator hook for opencode-swarm v6.17 two-tier knowledge system. */
+import type { KnowledgeConfig } from './knowledge-types.js';
+/**
+ * Check if the input is a write operation targeting an evidence file.
+ * Exported for testing purposes only.
+ */
+export declare function isWriteToEvidenceFile(input: unknown): boolean;
+/**
+ * Curate and store swarm knowledge entries from lessons.
+ * @returns Promise resolving to an object with counts of stored, skipped, and rejected lessons.
+ */
+export declare function curateAndStoreSwarm(lessons: string[], projectName: string, phaseInfo: {
+    phase_number: number;
+}, directory: string, config: KnowledgeConfig): Promise<{
+    stored: number;
+    skipped: number;
+    rejected: number;
+}>;
+/**
+ * Auto-promote swarm entries based on phase confirmations and age.
+ */
+export declare function runAutoPromotion(directory: string, config: KnowledgeConfig): Promise<void>;
+/**
+ * Create the knowledge curator hook.
+ * Watches for writes to .swarm/plan.md and extracts lessons from the retrospective section.
+ */
+export declare function createKnowledgeCuratorHook(directory: string, config: KnowledgeConfig): (input: unknown, output: unknown) => Promise<void>;

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

@@ -0,0 +1,20 @@
+/** Phase-Start Knowledge Injection Hook for opencode-swarm v6.17.
+ *
+ * Injects relevant knowledge (from both swarm + hive tiers) into the architect's
+ * context at phase start. Caches the injection text for re-injection after
+ * compaction. Skips for non-architect agents. Appends rejected-pattern warnings
+ * to prevent re-learning loops.
+ */
+import type { KnowledgeConfig, MessageWithParts } from './knowledge-types.js';
+/**
+ * Creates a knowledge injection hook that injects relevant knowledge into the
+ * architect's message context at phase start. Supports caching for re-injection
+ * after compaction.
+ *
+ * @param directory - The project directory containing .swarm/
+ * @param config - Knowledge system configuration
+ * @returns A hook function that injects knowledge into messages
+ */
+export declare function createKnowledgeInjectorHook(directory: string, config: KnowledgeConfig): (input: Record<string, never>, output: {
+    messages?: MessageWithParts[];
+}) => Promise<void>;

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

@@ -0,0 +1,11 @@
+/** One-time migration from .swarm/context.md → .swarm/knowledge.jsonl for existing projects. */
+import type { KnowledgeConfig } from './knowledge-types.js';
+export interface MigrationResult {
+    migrated: boolean;
+    entriesMigrated: number;
+    entriesDropped: number;
+    entriesTotal: number;
+    skippedReason?: 'sentinel-exists' | 'no-context-file' | 'empty-context' | 'external-sentinel-exists';
+}
+export declare function migrateKnowledgeToExternal(_directory: string, _config: KnowledgeConfig): Promise<MigrationResult>;
+export declare function migrateContextToKnowledge(directory: string, config: KnowledgeConfig): Promise<MigrationResult>;

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

@@ -0,0 +1,22 @@
+/** Read path for the opencode-swarm v6.17 two-tier knowledge system.
+ * Merges swarm + hive knowledge, deduplicates (hive wins), ranks by composite score,
+ * and provides utility tracking.
+ */
+import type { KnowledgeConfig, KnowledgeEntryBase } from './knowledge-types.js';
+export interface ProjectContext {
+    projectName: string;
+    currentPhase: string;
+    techStack?: string[];
+    recentErrors?: string[];
+}
+export interface RankedEntry extends KnowledgeEntryBase {
+    tier: 'swarm' | 'hive';
+    relevanceScore: {
+        category: number;
+        confidence: number;
+        keywords: number;
+    };
+    finalScore: number;
+}
+export declare function readMergedKnowledge(directory: string, config: KnowledgeConfig, context?: ProjectContext): Promise<RankedEntry[]>;
+export declare function updateRetrievalOutcome(directory: string, phaseInfo: string, phaseSucceeded: boolean): Promise<void>;

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

@@ -0,0 +1,30 @@
+/** Core storage layer for the opencode-swarm v6.17 two-tier knowledge system. */
+import type { KnowledgeEntryBase, RejectedLesson } from './knowledge-types.js';
+export declare function getPlatformConfigDir(): string;
+export declare function resolveSwarmKnowledgePath(directory: string): string;
+export declare function resolveSwarmRejectedPath(directory: string): string;
+export declare function resolveHiveKnowledgePath(): string;
+export declare function resolveHiveRejectedPath(): string;
+export declare function readKnowledge<T>(filePath: string): Promise<T[]>;
+export declare function readRejectedLessons(directory: string): Promise<RejectedLesson[]>;
+export declare function appendKnowledge<T>(filePath: string, entry: T): Promise<void>;
+export declare function rewriteKnowledge<T>(filePath: string, entries: T[]): Promise<void>;
+export declare function enforceKnowledgeCap<T>(filePath: string, maxEntries: number): Promise<void>;
+export interface SweepResult {
+    scanned: number;
+    aged: number;
+    archived: number;
+    removed: number;
+    skipped_promoted: number;
+}
+export declare function sweepAgedEntries<T extends KnowledgeEntryBase>(filePath: string, defaultMaxPhases: number): Promise<SweepResult>;
+export declare function sweepStaleTodos<T extends KnowledgeEntryBase>(filePath: string, todoMaxPhases: number): Promise<SweepResult>;
+export declare function appendRejectedLesson(directory: string, lesson: RejectedLesson): Promise<void>;
+export declare function normalize(text: string): string;
+export declare function wordBigrams(text: string): Set<string>;
+export declare function jaccardBigram(a: Set<string>, b: Set<string>): number;
+export declare function findNearDuplicate<T extends {
+    lesson: string;
+}>(candidate: string, entries: T[], threshold?: number): T | undefined;
+export declare function computeConfidence(confirmedByCount: number, autoGenerated: boolean): number;
+export declare function inferTags(lesson: string): string[];

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

@@ -0,0 +1,131 @@
+/** Type definitions for the opencode-swarm v6.17 two-tier knowledge system. */
+export type KnowledgeCategory = 'process' | 'architecture' | 'tooling' | 'security' | 'testing' | 'debugging' | 'performance' | 'integration' | 'todo' | 'other';
+export interface PhaseConfirmationRecord {
+    phase_number: number;
+    confirmed_at: string;
+    project_name: string;
+}
+export interface ProjectConfirmationRecord {
+    project_name: string;
+    confirmed_at: string;
+    phase_number?: number;
+}
+export interface RetrievalOutcome {
+    applied_count: number;
+    succeeded_after_count: number;
+    failed_after_count: number;
+    last_applied_at?: string;
+}
+export interface KnowledgeEntryBase {
+    id: string;
+    tier: 'swarm' | 'hive';
+    lesson: string;
+    category: KnowledgeCategory;
+    tags: string[];
+    scope: string;
+    confidence: number;
+    status: 'candidate' | 'established' | 'promoted' | 'archived';
+    confirmed_by: PhaseConfirmationRecord[] | ProjectConfirmationRecord[];
+    retrieval_outcomes: RetrievalOutcome;
+    schema_version: number;
+    created_at: string;
+    updated_at: string;
+    hive_eligible?: boolean;
+    auto_generated?: boolean;
+    phases_alive?: number;
+    max_phases?: number;
+}
+export interface SwarmKnowledgeEntry extends KnowledgeEntryBase {
+    tier: 'swarm';
+    confirmed_by: PhaseConfirmationRecord[];
+    project_name: string;
+}
+export interface HiveKnowledgeEntry extends KnowledgeEntryBase {
+    tier: 'hive';
+    confirmed_by: ProjectConfirmationRecord[];
+    source_project: string;
+    /** Weighted encounter score for hive advancement. Starts at 1.0 for originating project. */
+    encounter_score: number;
+    /** @deprecated Legacy field for backward compatibility. Use encounter_score for weighting. */
+    encounter_count?: number;
+}
+export interface RejectedLesson {
+    id: string;
+    lesson: string;
+    rejection_reason: string;
+    rejected_at: string;
+    rejection_layer: 1 | 2 | 3;
+}
+export interface KnowledgeConfig {
+    /** Enable or disable the entire knowledge system. Default: true */
+    enabled: boolean;
+    /** Maximum entries to keep in swarm knowledge.jsonl. Default: 100 */
+    swarm_max_entries: number;
+    /** Maximum entries to keep in hive shared-learnings.jsonl. Default: 200 */
+    hive_max_entries: number;
+    /** Days before auto-promotion to hive tier. Default: 90 */
+    auto_promote_days: number;
+    /** Maximum knowledge entries to inject per architect message. Default: 5 */
+    max_inject_count: number;
+    /** Maximum total chars for the entire injection block. Default: 2000 */
+    inject_char_budget?: number;
+    /** Minimum headroom chars required before knowledge injection activates. Default: 300 */
+    context_budget_threshold?: number;
+    /** Maximum display chars per lesson at injection time. Default: 120 */
+    max_lesson_display_chars?: number;
+    /** Jaccard bigram similarity threshold for deduplication. Default: 0.6 */
+    dedup_threshold: number;
+    /** Scope filters to apply when reading knowledge. Default: ['global'] */
+    scope_filter: string[];
+    /** Enable hive (cross-project) tier reads and writes. Default: true */
+    hive_enabled: boolean;
+    /** Maximum rejected lesson fingerprints to retain. Default: 20 */
+    rejected_max_entries: number;
+    /** Enable validation gate before storing lessons. Default: true */
+    validation_enabled: boolean;
+    /** Confidence threshold for marking an entry evergreen. Default: 0.9 */
+    evergreen_confidence: number;
+    /** Utility score threshold for marking an entry evergreen. Default: 0.8 */
+    evergreen_utility: number;
+    /** Utility score at or below which an entry is considered low-utility. Default: 0.3 */
+    low_utility_threshold: number;
+    /** Minimum retrieval count before utility scoring begins. Default: 3 */
+    min_retrievals_for_utility: number;
+    /** JSONL schema version. Default: 1 */
+    schema_version: number;
+    /** Weighted scoring: multiplier for encounters from the source project. Default: 1.0 */
+    same_project_weight: number;
+    /** Weighted scoring: multiplier for encounters from other projects. Default: 0.5 */
+    cross_project_weight: number;
+    /** Weighted scoring: minimum encounter score floor. Default: 0.1 */
+    min_encounter_score: number;
+    /** Weighted scoring: initial score for newly promoted hive entries. Default: 1.0 */
+    initial_encounter_score: number;
+    /** Weighted scoring: score increment per encounter. Default: 0.1 */
+    encounter_increment: number;
+    /** Weighted scoring: maximum encounter score cap. Default: 10.0 */
+    max_encounter_score: number;
+    /** Default N-phase TTL for knowledge entries. Default: 10 */
+    default_max_phases: number;
+    /** N-phase TTL for 'todo' category entries. Default: 3 */
+    todo_max_phases: number;
+    /** Enable age-based sweep of knowledge entries. Default: true */
+    sweep_enabled: boolean;
+}
+export interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    [key: string]: unknown;
+}
+export interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+export interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}

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

@@ -0,0 +1,29 @@
+/** Three-layer validation gate for the opencode-swarm v6.17 knowledge system. */
+import type { KnowledgeCategory, KnowledgeEntryBase } from './knowledge-types.js';
+export interface ValidationResult {
+    valid: boolean;
+    layer: 1 | 2 | 3 | null;
+    reason: string | null;
+    severity: 'error' | 'warning' | null;
+}
+export declare const DANGEROUS_COMMAND_PATTERNS: RegExp[];
+export declare const SECURITY_DEGRADING_PATTERNS: RegExp[];
+export declare const INVISIBLE_FORMAT_CHARS: RegExp;
+export declare const INJECTION_PATTERNS: RegExp[];
+export declare function validateLesson(candidate: string, existingLessons: string[], meta: {
+    category: KnowledgeCategory;
+    scope: string;
+    confidence: number;
+}): ValidationResult;
+export interface QuarantinedEntry extends KnowledgeEntryBase {
+    quarantine_reason: string;
+    quarantined_at: string;
+    reported_by: 'architect' | 'user' | 'auto';
+}
+export interface EntryHealthResult {
+    healthy: boolean;
+    concern?: string;
+}
+export declare function auditEntryHealth(entry: KnowledgeEntryBase): EntryHealthResult;
+export declare function quarantineEntry(directory: string, entryId: string, reason: string, reportedBy: 'architect' | 'user' | 'auto'): Promise<void>;
+export declare function restoreEntry(directory: string, entryId: string): Promise<void>;

package/dist/hooks/loop-detector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Loop detector for Task tool delegations.
+ * Tracks the last 10 delegation patterns per session using a sliding window.
+ * Detects loops when the same (toolName + targetAgent + firstArgKey) hash
+ * appears 3 or more consecutive times.
+ */
+export interface LoopDetectResult {
+    looping: boolean;
+    count: number;
+    pattern: string;
+}
+/**
+ * Detect delegation loops for a session.
+ * Only tracks Task tool calls (agent delegations).
+ * Returns the current loop state after recording this call.
+ */
+export declare function detectLoop(sessionId: string, toolName: string, args: unknown): LoopDetectResult;

package/dist/hooks/loop-detector.test.d.ts

@@ -0,0 +1 @@
+export {};