@soleri/core 9.3.1 → 9.4.0

package/src/packs/index.ts

@@ -4,7 +4,9 @@
 
 export {
   packManifestSchema,
+  PACK_TIERS,
   type PackManifest,
+  type PackTier as ManifestPackTier,
   type PackStatus,
   type InstalledPack,
   type InstallResult,
@@ -14,7 +16,7 @@ export {
 export { PackInstaller } from './pack-installer.js';
 
 export { PackLockfile, inferPackType } from './lockfile.js';
-export type { LockEntry, PackType, PackSource, LockfileData } from './lockfile.js';
+export type { LockEntry, PackType, PackSource, PackTier, LockfileData } from './lockfile.js';
 
 export { resolvePack, checkNpmVersion, checkVersionCompat } from './resolver.js';
 export type { ResolvedPack, ResolveOptions } from './resolver.js';

package/src/packs/lockfile.ts

@@ -39,10 +39,13 @@ export interface LockEntry {
   facadesRegistered: boolean;
   /** Compatible @soleri/core version range (from manifest "soleri" field) */
   soleriRange?: string;
+  /** Pack tier: default (ships with engine), community (free), premium (unlocked today) */
+  tier?: PackTier;
 }
 
 export type PackType = 'hooks' | 'skills' | 'knowledge' | 'domain' | 'bundle';
 export type PackSource = 'built-in' | 'local' | 'npm';
+export type PackTier = 'default' | 'community' | 'premium';
 
 export interface LockfileData {
   /** Lockfile format version */

package/src/packs/types.ts

@@ -23,11 +23,20 @@ import { z } from 'zod';
 // MANIFEST SCHEMA
 // =============================================================================
 
+// ---------------------------------------------------------------------------
+// Pack Tiers — determines visibility, licensing, and install behavior
+// ---------------------------------------------------------------------------
+
+export const PACK_TIERS = ['default', 'community', 'premium'] as const;
+export type PackTier = (typeof PACK_TIERS)[number];
+
 export const packManifestSchema = z.object({
   id: z.string().regex(/^[a-z0-9-]+$/, 'Pack ID must be lowercase alphanumeric with hyphens'),
   name: z.string().min(1),
   version: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver (x.y.z)'),
   description: z.string().optional().default(''),
+  /** Pack tier: 'default' (ships with engine), 'community' (free, npm), 'premium' (unlocked today, gated later) */
+  tier: z.enum(PACK_TIERS).optional().default('community'),
   /** Domains this pack covers */
   domains: z.array(z.string()).optional().default([]),
   /** Minimum engine version required (semver range) */

package/src/planning/plan-lifecycle.ts

@@ -232,7 +232,13 @@ export interface IterateChanges {
   objective?: string;
   scope?: string;
   decisions?: (string | PlanDecision)[];
-  addTasks?: Array<{ title: string; description: string }>;
+  addTasks?: Array<{
+    title: string;
+    description: string;
+    phase?: string;
+    milestone?: string;
+    parentTaskId?: string;
+  }>;
   removeTasks?: string[];
   approach?: string;
   context?: string;
@@ -240,26 +246,61 @@ export interface IterateChanges {
   tool_chain?: string[];
   flow?: string;
   target_mode?: string;
+  alternatives?: import('./planner-types.js').PlanAlternative[];
 }
 
 /**
  * Apply iteration changes to a plan (mutates in place).
  * Caller is responsible for status validation and persistence.
+ * Returns the number of fields actually mutated (0 = no-op).
  */
-export function applyIteration(plan: Plan, changes: IterateChanges): void {
+export function applyIteration(plan: Plan, changes: IterateChanges): number {
   const now = Date.now();
-  if (changes.objective !== undefined) plan.objective = changes.objective;
-  if (changes.scope !== undefined) plan.scope = changes.scope;
-  if (changes.decisions !== undefined) plan.decisions = changes.decisions;
-  if (changes.approach !== undefined) plan.approach = changes.approach;
-  if (changes.context !== undefined) plan.context = changes.context;
-  if (changes.success_criteria !== undefined) plan.success_criteria = changes.success_criteria;
-  if (changes.tool_chain !== undefined) plan.tool_chain = changes.tool_chain;
-  if (changes.flow !== undefined) plan.flow = changes.flow;
-  if (changes.target_mode !== undefined) plan.target_mode = changes.target_mode;
+  let mutated = 0;
+  if (changes.objective !== undefined) {
+    plan.objective = changes.objective;
+    mutated++;
+  }
+  if (changes.scope !== undefined) {
+    plan.scope = changes.scope;
+    mutated++;
+  }
+  if (changes.decisions !== undefined) {
+    plan.decisions = changes.decisions;
+    mutated++;
+  }
+  if (changes.approach !== undefined) {
+    plan.approach = changes.approach;
+    mutated++;
+  }
+  if (changes.context !== undefined) {
+    plan.context = changes.context;
+    mutated++;
+  }
+  if (changes.success_criteria !== undefined) {
+    plan.success_criteria = changes.success_criteria;
+    mutated++;
+  }
+  if (changes.tool_chain !== undefined) {
+    plan.tool_chain = changes.tool_chain;
+    mutated++;
+  }
+  if (changes.flow !== undefined) {
+    plan.flow = changes.flow;
+    mutated++;
+  }
+  if (changes.target_mode !== undefined) {
+    plan.target_mode = changes.target_mode;
+    mutated++;
+  }
+  if (changes.alternatives !== undefined) {
+    plan.alternatives = changes.alternatives;
+    mutated++;
+  }
   if (changes.removeTasks?.length) {
     const removeSet = new Set(changes.removeTasks);
     plan.tasks = plan.tasks.filter((t) => !removeSet.has(t.id));
+    mutated++;
   }
   if (changes.addTasks?.length) {
     const maxIndex = plan.tasks.reduce((max, t) => {
@@ -267,16 +308,24 @@ export function applyIteration(plan: Plan, changes: IterateChanges): void {
       return isNaN(num) ? max : Math.max(max, num);
     }, 0);
     for (let i = 0; i < changes.addTasks.length; i++) {
+      const t = changes.addTasks[i];
       plan.tasks.push({
         id: `task-${maxIndex + i + 1}`,
-        title: changes.addTasks[i].title,
-        description: changes.addTasks[i].description,
+        title: t.title,
+        description: t.description,
         status: 'pending' as TaskStatus,
+        ...(t.phase !== undefined && { phase: t.phase }),
+        ...(t.milestone !== undefined && { milestone: t.milestone }),
+        ...(t.parentTaskId !== undefined && { parentTaskId: t.parentTaskId }),
         updatedAt: now,
       });
     }
+    mutated++;
   }
-  plan.updatedAt = now;
+  if (mutated > 0) {
+    plan.updatedAt = now;
+  }
+  return mutated;
 }
 
 /**
@@ -308,7 +357,13 @@ export function createPlanObject(params: {
   objective: string;
   scope: string;
   decisions?: (string | PlanDecision)[];
-  tasks?: Array<{ title: string; description: string }>;
+  tasks?: Array<{
+    title: string;
+    description: string;
+    phase?: string;
+    milestone?: string;
+    parentTaskId?: string;
+  }>;
   approach?: string;
   context?: string;
   success_criteria?: string[];
@@ -325,13 +380,7 @@ export function createPlanObject(params: {
     scope: params.scope,
     status: params.initialStatus ?? 'draft',
     decisions: params.decisions ?? [],
-    tasks: (params.tasks ?? []).map((t, i) => ({
-      id: `task-${i + 1}`,
-      title: t.title,
-      description: t.description,
-      status: 'pending' as TaskStatus,
-      updatedAt: now,
-    })),
+    tasks: (params.tasks ?? []).map((t, i) => (Object.assign({id:`task-${i+1}`,title:t.title,description:t.description,status:`pending` as TaskStatus}, t.phase!==undefined&&{phase:t.phase}, t.milestone!==undefined&&{milestone:t.milestone}, t.parentTaskId!==undefined&&{parentTaskId:t.parentTaskId}, {updatedAt:now}))),
     ...(params.approach !== undefined && { approach: params.approach }),
     ...(params.context !== undefined && { context: params.context }),
     ...(params.success_criteria !== undefined && { success_criteria: params.success_criteria }),
@@ -352,6 +401,9 @@ export function applySplitTasks(
     description: string;
     dependsOn?: string[];
     acceptanceCriteria?: string[];
+    phase?: string;
+    milestone?: string;
+    parentTaskId?: string;
   }>,
 ): void {
   const now = Date.now();
@@ -362,6 +414,9 @@ export function applySplitTasks(
     status: 'pending' as TaskStatus,
     dependsOn: t.dependsOn,
     ...(t.acceptanceCriteria && { acceptanceCriteria: t.acceptanceCriteria }),
+    ...(t.phase !== undefined && { phase: t.phase }),
+    ...(t.milestone !== undefined && { milestone: t.milestone }),
+    ...(t.parentTaskId !== undefined && { parentTaskId: t.parentTaskId }),
     updatedAt: now,
   }));
   const taskIds = new Set(plan.tasks.map((t) => t.id));
@@ -372,6 +427,9 @@ export function applySplitTasks(
           throw new Error(`Task '${task.id}' depends on unknown task '${dep}'`);
       }
     }
+    if (task.parentTaskId && !taskIds.has(task.parentTaskId)) {
+      throw new Error(`Task '${task.id}' references unknown parent task '${task.parentTaskId}'`);
+    }
   }
   plan.updatedAt = now;
 }

package/src/planning/planner-types.ts

@@ -66,6 +66,12 @@ export interface PlanTask {
   status: TaskStatus;
   /** Optional dependency IDs — tasks that must complete before this one. */
   dependsOn?: string[];
+  /** Phase this task belongs to (e.g., "wave-1", "discovery", "implementation"). */
+  phase?: string;
+  /** Milestone this task contributes to (e.g., "v1.0", "mvp", "beta"). */
+  milestone?: string;
+  /** Parent task ID — enables sub-task hierarchy within a plan. */
+  parentTaskId?: string;
   /** Evidence submitted for task acceptance criteria. */
   evidence?: TaskEvidence[];
   /** Whether this task has been verified (all evidence checked + reviews passed). */

package/src/planning/planner.ts

@@ -235,15 +235,17 @@ export class Planner {
     );
   }
 
-  iterate(planId: string, changes: IterateChanges): Plan {
+  iterate(planId: string, changes: IterateChanges): { plan: Plan; mutated: number } {
     const plan = this.requirePlan(planId);
     if (plan.status !== 'draft' && plan.status !== 'brainstorming')
       throw new Error(
         `Cannot iterate plan in '${plan.status}' status — must be 'draft' or 'brainstorming'`,
       );
-    applyIteration(plan, changes);
-    this.save();
-    return plan;
+    const mutated = applyIteration(plan, changes);
+    if (mutated > 0) {
+      this.save();
+    }
+    return { plan, mutated };
   }
 
   splitTasks(
@@ -253,6 +255,9 @@ export class Planner {
       description: string;
       dependsOn?: string[];
       acceptanceCriteria?: string[];
+      phase?: string;
+      milestone?: string;
+      parentTaskId?: string;
     }>,
   ): Plan {
     const plan = this.requirePlan(planId);
@@ -445,6 +450,71 @@ export class Planner {
     return toArchive;
   }
 
+  /**
+   * Close stale plans — plans in non-terminal states older than the given threshold.
+   * For draft/approved: uses 30 min TTL by default.
+   * For executing/reconciling: uses olderThanMs parameter (24h default).
+   * Returns the list of closed plan IDs.
+   */
+  closeStale(olderThanMs?: number): {
+    closedIds: string[];
+    closedPlans: Array<{ id: string; previousStatus: string; reason: string }>;
+  } {
+    const now = Date.now();
+    const forceAll = olderThanMs === 0;
+    const defaultTtl = forceAll ? 0 : 30 * 60 * 1000; // 30 minutes for draft/approved
+    const executingTtl = forceAll ? 0 : (olderThanMs ?? 24 * 60 * 60 * 1000); // 24h default for executing/reconciling
+    const closed: Array<{ id: string; previousStatus: string; reason: string }> = [];
+
+    for (const plan of this.store.plans) {
+      // Skip terminal states
+      if (plan.status === 'completed' || plan.status === 'archived') continue;
+
+      const age = now - plan.updatedAt;
+      let shouldClose = false;
+      let reason = '';
+
+      if (plan.status === 'draft' || plan.status === 'approved') {
+        // Short TTL for draft/approved — these should move quickly
+        if (age >= defaultTtl) {
+          shouldClose = true;
+          reason = `ttl-expired (${plan.status}, age: ${Math.round(age / 60000)}min)`;
+        }
+      } else if (
+        plan.status === 'executing' ||
+        plan.status === 'validating' ||
+        plan.status === 'reconciling' ||
+        plan.status === 'brainstorming'
+      ) {
+        // Longer TTL for active states
+        if (age >= executingTtl) {
+          shouldClose = true;
+          reason = `stale-closed (${plan.status}, age: ${Math.round(age / 3600000)}h)`;
+        }
+      }
+
+      if (shouldClose) {
+        const previousStatus = plan.status;
+        // Force transition to completed (bypass FSM since these are stale)
+        plan.status = 'completed';
+        plan.updatedAt = now;
+        if (!plan.reconciliation) {
+          plan.reconciliation = {
+            planId: plan.id,
+            accuracy: 0,
+            driftItems: [],
+            summary: `Auto-closed: ${reason}`,
+            reconciledAt: now,
+          };
+        }
+        closed.push({ id: plan.id, previousStatus, reason });
+      }
+    }
+
+    if (closed.length > 0) this.save();
+    return { closedIds: closed.map((c) => c.id), closedPlans: closed };
+  }
+
   stats(): {
     total: number;
     byStatus: Record<PlanStatus, number>;

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

@@ -72,7 +72,10 @@ describe('assessTaskComplexity — complex tasks', () => {
   });
 
   it('classifies many-file task with design decision as complex', () => {
-    const result = assess({ prompt: 'how should we update styles across the app', filesEstimated: 5 });
+    const result = assess({
+      prompt: 'how should we update styles across the app',
+      filesEstimated: 5,
+    });
     expect(result.classification).toBe('complex');
     expect(result.score).toBeGreaterThanOrEqual(40);
     expect(signalByName(result, 'file-count')!.triggered).toBe(true);
@@ -117,7 +120,8 @@ describe('assessTaskComplexity — edge cases', () => {
 
   it('clamps score to 100 maximum', () => {
     const result = assess({
-      prompt: 'add authentication, migrate the DB, install new package, how should we design this, refactor across all modules',
+      prompt:
+        'add authentication, migrate the DB, install new package, how should we design this, refactor across all modules',
       filesEstimated: 10,
       domains: ['vault', 'brain', 'planning'],
     });

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

@@ -164,10 +164,7 @@ export function assessTaskComplexity(input: AssessmentInput): AssessmentResult {
     detectMultiDomain(input),
   ];
 
-  const rawScore = signals.reduce(
-    (sum, s) => sum + (s.triggered ? s.weight : 0),
-    0,
-  );
+  const rawScore = signals.reduce((sum, s) => sum + (s.triggered ? s.weight : 0), 0);
 
   // Clamp to 0-100
   const score = Math.max(0, Math.min(100, rawScore));

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

@@ -35,6 +35,9 @@ function mockRuntime(): AgentRuntime {
     curator: {
       getStatus: vi.fn().mockReturnValue({ initialized: true }),
     },
+    packInstaller: {
+      list: vi.fn().mockReturnValue([]),
+    },
     contextHealth: {
       check: vi.fn().mockReturnValue({
         level: 'green',
@@ -67,8 +70,8 @@ describe('createAdminOps', () => {
     ops = createAdminOps(rt);
   });
 
-  it('returns 9 ops', () => {
-    expect(ops.length).toBe(9);
+  it('returns 11 ops', () => {
+    expect(ops.length).toBe(11);
   });
 
   // ─── admin_health ─────────────────────────────────────────────
@@ -98,6 +101,50 @@ describe('createAdminOps', () => {
       expect(llm.openai).toBe(true);
       expect(llm.anthropic).toBe(false);
     });
+
+    it('reports skills status', async () => {
+      const op = findOp(ops, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const skills = result.skills as Record<string, unknown>;
+      expect(skills).toBeDefined();
+      expect(skills.count).toBe(0);
+      expect(skills.agent).toEqual([]);
+      expect(skills.packs).toEqual([]);
+    });
+
+    it('reports hooks status', async () => {
+      const op = findOp(ops, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const hooks = result.hooks as Record<string, unknown>;
+      expect(hooks).toBeDefined();
+      expect(hooks.count).toBe(0);
+      expect(hooks.packs).toEqual([]);
+    });
+
+    it('includes pack skills and hooks when packs are installed', async () => {
+      vi.mocked(rt.packInstaller.list).mockReturnValue([
+        {
+          id: 'test-pack',
+          manifest: {} as never,
+          directory: '/tmp/pack',
+          status: 'installed',
+          vaultEntries: 5,
+          skills: ['my-skill', 'another-skill'],
+          hooks: ['my-hook'],
+          facadesRegistered: false,
+          installedAt: Date.now(),
+        },
+      ]);
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const skills = result.skills as Record<string, unknown>;
+      expect(skills.count).toBe(2);
+      expect(skills.packs).toEqual(['my-skill', 'another-skill']);
+      const hooks = result.hooks as Record<string, unknown>;
+      expect(hooks.count).toBe(1);
+      expect(hooks.packs).toEqual(['my-hook']);
+    });
   });
 
   // ─── context_health ───────────────────────────────────────────
@@ -135,9 +182,7 @@ describe('createAdminOps', () => {
 
     it('returns routing hints in grouped mode', async () => {
       const op = findOp(ops, 'admin_tool_list');
-      const allOps = [
-        { name: 'admin_health', description: 'Health check', auth: 'read' },
-      ];
+      const allOps = [{ name: 'admin_health', description: 'Health check', auth: 'read' }];
       const result = (await op.handler({ _allOps: allOps })) as Record<string, unknown>;
       const routing = result.routing as Record<string, string>;
       expect(routing).toBeDefined();
@@ -229,6 +274,94 @@ describe('createAdminOps', () => {
     });
   });
 
+  // ─── operator_context_inspect ────────────────────────────────
+
+  describe('operator_context_inspect', () => {
+    it('returns full profile when store is available', async () => {
+      const mockContext = {
+        expertise: [
+          {
+            topic: 'TypeScript',
+            level: 'expert',
+            confidence: 0.9,
+            sessionCount: 5,
+            lastObserved: Date.now(),
+          },
+        ],
+        corrections: [],
+        interests: [
+          { tag: 'testing', confidence: 0.7, mentionCount: 3, lastMentioned: Date.now() },
+        ],
+        patterns: [],
+        sessionCount: 5,
+        lastUpdated: Date.now(),
+      };
+      (rt as Record<string, unknown>).operatorContextStore = {
+        inspect: vi.fn().mockReturnValue(mockContext),
+        deleteItem: vi.fn(),
+      };
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'operator_context_inspect');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.available).toBe(true);
+      expect(result.expertise).toEqual(mockContext.expertise);
+      expect(result.interests).toEqual(mockContext.interests);
+    });
+
+    it('returns not-available when store is missing', async () => {
+      // Default mock runtime has no operatorContextStore
+      const op = findOp(ops, 'operator_context_inspect');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.available).toBe(false);
+      expect(result.message).toBe('Operator context not configured');
+    });
+  });
+
+  // ─── operator_context_delete ───────────────────────────────────
+
+  describe('operator_context_delete', () => {
+    it('removes an item successfully', async () => {
+      (rt as Record<string, unknown>).operatorContextStore = {
+        inspect: vi.fn(),
+        deleteItem: vi.fn().mockReturnValue(true),
+      };
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'operator_context_delete');
+      const result = (await op.handler({ type: 'expertise', id: 'abc-123' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.deleted).toBe(true);
+      expect(result.type).toBe('expertise');
+      expect(result.id).toBe('abc-123');
+    });
+
+    it('returns false for missing item', async () => {
+      (rt as Record<string, unknown>).operatorContextStore = {
+        inspect: vi.fn(),
+        deleteItem: vi.fn().mockReturnValue(false),
+      };
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'operator_context_delete');
+      const result = (await op.handler({ type: 'pattern', id: 'nonexistent' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.deleted).toBe(false);
+      expect(result.message).toBe('Item not found');
+    });
+
+    it('returns not-available when store is missing', async () => {
+      const op = findOp(ops, 'operator_context_delete');
+      const result = (await op.handler({ type: 'expertise', id: 'abc' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.deleted).toBe(false);
+      expect(result.message).toBe('Operator context not configured');
+    });
+  });
+
   // ─── admin_diagnostic ─────────────────────────────────────────
 
   describe('admin_diagnostic', () => {
@@ -241,7 +374,7 @@ describe('createAdminOps', () => {
       expect(result).toHaveProperty('checks');
       expect(result).toHaveProperty('summary');
       const checks = result.checks as Array<Record<string, string>>;
-      expect(checks.length).toBeGreaterThanOrEqual(5);
+      expect(checks.length).toBeGreaterThanOrEqual(8);
     });
 
     it('reports degraded when LLM unavailable', async () => {