clawchef 0.1.0 → 0.1.1

package/README.md

@@ -17,9 +17,9 @@ Recipe-driven OpenClaw environment orchestrator.
 - Creates workspaces and agents (default workspace path: `~/.openclaw/workspaces/<workspace-name>`).
 - Materializes files into target workspaces.
 - Installs skills.
+- Supports plugin preinstall via `openclaw.plugins[]` and runtime `--plugin` flags.
 - Configures channels with `openclaw channels add`.
-- Enables channel plugins before channel configuration.
-- Supports interactive channel login at the end of execution (`channels[].login: true`).
+- Supports interactive channel login at the end of execution (`channels[].login: true`) for channels that expose login.
 - Supports remote HTTP orchestration via runtime flags (`--provider remote`) when OpenClaw is reachable via API.
 - Writes preset conversation messages.
 - Runs agent and validates reply output.
@@ -27,9 +27,7 @@ Recipe-driven OpenClaw environment orchestrator.
 ## Install and run
 
 ```bash
-npm install
-npm run build
-npm i -g .
+npm i -g clawchef
 clawchef cook recipes/sample.yaml
 ```
 
@@ -94,6 +92,12 @@ Telegram mock channel setup (for tests):
 CLAWCHEF_VAR_TELEGRAM_MOCK_API_KEY=test-key clawchef cook recipes/openclaw-telegram-mock.yaml -s
 ```
 
+Install plugin only for this run:
+
+```bash
+clawchef cook recipes/openclaw-telegram-mock.yaml --plugin openclaw-telegram-mock-channel -s
+```
+
 Remote HTTP orchestration:
 
 ```bash
@@ -121,12 +125,32 @@ clawchef validate ./bundle.zip
 clawchef validate ./bundle.zip:custom/recipe.yaml
 ```
 
+Create a new recipe project scaffold:
+
+```bash
+clawchef scaffold
+clawchef scaffold ./my-recipe-project
+clawchef scaffold ./my-recipe-project --name meetingbot
+```
+
+`scaffold` prompts for project name (default: target directory name).
+
+Scaffold output:
+
+- `package.json` with `telegram-api-mock-server` in `devDependencies`
+- `src/recipe.yaml` with `telegram-mock` channel and plugin preinstall
+- `src/<project-name>-assets/{AGENTS.md,IDENTITY.md,SOUL.md,TOOLS.md}`
+- `src/<project-name>-assets/scripts/scheduling.mjs`
+- `test/recipe-smoke.test.mjs`
+
+By default scaffold only writes files; it does not run `npm install`.
+
 ## Node.js API
 
 You can call clawchef directly from Node.js (without invoking CLI commands).
 
 ```ts
-import { cook, validate } from "clawchef";
+import { cook, scaffold, validate } from "clawchef";
 
 await validate("recipes/sample.yaml");
 
@@ -137,11 +161,16 @@ await cook("recipes/sample.yaml", {
     openai_api_key: process.env.OPENAI_API_KEY ?? "",
   },
 });
