@powerhousedao/ph-clint-cli 0.1.0-dev.3 → 0.1.0-dev.31

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,210 +29,47 @@ 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 [{
-        readonly version: 1;
-        readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-        readonly actions: {
-            enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-            disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-            enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-            disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-            enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-            setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-            setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-            setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-            clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-            setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-            setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-            setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-            clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-            setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-            setName: (name: string | {
-                name: string;
-            }) => import("document-model").SetNameAction;
-            undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-            redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-            prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-            loadState: <TState extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState & {
-                name: string;
-            }, operations: number) => import("document-model").LoadStateAction;
-            noop: (scope?: string) => import("document-model").NOOPAction;
-        };
-        readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-        readonly documentModel: import("document-model").DocumentModelPHState;
-    }]>>) => Promise<TOutput>;
+    }, 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 [{
-    readonly version: 1;
-    readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly actions: {
-        enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-        disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-        enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-        disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-        enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-        setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-        setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-        setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-        clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-        setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-        setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-        setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-        clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-        setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-        setName: (name: string | {
-            name: string;
-        }) => import("document-model").SetNameAction;
-        undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-        redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-        prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-        loadState: <TState_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
-            name: string;
-        }, operations: number) => import("document-model").LoadStateAction;
-        noop: (scope?: string) => import("document-model").NOOPAction;
-    };
-    readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly documentModel: import("document-model").DocumentModelPHState;
-}]>>) => import("@powerhousedao/ph-clint").Trigger<TState, {
+}, 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 [{
-    readonly version: 1;
-    readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly actions: {
-        enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-        disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-        enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-        disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-        enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-        setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-        setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-        setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-        clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-        setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-        setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-        setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-        clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-        setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-        setName: (name: string | {
-            name: string;
-        }) => import("document-model").SetNameAction;
-        undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-        redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-        prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-        loadState: <TState_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
-            name: string;
-        }, operations: number) => import("document-model").LoadStateAction;
-        noop: (scope?: string) => import("document-model").NOOPAction;
-    };
-    readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly documentModel: import("document-model").DocumentModelPHState;
-}]>>, defineService: (options: import("@powerhousedao/ph-clint").ServiceDefinition<{
+}, 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;
 } = {
     pending: number;
-}>(options: import("@powerhousedao/ph-clint").DocumentChangeTriggerOptions<import("@powerhousedao/ph-clint").InferRegistry<readonly [{
-    readonly version: 1;
-    readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly actions: {
-        enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-        disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-        enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-        disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-        enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-        setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-        setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-        setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-        clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-        setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-        setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-        setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-        clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-        setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-        setName: (name: string | {
-            name: string;
-        }) => import("document-model").SetNameAction;
-        undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-        redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-        prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-        loadState: <TState_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
-            name: string;
-        }, operations: number) => import("document-model").LoadStateAction;
-        noop: (scope?: string) => import("document-model").NOOPAction;
-    };
-    readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly documentModel: import("document-model").DocumentModelPHState;
-}]>, T, {
+}>(options: import("@powerhousedao/ph-clint").DocumentChangeTriggerOptions<import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>, T, {
     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 [{
-    readonly version: 1;
-    readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly actions: {
-        enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-        disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-        enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-        disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-        enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-        setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-        setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-        setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-        clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-        setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-        setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-        setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-        clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-        setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-        setName: (name: string | {
-            name: string;
-        }) => import("document-model").SetNameAction;
-        undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-        redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-        prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-        loadState: <TState_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
-            name: string;
-        }, operations: number) => import("document-model").LoadStateAction;
-        noop: (scope?: string) => import("document-model").NOOPAction;
-    };
-    readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly documentModel: import("document-model").DocumentModelPHState;
-}]>>;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;
 export { registry } from './framework.gen.js';
 export type { Registry } from './framework.gen.js';

package/dist/framework.gen.d.ts

@@ -2,36 +2,5 @@
  * Typed document registry derived from the reactor package's document models.
  * Regenerated whenever the spec's `documentTypes` list changes.
  */
