RCP-CWK-018 Cowork Recipe Loader

Fins Useful Recipes automatically

Discovers, loads, validates, and optionally executes CRAFT recipes from cookbook files in your workspace. It is the filesystem-native recipe runner for Cowork — the bridge between cookbook definitions and live recipe execution.

Cowork Recipe Loader

Cowork | Bridge (Core Extension) | Difficulty: Medium | Time: Under 1 min (browse), 1–3 min (load/execute)
Tags: Introduced in Beta, Recipe, Loader, Discovery, Validation, Execution, Bridge, Cowork

TL;DR

What It Does
Discovers, loads, validates, and optionally executes CRAFT recipes from cookbook files in your workspace. It is the filesystem-native recipe runner for Cowork — the bridge between cookbook definitions and live recipe execution.
How It Works
The recipe scans the workspace for cookbook files (CFT-FWK-COOKBK-*.txt), parses their recipe registries, and builds a catalog of available recipes. In browse mode it lists the catalog. In load mode it extracts the recipe body, runs a 3-check validation (format, dependencies, security), and presents the recipe for review. In execute mode it collects parameters, runs the recipe, and logs the result. Source options let you load from the workspace, git history, or the remote repository.
What To Expect
In browse mode you get a formatted table of all available recipes across all discovered cookbooks. In load mode you get a validation report confirming the recipe is safe to run. In execute mode the recipe runs with your provided parameters and the result is logged. If validation fails — missing format elements, unresolved dependencies, or suspicious security patterns — the recipe is blocked with a clear explanation.
Best Results When You
Start with browse mode to see what is available, then load a specific recipe to validate it, then execute. If you already know the recipe ID, jump straight to execute mode. Use the source parameter to load historical versions from git when you need to compare or roll back.
Typical Time
Under 1 minute for browse mode. 1–3 minutes for load or execute, depending on recipe complexity and parameter collection.
Difficulty
Medium — browse mode is simple, just listing available recipes. Load and execute modes require knowing or selecting a recipe ID and providing any required parameters. The validation pipeline is automatic and requires no user intervention.

How To Start

The recipe loader discovers cookbooks automatically. Choose a mode based on what you want to do.

STEP 1Choose the Operating Mode

Tell the AI what you want to do: browse available recipes, load and validate a specific one, or execute a recipe directly.
Available parameters
  • mode · string · required
    Operating mode. Options: “browse” (list available recipes from all cookbooks), “load” (parse and validate a specific recipe), “execute” (load + run with parameter collection).
  • recipe_id · string · optional
    Recipe ID to load or execute. Required for load and execute modes. Example: “RCP-CWK-005.”
  • source · string · optional · default: workspace
    Where to load the recipe from. Options: “workspace” (scan workspace folder), “git_history” (load from git commit history), “remote” (fetch from configured git remote).
  • filter · string · optional
    Category or keyword filter for browse mode. Narrows the recipe catalog to matching entries.
Invocations
Browse All Recipes
#H->AI::Directive: (Load CRAFT recipe with mode=browse)
Browse with Filter
#H->AI::Directive: (Load CRAFT recipe with mode=browse, filter=“Bridge”)
Load and Validate
#H->AI::Directive: (Load CRAFT recipe with mode=load, recipe_id=“RCP-CWK-005”)
Execute Recipe
#H->AI::Directive: (Load CRAFT recipe with mode=execute, recipe_id=“RCP-CWK-005”)
Load from Git History
#H->AI::Directive: (Load CRAFT recipe with mode=load, recipe_id=“RCP-CWK-005”, source=“git_history”)

Usage Examples

Three scenarios — browsing the recipe catalog, loading and validating a recipe, and executing a recipe with parameters.
Example 1 · Browse available recipes
User: What recipes do I have available?
AI: Scanning workspace for cookbook files. Found 3 cookbooks with 128 recipes. Here is the catalog: [formatted table of ID, Title, Version, Status, Cookbook]. Enter a recipe ID to load, or say “done.”
Example 2 · Load and validate a specific recipe
User: Load CWK-005 and tell me if it is safe to run.
AI: Loading recipe RCP-CWK-005 from workspace cookbook. Recipe acquired. Running pre-execution validation. Check 1/3: Format valid — PASS. Check 2/3: Dependencies resolved — PASS. Check 3/3: Security clear — PASS. All validation checks passed. Recipe: Git Checkpoint v2.00a, Category: Bridge, Status: Implemented. Execute now, review code, or done?
Example 3 · Execute a recipe directly
User: Run CWK-002 to write the session handoff.
AI: Loading recipe RCP-CWK-002. Validation passed. Collecting parameters: handoff_type is required — options are “standard” or “emergency.” Which type? [User: standard] Executing recipe: Cowork Session Handoff v2.00a. Recipe execution complete. Handoff written to project folder.

How AI Reads This Recipe

