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

package/dist/codegen/markers.d.ts

@@ -1,36 +1 @@
-/**
- * Marker-region parsing for `@clint:begin {name}` / `@clint:end {name}`
- * comment blocks. Used in delta mode to splice freshly-generated regions
- * into an existing, user-edited file while preserving everything outside
- * the markers.
- *
- * The only syntactic requirement is that the markers are on their own lines,
- * as ordinary line comments (`//`). Indentation is preserved for output.
- */
-export interface MarkerRegion {
-    /** Region identifier (the text after `@clint:begin`). */
-    name: string;
-    /** Lines *between* the begin and end markers (exclusive). */
-    body: string[];
-    /** Indentation of the begin line — used when rewriting. */
-    indent: string;
-    /** Line index of the begin marker in the source. */
-    beginLine: number;
-    /** Line index of the end marker in the source. */
-    endLine: number;
-}
-/**
- * Parse every `@clint:begin {name}` … `@clint:end {name}` block in `source`.
- * Throws if markers are mismatched or unclosed.
- */
-export declare function parseMarkerRegions(source: string): MarkerRegion[];
-/**
- * Replace every region in `target` that also exists in `source` with the
- * `source` region's body. Leaves regions present in `target` but not `source`
- * untouched. Ignores regions in `source` missing from `target`.
- *
- * Returns the rewritten file content.
- */
-export declare function spliceMarkerRegions(target: string, source: string): string;
-/** Convenience — true if `content` contains at least one `@clint:begin`. */
-export declare function hasMarkers(content: string): boolean;
+export { type MarkerRegion, parseMarkerRegions, spliceMarkerRegions, hasMarkers, } from '@powerhousedao/ph-clint-dev/codegen/markers';

package/dist/codegen/markers.js

@@ -1,86 +1 @@
-/**
- * Marker-region parsing for `@clint:begin {name}` / `@clint:end {name}`
- * comment blocks. Used in delta mode to splice freshly-generated regions
- * into an existing, user-edited file while preserving everything outside
- * the markers.
- *
- * The only syntactic requirement is that the markers are on their own lines,
- * as ordinary line comments (`//`). Indentation is preserved for output.
- */
-const BEGIN_RE = /^([ \t]*)\/\/\s*@clint:begin\s+(\S+)\s*$/;
-const END_RE = /^([ \t]*)\/\/\s*@clint:end\s+(\S+)\s*$/;
-/**
- * Parse every `@clint:begin {name}` … `@clint:end {name}` block in `source`.
- * Throws if markers are mismatched or unclosed.
- */
-export function parseMarkerRegions(source) {
-    const lines = source.split('\n');
-    const regions = [];
-    let open = null;
-    let bodyStart = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const begin = BEGIN_RE.exec(line);
-        if (begin) {
-            if (open) {
-                throw new Error(`nested @clint:begin ${begin[2]} at line ${i + 1} while ${open.name} is still open`);
-            }
-            open = { name: begin[2], indent: begin[1], beginLine: i };
-            bodyStart = i + 1;
-            continue;
-        }
-        const end = END_RE.exec(line);
-        if (end) {
-            if (!open) {
-                throw new Error(`@clint:end ${end[2]} at line ${i + 1} without matching begin`);
-            }
-            if (open.name !== end[2]) {
-                throw new Error(`@clint:end ${end[2]} at line ${i + 1} does not match open @clint:begin ${open.name}`);
-            }
-            regions.push({
-                name: open.name,
-                body: lines.slice(bodyStart, i),
-                indent: open.indent,
-                beginLine: open.beginLine,
-                endLine: i,
-            });
-            open = null;
-        }
-    }
-    if (open) {
-        throw new Error(`unterminated @clint:begin ${open.name}`);
-    }
-    return regions;
-}
-/**
- * Replace every region in `target` that also exists in `source` with the
- * `source` region's body. Leaves regions present in `target` but not `source`
- * untouched. Ignores regions in `source` missing from `target`.
- *
- * Returns the rewritten file content.
- */
-export function spliceMarkerRegions(target, source) {
-    const sourceRegions = parseMarkerRegions(source);
-    const sourceByName = new Map();
-    for (const r of sourceRegions)
-        sourceByName.set(r.name, r);
-    const targetRegions = parseMarkerRegions(target);
-    if (targetRegions.length === 0)
-        return target;
-    const lines = target.split('\n');
-    // Apply replacements from last to first so line indices stay valid.
-    const sorted = [...targetRegions].sort((a, b) => b.beginLine - a.beginLine);
-    for (const region of sorted) {
-        const fresh = sourceByName.get(region.name);
-        if (!fresh)
-            continue;
-        // Replace the body lines (exclusive of the begin/end marker lines).
-        const bodyLen = region.endLine - region.beginLine - 1;
-        lines.splice(region.beginLine + 1, bodyLen, ...fresh.body);
-    }
-    return lines.join('\n');
-}
-/** Convenience — true if `content` contains at least one `@clint:begin`. */
-export function hasMarkers(content) {
-    return /^[ \t]*\/\/\s*@clint:begin\s+\S+\s*$/m.test(content);
-}
+export { parseMarkerRegions, spliceMarkerRegions, hasMarkers, } from '@powerhousedao/ph-clint-dev/codegen/markers';

