@soleri/core 9.3.1 → 9.5.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/persistence/sqlite-provider.ts

@@ -20,6 +20,7 @@ export function applyPerformancePragmas(db: Database.Database): void {
   db.pragma('cache_size = -64000'); // 64MB
   db.pragma('temp_store = MEMORY');
   db.pragma('mmap_size = 268435456'); // 256MB
+  db.pragma('synchronous = NORMAL');
 }
 
 export class SQLitePersistenceProvider implements PersistenceProvider {

package/src/planning/github-projection.ts

@@ -7,7 +7,10 @@
  * The plan is the source of truth; GitHub issues are the projection.
  */
 
-import { execFileSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
 
 // ---------------------------------------------------------------------------
 // Types
@@ -88,15 +91,14 @@ export function parseGitHubRemote(remoteUrl: string): GitHubRepo | null {
  * Detect the GitHub remote from a project directory.
  * Returns null if no GitHub remote found or not a git repo.
  */
-export function detectGitHubRemote(projectPath: string): GitHubRepo | null {
+export async function detectGitHubRemote(projectPath: string): Promise<GitHubRepo | null> {
   try {
-    const output = execFileSync('git', ['remote', 'get-url', 'origin'], {
+    const { stdout } = await execFileAsync('git', ['remote', 'get-url', 'origin'], {
       cwd: projectPath,
-      encoding: 'utf-8',
       timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-    return parseGitHubRemote(output);
+      signal: AbortSignal.timeout(5000),
+    });
+    return parseGitHubRemote(stdout.trim());
   } catch {
     return null;
   }
@@ -105,12 +107,11 @@ export function detectGitHubRemote(projectPath: string): GitHubRepo | null {
 /**
  * Check if the `gh` CLI is authenticated.
  */
-export function isGhAuthenticated(): boolean {
+export async function isGhAuthenticated(): Promise<boolean> {
   try {
-    execFileSync('gh', ['auth', 'status'], {
-      encoding: 'utf-8',
+    await execFileAsync('gh', ['auth', 'status'], {
       timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
+      signal: AbortSignal.timeout(5000),
     });
     return true;
   } catch {
@@ -125,9 +126,9 @@ export function isGhAuthenticated(): boolean {
 /**
  * List milestones for a GitHub repo.
  */
-export function listMilestones(repo: GitHubRepo): GitHubMilestone[] {
+export async function listMilestones(repo: GitHubRepo): Promise<GitHubMilestone[]> {
   try {
-    const output = execFileSync(
+    const { stdout } = await execFileAsync(
       'gh',
       [
         'api',
@@ -136,12 +137,12 @@ export function listMilestones(repo: GitHubRepo): GitHubMilestone[] {
         '.[] | {number, title, state}',
       ],
       {
-        encoding: 'utf-8',
         timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(10000),
       },
-    ).trim();
+    );
 
+    const output = stdout.trim();
     if (!output) return [];
 
     // gh --jq outputs one JSON object per line
@@ -157,9 +158,12 @@ export function listMilestones(repo: GitHubRepo): GitHubMilestone[] {
 /**
  * List open issues for a GitHub repo.
  */
-export function listOpenIssues(repo: GitHubRepo, limit: number = 100): GitHubIssue[] {
+export async function listOpenIssues(
+  repo: GitHubRepo,
+  limit: number = 100,
+): Promise<GitHubIssue[]> {
   try {
-    const output = execFileSync(
+    const { stdout } = await execFileAsync(
       'gh',
       [
         'issue',
@@ -174,12 +178,12 @@ export function listOpenIssues(repo: GitHubRepo, limit: number = 100): GitHubIss
         'number,title,state,body',
       ],
       {
-        encoding: 'utf-8',
         timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(10000),
       },
-    ).trim();
+    );
 
+    const output = stdout.trim();
     if (!output) return [];
     return JSON.parse(output) as GitHubIssue[];
   } catch {
@@ -190,18 +194,18 @@ export function listOpenIssues(repo: GitHubRepo, limit: number = 100): GitHubIss
 /**
  * List labels for a GitHub repo.
  */
-export function listLabels(repo: GitHubRepo): GitHubLabel[] {
+export async function listLabels(repo: GitHubRepo): Promise<GitHubLabel[]> {
   try {
-    const output = execFileSync(
+    const { stdout } = await execFileAsync(
       'gh',
       ['label', 'list', '--repo', `${repo.owner}/${repo.repo}`, '--json', 'name,color'],
       {
-        encoding: 'utf-8',
         timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(10000),
       },
-    ).trim();
+    );
 
+    const output = stdout.trim();
     if (!output) return [];
     return JSON.parse(output) as GitHubLabel[];
   } catch {
@@ -217,16 +221,18 @@ export function listLabels(repo: GitHubRepo): GitHubLabel[] {
  * Detect full GitHub context for a project.
  * Returns null if not a GitHub project or gh CLI not available.
  */
-export function detectGitHubContext(projectPath: string): GitHubContext | null {
-  const repo = detectGitHubRemote(projectPath);
+export async function detectGitHubContext(projectPath: string): Promise<GitHubContext | null> {
+  const repo = await detectGitHubRemote(projectPath);
   if (!repo) return null;
 
-  const authenticated = isGhAuthenticated();
+  const authenticated = await isGhAuthenticated();
   if (!authenticated) return null;
 
-  const milestones = listMilestones(repo);
-  const existingIssues = listOpenIssues(repo);
-  const labels = listLabels(repo);
+  const [milestones, existingIssues, labels] = await Promise.all([
+    listMilestones(repo),
+    listOpenIssues(repo),
+    listLabels(repo),
+  ]);
 
   return { repo, authenticated, milestones, existingIssues, labels };
 }
@@ -370,7 +376,7 @@ export function formatIssueBody(
  * Create a GitHub issue using the `gh` CLI.
  * Returns the issue number, or null on failure.
  */
-export function createGitHubIssue(
+export async function createGitHubIssue(
   repo: GitHubRepo,
   title: string,
   body: string,
@@ -378,7 +384,7 @@ export function createGitHubIssue(
     milestone?: number;
     labels?: string[];
   },
-): number | null {
+): Promise<number | null> {
   try {
     const args = [
       'issue',
@@ -399,14 +405,13 @@ export function createGitHubIssue(
       args.push('--label', options.labels.join(','));
     }
 
-    const output = execFileSync('gh', args, {
-      encoding: 'utf-8',
+    const { stdout } = await execFileAsync('gh', args, {
       timeout: 15000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
+      signal: AbortSignal.timeout(15000),
+    });
 
     // gh issue create returns the issue URL: https://github.com/owner/repo/issues/123
-    const match = output.match(/\/issues\/(\d+)/);
+    const match = stdout.trim().match(/\/issues\/(\d+)/);
     return match ? parseInt(match[1], 10) : null;
   } catch {
     return null;
@@ -416,13 +421,13 @@ export function createGitHubIssue(
 /**
  * Update an existing GitHub issue body (for linking plans to existing issues).
  */
-export function updateGitHubIssueBody(
+export async function updateGitHubIssueBody(
   repo: GitHubRepo,
   issueNumber: number,
   body: string,
-): boolean {
+): Promise<boolean> {
   try {
-    execFileSync(
+    await execFileAsync(
       'gh',
       [
         'issue',
@@ -434,9 +439,8 @@ export function updateGitHubIssueBody(
         body,
       ],
       {
-        encoding: 'utf-8',
         timeout: 15000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(15000),
       },
     );
     return true;

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,20 @@ 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 +414,9 @@ export function applySplitTasks(
     description: string;
     dependsOn?: string[];
     acceptanceCriteria?: string[];
+    phase?: string;
+    milestone?: string;
+    parentTaskId?: string;
   }>,
 ): void {
   const now = Date.now();
@@ -362,6 +427,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 +440,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/queue/pipeline-runner.ts

@@ -58,6 +58,10 @@ export class PipelineRunner {
     if (this.running) return;
     this.running = true;
     this.timer = setInterval(() => this.tick(), this.pollIntervalMs);
+    // Don't prevent process exit for background polling
+    if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {
+      (this.timer as NodeJS.Timeout).unref();
+    }
   }
 
   /**