When this recipe is triggered, the AI discovers and manages CRAFT recipes through a 6-step pipeline. The AI should:
  1. DISCOVER COOKBOOKS by scanning the workspace for CFT-FWK-COOKBK-*.txt files. Parse each cookbook’s master index to extract recipe registries with IDs, titles, versions, categories, and statuses.
  2. ROUTE BY MODE: browse → Step 3A (catalog display), load → Step 3B (recipe acquisition), execute → Step 3B then Step 5 (acquisition + execution).
  3. BUILD CATALOG in browse mode. Compile all recipes from all discovered cookbooks into a formatted table. Apply the filter parameter if provided. Present the catalog and wait for the user to select a recipe or say “done.”
  4. ACQUIRE RECIPE in load/execute mode. Locate the recipe ID in the discovered cookbooks, extract the recipe body from the source (workspace file, git history, or remote), and confirm acquisition.
  5. VALIDATE before execution with 3 checks: CRAFT format compliance (recipe_id, title, description, parameters, prompt_template, CRAFT comment syntax), dependency resolution (all referenced recipes exist in discovered cookbooks), and security scan (8 suspicious patterns blocked). Any failure stops execution.
  6. EXECUTE the recipe: collect required parameters, log the execution start, run the prompt template with parameter values, log the result. If execution fails and CWK-014 (Error Interceptor) is available, route to it for analysis.
The recipe extends Core Single Recipe Runner with filesystem-native discovery, multi-cookbook scanning, and Cowork-adapted security checks. The 3-check validation pipeline (format, dependencies, security) prevents execution of malformed or unsafe recipes. Source flexibility (workspace, git_history, remote) enables version comparison and rollback. Execution logging integrates with COM (CWK-012) for operational tracking.

When to Use This Recipe

Use this recipe when you:
  • Want to see all available CRAFT recipes across your workspace cookbooks in a browsable catalog.
  • Need to load and validate a specific recipe before executing it, especially unfamiliar or newly added recipes.
  • Want to execute a recipe with full validation, parameter collection, and execution logging.
  • Need to load a historical version of a recipe from git for comparison or rollback.
Do not use this recipe when:
You already know a recipe well and are invoking it directly via its CRAFT directive syntax. The recipe loader adds validation overhead that is unnecessary for trusted, frequently used recipes. Use the loader for discovery, unfamiliar recipes, or when you want the security scan.

Recipe FAQ

Q.How does cookbook discovery work?

The recipe uses the Glob tool to find all files matching CFT-FWK-COOKBK-*.txt in the workspace folder. It then reads each file and parses the COOKBOOK_MASTER_INDEX section to extract recipe registries. Each registry entry provides the recipe ID, title, version, category, and status.

Q.What does the 3-check validation cover?

Three checks: (1) CRAFT format compliance — verifies recipe_id, title, description, parameters, prompt_template, and CRAFT comment syntax are present. (2) Dependency resolution — confirms all referenced recipes exist in the discovered cookbooks. (3) Security scan — checks for 8 suspicious patterns (rm -rf /, chmod 777, eval(), __import__, /etc/passwd, base64.decode, curl|sh, wget|bash) and blocks the recipe if any are found.

Q.What source options are available?

Three: “workspace” (default) reads from cookbook files in the workspace folder. “git_history” loads a specific version from git commit history — useful for comparing versions or rolling back. “remote” fetches from the configured git remote via git fetch + git show, useful when the local workspace is not up to date.

Q.What happens when validation fails?

Execution stops with a clear error. Format failures list the missing element (e.g., “Missing: prompt_template”). Dependency failures warn about unresolved references. Security failures identify the suspicious pattern and block the recipe. The user can fix the issue and retry.

Q.How does execute mode collect parameters?

After validation passes, the recipe inspects the loaded recipe’s parameter definitions. For each required parameter, it prompts the user with the parameter name, description, type, and available options. It validates the provided values against type constraints before execution.

Q.Does the loader integrate with other recipes?

Yes. Execution failures route to CWK-014 (Error Interceptor) if available. Execution logging integrates with COM (CWK-012) for operational tracking. The loader can load any recipe in any cookbook, including recipes from CORE, COWORK, and ADMIN catalogs.

Version History

Changes to this recipe over time. Most recent first.
v1.00a 2026-02-28
Initial release. Filesystem-native recipe loader for Cowork: 3 operating modes (browse, load, execute), multi-cookbook discovery via Glob scanning, recipe registry parsing, 3-check validation pipeline (format, dependencies, security), 3 source options (workspace, git_history, remote), parameter collection and type validation, execution logging with COM integration, Error Interceptor routing on failure.

Get this recipe with CRAFT for Claude Cowork

Cowork recipes ship bundled with CRAFT for Claude Cowork — there’s no separate download. Clone the framework once, and your AI runs every recipe automatically when invoked.

Pull anytime to stay on the latest version — free to clone, no login or email required.

Then start your session

Once CRAFT is in your project folder, open a new Cowork session and ask Claude to initialize. For example:

You

Please initialize my CRAFT session.

Claude

CRAFT session ready. Your project is loaded, your persona is active, and your recipes are available. What would you like to work on?

What is CRAFT for Claude Cowork?

Not familiar with Git? Download as a ZIP

No command line needed. Just download, move, and unzip:

  1. Open the CRAFT framework repo on GitHub.
  2. Click the green Code button, then choose Download ZIP.
  3. Move the downloaded ZIP into your Claude Cowork project folder.
  4. Unzip it: double-click on Mac, or right-click → Extract All on Windows.

Similar Posts