-export declare const registry: import("@powerhousedao/ph-clint").InferRegistry<readonly [{
-    readonly version: 1;
-    readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly actions: {
-        enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-        disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-        enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-        disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-        enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-        setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-        setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-        setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-        clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-        setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-        setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-        setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-        clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-        setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-        setName: (name: string | {
-            name: string;
-        }) => import("document-model").SetNameAction;
-        undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-        redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-        prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-        loadState: <TState extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState & {
-            name: string;
-        }, operations: number) => import("document-model").LoadStateAction;
-        noop: (scope?: string) => import("document-model").NOOPAction;
-    };
-    readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly documentModel: import("document-model").DocumentModelPHState;
-}]>;
+export declare const registry: import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>;
 export type Registry = typeof registry;

package/dist/framework.gen.js

@@ -1,7 +1,7 @@
 /**
  * THIS FILE IS GENERATED BY ph-clint-cli. DO NOT EDIT.
  *
- * Regenerated on every `ph-clint regen` and on every spec-change tick.
+ * Regenerated on every `ph-clint clint-project-regen` and on every spec-change tick.
  * Put custom bindings in `framework.ts`, not here — edits to this file
  * will be overwritten.
  */

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/{prompts/agent-profiles/AgentBase.md → dist/gen/agent-profiles/PhClintDevAgent.md}

@@ -1,6 +1,6 @@
 # Agent Base System Prompt
 
-You are {{agentName}}, an agent available through the {{cliName}} CLI.
+You are PhClintDevAgent, an agent available through the  CLI.
 
 ## Capabilities
 

package/dist/gen/skills/cli-setup/.cli-docs.md

