cognitive-core 0.2.0 → 0.2.2

package/src/atlas.ts

@@ -9,6 +9,15 @@ import type {
 import type { KnowledgeMatch } from './types/knowledge.js';
 import { createDefaultConfig } from './types/index.js';
 import { MemorySystem, createMemorySystem, type TeamExperience } from './memory/index.js';
+import {
+  loadCuratedPlaybooks as loadCuratedPlaybooksFn,
+  BUNDLED_SEED_PACK_DIR,
+} from './memory/curated-loader.js';
+import {
+  resolvePlaybookSource,
+  sourceStateKey,
+  type SourceState,
+} from './memory/source-resolver.js';
 import {
   UnifiedLearningPipeline,
   createUnifiedPipeline,
@@ -271,6 +280,9 @@ export class Atlas {
 
     // Initialize playbook-based components if playbooks are available
     if (this.memory.playbooks) {
+      // Load curated playbooks (bundled seed pack + additional dirs)
+      await this.loadCuratedPlaybooks();
+
       this.skillLibrary = createSkillLibrary(
         this.memory.playbooks,
         this.config.skillLibrary
@@ -290,6 +302,90 @@ export class Atlas {
     }
   }
 
+  /**
+   * Load curated playbooks from bundled seed pack, additional directories,
+   * and resolved sources (local paths or git repos).
+   * Called during init() when curatedPlaybooks config is enabled.
+   */
+  private async loadCuratedPlaybooks(): Promise<void> {
+    const cfg = this.config.curatedPlaybooks;
+    const recreate = cfg.recreateOnInit;
+
+    // Load bundled seed pack (shipped with cognitive-core)
+    if (cfg.loadBundledSeedPack) {
+      const loadOpts = recreate
+        ? { recreate: true, sourceId: 'bundled' }
+        : { sourceId: 'bundled' };
+      await loadCuratedPlaybooksFn(
+        BUNDLED_SEED_PACK_DIR,
+        this.memory.playbooks,
+        loadOpts,
+      );
+    }
+
+    // Load from additional directories (backward compat)
+    for (const dir of cfg.additionalDirs) {
+      const loadOpts = recreate
+        ? { recreate: true, sourceId: dir }
+        : { sourceId: dir };
+      await loadCuratedPlaybooksFn(dir, this.memory.playbooks, loadOpts);
+    }
+
+    // Resolve and load from sources (local paths + git repos)
+    if (cfg.sources.length > 0) {
+      const cacheDir = join(this.config.storage.baseDir, cfg.cache.dir);
+      for (const source of cfg.sources) {
+        await this.loadFromSource(source, cacheDir, recreate);
+      }
+    }
+  }
+
+  /**
+   * Resolve a single source (local or git) and load its playbooks.
+   */
+  private async loadFromSource(
+    source: string,
+    cacheDir: string,
+    recreate: boolean,
+  ): Promise<void> {
+    const cfg = this.config.curatedPlaybooks;
+
+    const resolved = await resolvePlaybookSource(source, {
+      cacheDir,
+      maxAgeMs: cfg.cache.maxAgeMs,
+      forceUpdate: recreate,
+      getSourceState: (s) =>
+        this.persistence.getSystemState<SourceState>(sourceStateKey(s)),
+      setSourceState: (s, state) =>
+        this.persistence.setSystemState(sourceStateKey(s), state),
+    });
+
+    if (!resolved) return;
+
+    // For git sources: skip loading if SHA hasn't changed and we're not recreating
+    // (playbooks are already in the library from a previous init).
+    // For local paths: always load (the loader handles dedup via getByName).
+    if (resolved.isGit && !resolved.updated && !recreate) return;
+
+    const loadOpts = recreate
+      ? { recreate: true, sourceId: resolved.sourceId }
+      : { sourceId: resolved.sourceId };
+
+    const result = await loadCuratedPlaybooksFn(
+      resolved.playbookDir,
+      this.memory.playbooks,
+      loadOpts,
+    );
+
+    // Update source state with playbook count
+    const stateKey = sourceStateKey(source);
+    const prevState = this.persistence.getSystemState<SourceState>(stateKey);
+    if (prevState) {
+      prevState.playbookCount = result.loaded;
+      this.persistence.setSystemState(stateKey, prevState);
+    }
+  }
+
   /**
    * Set the LLM provider for solving (deprecated)
    * @deprecated Use setAgentManager() with backends for real execution

package/src/index.ts

@@ -435,6 +435,33 @@ export {
   type AgenticTaskResult,
   type AgenticTaskMetrics,
   AgenticTaskOutputError,
+  // Efficacy toolkit
+  computeNormalizedGain,
+  computeTemporalTrend,
+  computeDomainBreakdown,
+  buildEfficacyProfile,
+  buildPortfolioSnapshot,
+  type PlaybookEfficacyProfile,
+  type DomainBreakdown,
+  type TemporalTrend,
+  type UsageProfile,
+  type EvolutionSummary,
+  type PortfolioSnapshot,
+  type PlaybookHealthFlag,
+  type RedundancyPair,
+  // Efficacy templates
+  playbookEfficacyAuditTemplate,
+  type PlaybookEfficacyAuditInput,
+  type PlaybookEfficacyAuditOutput,
+  type PlaybookRecommendation,
+  playbookDecayDetectionTemplate,
+  type PlaybookDecayDetectionInput,
+  type PlaybookDecayDetectionOutput,
+  type DecaySignal,
+  playbookLifecycleReviewTemplate,
+  type PlaybookLifecycleReviewInput,
+  type PlaybookLifecycleReviewOutput,
+  type LifecycleRecommendation,
 } from './workspace/index.js';
 
 // Persistence - Unified SQLite database for system-internal state

package/src/learning/index.ts

@@ -106,6 +106,7 @@ export {
   createUnifiedPipeline,
   type UnifiedPipelineConfig,
   type UnifiedPipelineFeatures,
+  type EfficacyMaintenanceConfig,
   type ImmediateResult,
   type UnifiedBatchResult,
   type UnifiedPipelineStats,

package/src/learning/unified-pipeline.ts

@@ -54,7 +54,12 @@ import { playbookExtractionTemplate } from '../workspace/templates/playbook-extr
 
 // Meta-learning and effectiveness
 import { MetaLearner, type MetaLearnerConfig } from './meta-learner.js';
-import { LearningEffectivenessTracker } from './effectiveness.js';
+import { LearningEffectivenessTracker, type TaskAnnotation, type PlaybookEffectivenessEntry } from './effectiveness.js';
+
+// Efficacy templates (used in maintenance tasks)
+import { playbookDecayDetectionTemplate, type PlaybookDecayDetectionOutput } from '../workspace/templates/playbook-decay-detection.js';
+import { playbookEfficacyAuditTemplate } from '../workspace/templates/playbook-efficacy-audit.js';
+import { playbookLifecycleReviewTemplate } from '../workspace/templates/playbook-lifecycle-review.js';
 
 // Energy evaluator (batch trigger)
 import {
@@ -121,6 +126,8 @@ export interface UnifiedPipelineFeatures {
   effectivenessTracking?: boolean;
   /** Enable healing orchestrator with built-in detectors (default: true) */
   healing?: boolean;
+  /** Enable efficacy maintenance tasks (decay detection, audit, lifecycle review) (default: true) */
+  efficacy?: boolean;
 }
 
 /**
@@ -140,10 +147,30 @@ export interface UnifiedPipelineConfig {
   metaLearner: Partial<MetaLearnerConfig>;
   /** Feature flags */
   features: UnifiedPipelineFeatures;
+  /** Efficacy maintenance config */
+  efficacy: EfficacyMaintenanceConfig;
   /** Max latency warning threshold for instant loop in ms (default: 200) */
   maxInstantLatencyMs: number;
 }
 
+/**
+ * Configuration for efficacy maintenance tasks.
+ */
+export interface EfficacyMaintenanceConfig {
+  /** Run lifecycle review every Nth maintenance cycle (default: 3) */
+  lifecycleReviewFrequency: number;
+  /** Minimum playbooks required before running efficacy tasks (default: 1) */
+  minPlaybooks: number;
+  /** Minimum annotations required before running efficacy tasks (default: 3) */
+  minAnnotations: number;
+}
+
+const DEFAULT_EFFICACY_CONFIG: EfficacyMaintenanceConfig = {
+  lifecycleReviewFrequency: 3,
+  minPlaybooks: 1,
+  minAnnotations: 3,
+};
+
 const DEFAULT_UNIFIED_CONFIG: UnifiedPipelineConfig = {
   instant: {},
   batch: {
@@ -153,6 +180,7 @@ const DEFAULT_UNIFIED_CONFIG: UnifiedPipelineConfig = {
   maintenance: {},
   metaLearner: {},
   features: {},
+  efficacy: DEFAULT_EFFICACY_CONFIG,
   maxInstantLatencyMs: 200,
 };
 
@@ -267,6 +295,7 @@ export class UnifiedLearningPipeline {
   private batchCyclesRun = 0;
   private maintenanceCyclesRun = 0;
   private _onLatencyWarning: ((durationMs: number) => void) | null = null;
+  private lastDecayResult: PlaybookDecayDetectionOutput | null = null;
 
   constructor(
     memory: MemorySystem,
@@ -284,6 +313,7 @@ export class UnifiedLearningPipeline {
       maintenance: { ...DEFAULT_UNIFIED_CONFIG.maintenance, ...config?.maintenance },
       metaLearner: { ...DEFAULT_UNIFIED_CONFIG.metaLearner, ...config?.metaLearner },
       features: { ...DEFAULT_UNIFIED_CONFIG.features, ...config?.features },
+      efficacy: { ...DEFAULT_EFFICACY_CONFIG, ...config?.efficacy },
     };
 
     this.memory = memory;
@@ -822,6 +852,246 @@ export class UnifiedLearningPipeline {
         },
       });
     }
+
+    // Efficacy maintenance tasks
+    this.registerEfficacyMaintenanceTasks();
+  }
+
+  /**
+   * Register efficacy maintenance tasks (decay detection, audit, lifecycle review).
+   * All tasks are log-only — results are returned in details but no automatic mutations.
+   */
+  private registerEfficacyMaintenanceTasks(): void {
+    if (!(this.config.features.efficacy ?? true)) return;
+
+    const efficacyCfg = this.config.efficacy;
+
+    // 1. Playbook Decay Detection (priority 70) — runs every maintenance cycle
+    this.maintenanceScheduler.registerTask({
+      name: 'playbook-decay-detection',
+      priority: 70,
+      execute: async () => {
+        const start = Date.now();
+        this.lastDecayResult = null;
+
+        const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } =
+          await this.getEfficacyData();
+
+        if (playbooks.length < efficacyCfg.minPlaybooks || annotations.length < efficacyCfg.minAnnotations) {
+          return {
+            taskName: 'playbook-decay-detection',
+            success: true,
+            durationMs: Date.now() - start,
+            details: { skipped: true, reason: 'insufficient data' },
+          };
+        }
+
+        const result = await playbookDecayDetectionTemplate.heuristicFallback!({
+          playbooks,
+          annotations,
+          playbookEffectiveness,
+          unguidedSuccessRate,
+        });
+
+        this.lastDecayResult = result;
+
+        return {
+          taskName: 'playbook-decay-detection',
+          success: true,
+          durationMs: Date.now() - start,
+          details: {
+            decayingCount: result.decaying.length,
+            atRiskCount: result.atRisk.length,
+            healthyCount: result.healthy.length,
+            decaying: result.decaying,
+            atRisk: result.atRisk,
+            portfolioAssessment: result.portfolioAssessment,
+          },
+        };
+      },
+    });
+
+    // 2. Playbook Efficacy Audit (priority 65) — audits flagged playbooks from decay detection
+    this.maintenanceScheduler.registerTask({
+      name: 'playbook-efficacy-audit',
+      priority: 65,
+      execute: async () => {
+        const start = Date.now();
+
+        if (!this.lastDecayResult) {
+          return {
+            taskName: 'playbook-efficacy-audit',
+            success: true,
+            durationMs: Date.now() - start,
+            details: { skipped: true, reason: 'no decay detection results' },
+          };
+        }
+
+        const flagged = [
+          ...this.lastDecayResult.decaying,
+          ...this.lastDecayResult.atRisk,
+        ];
+
+        if (flagged.length === 0) {
+          return {
+            taskName: 'playbook-efficacy-audit',
+            success: true,
+            durationMs: Date.now() - start,
+            details: { skipped: true, reason: 'no flagged playbooks' },
+          };
+        }
+
+        const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } =
+          await this.getEfficacyData();
+
+        const playbookMap = new Map(playbooks.map(p => [p.id, p]));
+        const effectivenessMap = new Map(playbookEffectiveness.map(e => [e.playbookId, e]));
+        const trajectoryDomainMap = this.buildTrajectoryDomainMap(annotations);
+
+        const audits: Array<{
+          playbookId: string;
+          health: string;
+          recommendations: unknown[];
+          summary: string;
+        }> = [];
+
+        for (const signal of flagged) {
+          const playbook = playbookMap.get(signal.playbookId);
+          if (!playbook) continue;
+
+          const auditResult = await playbookEfficacyAuditTemplate.heuristicFallback!({
+            playbook,
+            annotations,
+            playbookEffectiveness: effectivenessMap.get(signal.playbookId),
+            unguidedSuccessRate,
+            trajectoryDomainMap,
+          });
+
+          audits.push({
+            playbookId: signal.playbookId,
+            health: auditResult.assessment.health,
+            recommendations: auditResult.assessment.recommendations,
+            summary: auditResult.assessment.summary,
+          });
+        }
+
+        return {
+          taskName: 'playbook-efficacy-audit',
+          success: true,
+          durationMs: Date.now() - start,
+          details: {
+            auditsPerformed: audits.length,
+            audits,
+          },
+        };
+      },
+    });
+
+    // 3. Playbook Lifecycle Review (priority 50) — runs every Nth maintenance cycle
+    this.maintenanceScheduler.registerTask({
+      name: 'playbook-lifecycle-review',
+      priority: 50,
+      execute: async () => {
+        const start = Date.now();
+
+        // Only run every Nth maintenance cycle
+        if (this.maintenanceCyclesRun % efficacyCfg.lifecycleReviewFrequency !== 0) {
+          return {
+            taskName: 'playbook-lifecycle-review',
+            success: true,
+            durationMs: Date.now() - start,
+            details: {
+              skipped: true,
+              reason: `runs every ${efficacyCfg.lifecycleReviewFrequency} maintenance cycles`,
+            },
+          };
+        }
+
+        const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } =
+          await this.getEfficacyData();
+
+        if (playbooks.length < efficacyCfg.minPlaybooks || annotations.length < efficacyCfg.minAnnotations) {
+          return {
+            taskName: 'playbook-lifecycle-review',
+            success: true,
+            durationMs: Date.now() - start,
+            details: { skipped: true, reason: 'insufficient data' },
+          };
+        }
+
+        const trajectoryDomainMap = this.buildTrajectoryDomainMap(annotations);
+
+        const result = await playbookLifecycleReviewTemplate.heuristicFallback!({
+          playbooks,
+          annotations,
+          playbookEffectiveness,
+          unguidedSuccessRate,
+          trajectoryDomainMap,
+        });
+
+        return {
+          taskName: 'playbook-lifecycle-review',
+          success: true,
+          durationMs: Date.now() - start,
+          details: {
+            totalPlaybooks: result.snapshot.totalPlaybooks,
+            recommendationsCount: result.recommendations.length,
+            recommendations: result.recommendations,
+            insights: result.insights,
+            actionPlan: result.actionPlan,
+            snapshot: {
+              avgConfidence: result.snapshot.avgConfidence,
+              avgSuccessRate: result.snapshot.avgSuccessRate,
+              confidenceBands: result.snapshot.confidenceBands,
+              decayingCount: result.snapshot.decaying.length,
+              staleCount: result.snapshot.stale.length,
+            },
+          },
+        };
+      },
+    });
+  }
+
+  /**
+   * Fetch shared efficacy data used by all three efficacy maintenance tasks.
+   */
+  private async getEfficacyData(): Promise<{
+    annotations: TaskAnnotation[];
+    playbooks: Playbook[];
+    playbookEffectiveness: PlaybookEffectivenessEntry[];
+    unguidedSuccessRate: number;
+  }> {
+    const playbooks = await this.memory.playbooks.getAll();
+
+    let annotations: TaskAnnotation[] = [];
+    let playbookEffectiveness: PlaybookEffectivenessEntry[] = [];
+    let unguidedSuccessRate = 0;
+
+    if (this.effectivenessTracker) {
+      annotations = await this.effectivenessTracker.getAll();
+      const metrics = await this.effectivenessTracker.computeMetrics();
+      playbookEffectiveness = metrics.playbookEffectiveness;
+      unguidedSuccessRate = metrics.unguidedSuccessRate;
+    }
+
+    return { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate };
+  }
+
+  /**
+   * Build a trajectoryId→domain map from annotations.
+   * Uses accumulated trajectories when available, otherwise infers from task annotations.
+   */
+  private buildTrajectoryDomainMap(_annotations: TaskAnnotation[]): Map<string, string> {
+    const domainMap = new Map<string, string>();
+
+    // Map from accumulated trajectories (has task.domain directly).
+    // Annotations don't carry domain, so historical trajectories will
+    // fall through to the toolkit's 'unknown' default — acceptable for log-only mode.
+    for (const t of this.accumulated) {
+      domainMap.set(t.id, t.task.domain);
+    }
+
+    return domainMap;
   }
 
   /**

package/src/memory/candidate-retrieval.ts

@@ -63,7 +63,8 @@ export function getCandidates<T>(
       const item = resolver.get(id);
       if (item) items.push(item);
     }
-    return items;
+    // If all IDs were stale/unresolvable, fall back to full scan
+    if (items.length > 0) return items;
   }
 
   // Too few candidates — fall back

package/src/memory/curated-loader.ts

@@ -6,17 +6,30 @@
  * drop all curated playbooks and reload from source files without
  * losing extracted or imported playbooks.
  *
+ * Supports recursive directory scanning and source-prefix-based
+ * deletion for per-source recreate (multiple sources don't clobber
+ * each other).
+ *
  * Inspired by Dash's separation of curated knowledge (file-loaded)
  * vs learnings (runtime-discovered).
  */
 
