@powerhousedao/ph-clint-cli 0.1.0-dev.2 → 0.1.0-dev.20

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/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()
@@ -40,29 +52,33 @@ export const clintProjectSpecSchema = z.object({
         .string()
         .regex(/^[a-z0-9][a-z0-9-]*$/, 'lowercase letters, digits, hyphens only')
         .optional(),
-    version: z.string().default('0.1.0'),
+    version: z.string().default('0.0.1-dev.0'),
     description: z.string().default(''),
     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

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

@@ -0,0 +1,11 @@
+/** Map document model PublishTag values to CLI --tag values. */
+export declare function tagToCli(tag: string): 'dev' | 'staging' | 'production' | null;
+export declare const publishTrigger: import("@powerhousedao/ph-clint").Trigger<{
+    pending: number;
+}, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    projectDocumentId?: string | undefined;
+    apiKey?: string | undefined;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;

package/dist/triggers/publish-trigger.js

@@ -0,0 +1,172 @@
+/**
+ * `publish-trigger` — watches `powerhouse/ph-clint-project` documents for
+ * publish records with `Pending` status and invokes the publish pipeline.
+ *
+ * Unlike `spec-change`, this trigger does NOT convert to a `ClintProjectSpec`.
+ * It reads `publishHistory` directly from the document state, since publish
+ * records are a doc-model concern (not a codegen input).
+ *
+ * Flow:
+ *   1. On document change, scans `publishHistory` for records with status
+ *      `"Pending"`.
+ *   2. For each pending record, returns a work item that:
+ *      a. Dispatches SET_PUBLISH_STATUS({ id, status: "InProgress" }).
+ *      b. Runs `ph-clint clint-project-publish --tag <tag>`.
+ *      c. Dispatches SET_PUBLISH_STATUS({ id, status: "Succeeded"|"Failed" }).
+ */
+import { spawn } from 'node:child_process';
+import { setPublishStatus } from '@powerhousedao/ph-clint-app';
+import { createDocumentChangeTrigger } from '../framework.js';
+const DOCUMENT_TYPE = 'powerhouse/ph-clint-project';
+const TAG = '[publish]';
+/** Find the first ph-clint-project document on the default drive. */
+async function findProjectDocumentId(client, driveId) {
+    try {
+        const children = await client.getChildren(driveId);
+        const results = (children?.results ?? []);
+        for (const node of results) {
+            if (node.header?.documentType === DOCUMENT_TYPE && node.header.id) {
+                return node.header.id;
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return undefined;
+}
+/** Run a shell command and return stdout. Rejects on non-zero exit. */
+function exec(cmd, args, cwd, onLog) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        const out = [];
+        const err = [];
+        proc.stdout?.on('data', (d) => {
+            const s = d.toString();
+            out.push(s);
+            if (onLog)
+                for (const line of s.split('\n'))
+                    if (line.trim())
+                        onLog(line.trim());
+        });
+        proc.stderr?.on('data', (d) => {
+            const s = d.toString();
+            err.push(s);
+            if (onLog)
+                for (const line of s.split('\n'))
+                    if (line.trim())
+                        onLog(line.trim());
+        });
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+            if (code === 0)
+                resolve(out.join(''));
+            else
+                reject(new Error(`${cmd} ${args.join(' ')} exited ${code}\n${err.join('')}`));
+        });
+    });
+}
+/** Map document model PublishTag values to CLI --tag values. */
+export function tagToCli(tag) {
+    switch (tag) {
+        case 'Dev':
+            return 'dev';
+        case 'Staging':
+            return 'staging';
+        case 'Production':
+            return 'production';
+        default:
+            return null;
+    }
+}
+export const publishTrigger = createDocumentChangeTrigger({
+    id: 'publish-trigger',
+    documentType: DOCUMENT_TYPE,
+    // Don't fire on startup — only react to new pending records.
+    initialReconcile: false,
+    // Resolve the target document lazily (same pattern as spec-change trigger).
+    documentId: async (ctx) => {
+        const configured = ctx.context.config.projectDocumentId &&
+            ctx.context.config.projectDocumentId.length > 0
+            ? ctx.context.config.projectDocumentId
+            : undefined;
+        if (configured)
+            return configured;
+        const reactor = await ctx.reactor();
+        if (!reactor)
+            return undefined;
+        return findProjectDocumentId(reactor.client, reactor.driveId);
+    },
+    async onChange(doc, ctx) {
+        const log = ctx.context.log;
+        const publishHistory = doc.state.global.publishHistory ?? [];
+        const pending = publishHistory.filter((r) => r.status === 'Pending');
+        if (pending.length === 0)
+            return null;
+        // Process the first pending record (one per tick to avoid races).
+        const record = pending[0];
+        const cliTag = tagToCli(record.tag);
+        if (!cliTag) {
+            log?.warn(`${TAG} unknown publish tag "${record.tag}" for record ${record.id}`);
+            return null;
+        }
+        log?.info(`${TAG} found pending ${record.tag} publish (id=${record.id}, version=${record.version})`);
+        return {
+            type: 'function',
+            params: {
+                fn: async () => {
+                    const reactor = await ctx.reactor();
+                    if (!reactor) {
+                        log?.error(`${TAG} reactor not available, cannot update publish status`);
+                        return;
+                    }
+                    // Mark as InProgress.
+                    log?.info(`${TAG} marking record ${record.id} as InProgress`);
+                    await reactor.client.execute(doc.header.id, 'main', [
+                        setPublishStatus({ id: record.id, status: 'InProgress' }),
+                    ]);
+                    // Install dependencies in the generated project before publishing.
+                    const workdir = ctx.context.workdir;
+                    log?.info(`${TAG} running pnpm install in ${workdir}`);
+                    try {
+                        await exec('pnpm', ['install'], workdir, (msg) => log?.debug(`${TAG} [install] ${msg}`));
+                    }
+                    catch (installErr) {
+                        log?.error(`${TAG} pnpm install failed: ${installErr instanceof Error ? installErr.message : String(installErr)}`);
+                    }
+                    // Run the publish command.
+                    let success = false;
+                    try {
+                        log?.info(`${TAG} invoking clint-project-publish --tag ${cliTag}`);
+                        const { clintProjectPublish } = await import('../commands/clint-project-publish.js');
+                        const result = await clintProjectPublish.execute({ tag: cliTag, dryRun: false, skipBuild: false, skipGitCheck: true, verbose: false }, 
+                        // @ts-expect-error — minimal context; publish uses workdir + stdout.
+                        {
+                            workdir: ctx.context.workdir,
+                            stdout: (msg) => log?.info(`${TAG} ${msg}`),
+                            log,
+                        });
+                        success = !result.text.includes('failed');
+                    }
+                    catch (err) {
+                        log?.error(`${TAG} publish failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    // Update status.
+                    const finalStatus = success ? 'Succeeded' : 'Failed';
+                    log?.info(`${TAG} marking record ${record.id} as ${finalStatus}`);
+                    await reactor.client.execute(doc.header.id, 'main', [
+                        setPublishStatus({
+                            id: record.id,
+                            status: finalStatus,
+                        }),
+                    ]);
+                },
+            },
+            callbacks: {
+                onFailure: (err) => {
+                    log?.error(`${TAG} publish trigger failed: ${err.message}`);
+                },
+            },
+        };
+    },
+});