@powerhousedao/ph-clint-cli 0.1.0-dev.10 → 0.1.0-dev.101

package/dist/triggers/spec-change.js

@@ -1,26 +1,29 @@
 /**
- * `spec-change` trigger — watches the `powerhouse/ph-clint-project` document
- * on the Reactor drive and, when its state changes, enqueues a work item
- * that re-runs the code generator in update mode.
+ * `spec-change` trigger — watches ALL `powerhouse/ph-clint-project` documents
+ * and, when any change, re-runs the code generator for each affected project.
  *
  * Flow:
  *   1. `createDocumentChangeTrigger` (from ph-clint) owns the subscription,
- *      event coalescing, doc loading, and type narrowing.
- *   2. `documentId` resolves the target doc lazily: it prefers
- *      `config.projectDocumentId`, falling back to a drive scan for the first
- *      `powerhouse/ph-clint-project` document (and pinning the id into local
- *      config on success).
- *   3. `onChange` converts the doc state to a `ClintProjectSpec`, hashes it,
+ *      event coalescing, doc loading, and type narrowing. No `documentId` is
+ *      set, so it loads ALL matching documents on each poll.
+ *   2. `getProjectMapping()` merges an on-disk scan (via the clint-project
+ *      service's projectScanner) with personal-drive folder entries to
+ *      correlate each document to an on-disk project directory.
+ *   3. For each document, `specFromDocumentState()` builds a spec, hashes it,
  *      and compares against `.ph/ph-clint-cli/.last-spec-hash`. If unchanged,
- *      emits nothing. If different, returns a `function` work item that calls
- *      `generateProject(spec, workdir, 'update')` and writes the new hash.
+ *      skips. Otherwise regenerates at the mapped target directory.
  */
 import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { scanProjects, getProjectMapping } from '@powerhousedao/ph-clint';
 import { createDocumentChangeTrigger } from '../framework.js';
 import { generateProject } from '../codegen/index.js';
+import { runPostGenActions } from '@powerhousedao/ph-clint-dev/codegen/actions';
 import { specFromDocumentState } from '../spec/from-document.js';
+import { readProjectSpec, writeProjectSpec } from '../spec/file.js';
+import { ensureSpecDocument } from '../spec/ensure-document.js';
+import { clintProject } from '../services/clint-project.js';
 const DOCUMENT_TYPE = 'powerhouse/ph-clint-project';
 const HASH_DIR = path.join('.ph', 'ph-clint-cli');
 const HASH_FILE = '.last-spec-hash';
@@ -49,11 +52,13 @@ async function writeLastSpecHash(targetDir, hash) {
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, hash + '\n', 'utf8');
 }
-/** Stable hash of a ClintProjectSpec (sha256 of canonical-key JSON). */
+/** Stable hash of a ClintProjectSpec (sha256 of canonical-key JSON).
+ *  Excludes documentId/documentType — they don't affect codegen output. */
 export function hashSpec(spec) {
+    const { documentId, documentType, ...codegenRelevant } = spec;
     return crypto
         .createHash('sha256')
-        .update(canonicalJson(spec), 'utf8')
+        .update(canonicalJson(codegenRelevant), 'utf8')
         .digest('hex');
 }
 function canonicalJson(value) {
@@ -70,102 +75,150 @@ function canonicalJson(value) {
             .join(',') +
         '}');
 }