-import { readFile, readdir, stat } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative, dirname } from 'node:path';
 import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import type { PlaybookProvenance } from '../types/index.js';
 import { createPlaybook } from '../types/index.js';
 import type { PlaybookLibrary } from './playbook.js';
 
+/**
+ * Path to the bundled compound-engineering seed pack shipped with cognitive-core.
+ * Resolves relative to this file's location in the package.
+ */
+const __filename_curated = fileURLToPath(import.meta.url);
+const __dirname_curated = dirname(__filename_curated);
+export const BUNDLED_SEED_PACK_DIR = join(__dirname_curated, '../../playbooks/compound-engineering');
+
 /**
  * Schema for a curated playbook JSON file
  */
@@ -55,17 +68,49 @@ export interface CuratedLoadResult {
   recreated: boolean;
 }
 
+/**
+ * Options for loadCuratedPlaybooks
+ */
+export interface CuratedLoadOptions {
+  /** If true, delete existing curated playbooks before loading */
+  recreate?: boolean;
+  /**
+   * Source identifier for provenance tracking.
+   * Used as prefix in provenance.sourceFile for per-source recreate.
+   * If provided and recreate is true, only playbooks from this source are deleted.
+   */
+  sourceId?: string;
+}
+
+/**
+ * Recursively find all JSON files in a directory tree.
+ */
+async function findJsonFiles(dir: string): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await findJsonFiles(fullPath));
+    } else if (entry.name.endsWith('.json')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
 /**
  * Load curated playbooks from a directory of JSON files into the library.
+ * Supports recursive directory scanning.
  *
  * @param curatedDir - Directory containing curated playbook JSON files
  * @param library - PlaybookLibrary to load into
- * @param options.recreate - If true, delete existing curated playbooks before loading
+ * @param options - Load options (recreate, sourceId)
  */
 export async function loadCuratedPlaybooks(
   curatedDir: string,
   library: PlaybookLibrary,
-  options?: { recreate?: boolean }
+  options?: CuratedLoadOptions
 ): Promise<CuratedLoadResult> {
   const result: CuratedLoadResult = {
     loaded: 0,
@@ -78,20 +123,23 @@ export async function loadCuratedPlaybooks(
     return result;
   }
 
-  // Recreate: drop all curated playbooks first
+  // Recreate: drop curated playbooks before loading
   if (options?.recreate) {
-    await library.deleteByOrigin('curated');
+    if (options.sourceId) {
+      // Per-source recreate: only delete playbooks from this source
+      await library.deleteByCuratedSource(options.sourceId);
+    } else {
+      // Global recreate: delete all curated playbooks
+      await library.deleteByOrigin('curated');
+    }
     result.recreated = true;
   }
 
-  // Find all JSON files in the directory (non-recursive)
-  const files = await readdir(curatedDir);
-  const jsonFiles = files.filter((f) => f.endsWith('.json'));
+  // Find all JSON files recursively
+  const jsonFiles = await findJsonFiles(curatedDir);
 
-  for (const file of jsonFiles) {
-    const filePath = join(curatedDir, file);
-    const fileStat = await stat(filePath);
-    if (!fileStat.isFile()) continue;
+  for (const filePath of jsonFiles) {
+    const relativeToDir = relative(curatedDir, filePath);
 
     try {
       const content = await readFile(filePath, 'utf-8');
@@ -100,7 +148,7 @@ export async function loadCuratedPlaybooks(
       // Validate required fields
       if (!parsed.name || !parsed.applicability || !parsed.guidance) {
         result.errors.push({
-          file,
+          file: relativeToDir,
           error: 'Missing required fields: name, applicability, guidance',
         });
         continue;
@@ -113,10 +161,15 @@ export async function loadCuratedPlaybooks(
         continue;
       }
 
+      // Build sourceFile with optional source prefix
       const relativePath = relative(process.cwd(), filePath);
+      const sourceFile = options?.sourceId
+        ? `${options.sourceId}:${relativeToDir}`
+        : relativePath;
+
       const provenance: PlaybookProvenance = {
         origin: 'curated',
-        sourceFile: relativePath,
+        sourceFile,
         curatedBy: parsed.curatedBy,
         recordedAt: new Date(),
       };
@@ -150,7 +203,7 @@ export async function loadCuratedPlaybooks(
       result.loaded++;
     } catch (error) {
       result.errors.push({
-        file,
+        file: relativeToDir,
         error: error instanceof Error ? error.message : String(error),
       });
     }

package/src/memory/index.ts

@@ -99,10 +99,26 @@ export type { SqlitePersistenceConfig } from '../persistence/index.js';
 // Curated playbook loading
 export {
   loadCuratedPlaybooks,
+  BUNDLED_SEED_PACK_DIR,
   type CuratedPlaybookFile,
   type CuratedLoadResult,
+  type CuratedLoadOptions,
 } from './curated-loader.js';
 
+// Source resolver (git + local path resolution for curated sources)
+export {
+  resolvePlaybookSource,
+  isGitSource,
+  parseGitSource,
+  discoverPlaybookDir,
+  sourceStateKey,
+  type ParsedGitSource,
+  type PlaybookManifest,
+  type SourceState,
+  type ResolveResult,
+  type ResolveOptions,
+} from './source-resolver.js';
+
 // Skill export (compile playbooks → Open Agent Skills format)
 export {
   compilePlaybookToSkill,

package/src/memory/playbook.ts

@@ -616,6 +616,25 @@ export class PlaybookLibrary {
     return toDelete.length;
   }
 
+  /**
+   * Delete curated playbooks whose provenance.sourceFile starts with the given prefix.
+   * Used by the source resolver to recreate playbooks from a specific source
+   * without affecting other curated sources.
+   */
+  async deleteByCuratedSource(sourcePrefix: string): Promise<number> {
+    await this.init();
+    const toDelete = this.getAllSync().filter(
+      (p) =>
+        p.provenance?.origin === 'curated' &&
+        p.provenance.sourceFile?.startsWith(sourcePrefix),
+    );
+    for (const playbook of toDelete) {
+      this.persistence.deletePlaybook(playbook.id);
+      this._index.remove(playbook.id);
+    }
+    return toDelete.length;
+  }
+
   /**
    * Get provenance summary across all playbooks
    */