@powerhousedao/ph-clint-cli 0.1.0-dev.15 → 0.1.0-dev.16

package/dist/framework.d.ts

@@ -32,38 +32,7 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
         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;
@@ -76,75 +45,13 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
     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;
@@ -160,38 +67,7 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
     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;
@@ -203,37 +79,6 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
     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/skills/sync.d.ts

@@ -0,0 +1,40 @@
+import type { ExternalSkill } from '../spec/types.js';
+/** On-disk manifest entry (what is currently installed). */
+export interface ManifestEntry {
+    name: string;
+    githubUrl: string;
+}
+/** Persisted manifest — a simple JSON array. */
+export type SkillsManifest = ManifestEntry[];
+export interface SyncResult {
+    added: string[];
+    removed: string[];
+    unchanged: string[];
+}
+export interface SyncOptions {
+    /** Project root (CLI sub-tree when split layout). */
+    targetDir: string;
+    /** Desired state from the spec. */
+    desired: ExternalSkill[];
+    /** Optional log callback. */
+    log?: (msg: string) => void;
+}
+export declare function readManifest(targetDir: string): Promise<SkillsManifest>;
+/**
+ * Compute the diff between desired (spec) and current (manifest) skills.
+ *
+ * Pure function — no I/O.
+ */
+export declare function diffSkills(desired: ExternalSkill[], current: SkillsManifest): {
+    toAdd: ExternalSkill[];
+    toRemove: ManifestEntry[];
+    unchanged: string[];
+};
+/**
+ * Synchronise external skills on disk to match the spec.
+ *
+ * - Clones missing skills via `git clone --depth 1`.
+ * - Removes skills no longer in the spec.
+ * - Updates the `.skills-manifest.json`.
+ */
+export declare function syncExternalSkills(opts: SyncOptions): Promise<SyncResult>;

package/dist/skills/sync.js

@@ -0,0 +1,119 @@
+/**
+ * External skills synchronisation.
+ *
+ * Reads the desired external skills from a `ClintProjectSpec`, diffs them
+ * against a `.skills-manifest.json` on disk, and runs `git clone` / `rm -rf`
+ * to reconcile.  Each external skill ends up as a subdirectory of
+ * `prompts/skills-ext/<name>/` so the build-skills pipeline picks it up.
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const MANIFEST_FILE = '.skills-manifest.json';
+const SKILLS_DIR = path.join('prompts', 'skills-ext');
+function manifestPath(targetDir) {
+    return path.join(targetDir, SKILLS_DIR, MANIFEST_FILE);
+}
+export async function readManifest(targetDir) {
+    try {
+        const raw = await fs.readFile(manifestPath(targetDir), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+async function writeManifest(targetDir, manifest) {
+    const file = manifestPath(targetDir);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify(manifest, null, 2) + '\n', 'utf8');
+}
+function execGit(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stderr = '';
+        if (proc.stderr) {
+            proc.stderr.on('data', (d) => {
+                stderr += d.toString();
+            });
+        }
+        proc.on('close', (code) => resolve({ code: code ?? 1, stderr }));
+        proc.on('error', (err) => reject(err));
+    });
+}
+/**
+ * Compute the diff between desired (spec) and current (manifest) skills.
+ *
+ * Pure function — no I/O.
+ */
+export function diffSkills(desired, current) {
+    const desiredMap = new Map(desired.map((s) => [s.name, s]));
+    const currentMap = new Map(current.map((s) => [s.name, s]));
+    const toAdd = [];
+    const toRemove = [];
+    const unchanged = [];
+    for (const [name, skill] of desiredMap) {
+        const existing = currentMap.get(name);
+        if (!existing) {
+            toAdd.push(skill);
+        }
+        else if (existing.githubUrl !== skill.githubUrl) {
+            // URL changed — remove old, add new.
+            toRemove.push(existing);
+            toAdd.push(skill);
+        }
+        else {
+            unchanged.push(name);
+        }
+    }
+    for (const [name, entry] of currentMap) {
+        if (!desiredMap.has(name)) {
+            toRemove.push(entry);
+        }
+    }
+    return { toAdd, toRemove, unchanged };
+}
+/**
+ * Synchronise external skills on disk to match the spec.
+ *
+ * - Clones missing skills via `git clone --depth 1`.
+ * - Removes skills no longer in the spec.
+ * - Updates the `.skills-manifest.json`.
+ */
+export async function syncExternalSkills(opts) {
+    const { targetDir, desired, log } = opts;
+    const skillsDir = path.join(targetDir, SKILLS_DIR);
+    await fs.mkdir(skillsDir, { recursive: true });
+    const current = await readManifest(targetDir);
+    const { toAdd, toRemove, unchanged } = diffSkills(desired, current);
+    const result = { added: [], removed: [], unchanged };
+    // Remove skills.
+    for (const entry of toRemove) {
+        const dir = path.join(skillsDir, entry.name);
+        log?.(`Removing skill "${entry.name}"…`);
+        await fs.rm(dir, { recursive: true, force: true });
+        result.removed.push(entry.name);
+    }
+    // Add skills.
+    for (const skill of toAdd) {
+        const dir = path.join(skillsDir, skill.name);
+        log?.(`Cloning skill "${skill.name}" from ${skill.githubUrl}…`);
+        // Ensure the target doesn't exist (re-add after URL change).
+        await fs.rm(dir, { recursive: true, force: true });
+        const { code, stderr } = await execGit(['clone', '--depth', '1', skill.githubUrl, skill.name], skillsDir);
+        if (code !== 0) {
+            log?.(`Warning: git clone failed for "${skill.name}": ${stderr.trim()}`);
+            continue;
+        }
+        // Remove .git dir — we don't want a nested repo.
+        await fs.rm(path.join(dir, '.git'), { recursive: true, force: true });
+        result.added.push(skill.name);
+    }
+    // Write updated manifest.
+    const newManifest = desired.map((s) => ({
+        name: s.name,
+        githubUrl: s.githubUrl,
+    }));
+    await writeManifest(targetDir, newManifest);
+    return result;
+}

