RCP-CWK-016 Cowork Limitation Registry

Maintains a living registry of discovered Cowork platform limitations that persists across sessions via the project folder and git

Tracks what works, what does not, and known workarounds — enabling cumulative learning about platform boundaries.

Cowork Limitation Registry with File-Based Persistence

Cowork | Bridge (Core Extension) | Difficulty: Medium | Time: Under 1 min (auto), 2–5 min (manual)
Tags: Introduced in Beta, Limitation, Registry, Persistence, Workaround, Platform, Bridge, Cowork

TL;DR

What It Does
Maintains a living registry of discovered Cowork platform limitations that persists across sessions via the project folder and git. Tracks what works, what does not, and known workarounds — enabling cumulative learning about platform boundaries.
How It Works
The recipe extends Core Limitation Detection with Cowork-specific tracking, file-based persistence, and environment-aware detection. It maintains a built-in registry of known limitations organized by category: platform boundaries, tool constraints, CRAFT-specific issues, overridden Core limitations, and documented workarounds. In automatic mode, it scans requests for limitation triggers before execution. In manual modes, you can list, update, check specific capabilities, or export the full registry to a file.
What To Expect
In automatic mode (the default), the recipe runs silently in the background — you only see output when a limitation is detected. It reports the known limitation, any available workaround, and whether it is blocking. When a new limitation is discovered, it auto-adds the entry to the registry and suggests persisting via export.
Best Results When You
Let automatic mode run in the background. When you encounter a new platform behavior that blocks or limits a task, use update mode to add it to the registry with a workaround if known. Periodically export the registry to a file and commit it for cross-session persistence.
Typical Time
Under 1 minute in automatic mode. 2–5 minutes for manual operations like listing, updating, or exporting the registry.
Difficulty
Medium — automatic mode requires no interaction. Manual modes (list, update, check, export) require specifying the operation and providing details for new entries. Understanding limitation categories helps with organization.

How To Start

The limitation registry runs automatically by default, scanning requests for known limitations before execution. You can also use it in five manual modes.

STEP 1Choose the Operation Mode

Tell the AI what you want to do with the registry, or let automatic mode handle it.
Available parameters
  • request · string · optional
    Request to analyze for limitations. Used in automatic and check_specific modes.
  • mode · string · optional · default: automatic
    Operation mode. Options: “automatic” (scan for triggers), “list” (display registry), “update” (add/modify entry), “check_specific” (test capability), “export” (write to file).
  • category_filter · string · optional · default: all
    Filter limitations by category: “all,” “cowork_platform,” “git_operations,” “file_system,” “network,” “tool_specific,” “policy.”
Invocations
Automatic (Default — Background)
#H->AI::Directive: (Manage Cowork limitation registry)
List All Limitations
#H->AI::Directive: (Manage Cowork limitation registry with mode=list)
Check Specific Capability
#H->AI::Directive: (Manage Cowork limitation registry with mode=check_specific, request=“Can I push to GitHub?”)
Update Registry
#H->AI::Directive: (Manage Cowork limitation registry with mode=update)
Export to File
#H->AI::Directive: (Manage Cowork limitation registry with mode=export)

Usage Examples

Three scenarios — automatic detection of a known limitation, checking a specific capability, and discovering a new limitation.
Example 1 · Automatic mode detects git push limitation
User: Push all committed changes to the remote.
AI: Known Cowork limitation detected: Sandbox blocks outbound git push (SSH/HTTPS auth fails). Workaround: User manually pushes from host, or provide a PAT for token-per-session auth. Would you like to set up a PAT for this session?
Example 2 · Check specific capability
User: Can I run a long-running data analysis script?
AI: Capability check result. Capability: long-running script. Status: LIMITED. Details: Bash commands timeout after 120 seconds by default, with a maximum of 600 seconds using explicit timeout. Workaround: Break the script into stages under 120 seconds each, or use explicit timeout for up to 600 seconds. Source: Built-in registry, tool_constraints.
Example 3 · New limitation discovered and auto-registered
AI: New limitation discovered — cannot access /Users/Documents (outside mounted workspace folder). Adding to registry under platform_boundaries. No workaround available — requires user to mount the directory as workspace. Use mode=export to persist to file.

How AI Reads This Recipe