package/dist/codegen/scaffold.d.ts

@@ -1,34 +1 @@
-import type { ClintProjectSpec } from '../spec/types.js';
-export interface PhInitOptions {
-    /** Absolute path to the project root. */
-    targetDir: string;
-    /** Absolute path to `{targetDir}/{name}-app` (exists with our placeholder). */
-    appDir: string;
-    spec: ClintProjectSpec;
-    /** Logger; defaults to noop. */
-    log?: (msg: string) => void;
-    /** Override `ph` binary name (for tests). */
-    binName?: string;
-    /** Stdio passthrough (tests pass 'ignore'). */
-    stdio?: 'inherit' | 'ignore';
-}
-export interface PhInitResult {
-    ran: boolean;
-    exitCode?: number;
-    reason?: string;
-}
-export declare function runPhInit(options: PhInitOptions): Promise<PhInitResult>;
-export interface PnpmInstallOptions {
-    /** Directories to run `pnpm install` in, in order. */
-    dirs: string[];
-    log?: (msg: string) => void;
-    /** Override `pnpm` binary name (for tests). */
-    binName?: string;
-    stdio?: 'inherit' | 'ignore';
-}
-export interface PnpmInstallResult {
-    ran: string[];
-    skipped: string[];
-    reason?: string;
-}
-export declare function runPnpmInstall(options: PnpmInstallOptions): Promise<PnpmInstallResult>;
+export { type RunProcess, type PhInitOptions, type PhInitResult, getPhVersion, runPhInit, patchAppPackageName, type PnpmInstallOptions, type PnpmInstallResult, runPnpmInstall, runPhInstallPackages, } from '@powerhousedao/ph-clint-dev/codegen/scaffold';

package/dist/codegen/scaffold.js

