cognitive-core 0.2.1 → 0.2.2

package/src/types/index.ts

@@ -250,6 +250,8 @@ export {
   type GraphConfigType,
   type DefragConfig,
   type SkillTreeConfig,
+  type CuratedCacheConfig,
+  type CuratedPlaybooksConfig,
   type SessionBankConfig,
   type FeaturesConfig,
   type AtlasConfig,
@@ -282,6 +284,8 @@ export {
   TeamLearningConfigSchema,
   AgenticTaskRunnerConfigSchema,
   SkillTreeConfigSchema,
+  CuratedCacheConfigSchema,
+  CuratedPlaybooksConfigSchema,
   FeaturesConfigSchema,
   AtlasConfigSchema,
   createDefaultConfig,

package/src/workspace/types.ts

@@ -1,10 +1,16 @@
-import type { WorkspaceHandle, OutputSpec } from 'agent-workspace';
+import type {
+  TaskTemplate,
+  TaskComplexity,
+  SkillSpec,
+  ResourceSpec as BaseResourceSpec,
+} from 'agent-workspace';
 import type { MemorySystem, MemoryQueryResultV2 } from '../memory/system.js';
 import type { Trajectory } from '../types/index.js';
 import type { ComputeRequirements } from '../runtime/compute-provider.js';
 
 // Re-export agent-workspace types used by consumers
 export type { WorkspaceHandle, OutputSpec, OutputFileSpec, ValidationResult } from 'agent-workspace';
+export type { TaskTemplate, TaskComplexity, SkillSpec, TaskRunner, TaskResult, AgentBackend, AgentSpawnConfig, AgentResult, TaskRunnerHooks, TaskRunnerConfig } from 'agent-workspace';
 
 // ============================================================
 // Agent Skills
@@ -12,13 +18,9 @@ export type { WorkspaceHandle, OutputSpec, OutputFileSpec, ValidationResult } fr
 
 /**
  * Skill to load into workspace skills/ directory.
- * Agent Skills open standard format (SKILL.md).
+ * Extends agent-workspace's SkillSpec with source tracking.
  */
-export interface AgentSkillSpec {
-  /** Skill directory name */
-  name: string;
-  /** SKILL.md content */
-  content: string;
+export interface AgentSkillSpec extends SkillSpec {
   /** Source of this skill */
   source: 'playbook-conversion' | 'curated' | 'extracted';
 }
@@ -29,14 +31,9 @@ export interface AgentSkillSpec {
 
 /**
  * Supplementary resource to load into workspace resources/ directory.
+ * Extends agent-workspace's ResourceSpec with description.
  */
-export interface ResourceSpec {
-  /** Path relative to resources/ directory */
-  path: string;
-  /** How to populate this resource */
-  type: 'directory' | 'file' | 'symlink';
-  /** Source path (for symlink/copy) or content (for file) */
-  source: string;
+export interface ResourceSpec extends BaseResourceSpec {
   /** Description for the agent */
   description?: string;
 }
@@ -46,13 +43,9 @@ export interface ResourceSpec {
 // ============================================================
 
 /**
- * Complexity level determines whether to use heuristic or agentic analysis.
+ * Backward-compatible alias for agent-workspace's TaskComplexity.
  */
-export type AnalysisComplexity =
-  | 'heuristic'    // Use heuristicFallback(), no agent needed
-  | 'lightweight'  // Agent with small budget, simple workspace
-  | 'standard'     // Agent with moderate budget, full workspace
-  | 'thorough';    // Agent with large budget, full workspace, more time
+export type AnalysisComplexity = TaskComplexity;
 
 // ============================================================
 // Processing Context
@@ -81,34 +74,14 @@ export interface ProcessingContext {
 /**
  * Declarative recipe for an agentic analysis task.
  *
+ * Extends agent-workspace's TaskTemplate with cognitive-core-specific hooks
+ * for memory injection, output processing, and compute requirements.
+ *
  * TInput: the typed input data for this analysis
  * TOutput: the typed output the agent produces
  */
-export interface AgenticTaskTemplate<TInput, TOutput> {
-  /** Unique identifier for this task type */
-  taskType: string;
-
-  /** Domain for knowledge injection and meta-learning */
-  domain: string;
-
-  /** Human-readable description */
-  description: string;
-
-  // === WORKSPACE SETUP ===
-
-  /**
-   * Prepare the workspace filesystem from typed input.
-   * Uses the WorkspaceHandle to write input files via typed I/O methods.
-   */
-  prepareWorkspace(input: TInput, handle: WorkspaceHandle): Promise<void>;
-
-  /**
-   * Build the task description for the agent.
-   * Natural language prompt explaining what to do and what output to produce.
-   */
-  buildTaskPrompt(input: TInput): string;
-
-  // === SKILLS ===
+export interface AgenticTaskTemplate<TInput, TOutput> extends TaskTemplate<TInput, TOutput> {
+  // === SKILLS (override with source tracking) ===
 
   /**
    * Skills to load into the workspace skills/ directory.
@@ -116,14 +89,14 @@ export interface AgenticTaskTemplate<TInput, TOutput> {
    */
   getSkills(input: TInput): AgentSkillSpec[];
 
-  // === RESOURCES ===
+  // === RESOURCES (override with description) ===
 
   /**
    * Supplementary resources for the workspace resources/ directory.
    */
   getResources(input: TInput): ResourceSpec[];
 
-  // === KNOWLEDGE ===
+  // === KNOWLEDGE (cognitive-core extension) ===
 
   /**
    * Additional memory queries beyond the automatic domain-scoped query.
@@ -133,17 +106,7 @@ export interface AgenticTaskTemplate<TInput, TOutput> {
     memory: MemorySystem
   ): Promise<MemoryQueryResultV2>;
 
-  // === OUTPUT ===
-
-  /** Configuration defining the expected output shape */
-  outputConfig: OutputSpec;
-
-  /**
-   * Read and validate agent output from workspace.
-   * Uses the WorkspaceHandle to read output via typed I/O methods.
-   * Returns typed output or throws if validation fails.
-   */
-  collectOutput(handle: WorkspaceHandle): Promise<TOutput>;
+  // === OUTPUT PROCESSING (cognitive-core extension) ===
 
   /**
    * Process the validated output — store results, accumulate for batch learning, etc.
@@ -154,31 +117,12 @@ export interface AgenticTaskTemplate<TInput, TOutput> {
     context: ProcessingContext
   ): Promise<void>;
 
-  // === COMPLEXITY ASSESSMENT ===
-
-  /**
-   * Assess whether this input needs agentic analysis or heuristic fallback.
-   */
-  assessComplexity(input: TInput): AnalysisComplexity;
-
-  /**
-   * Heuristic fallback for simple cases.
-   * Called when assessComplexity returns 'heuristic'.
-   */
-  heuristicFallback?(input: TInput): Promise<TOutput>;
-
   // === CONFIGURATION ===
 
-  /** Agent type to spawn (default: 'claude-code') */
-  agentType?: string;
-
-  /** Timeout for the analysis agent (default: 120_000ms) */
-  timeout?: number;
-
   /** Whether to capture detailed tool calls (default: true) */
   captureToolCalls?: boolean;
 
-  // === COMPUTE ===
+  // === COMPUTE (cognitive-core extension) ===
 
   /**
    * Static compute requirements for this template.

package/tests/integration/curated-sources-e2e.test.ts

@@ -0,0 +1,502 @@
+/**
+ * Integration test: Curated playbook sources (local + git)
+ *
+ * Verifies the full flow from Atlas config → source resolution → playbook
+ * loading → search/retrieval. Uses real git repos, real SQLite, no mocks.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Atlas, createAtlas } from '../../src/atlas.js';
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { existsSync } from 'node:fs';
+
+const execFile = promisify(execFileCb);
+
+/**
+ * Helper: create a local bare git repo with playbook JSON files.
+ */
+async function createGitPlaybookRepo(
+  baseDir: string,
+  playbooks: Array<{
+    name: string;
+    domain: string;
+    situation: string;
+    confidence?: number;
+  }>,
+  opts?: { subdir?: string; manifest?: boolean; tag?: string },
+): Promise<string> {
+  const repoDir = join(baseDir, `bare-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`);
+  await mkdir(repoDir);
+  await execFile('git', ['init', '--bare', repoDir]);
+
+  const workDir = join(baseDir, `work-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`);
+  await mkdir(workDir);
+  await execFile('git', ['clone', repoDir, workDir]);
+  await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+
+  const subdir = opts?.subdir ?? 'playbooks';
+  const pbDir = join(workDir, subdir);
+  await mkdir(pbDir, { recursive: true });
+
+  for (const pb of playbooks) {
+    await writeFile(
+      join(pbDir, `${pb.name}.json`),
+      JSON.stringify({
+        name: pb.name,
+        applicability: {
+          situations: [pb.situation],
+          triggers: [`${pb.name} trigger`],
+          domains: [pb.domain],
+        },
+        guidance: {
+          strategy: `Strategy for ${pb.name}`,
+          tactics: [`Tactic 1 for ${pb.name}`, `Tactic 2 for ${pb.name}`],
+        },
+        verification: {
+          successIndicators: [`${pb.name} succeeds`],
+          failureIndicators: [`${pb.name} fails`],
+        },
+        confidence: pb.confidence ?? 0.8,
+        curatedBy: 'integration-test',
+      }),
+    );
+  }
+
+  if (opts?.manifest) {
+    await writeFile(
+      join(workDir, 'cognitive-core.json'),
+      JSON.stringify({ playbooks: subdir, name: 'test-source' }),
+    );
+  }
+
+  await execFile('git', ['add', '.'], { cwd: workDir });
+  await execFile('git', ['commit', '-m', 'Add playbooks'], {
+    cwd: workDir,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 'test@test.com',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 'test@test.com',
+    },
+  });
+  await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+
+  if (opts?.tag) {
+    await execFile('git', ['tag', opts.tag], { cwd: workDir });
+    await execFile('git', ['push', 'origin', opts.tag], { cwd: workDir });
+  }
+
+  return repoDir;
+}
+
+describe('Curated sources integration', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'curated-source-e2e-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  // ========================================================================
+  // Local path sources
+  // ========================================================================
+
+  it('should load playbooks from a local path via sources[]', async () => {
+    // Create local playbooks directory
+    const localDir = join(tempDir, 'local-playbooks');
+    await mkdir(localDir);
+    await writeFile(
+      join(localDir, 'local-review.json'),
+      JSON.stringify({
+        name: 'local-review',
+        applicability: {
+          situations: ['Code review for local project'],
+          triggers: ['review needed'],
+          domains: ['code-review'],
+        },
+        guidance: {
+          strategy: 'Review code thoroughly',
+          tactics: ['Check logic', 'Check tests'],
+        },
+        confidence: 0.85,
+      }),
+    );
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [localDir],
+      },
+    });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    expect(await memory.playbooks.count()).toBe(1);
+
+    const pb = await memory.playbooks.getByName('local-review');
+    expect(pb).toBeDefined();
+    expect(pb!.provenance?.origin).toBe('curated');
+    expect(pb!.confidence).toBe(0.85);
+
+    // Should be searchable
+    const matches = await memory.playbooks.findMatching('code review');
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches[0].playbook.name).toBe('local-review');
+
+    await atlas.close();
+  });
+
+  it('should load from local source with nested subdirectories', async () => {
+    const localDir = join(tempDir, 'nested-playbooks');
+    const subA = join(localDir, 'review');
+    const subB = join(localDir, 'planning', 'deep');
+    await mkdir(subA, { recursive: true });
+    await mkdir(subB, { recursive: true });
+
+    await writeFile(join(localDir, 'root.json'), JSON.stringify({
+      name: 'root-pb',
+      applicability: { situations: ['Root'], domains: ['general'] },
+      guidance: { strategy: 'Root', tactics: ['Root tactic'] },
+    }));
+    await writeFile(join(subA, 'review.json'), JSON.stringify({
+      name: 'nested-review',
+      applicability: { situations: ['Review'], domains: ['review'] },
+      guidance: { strategy: 'Review', tactics: ['Review tactic'] },
+    }));
+    await writeFile(join(subB, 'deep-plan.json'), JSON.stringify({
+      name: 'deep-plan',
+      applicability: { situations: ['Planning'], domains: ['planning'] },
+      guidance: { strategy: 'Plan', tactics: ['Plan tactic'] },
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: { sources: [localDir] },
+    });
+    await atlas.init();
+
+    expect(await atlas.getMemory().playbooks.count()).toBe(3);
+    expect(await atlas.getMemory().playbooks.getByName('root-pb')).toBeDefined();
+    expect(await atlas.getMemory().playbooks.getByName('nested-review')).toBeDefined();
+    expect(await atlas.getMemory().playbooks.getByName('deep-plan')).toBeDefined();
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Git sources
+  // ========================================================================
+
+  it('should clone a git repo source and load its playbooks', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'git-review', domain: 'review', situation: 'Git-based code review' },
+      { name: 'git-planning', domain: 'planning', situation: 'Git-based planning' },
+    ]);
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+      },
+    });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    expect(await memory.playbooks.count()).toBe(2);
+
+    const review = await memory.playbooks.getByName('git-review');
+    expect(review).toBeDefined();
+    expect(review!.provenance?.origin).toBe('curated');
+    expect(review!.provenance?.sourceFile).toMatch(/^git:/);
+    expect(review!.provenance?.curatedBy).toBe('integration-test');
+
+    const planning = await memory.playbooks.getByName('git-planning');
+    expect(planning).toBeDefined();
+
+    // Verify searchable
+    const matches = await memory.playbooks.findMatching('code review');
+    expect(matches.some(m => m.playbook.name === 'git-review')).toBe(true);
+
+    await atlas.close();
+  });
+
+  it('should clone a git repo with tag ref', async () => {
+    const repoDir = await createGitPlaybookRepo(
+      tempDir,
+      [{ name: 'tagged-pb', domain: 'ops', situation: 'Tagged release' }],
+      { tag: 'v1.0.0' },
+    );
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}#v1.0.0`],
+      },
+    });
+    await atlas.init();
+
+    expect(await atlas.getMemory().playbooks.count()).toBe(1);
+    expect(await atlas.getMemory().playbooks.getByName('tagged-pb')).toBeDefined();
+
+    await atlas.close();
+  });
+
+  it('should discover playbook dir via manifest', async () => {
+    const repoDir = await createGitPlaybookRepo(
+      tempDir,
+      [{ name: 'manifest-pb', domain: 'custom', situation: 'Custom dir via manifest' }],
+      { subdir: 'my-custom-dir', manifest: true },
+    );
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+      },
+    });
+    await atlas.init();
+
+    expect(await atlas.getMemory().playbooks.count()).toBe(1);
+    expect(await atlas.getMemory().playbooks.getByName('manifest-pb')).toBeDefined();
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Mixed sources + bundled seed pack
+  // ========================================================================
+
+  it('should load from bundled + git + local sources simultaneously', async () => {
+    // Git source
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'git-pb', domain: 'git-domain', situation: 'From git' },
+    ]);
+
+    // Local source
+    const localDir = join(tempDir, 'local-source');
+    await mkdir(localDir);
+    await writeFile(join(localDir, 'local.json'), JSON.stringify({
+      name: 'local-pb',
+      applicability: { situations: ['From local'], domains: ['local-domain'] },
+      guidance: { strategy: 'Local', tactics: ['Local tactic'] },
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        loadBundledSeedPack: true,
+        sources: [`git:${repoDir}`, localDir],
+      },
+    });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    const count = await memory.playbooks.count();
+    expect(count).toBe(27); // 25 bundled + 1 git + 1 local
+
+    expect(await memory.playbooks.getByName('git-pb')).toBeDefined();
+    expect(await memory.playbooks.getByName('local-pb')).toBeDefined();
+    expect(await memory.playbooks.getByName('review-orchestration')).toBeDefined(); // from bundled
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Persistence across restarts
+  // ========================================================================
+
+  it('should skip re-cloning on second init when SHA unchanged', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'persist-pb', domain: 'persist', situation: 'Persisted' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+    const config = {
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+      },
+    };
+
+    // First init — clones and loads
+    const atlas1 = createAtlas(config);
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(1);
+    await atlas1.close();
+
+    // Second init — should use cached SHA, skip reload
+    // Playbooks are already in SQLite from first init
+    const atlas2 = createAtlas(config);
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(1);
+
+    const pb = await atlas2.getMemory().playbooks.getByName('persist-pb');
+    expect(pb).toBeDefined();
+
+    await atlas2.close();
+  });
+
+  it('should detect new commits and reload on next init', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'original-pb', domain: 'evolve', situation: 'Original version' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+    const config = {
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+        cache: { maxAgeMs: 0 }, // always stale → always re-fetch
+        recreateOnInit: true,   // reload when updated
+      },
+    };
+
+    // First init
+    const atlas1 = createAtlas(config);
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(1);
+    await atlas1.close();
+
+    // Push a new playbook to the repo
+    const workDir = join(tempDir, 'update-work');
+    await mkdir(workDir);
+    await execFile('git', ['clone', repoDir, workDir]);
+    await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+    await writeFile(
+      join(workDir, 'playbooks', 'new-pb.json'),
+      JSON.stringify({
+        name: 'new-pb',
+        applicability: { situations: ['Newly added'], domains: ['evolve'] },
+        guidance: { strategy: 'New', tactics: ['New tactic'] },
+      }),
+    );
+    await execFile('git', ['add', '.'], { cwd: workDir });
+    await execFile('git', ['commit', '-m', 'Add new playbook'], {
+      cwd: workDir,
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    });
+    await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+
+    // Second init — should detect new SHA and reload
+    const atlas2 = createAtlas(config);
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(2);
+    expect(await atlas2.getMemory().playbooks.getByName('original-pb')).toBeDefined();
+    expect(await atlas2.getMemory().playbooks.getByName('new-pb')).toBeDefined();
+    await atlas2.close();
+  });
+
+  // ========================================================================
+  // Per-source recreate isolation
+  // ========================================================================
+
+  it('should recreate only the specified source without clobbering others', async () => {
+    const repoA = await createGitPlaybookRepo(tempDir, [
+      { name: 'source-a-pb', domain: 'a', situation: 'From source A' },
+    ]);
+    const repoB = await createGitPlaybookRepo(tempDir, [
+      { name: 'source-b-pb', domain: 'b', situation: 'From source B' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+
+    // First init with both sources
+    const atlas1 = createAtlas({
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoA}`, `git:${repoB}`],
+        cache: { maxAgeMs: 0 },
+        recreateOnInit: true,
+      },
+    });
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(2);
+    await atlas1.close();
+
+    // Second init — recreate triggers per-source delete + reload
+    // Both sources should still have their playbooks
+    const atlas2 = createAtlas({
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoA}`, `git:${repoB}`],
+        cache: { maxAgeMs: 0 },
+        recreateOnInit: true,
+      },
+    });
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(2);
+    expect(await atlas2.getMemory().playbooks.getByName('source-a-pb')).toBeDefined();
+    expect(await atlas2.getMemory().playbooks.getByName('source-b-pb')).toBeDefined();
+    await atlas2.close();
+  });
+
+  // ========================================================================
+  // Cache directory structure
+  // ========================================================================
+
+  it('should create cache directory under storage.baseDir', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'cache-test-pb', domain: 'cache', situation: 'Cache test' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+    const atlas = createAtlas({
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+        cache: { dir: 'my-cache' },
+      },
+    });
+    await atlas.init();
+
+    // Verify cache dir was created
+    expect(existsSync(join(atlasDir, 'my-cache'))).toBe(true);
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Error resilience
+  // ========================================================================
+
+  it('should skip invalid git source and continue with others', async () => {
+    const localDir = join(tempDir, 'fallback-local');
+    await mkdir(localDir);
+    await writeFile(join(localDir, 'ok.json'), JSON.stringify({
+      name: 'fallback-pb',
+      applicability: { situations: ['Fallback'], domains: ['test'] },
+      guidance: { strategy: 'Fallback', tactics: ['Fallback'] },
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [
+          'git:/nonexistent/repo/that/does/not/exist',
+          localDir,
+        ],
+      },
+    });
+    await atlas.init();
+
+    // Invalid git source should be skipped; local source should load
+    expect(await atlas.getMemory().playbooks.count()).toBe(1);
+    expect(await atlas.getMemory().playbooks.getByName('fallback-pb')).toBeDefined();
+
+    await atlas.close();
+  });
+});