+
+await scaffold("./my-recipe-project", {
+  projectName: "my-recipe-project",
+});
 ```
 
 `cook()` options:
 
 - `vars`: template variables (`Record<string, string>`)
+- `plugins`: plugin npm specs to preinstall for this run (`string[]`)
 - `provider`: `command | remote | mock`
 - `remote`: remote provider config (same fields as CLI remote flags)
 - `dryRun`, `allowMissing`, `verbose`
@@ -152,6 +181,7 @@ Notes:
 
 - `validate()` throws on invalid recipe.
 - `cook()` throws on runtime/configuration errors.
+- `scaffold()` creates `package.json`, `src/recipe.yaml`, `src/<project-name>-assets`, and `test/`.
 
 ## Variable precedence
 
@@ -233,6 +263,7 @@ Expected response format:
 Supported operation values sent by clawchef:
 
 - `ensure_version`, `factory_reset`, `start_gateway`
+- `install_plugin`
 - `create_workspace`, `create_agent`, `materialize_file`, `install_skill`
 - `configure_channel`, `login_channel`
 - `run_agent`
@@ -258,6 +289,20 @@ Supported fields include:
 - setup toggles: `skip_channels`, `skip_skills`, `skip_health`, `skip_ui`, `skip_daemon`, `install_daemon`
 - auth/provider: `auth_choice`, `openai_api_key`, `anthropic_api_key`, `openrouter_api_key`, `xai_api_key`, `gemini_api_key`, `ai_gateway_api_key`, `cloudflare_ai_gateway_api_key`, `token`, `token_provider`, `token_profile_id`
 
+### Plugin preinstall
+
+Use `openclaw.plugins` to preinstall plugin packages before workspace/channel setup.
+
+Example:
+
+```yaml
+openclaw:
+  version: "2026.2.9"
+  plugins:
+    - "openclaw-telegram-mock-channel"
+    - "@scope/custom-channel-plugin@1.2.3"
+```
+
 When `openclaw.bootstrap` contains provider keys, `clawchef` also injects them into runtime env for `openclaw agent --local`.
 
 For `command` provider, default command templates are:
@@ -265,9 +310,9 @@ For `command` provider, default command templates are:
 - `use_version`: `${bin} --version`
 - `install_version`: `npm install -g openclaw@${version}`
 - `uninstall_version`: `npm uninstall -g openclaw`
+- `install_plugin`: `${bin} plugins install ${plugin_spec_q}`
 - `factory_reset`: `${bin} reset --scope full --yes --non-interactive`
 - `start_gateway`: `${bin} gateway start`
-- `enable_plugin`: `${bin} plugins enable ${channel_q}`
 - `login_channel`: `${bin} channels login --channel ${channel_q}${account_arg}`
 - `create_workspace`: generated from `openclaw.bootstrap` (override with `openclaw.commands.create_workspace`)
 - `create_agent`: `${bin} agents add ${agent} --workspace ${workspace_path} --model ${model} --non-interactive --json`
@@ -277,10 +322,14 @@ For `command` provider, default command templates are:
 
 You can override any command under `openclaw.commands` in recipe.
 
+By default, clawchef does not auto-run `openclaw plugins enable <channel>` during channel configuration.
+If you need custom enable behavior, set `openclaw.commands.enable_plugin` explicitly.
+
 ## Channels
 
 Use `channels[]` to configure accounts via `openclaw channels add`.
 If `login: true` is set, clawchef runs channel login at the end of `cook` (after gateway start).
+Telegram does not support `openclaw channels login`; do not set `login` for `channel: "telegram"`.
 
 Example:
 
@@ -289,7 +338,6 @@ channels:
   - channel: "telegram"
     token: "${telegram_bot_token}"
     account: "default"
-    login: true
 
   - channel: "slack"
     bot_token: "${slack_bot_token}"

package/dist/api.d.ts

@@ -1,6 +1,8 @@
 import type { OpenClawProvider, OpenClawRemoteConfig } from "./types.js";
+import type { ScaffoldOptions, ScaffoldResult } from "./scaffold.js";
 export interface CookOptions {
     vars?: Record<string, string>;
+    plugins?: string[];
     dryRun?: boolean;
     allowMissing?: boolean;
     verbose?: boolean;
@@ -11,4 +13,6 @@ export interface CookOptions {
 }
 export declare function cook(recipeRef: string, options?: CookOptions): Promise<void>;
 export declare function validate(recipeRef: string): Promise<void>;
+export declare function scaffold(targetDir?: string, options?: ScaffoldOptions): Promise<ScaffoldResult>;
 export type { OpenClawProvider, OpenClawRemoteConfig };
+export type { ScaffoldOptions, ScaffoldResult };

package/dist/api.js

@@ -4,10 +4,13 @@ import { importDotEnvFromCwd } from "./env.js";
 import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
+import { scaffoldProject } from "./scaffold.js";
 import { recipeSchema } from "./schema.js";
 function normalizeCookOptions(options) {
+    const plugins = Array.from(new Set((options.plugins ?? []).map((value) => value.trim()).filter((value) => value.length > 0)));
     return {
         vars: options.vars ?? {},
+        plugins,
         dryRun: Boolean(options.dryRun),
         allowMissing: Boolean(options.allowMissing),
         verbose: Boolean(options.verbose),
@@ -47,3 +50,6 @@ export async function validate(recipeRef) {
         }
     }
 }
+export async function scaffold(targetDir, options = {}) {
+    return scaffoldProject(targetDir, options);
+}

package/dist/cli.js

@@ -4,7 +4,11 @@ import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
 import { recipeSchema } from "./schema.js";
+import { scaffoldProject } from "./scaffold.js";
 import YAML from "js-yaml";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
 function parseVarFlags(values) {
     const out = {};
     for (const item of values) {
@@ -18,6 +22,9 @@ function parseVarFlags(values) {
     }
     return out;
 }
+function parsePluginFlags(values) {
+    return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
 function readEnv(name) {
     const value = process.env[name];
     if (value === undefined) {
@@ -42,6 +49,20 @@ function parseOptionalInt(value, fieldName) {
     }
     return parsed;
 }
+async function promptProjectName(defaultValue) {
+    if (!input.isTTY) {
+        return defaultValue;
+    }
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question(`Project name [${defaultValue}]: `);
+        const value = answer.trim();
+        return value || defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
 export function buildCli() {
     const program = new Command();
     program
@@ -57,6 +78,7 @@ export function buildCli() {
         .option("--verbose", "Verbose logging", false)
         .option("-s, --silent", "Skip reset confirmation prompt", false)
         .option("--provider <provider>", "Execution provider: command | remote | mock")
+        .option("--plugin <npm-spec>", "Preinstall plugin package (repeatable)", (v, p) => p.concat([v]), [])
         .option("--remote-base-url <url>", "Remote OpenClaw API base URL")
         .option("--remote-api-key <key>", "Remote OpenClaw API key")
         .option("--remote-api-header <header>", "Remote auth header name")
@@ -67,6 +89,7 @@ export function buildCli() {
         const provider = parseProvider(opts.provider ?? readEnv("CLAWCHEF_PROVIDER") ?? "command");
         const options = {
             vars: parseVarFlags(opts.var),
+            plugins: parsePluginFlags(opts.plugin),
             dryRun: Boolean(opts.dryRun),
             allowMissing: Boolean(opts.allowMissing),
             verbose: Boolean(opts.verbose),
@@ -92,6 +115,19 @@ export function buildCli() {
             }
         }
     });
+    program
+        .command("scaffold")
+        .argument("[dir]", "Target directory (default: current directory)")
+        .option("--name <project-name>", "Project name (default: directory name)")
+        .action(async (dir, opts) => {
+        const resolvedDir = path.resolve(dir?.trim() ? dir : process.cwd());
+        const defaultName = path.basename(resolvedDir);
+        const projectName = opts.name?.trim() ? opts.name.trim() : await promptProjectName(defaultName);
+        const result = await scaffoldProject(resolvedDir, { projectName });
+        process.stdout.write(`Scaffold created at ${result.targetDir}\n`);
+        process.stdout.write(`Project name: ${result.projectName}\n`);
+        process.stdout.write("Next: run npm install\n");
+    });
     program
         .command("validate")
         .argument("<recipe>", "Recipe path/URL/dir/archive[:file]")

package/dist/openclaw/command-provider.d.ts

@@ -4,6 +4,7 @@ export declare class CommandOpenClawProvider implements OpenClawProvider {
     private readonly stagedMessages;
     ensureVersion(config: OpenClawSection, dryRun: boolean, silent: boolean): Promise<EnsureVersionResult>;
     factoryReset(config: OpenClawSection, dryRun: boolean): Promise<void>;
+    installPlugin(config: OpenClawSection, pluginSpec: string, dryRun: boolean): Promise<void>;
     startGateway(config: OpenClawSection, dryRun: boolean): Promise<void>;
     createWorkspace(config: OpenClawSection, workspace: ResolvedWorkspaceDef, dryRun: boolean): Promise<void>;
     configureChannel(config: OpenClawSection, channel: ChannelDef, dryRun: boolean): Promise<void>;

package/dist/openclaw/command-provider.js

@@ -10,9 +10,10 @@ const DEFAULT_COMMANDS = {
     use_version: "${bin} --version",
     install_version: "npm install -g openclaw@${version}",
     uninstall_version: "npm uninstall -g openclaw",
+    install_plugin: "${bin} plugins install ${plugin_spec_q}",
     factory_reset: "${bin} reset --scope full --yes --non-interactive",
     start_gateway: "${bin} gateway start",
-    enable_plugin: "${bin} plugins enable ${channel_q}",
+    enable_plugin: "",
     login_channel: "${bin} channels login --channel ${channel_q}${account_arg}",
     create_agent: "${bin} agents add ${agent} --workspace ${workspace_path} --model ${model} --non-interactive --json",
     install_skill: "${bin} skills check",
@@ -302,6 +303,23 @@ export class CommandOpenClawProvider {
         }
         await runShell(resetCmd, dryRun);
     }
+    async installPlugin(config, pluginSpec, dryRun) {
+        const trimmed = pluginSpec.trim();
+        if (!trimmed) {
+            return;
+        }
+        const bin = config.bin ?? "openclaw";
+        const cmd = commandFor(config, "install_plugin", {
+            bin,
+            version: config.version,
+            plugin_spec: trimmed,
+            plugin_spec_q: shellQuote(trimmed),
+        });
+        if (!cmd.trim()) {
+            return;
+        }
+        await runShell(cmd, dryRun);
+    }
     async startGateway(config, dryRun) {
         const bin = config.bin ?? "openclaw";
         const startCmd = commandFor(config, "start_gateway", { bin, version: config.version });
@@ -328,14 +346,17 @@ export class CommandOpenClawProvider {
     }
     async configureChannel(config, channel, dryRun) {
         const bin = config.bin ?? "openclaw";
-        const enablePluginCmd = commandFor(config, "enable_plugin", {
-            bin,
-            version: config.version,
-            channel: channel.channel,
-            channel_q: shellQuote(channel.channel),
-        });
-        if (enablePluginCmd.trim()) {
-            await runShell(enablePluginCmd, dryRun);
+        const enablePluginTemplate = config.commands?.enable_plugin;
+        if (enablePluginTemplate?.trim()) {
+            const enablePluginCmd = fillTemplate(enablePluginTemplate, {
+                bin,
+                version: config.version,
+                channel: channel.channel,
+                channel_q: shellQuote(channel.channel),
+            });
+            if (enablePluginCmd.trim()) {
+                await runShell(enablePluginCmd, dryRun);
+            }
         }
         const flags = [
             "--channel",

package/dist/openclaw/mock-provider.d.ts

@@ -3,6 +3,7 @@ import type { EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from
 export declare class MockOpenClawProvider implements OpenClawProvider {
     private state;
     ensureVersion(config: OpenClawSection, _dryRun: boolean, _silent: boolean): Promise<EnsureVersionResult>;
+    installPlugin(_config: OpenClawSection, _pluginSpec: string, _dryRun: boolean): Promise<void>;
     factoryReset(_config: OpenClawSection, _dryRun: boolean): Promise<void>;
     startGateway(_config: OpenClawSection, _dryRun: boolean): Promise<void>;
     createWorkspace(_config: OpenClawSection, workspace: ResolvedWorkspaceDef, _dryRun: boolean): Promise<void>;

package/dist/openclaw/mock-provider.js

@@ -25,6 +25,9 @@ export class MockOpenClawProvider {
         this.state.currentVersion = config.version;
         return { installedThisRun };
     }
+    async installPlugin(_config, _pluginSpec, _dryRun) {
+        return;
+    }
     async factoryReset(_config, _dryRun) {
         this.state.workspaces.clear();
         this.state.channels.clear();

package/dist/openclaw/provider.d.ts

@@ -7,6 +7,7 @@ export interface EnsureVersionResult {
 }
 export interface OpenClawProvider {
     ensureVersion(config: OpenClawSection, dryRun: boolean, silent: boolean): Promise<EnsureVersionResult>;
+    installPlugin(config: OpenClawSection, pluginSpec: string, dryRun: boolean): Promise<void>;
     factoryReset(config: OpenClawSection, dryRun: boolean): Promise<void>;
     startGateway(config: OpenClawSection, dryRun: boolean): Promise<void>;
     createWorkspace(config: OpenClawSection, workspace: ResolvedWorkspaceDef, dryRun: boolean): Promise<void>;

package/dist/openclaw/remote-provider.d.ts

@@ -6,6 +6,7 @@ export declare class RemoteOpenClawProvider implements OpenClawProvider {
     constructor(remoteConfig: Partial<OpenClawRemoteConfig>);
     private perform;
     ensureVersion(config: OpenClawSection, dryRun: boolean, _silent: boolean): Promise<EnsureVersionResult>;
+    installPlugin(config: OpenClawSection, pluginSpec: string, dryRun: boolean): Promise<void>;
     factoryReset(config: OpenClawSection, dryRun: boolean): Promise<void>;
     startGateway(config: OpenClawSection, dryRun: boolean): Promise<void>;
     createWorkspace(config: OpenClawSection, workspace: ResolvedWorkspaceDef, dryRun: boolean): Promise<void>;

package/dist/openclaw/remote-provider.js

@@ -102,6 +102,11 @@ export class RemoteOpenClawProvider {
             installedThisRun: Boolean(result.installed_this_run),
         };
     }
+    async installPlugin(config, pluginSpec, dryRun) {
+        await this.perform(config, "install_plugin", {
+            plugin_spec: pluginSpec,
+        }, dryRun);
+    }
     async factoryReset(config, dryRun) {
         await this.perform(config, "factory_reset", undefined, dryRun);
     }

package/dist/orchestrator.js

@@ -112,6 +112,12 @@ export async function runRecipe(recipe, recipeOrigin, options, logger) {
         await provider.factoryReset(recipe.openclaw, options.dryRun);
         logger.info("Factory reset completed");
     }
+    const pluginSpecs = Array.from(new Set([...(recipe.openclaw.plugins ?? []), ...options.plugins].map((v) => v.trim())))
+        .filter((v) => v.length > 0);
+    for (const pluginSpec of pluginSpecs) {
+        await provider.installPlugin(recipe.openclaw, pluginSpec, options.dryRun);
+        logger.info(`Plugin preinstalled: ${pluginSpec}`);
+    }
     for (const ws of recipe.workspaces ?? []) {
         const absPath = resolveWorkspacePath(recipeOrigin, ws.name, ws.path);
         workspacePaths.set(ws.name, absPath);

package/dist/recipe.js

@@ -148,6 +148,10 @@ function semanticValidate(recipe) {
         if (!ALLOWED_CHANNELS.has(channel.channel)) {
             throw new ClawChefError(`Unsupported channel: ${channel.channel}. Allowed: ${Array.from(ALLOWED_CHANNELS).join(", ")}`);
         }
+        if (channel.channel === "telegram" &&
+            (channel.login || channel.login_mode !== undefined || channel.login_account !== undefined)) {
+            throw new ClawChefError("channels[] entry for telegram does not support login/login_mode/login_account. Configure token (or use_env/token_file), then start gateway.");
+        }
         const hasAuth = Boolean(channel.use_env) ||
             Boolean(channel.token?.trim()) ||
             Boolean(channel.token_file?.trim()) ||

package/dist/scaffold.d.ts

@@ -0,0 +1,8 @@
+export interface ScaffoldOptions {
+    projectName?: string;
+}
+export interface ScaffoldResult {
+    targetDir: string;
+    projectName: string;
+}
+export declare function scaffoldProject(targetDirArg?: string, options?: ScaffoldOptions): Promise<ScaffoldResult>;

package/dist/scaffold.js

@@ -0,0 +1,197 @@
+import path from "node:path";
+import { access, mkdir, readdir, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { ClawChefError } from "./errors.js";
+function normalizeProjectName(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s_]+/g, "-")
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    if (!normalized) {
+        throw new ClawChefError("Project name is empty after normalization. Use letters, numbers, spaces, underscore, or dash.");
+    }
+    return normalized;
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDirectoryEmpty(targetDir) {
+    const exists = await pathExists(targetDir);
+    if (!exists) {
+        await mkdir(targetDir, { recursive: true });
+        return;
+    }
+    const entries = await readdir(targetDir);
+    if (entries.length > 0) {
+        throw new ClawChefError(`Target directory is not empty: ${targetDir}`);
+    }
+}
+function makePackageJson(projectName) {
+    const content = {
+        name: `${projectName}-recipe`,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: {
+            "test:recipe": "node --test test/recipe-smoke.test.mjs",
+            test: "node --test \"test/**/*.test.mjs\"",
+        },
+        devDependencies: {
+            "telegram-api-mock-server": "^0.1.5",
+        },
+    };
+    return `${JSON.stringify(content, null, 2)}\n`;
+}
+function makeRecipeYaml(projectName) {
+    return `version: "1"
+name: "${projectName}"
+
+params:
+  openclaw_version:
+    default: "2026.2.9"
+  workspace_name:
+    default: "${projectName}"
+  agent_name:
+    default: "${projectName}"
+  agent_model:
+    default: "openai/gpt-4.1"
+  telegram_mock_api_key:
+    required: true
+
+openclaw:
+  bin: "openclaw"
+  version: "\${openclaw_version}"
+  install: "never"
+  plugins:
+    - "openclaw-telegram-mock-channel"
+
+workspaces:
+  - name: "\${workspace_name}"
+
+agents:
+  - workspace: "\${workspace_name}"
+    name: "\${agent_name}"
+    model: "\${agent_model}"
+
+files:
+  - workspace: "\${workspace_name}"
+    path: "AGENTS.md"
+    overwrite: true
+    content_from: "./${projectName}-assets/AGENTS.md"
+
+  - workspace: "\${workspace_name}"
+    path: "IDENTITY.md"
+    overwrite: true
+    content_from: "./${projectName}-assets/IDENTITY.md"
+
+  - workspace: "\${workspace_name}"
+    path: "SOUL.md"
+    overwrite: true
+    content_from: "./${projectName}-assets/SOUL.md"
+
+  - workspace: "\${workspace_name}"
+    path: "TOOLS.md"
+    overwrite: true
+    content_from: "./${projectName}-assets/TOOLS.md"
+
+  - workspace: "\${workspace_name}"
+    path: "scripts/scheduling.mjs"
+    overwrite: true
+    content_from: "./${projectName}-assets/scripts/scheduling.mjs"
+
+channels:
+  - channel: "telegram-mock"
+    account: "default"
+    token: "\${telegram_mock_api_key}"
+    extra_flags:
+      mock_bind: "127.0.0.1:18790"
+      mock_api_key: "\${telegram_mock_api_key}"
+      mode: "webhook"
+`;
+}
+function makeAgentsDoc(projectName) {
+    return `# ${projectName}
+
+Project scaffold generated by clawchef.
+`;
+}
+function makeIdentityDoc(projectName) {
+    return `# Identity
+
+You are the ${projectName} assistant.
+`;
+}
+function makeSoulDoc() {
+    return `# Soul
+
+Keep responses practical, concise, and action-oriented.
+`;
+}
+function makeToolsDoc() {
+    return `# Tools
+
+- Use available workspace files first.
+- Ask for missing secrets explicitly.
+`;
+}
+function makeSchedulingScript() {
+    return `#!/usr/bin/env node
+import process from "node:process";
+
+const message = process.argv.slice(2).join(" ").trim();
+if (!message) {
+  console.error("Usage: node scripts/scheduling.mjs <message>");
+  process.exit(1);
+}
+
+console.log("[scheduling] " + message);
+`;
+}
+function makeRecipeSmokeTest() {
+    return `import test from "node:test";
+import assert from "node:assert/strict";
+import { access } from "node:fs/promises";
+
+test("recipe scaffold files exist", async () => {
+  await access("src/recipe.yaml");
+  await access("package.json");
+  assert.ok(true);
+});
+`;
+}
+export async function scaffoldProject(targetDirArg, options = {}) {
+    const targetDir = path.resolve(targetDirArg?.trim() ? targetDirArg : process.cwd());
+    await ensureDirectoryEmpty(targetDir);
+    const defaultName = path.basename(targetDir);
+    const rawProjectName = options.projectName?.trim() || defaultName;
+    const projectName = normalizeProjectName(rawProjectName);
+    const srcDir = path.join(targetDir, "src");
+    const assetsDir = path.join(srcDir, `${projectName}-assets`);
+    const assetsScriptsDir = path.join(assetsDir, "scripts");
+    const testDir = path.join(targetDir, "test");
+    await mkdir(srcDir, { recursive: true });
+    await mkdir(assetsDir, { recursive: true });
+    await mkdir(assetsScriptsDir, { recursive: true });
+    await mkdir(testDir, { recursive: true });
+    await writeFile(path.join(targetDir, "package.json"), makePackageJson(projectName), "utf8");
+    await writeFile(path.join(srcDir, "recipe.yaml"), makeRecipeYaml(projectName), "utf8");
+    await writeFile(path.join(assetsDir, "AGENTS.md"), makeAgentsDoc(projectName), "utf8");
+    await writeFile(path.join(assetsDir, "IDENTITY.md"), makeIdentityDoc(projectName), "utf8");
+    await writeFile(path.join(assetsDir, "SOUL.md"), makeSoulDoc(), "utf8");
+    await writeFile(path.join(assetsDir, "TOOLS.md"), makeToolsDoc(), "utf8");
+    await writeFile(path.join(assetsScriptsDir, "scheduling.mjs"), makeSchedulingScript(), "utf8");
+    await writeFile(path.join(testDir, "recipe-smoke.test.mjs"), makeRecipeSmokeTest(), "utf8");
+    return {
+        targetDir,
+        projectName,
+    };
+}