-/** Find the first ph-clint-project document on the default drive. */
-async function findProjectDocumentId(client, driveId) {
-    try {
-        const children = await client.getChildren(driveId);
-        const results = (children?.results ?? []);
-        for (const node of results) {
-            if (node.header?.documentType === DOCUMENT_TYPE && node.header.id) {
-                return node.header.id;
+export function specToImportInput(spec) {
+    const main = spec.features.mastra.mainAgent;
+    return {
+        name: spec.name,
+        scope: spec.scope ?? null,
+        version: spec.version,
+        description: spec.description,
+        powerhouse: spec.features.powerhouse,
+        mastraEnabled: spec.features.mastra.enabled,
+        routineEnabled: spec.features.routine.enabled,
+        mainAgent: main
+            ? {
+                id: main.id,
+                name: main.name,
+                description: main.description,
+                attachment: main.image,
+                modelId: main.modelId,
+                profileIds: [...main.profileIds],
+                skills: [...main.skills],
+                toolPatterns: [...main.toolPatterns],
             }
-        }
-    }
-    catch {
-        // fall through
-    }
-    return undefined;
+            : null,
+        subAgents: spec.features.mastra.subAgents.map((s) => ({
+            id: s.id,
+            name: s.name,
+            description: s.description,
+            modelId: s.modelId,
+            profileIds: [...s.profileIds],
+            skills: [...s.skills],
+            toolPatterns: [...s.toolPatterns],
+        })),
+        models: spec.features.mastra.models.map((m) => ({
+            id: m.id,
+        })),
+        profiles: spec.features.mastra.profiles.map((p) => ({
+            id: p.id,
+            title: p.title,
+            content: p.content,
+        })),
+        packages: spec.packages.map((p) => ({
+            id: p.id,
+            packageName: p.packageName,
+            documentTypes: p.documentTypes,
+        })),
+        externalSkills: spec.externalSkills.map((s) => ({
+            id: s.id,
+            name: s.name,
+            githubUrl: s.githubUrl,
+        })),
+        enableChat: spec.features.mastra.common.enableChat,
+        proxyEnabled: spec.deployment.proxyEnabled,
+        observabilityEnabled: spec.deployment.observabilityEnabled,
+        supportedResources: spec.deployment.supportedResources,
+    };
 }
 export const specChangeTrigger = createDocumentChangeTrigger({
     id: 'spec-change',
     documentType: DOCUMENT_TYPE,
-    // Resolve the target id lazily so we can also do first-time discovery and
-    // persist the discovered id into local config.
-    documentId: async (ctx) => {
-        const configured = ctx.context.config.projectDocumentId &&
-            ctx.context.config.projectDocumentId.length > 0
-            ? ctx.context.config.projectDocumentId
-            : undefined;
-        if (configured)
-            return configured;
+    // No documentId → watches ALL ph-clint-project docs
+    callOnEmpty: true, // bootstrap from disk when no documents exist yet
+    async onChange(docs, ctx) {
+        const log = ctx.context.log;
+        const folders = ctx.context.folders;
+        // Build the mapping: on-disk projects + personal drive documents
+        const scanner = clintProject.projectScanner;
+        const scanResults = scanner
+            ? scanProjects(ctx.context.workdir, scanner)
+            : [];
+        const mapping = await getProjectMapping(scanResults, folders);
+        // Auto-create spec documents for unlinked or orphaned projects
         const reactor = await ctx.reactor();
-        if (!reactor)
-            return undefined;
-        const discovered = await findProjectDocumentId(reactor.client, reactor.driveId);
-        if (!discovered) {
-            ctx.context.log?.debug(`${TAG} no ${DOCUMENT_TYPE} document found on drive ${reactor.driveId}`);
-            return undefined;
+        if (reactor && folders) {
+            for (const entry of mapping) {
+                if (!entry.path)
+                    continue;
+                const existingSpec = await readProjectSpec(entry.path);
+                if (!existingSpec)
+                    continue;
+                try {
+                    const { docId, created } = await ensureSpecDocument({
+                        spec: existingSpec,
+                        targetDir: entry.path,
+                        reactor,
+                        folders,
+                    });
+                    if (created) {
+                        log?.info(`${TAG} linked project ${entry.name} to document ${docId}`);
+                    }
+                }
+                catch (err) {
+                    log?.warn(`${TAG} could not ensure spec document for ${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
         }
-        // Persist into local config + mutate in-memory so future ticks skip discovery.
-        try {
-            const current = await ctx.context.workspace.loadLocalConfig({});
-            await ctx.context.workspace.storeLocalConfig({
-                ...current,
-                projectDocumentId: discovered,
+        for (const doc of docs) {
+            const spec = specFromDocumentState(doc.state.global, {
+                documentId: doc.header.id,
+                documentType: doc.header.documentType,
+            });
+            if (!spec) {
+                log?.debug(`${TAG} document ${doc.header.id} state did not validate against ClintProjectSpec, skipping`);
+                continue;
+            }
+            // Find target directory from mapping
+            const entry = mapping.find((m) => m.documentId === doc.header.id);
+            const targetDir = entry?.path ?? path.join(ctx.context.workdir, spec.name);
+            // Per-project hash comparison
+            const nextHash = hashSpec(spec);
+            const prevHash = await readLastSpecHash(targetDir);
+            if (nextHash === prevHash) {
+                log?.debug(`${TAG} spec for ${spec.name} unchanged (hash=${nextHash.slice(0, 12)}…), skipping`);
+                continue;
+            }
+            log?.debug(`${TAG} spec for ${spec.name} changed: ${prevHash ? prevHash.slice(0, 12) + '…' : '<none>'} → ${nextHash.slice(0, 12)}…`);
+            log?.info(`${TAG} regenerating ${spec.name} at ${targetDir} (doc=${doc.header.id})`);
+            const t0 = Date.now();
+            const warnings = [];
+            const result = await generateProject({
+                targetDir,
+                spec,
+                mode: 'update',
+                force: true,
+                onWarn: (m) => warnings.push(m),
+            });
+            // Write spec JSON with documentId
+            await writeProjectSpec(targetDir, spec);
+            await writeLastSpecHash(targetDir, nextHash);
+            const elapsed = Date.now() - t0;
+            if (log) {
+                if (result.migrated)
+                    log.info(`${TAG} migrated flat → split layout`);
+                log.info(`${TAG} regenerated ${spec.name} in ${elapsed}ms: ${result.files.length} written, ${result.skipped.length} skipped, ${result.deleted.length} deleted`);
+                for (const w of warnings)
+                    log.warn(`${TAG} ${w}`);
+            }
+            // Run post-generation actions (ph-init, install, build, skills-sync).
+            // Route through ctx.context.stdout so output flows through
+            // routine.onOutput → service log buffer → ServicePanel.
+            await runPostGenActions(result.pendingActions, {
+                log: (msg) => ctx.context.stdout(`${TAG} ${msg}\n`),
+                runProcess: ctx.context.runProcess,
             });
-            ctx.context.config.projectDocumentId = discovered;
-            ctx.context.log?.info(`${TAG} pinned projectDocumentId=${discovered} in ${ctx.context.workspace.getLocalConfigPath()}`);
-        }
-        catch (err) {
-            ctx.context.log?.warn(`${TAG} failed to persist projectDocumentId: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return discovered;
-    },
-    async onChange(doc, ctx) {
-        const log = ctx.context.log;
-        const spec = specFromDocumentState(doc.state.global);
-        if (!spec) {
-            log?.debug(`${TAG} document ${doc.header.id} state did not validate against ClintProjectSpec, skipping`);
-            return null;
-        }
-        const targetDir = ctx.context.workdir;
-        const nextHash = hashSpec(spec);
-        const prevHash = await readLastSpecHash(targetDir);
-        if (nextHash === prevHash) {
-            log?.debug(`${TAG} spec unchanged (hash=${nextHash.slice(0, 12)}…), nothing to do`);
-            return null;
         }
-        log?.debug(`${TAG} spec changed: ${prevHash ? prevHash.slice(0, 12) + '…' : '<none>'} → ${nextHash.slice(0, 12)}…`);
-        return {
-            type: 'function',
-            params: {
-                fn: async () => {
-                    log?.info(`${TAG} regenerating project at ${targetDir} (doc=${doc.header.id})`);
-                    const t0 = Date.now();
-                    const warnings = [];
-                    const result = await generateProject({
-                        targetDir,
-                        spec,
-                        mode: 'update',
-                        onWarn: (m) => warnings.push(m),
-                    });
-                    await writeLastSpecHash(targetDir, nextHash);
-                    const elapsed = Date.now() - t0;
-                    if (log) {
-                        if (result.migrated)
-                            log.info(`${TAG} migrated flat → split layout`);
-                        log.info(`${TAG} regenerated in ${elapsed}ms: ${result.files.length} written, ${result.skipped.length} skipped, ${result.deleted.length} deleted`);
-                        for (const w of warnings)
-                            log.warn(`${TAG} ${w}`);
-                    }
-                },
-            },
-            callbacks: {
-                onFailure: (err) => {
-                    log?.error(`${TAG} regen failed: ${err.message}`);
-                    log?.debug(`${TAG} stack: ${err.stack ?? '<no stack>'}`);
-                },
-            },
-        };
+        // Work done inline, no additional work item needed
+        return null;
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/ph-clint-cli",
-  "version": "0.1.0-dev.10",
+  "version": "0.1.0-dev.101",
   "publishConfig": {
     "access": "public"
   },
@@ -10,40 +10,23 @@
     "ph-clint": "./dist/main.js"
   },
   "files": [
-    "dist",
-    "prompts"
+    "dist"
   ],
-  "scripts": {
-    "build:skills": "tsx scripts/build-skills.ts",
-    "build": "pnpm build:skills && tsc",
-    "dev": "tsx src/main.ts",
-    "start": "node dist/main.js",
-    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles",
-    "lint": "eslint src",
-    "mastra:dev": "mastra dev",
-    "mastra:build": "mastra build",
-    "mastra:start": "mastra start"
-  },
   "dependencies": {
-    "@powerhousedao/ph-clint": "^0.1.0-dev.10",
-    "@powerhousedao/ph-clint-app": "^0.1.0-dev.10",
-    "@mastra/core": "^1.22.0",
-    "@mastra/libsql": "^1.7.4",
-    "@mastra/memory": "^1.13.1",
-    "@powerhousedao/reactor": "6.0.0-dev.170",
-    "@powerhousedao/reactor-api": "6.0.0-dev.170",
-    "@powerhousedao/shared": "6.0.0-dev.170",
     "@electric-sql/pglite": "0.3.15",
-    "document-model": "6.0.0-dev.170",
+    "@mastra/core": "^1.41.0",
+    "@mastra/libsql": "^1.12.1",
+    "@mastra/memory": "^1.20.2",
+    "@powerhousedao/reactor": "6.2.0-rc.6",
+    "@powerhousedao/reactor-api": "6.2.0-rc.6",
+    "@powerhousedao/shared": "6.2.0-rc.6",
+    "document-model": "6.2.0-rc.6",
     "kysely": "^0.27.0",
     "kysely-pglite-dialect": "^1.3.0",
-    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.10",
-    "zod": "^4.3.6"
-  },
-  "pnpm": {
-    "overrides": {
-      "mastra>@mastra/deployer": "1.22.0"
-    }
+    "zod": "4.3.6",
+    "@powerhousedao/ph-clint-app": "0.1.0-dev.101",
+    "@powerhousedao/ph-clint-dev": "0.1.0-dev.101",
+    "@powerhousedao/ph-clint": "0.1.0-dev.101"
   },
   "devDependencies": {
     "@jest/globals": "^30.2.0",
@@ -55,5 +38,17 @@
   },
   "engines": {
     "node": ">=22.13.0"
+  },
+  "scripts": {
+    "build:skills": "tsx scripts/build-skills.ts",
+    "build": "pnpm build:skills && tsc",
+    "dev": "tsx src/main.ts",
+    "start": "node dist/main.js",
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles --coverage",
+    "test:e2e": "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles --testPathPatterns 'tests/(e2e|codegen-e2e)/' --testPathIgnorePatterns '/node_modules/'",
+    "lint": "eslint src",
+    "mastra:dev": "mastra dev",
+    "mastra:build": "mastra build",
+    "mastra:start": "mastra start"
   }
-}
+}

package/dist/codegen/builders/agent-base-md.d.ts

@@ -1,5 +0,0 @@
-/**
- * Builds `prompts/agent-profiles/AgentBase.md` — the minimal base profile.
- */
-import { type ClintProjectSpec } from '../../spec/types.js';
-export declare function buildAgentBaseMd(spec: ClintProjectSpec): string;

package/dist/codegen/builders/agent-base-md.js

@@ -1,18 +0,0 @@
-/**
- * Builds `prompts/agent-profiles/AgentBase.md` — the minimal base profile.
- */
-import { getPackageName, } from '../../spec/types.js';
-export function buildAgentBaseMd(spec) {
-    return [
-        '# Agent Base System Prompt',
-        '',
-        `You are {{agentName}}, an agent available through the ${getPackageName(spec)} CLI.`,
-        '',
-        '## Capabilities',
-        '',
-        'This base profile is a minimal placeholder. Extend it with project-specific',
-        "context, workflows, and domain knowledge. Additional sections listed in the",
-        "agent's `sections` array are concatenated after this file at build time.",
-        '',
-    ].join('\n');
-}

package/dist/codegen/builders/agent-ts.d.ts

@@ -1,9 +0,0 @@
-/**
- * Builds `src/agents/agent.ts` — a minimal Mastra agent factory.
- *
- * Emitted only when `features.mastra.enabled`. The generated agent falls back
- * to a deterministic echo-style demo provider when no API key is configured,
- * so `pnpm dev` works immediately out of the box.
- */
-import { type ClintProjectSpec } from '../../spec/types.js';
-export declare function buildAgentTs(spec: ClintProjectSpec): string;

package/dist/codegen/builders/agent-ts.js

@@ -1,34 +0,0 @@
-export function buildAgentTs(spec) {
-    const id = spec.name;
-    return [
-        "import type { AgentProvider, AgentSetupContext, StreamChunk } from '@powerhousedao/ph-clint';",
-        "import type { Config } from '../framework.js';",
-        '',
-        '/**',
-        ' * Demo agent — deterministic echo responses. Replace with a real Mastra',
-        " * `Agent` once you've wired your model + tools.",
-        ' */',
-        'function createDemoAgent(): AgentProvider {',
-        '  return {',
-        `    id: '${id}',`,
-        '    async *stream(prompt) {',
-        '      yield {',
-        "        type: 'text-delta',",
-        "        text: `You said: ${prompt}\\n(demo mode — set an API key and replace createDemoAgent with a Mastra Agent)`,",
-        '      } satisfies StreamChunk;',
-        '    },',
-        '  };',
-        '}',
-        '',
-        '/**',
-        ' * Agent factory invoked by `cli.configureAgent`. Receives the resolved',
-        ' * config and workdir; return an AgentProvider.',
-        ' */',
-        'export async function createAgent(',
-        '  _ctx: AgentSetupContext<Config>,',
-        '): Promise<AgentProvider> {',
-        '  return createDemoAgent();',
-        '}',
-        '',
-    ].join('\n');
-}

package/dist/codegen/builders/app-index-ts.d.ts

@@ -1,18 +0,0 @@
-/**
- * Builds `{name}-app/index.ts` — the top-level re-export barrel for the
- * reactor package. Impl code imports from `'{name}-app'` instead of drilling
- * into `'{name}-app/document-models/<slug>/v1/gen/...'`.
- *
- * Each entry re-exports a document-model subfolder's `index.ts`, which in
- * turn re-exports the module object (`PhClintProject`, ...), action creators,
- * document/state types, and type guards. Fully machine-owned: regen on every
- * run.
- *
- * Powerhouse's own codegen might emit its own `index.ts` (as is the case for
- * ph-clint-app today, which has manifest/editors/processors re-exports). When
- * that exists, leave it alone — users hand-merge. Our codegen only emits when
- * the file is absent or was emitted by a previous ph-clint-cli run (hash
- * matches the ledger).
- */
-import { type ClintProjectSpec } from '../../spec/types.js';
-export declare function buildAppIndexTs(spec: ClintProjectSpec): string | null;

package/dist/codegen/builders/app-index-ts.js

@@ -1,33 +0,0 @@
-/**
- * Builds `{name}-app/index.ts` — the top-level re-export barrel for the
- * reactor package. Impl code imports from `'{name}-app'` instead of drilling
- * into `'{name}-app/document-models/<slug>/v1/gen/...'`.
- *
- * Each entry re-exports a document-model subfolder's `index.ts`, which in
- * turn re-exports the module object (`PhClintProject`, ...), action creators,
- * document/state types, and type guards. Fully machine-owned: regen on every
- * run.
- *
- * Powerhouse's own codegen might emit its own `index.ts` (as is the case for
- * ph-clint-app today, which has manifest/editors/processors re-exports). When
- * that exists, leave it alone — users hand-merge. Our codegen only emits when
- * the file is absent or was emitted by a previous ph-clint-cli run (hash
- * matches the ledger).
- */
-import { getDocumentTypeSlug, } from '../../spec/types.js';
-export function buildAppIndexTs(spec) {
-    if (!spec.features.powerhouse.enabled)
-        return null;
-    if (spec.documentTypes.length === 0)
-        return null;
-    const lines = [];
-    lines.push('// THIS FILE IS GENERATED BY ph-clint-cli.');
-    lines.push('// Re-exports every registered document model from a single top-level');
-    lines.push('// entry so impl code can `import { ... } from \'{name}-app\'`.');
-    lines.push('');
-    for (const docType of spec.documentTypes) {
-        const slug = getDocumentTypeSlug(docType);
-        lines.push(`export * from './document-models/${slug}/index.js';`);
-    }
-    return lines.join('\n') + '\n';
-}

package/dist/codegen/builders/build-skills-ts.d.ts

@@ -1,4 +0,0 @@
-/**
- * Builds `scripts/build-skills.ts` — the build-time skill compiler.
- */
-export declare function buildBuildSkillsScript(): string;

package/dist/codegen/builders/build-skills-ts.js

@@ -1,37 +0,0 @@
-/**
- * Builds `scripts/build-skills.ts` — the build-time skill compiler.
- */
-export function buildBuildSkillsScript() {
-    return [
-        '#!/usr/bin/env tsx',
-        '/**',
-        ' * Build script — compiles Handlebars templates in `prompts/` into static',
-        ' * SKILL.md files and agent instruction strings under `gen/`, using',
-        " * ph-clint-dev's `buildSkills`.",
-        ' */',
-        "import path from 'node:path';",
-        "import { buildSkills } from '@powerhousedao/ph-clint-dev';",
-        "import { cli } from '../src/cli.js';",
-        '',
-        'const PROJECT_ROOT = path.resolve(import.meta.dirname, \'..\');',
-        '',
-        '// @clint:begin templateVars',
-        'function loadTemplateVars(): Record<string, string> {',
-        '  return {',
-        "    agentName: '{{AGENT_NAME}}',",
-        '  };',
-        '}',
-        '// @clint:end templateVars',
-        '',
-        'buildSkills({',
-        "  include: [path.join(PROJECT_ROOT, 'prompts')],",
-        '  context: loadTemplateVars(),',
-        '  output: [',
-        "    path.join(PROJECT_ROOT, 'gen'),",
-        "    path.join(PROJECT_ROOT, 'dist', 'gen'),",
-        '  ],',
-        '  cli,',
-        '});',
-        '',
-    ].join('\n');
-}

package/dist/codegen/builders/cli-package-json.d.ts

@@ -1,8 +0,0 @@
-/**
- * Builds the CLI-side `package.json` (the ph-clint CLI itself).
- *
- * When `features.powerhouse.enabled`, this file lives at
- * `{root}/{name}-cli/package.json`. Otherwise at `{root}/package.json`.
- */
-import { type ClintProjectSpec } from '../../spec/types.js';
-export declare function buildCliPackageJson(spec: ClintProjectSpec): string;

package/dist/codegen/builders/cli-package-json.js

@@ -1,96 +0,0 @@
-/**
- * Builds the CLI-side `package.json` (the ph-clint CLI itself).
- *
- * When `features.powerhouse.enabled`, this file lives at
- * `{root}/{name}-cli/package.json`. Otherwise at `{root}/package.json`.
- */
-import { getBinName, getPackageName, } from '../../spec/types.js';
-import { CLI_VERSION } from '../../config.js';
-/**
- * Derive a semver range from the running ph-clint-cli version that respects
- * the dev / staging / production channel boundary. This is the version range
- * emitted into *scaffolded* projects' package.json for @powerhousedao/ph-clint
- * and @powerhousedao/ph-clint-dev dependencies.
- *
- * CLI_VERSION is the version of ph-clint-cli itself (read from its own
- * package.json at startup). Since all framework packages share a lockstep
- * version, this is also the correct base for the dependency range.
- *
- * Examples:
- *   "0.1.0"            → "^0.1.0"            (production — stable only)
- *   "0.1.0-staging.2"  → "^0.1.0-staging.0"  (staging + stable)
- *   "0.1.0-dev.4"      → "^0.1.0-dev.0"      (dev + staging + stable)
- *
- * This works because semver orders prereleases alphabetically:
- * dev.N < staging.N < release. A caret range starting at dev.0 naturally
- * upgrades through staging to production.
- */
-function phClintRange(version) {
-    const match = /^(\d+\.\d+\.\d+)(?:-([a-z]+)\.\d+)?/.exec(version);
-    if (!match)
-        return `^${version}`;
-    const base = match[1];
-    const channel = match[2]; // "dev", "staging", or undefined
-    return channel ? `^${base}-${channel}.0` : `^${base}`;
-}
-/** Version range for @powerhousedao/ph-clint{,-dev} deps in scaffolded projects. */
-const PH_CLINT_VERSION = phClintRange(CLI_VERSION);
-const POWERHOUSE_VERSION = '6.0.0-dev.170';
-export function buildCliPackageJson(spec) {
-    const { mastra, powerhouse } = spec.features;
-    const pkgName = powerhouse.enabled
-        ? `${getPackageName(spec)}-cli`
-        : getPackageName(spec);
-    const bin = getBinName(spec);
-    const dependencies = {
-        '@powerhousedao/ph-clint': PH_CLINT_VERSION,
-        zod: '^4.3.6',
-    };
-    if (mastra.enabled) {
-        dependencies['@mastra/core'] = '^1.22.0';
-        dependencies['@mastra/libsql'] = '^1.7.4';
-        dependencies['@mastra/memory'] = '^1.13.1';
-    }
-    if (powerhouse.enabled) {
-        dependencies[`${spec.name}-app`] = `file:../${spec.name}-app`;
-        dependencies['@powerhousedao/reactor'] = POWERHOUSE_VERSION;
-        dependencies['@powerhousedao/reactor-api'] = POWERHOUSE_VERSION;
-        dependencies['@powerhousedao/shared'] = POWERHOUSE_VERSION;
-        dependencies['document-model'] = POWERHOUSE_VERSION;
-    }
-    const scripts = {
-        'build:skills': 'tsx scripts/build-skills.ts',
-        build: 'pnpm build:skills && tsc',
-        dev: 'tsx src/main.ts',
-        start: 'node dist/main.js',
-        test: "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles",
-        lint: 'eslint src',
-    };
-    if (mastra.enabled) {
-        scripts['mastra:dev'] = 'mastra dev';
-        scripts['mastra:build'] = 'mastra build';
-        scripts['mastra:start'] = 'mastra start';
-    }
-    const pkg = {
-        name: pkgName,
-        version: spec.version,
-        private: true,
-        type: 'module',
-    };
-    if (spec.description)
-        pkg.description = spec.description;
-    pkg.bin = { [bin]: './dist/main.js' };
-    pkg.scripts = scripts;
-    pkg.dependencies = dependencies;
-    pkg.devDependencies = {
-        '@jest/globals': '^30.2.0',
-        '@types/node': '^25.5.2',
-        jest: '^30.2.0',
-        '@powerhousedao/ph-clint-dev': PH_CLINT_VERSION,
-        'ts-jest': '^29.4.6',
-        tsx: '^4.19.0',
-        typescript: '^6.0.2',
-    };
-    pkg.engines = { node: '>=22.13.0' };
-    return JSON.stringify(pkg, null, 2) + '\n';
-}