@@ -0,0 +1,135 @@
+## API Reference: CLI Setup
+
+### `defineCli<TSchema, TSecrets>(options): Cli`
+
+Factory function that creates a CLI from a declarative options object. Two generic type parameters:
+
+- `TSchema extends z.ZodType` — config schema type (defaults to `Record<string, unknown>`)
+- `TSecrets extends z.ZodType` — secrets schema type (defaults to `Record<string, unknown>`)
+
+### `CliOptions<TSchema, TSecrets>` Interface
+
+```typescript
+interface CliOptions<TSchema, TSecrets> {
+  name: string;                          // CLI name (kebab-case, used for config files and env var prefix)
+  version: string;                       // Semantic version (shown in --version)
+  root?: string;                         // Absolute path to package root (resolves sibling packages)
+  description: Resolvable<string, Config>; // Static string or function of ({ config, workdir })
+  commands: Command<any, any, any>[];    // Array of command definitions
+  configSchema?: TSchema;                // Zod schema for user-facing config
+  secretsSchema?: TSecrets;              // Zod schema for sensitive config (API keys, tokens)
+  interactive?: InteractiveConfig<Config>; // REPL configuration
+  triggers?: Trigger<any, any, any>[];   // Routine loop triggers
+  routine?: RoutineConfig;               // Routine loop timing & project scanner
+  services?: ServiceDefinition<Config>[]; // Background service definitions
+  events?: Record<string, (data: any, log: Logger) => void>; // Event handlers
+  workdir?: string;                      // Implementation-level workdir override (hides --workdir flag)
+  configDefaults?: Record<string, unknown>; // Layer 5 config defaults
+  prompts?: PromptsConfig;               // Agent skills & profiles
+}
+```
+
+### `InteractiveConfig<TConfig>` Interface
+
+```typescript
+interface InteractiveConfig<TConfig> {
+  welcome: Resolvable<string, TConfig>;  // Welcome message (static or dynamic)
+  outputWindow?: number;                 // Trailing output lines in REPL (default: 6)
+}
+```
+
+### `Resolvable<T, TConfig>` Type
+
+```typescript
+type Resolvable<T, TConfig> = T | ((ctx: { workdir: string; config: TConfig }) => T);
+```
+
+Allows static values OR dynamic computation based on resolved workdir and config.
+
+### `Cli` Object Interface
+
+Methods available on the object returned by `defineCli()`:
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `run` | `(argv: string[], options?: RunOptions) => Promise<void>` | Main entry point — parse args, dispatch command or start REPL |
+| `bootstrap` | `(opts?: BootstrapOptions) => Promise<BootstrapResult>` | Initialize runtime without dispatch — for programmatic access |
+| `execute` | `(commandId, args, context?) => Promise<unknown>` | Execute a command directly (programmatic use) |
+| `parseArgs` | `(commandId, argv) => Record<string, unknown>` | Parse CLI argv for a specific command |
+| `getCommand` | `(id: string) => Command \| undefined` | Look up a registered command |
+| `listCommands` | `() => Command[]` | List all registered commands |
+| `generateHelp` | `() => string` | Generate CLI help text |
+| `generateCommandHelp` | `(commandId: string) => string` | Generate help for a specific command |
+| `generateCompletion` | `(shell: string) => string` | Generate shell completion script (bash/zsh/fish) |
+| `configEnvVars` | `() => ConfigEnvVar[]` | List config env var mappings |
+| `getMetadata` | `() => CliMetadata` | JSON-serializable CLI metadata |
+| `configureAgent` | `(loader: AgentLoader<any>) => void` | Set the agent factory (lazy-loaded) |
+| `configureReactor` | `(config: ReactorConfiguration) => void` | Set the reactor configuration (lazy-loaded) |
+
+Properties:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `name` | `string` | CLI name |
+| `version` | `string` | CLI version |
+| `description` | `string` | CLI description |
+| `hasAgent` | `boolean` | True when `configureAgent()` has been called |
+| `hasReactor` | `boolean` | True when `configureReactor()` has been called |
+
+### `RunOptions` Interface
+
+```typescript
+interface RunOptions {
+  exit?: (code: number) => void;         // Override process.exit (for testing)
+  stdout?: (message: string) => void;    // Capture stdout
+  stderr?: (message: string) => void;    // Capture stderr
+  interactiveInput?: AsyncIterable<string>; // Headless REPL input (for testing)
+  resume?: string;                       // Resume agent conversation by thread ID
+  workdir?: string;                      // Override workdir (for testing)
+  configFile?: string;                   // --config flag value
+  logLevel?: LogLevel;                   // Override log verbosity (default: 'info')
+}
+```
+
+### `BootstrapOptions` & `BootstrapResult`
+
+```typescript
+interface BootstrapOptions {
+  workdir?: string;        // Explicit workdir (skips flag/cwd logic)
+  configFile?: string;     // Config file override
+  logLevel?: LogLevel;     // Log level (default: 'info')
+  stdout?: (text: string) => void;
+  stderr?: (text: string) => void;
+}
+
+interface BootstrapResult {
+  workdir: string;
+  config: Record<string, unknown>;
+  context: CommandContext;
+  getAgent(): Promise<AgentProvider | undefined>;
+  get mastraAgent(): Promise<unknown | undefined>;
+}
+```
+
+### Built-in Commands (Auto-Injected)
+
+| Command ID | Condition | Purpose |
+|-----------|-----------|---------|
+| `cli-docs` | Always | Show CLI help (also usable as agent tool) |
+| `config` | When `configSchema` provided | View/modify configuration settings |
+| `{service-id}-start` | Per service definition | Start a background service |
+| `{service-id}-stop` | Per service definition | Stop a running service |
+| `{service-id}-restart` | Per service definition | Restart a service |
+| `{service-id}-ps` | Per service definition | Show service status |
+| `{service-id}-logs` | Per service definition | Tail service logs |
+| `{service-id}-manage` | Per service definition | Interactive management (REPL only) |
+| `{service-id}-ls` | Per service + projectScanner | List discovered projects |
+
+### `readPackageInfo(importMetaUrl)`
+
+Utility to read name and version from the nearest `package.json`:
+
+```typescript
+import { readPackageInfo } from '@powerhousedao/ph-clint';
+const { name, version } = readPackageInfo(import.meta.url);
+```