package/dist/spec/from-document.js

@@ -8,11 +8,6 @@ import { clintProjectSpecSchema, } from './types.js';
 export function specFromDocumentState(state) {
     if (!state.name)
         return null;
-    // `documentTypes` is a forward-compatible field — older `ph-clint-project`
-    // document states don't declare it yet. Pull through if present, otherwise
-    // leave it to the schema default (`[]`). Codegen treats the empty list as
-    // "no registry entries" and emits an empty `defineRegistry([...])`.
-    const documentTypes = state.documentTypes ?? undefined;
     const parsed = clintProjectSpecSchema.safeParse({
         name: state.name,
         scope: state.scope ?? undefined,
@@ -20,11 +15,20 @@ export function specFromDocumentState(state) {
         description: state.description,
         bin: state.bin ?? undefined,
         features: {
-            powerhouse: { ...state.features.powerhouse },
+            powerhouse: state.features.powerhouse,
             mastra: { ...state.features.mastra },
             routine: { ...state.features.routine },
         },
-        ...(Array.isArray(documentTypes) ? { documentTypes } : {}),
+        packages: state.packages.map((p) => ({
+            id: p.id,
+            packageName: p.packageName,
+            documentTypes: [...p.documentTypes],
+        })),
+        externalSkills: state.externalSkills.map((s) => ({
+            id: s.id,
+            name: s.name,
+            githubUrl: s.githubUrl,
+        })),
     });
     return parsed.success ? parsed.data : null;
 }

package/dist/spec/types.d.ts

@@ -9,6 +9,32 @@
  * generator step actually needs it.
  */
 import { z } from 'zod';
+/**
+ * Ordered Powerhouse integration level. Higher levels imply all lower ones:
+ *   Disabled → Reactor → Switchboard → Connect
+ */
+export declare const POWERHOUSE_LEVELS: readonly ["Disabled", "Reactor", "Switchboard", "Connect"];
+export declare const powerhouseLevelSchema: z.ZodDefault<z.ZodEnum<{
+    Disabled: "Disabled";
+    Reactor: "Reactor";
+    Switchboard: "Switchboard";
+    Connect: "Connect";
+}>>;
+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 powerhousePackageSchema: z.ZodObject<{
+    id: z.ZodString;
+    packageName: z.ZodString;
+    documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PowerhousePackage = z.infer<typeof powerhousePackageSchema>;
+export declare const externalSkillSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    githubUrl: z.ZodString;
+}, z.core.$strip>;
+export type ExternalSkill = z.infer<typeof externalSkillSchema>;
 export declare const clintProjectSpecSchema: z.ZodObject<{
     name: z.ZodString;
     scope: z.ZodOptional<z.ZodString>;
@@ -16,11 +42,12 @@ export declare const clintProjectSpecSchema: z.ZodObject<{
     description: z.ZodDefault<z.ZodString>;
     bin: z.ZodOptional<z.ZodString>;
     features: z.ZodDefault<z.ZodObject<{
-        powerhouse: z.ZodDefault<z.ZodObject<{
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            switchboard: z.ZodDefault<z.ZodBoolean>;
-            connect: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>>;
+        powerhouse: z.ZodDefault<z.ZodEnum<{
+            Disabled: "Disabled";
+            Reactor: "Reactor";
+            Switchboard: "Switchboard";
+            Connect: "Connect";
+        }>>;
         mastra: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
@@ -28,7 +55,16 @@ export declare const clintProjectSpecSchema: z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
-    documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    packages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        packageName: z.ZodString;
+        documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    externalSkills: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        githubUrl: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type ClintProjectSpec = z.infer<typeof clintProjectSpecSchema>;
 export type ClintProjectSpecInput = z.input<typeof clintProjectSpecSchema>;
@@ -45,6 +81,19 @@ export declare function getCliFolderName(spec: ClintProjectSpec): string;
  * Name of the reactor-package sub-folder when the project is split.
  */
 export declare function getAppFolderName(spec: ClintProjectSpec): string;
+/**
+ * Flat list of all document types across all packages. Convenience for
+ * codegen that needs to iterate every registered document type regardless
+ * of which package provides it.
+ */
+export declare function getAllDocumentTypes(spec: ClintProjectSpec): string[];
+/**
+ * The app npm package name (`@scope/{name}-app` or `{name}-app`).
+ * Matches what the document model reducer stores in `packages[].packageName`.
+ */
+export declare function getAppPackageName(spec: ClintProjectSpec): string;
+/** Directory name for the app package (`{name}-app`, no scope prefix). */
+export declare function getAppDirName(spec: ClintProjectSpec): string;
 /**
  * Folder slug for a documentType ID. The slug is the portion after the last
  * `/` (e.g. `powerhouse/ph-clint-project` → `ph-clint-project`). Matches the

package/dist/spec/types.js

@@ -9,29 +9,41 @@
  * generator step actually needs it.
  */
 import { z } from 'zod';
-const powerhouseFeatureSchema = z.object({
-    enabled: z.boolean().default(false),
-    switchboard: z.boolean().default(true),
-    connect: z.boolean().default(true),
-});
+/**
+ * Ordered Powerhouse integration level. Higher levels imply all lower ones:
+ *   Disabled → Reactor → Switchboard → Connect
+ */
+export const POWERHOUSE_LEVELS = [
+    'Disabled',
+    'Reactor',
+    'Switchboard',
+    'Connect',
+];
+export const powerhouseLevelSchema = z
+    .enum(POWERHOUSE_LEVELS)
+    .default('Disabled');
+/** Check whether `level` is at least `threshold` in the ordered enum. */
+export function phAtLeast(level, threshold) {
+    return (POWERHOUSE_LEVELS.indexOf(level) >= POWERHOUSE_LEVELS.indexOf(threshold));
+}
 const mastraFeatureSchema = z.object({
     enabled: z.boolean().default(false),
 });
 const routineFeatureSchema = z.object({
     enabled: z.boolean().default(false),
 });
-// Zod 4 does not cascade `.default({})` through nested object schemas — a
-// missing outer key fills in `{}`, but nested keys with their own `.default`
-// are not re-defaulted unless the object itself re-parses. We spell out full
-// defaults here so `clintProjectSpecSchema.parse({ name: 'x' })` yields a
-// fully-populated feature tree.
-const DEFAULT_POWERHOUSE = {
-    enabled: false,
-    switchboard: true,
-    connect: true,
-};
 const DEFAULT_MASTRA = { enabled: false };
 const DEFAULT_ROUTINE = { enabled: false };
+export const powerhousePackageSchema = z.object({
+    id: z.string(),
+    packageName: z.string(),
+    documentTypes: z.array(z.string()).default([]),
+});
+export const externalSkillSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    githubUrl: z.string(),
+});
 export const clintProjectSpecSchema = z.object({
     name: z
         .string()
@@ -45,24 +57,28 @@ export const clintProjectSpecSchema = z.object({
     bin: z.string().optional(),
     features: z
         .object({
-        powerhouse: powerhouseFeatureSchema.default(DEFAULT_POWERHOUSE),
+        powerhouse: powerhouseLevelSchema,
         mastra: mastraFeatureSchema.default(DEFAULT_MASTRA),
         routine: routineFeatureSchema.default(DEFAULT_ROUTINE),
     })
         .default({
-        powerhouse: DEFAULT_POWERHOUSE,
+        powerhouse: 'Disabled',
         mastra: DEFAULT_MASTRA,
         routine: DEFAULT_ROUTINE,
     }),
     /**
-     * Document types registered with this CLI — full documentType ID strings
-     * (e.g. `powerhouse/ph-clint-project`). Drives codegen of `src/framework.gen.ts`,
-     * which emits a typed `defineRegistry([...] as const)` call so impl code
-     * gets narrowed `reactor.client.get(id, 'my-type')` access. Empty on
-     * fresh projects — populated as document models are added to the reactor
-     * package.
+     * Reactor packages and their document types. Each entry groups a package
+     * name with the document type IDs it provides. The app package (project's
+     * own reactor package) uses a `file:` dependency; external packages become
+     * versioned npm dependencies. Drives codegen of `framework.gen.ts`,
+     * `app/index.ts`, and `cli/package.json`.
      */
-    documentTypes: z.array(z.string()).default([]),
+    packages: z.array(powerhousePackageSchema).default([]),
+    /**
+     * External skills from the skills.sh ecosystem. Each skill has a name
+     * (kebab-case) and a GitHub URL for installation.
+     */
+    externalSkills: z.array(externalSkillSchema).default([]),
 });
 /** npm package name (e.g. `@scope/foo` or `foo`). */
 export function getPackageName(spec) {
@@ -85,6 +101,26 @@ export function getCliFolderName(spec) {
 export function getAppFolderName(spec) {
     return `${spec.name}-app`;
 }
+/**
+ * Flat list of all document types across all packages. Convenience for
+ * codegen that needs to iterate every registered document type regardless
+ * of which package provides it.
+ */
+export function getAllDocumentTypes(spec) {
+    return spec.packages.flatMap((p) => p.documentTypes);
+}
+/**
+ * The app npm package name (`@scope/{name}-app` or `{name}-app`).
+ * Matches what the document model reducer stores in `packages[].packageName`.
+ */
+export function getAppPackageName(spec) {
+    const base = `${spec.name}-app`;
+    return spec.scope ? `@${spec.scope}/${base}` : base;
+}
+/** Directory name for the app package (`{name}-app`, no scope prefix). */
+export function getAppDirName(spec) {
+    return `${spec.name}-app`;
+}
 /**
  * Folder slug for a documentType ID. The slug is the portion after the last
  * `/` (e.g. `powerhouse/ph-clint-project` → `ph-clint-project`). Matches the