@soleri/core 9.15.0 → 9.16.7

package/src/planning/task-complexity-assessor.test.ts

@@ -294,9 +294,4 @@ describe('assessTaskComplexity — reasoning', () => {
     const result = assess({ prompt: 'fix typo' });
     expect(result.reasoning).toContain('No complexity signals detected');
   });
-
-  it('always returns 6 signals', () => {
-    const result = assess({ prompt: 'anything' });
-    expect(result.signals).toHaveLength(6);
-  });
 });

package/src/planning/task-verifier.test.ts

@@ -25,6 +25,7 @@ describe('task-verifier', () => {
       const existing: TaskEvidence[] = [
         { criterion: 'cr1', content: 'result', type: 'description', submittedAt: 100 },
       ];
+      const before = Date.now();
       const result = createEvidence(existing, {
         criterion: 'cr2',
         content: 'output',
@@ -32,7 +33,8 @@ describe('task-verifier', () => {
       });
       expect(result).toHaveLength(2);
       expect(result[1].criterion).toBe('cr2');
-      expect(result[1].submittedAt).toBeGreaterThan(0);
+      expect(result[1].submittedAt).toBeGreaterThanOrEqual(before);
+      expect(result[1].submittedAt).toBeLessThanOrEqual(Date.now());
     });
     it('does not mutate original array', () => {
       const existing: TaskEvidence[] = [];

package/src/playbooks/generic/generic-playbooks.test.ts

@@ -181,10 +181,6 @@ describe('All generic playbooks', () => {
 // ─── Individual playbook tests ────────────────────────────────────
 
 describe('brainstormingPlaybook', () => {
-  it('should have correct id', () => {
-    expect(brainstormingPlaybook.id).toBe('generic-brainstorming');
-  });
-
   it('should match BUILD and PLAN intents', () => {
     expect(brainstormingPlaybook.matchIntents).toContain('BUILD');
     expect(brainstormingPlaybook.matchIntents).toContain('PLAN');
@@ -221,10 +217,6 @@ describe('brainstormingPlaybook', () => {
 });
 
 describe('codeReviewPlaybook', () => {
-  it('should have correct id', () => {
-    expect(codeReviewPlaybook.id).toBe('generic-code-review');
-  });
-
   it('should match REVIEW intent only', () => {
     expect(codeReviewPlaybook.matchIntents).toEqual(['REVIEW']);
   });
@@ -260,10 +252,6 @@ describe('codeReviewPlaybook', () => {
 });
 
 describe('onboardingPlaybook', () => {
-  it('should have correct id', () => {
-    expect(onboardingPlaybook.id).toBe('generic-onboarding');
-  });
-
   it('should match PLAN intent', () => {
     expect(onboardingPlaybook.matchIntents).toContain('PLAN');
   });
@@ -288,10 +276,6 @@ describe('onboardingPlaybook', () => {
 });
 
 describe('subagentExecutionPlaybook', () => {
-  it('should have correct id', () => {
-    expect(subagentExecutionPlaybook.id).toBe('generic-subagent-execution');
-  });
-
   it('should match BUILD and IMPROVE intents', () => {
     expect(subagentExecutionPlaybook.matchIntents).toContain('BUILD');
     expect(subagentExecutionPlaybook.matchIntents).toContain('IMPROVE');
@@ -314,10 +298,6 @@ describe('subagentExecutionPlaybook', () => {
 });
 
 describe('systematicDebuggingPlaybook', () => {
-  it('should have correct id', () => {
-    expect(systematicDebuggingPlaybook.id).toBe('generic-systematic-debugging');
-  });
-
   it('should match FIX intent only', () => {
     expect(systematicDebuggingPlaybook.matchIntents).toEqual(['FIX']);
   });
@@ -361,10 +341,6 @@ describe('systematicDebuggingPlaybook', () => {
 });
 
 describe('tddPlaybook', () => {
-  it('should have correct id', () => {
-    expect(tddPlaybook.id).toBe('generic-tdd');
-  });
-
   it('should match BUILD and FIX intents', () => {
     expect(tddPlaybook.matchIntents).toContain('BUILD');
     expect(tddPlaybook.matchIntents).toContain('FIX');
@@ -399,10 +375,6 @@ describe('tddPlaybook', () => {
 });
 
 describe('verificationPlaybook', () => {
-  it('should have correct id', () => {
-    expect(verificationPlaybook.id).toBe('generic-verification');
-  });
-
   it('should match BUILD, FIX, IMPROVE, and DELIVER intents', () => {
     expect(verificationPlaybook.matchIntents).toContain('BUILD');
     expect(verificationPlaybook.matchIntents).toContain('FIX');

package/src/playbooks/index.test.ts

@@ -9,61 +9,6 @@ import { describe, it, expect } from 'vitest';
 import * as playbooksModule from './index.js';
 
 describe('playbooks barrel export', () => {
-  it('should export getBuiltinPlaybook function', () => {
-    expect(typeof playbooksModule.getBuiltinPlaybook).toBe('function');
-  });
-
-  it('should export getAllBuiltinPlaybooks function', () => {
-    expect(typeof playbooksModule.getAllBuiltinPlaybooks).toBe('function');
-  });
-
-  it('should export scorePlaybook function', () => {
-    expect(typeof playbooksModule.scorePlaybook).toBe('function');
-  });
-
-  it('should export mergePlaybooks function', () => {
-    expect(typeof playbooksModule.mergePlaybooks).toBe('function');
-  });
-
-  it('should export matchPlaybooks function', () => {
-    expect(typeof playbooksModule.matchPlaybooks).toBe('function');
-  });
-
-  it('should export playbookDefinitionToEntry function', () => {
-    expect(typeof playbooksModule.playbookDefinitionToEntry).toBe('function');
-  });
-
-  it('should export entryToPlaybookDefinition function', () => {
-    expect(typeof playbooksModule.entryToPlaybookDefinition).toBe('function');
-  });
-
-  it('should export seedDefaultPlaybooks function', () => {
-    expect(typeof playbooksModule.seedDefaultPlaybooks).toBe('function');
-  });
-
-  it('should export PlaybookExecutor class', () => {
-    expect(typeof playbooksModule.PlaybookExecutor).toBe('function');
-    const executor = new playbooksModule.PlaybookExecutor();
-    expect(executor).toBeInstanceOf(playbooksModule.PlaybookExecutor);
-  });
-
-  it('should not export unexpected runtime values', () => {
-    const expectedExports = [
-      'getBuiltinPlaybook',
-      'getAllBuiltinPlaybooks',
-      'scorePlaybook',
-      'mergePlaybooks',
-      'matchPlaybooks',
-      'playbookDefinitionToEntry',
-      'entryToPlaybookDefinition',
-      'seedDefaultPlaybooks',
-      'PlaybookExecutor',
-    ];
-
-    const actualExports = Object.keys(playbooksModule);
-    expect(actualExports.sort()).toEqual(expectedExports.sort());
-  });
-
   it('should return playbooks from getAllBuiltinPlaybooks via barrel', () => {
     const playbooks = playbooksModule.getAllBuiltinPlaybooks();
     expect(playbooks.length).toBeGreaterThanOrEqual(6);

package/src/playbooks/playbook-executor.test.ts

@@ -217,6 +217,82 @@ describe('PlaybookExecutor', () => {
       const result = executor.complete(sessionId);
       expect('error' in result).toBe(true);
     });
+
+    // ── evidence source ──────────────────────────────────────────────
+
+    describe('evidence source', () => {
+      function makePlaybookWithUserGate(): PlaybookDefinition {
+        return makePlaybook({
+          gates: [
+            {
+              phase: 'completion',
+              requirement: 'User confirmed result',
+              checkType: 'user-confirm',
+              requiresUserEvidence: true,
+            },
+          ],
+        });
+      }
+
+      it('agent-source evidence fails a requiresUserEvidence gate', () => {
+        const { sessionId, totalSteps } = executor.start(makePlaybookWithUserGate());
+        for (let i = 0; i < totalSteps; i++) executor.step(sessionId);
+
+        const result = executor.complete(sessionId, {
+          gateResults: { 'user-confirm': { satisfied: true, source: 'agent' } },
+        });
+
+        expect('error' in result).toBe(false);
+        if ('error' in result) return;
+
+        expect(result.gatesPassed).toBe(false);
+        expect(result.unsatisfiedGates[0]).toContain('user-confirm');
+        expect(result.unsatisfiedGates[0]).toContain('requires user confirmation');
+      });
+
+      it('user-source evidence satisfies a requiresUserEvidence gate', () => {
+        const { sessionId, totalSteps } = executor.start(makePlaybookWithUserGate());
+        for (let i = 0; i < totalSteps; i++) executor.step(sessionId);
+
+        const result = executor.complete(sessionId, {
+          gateResults: { 'user-confirm': { satisfied: true, source: 'user' } },
+        });
+
+        expect('error' in result).toBe(false);
+        if ('error' in result) return;
+
+        expect(result.gatesPassed).toBe(true);
+        expect(result.unsatisfiedGates).toHaveLength(0);
+      });
+
+      it('plain boolean true satisfies a gate without requiresUserEvidence', () => {
+        const { sessionId, totalSteps } = executor.start(makePlaybook());
+        for (let i = 0; i < totalSteps; i++) executor.step(sessionId);
+
+        const result = executor.complete(sessionId, {
+          gateResults: { 'test-pass': true },
+        });
+
+        expect('error' in result).toBe(false);
+        if ('error' in result) return;
+        expect(result.gatesPassed).toBe(true);
+      });
+
+      it('plain boolean true does not satisfy a requiresUserEvidence gate', () => {
+        const { sessionId, totalSteps } = executor.start(makePlaybookWithUserGate());
+        for (let i = 0; i < totalSteps; i++) executor.step(sessionId);
+
+        // bare true = no source = treated as agent
+        const result = executor.complete(sessionId, {
+          gateResults: { 'user-confirm': true },
+        });
+
+        expect('error' in result).toBe(false);
+        if ('error' in result) return;
+        expect(result.gatesPassed).toBe(false);
+        expect(result.unsatisfiedGates[0]).toContain('requires user confirmation');
+      });
+    });
   });
 
   // ─── getSession / listSessions ──────────────────────────────────

package/src/playbooks/playbook-executor.ts

@@ -72,6 +72,16 @@ export interface CompleteResult {
   duration: number;
 }
 
+/**
+ * Evidence record for a gate result.
+ * `source` distinguishes agent-collected evidence from explicit user confirmation.
+ */
+export interface GateEvidence {
+  satisfied: boolean;
+  /** Who produced the evidence. Defaults to 'agent' when omitted. */
+  source?: 'agent' | 'user';
+}
+
 // =============================================================================
 // STEP PARSER
 // =============================================================================
@@ -227,7 +237,7 @@ export class PlaybookExecutor {
    */
   complete(
     sessionId: string,
-    options?: { abort?: boolean; gateResults?: Record<string, boolean> },
+    options?: { abort?: boolean; gateResults?: Record<string, boolean | GateEvidence> },
   ): CompleteResult | { error: string } {
     const session = this.sessions.get(sessionId);
     if (!session) return { error: `Session not found: ${sessionId}` };
@@ -251,8 +261,19 @@ export class PlaybookExecutor {
     const completionGates = session.gates.filter((g) => g.phase === 'completion');
     const unsatisfiedGates: string[] = [];
     for (const gate of completionGates) {
-      if (!gateResults[gate.checkType]) {
-        unsatisfiedGates.push(`${gate.checkType}: ${gate.requirement}`);
+      const raw = gateResults[gate.checkType];
+      const evidence: GateEvidence =
+        typeof raw === 'object' && raw !== null ? raw : { satisfied: !!raw, source: 'agent' };
+
+      const satisfied =
+        evidence.satisfied && !(gate.requiresUserEvidence && evidence.source !== 'user');
+
+      if (!satisfied) {
+        const reason =
+          gate.requiresUserEvidence && evidence.satisfied && evidence.source !== 'user'
+            ? `${gate.checkType}: ${gate.requirement} (requires user confirmation)`
+            : `${gate.checkType}: ${gate.requirement}`;
+        unsatisfiedGates.push(reason);
       }
     }
 

package/src/playbooks/playbook-types.ts

@@ -48,6 +48,14 @@ export interface PlaybookGate {
   requirement: string;
   /** Check type to create/validate */
   checkType: string;
+  /** Whether this gate blocks progression (blocking) or is advisory only (advisory). Defaults to 'blocking'. */
+  severity?: 'blocking' | 'advisory';
+  /**
+   * When true, only user-sourced evidence satisfies this gate.
+   * Agent-collected evidence (e.g. automated test runs) does not count.
+   * Defaults to false.
+   */
+  requiresUserEvidence?: boolean;
 }
 
 // =============================================================================

package/src/plugins/plugin-registry.test.ts

@@ -47,13 +47,15 @@ describe('PluginRegistry — colocated', () => {
 
   describe('register', () => {
     it('registers a plugin and sets initial status to registered', () => {
+      const before = Date.now();
       const loaded = makeLoaded();
       const registered = registry.register(loaded);
 
       expect(registered.id).toBe('test-plugin');
       expect(registered.status).toBe('registered');
       expect(registered.facades).toEqual([]);
-      expect(registered.registeredAt).toBeGreaterThan(0);
+      expect(registered.registeredAt).toBeGreaterThanOrEqual(before);
+      expect(registered.registeredAt).toBeLessThanOrEqual(Date.now());
     });
 
     it('throws when registering duplicate id', () => {
@@ -86,11 +88,13 @@ describe('PluginRegistry — colocated', () => {
         }),
       });
 
+      const before = Date.now();
       registry.register(loaded);
       const result = await registry.activate('test-plugin', makeContext(loaded));
 
       expect(result.status).toBe('active');
-      expect(result.activatedAt).toBeGreaterThan(0);
+      expect(result.activatedAt).toBeGreaterThanOrEqual(before);
+      expect(result.activatedAt).toBeLessThanOrEqual(Date.now());
       expect(result.facades).toHaveLength(1);
       expect(result.facades[0].name).toBe('my_facade');
       expect(result.facades[0].ops).toHaveLength(2);

package/src/project/project-registry.test.ts

@@ -214,10 +214,12 @@ describe('ProjectRegistry', () => {
 
   describe('register', () => {
     it('creates a new project and returns it', () => {
+      const before = Date.now();
       const proj = registry.register('/tmp/myproj', 'My Project');
       expect(proj.path).toBe('/tmp/myproj');
       expect(proj.name).toBe('My Project');
       expect(proj.id).toBeTruthy();
+      expect(proj.registeredAt).toBeGreaterThanOrEqual(before);
       expect(proj.registeredAt).toBeLessThanOrEqual(Date.now());
     });
 

package/src/queue/async-infrastructure.test.ts

@@ -104,8 +104,7 @@ describe('JobQueue', () => {
 
   it('enqueue creates a job and returns ID', () => {
     const id = queue.enqueue('tag-normalize', { entryId: 'e1' });
-    expect(id).toBeTruthy();
-    expect(id.length).toBeGreaterThan(0);
+    expect(id).toHaveLength(12);
   });
 
   it('dequeue returns oldest pending job', () => {
@@ -200,16 +199,18 @@ describe('JobQueue', () => {
 
   it('getStats returns correct counts', () => {
     const stats = queue.getStats();
-    expect(stats.total).toBeGreaterThan(0);
+    expect(typeof stats.total).toBe('number');
     expect(typeof stats.pending).toBe('number');
     expect(typeof stats.running).toBe('number');
     expect(typeof stats.completed).toBe('number');
     expect(typeof stats.failed).toBe('number');
+    expect(stats.total).toBe(stats.pending + stats.running + stats.completed + stats.failed);
   });
 
   it('purge removes old completed/failed jobs', () => {
     // purge with 0 days should remove all completed/failed
     const purged = queue.purge(0);
+    expect(typeof purged).toBe('number');
     expect(purged).toBeGreaterThanOrEqual(0);
   });
 });
@@ -275,7 +276,8 @@ describe('PipelineRunner', () => {
     const status = runner.getStatus();
     expect(status.running).toBe(false); // Not started yet
     expect(status.pollIntervalMs).toBe(100);
-    expect(status.jobsProcessed).toBeGreaterThanOrEqual(1);
+    // At this point: process-test succeeded = 1 processed; flaky-type threw so it's retried, not counted
+    expect(status.jobsProcessed).toBe(1);
   });
 
   it('start/stop controls background polling', async () => {

package/src/queue/job-queue.test.ts

@@ -131,11 +131,14 @@ describe('JobQueue', () => {
     queue = new JobQueue(provider);
   });
 
-  it('initializes the table on construction', () => {
-    expect(provider.execSql).toHaveBeenCalledTimes(1);
-    expect((provider.execSql as ReturnType<typeof vi.fn>).mock.calls[0][0]).toContain(
-      'CREATE TABLE IF NOT EXISTS job_queue',
-    );
+  it('initializes the job_queue table on construction', () => {
+    // Verify the correct DDL was executed — not just that something was called
+    const ddl = (provider.execSql as ReturnType<typeof vi.fn>).mock.calls[0]?.[0] as
+      | string
+      | undefined;
+    expect(ddl).toContain('CREATE TABLE IF NOT EXISTS job_queue');
+    expect(ddl).toContain('status');
+    expect(ddl).toContain('retry_count');
   });
 
   describe('enqueue', () => {
@@ -281,7 +284,8 @@ describe('JobQueue', () => {
       queue.dequeue();
       queue.complete(id);
       const stats = queue.getStats();
-      expect(stats.total).toBeGreaterThan(0);
+      expect(stats.total).toBe(stats.pending + stats.running + stats.completed + stats.failed);
+      expect(stats.completed).toBeGreaterThanOrEqual(1);
     });
   });
 
@@ -321,7 +325,9 @@ describe('JobQueue', () => {
       queue.complete(id1);
       queue.fail(id2, 'err');
       const deleted = queue.purge(30);
-      expect(deleted).toBeGreaterThanOrEqual(0);
+      // The mock purges all completed/failed — 2 were just created
+      expect(typeof deleted).toBe('number');
+      expect(deleted).toBeGreaterThanOrEqual(2);
     });
   });
 });

package/src/runtime/admin-extra-ops.test.ts

@@ -95,19 +95,6 @@ describe('createAdminExtraOps', () => {
     ops = createAdminExtraOps(runtime);
   });
 
-  it('returns at least 24 ops', () => {
-    expect(ops.length).toBeGreaterThanOrEqual(24);
-  });
-
-  it('all ops have name, description, auth, and handler', () => {
-    for (const op of ops) {
-      expect(op.name).toBeTruthy();
-      expect(op.description).toBeTruthy();
-      expect(['read', 'write', 'admin']).toContain(op.auth);
-      expect(typeof op.handler).toBe('function');
-    }
-  });
-
   describe('admin_telemetry', () => {
     it('returns telemetry stats', async () => {
       const result = await findOp(ops, 'admin_telemetry').handler({});
@@ -441,7 +428,7 @@ describe('createAdminExtraOps', () => {
         subsystem: 'nonexistent',
       })) as Record<string, unknown>;
       expect(result.error).toContain('Unknown subsystem');
-      expect(result.available).toBeDefined();
+      expect(result.available).toEqual(['vault', 'brain']); // keys from mock snapshot.subsystems
     });
   });
 
@@ -481,33 +468,51 @@ describe('createAdminExtraOps', () => {
   });
 
   describe('admin_persistence_info', () => {
-    it('returns backend and table counts', async () => {
-      const result = (await findOp(ops, 'admin_persistence_info').handler({})) as Record<
-        string,
-        unknown
-      >;
+    it('returns backend and table counts for each known table', async () => {
+      const result = (await findOp(ops, 'admin_persistence_info').handler({})) as {
+        backend: string;
+        tables: Record<string, number>;
+      };
       expect(result.backend).toBe('sqlite');
-      expect(result.tables).toBeDefined();
+      // Mock provider.get returns { count: 42 } for every table
+      expect(result.tables).toEqual({
+        entries: 42,
+        entries_archive: 42,
+        memories: 42,
+        projects: 42,
+        brain_vocabulary: 42,
+        brain_feedback: 42,
+      });
     });
   });
 
   describe('admin_setup_check', () => {
-    it('returns readiness with per-subsystem checks', async () => {
-      const result = (await findOp(ops, 'admin_setup_check').handler({})) as Record<
-        string,
-        unknown
-      >;
+    it('returns ready: true with vault, brain, llm, and health checks all passing', async () => {
+      const result = (await findOp(ops, 'admin_setup_check').handler({})) as {
+        agentId: string;
+        ready: boolean;
+        checks: Record<string, { ok: boolean }>;
+      };
       expect(result.agentId).toBe('test-agent');
-      expect(result.checks).toBeDefined();
-      expect(typeof result.ready).toBe('boolean');
+      expect(result.ready).toBe(true);
+      expect(result.checks.vault.ok).toBe(true);
+      expect(result.checks.brain.ok).toBe(true);
+      expect(result.checks.llm.ok).toBe(true);
     });
   });
 
   describe('admin_setup_run', () => {
-    it('runs setup actions', async () => {
-      const result = (await findOp(ops, 'admin_setup_run').handler({})) as Record<string, unknown>;
+    it('runs all three setup actions and returns their names', async () => {
+      const result = (await findOp(ops, 'admin_setup_run').handler({})) as {
+        setup: boolean;
+        actions: string[];
+      };
       expect(result.setup).toBe(true);
-      expect((result.actions as string[]).length).toBeGreaterThan(0);
+      expect(result.actions).toEqual([
+        'brain_vocabulary_rebuilt',
+        'fts_index_rebuilt',
+        'templates_reloaded',
+      ]);
     });
   });
 });

package/src/runtime/admin-extra-ops.ts

@@ -849,5 +849,35 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
         };
       },
     },
+    {
+      name: 'worktree_status',
+      description: 'List stale .claude/worktrees/ entries without removing them.',
+      auth: 'read' as const,
+      schema: z.object({
+        projectPath: z.string().optional().default('.'),
+      }),
+      handler: async (params) => {
+        const { worktreeStatus } = await import('../utils/worktree-reaper.js');
+        const { resolve } = await import('node:path');
+        const projectPath = resolve((params.projectPath as string) ?? '.');
+        const status = worktreeStatus(projectPath);
+        return { ...status, projectPath };
+      },
+    },
+    {
+      name: 'worktree_reap',
+      description: 'Remove stale .claude/worktrees/ entries and prune git worktree refs.',
+      auth: 'write' as const,
+      schema: z.object({
+        projectPath: z.string().optional().default('.'),
+      }),
+      handler: async (params) => {
+        const { worktreeReap } = await import('../utils/worktree-reaper.js');
+        const { resolve } = await import('node:path');
+        const projectPath = resolve((params.projectPath as string) ?? '.');
+        const report = worktreeReap(projectPath);
+        return { ...report, projectPath };
+      },
+    },
   ];
 }

package/src/runtime/admin-ops.test.ts

@@ -70,10 +70,6 @@ describe('createAdminOps', () => {
     ops = createAdminOps(rt);
   });
 
-  it('returns ops array', () => {
-    expect(ops.length).toBeGreaterThan(0);
-  });
-
   // ─── admin_health ─────────────────────────────────────────────
 
   describe('admin_health', () => {