When this recipe is triggered, the AI manages a Cowork limitation registry through a 6-step mode-based pipeline. The AI should:
  1. DETERMINE MODE from the mode parameter. Route to the appropriate step: automatic → Step 2, list → Step 4, update → Step 5, check_specific → Step 3, export → Step 6.
  2. SCAN REQUEST for limitation triggers in automatic mode: git push/pull operations, external network access, cross-session persistence needs, host system access beyond workspace, long-running operations (>120s), interactive terminal operations, file operations outside workspace, multi-agent coordination. If a trigger matches a known registry entry, report the limitation and workaround. If it is a new limitation, auto-add it to the registry.
  3. CHECK SPECIFIC CAPABILITY in check_specific mode: look up the request in the built-in registry, check overridden Core limitations, attempt a safe probe if unknown, and report the result with status (AVAILABLE, LIMITED, BLOCKED, or UNKNOWN), details, workaround, and source.
  4. LIST REGISTRY in list mode: display all or filtered limitation entries with category, workaround, discovery session, and Lessons Learned cross-reference.
  5. UPDATE REGISTRY in update mode: add or modify a limitation entry. Auto-add mode skips the user prompt. Manual mode asks for the limitation details, validates format, and updates the registry.
  6. EXPORT REGISTRY in export mode: generate a formatted registry file, write it to the project folder, and recommend a git checkpoint.
The built-in registry includes five sections: platform boundaries (8 entries), tool constraints (6 entries), CRAFT-specific issues (5 entries), overridden Core limitations (5 entries showing what Cowork CAN do that Core cannot), and workarounds (5 documented solutions). Integrates with COM (CWK-012), Error Interceptor (CWK-014), Session Init (CWK-001), and Handoff (CWK-002). If a limitation test causes an error, that IS the limitation — capture and register it.

When to Use This Recipe

Use this recipe when you:
  • Want automatic pre-execution checks for known Cowork platform limitations before attempting an action.
  • Need to check whether a specific capability is available, limited, or blocked in the Cowork environment.
  • Have discovered a new platform limitation and want to document it with a workaround for future sessions.
  • Want a persistent, exportable record of all known limitations and their workarounds.
Do not use this recipe when:
You are working entirely within known, supported capabilities (file editing, Bash execution, web search) and no limitation triggers are present. Automatic mode handles this correctly — it stays silent when no triggers are detected. Do not manually run capability checks for well-established features.

Recipe FAQ

Q.What limitation categories does the registry track?

Six categories: cowork_platform (sandbox boundaries and session behavior), git_operations (push/pull/auth limitations), file_system (workspace scope and persistence), network (outbound access restrictions), tool_specific (Edit/Bash/WebFetch constraints), and policy (compliance and content restrictions).

Q.What is in the built-in registry?

Five sections with pre-loaded entries: platform boundaries (8 entries covering sandbox, auth, context, and workspace limits), tool constraints (6 entries covering Edit, Bash, WebSearch, and sub-agent limits), CRAFT-specific issues (5 entries covering infrastructure drift, docx editing, and handoff growth), overridden Core limitations (5 entries showing capabilities Cowork has that Core does not), and workarounds (5 documented solutions for the most common blockers).

Q.How does automatic mode work?

The recipe scans incoming requests for 8 trigger patterns: git push/pull, external network access, cross-session persistence, host access beyond workspace, long-running operations, interactive terminal, file operations outside workspace, and multi-agent coordination. If a trigger matches a known limitation, it reports the limitation and workaround. If the trigger reveals a new limitation, it auto-adds the entry.

Q.What are overridden Core limitations?

Core CRAFT (non-Cowork) has limitations like “cannot save files” and “cannot execute code.” Cowork overrides five of these: CAN save files (workspace + project folder), CAN execute code (Bash tool), CAN access user file system (mounted workspace), CAN access real-time data (WebSearch), CAN persist data (git commits). The registry tracks these to prevent false limitation reports.

Q.Which other recipes integrate with the limitation registry?

Four: COM (CWK-012) checks the registry before suggesting actions. Error Interceptor (CWK-014) auto-registers new limitations when errors occur. Session Init (CWK-001) loads registry context at session start. Handoff (CWK-002) includes the active limitation count in handoff notes.

Q.How do I persist the registry across sessions?

Use export mode to write the registry to a file in the project folder, then commit it via CWK-005. At the next session start, CWK-001 loads the exported file as registry context. The combination of file export and git versioning gives you full cross-session persistence with history.

Version History

Changes to this recipe over time. Most recent first.
v1.00a 2026-02-28
Initial release. Extends Core Limitation Detection with Cowork-specific tracking: file-based persistence, environment-aware detection, 5 operation modes (automatic, list, update, check_specific, export), built-in registry with 5 sections (29 entries), 6 limitation categories, capability status reporting (AVAILABLE/LIMITED/BLOCKED/UNKNOWN), integration with 4 recipes (COM, Error Interceptor, Session Init, Handoff), auto-registration of newly discovered limitations.

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