@@ -1,60 +1 @@
-/**
- * Post-generation side-effects: invoke `ph init` to fill in the reactor
- * package skeleton, and run `pnpm install` in the relevant sub-projects.
- *
- * Both steps are opt-out (flags on the init command) and both tolerate
- * missing binaries — they never fail the init flow, only emit warnings.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { hasCommandOnPath, runCommand } from './exec.js';
-export async function runPhInit(options) {
-    const log = options.log ?? (() => { });
-    const binName = options.binName ?? 'ph';
-    const appFolder = path.basename(options.appDir);
-    if (!(await hasCommandOnPath(binName))) {
-        log(`Skipping \`${binName} init\` — \`${binName}\` is not on PATH. ` +
-            `Install @powerhousedao/ph-cli and re-run manually inside ${appFolder}/.`);
-        return { ran: false, reason: 'ph-not-on-path' };
-    }
-    // `ph init {name}` creates a fresh directory beside the cwd. Our generator
-    // placed a `.gitkeep` + README.md placeholder there; clear it out so
-    // ph init has a blank slate to work with.
-    await fs.rm(options.appDir, { recursive: true, force: true });
-    log(`Running \`${binName} init ${appFolder}\` in ${options.targetDir} …`);
-    const result = await runCommand(binName, [
-        'init',
-        appFolder,
-        '--pnpm',
-        '--dev',
-    ], { cwd: options.targetDir, stdio: options.stdio ?? 'inherit' });
-    if (result.exitCode !== 0) {
-        log(`\`${binName} init\` exited with code ${result.exitCode}. ` +
-            'You can re-run it manually after resolving the issue.');
-    }
-    return { ran: true, exitCode: result.exitCode };
-}
-export async function runPnpmInstall(options) {
-    const log = options.log ?? (() => { });
-    const binName = options.binName ?? 'pnpm';
-    if (!(await hasCommandOnPath(binName))) {
-        log(`Skipping \`${binName} install\` — \`${binName}\` is not on PATH. ` +
-            'Install pnpm and re-run manually.');
-        return { ran: [], skipped: options.dirs, reason: 'pnpm-not-on-path' };
-    }
-    const ran = [];
-    for (const dir of options.dirs) {
-        log(`Running \`${binName} install\` in ${dir} …`);
-        const result = await runCommand(binName, ['install'], {
-            cwd: dir,
-            stdio: options.stdio ?? 'inherit',
-        });
-        if (result.exitCode !== 0) {
-            log(`\`${binName} install\` exited with code ${result.exitCode} in ${dir}. ` +
-                'Retry manually once the underlying issue is resolved.');
-            // Don't abort the whole chain — subsequent dirs may still work.
-        }
-        ran.push(dir);
-    }
-    return { ran, skipped: [] };
-}
+export { getPhVersion, runPhInit, patchAppPackageName, runPnpmInstall, runPhInstallPackages, } from '@powerhousedao/ph-clint-dev/codegen/scaffold';

package/dist/codegen/write.d.ts

@@ -1,6 +1 @@
-export declare function writeFileEnsuringDir(filePath: string, content: string): Promise<void>;
-/**
- * Returns true if the directory doesn't exist or only contains ignorable
- * entries (`.git`, `.DS_Store`, `.ph/ph-clint-cli/project-spec.json`).
- */
-export declare function isDirEmptyEnough(dir: string): Promise<boolean>;
+export { writeFileEnsuringDir, isDirEmptyEnough, } from '@powerhousedao/ph-clint-dev/codegen/write';

package/dist/codegen/write.js

@@ -1,32 +1 @@
-/**
- * Low-level file-writing helpers for the code generator.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-export async function writeFileEnsuringDir(filePath, content) {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, content, 'utf8');
-}
-function isEnoent(err) {
-    return (!!err &&
-        typeof err === 'object' &&
-        'code' in err &&
-        err.code === 'ENOENT');
-}
-/**
- * Returns true if the directory doesn't exist or only contains ignorable
- * entries (`.git`, `.DS_Store`, `.ph/ph-clint-cli/project-spec.json`).
- */
-export async function isDirEmptyEnough(dir) {
-    let entries;
-    try {
-        entries = await fs.readdir(dir);
-    }
-    catch (err) {
-        if (isEnoent(err))
-            return true;
-        throw err;
-    }
-    const ignorable = new Set(['.git', '.DS_Store', '.ph']);
-    return entries.every((entry) => ignorable.has(entry));
-}
+export { writeFileEnsuringDir, isDirEmptyEnough, } from '@powerhousedao/ph-clint-dev/codegen/write';

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

@@ -4,4 +4,9 @@ export declare const build: import("@powerhousedao/ph-clint").Command<z.ZodObjec
     verbose: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, {
     text: string;
-}, Record<string, unknown>>;
+}, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    apiKey?: string | undefined;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;

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

@@ -1,50 +1,33 @@
 import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { defineCommand } from '@powerhousedao/ph-clint';
+import { defineCommand } from '../framework.js';
 import { z } from 'zod';
 import { detectLayout } from '@powerhousedao/ph-clint-dev';
 const inputSchema = z.object({
     dir: z.string().optional().describe('Project root directory (default: cwd)'),
     verbose: z.boolean().default(false),
 });
