@powerhousedao/ph-clint-cli 0.1.0-dev.7 → 0.1.0-dev.70

package/dist/cli.js

@@ -7,7 +7,8 @@
  * Everything outside the markers is user-editable and preserved.
  */
 import path from 'node:path';
-import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';
+import { defineCli, buildDefaultReactor, deterministicId } from '@powerhousedao/ph-clint';
+import { z } from 'zod';
 import { CLI_NAME, CLI_VERSION, CLI_ROOT } from './config.js';
 import { configSchema, secretsSchema } from './framework.js';
 // @clint:begin imports
@@ -18,30 +19,69 @@ import { regen } from './commands/clint-project-regen.js';
 import { build } from './commands/clint-project-build.js';
 import { clintProjectPublish } from './commands/clint-project-publish.js';
 import { clintProject } from './services/clint-project.js';
+import { skillsSync } from './commands/clint-skills-sync.js';
 import { specChangeTrigger } from './triggers/spec-change.js';
+import { publishTrigger } from './triggers/publish-trigger.js';
 // @clint:end imports
-// Connect (ph connect) must run inside the Reactor Package (ph-clint-app).
-const appDir = path.resolve(CLI_ROOT, '../ph-clint-app');
 export const cli = defineCli({
     name: CLI_NAME,
     version: CLI_VERSION,
+    root: CLI_ROOT,
     description: `${CLI_NAME} v${CLI_VERSION} — scaffold and maintain ph-clint implementation projects`,
     configSchema,
     secretsSchema,
     // @clint:begin commands
-    commands: [init, regen, build, clintProjectPublish],
+    commands: [init, regen, build, clintProjectPublish, skillsSync],
     // @clint:end commands
     // @clint:begin services
     services: [clintProject],
     // @clint:end services
     // @clint:begin triggers
-    triggers: [specChangeTrigger],
+    triggers: [specChangeTrigger, publishTrigger],
+    routine: { id: 'triggers', name: 'Triggers' },
     // @clint:end triggers
     // @clint:begin prompts
     prompts: {
-        sources: [],
-        agents: {},
-        skills: {},
+        artifacts: [path.join(CLI_ROOT, 'gen', 'skills'), path.join(CLI_ROOT, 'dist', 'gen', 'skills')],
+        agents: {
+            'ph-clint-dev-agent': {
+                name: 'PhClintDevAgent',
+                sections: ['AgentBase.md'],
+                skills: ['cli-setup', 'command-definition', 'service-definition'],
+            },
+        },
+        skills: {
+            'cli-setup': {
+                description: 'Set up a new CLI with defineCli, config schemas, entrypoint, and interactive mode',
+                inputSchema: z.object({
+                    mode: z
+                        .enum(['expert', 'discovery', 'one-shot'])
+                        .default('expert')
+                        .describe('Expert: align design decisions with the developer. Discovery: explain concepts step by step. One-shot: make all decisions autonomously'),
+                }),
+                instructionTemplate: 'Use your {{skillId}} skill in {{mode}} mode for: {{prompt}}',
+            },
+            'command-definition': {
+                description: 'Define commands with Zod schemas, execute functions, return values, and parameter prompting',
+                inputSchema: z.object({
+                    mode: z
+                        .enum(['expert', 'discovery', 'one-shot'])
+                        .default('expert')
+                        .describe('Expert: align design decisions with the developer. Discovery: explain concepts step by step. One-shot: make all decisions autonomously'),
+                }),
+                instructionTemplate: 'Use your {{skillId}} skill in {{mode}} mode for: {{prompt}}',
+            },
+            'service-definition': {
+                description: 'Define background services with readiness detection, preflight checks, and project scanning',
+                inputSchema: z.object({
+                    mode: z
+                        .enum(['expert', 'discovery', 'one-shot'])
+                        .default('expert')
+                        .describe('Expert: align design decisions with the developer. Discovery: explain concepts step by step. One-shot: make all decisions autonomously'),
+                }),
+                instructionTemplate: 'Use your {{skillId}} skill in {{mode}} mode for: {{prompt}}',
+            },
+        },
     },
     // @clint:end prompts
     // @clint:begin events
@@ -68,11 +108,13 @@ export const cli = defineCli({
 cli.configureReactor({
     create: (ctx) => buildDefaultReactor(ctx, {
         documentModels,
-        drive: { name: 'Clint' },
+        drives: [
+            { name: 'Clint Folders', role: 'personal', id: deterministicId(CLI_NAME, 'personal-drive') },
+        ],
         subscriptions: { documentTypes: ['powerhouse/ph-clint-project'] },
     }),
     switchboard: { enabled: true },
-    connect: { enabled: true, workdir: appDir },
+    connect: { enabled: true },
 });
 // @clint:end reactor
 // @clint:begin mastra

package/dist/codegen/actions.d.ts

@@ -0,0 +1 @@
+export { type PostGenAction, type PostGenActionKind, type PostGenActionContext, type PostGenActionResult, collectPostGenActions, runPostGenActions, } from '@powerhousedao/ph-clint-dev/codegen/actions';

package/dist/codegen/actions.js

@@ -0,0 +1 @@
+export { collectPostGenActions, runPostGenActions, } from '@powerhousedao/ph-clint-dev/codegen/actions';

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

@@ -1,9 +1,9 @@
 /**
- * Builds `src/agents/agent.ts` — a minimal Mastra agent factory.
+ * Builds `src/agents/agent.ts` — a 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.
+ * Emitted only when `features.mastra.enabled`. When the spec includes agent
+ * config (agentId, models, profiles), generates a real `@mastra/core` Agent.
+ * Otherwise falls back to a deterministic echo-style demo provider.
  */
 import { type ClintProjectSpec } from '../../spec/types.js';
 export declare function buildAgentTs(spec: ClintProjectSpec): string;

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

@@ -1,5 +1,20 @@
-export function buildAgentTs(spec) {
-    const id = spec.name;
+/** Map provider prefix to AI SDK package. */
+function providerImport(provider) {
+    switch (provider) {
+        case 'anthropic':
+            return { pkg: '@ai-sdk/anthropic', fn: 'anthropic' };
+        case 'openai':
+            return { pkg: '@ai-sdk/openai', fn: 'openai' };
+        case 'google':
+            return { pkg: '@ai-sdk/google', fn: 'google' };
+        default:
+            return { pkg: `@ai-sdk/${provider}`, fn: provider };
+    }
+}
+function buildDemoAgent(spec) {
+    const mastra = spec.features.mastra;
+    const id = mastra.agentId ?? spec.name;
+    const name = mastra.agentName ?? id;
     return [
         "import type { AgentProvider, AgentSetupContext, StreamChunk } from '@powerhousedao/ph-clint';",
         "import type { Config } from '../framework.js';",
@@ -11,6 +26,7 @@ export function buildAgentTs(spec) {
         'function createDemoAgent(): AgentProvider {',
         '  return {',
         `    id: '${id}',`,
+        `    name: '${name}',`,
         '    async *stream(prompt) {',
         '      yield {',
         "        type: 'text-delta',",
@@ -32,3 +48,77 @@ export function buildAgentTs(spec) {
         '',
     ].join('\n');
 }
+function buildRealAgent(spec) {
+    const mastra = spec.features.mastra;
+    const agentId = mastra.agentId;
+    const agentName = mastra.agentName;
+    const defaultModel = mastra.models.find(m => m.isDefault) ?? mastra.models[0];
+    const modelId = defaultModel?.id ?? 'anthropic/claude-sonnet-4-5';
+    const [provider] = modelId.split(/[:/]/);
+    const { pkg, fn } = providerImport(provider);
+    const apiKeyField = `${provider}ApiKey`;
+    const lines = [];
+    lines.push("import { Agent } from '@mastra/core/agent';");
+    lines.push("import { MCPClient } from '@mastra/mcp';");
+    lines.push("import { createMastraHelpers } from '@powerhousedao/ph-clint/mastra';");
+    lines.push("import { createWorkdirStore } from '@powerhousedao/ph-clint';");
+    lines.push("import type { AgentSetupContext, AgentProvider } from '@powerhousedao/ph-clint';");
+    lines.push("import type { WrapAgentOptions } from '@powerhousedao/ph-clint/mastra';");
+    lines.push("import { CLI_NAME } from '../config.js';");
+    lines.push("import type { Config } from '../framework.js';");
+    lines.push("import { createDemoAgent } from './demo-agent.js';");
+    lines.push('');
+    lines.push('/**');
+    lines.push(' * Agent factory for the CLI.');
+    lines.push(' *');
+    lines.push(' * Returns a demo agent when no API key is configured, or wraps the full');
+    lines.push(' * agent as a ph-clint AgentProvider.');
+    lines.push(' */');
+    lines.push('export async function createAgent(ctx: AgentSetupContext<Config>): Promise<AgentProvider> {');
+    lines.push(`  if (!ctx.config.${apiKeyField}) return createDemoAgent();`);
+    lines.push('');
+    lines.push('  const m = createMastraHelpers(ctx);');
+    lines.push('');
+    lines.push('  const agent = new Agent({');
+    lines.push(`    id: '${agentId}',`);
+    lines.push(`    name: '${agentName}',`);
+    lines.push(`    instructions: m.getAgentInstructions('${agentId}'),`);
+    lines.push(`    model: ctx.config.${apiKeyField}`);
+    lines.push(`      ? { id: ctx.config.model as \`\${string}/\${string}\`, apiKey: ctx.config.${apiKeyField} }`);
+    lines.push(`      : (ctx.config.model as \`\${string}/\${string}\`),`);
+    lines.push('    tools: async () => {');
+    lines.push("      ctx.context.log?.debug('[agent] tools callback invoked');");
+    lines.push('      const tools = await m.getTools({ MCPClient });');
+    lines.push("      ctx.context.log?.debug(`[agent] tools resolved: ${Object.keys(tools).length} tools`);");
+    lines.push('      return tools;');
+    lines.push('    },');
+    lines.push('    workspace: await m.createWorkspace(),');
+    lines.push('    memory: await m.createMemory(),');
+    lines.push('  });');
+    lines.push('');
+    lines.push('  const store = createWorkdirStore(ctx.workdir, CLI_NAME);');
+    lines.push('  const wrapOpts: WrapAgentOptions = {');
+    lines.push('    maxSteps: 80,');
+    lines.push('    enableLogging: ctx.config.agentLogging,');
+    lines.push("    logDirectory: store.getStoreFolder('logs'),");
+    lines.push('    cacheControl: true,');
+    if (mastra.agentDescription) {
+        lines.push(`    description: ${JSON.stringify(mastra.agentDescription)},`);
+    }
+    if (mastra.agentImage) {
+        lines.push(`    image: ${JSON.stringify(mastra.agentImage)},`);
+    }
+    lines.push('  };');
+    lines.push('  return m.wrapAgent(agent, wrapOpts);');
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}
+export function buildAgentTs(spec) {
+    const mastra = spec.features.mastra;
+    // Generate real agent when we have full config, demo otherwise
+    if (mastra.agentId && mastra.models.length > 0) {
+        return buildRealAgent(spec);
+    }
+    return buildDemoAgent(spec);
+}

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

@@ -3,16 +3,9 @@
  * 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).
+ * Only re-exports document types belonging to the app package (the project's
+ * own reactor package). External packages' document types are imported from
+ * their own npm packages, not from the app barrel.
  */
 import { type ClintProjectSpec } from '../../spec/types.js';
 export declare function buildAppIndexTs(spec: ClintProjectSpec): string | null;

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

@@ -3,31 +3,41 @@
  * 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).
+ * Only re-exports document types belonging to the app package (the project's
+ * own reactor package). External packages' document types are imported from
+ * their own npm packages, not from the app barrel.
  */
-import { getDocumentTypeSlug, } from '../../spec/types.js';
+import { getAppPackageName, getDocumentTypeSlug, isDocTypeGlob, phAtLeast, } from '../../spec/types.js';
 export function buildAppIndexTs(spec) {
-    if (!spec.features.powerhouse.enabled)
-        return null;
-    if (spec.documentTypes.length === 0)
+    if (!phAtLeast(spec.features.powerhouse, 'Reactor'))
         return null;
     const lines = [];
+    // Standard Powerhouse reactor-package barrel — matches what `ph init`
+    // generates. Required by main.tsx (Connect) and cli.ts imports.
     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';`);
+    lines.push("import type { Manifest } from 'document-model';");
+    lines.push("import manifestJson from './powerhouse.manifest.json' with { type: 'json' };");
+    lines.push("export { documentModels } from './document-models/document-models.js';");
+    lines.push("export { upgradeManifests } from './document-models/upgrade-manifests.js';");
+    lines.push("export { editors } from './editors/editors.js';");
+    lines.push("export { processorFactory } from './processors/factory.js';");
+    lines.push('export const manifest: Manifest = manifestJson;');
+    // Per-document-type re-exports so impl code can import from
+    // '{name}-app' instead of drilling into deep paths.
+    const appPkg = getAppPackageName(spec);
+    const appEntry = spec.packages.find((p) => p.packageName === appPkg);
+    const docTypes = appEntry?.documentTypes ?? [];
+    if (docTypes.length > 0) {
+        const hasGlobs = docTypes.some(isDocTypeGlob);
+        const explicits = docTypes.filter((dt) => !isDocTypeGlob(dt));
+        lines.push('');
+        if (hasGlobs) {
+            lines.push("export * from './document-models/index.js';");
+        }
+        for (const docType of explicits) {
+            const slug = getDocumentTypeSlug(docType);
+            lines.push(`export * from './document-models/${slug}/index.js';`);
+        }
     }
     return lines.join('\n') + '\n';
 }

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

@@ -1,8 +1 @@
-/**
- * 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;
+export { buildCliPackageJson } from '@powerhousedao/ph-clint-dev/codegen/builders';

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

@@ -1,96 +1 @@
-/**
- * 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';
-}
+export { buildCliPackageJson } from '@powerhousedao/ph-clint-dev/codegen/builders';

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

@@ -1,5 +1,17 @@
+/**
+ * Builds `src/cli.ts` — the defineCli() call with feature blocks guarded by
+ * `@clint:begin`/`@clint:end` markers so the code generator can patch
+ * specific regions on subsequent runs (delta mode — future phase).
+ */
+import { getAppPackageName, phAtLeast } from '../../spec/types.js';
+/** External packages that have document types (not the app package). */
+function getExternalPackages(spec) {
+    const appPkg = getAppPackageName(spec);
+    return spec.packages.filter((p) => p.packageName !== appPkg && p.documentTypes.length > 0);
+}
 export function buildCliTs(spec) {
     const { mastra, routine, powerhouse } = spec.features;
+    const ph = powerhouse;
     const lines = [];
     lines.push('/**');
     lines.push(' * CLI definition.');
@@ -8,32 +20,42 @@ export function buildCliTs(spec) {
     lines.push(' * markers are rewritten by ph-clint when the project spec changes.');
     lines.push(' * Everything outside the markers is user-editable and preserved.');
     lines.push(' */');
-    if (powerhouse.enabled) {
-        lines.push(`import path from 'node:path';`);
-        lines.push(`import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';`);
-    }
-    else {
-        lines.push(`import { defineCli } from '@powerhousedao/ph-clint';`);
+    const needsRoot = phAtLeast(ph, 'Reactor') || mastra.enabled;
+    lines.push('// @clint:begin imports');
+    const phClintImports = ['defineCli'];
+    if (phAtLeast(ph, 'Reactor'))
+        phClintImports.push('buildDefaultReactor');
+    // proxy has no additional imports
+    lines.push(`import { ${phClintImports.join(', ')} } from '@powerhousedao/ph-clint';`);
+    if (needsRoot) {
+        lines.push("import path from 'node:path';");
     }
-    lines.push(`import { CLI_NAME, CLI_VERSION${powerhouse.enabled ? ', CLI_ROOT' : ''} } from './config.js';`);
+    lines.push(`import { CLI_NAME, CLI_VERSION${needsRoot ? ', CLI_ROOT' : ''} } from './config.js';`);
     lines.push(`import { configSchema, secretsSchema } from './framework.js';`);
-    lines.push('');
-    lines.push('// @clint:begin imports');
-    if (powerhouse.enabled) {
-        lines.push(`import { documentModels } from '${spec.name}-app';`);
+    if (phAtLeast(ph, 'Reactor')) {
+        lines.push(`import { documentModels } from '${getAppPackageName(spec)}';`);
+        const extPkgs = getExternalPackages(spec);
+        for (let i = 0; i < extPkgs.length; i++) {
+            const alias = extPkgs.length === 1 ? 'extModels' : `extModels${i}`;
+            lines.push(`import { documentModels as ${alias} } from '${extPkgs[i].packageName}';`);
+        }
     }
     if (mastra.enabled) {
         lines.push(`import { createAgent } from './agents/agent.js';`);
     }
+    if (mastra.enabled && mastra.common?.enableChat) {
+        lines.push(`import { chatSessionWatchTrigger } from '@powerhousedao/clint-common/chat';`);
+    }
     lines.push('// @clint:end imports');
     lines.push('');
-    if (powerhouse.enabled) {
-        lines.push(`const appDir = path.resolve(CLI_ROOT, '../${spec.name}-app');`);
-        lines.push('');
-    }
     lines.push('export const cli = defineCli({');
     lines.push('  name: CLI_NAME,');
     lines.push('  version: CLI_VERSION,');
+    lines.push('  // @clint:begin root');
+    if (phAtLeast(ph, 'Reactor')) {
+        lines.push('  root: CLI_ROOT,');
+    }
+    lines.push('  // @clint:end root');
     lines.push('  description: `${CLI_NAME} v${CLI_VERSION}`,');
     lines.push('  configSchema,');
     lines.push('  secretsSchema,');
@@ -47,8 +69,8 @@ export function buildCliTs(spec) {
     lines.push('  // @clint:end services');
     lines.push('');
     lines.push('  // @clint:begin triggers');
-    if (routine.enabled) {
-        lines.push('  triggers: [],');
+    if (mastra.enabled && mastra.common?.enableChat) {
+        lines.push('  triggers: [chatSessionWatchTrigger],');
     }
     else {
         lines.push('  triggers: [],');
@@ -57,8 +79,34 @@ export function buildCliTs(spec) {
     lines.push('');
     lines.push('  // @clint:begin prompts');
     lines.push('  prompts: {');
-    lines.push('    sources: [],');
-    lines.push('    agents: {},');
+    if (mastra.enabled) {
+        lines.push("    artifacts: [path.join(CLI_ROOT, 'gen', 'skills'), path.join(CLI_ROOT, 'dist', 'gen', 'skills')],");
+    }
+    else {
+        lines.push('    artifacts: [],');
+    }
+    if (mastra.enabled && mastra.agentId) {
+        lines.push('    agents: {');
+        lines.push(`      '${mastra.agentId}': {`);
+        if (mastra.profiles.length > 0) {
+            lines.push(`        name: '${mastra.profiles[0].id}',`);
+            lines.push('        sections: [');
+            for (const p of mastra.profiles) {
+                lines.push(`          '${p.id}.md',`);
+            }
+            lines.push('        ],');
+        }
+        else {
+            lines.push("        name: 'AgentBase',");
+            lines.push("        sections: ['AgentBase.md'],");
+        }
+        lines.push('        skills: [],');
+        lines.push('      },');
+        lines.push('    },');
+    }
+    else {
+        lines.push('    agents: {},');
+    }
     lines.push('    skills: {},');
     lines.push('  },');
     lines.push('  // @clint:end prompts');
@@ -67,29 +115,24 @@ export function buildCliTs(spec) {
     lines.push('  events: {},');
     lines.push('  // @clint:end events');
     lines.push('');
+    lines.push('  // @clint:begin proxy');
+    if (spec.deployment.proxyEnabled) {
+        lines.push('  proxyEnabled: true,');
+    }
+    lines.push('  // @clint:end proxy');
+    lines.push('');
     lines.push('  // @clint:begin interactive');
     lines.push('  interactive: {');
-    const ctxArgs = [];
-    if (powerhouse.enabled && (powerhouse.switchboard || powerhouse.connect)) {
-        ctxArgs.push('config');
-    }
-    ctxArgs.push('workdir');
-    lines.push(`    welcome: ({ ${ctxArgs.join(', ')} }) =>`);
+    lines.push(`    welcome: ({ workdir }) =>`);
     lines.push('      [');
     lines.push('        `${CLI_NAME} v${CLI_VERSION}`,');
     lines.push('        `Workdir: ${workdir}`,');
-    if (powerhouse.enabled && powerhouse.switchboard) {
-        lines.push('        `Switchboard: http://localhost:${config.switchboardPort}`,');
-    }
-    if (powerhouse.enabled && powerhouse.connect) {
-        lines.push('        `Connect:     http://localhost:${config.connectPort}`,');
-    }
     lines.push("        '',");
     if (mastra.enabled) {
-        lines.push("        'Type a message to talk to the agent, or /help for commands.',");
+        lines.push("        'Type a message to talk to the agent, or / for commands.',");
     }
     else {
-        lines.push("        'Type /help for commands.',");
+        lines.push("        'Type / for commands or /cli-docs for help.',");
     }
     lines.push("      ].join('\\n'),");
     lines.push('  },');
@@ -97,15 +140,23 @@ export function buildCliTs(spec) {
     lines.push('});');
     lines.push('');
     lines.push('// @clint:begin reactor');
-    if (powerhouse.enabled) {
+    if (phAtLeast(ph, 'Reactor')) {
         lines.push('cli.configureReactor({');
         lines.push('  create: (ctx) =>');
         lines.push('    buildDefaultReactor(ctx, {');
-        lines.push('      documentModels,');
+        const extPkgs = getExternalPackages(spec);
+        if (extPkgs.length === 0) {
+            lines.push('      documentModels,');
+        }
+        else {
+            const aliases = extPkgs.map((_, i) => extPkgs.length === 1 ? 'extModels' : `extModels${i}`);
+            lines.push(`      documentModels: [...documentModels, ${aliases.map(a => `...${a}`).join(', ')}],`);
+        }
         lines.push(`      drive: { name: '${spec.name}' },`);
+        lines.push('      subscriptions: {},');
         lines.push('    }),');
-        lines.push(`  switchboard: { enabled: ${String(powerhouse.switchboard)} },`);
-        lines.push(`  connect: { enabled: ${String(powerhouse.connect)}, workdir: appDir },`);
+        lines.push(`  switchboard: { enabled: ${String(phAtLeast(ph, 'Switchboard'))} },`);
+        lines.push(`  connect: { enabled: ${String(phAtLeast(ph, 'Connect'))} },`);
         lines.push('});');
     }
     lines.push('// @clint:end reactor');

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

@@ -5,4 +5,4 @@
  * can extend them without fighting the generator.
  */
 import { type ClintProjectSpec } from '../../spec/types.js';
-export declare function buildConfigTs(spec: ClintProjectSpec): string;
+export declare function buildConfigTs(_spec: ClintProjectSpec): string;

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

@@ -1,17 +1,11 @@
-export function buildConfigTs(spec) {
-    const hasCustomBin = !!spec.bin;
+export function buildConfigTs(_spec) {
     const lines = [];
     lines.push(`import { readPackageInfo } from '@powerhousedao/ph-clint';`);
     lines.push('');
     lines.push('const pkg = readPackageInfo(import.meta.url);');
     lines.push('');
     lines.push('export const CLI_ROOT = pkg.root;');
-    if (hasCustomBin) {
-        lines.push(`export const CLI_NAME = '${spec.bin}';`);
-    }
-    else {
-        lines.push(`export const CLI_NAME = pkg.name.replace(/-cli$/, '');`);
-    }
+    lines.push(`export const CLI_NAME = pkg.name.replace(/-cli$/, '');`);
     lines.push('export const CLI_VERSION = pkg.version;');
     return lines.join('\n') + '\n';
 }