@soleri/core 9.15.0 → 9.16.7

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

@@ -134,18 +134,6 @@ describe('createPlanningExtraOps', () => {
     ops = createPlanningExtraOps(runtime);
   });
 
-  it('returns expected op count', () => {
-    expect(ops.length).toBeGreaterThanOrEqual(22);
-  });
-
-  it('all ops have required fields', () => {
-    for (const op of ops) {
-      expect(op.name).toBeTruthy();
-      expect(op.handler).toBeDefined();
-      expect(['read', 'write', 'admin']).toContain(op.auth);
-    }
-  });
-
   describe('plan_iterate', () => {
     it('iterates a draft plan', async () => {
       const result = (await findOp(ops, 'plan_iterate').handler({
@@ -460,7 +448,7 @@ describe('createPlanningExtraOps', () => {
         intent: 'BUILD',
       })) as Record<string, unknown>;
       expect(result.matched).toBe(true);
-      expect(result.sections).toBeDefined();
+      expect(result.sections).toEqual(['design', 'scope', 'tokens']); // generic + domain brainstorm sections
     });
 
     it('returns not-matched when no playbook fits', async () => {
@@ -498,7 +486,7 @@ describe('createPlanningExtraOps', () => {
         planId: 'plan-1',
       })) as Record<string, unknown>;
       expect(result.planId).toBe('plan-1');
-      expect(result.taskMetrics).toBeDefined();
+      expect(result.taskMetrics).toHaveLength(1); // mock plan has exactly 1 task
     });
 
     it('returns error for missing plan', async () => {

package/src/runtime/playbook-ops-execution.test.ts

@@ -26,15 +26,6 @@ describe('playbook execution ops', () => {
     ops = createPlaybookOps(runtime);
   }
 
-  it('should return 8 ops total', () => {
-    setup();
-    expect(ops).toHaveLength(8);
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('playbook_start');
-    expect(names).toContain('playbook_step');
-    expect(names).toContain('playbook_complete');
-  });
-
   // ─── playbook_start ─────────────────────────────────────────────
 
   describe('playbook_start', () => {
@@ -46,7 +37,7 @@ describe('playbook execution ops', () => {
 
       expect(result.sessionId).toMatch(/^pbk-/);
       expect(result.label).toBe('Test-Driven Development');
-      expect(result.totalSteps).toBeGreaterThan(0);
+      expect(result.totalSteps).toBe(4); // TDD playbook has 4 steps: RED, GREEN, REFACTOR, VERIFY
     });
 
     it('should start by intent auto-match', async () => {
@@ -57,7 +48,7 @@ describe('playbook execution ops', () => {
       })) as { sessionId: string; label: string };
 
       expect(result.sessionId).toMatch(/^pbk-/);
-      expect(result.label).toBeDefined();
+      expect(result.label).toBe('Test-Driven Development'); // BUILD + "tests" triggers TDD playbook
     });
 
     it('should return error for unknown playbookId', async () => {
@@ -69,21 +60,19 @@ describe('playbook execution ops', () => {
       expect(result.error).toContain('not found');
     });
 
-    it('should return available playbooks when no match', async () => {
+    it('should start Verification playbook for DELIVER intent', async () => {
       setup();
       const result = (await findOp('playbook_start').handler({
         intent: 'DELIVER',
         text: 'something very obscure with no keyword matches',
-      })) as { error: string; available: Array<{ id: string }> };
+      })) as { sessionId: string; label: string };
 
-      // May or may not match — if error, should list available
-      if (result.error) {
-        expect(result.available).toBeDefined();
-        expect(result.available.length).toBeGreaterThan(0);
-      }
+      // DELIVER intent always matches Verification Before Completion
+      expect(result.sessionId).toMatch(/^pbk-/);
+      expect(result.label).toBe('Verification Before Completion');
     });
 
-    it('should return error with no params', async () => {
+    it('should return error with all 7 available playbooks listed when no params', async () => {
       setup();
       const result = (await findOp('playbook_start').handler({})) as {
         error: string;
@@ -91,7 +80,7 @@ describe('playbook execution ops', () => {
       };
 
       expect(result.error).toContain('Provide');
-      expect(result.available.length).toBeGreaterThan(0);
+      expect(result.available).toHaveLength(7); // 7 built-in playbooks
     });
   });
 

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

@@ -183,25 +183,16 @@ describe('playbook-ops', () => {
     });
   });
 
-  describe('playbook_seed', () => {
-    it('seeds default playbooks', async () => {
-      const { ops } = setup();
-      const res = await executeOp(ops, 'playbook_seed');
-      expect(res.success).toBe(true);
-      // seedDefaultPlaybooks returns { seeded, skipped, errors }
-      const data = res.data as { seeded: number; skipped: number };
-      expect(typeof data.seeded).toBe('number');
-    });
-  });
-
   describe('playbook_start', () => {
     it('returns error when neither playbookId nor intent provided', async () => {
       const { ops } = setup();
       const res = await executeOp(ops, 'playbook_start', {});
       expect(res.success).toBe(true);
-      const data = res.data as { error: string; available: unknown[] };
+      const data = res.data as { error: string; available: Array<{ id: string; title: string }> };
       expect(data.error).toContain('Provide playbookId or intent');
-      expect(data.available).toBeDefined();
+      expect(data.available).toHaveLength(7); // 7 built-in playbooks
+      expect(data.available[0]).toHaveProperty('id');
+      expect(data.available[0]).toHaveProperty('title');
     });
 
     it('returns error for unknown playbookId', async () => {
@@ -228,58 +219,4 @@ describe('playbook-ops', () => {
       // Either starts a matched playbook or returns "no matching playbook"
     });
   });
-
-  describe('playbook_step', () => {
-    it('delegates to executor step', async () => {
-      const { ops, playbookExecutor } = setup();
-      const res = await executeOp(ops, 'playbook_step', {
-        sessionId: 'test-session',
-        output: 'Did the thing',
-      });
-      expect(res.success).toBe(true);
-      expect(playbookExecutor.step).toHaveBeenCalledWith('test-session', {
-        output: 'Did the thing',
-        skip: undefined,
-      });
-    });
-
-    it('supports skip option', async () => {
-      const { ops, playbookExecutor } = setup();
-      await executeOp(ops, 'playbook_step', { sessionId: 's1', skip: true });
-      expect(playbookExecutor.step).toHaveBeenCalledWith('s1', { output: undefined, skip: true });
-    });
-  });
-
-  describe('playbook_complete', () => {
-    it('delegates to executor complete', async () => {
-      const { ops, playbookExecutor } = setup();
-      const res = await executeOp(ops, 'playbook_complete', { sessionId: 's1' });
-      expect(res.success).toBe(true);
-      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
-        abort: undefined,
-        gateResults: undefined,
-      });
-    });
-
-    it('supports abort option', async () => {
-      const { ops, playbookExecutor } = setup();
-      await executeOp(ops, 'playbook_complete', { sessionId: 's1', abort: true });
-      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
-        abort: true,
-        gateResults: undefined,
-      });
-    });
-
-    it('passes gate results', async () => {
-      const { ops, playbookExecutor } = setup();
-      await executeOp(ops, 'playbook_complete', {
-        sessionId: 's1',
-        gateResults: { 'tests-pass': true, 'lint-clean': false },
-      });
-      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
-        abort: undefined,
-        gateResults: { 'tests-pass': true, 'lint-clean': false },
-      });
-    });
-  });
 });

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

@@ -39,21 +39,6 @@ describe('createReviewOps', () => {
     ops = createReviewOps(rt);
   });
 
-  it('returns 5 ops', () => {
-    expect(ops.length).toBe(5);
-  });
-
-  it('has the expected op names', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'vault_submit_review',
-      'vault_approve',
-      'vault_reject',
-      'vault_pending_reviews',
-      'vault_review_stats',
-    ]);
-  });
-
   // ─── vault_submit_review ──────────────────────────────────────
 
   describe('vault_submit_review', () => {

package/src/runtime/schema-helpers.ts

@@ -14,6 +14,10 @@ export function coerceArray<T extends z.ZodTypeAny>(itemSchema: T) {
         /* fall through to let Zod reject */
       }
     }
+    // Wrap a bare object in an array so callers can omit the array wrapper
+    if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
+      return [val];
+    }
     return val;
   }, z.array(itemSchema));
 }

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