package/dist/gen/skills/cli-setup/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: cli-setup
+description: "Cli Setup tasks"
+metadata:
+  author: Powerhouse
+  version: "1.0.0"
+---
+
+=== BEGIN SKILL BRIEFING ===
+
+IMPORTANT: Don't take any action yet. You will be guided through your tasks after the briefing(s). Just process and confirm your understanding.
+
+# CLI Setup - Skill Preamble
+
+With this skill, you can scaffold or extend a `defineCli()` configuration — the composition root that wires commands, config, services, triggers, and integrations into a single CLI runtime. A single `defineCli()` call produces a CLI that works in command mode (`mycli cmd --arg val`), interactive REPL mode (`/cmd --arg val`), and as an MCP server — all from the same code.
+
+## Core Principles
+
+### defineCli Is Declarative
+
+You describe _what_ the CLI has — the framework wires it up. The order of options doesn't matter, but understanding what triggers what does:
+
+- `configSchema` present → auto-injects a `config` command for viewing/modifying settings
+- `secretsSchema` present → fields merge into configSchema internally, but are censored in output
+- `services` present → auto-injects per-service management commands (`{id}-start`, `{id}-stop`, etc.)
+- `interactive` present → enables the `-i` flag for REPL mode
+- `triggers` present → enables routine loop
+- `cli-docs` command is always auto-injected (CLI help for the agent)
+
+### Resolvable Values
+
+`description` and `interactive.welcome` accept either a static string or a function `({ config, workdir }) => string`. Use functions when the message depends on runtime state — e.g., showing "demo mode" vs "LLM mode" based on whether an API key is configured.
+
+### The Cli Object
+
+`defineCli()` returns a `Cli` object — the public API with methods for running, testing, introspection, and metadata. The standard entry point is `cli.run(process.argv)`. For programmatic access (e.g., codegen scripts), use `cli.bootstrap()` which resolves workdir, config, and context without entering the dispatch loop.
+
+### Two Interaction Modes
+
+1. **Command mode** (headless): Execute one subcommand, then exit. Triggered by `mycli cmd --flag val`.
+2. **Interactive REPL mode**: Persistent session with `/command` syntax and bare text for the default subcommand (typically the agent). Triggered by `mycli -i` or when keep-alive features are active (routine loop, API server).
+
+### 6-Layer Config Resolution
+
+Config values are resolved in this priority order (highest wins):
+1. `--config <file>` flag
+2. Environment variables: `{CLI_NAME}_{UPPER_SNAKE_FIELD}`
+3. Local config: `{workdir}/.ph/{cliName}.config.local.json`
+4. User config: `~/.ph/{cliName}.config.user.json`
+5. Implementation defaults: `configDefaults` in CliOptions
+6. Zod schema `.default()` values
+
+### Config vs Secrets
+
+- `configSchema` — user-facing settings (model name, ports, feature flags). Shown in `config` command output.
+- `secretsSchema` — sensitive values (API keys, tokens). Merged into configSchema internally but censored as `***` in output unless `--revealSecrets` is used.
+
+Put API keys and tokens in `secretsSchema`, not `configSchema`.
+
+### configDefaults vs Schema Defaults
+
+- `.default(value)` in the Zod schema → layer 6, the fallback when nothing else is configured
+- `configDefaults` in CliOptions → layer 5, implementation-level overrides that sit above schema defaults but below user/local config
+
+Use schema `.default()` for universal sensible defaults. Use `configDefaults` for implementation-specific overrides that differ from the general-purpose default.
+
+### Entry Point Convention
+
+The CLI entry point is a TypeScript file with a Node.js shebang:
+
+```typescript
+#!/usr/bin/env node
+import { defineCli } from '@powerhousedao/ph-clint';
+// ... imports ...
+const cli = defineCli({ /* options */ });
+cli.run(process.argv);
+```
+
+The `package.json` needs a `"bin"` field pointing to the compiled output and `"type": "module"` for ESM.
+
+## Common Pitfalls
+
+- **Forgetting `version`** — Commander needs it for the `--version` flag; omitting it breaks help output
+- **Putting secrets in `configSchema`** — they show up in `config` command output and metadata, exposing sensitive values
+- **Not setting `interactive.welcome`** — REPL starts with no context, confusing the user
+- **Using `configDefaults` for universal defaults** — use `.default()` in the schema instead; `configDefaults` is for implementation-level overrides only
+- **Calling `configureAgent()` inside `defineCli()`** — it's a method on the returned `Cli` object, called after definition
+- **Forgetting `"type": "module"` in package.json** — ESM imports fail at runtime
+- **Not exporting the `cli` object** — other files (e.g., `mastra/index.ts`) may need it for `cli.bootstrap()`
+
+## When to Use `createTypes()`
+
+For projects with a config schema, use the typed factory to get automatic config typing in all commands:
+
+```typescript
+import { createTypes } from '@powerhousedao/ph-clint';
+const { defineCommand, defineTrigger } = createTypes({ configSchema });
+// context.config is now fully typed in every command
+```
+
+## Codegen-Managed Projects
+
+In ph-clint-cli projects, `clint-project-init` generates the initial scaffold including `cli.ts` with `@clint:begin`/`@clint:end` marker regions. The codegen system:
+
+- **Generates `cli.ts`** with marker regions for imports, commands, services, triggers, prompts, events, interactive, reactor, and mastra
+- **Generates `framework.gen.ts`** (codegen-owned) with the document registry — regenerated when the spec's `documentTypes` change
+- **Emits `framework.ts`** once (user-owned) with `configSchema`, `secretsSchema`, and `createTypes()` — never overwritten after creation
+
+**The agent never hand-edits marker regions in `cli.ts`.** To add or change CLI features:
+
+1. Update `project-spec.json` to declare the new structure
+2. Run `clint-project-regen` to regenerate the marker regions
+3. Run `clint-project-build` to verify
+
+User-owned code outside markers (`configSchema`, `secretsSchema`, `CLI_NAME`) is preserved across regens. User-owned files (`framework.ts`, `src/commands/*.ts`, `src/services/*.ts`, `src/triggers/*.ts`) are never overwritten.
+
+=== END OF SKILL BRIEFING ===
+
+## Specific tasks
+
+* **Assess Cli Needs** [references/00.assess-cli-needs.md](references/00.assess-cli-needs.md)
+* **Define Config Schema** [references/01.define-config-schema.md](references/01.define-config-schema.md)
+* **Wire Cli** [references/02.wire-cli.md](references/02.wire-cli.md)
+* **Add Entrypoint** [references/03.add-entrypoint.md](references/03.add-entrypoint.md)
+* **Expected Outcome** [references/expected-outcome.md](references/expected-outcome.md)