-function execInDir(dir, cmd, verbose) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn(cmd, {
-            cwd: dir,
-            shell: true,
-            stdio: verbose ? 'inherit' : 'pipe',
-        });
-        let stderr = '';
-        if (!verbose && proc.stderr) {
-            proc.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-        }
-        proc.on('close', (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`Command "${cmd}" failed in ${dir} (exit ${code})${stderr ? `:\n${stderr}` : ''}`));
-        });
-        proc.on('error', (err) => reject(err));
-    });
-}
 export const build = defineCommand({
     id: 'clint-project-build',
     description: 'Build all packages in the project',
     inputSchema,
-    execute: async (input, { workdir, stdout }) => {
+    execute: async (input, { workdir, stdout, runProcess }) => {
         const dir = path.resolve(input.dir ?? workdir);
         const layout = detectLayout(dir);
         if (layout?.type === 'split') {
             stdout(`Building app package (${layout.app})...\n`);
-            await execInDir(layout.app, 'pnpm build', input.verbose);
+            const appResult = await runProcess('pnpm build', { cwd: layout.app, timeout: 120_000 });
+            if (!appResult.success)
+                return { text: `App build failed.` };
             stdout(`Building cli package (${layout.cli})...\n`);
-            await execInDir(layout.cli, 'pnpm build', input.verbose);
+            const cliResult = await runProcess('pnpm build', { cwd: layout.cli, timeout: 120_000 });
+            if (!cliResult.success)
+                return { text: `CLI build failed.` };
         }
         else {
             stdout(`Building project...\n`);
-            await execInDir(layout?.cli ?? dir, 'pnpm build', input.verbose);
+            const result = await runProcess('pnpm build', { cwd: layout?.cli ?? dir, timeout: 120_000 });
+            if (!result.success)
+                return { text: `Build failed.` };
         }
         return { text: 'Build complete.' };
     },

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

@@ -7,8 +7,8 @@ declare const inputSchema: z.ZodObject<{
     enablePowerhouse: z.ZodDefault<z.ZodBoolean>;
     enableMastra: z.ZodDefault<z.ZodBoolean>;
     enableRoutine: z.ZodDefault<z.ZodBoolean>;
+    enableObservability: z.ZodDefault<z.ZodBoolean>;
     force: z.ZodDefault<z.ZodBoolean>;
-    skipPhInit: z.ZodDefault<z.ZodBoolean>;
     skipInstall: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 type InitInput = z.output<typeof inputSchema>;
@@ -20,8 +20,8 @@ export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject
     enablePowerhouse: z.ZodDefault<z.ZodBoolean>;
     enableMastra: z.ZodDefault<z.ZodBoolean>;
     enableRoutine: z.ZodDefault<z.ZodBoolean>;
+    enableObservability: z.ZodDefault<z.ZodBoolean>;
     force: z.ZodDefault<z.ZodBoolean>;
-    skipPhInit: z.ZodDefault<z.ZodBoolean>;
     skipInstall: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, {
     text: string;
@@ -35,23 +35,58 @@ export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject
             version: string;
             description: string;
             features: {
-                powerhouse: {
-                    enabled: boolean;
-                    switchboard: boolean;
-                    connect: boolean;
-                };
+                powerhouse: "Disabled" | "Reactor" | "Switchboard" | "Connect";
                 mastra: {
                     enabled: boolean;
+                    agentId: string | null;
+                    agentName: string | null;
+                    agentDescription: string | null;
+                    agentImage: string | null;
+                    models: {
+                        id: string;
+                        isDefault: boolean;
+                    }[];
+                    profiles: {
+                        id: string;
+                        title: string;
+                        content: string;
+                    }[];
+                    common: {
+                        enableChat: boolean;
+                    };
                 };
                 routine: {
                     enabled: boolean;
                 };
+                observability: {
+                    enabled: boolean;
+                };
+            };
+            packages: {
+                id: string;
+                packageName: string;
+                documentTypes: string[];
+                version: string | null;
+            }[];
+            externalSkills: {
+                id: string;
+                name: string;
+                githubUrl: string;
+            }[];
+            deployment: {
+                proxyEnabled: boolean;
+                supportedResources: string[];
             };
-            documentTypes: string[];
             scope?: string | undefined;
-            bin?: string | undefined;
+            documentId?: string | undefined;
+            documentType?: string | undefined;
         };
         fileCount: number;
     };
-}, Record<string, unknown>>;
+}, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    apiKey?: string | undefined;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;
 export {};

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

@@ -2,27 +2,28 @@
  * `ph-clint clint-project-init` — the project bootstrap wizard.
  *
  * Behavior:
- *   1. Resolve target dir (positional `dir`, defaults to cwd).
+ *   1. Resolve target dir (positional `dir`, defaults to the project name).
  *   2. Assert it is empty (or `--force`).
  *   3. Collect project identity + feature toggles (prompt for missing).
  *   4. Assemble a ClintProjectSpec and validate with Zod.
  *   5. Write the spec + emit the generated tree via `generateProject`.
- *   6. (Split layout) run `ph init` in `{name}-app/` unless `--skip-ph-init`.
+ *   6. (Split layout) run `ph init` in `{name}-app/`.
  *   7. Run `pnpm install` in generated sub-projects unless `--skip-install`.
  *   8. Print next-steps guidance.
  */
 import path from 'node:path';
-import { defineCommand } from '@powerhousedao/ph-clint';
+import { defineCommand } from '../framework.js';
 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 { isDirEmptyEnough } from '@powerhousedao/ph-clint-dev/codegen/write';
+import { runPostGenActions } from '@powerhousedao/ph-clint-dev/codegen/actions';
+import { ensureSpecDocument } from '../spec/ensure-document.js';
 const inputSchema = z.object({
     dir: z
         .string()
         .optional()
-        .describe('Target directory (defaults to the current directory)'),
+        .describe('Target directory (defaults to the project name)'),
     name: z
         .string()
         .describe('Project name — bare, or `@scope/name`. Lowercase letters, digits, hyphens.'),
@@ -39,45 +40,60 @@ const inputSchema = z.object({
         .boolean()
         .default(false)
         .describe('Enable the tick-based routine loop'),
-    force: z
+    enableObservability: z
         .boolean()
         .default(false)
-        .describe('Overwrite files if the target directory is not empty'),
-    skipPhInit: z
+        .describe('Wire @powerhousedao/ph-clint-observability into the generated CLI. ' +
+        'The generated CLI will ask its end-user for telemetry consent on first run.'),
+    force: z
         .boolean()
         .default(false)
-        .describe('Do not run `ph init` in the app folder after scaffolding'),
+        .describe('Overwrite files if the target directory is not empty'),
     skipInstall: z
         .boolean()
         .default(false)
         .describe('Do not run `pnpm install` after scaffolding'),
 });
-/** Parse `@scope/name` into { scope, name }. */
+/** Parse `@scope/name` into { scope, name }. Auto-appends `-cli` if missing. */
 function splitPackageName(raw) {
     const match = /^@([a-z0-9][a-z0-9-]*)\/([a-z0-9][a-z0-9-]*)$/.exec(raw);
-    if (match)
-        return { scope: match[1], name: match[2] };
+    if (match) {
+        const name = match[2].endsWith('-cli') ? match[2] : `${match[2]}-cli`;
+        return { scope: `@${match[1]}`, name };
+    }
     if (raw.startsWith('@')) {
         throw new Error(`invalid package name "${raw}" — expected "@scope/name" with lowercase letters, digits, hyphens`);
     }
     if (!/^[a-z0-9][a-z0-9-]*$/.test(raw)) {
         throw new Error(`invalid project name "${raw}" — expected lowercase letters, digits, hyphens`);
     }
-    return { name: raw };
+    const name = raw.endsWith('-cli') ? raw : `${raw}-cli`;
+    return { name };
 }
 export function buildSpec(input) {
     const { scope, name } = splitPackageName(input.name);
     // 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 baseName = name.replace(/-cli$/, '');
+    const mastra = input.enableMastra
+        ? {
+            enabled: true,
+            agentId: `${baseName}-agent`,
+            agentName: `${baseName.charAt(0).toUpperCase()}${baseName.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: { enabled: input.enablePowerhouse },
-            mastra: { enabled: input.enableMastra },
+            powerhouse: input.enablePowerhouse ? 'Connect' : 'Disabled',
+            mastra,
             routine: { enabled: routine },
+            observability: { enabled: input.enableObservability },
         },
     };
     return clintProjectSpecSchema.parse(candidate);
@@ -90,8 +106,9 @@ export const init = defineCommand({
         promptForDefaults: true,
         promptOptional: ['description'],
     },
-    execute: async (input, { workdir, stdout }) => {
-        const targetDir = path.resolve(workdir, input.dir ?? '.');
+    execute: async (input, { workdir, stdout, reactor: getReactor, folders, runProcess }) => {
+        const { name: bareName } = splitPackageName(input.name);
+        const targetDir = path.resolve(workdir, input.dir ?? bareName);
         if (!input.force) {
             const empty = await isDirEmptyEnough(targetDir);
             if (!empty) {
@@ -109,44 +126,41 @@ export const init = defineCommand({
             allowNonEmpty: input.force,
         });
         stdout(`Generated ${result.files.length} files in ${targetDir}\n`);
-        const split = spec.features.powerhouse.enabled;
-        // Reactor package scaffolding (split layout only).
-        if (split && result.appDir && !input.skipPhInit) {
-            const phResult = await runPhInit({
-                targetDir,
-                appDir: result.appDir,
-                spec,
-                log: (msg) => stdout(msg + '\n'),
-            });
-            if (!phResult.ran) {
-                stdout(`Note: \`ph init\` did not run — ${phResult.reason ?? 'see above'}.\n`);
+        // Create spec document in personal drive (if reactor available)
+        if (getReactor && folders) {
+            try {
+                const reactor = await getReactor();
+                if (reactor) {
+                    const { docId } = await ensureSpecDocument({
+                        spec, targetDir, reactor, folders,
+                    });
+                    stdout(`Created spec document ${docId} in Clint Folders/specs/${spec.name}\n`);
+                }
             }
-        }
-        // Dependency installation.
-        if (!input.skipInstall) {
-            const dirs = [];
-            if (split) {
-                if (result.appDir)
-                    dirs.push(result.appDir);
-                dirs.push(result.cliDir);
-            }
-            else {
-                dirs.push(targetDir);
+            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`);
             }
-            await runPnpmInstall({
-                dirs,
-                log: (msg) => stdout(msg + '\n'),
-            });
         }
+        // Run post-generation actions (ph-init, install, build, skills-sync).
+        // Only skip cli-install — in split layout, ph-init handles app install
+        // internally, and app-build must still run so the CLI can link to it.
+        const skip = new Set();
+        if (input.skipInstall) {
+            skip.add('cli-install');
+        }
+        await runPostGenActions(result.pendingActions, {
+            log: (msg) => stdout(msg + '\n'),
+            runProcess,
+            skip,
+        });
+        const split = spec.features.powerhouse !== 'Disabled';
         const next = [];
         next.push('');
         next.push('Next steps:');
         const relDir = path.relative(workdir, targetDir) || '.';
         if (split) {
             next.push(`  cd ${relDir}`);
-            if (input.skipPhInit) {
-                next.push(`  cd ${spec.name}-app && ph init . && cd ..`);
-            }
             if (input.skipInstall) {
                 next.push('  pnpm install');
             }

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

@@ -8,8 +8,14 @@ export declare const clintProjectPublish: import("@powerhousedao/ph-clint").Comm
     dir: z.ZodOptional<z.ZodString>;
     dryRun: z.ZodDefault<z.ZodBoolean>;
     skipBuild: z.ZodDefault<z.ZodBoolean>;
+    skipGitCheck: z.ZodDefault<z.ZodBoolean>;
     verbose: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, {
     text: string;
     data: import("@powerhousedao/ph-clint-dev/publish").PublishResult;
-}, Record<string, unknown>>;
+}, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    apiKey?: string | undefined;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { defineCommand } from '@powerhousedao/ph-clint';
+import { defineCommand } from '../framework.js';
 import { z } from 'zod';
 import { resolvePublishPlan, buildPackages, publishPackages, } from '@powerhousedao/ph-clint-dev/publish';
 const inputSchema = z.object({
@@ -7,6 +7,7 @@ const inputSchema = z.object({
     dir: z.string().optional().describe('Project root directory'),
     dryRun: z.boolean().default(false).describe('Preview without publishing'),
     skipBuild: z.boolean().default(false),
+    skipGitCheck: z.boolean().default(false).describe('Skip git working tree check'),
     verbose: z.boolean().default(false),
 });
 function formatPlanPreview(plan) {
@@ -34,11 +35,12 @@ export const clintProjectPublish = defineCommand({
             logLines.push(msg);
             stdout(msg + '\n');
         };
-        // 1. Resolve plan
+        // 1. Resolve plan — discover config from the target dir, not process.cwd().
+        const configFile = path.join(dir, 'publish.config.js');
         const plan = await resolvePublishPlan({
             tag: input.tag,
-            configPath: undefined, // auto-discover from dir
-            skipGitCheck: input.dryRun,
+            configPath: configFile,
+            skipGitCheck: input.dryRun || input.skipGitCheck,
             log,
         });
         // 2. Show preview