@@ -72,24 +72,6 @@ describe('createSyncOps', () => {
     ops = createSyncOps(rt);
   });
 
-  it('returns 8 ops', () => {
-    expect(ops.length).toBe(8);
-  });
-
-  it('has the expected op names', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'vault_git_push',
-      'vault_git_pull',
-      'vault_git_sync',
-      'obsidian_export',
-      'obsidian_import',
-      'obsidian_sync',
-      'vault_export_pack',
-      'vault_import_pack',
-    ]);
-  });
-
   // ─── vault_git_push ───────────────────────────────────────────
 
   describe('vault_git_push', () => {

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

@@ -37,27 +37,6 @@ describe('tier-ops', () => {
     ops = captureOps(createTierOps(runtime));
   });
 
-  it('registers all 7 tier/source ops', () => {
-    expect(ops.size).toBe(7);
-    expect(ops.has('vault_connect')).toBe(true);
-    expect(ops.has('vault_disconnect')).toBe(true);
-    expect(ops.has('vault_tiers')).toBe(true);
-    expect(ops.has('vault_search_all')).toBe(true);
-    expect(ops.has('vault_connect_source')).toBe(true);
-    expect(ops.has('vault_disconnect_source')).toBe(true);
-    expect(ops.has('vault_list_sources')).toBe(true);
-  });
-
-  it('has correct auth levels', () => {
-    expect(ops.get('vault_connect')!.auth).toBe('admin');
-    expect(ops.get('vault_disconnect')!.auth).toBe('admin');
-    expect(ops.get('vault_tiers')!.auth).toBe('read');
-    expect(ops.get('vault_search_all')!.auth).toBe('read');
-    expect(ops.get('vault_connect_source')!.auth).toBe('admin');
-    expect(ops.get('vault_disconnect_source')!.auth).toBe('admin');
-    expect(ops.get('vault_list_sources')!.auth).toBe('read');
-  });
-
   // ─── Multi-vault ops ──────────────────────────────────────────────
 
   describe('vault_connect', () => {

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

@@ -77,18 +77,6 @@ describe('createVaultExtraOps', () => {
     ops = createVaultExtraOps(runtime);
   });
 
-  it('returns 13 ops', () => {
-    expect(ops).toHaveLength(13);
-  });
-
-  it('all ops have required fields', () => {
-    for (const op of ops) {
-      expect(op.name).toBeTruthy();
-      expect(op.handler).toBeDefined();
-      expect(['read', 'write', 'admin']).toContain(op.auth);
-    }
-  });
-
   describe('vault_get', () => {
     it('returns entry by ID', async () => {
       const result = (await findOp(ops, 'vault_get').handler({ id: 'entry-1' })) as Record<

package/src/runtime/vault-linking-ops.test.ts

@@ -52,10 +52,6 @@ describe('createVaultLinkingOps', () => {
     ops = createVaultLinkingOps(rt);
   });
 
-  it('returns 9 ops', () => {
-    expect(ops.length).toBe(9);
-  });
-
   // ─── link_entries ─────────────────────────────────────────────
 
   describe('link_entries', () => {

package/src/runtime/vault-linking-ops.ts

@@ -32,14 +32,32 @@ export function createVaultLinkingOps(runtime: AgentRuntime): OpDefinition[] {
       name: 'link_entries',
       description: 'Create a typed link between two vault entries (Zettelkasten)',
       auth: 'write',
-      schema: z.object({
-        sourceId: z.string().describe('REQUIRED: Source entry ID'),
-        targetId: z.string().describe('REQUIRED: Target entry ID'),
-        linkType: z
-          .enum(['supports', 'contradicts', 'extends', 'sequences'])
-          .describe('REQUIRED: Relationship type'),
-        note: z.string().optional().describe('Optional context for the link'),
-      }),
+      schema: z.preprocess(
+        (val) => {
+          if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
+            const obj = val as Record<string, unknown>;
+            // Accept "relationship" as alias for "linkType"
+            if (obj.relationship !== undefined && obj.linkType === undefined) {
+              return { ...obj, linkType: obj.relationship };
+            }
+          }
+          return val;
+        },
+        z.object({
+          sourceId: z.string().describe('REQUIRED: Source entry ID'),
+          targetId: z.string().describe('REQUIRED: Target entry ID'),
+          linkType: z
+            .enum(['supports', 'contradicts', 'extends', 'sequences'])
+            .describe(
+              'REQUIRED: Relationship type — supports | contradicts | extends | sequences. Alias: relationship',
+            ),
+          relationship: z
+            .enum(['supports', 'contradicts', 'extends', 'sequences'])
+            .optional()
+            .describe('Alias for linkType'),
+          note: z.string().optional().describe('Optional context for the link'),
+        }),
+      ),
       handler: async (params) => {
         const sourceId = params.sourceId as string;
         const targetId = params.targetId as string;

package/src/runtime/vault-sharing-ops.test.ts

@@ -54,15 +54,6 @@ describe('createVaultSharingOps', () => {
     ops = createVaultSharingOps(rt);
   });
 
-  it('returns 3 scope ops', () => {
-    expect(ops.length).toBe(3);
-  });
-
-  it('has the expected op names', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual(['vault_detect_scope', 'vault_set_scope', 'vault_list_by_scope']);
-  });
-
   // ─── vault_detect_scope ───────────────────────────────────────
 
   describe('vault_detect_scope', () => {

package/src/scheduler/cron-validator.ts

@@ -0,0 +1,101 @@
+/**
+ * Minimal cron expression validator.
+ * Enforces minimum 1-hour interval to prevent runaway automation.
+ */
+
+/**
+ * Validate a cron expression (5-field: minute hour day month weekday).
+ * Returns null if valid, or an error message if invalid.
+ */
+export function validateCron(expression: string): string | null {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    return 'Cron expression must have exactly 5 fields: minute hour day month weekday';
+  }
+
+  const [minute, hour] = parts;
+
+  // Enforce minimum 1-hour interval: minute field must be a single fixed value (no */1 style)
+  if (minute === '*' || minute.startsWith('*/')) {
+    return 'Minimum scheduling interval is 1 hour. Minute field cannot be * or */N';
+  }
+
+  // Hour field: validate basic format (number, range, or list — not */1 which would be every hour on the minute)
+  if (hour !== '*' && !isValidField(hour, 0, 23)) {
+    return `Invalid hour field: "${hour}"`;
+  }
+
+  if (!isValidField(parts[0], 0, 59)) return `Invalid minute field: "${parts[0]}"`;
+  if (!isValidField(parts[2], 1, 31)) return `Invalid day field: "${parts[2]}"`;
+  if (!isValidField(parts[3], 1, 12)) return `Invalid month field: "${parts[3]}"`;
+  if (!isValidField(parts[4], 0, 7)) return `Invalid weekday field: "${parts[4]}"`;
+
+  return null;
+}
+
+function isValidField(field: string, min: number, max: number): boolean {
+  if (field === '*') return true;
+
+  // Handle step values: */N or N-M/S
+  if (field.includes('/')) {
+    const [range, step] = field.split('/');
+    const stepNum = Number(step);
+    if (isNaN(stepNum) || stepNum < 1) return false;
+    if (range !== '*' && !isValidRange(range, min, max)) return false;
+    return true;
+  }
+
+  // Handle comma-separated lists
+  if (field.includes(',')) {
+    return field.split(',').every((v) => isValidValue(v.trim(), min, max));
+  }
+
+  // Handle ranges
+  if (field.includes('-')) {
+    return isValidRange(field, min, max);
+  }
+
+  return isValidValue(field, min, max);
+}
+
+function isValidRange(range: string, min: number, max: number): boolean {
+  const [start, end] = range.split('-');
+  const s = Number(start);
+  const e = Number(end);
+  return !isNaN(s) && !isNaN(e) && s >= min && e <= max && s <= e;
+}
+
+function isValidValue(value: string, min: number, max: number): boolean {
+  const n = Number(value);
+  return !isNaN(n) && n >= min && n <= max;
+}
+
+/**
+ * Estimate the minimum interval in hours from a cron expression.
+ * Returns Infinity if the expression is invalid.
+ */
+export function estimateMinIntervalHours(expression: string): number {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) return Infinity;
+
+  const hour = parts[1];
+
+  // */N style = every N hours
+  if (hour.startsWith('*/')) {
+    return Number(hour.slice(2));
+  }
+
+  // Comma-separated: e.g. "2,4,6" = every 2 hours
+  if (hour.includes(',')) {
+    const values = hour
+      .split(',')
+      .map(Number)
+      .sort((a, b) => a - b);
+    if (values.length < 2) return 24;
+    const gaps = values.slice(1).map((v, i) => v - values[i]);
+    return Math.min(...gaps);
+  }
+
+  // Single value or range: at least once per day
+  return 24;
+}

package/src/scheduler/platform-linux.ts

@@ -0,0 +1,122 @@
+/**
+ * Linux platform adapter — uses systemd user timers for scheduling.
+ *
+ * Creates ~/.config/systemd/user/{name}.timer and {name}.service units.
+ */
+
+import { existsSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import type { PlatformAdapter, ScheduledTask } from './types.js';
+
+const SYSTEMD_USER_DIR = join(homedir(), '.config', 'systemd', 'user');
+
+function unitPath(name: string, ext: 'service' | 'timer'): string {
+  return join(SYSTEMD_USER_DIR, `soleri-${name}.${ext}`);
+}
+
+/** Convert a 5-field cron to systemd OnCalendar format (simplified). */
+function cronToOnCalendar(cron: string): string {
+  const [minute, hour, day, month, weekday] = cron.split(/\s+/);
+
+  // Simplified: only handle fixed values and */N patterns
+  const d = day === '*' ? '*' : day;
+  const M = month === '*' ? '*' : month;
+  const dow = weekday === '*' ? '*' : weekday;
+  const h = hour === '*' ? '*' : hour.startsWith('*/') ? `*/${hour.slice(2)}` : hour;
+  const m = minute === '*' ? '*' : minute;
+
+  return `${dow === '*' ? '' : dowName(dow)}*-${M}-${d} ${h}:${m}:00`;
+}
+
+function dowName(dow: string): string {
+  const names = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+  const n = Number(dow);
+  return isNaN(n) ? dow : (names[n % 7] ?? '*');
+}
+
+function buildService(task: ScheduledTask, logPath: string): string {
+  return `[Unit]
+Description=Soleri scheduled task: ${task.name}
+
+[Service]
+Type=oneshot
+ExecStart=/usr/local/bin/claude -p "${task.prompt.replace(/"/g, '\\"')}" --project-dir ${task.projectPath}
+WorkingDirectory=${task.projectPath}
+StandardOutput=append:${logPath}.log
+StandardError=append:${logPath}.err
+TimeoutStartSec=600
+`;
+}
+
+function buildTimer(task: ScheduledTask): string {
+  return `[Unit]
+Description=Soleri timer for task: ${task.name}
+
+[Timer]
+OnCalendar=${cronToOnCalendar(task.cronExpression)}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+
+export class LinuxAdapter implements PlatformAdapter {
+  async create(task: ScheduledTask): Promise<string> {
+    mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
+    const logDir = join(homedir(), '.soleri', 'logs', 'scheduler');
+    mkdirSync(logDir, { recursive: true });
+    const logPath = join(logDir, task.name);
+
+    writeFileSync(unitPath(task.name, 'service'), buildService(task, logPath), 'utf-8');
+    writeFileSync(unitPath(task.name, 'timer'), buildTimer(task), 'utf-8');
+
+    execFileSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'pipe' });
+
+    if (task.enabled) {
+      execFileSync('systemctl', ['--user', 'enable', '--now', `soleri-${task.name}.timer`], {
+        stdio: 'pipe',
+      });
+    }
+
+    return `soleri-${task.name}`;
+  }
+
+  async remove(platformId: string): Promise<void> {
+    try {
+      execFileSync('systemctl', ['--user', 'disable', '--now', `${platformId}.timer`], {
+        stdio: 'pipe',
+      });
+    } catch {
+      // OK — may not exist
+    }
+    const name = platformId.replace(/^soleri-/, '');
+    for (const ext of ['service', 'timer'] as const) {
+      const path = unitPath(name, ext);
+      if (existsSync(path)) rmSync(path);
+    }
+    try {
+      execFileSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'pipe' });
+    } catch {
+      // Best-effort
+    }
+  }
+
+  async exists(platformId: string): Promise<boolean> {
+    const name = platformId.replace(/^soleri-/, '');
+    return existsSync(unitPath(name, 'timer'));
+  }
+
+  async pause(platformId: string): Promise<void> {
+    execFileSync('systemctl', ['--user', 'disable', `${platformId}.timer`], { stdio: 'pipe' });
+    execFileSync('systemctl', ['--user', 'stop', `${platformId}.timer`], { stdio: 'pipe' });
+  }
+
+  async resume(platformId: string): Promise<void> {
+    execFileSync('systemctl', ['--user', 'enable', '--now', `${platformId}.timer`], {
+      stdio: 'pipe',
+    });
+  }
+}