package/dist/gen/skills/cli-setup/references/00.assess-cli-needs.md

@@ -0,0 +1,53 @@
+# Phase 0: Assess CLI Needs
+
+Before writing any code, determine which features the CLI requires.
+
+## Steps
+
+### 1. Name the CLI
+
+Choose a kebab-case name. This name is used for:
+- Config file paths: `{workdir}/.ph/{name}.config.local.json`
+- Environment variable prefix: `{NAME}_*` (UPPER_SNAKE_CASE)
+- Package `"bin"` field and executable name
+
+### 2. Determine version sourcing
+
+Choose one:
+- **Hardcoded**: `version: '1.0.0'`
+- **From package.json**: `const { version } = readPackageInfo(import.meta.url)`
+
+### 3. Feature checklist
+
+For each feature, determine if the CLI needs it:
+
+- [ ] **Custom config?** → needs `configSchema` (Zod object)
+- [ ] **Sensitive config (API keys, tokens)?** → needs `secretsSchema` (Zod object)
+- [ ] **Interactive REPL?** → needs `interactive` with `welcome` message
+- [ ] **Background services?** → needs `services` array of `defineService()` definitions
+- [ ] **Automated triggers?** → needs `triggers` array + `routine` config
+- [ ] **AI agent?** → needs `cli.configureAgent(loader)` after `defineCli()`
+- [ ] **Skill templates?** → needs `prompts` config with `artifacts`, `agents`, `skills`
+- [ ] **Powerhouse documents?** → needs `cli.configureReactor(config)` after `defineCli()`
+- [ ] **Service lifecycle events?** → needs `events` handlers
+- [ ] **Implementation-level workdir override?** → needs `workdir` option (hides `--workdir` flag)
+
+### 4. List commands to register
+
+Enumerate all commands that will be passed to the `commands` array. These should already be defined using `defineCommand()` (see the `command-definition` skill). Note which ones need agent-compatible `{ text, data }` returns.
+
+### 5. Detect codegen vs manual project
+
+For existing projects, check if `cli.ts` already has `@clint:begin` marker regions:
+- **Codegen-managed**: Markers present — update `project-spec.json` and run `clint-project-regen`. Never hand-edit marker regions.
+- **Manual**: No markers — edit `defineCli()` directly as a regular TypeScript file.
+
+For new projects, prefer using `clint-project-init` to generate the scaffold with markers.
+
+### 6. Determine config field names
+
+For each config/secret field, verify the auto-generated env var name is sensible:
+- Field `apiKey` on CLI `mycli` → env var `MYCLI_API_KEY`
+- Field `connectPort` on CLI `vetra` → env var `VETRA_CONNECT_PORT`
+
+If a name would be confusing, consider renaming the field.