@soleri/core 9.14.4 → 9.16.7

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', () => {

package/src/runtime/admin-ops.ts

@@ -5,8 +5,9 @@
  * runtime state. No new modules needed — uses existing runtime parts.
  */
 
-import { readFileSync, statSync } from 'node:fs';
+import { readFileSync, statSync, existsSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
@@ -147,20 +148,21 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           };
         }
         // Fallback — just describe admin ops
+        const adminOps = [
+          'admin_health',
+          'admin_tool_list',
+          'admin_config',
+          'admin_vault_size',
+          'admin_uptime',
+          'admin_version',
+          'admin_reset_cache',
+          'admin_diagnostic',
+        ];
         return {
-          count: 8,
-          ops: {
-            admin: [
-              'admin_health',
-              'admin_tool_list',
-              'admin_config',
-              'admin_vault_size',
-              'admin_uptime',
-              'admin_version',
-              'admin_reset_cache',
-              'admin_diagnostic',
-            ],
-          },
+          count: adminOps.length,
+          scope: 'admin-only',
+          note: 'Pass _allOps for full system op count',
+          ops: { admin: adminOps },
           routing: buildRoutingHints(),
         };
       },
@@ -380,7 +382,7 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           });
         }
 
-        // 7. Skills
+        // 7. Skills — check discovered vs registered in .claude/skills/
         try {
           const agentDir = runtime.config.agentDir;
           const skillsDirs = agentDir ? [join(agentDir, 'skills')] : [];
@@ -388,12 +390,52 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           const installedPacks = packInstaller.list();
           const packSkillCount = installedPacks.reduce((sum, p) => sum + p.skills.length, 0);
           const totalSkills = agentSkills.length + packSkillCount;
-          const skillStatus = totalSkills > 0 ? 'ok' : agentDir ? 'warn' : 'ok';
-          checks.push({
-            name: 'skills',
-            status: skillStatus,
-            detail: `${totalSkills} skills (${agentSkills.length} agent, ${packSkillCount} pack)`,
-          });
+
+          // Check registration status in .claude/skills/
+          const claudeSkillsDir = join(homedir(), '.claude', 'skills');
+          let registeredCount = 0;
+          let brokenCount = 0;
+          const unregistered: string[] = [];
+
+          if (existsSync(claudeSkillsDir)) {
+            try {
+              const registered = readdirSync(claudeSkillsDir, { withFileTypes: true });
+              registeredCount = registered.length;
+              for (const entry of registered) {
+                if (entry.isSymbolicLink()) {
+                  try {
+                    statSync(join(claudeSkillsDir, entry.name));
+                  } catch {
+                    brokenCount++;
+                  }
+                }
+              }
+            } catch {
+              // Can't read .claude/skills/ — skip registration check
+            }
+          }
+
+          for (const skill of agentSkills) {
+            const skillRegisteredDir = join(claudeSkillsDir, skill.name);
+            if (!existsSync(skillRegisteredDir)) {
+              unregistered.push(skill.name);
+            }
+          }
+
+          const hasIssues = unregistered.length > 0 || brokenCount > 0;
+          // Warn only when agentDir is set but no skills exist anywhere (local OR global)
+          const hasAnySkills = totalSkills > 0 || registeredCount > 0;
+          const skillStatus = !hasAnySkills && agentDir ? 'warn' : hasIssues ? 'warn' : 'ok';
+          const detail = [
+            `${totalSkills} discovered (${agentSkills.length} agent, ${packSkillCount} pack)`,
+            `${registeredCount} registered in .claude/skills/`,
+            ...(unregistered.length > 0
+              ? [`${unregistered.length} unregistered: ${unregistered.join(', ')}`]
+              : []),
+            ...(brokenCount > 0 ? [`${brokenCount} broken links`] : []),
+          ].join(' — ');
+
+          checks.push({ name: 'skills', status: skillStatus, detail });
         } catch (err) {
           checks.push({
             name: 'skills',