@powerhousedao/ph-clint-cli 0.1.0-dev.4 → 0.1.0-dev.41

package/dist/cli.js

@@ -7,9 +7,9 @@
  * Everything outside the markers is user-editable and preserved.
  */
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';
-import { CLI_NAME, CLI_VERSION } from './config.js';
+import { z } from 'zod';
+import { CLI_NAME, CLI_VERSION, CLI_ROOT } from './config.js';
 import { configSchema, secretsSchema } from './framework.js';
 // @clint:begin imports
 import { documentModels } from '@powerhousedao/ph-clint-app';
@@ -19,31 +19,68 @@ 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 __dirname = path.dirname(fileURLToPath(import.meta.url));
-const appDir = path.resolve(__dirname, '../../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],
     // @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
@@ -70,11 +107,13 @@ export const cli = defineCli({
 cli.configureReactor({
     create: (ctx) => buildDefaultReactor(ctx, {
         documentModels,
-        drive: { name: 'Clint' },
+        drives: [
+            { name: 'Clint Folders', role: 'personal' },
+        ],
         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,42 @@
+import type { GenerateProjectResult } from './index.js';
+import type { ClintProjectSpec, ExternalSkill } from '../spec/types.js';
+import type { ProcessRunOptions } from '@powerhousedao/ph-clint';
+export type PostGenAction = {
+    kind: 'ph-init';
+    targetDir: string;
+    appDir: string;
+    spec: ClintProjectSpec;
+} | {
+    kind: 'app-install';
+    dir: string;
+} | {
+    kind: 'app-build';
+    dir: string;
+} | {
+    kind: 'cli-install';
+    dir: string;
+} | {
+    kind: 'cli-build';
+    dir: string;
+} | {
+    kind: 'skills-sync';
+    targetDir: string;
+    desired: ExternalSkill[];
+};
+export type PostGenActionKind = PostGenAction['kind'];
+export interface PostGenActionContext {
+    log: (msg: string) => void;
+    runProcess?: (command: string, opts?: Omit<ProcessRunOptions, 'onOutput'>) => Promise<{
+        success: boolean;
+        output: string;
+    }>;
+    skip?: Set<PostGenActionKind>;
+}
+export interface PostGenActionResult {
+    action: PostGenAction;
+    status: 'success' | 'failed' | 'skipped';
+    reason?: string;
+    durationMs: number;
+}
+export declare function collectPostGenActions(result: GenerateProjectResult, spec: ClintProjectSpec): Promise<PostGenAction[]>;
+export declare function runPostGenActions(actions: PostGenAction[], ctx: PostGenActionContext): Promise<PostGenActionResult[]>;

package/dist/codegen/actions.js

@@ -0,0 +1,387 @@
+/**
+ * Post-generation actions — a typed pipeline that runs after codegen.
+ *
+ * `collectPostGenActions()` inspects a `GenerateProjectResult` to determine
+ * which side-effects (install, build, ph-init, skills-sync) are needed.
+ *
+ * `runPostGenActions()` executes them sequentially with proper ordering,
+ * failure cascading, and log output.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+// ---------------------------------------------------------------------------
+// Fixed execution order — index defines precedence
+// ---------------------------------------------------------------------------
+const ACTION_ORDER = [
+    'ph-init',
+    'app-install',
+    'app-build',
+    'cli-install',
+    'cli-build',
+    'skills-sync',
+];
+function actionIndex(kind) {
+    return ACTION_ORDER.indexOf(kind);
+}
+// ---------------------------------------------------------------------------
+// Dependency map — which actions depend on which (for failure cascading)
+// ---------------------------------------------------------------------------
+/** Returns true if `downstream` depends on `upstream` succeeding. */
+function dependsOn(downstream, upstream) {
+    // ph-init → app-install → app-build → cli-install → cli-build
+    // skills-sync is independent of the build chain
+    const chain = [
+        'ph-init',
+        'app-install',
+        'app-build',
+        'cli-install',
+        'cli-build',
+    ];
+    if (downstream === 'skills-sync')
+        return false;
+    const di = chain.indexOf(downstream);
+    const ui = chain.indexOf(upstream);
+    if (di < 0 || ui < 0)
+        return false;
+    return di > ui;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// collectPostGenActions
+// ---------------------------------------------------------------------------
+export async function collectPostGenActions(result, spec) {
+    const split = result.appDir !== null;
+    const relPaths = new Set(result.files.map((f) => f.relativePath));
+    // Determine the earliest triggered action in the chain
+    let earliest = null;
+    if (split) {
+        const appFolder = result.appDir ? path.basename(result.appDir) : '';
+        const cliFolder = path.basename(result.cliDir);
+        // ph-init needed: app dir placeholder written but app not yet initialized.
+        // Check the actual filesystem — if package.json already exists on disk,
+        // ph init has already run and must not run again.
+        const appPkgJsonChanged = relPaths.has(path.join(appFolder, 'package.json'));
+        const appGitkeepWritten = relPaths.has(path.join(appFolder, '.gitkeep'));
+        // ph-init needed: app dir placeholder written but app not yet initialized.
+        // Check the actual filesystem — if package.json already exists on disk,
+        // ph init has already run and must not run again.
+        if (appGitkeepWritten && !appPkgJsonChanged) {
+            const appAlreadyInitialized = result.appDir
+                ? await fileExists(path.join(result.appDir, 'package.json'))
+                : false;
+            if (!appAlreadyInitialized) {
+                earliest = 'ph-init';
+            }
+        }
+        // Migration always triggers full rebuild
+        if (result.migrated) {
+            earliest = earliest ?? 'app-install';
+        }
+        // App package.json changed
+        if (!earliest && appPkgJsonChanged) {
+            earliest = 'app-install';
+        }
+        // App source regenerated (framework.gen.ts, index.ts, etc.)
+        if (!earliest) {
+            for (const rel of relPaths) {
+                if (rel.startsWith(appFolder + '/') &&
+                    rel.endsWith('.ts')) {
+                    earliest = 'app-build';
+                    break;
+                }
+            }
+        }
+        // CLI package.json changed
+        if (!earliest) {
+            if (relPaths.has(path.join(cliFolder, 'package.json'))) {
+                earliest = 'cli-install';
+            }
+        }
+        // CLI source or prompts regenerated (.ts files, agent profile .md files)
+        if (!earliest) {
+            for (const rel of relPaths) {
+                if (rel.startsWith(cliFolder + '/') &&
+                    (rel.endsWith('.ts') || rel.endsWith('.md'))) {
+                    earliest = 'cli-build';
+                    break;
+                }
+            }
+        }
+    }
+    else {
+        // Flat layout
+        if (relPaths.has('package.json')) {
+            earliest = 'cli-install';
+        }
+        else {
+            for (const rel of relPaths) {
+                if (rel.endsWith('.ts') || rel.endsWith('.md')) {
+                    earliest = 'cli-build';
+                    break;
+                }
+            }
+        }
+    }
+    // Build the action list from earliest onward
+    const actions = [];
+    if (earliest && split && result.appDir) {
+        const ei = actionIndex(earliest);
+        if (ei <= actionIndex('ph-init')) {
+            actions.push({
+                kind: 'ph-init',
+                targetDir: path.dirname(result.appDir),
+                appDir: result.appDir,
+                spec,
+            });
+        }
+        if (ei <= actionIndex('app-install')) {
+            actions.push({ kind: 'app-install', dir: result.appDir });
+        }
+        if (ei <= actionIndex('app-build')) {
+            // Add install if not already in the list and node_modules is missing
+            if (!actions.some(a => a.kind === 'app-install') &&
+                !(await fileExists(path.join(result.appDir, 'node_modules')))) {
+                actions.push({ kind: 'app-install', dir: result.appDir });
+            }
+            actions.push({ kind: 'app-build', dir: result.appDir });
+        }
+        if (ei <= actionIndex('cli-install')) {
+            actions.push({ kind: 'cli-install', dir: result.cliDir });
+        }
+        if (ei <= actionIndex('cli-build')) {
+            // Add install if not already in the list and node_modules is missing
+            if (!actions.some(a => a.kind === 'cli-install') &&
+                !(await fileExists(path.join(result.cliDir, 'node_modules')))) {
+                actions.push({ kind: 'cli-install', dir: result.cliDir });
+            }
+            actions.push({ kind: 'cli-build', dir: result.cliDir });
+        }
+    }
+    else if (earliest && !split) {
+        const ei = actionIndex(earliest);
+        if (ei <= actionIndex('cli-install')) {
+            actions.push({ kind: 'cli-install', dir: result.cliDir });
+        }
+        if (ei <= actionIndex('cli-build')) {
+            // Add install if not already in the list and node_modules is missing
+            if (!actions.some(a => a.kind === 'cli-install') &&
+                !(await fileExists(path.join(result.cliDir, 'node_modules')))) {
+                actions.push({ kind: 'cli-install', dir: result.cliDir });
+            }
+            actions.push({ kind: 'cli-build', dir: result.cliDir });
+        }
+    }
+    // skills-sync is independent — append if needed
+    if (spec.externalSkills.length > 0) {
+        const targetDir = split ? result.cliDir : result.cliDir;
+        actions.push({
+            kind: 'skills-sync',
+            targetDir,
+            desired: spec.externalSkills,
+        });
+    }
+    return actions;
+}
+// ---------------------------------------------------------------------------
+// Human-readable label for an action
+// ---------------------------------------------------------------------------
+function actionLabel(action) {
+    switch (action.kind) {
+        case 'ph-init':
+            return `Initialize reactor package (${path.basename(action.appDir)})`;
+        case 'app-install':
+            return `Install dependencies (${path.basename(action.dir)})`;
+        case 'app-build':
+            return `Build (${path.basename(action.dir)})`;
+        case 'cli-install':
+            return `Install dependencies (${path.basename(action.dir)})`;
+        case 'cli-build':
+            return `Build (${path.basename(action.dir)})`;
+        case 'skills-sync':
+            return `Sync external skills (${action.desired.length} skill${action.desired.length === 1 ? '' : 's'})`;
+    }
+}
+// ---------------------------------------------------------------------------
+// runPostGenActions — effectful runner
+// ---------------------------------------------------------------------------
+export async function runPostGenActions(actions, ctx) {
+    if (actions.length === 0)
+        return [];
+    const skip = ctx.skip ?? new Set();
+    // Filter out explicitly skipped actions. Also skip builds if their
+    // corresponding install is skipped (building without install is pointless).
+    const effective = actions.filter((a) => {
+        if (skip.has(a.kind))
+            return false;
+        // If app-install is skipped, also skip app-build
+        if (a.kind === 'app-build' && skip.has('app-install'))
+            return false;
+        // If cli-install is skipped, also skip cli-build
+        if (a.kind === 'cli-build' && skip.has('cli-install'))
+            return false;
+        return true;
+    });
+    if (effective.length === 0)
+        return [];
+    // Print numbered summary
+    ctx.log(`\nPost-generation steps (${effective.length}):`);
+    effective.forEach((a, i) => {
+        ctx.log(`  ${i + 1}. ${actionLabel(a)}`);
+    });
+    ctx.log('');
+    const results = [];
+    const failed = new Set();
+    for (let i = 0; i < effective.length; i++) {
+        const action = effective[i];
+        const label = actionLabel(action);
+        const prefix = `[${i + 1}/${effective.length}]`;
+        // Check if a dependency failed
+        const failedDep = [...failed].find((f) => dependsOn(action.kind, f));
+        if (failedDep) {
+            ctx.log(`${prefix} ${label}... skipped (dependency failed)`);
+            results.push({
+                action,
+                status: 'skipped',
+                reason: 'dependency failed',
+                durationMs: 0,
+            });
+            continue;
+        }
+        ctx.log(`${prefix} ${label}...`);
+        const t0 = Date.now();
+        try {
+            const success = await executeAction(action, ctx);
+            const elapsed = Date.now() - t0;
+            if (success) {
+                ctx.log(`      done (${formatDuration(elapsed)})`);
+                results.push({ action, status: 'success', durationMs: elapsed });
+            }
+            else {
+                ctx.log(`      FAILED`);
+                results.push({ action, status: 'failed', durationMs: elapsed });
+                failed.add(action.kind);
+            }
+        }
+        catch (err) {
+            const elapsed = Date.now() - t0;
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.log(`      FAILED: ${msg}`);
+            results.push({
+                action,
+                status: 'failed',
+                reason: msg,
+                durationMs: elapsed,
+            });
+            failed.add(action.kind);
+        }
+    }
+    // Print summary
+    const succeeded = results.filter((r) => r.status === 'success').length;
+    const failedCount = results.filter((r) => r.status === 'failed').length;
+    const skippedCount = results.filter((r) => r.status === 'skipped').length;
+    ctx.log('');
+    if (failedCount === 0 && skippedCount === 0) {
+        ctx.log(`Post-generation: ${succeeded} step${succeeded === 1 ? '' : 's'} completed successfully.`);
+        ctx.log('Ready — run `pnpm dev` to start.');
+    }
+    else {
+        ctx.log(`Post-generation: ${succeeded} succeeded, ${failedCount} failed, ${skippedCount} skipped.`);
+        if (failedCount > 0) {
+            ctx.log('Fix the reported error(s) and re-run `ph-clint clint-project-regen`.');
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Action dispatch
+// ---------------------------------------------------------------------------
+async function executeAction(action, ctx) {
+    switch (action.kind) {
+        case 'ph-init': {
+            const { runPhInit } = await import('./scaffold.js');
+            const result = await runPhInit({
+                targetDir: action.targetDir,
+                appDir: action.appDir,
+                spec: action.spec,
+                log: (msg) => ctx.log(`      ${msg}`),
+                runProcess: ctx.runProcess,
+            });
+            if (!result.ran) {
+                ctx.log(`      ${result.reason ?? 'ph init did not run'}`);
+                return false;
+            }
+            if (result.exitCode === 0) {
+                // Mark app as initialized in generated state
+                const { readGeneratedState, writeGeneratedState } = await import('./generated.js');
+                const gen = await readGeneratedState(action.targetDir);
+                if (gen) {
+                    gen.appInitialized = true;
+                    await writeGeneratedState(action.targetDir, gen);
+                }
+            }
+            return result.exitCode === 0;
+        }
+        case 'app-install':
+        case 'cli-install': {
+            if (ctx.runProcess) {
+                const result = await ctx.runProcess('pnpm install', {
+                    cwd: action.dir,
+                    timeout: 300_000,
+                });
+                return result.success;
+            }
+            // Fallback: direct spawn
+            const { runCommand } = await import('./exec.js');
+            const result = await runCommand('pnpm', ['install'], {
+                cwd: action.dir,
+                stdio: 'inherit',
+            });
+            return result.exitCode === 0;
+        }
+        case 'app-build':
+        case 'cli-build': {
+            return runBuild(action.dir, ctx);
+        }
+        case 'skills-sync': {
+            const { syncExternalSkills } = await import('../skills/sync.js');
+            await syncExternalSkills({
+                targetDir: action.targetDir,
+                desired: action.desired,
+                log: (msg) => ctx.log(`      ${msg}`),
+            });
+            return true;
+        }
+    }
+}
+async function runBuild(dir, ctx) {
+    if (ctx.runProcess) {
+        const result = await ctx.runProcess('pnpm build', {
+            cwd: dir,
+            timeout: 120_000,
+        });
+        return result.success;
+    }
+    // Fallback: direct spawn
+    const { runCommand } = await import('./exec.js');
+    const result = await runCommand('pnpm', ['build'], {
+        cwd: dir,
+        stdio: 'inherit',
+    });
+    return result.exitCode === 0;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}

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,18 @@
-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 id = spec.features.mastra.agentId ?? spec.name;
     return [
         "import type { AgentProvider, AgentSetupContext, StreamChunk } from '@powerhousedao/ph-clint';",
         "import type { Config } from '../framework.js';",
@@ -32,3 +45,71 @@ 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,');
+    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;