@powerhousedao/ph-clint-cli 0.1.0-dev.21 → 0.1.0-dev.23

package/dist/cli.js

@@ -68,7 +68,9 @@ 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 },

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 envKey = `${provider.toUpperCase()}_API_KEY`;
+    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.apiKey) 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.apiKey');
+    lines.push("      ? { id: ctx.config.model as `${string}/${string}`, apiKey: ctx.config.apiKey }");
+    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/cli-ts.js

@@ -63,7 +63,20 @@ export function buildCliTs(spec) {
     lines.push('  // @clint:begin prompts');
     lines.push('  prompts: {');
     lines.push('    artifacts: [],');
-    lines.push('    agents: {},');
+    if (mastra.enabled && mastra.agentId && mastra.profiles.length > 0) {
+        lines.push('    agents: {');
+        lines.push(`      '${mastra.agentId}': {`);
+        lines.push('        sections: [');
+        for (const p of mastra.profiles) {
+            lines.push(`          { id: '${p.id}', title: '${p.title}', file: '${p.id}.md' },`);
+        }
+        lines.push('        ],');
+        lines.push('      },');
+        lines.push('    },');
+    }
+    else {
+        lines.push('    agents: {},');
+    }
     lines.push('    skills: {},');
     lines.push('  },');
     lines.push('  // @clint:end prompts');

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

@@ -43,7 +43,8 @@ export function buildFrameworkTs(spec) {
     lines.push('');
     lines.push('export const configSchema = z.object({');
     if (mastra.enabled) {
-        lines.push("  model: z.string().default('anthropic/claude-haiku-4-5').describe('LLM model to use'),");
+        const defaultModel = mastra.models.find(m => m.isDefault)?.id ?? 'anthropic/claude-sonnet-4-5';
+        lines.push(`  model: z.string().default('${defaultModel}').describe('LLM model to use'),`);
     }
     // Ports are derived from CLI name by resolveReactorDefaults() — no config fields needed.
     // Override via switchboard.port / connect.port in configureReactor() if required.

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

@@ -36,6 +36,11 @@ export interface FileBuilder {
      */
     initOnly?: boolean;
 }
+/**
+ * Generate dynamic file builders for agent profile markdown files.
+ * One file per profile in `prompts/agent-profiles/{id}.md`.
+ */
+export declare function getProfileFileBuilders(spec: ClintProjectSpec): FileBuilder[];
 export declare const CLI_FILE_BUILDERS: FileBuilder[];
 export { buildCliPackageJson, buildCliTs, buildConfigTs, buildMainTs, buildTsconfigJson, buildJestConfigJs, buildEslintConfigJs, buildGitignore, buildMastraIndexTs, buildBuildSkillsScript, buildAgentBaseMd, buildAgentTs, buildFrameworkGenTs, buildFrameworkTs, };
 export { buildRootPackageJson } from './root-package-json.js';

package/dist/codegen/builders/index.js

@@ -19,6 +19,19 @@ import { buildAgentBaseMd } from './agent-base-md.js';
 import { buildAgentTs } from './agent-ts.js';
 import { buildFrameworkGenTs } from './framework-gen-ts.js';
 import { buildFrameworkTs } from './framework-ts.js';
+/**
+ * Generate dynamic file builders for agent profile markdown files.
+ * One file per profile in `prompts/agent-profiles/{id}.md`.
+ */
+export function getProfileFileBuilders(spec) {
+    const { mastra } = spec.features;
+    if (!mastra.enabled || mastra.profiles.length === 0)
+        return [];
+    return mastra.profiles.map((profile) => ({
+        relativePath: `prompts/agent-profiles/${profile.id}.md`,
+        build: () => profile.content + '\n',
+    }));
+}
 export const CLI_FILE_BUILDERS = [
     { relativePath: 'package.json', build: buildCliPackageJson },
     { relativePath: 'tsconfig.json', build: () => buildTsconfigJson() },
@@ -34,7 +47,10 @@ export const CLI_FILE_BUILDERS = [
     { relativePath: 'src/framework.gen.ts', build: buildFrameworkGenTs },
     { relativePath: 'src/mastra/index.ts', build: buildMastraIndexTs },
     { relativePath: 'scripts/build-skills.ts', build: () => buildBuildSkillsScript() },
-    { relativePath: 'prompts/agent-profiles/AgentBase.md', build: buildAgentBaseMd },
+    {
+        relativePath: 'prompts/agent-profiles/AgentBase.md',
+        build: (spec) => (spec.features.mastra.profiles.length > 0 ? null : buildAgentBaseMd(spec)),
+    },
     {
         relativePath: 'src/agents/agent.ts',
         build: (spec) => (spec.features.mastra.enabled ? buildAgentTs(spec) : null),

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

@@ -3,6 +3,9 @@
  *
  * When Mastra is off, emit a no-op placeholder so the directory still exists
  * and `mastra dev` fails predictably rather than importing partial code.
+ *
+ * When Mastra is on with full agent config, emit a real Mastra instance
+ * that registers the agent.
  */
 import { type ClintProjectSpec } from '../../spec/types.js';
 export declare function buildMastraIndexTs(spec: ClintProjectSpec): string;

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

@@ -12,9 +12,29 @@ export function buildMastraIndexTs(spec) {
             '',
         ].join('\n');
     }
-    // When Mastra is enabled but we still emit the demo `AgentProvider` shim
-    // (not a real `@mastra/core` Agent), there is no `mastra` export yet —
-    // `mastra dev` will surface a helpful message once you wire a real Agent.
+    // Full agent config available — emit real Mastra instance
+    if (mastra.agentId && mastra.models.length > 0) {
+        const agentId = mastra.agentId;
+        return [
+            '/**',
+            ' * Mastra Studio entry point for `mastra dev` / `mastra build` / `mastra start`.',
+            ' *',
+            ' * Exports a configured Mastra instance with the project agent registered.',
+            ' */',
+            "import { Mastra } from '@mastra/core/mastra';",
+            "import { Agent } from '@mastra/core/agent';",
+            '',
+            '// @clint:begin mastra-index',
+            `const agent = new Agent({ id: '${agentId}', model: '${(mastra.models.find(m => m.isDefault) ?? mastra.models[0]).id}' });`,
+            '',
+            'export const mastra = new Mastra({',
+            `  agents: { '${agentId}': agent },`,
+            '});',
+            '// @clint:end mastra-index',
+            '',
+        ].join('\n');
+    }
+    // Mastra enabled but no full agent config yet — placeholder
     return [
         '/**',
         ' * Mastra Studio entry point for `mastra dev` / `mastra build` / `mastra start`.',

package/dist/codegen/index.js

@@ -35,7 +35,7 @@ import { hashContent, hashFile, readHashes, writeHashes, } from './hashes.js';
 import { hasMarkers, spliceMarkerRegions } from './markers.js';
 import { writeFileEnsuringDir, isDirEmptyEnough } from './write.js';
 import { migrateFlatToSplit } from './migrate/flat-to-split.js';
-import { CLI_FILE_BUILDERS, buildReadme, buildRootPackageJson, buildPublishConfigTs, buildAppIndexTs, } from './builders/index.js';
+import { CLI_FILE_BUILDERS, getProfileFileBuilders, buildReadme, buildRootPackageJson, buildPublishConfigTs, buildAppIndexTs, } from './builders/index.js';
 /**
  * Generate / reconcile a project at `targetDir` from the given spec.
  */
@@ -79,7 +79,8 @@ function planFiles(spec, targetDir) {
     const cliDir = split ? path.join(targetDir, getCliFolderName(spec)) : targetDir;
     const appDir = split ? path.join(targetDir, getAppFolderName(spec)) : null;
     const planned = [];
-    for (const builder of CLI_FILE_BUILDERS) {
+    const allBuilders = [...CLI_FILE_BUILDERS, ...getProfileFileBuilders(spec)];
+    for (const builder of allBuilders) {
         const content = builder.build(spec);
         if (content === null)
             continue;

package/dist/commands/clint-project-init.d.ts

@@ -38,6 +38,17 @@ export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject
                 powerhouse: "Disabled" | "Reactor" | "Switchboard" | "Connect";
                 mastra: {
                     enabled: boolean;
+                    agentId: string | null;
+                    agentName: string | null;
+                    models: {
+                        id: string;
+                        isDefault: boolean;
+                    }[];
+                    profiles: {
+                        id: string;
+                        title: string;
+                        content: string;
+                    }[];
                 };
                 routine: {
                     enabled: boolean;
@@ -55,6 +66,8 @@ export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject
             }[];
             scope?: string | undefined;
             bin?: string | undefined;
+            documentId?: string | undefined;
+            documentType?: string | undefined;
         };
         fileCount: number;
     };

package/dist/commands/clint-project-init.js

@@ -13,11 +13,14 @@
  */
 import path from 'node:path';
 import { defineCommand } from '@powerhousedao/ph-clint';
+import { importSpec } from '@powerhousedao/ph-clint-app/document-models/ph-clint-project';
 import { z } from 'zod';
 import { clintProjectSpecSchema, } from '../spec/types.js';
 import { generateProject } from '../codegen/index.js';
 import { isDirEmptyEnough } from '../codegen/write.js';
 import { runPhInit, runPnpmInstall } from '../codegen/scaffold.js';
+import { writeProjectSpec } from '../spec/file.js';
+import { specToImportInput } from '../triggers/spec-change.js';
 const inputSchema = z.object({
     dir: z
         .string()
@@ -70,13 +73,22 @@ export function buildSpec(input) {
     // Routine is forced on when Mastra is on — the REPL-only path works, but
     // the agent routine loop is what most users actually want.
     const routine = input.enableRoutine || input.enableMastra;
+    const mastra = input.enableMastra
+        ? {
+            enabled: true,
+            agentId: `${name}-agent`,
+            agentName: `${name.charAt(0).toUpperCase()}${name.slice(1).replace(/-(\w)/g, (_, c) => ' ' + c.toUpperCase())} Agent`,
+            models: [{ id: 'anthropic/claude-sonnet-4-5', isDefault: true }],
+            profiles: [{ id: 'base', title: 'Base', content: 'You are a helpful assistant.' }],
+        }
+        : { enabled: false };
     const candidate = {
         name,
         scope,
         description: input.description ?? '',
         features: {
             powerhouse: input.enablePowerhouse ? 'Connect' : 'Disabled',
-            mastra: { enabled: input.enableMastra },
+            mastra,
             routine: { enabled: routine },
         },
     };
@@ -90,7 +102,7 @@ export const init = defineCommand({
         promptForDefaults: true,
         promptOptional: ['description'],
     },
-    execute: async (input, { workdir, stdout }) => {
+    execute: async (input, { workdir, stdout, reactor: getReactor, folders }) => {
         const { name: bareName } = splitPackageName(input.name);
         const targetDir = path.resolve(workdir, input.dir ?? bareName);
         if (!input.force) {
@@ -110,6 +122,27 @@ export const init = defineCommand({
             allowNonEmpty: input.force,
         });
         stdout(`Generated ${result.files.length} files in ${targetDir}\n`);
+        // Create spec document in personal drive (if reactor available)
+        if (getReactor && folders) {
+            try {
+                const reactor = await getReactor();
+                if (reactor) {
+                    const newDoc = await reactor.client.createEmpty('powerhouse/ph-clint-project');
+                    const docId = newDoc.header.id;
+                    await folders.addDocument(docId, `specs/${spec.name}`, spec.name);
+                    const importInput = specToImportInput(spec);
+                    await reactor.client.execute(docId, 'main', [importSpec(importInput)]);
+                    spec.documentId = docId;
+                    spec.documentType = 'powerhouse/ph-clint-project';
+                    await writeProjectSpec(targetDir, spec);
+                    stdout(`Created spec document ${docId} in Clint Folders/specs/${spec.name}\n`);
+                }
+            }
+            catch (err) {
+                // Non-fatal — trigger will pick it up on next startup
+                stdout(`Note: could not create spec document — ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
         const split = spec.features.powerhouse !== 'Disabled';
         // Reactor package scaffolding (split layout only).
         if (split && result.appDir && !input.skipPhInit) {

package/dist/framework.d.ts

@@ -14,7 +14,6 @@ export declare const configSchema: z.ZodObject<{
     model: z.ZodDefault<z.ZodString>;
     devServicePort: z.ZodDefault<z.ZodNumber>;
     phVersion: z.ZodDefault<z.ZodString>;
-    projectDocumentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const secretsSchema: z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
@@ -30,38 +29,32 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
         model: string;
         devServicePort: number;
         phVersion: string;
-        projectDocumentId?: string | undefined;
         apiKey?: string | undefined;
     }, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>) => Promise<TOutput>;
 }) => import("@powerhousedao/ph-clint").Command<TInput, TOutput, {
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }>, defineTrigger: <TState = Record<string, unknown>>(options: import("@powerhousedao/ph-clint").TriggerOptions<TState, {
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>) => import("@powerhousedao/ph-clint").Trigger<TState, {
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>, defineService: (options: import("@powerhousedao/ph-clint").ServiceDefinition<{
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }>) => import("@powerhousedao/ph-clint").ServiceDefinition<{
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }>, createDocumentChangeTrigger: <T extends string, TState extends {
     pending: number;
@@ -71,13 +64,11 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }, TState>) => import("@powerhousedao/ph-clint").Trigger<TState, {
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;
 export { registry } from './framework.gen.js';

package/dist/framework.js

@@ -25,10 +25,6 @@ export const configSchema = z.object({
         .string()
         .default('6.0.0-dev.170')
         .describe('Pinned Powerhouse version used when emitting a new impl project'),
-    projectDocumentId: z
-        .string()
-        .optional()
-        .describe('ID of the powerhouse/ph-clint-project document that drives codegen (set on first regen; edit to switch projects)'),
 });
 export const secretsSchema = z.object({
     apiKey: z.string().optional().describe('Anthropic API key'),

package/dist/services/clint-project.js

@@ -31,6 +31,11 @@ export const clintProject = defineService({
     ],
     projectScanner: {
         isProjectFolder: (p) => {
+            // Match if a project-spec.json exists (split-layout root)
+            const specPath = path.join(p, '.ph', 'ph-clint-cli', 'project-spec.json');
+            if (fs.existsSync(specPath))
+                return true;
+            // Match if package.json has ph-clint as a dependency (flat layout or cli subfolder)
             const pkg = path.join(p, 'package.json');
             if (!fs.existsSync(pkg))
                 return false;
@@ -42,6 +47,22 @@ export const clintProject = defineService({
                 return false;
             }
         },
+        getDocumentLink: (p) => {
+            const specPath = path.join(p, '.ph', 'ph-clint-cli', 'project-spec.json');
+            if (!fs.existsSync(specPath))
+                return undefined;
+            try {
+                const spec = JSON.parse(fs.readFileSync(specPath, 'utf8'));
+                if (spec.documentId) {
+                    return {
+                        documentId: spec.documentId,
+                        documentType: spec.documentType ?? 'powerhouse/ph-clint-project',
+                    };
+                }
+            }
+            catch { /* noop */ }
+            return undefined;
+        },
     },
     restart: { enabled: false, maxRetries: 0, delay: 0 },
 });

package/dist/spec/from-document.d.ts

@@ -15,4 +15,7 @@ import { type ClintProjectSpec } from './types.js';
  * Returns `null` if the document has no valid package name yet — callers
  * should wait for the user to populate it before triggering codegen.
  */
-export declare function specFromDocumentState(state: PhClintProjectGlobalState): ClintProjectSpec | null;
+export declare function specFromDocumentState(state: PhClintProjectGlobalState, meta?: {
+    documentId?: string;
+    documentType?: string;
+}): ClintProjectSpec | null;

package/dist/spec/from-document.js

@@ -5,7 +5,7 @@ import { clintProjectSpecSchema, } from './types.js';
  * Returns `null` if the document has no valid package name yet — callers
  * should wait for the user to populate it before triggering codegen.
  */
-export function specFromDocumentState(state) {
+export function specFromDocumentState(state, meta) {
     if (!state.name)
         return null;
     const parsed = clintProjectSpecSchema.safeParse({
@@ -29,6 +29,8 @@ export function specFromDocumentState(state) {
             name: s.name,
             githubUrl: s.githubUrl,
         })),
+        documentId: meta?.documentId,
+        documentType: meta?.documentType,
     });
     return parsed.success ? parsed.data : null;
 }

package/dist/spec/types.d.ts

@@ -23,6 +23,17 @@ export declare const powerhouseLevelSchema: z.ZodDefault<z.ZodEnum<{
 export type PowerhouseLevel = z.infer<typeof powerhouseLevelSchema>;
 /** Check whether `level` is at least `threshold` in the ordered enum. */
 export declare function phAtLeast(level: PowerhouseLevel, threshold: PowerhouseLevel): boolean;
+export declare const agentModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    isDefault: z.ZodBoolean;
+}, z.core.$strip>;
+export type AgentModel = z.infer<typeof agentModelSchema>;
+export declare const agentProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type AgentProfile = z.infer<typeof agentProfileSchema>;
 export declare const powerhousePackageSchema: z.ZodObject<{
     id: z.ZodString;
     packageName: z.ZodString;
@@ -50,6 +61,17 @@ export declare const clintProjectSpecSchema: z.ZodObject<{
         }>>;
         mastra: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
+            agentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            agentName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            models: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                isDefault: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            profiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                content: z.ZodString;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>;
         routine: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
@@ -65,6 +87,8 @@ export declare const clintProjectSpecSchema: z.ZodObject<{
         name: z.ZodString;
         githubUrl: z.ZodString;
     }, z.core.$strip>>>;
+    documentId: z.ZodOptional<z.ZodString>;
+    documentType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ClintProjectSpec = z.infer<typeof clintProjectSpecSchema>;
 export type ClintProjectSpecInput = z.input<typeof clintProjectSpecSchema>;

package/dist/spec/types.js

@@ -26,13 +26,32 @@ export const powerhouseLevelSchema = z
 export function phAtLeast(level, threshold) {
     return (POWERHOUSE_LEVELS.indexOf(level) >= POWERHOUSE_LEVELS.indexOf(threshold));
 }
+export const agentModelSchema = z.object({
+    id: z.string(),
+    isDefault: z.boolean(),
+});
+export const agentProfileSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    content: z.string(),
+});
 const mastraFeatureSchema = z.object({
     enabled: z.boolean().default(false),
+    agentId: z.string().nullable().default(null),
+    agentName: z.string().nullable().default(null),
+    models: z.array(agentModelSchema).default([]),
+    profiles: z.array(agentProfileSchema).default([]),
 });
 const routineFeatureSchema = z.object({
     enabled: z.boolean().default(false),
 });
-const DEFAULT_MASTRA = { enabled: false };
+const DEFAULT_MASTRA = {
+    enabled: false,
+    agentId: null,
+    agentName: null,
+    models: [],
+    profiles: [],
+};
 const DEFAULT_ROUTINE = { enabled: false };
 export const powerhousePackageSchema = z.object({
     id: z.string(),
@@ -79,6 +98,10 @@ export const clintProjectSpecSchema = z.object({
      * (kebab-case) and a GitHub URL for installation.
      */
     externalSkills: z.array(externalSkillSchema).default([]),
+    /** ID of the source specification document (if backed by a Powerhouse document). */
+    documentId: z.string().optional(),
+    /** Document type of the source specification document. */
+    documentType: z.string().optional(),
 });
 /** npm package name (e.g. `@scope/foo` or `foo`). */
 export function getPackageName(spec) {

package/dist/triggers/publish-trigger.d.ts

@@ -6,6 +6,5 @@ export declare const publishTrigger: import("@powerhousedao/ph-clint").Trigger<{
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
 }, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;

package/dist/triggers/publish-trigger.js

@@ -1,11 +1,15 @@
 /**
- * `publish-trigger` — watches `powerhouse/ph-clint-project` documents for
+ * `publish-trigger` — watches ALL `powerhouse/ph-clint-project` documents for
  * publish records with `Pending` status and invokes the publish pipeline.
  *
  * Unlike `spec-change`, this trigger does NOT convert to a `ClintProjectSpec`.
  * It reads `publishHistory` directly from the document state, since publish
  * records are a doc-model concern (not a codegen input).
  *
+ * Uses the multi-doc path (no `documentId`), scanning all matching documents
+ * on each poll. For each document with a pending publish record, it uses the
+ * project mapping to resolve the on-disk project directory.
+ *
  * Flow:
  *   1. On document change, scans `publishHistory` for records with status
  *      `"Pending"`.
@@ -15,26 +19,14 @@
  *      c. Dispatches SET_PUBLISH_STATUS({ id, status: "Succeeded"|"Failed" }).
  */
 import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { scanProjects, getProjectMapping } from '@powerhousedao/ph-clint';
 import { setPublishStatus } from '@powerhousedao/ph-clint-app';
 import { createDocumentChangeTrigger } from '../framework.js';
+import { specFromDocumentState } from '../spec/from-document.js';
+import { clintProject } from '../services/clint-project.js';
 const DOCUMENT_TYPE = 'powerhouse/ph-clint-project';
 const TAG = '[publish]';
-/** 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;
-            }
-        }
-    }
-    catch {
-        // fall through
-    }
-    return undefined;
-}
 /** Run a shell command and return stdout. Rejects on non-zero exit. */
 function exec(cmd, args, cwd, onLog) {
     return new Promise((resolve, reject) => {
@@ -82,91 +74,96 @@ export function tagToCli(tag) {
 export const publishTrigger = createDocumentChangeTrigger({
     id: 'publish-trigger',
     documentType: DOCUMENT_TYPE,
+    // No documentId → watches ALL ph-clint-project docs
     // Don't fire on startup — only react to new pending records.
     initialReconcile: false,
-    // Resolve the target document lazily (same pattern as spec-change trigger).
-    documentId: async (ctx) => {
-        const configured = ctx.context.config.projectDocumentId &&
-            ctx.context.config.projectDocumentId.length > 0
-            ? ctx.context.config.projectDocumentId
-            : undefined;
-        if (configured)
-            return configured;
-        const reactor = await ctx.reactor();
-        if (!reactor)
-            return undefined;
-        return findProjectDocumentId(reactor.client, reactor.driveId);
-    },
-    async onChange(doc, ctx) {
+    async onChange(docs, ctx) {
         const log = ctx.context.log;
-        const publishHistory = doc.state.global.publishHistory ?? [];
-        const pending = publishHistory.filter((r) => r.status === 'Pending');
-        if (pending.length === 0)
-            return null;
-        // Process the first pending record (one per tick to avoid races).
-        const record = pending[0];
-        const cliTag = tagToCli(record.tag);
-        if (!cliTag) {
-            log?.warn(`${TAG} unknown publish tag "${record.tag}" for record ${record.id}`);
-            return null;
-        }
-        log?.info(`${TAG} found pending ${record.tag} publish (id=${record.id}, version=${record.version})`);
-        return {
-            type: 'function',
-            params: {
-                fn: async () => {
-                    const reactor = await ctx.reactor();
-                    if (!reactor) {
-                        log?.error(`${TAG} reactor not available, cannot update publish status`);
-                        return;
-                    }
-                    // Mark as InProgress.
-                    log?.info(`${TAG} marking record ${record.id} as InProgress`);
-                    await reactor.client.execute(doc.header.id, 'main', [
-                        setPublishStatus({ id: record.id, status: 'InProgress' }),
-                    ]);
-                    // Install dependencies in the generated project before publishing.
-                    const workdir = ctx.context.workdir;
-                    log?.info(`${TAG} running pnpm install in ${workdir}`);
-                    try {
-                        await exec('pnpm', ['install'], workdir, (msg) => log?.debug(`${TAG} [install] ${msg}`));
-                    }
-                    catch (installErr) {
-                        log?.error(`${TAG} pnpm install failed: ${installErr instanceof Error ? installErr.message : String(installErr)}`);
-                    }
-                    // Run the publish command.
-                    let success = false;
-                    try {
-                        log?.info(`${TAG} invoking clint-project-publish --tag ${cliTag}`);
-                        const { clintProjectPublish } = await import('../commands/clint-project-publish.js');
-                        const result = await clintProjectPublish.execute({ tag: cliTag, dryRun: false, skipBuild: false, skipGitCheck: true, verbose: false }, 
-                        // @ts-expect-error — minimal context; publish uses workdir + stdout.
-                        {
-                            workdir: ctx.context.workdir,
-                            stdout: (msg) => log?.info(`${TAG} ${msg}`),
-                            log,
-                        });
-                        success = !result.text.includes('failed');
-                    }
-                    catch (err) {
-                        log?.error(`${TAG} publish failed: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                    // Update status.
-                    const finalStatus = success ? 'Succeeded' : 'Failed';
-                    log?.info(`${TAG} marking record ${record.id} as ${finalStatus}`);
-                    await reactor.client.execute(doc.header.id, 'main', [
-                        setPublishStatus({
-                            id: record.id,
-                            status: finalStatus,
-                        }),
-                    ]);
+        const folders = ctx.context.folders;
+        // Build the mapping to resolve on-disk project directories
+        const scanner = clintProject.projectScanner;
+        const scanResults = scanner
+            ? scanProjects(ctx.context.workdir, scanner)
+            : [];
+        const mapping = await getProjectMapping(scanResults, folders);
+        for (const doc of docs) {
+            const publishHistory = doc.state.global.publishHistory ?? [];
+            const pending = publishHistory.filter((r) => r.status === 'Pending');
+            if (pending.length === 0)
+                continue;
+            // Resolve the on-disk target directory for this document
+            const spec = specFromDocumentState(doc.state.global, {
+                documentId: doc.header.id,
+                documentType: doc.header.documentType,
+            });
+            const entry = mapping.find((m) => m.documentId === doc.header.id);
+            const workdir = entry?.path
+                ?? (spec ? path.join(ctx.context.workdir, spec.name) : ctx.context.workdir);
+            // Process the first pending record (one per tick to avoid races).
+            const record = pending[0];
+            const cliTag = tagToCli(record.tag);
+            if (!cliTag) {
+                log?.warn(`${TAG} unknown publish tag "${record.tag}" for record ${record.id}`);
+                continue;
+            }
+            log?.info(`${TAG} found pending ${record.tag} publish for doc ${doc.header.id} (id=${record.id}, version=${record.version})`);
+            return {
+                type: 'function',
+                params: {
+                    fn: async () => {
+                        const reactor = await ctx.reactor();
+                        if (!reactor) {
+                            log?.error(`${TAG} reactor not available, cannot update publish status`);
+                            return;
+                        }
+                        // Mark as InProgress.
+                        log?.info(`${TAG} marking record ${record.id} as InProgress`);
+                        await reactor.client.execute(doc.header.id, 'main', [
+                            setPublishStatus({ id: record.id, status: 'InProgress' }),
+                        ]);
+                        // Install dependencies in the generated project before publishing.
+                        log?.info(`${TAG} running pnpm install in ${workdir}`);
+                        try {
+                            await exec('pnpm', ['install'], workdir, (msg) => log?.debug(`${TAG} [install] ${msg}`));
+                        }
+                        catch (installErr) {
+                            log?.error(`${TAG} pnpm install failed: ${installErr instanceof Error ? installErr.message : String(installErr)}`);
+                        }
+                        // Run the publish command.
+                        let success = false;
+                        try {
+                            log?.info(`${TAG} invoking clint-project-publish --tag ${cliTag}`);
+                            const { clintProjectPublish } = await import('../commands/clint-project-publish.js');
+                            const result = await clintProjectPublish.execute({ tag: cliTag, dryRun: false, skipBuild: false, skipGitCheck: true, verbose: false }, 
+                            // @ts-expect-error — minimal context; publish uses workdir + stdout.
+                            {
+                                workdir,
+                                stdout: (msg) => log?.info(`${TAG} ${msg}`),
+                                log,
+                            });
+                            success = !result.text.includes('failed');
+                        }
+                        catch (err) {
+                            log?.error(`${TAG} publish failed: ${err instanceof Error ? err.message : String(err)}`);
+                        }
+                        // Update status.
+                        const finalStatus = success ? 'Succeeded' : 'Failed';
+                        log?.info(`${TAG} marking record ${record.id} as ${finalStatus}`);
+                        await reactor.client.execute(doc.header.id, 'main', [
+                            setPublishStatus({
+                                id: record.id,
+                                status: finalStatus,
+                            }),
+                        ]);
+                    },
                 },
-            },
-            callbacks: {
-                onFailure: (err) => {
-                    log?.error(`${TAG} publish trigger failed: ${err.message}`);
+                callbacks: {
+                    onFailure: (err) => {
+                        log?.error(`${TAG} publish trigger failed: ${err.message}`);
+                    },
                 },
-            },
-        };
+            };
+        }
+        return null;
     },
 });

package/dist/triggers/spec-change.d.ts

@@ -1,12 +1,14 @@
+import type { ImportSpecInput } from '@powerhousedao/ph-clint-app/document-models/ph-clint-project';
 import type { ClintProjectSpec } from '../spec/types.js';
-/** 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 declare function hashSpec(spec: ClintProjectSpec): string;
+export declare function specToImportInput(spec: ClintProjectSpec): ImportSpecInput;
 export declare const specChangeTrigger: import("@powerhousedao/ph-clint").Trigger<{
     pending: number;
 }, {
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
-}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app/document-models/ph-clint-project").PhClintProjectPHState>]>>;

package/dist/triggers/spec-change.js

@@ -1,28 +1,30 @@
 /**
- * `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 { importSpec } from '@powerhousedao/ph-clint-app/document-models/ph-clint-project';
 import { createDocumentChangeTrigger } from '../framework.js';
 import { generateProject } from '../codegen/index.js';
 import { runPhInit } from '../codegen/scaffold.js';
 import { specFromDocumentState } from '../spec/from-document.js';
+import { readProjectSpec, writeProjectSpec } from '../spec/file.js';
 import { syncExternalSkills } from '../skills/sync.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';
@@ -51,11 +53,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) {
@@ -72,159 +76,172 @@ 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;
-            }
-        }
-    }
-    catch {
-        // fall through
-    }
-    return undefined;
+export function specToImportInput(spec) {
+    return {
+        name: spec.name,
+        scope: spec.scope ?? null,
+        version: spec.version,
+        description: spec.description,
+        bin: spec.bin ?? null,
+        powerhouse: spec.features.powerhouse,
+        mastraEnabled: spec.features.mastra.enabled,
+        routineEnabled: spec.features.routine.enabled,
+        agentId: spec.features.mastra.agentId ?? null,
+        agentName: spec.features.mastra.agentName ?? null,
+        models: spec.features.mastra.models.map(m => ({
+            id: m.id,
+            isDefault: m.isDefault,
+        })),
+        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,
+        })),
+    };
 }
 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
+    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 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 && !entry.documentId) {
+                    const existingSpec = await readProjectSpec(entry.path);
+                    if (!existingSpec)
+                        continue;
+                    log?.info(`${TAG} creating spec document for unlinked project ${entry.name}`);
+                    const newDoc = await reactor.client.createEmpty('powerhouse/ph-clint-project');
+                    const docId = newDoc.header.id;
+                    await folders.addDocument(docId, `specs/${entry.name}`, entry.name);
+                    const importInput = specToImportInput(existingSpec);
+                    await reactor.client.execute(docId, 'main', [importSpec(importInput)]);
+                    existingSpec.documentId = docId;
+                    existingSpec.documentType = 'powerhouse/ph-clint-project';
+                    await writeProjectSpec(entry.path, existingSpec);
+                    log?.info(`${TAG} linked project ${entry.name} to document ${docId}`);
+                }
+            }
         }
-        // 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,
             });
-            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({
+            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}`);
+            }
+            // Scaffold the reactor package (app dir) if it hasn't been initialized yet.
+            if (result.appDir) {
+                const appPkgJson = path.join(result.appDir, 'package.json');
+                let appExists = false;
+                try {
+                    await fs.access(appPkgJson);
+                    appExists = true;
+                }
+                catch { /* noop */ }
+                if (!appExists) {
+                    log?.info(`${TAG} initializing reactor package at ${result.appDir}`);
+                    const phResult = await runPhInit({
                         targetDir,
+                        appDir: result.appDir,
                         spec,
-                        mode: 'update',
-                        force: true,
-                        onWarn: (m) => warnings.push(m),
+                        log: (msg) => log?.info(`${TAG} ${msg}`),
+                        stdio: 'ignore',
                     });
-                    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}`);
+                    if (!phResult.ran) {
+                        log?.warn(`${TAG} ph init skipped: ${phResult.reason ?? 'unknown'}`);
                     }
-                    // Scaffold the reactor package (app dir) if it hasn't been initialized yet.
-                    if (result.appDir) {
-                        const appPkgJson = path.join(result.appDir, 'package.json');
-                        let appExists = false;
-                        try {
-                            await fs.access(appPkgJson);
-                            appExists = true;
-                        }
-                        catch { /* noop */ }
-                        if (!appExists) {
-                            log?.info(`${TAG} initializing reactor package at ${result.appDir}`);
-                            const phResult = await runPhInit({
-                                targetDir,
-                                appDir: result.appDir,
-                                spec,
-                                log: (msg) => log?.info(`${TAG} ${msg}`),
-                                stdio: 'ignore',
-                            });
-                            if (!phResult.ran) {
-                                log?.warn(`${TAG} ph init skipped: ${phResult.reason ?? 'unknown'}`);
-                            }
-                            else if (phResult.exitCode !== 0) {
-                                log?.warn(`${TAG} ph init exited with code ${phResult.exitCode}`);
-                            }
-                        }
-                        // Always ensure the app package name matches the spec's scope,
-                        // even if ph init ran in a previous trigger cycle without scope.
-                        if (spec.scope) {
-                            try {
-                                const raw = await fs.readFile(appPkgJson, 'utf8');
-                                const pkg = JSON.parse(raw);
-                                const appFolder = path.basename(result.appDir);
-                                const scopedName = `@${spec.scope}/${appFolder}`;
-                                if (pkg.name !== scopedName) {
-                                    pkg.name = scopedName;
-                                    pkg.publishConfig = { access: 'public' };
-                                    await fs.writeFile(appPkgJson, JSON.stringify(pkg, null, 2) + '\n');
-                                    log?.info(`${TAG} patched app package name to ${scopedName}`);
-                                }
-                            }
-                            catch (err) {
-                                log?.warn(`${TAG} could not patch app package name: ${err instanceof Error ? err.message : String(err)}`);
-                            }
-                        }
+                    else if (phResult.exitCode !== 0) {
+                        log?.warn(`${TAG} ph init exited with code ${phResult.exitCode}`);
                     }
-                    // Sync external skills after codegen.
-                    if (spec.externalSkills.length > 0) {
-                        const skillsResult = await syncExternalSkills({
-                            targetDir,
-                            desired: spec.externalSkills,
-                            log: (msg) => log?.info(`${TAG} ${msg}`),
-                        });
-                        if (log && (skillsResult.added.length > 0 || skillsResult.removed.length > 0)) {
-                            log.info(`${TAG} skills sync: +${skillsResult.added.length} -${skillsResult.removed.length}`);
+                }
+                // Always ensure the app package name matches the spec's scope,
+                // even if ph init ran in a previous trigger cycle without scope.
+                if (spec.scope) {
+                    try {
+                        const raw = await fs.readFile(appPkgJson, 'utf8');
+                        const pkg = JSON.parse(raw);
+                        const appFolder = path.basename(result.appDir);
+                        const scopedName = `@${spec.scope}/${appFolder}`;
+                        if (pkg.name !== scopedName) {
+                            pkg.name = scopedName;
+                            pkg.publishConfig = { access: 'public' };
+                            await fs.writeFile(appPkgJson, JSON.stringify(pkg, null, 2) + '\n');
+                            log?.info(`${TAG} patched app package name to ${scopedName}`);
                         }
                     }
-                },
-            },
-            callbacks: {
-                onFailure: (err) => {
-                    log?.error(`${TAG} regen failed: ${err.message}`);
-                    log?.debug(`${TAG} stack: ${err.stack ?? '<no stack>'}`);
-                },
-            },
-        };
+                    catch (err) {
+                        log?.warn(`${TAG} could not patch app package name: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            // Sync external skills after codegen.
+            if (spec.externalSkills.length > 0) {
+                const skillsResult = await syncExternalSkills({
+                    targetDir,
+                    desired: spec.externalSkills,
+                    log: (msg) => log?.info(`${TAG} ${msg}`),
+                });
+                if (log && (skillsResult.added.length > 0 || skillsResult.removed.length > 0)) {
+                    log.info(`${TAG} skills sync: +${skillsResult.added.length} -${skillsResult.removed.length}`);
+                }
+            }
+        }
+        // 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.21",
+  "version": "0.1.0-dev.23",
   "publishConfig": {
     "access": "public"
   },
@@ -28,9 +28,9 @@
     "@mastra/core": "^1.22.0",
     "@mastra/libsql": "^1.7.4",
     "@mastra/memory": "^1.13.1",
-    "@powerhousedao/ph-clint": "^0.1.0-dev.21",
-    "@powerhousedao/ph-clint-app": "^0.1.0-dev.21",
-    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.21",
+    "@powerhousedao/ph-clint": "^0.1.0-dev.23",
+    "@powerhousedao/ph-clint-app": "^0.1.0-dev.23",
+    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.23",
     "@powerhousedao/reactor": "6.0.0-dev.170",
     "@powerhousedao/reactor-api": "6.0.0-dev.170",
     "@powerhousedao/shared": "6.0.0-dev.170",