@clawcipes/recipes 0.1.3 → 0.1.5

package/README.md

@@ -4,6 +4,8 @@
   <img src="./clawcipes_cook.jpg" alt="Clawcipes logo" width="240" />
 </p>
 
+> **Experimental:** We’re in active development. Installing should not have any negative impacts, but it’s always good to be safe and copy your `~/.openclaw` folder to a backup.
+
 Clawcipes is an OpenClaw plugin that provides **CLI-first recipes** for scaffolding specialist agents and teams from Markdown.
 
 If you like durable workflows: Clawcipes is built around a **file-first team workspace** (inbox/backlog/in-progress/done) that plays nicely with git.
@@ -50,9 +52,10 @@ openclaw recipes dispatch \
 
 ## Commands (high level)
 - `openclaw recipes list|show|status`
-- `openclaw recipes scaffold` (agent)
-- `openclaw recipes scaffold-team` (team)
-- `openclaw recipes install <idOrSlug> [--yes]` (workspace-local skill install)
+- `openclaw recipes scaffold` (agent → `workspace-<agentId>`)
+- `openclaw recipes scaffold-team` (team → `workspace-<teamId>` + `roles/<role>/`)
+- `openclaw recipes install <idOrSlug> [--yes] [--global|--agent-id <id>|--team-id <id>]` (skills: global or scoped)
+- `openclaw recipes bind|bindings` (multi-agent routing)
 - `openclaw recipes dispatch ...` (request → inbox + ticket + assignment)
 
 For full details, see `docs/COMMANDS.md`.
@@ -83,7 +86,12 @@ Reference:
 
 (Also see: GitHub repo https://github.com/rjdjohnston/clawcipes)
 ## Notes / principles
-- Workspace-local skills live in `~/.openclaw/workspace/skills` by default.
+- Workspaces:
+  - Standalone agents: `~/.openclaw/workspace-<agentId>/`
+  - Teams: `~/.openclaw/workspace-<teamId>/` with `roles/<role>/...`
+- Skills:
+  - Global (shared): `~/.openclaw/skills/<skill>`
+  - Scoped (agent/team): `~/.openclaw/workspace-*/skills/<skill>`
 - Team IDs end with `-team`; agent IDs are namespaced: `<teamId>-<role>`.
 - Recipe template rendering is intentionally simple: `{{var}}` replacement only.
 
@@ -92,10 +100,9 @@ Clawcipes does not (yet) include a first-class `remove-team` command.
 
 To remove a scaffolded team created with `scaffold-team --apply-config`, do two things:
 
-1) Remove team + agent folders (recommended: send to trash):
+1) Remove the team workspace (recommended: send to trash):
 ```bash
-trash ~/.openclaw/workspace/teams/<teamId>
-trash ~/.openclaw/workspace/agents/<teamId>-*
+trash ~/.openclaw/workspace-<teamId>
 ```
 
 2) Remove the agents from OpenClaw config:

package/docs/AGENTS_AND_SKILLS.md

@@ -9,12 +9,13 @@ In OpenClaw, an **agent** is a configured assistant persona with:
 - a **tool policy** (what tools it is allowed to use)
 - a **model** configuration (defaults come from OpenClaw)
 
-In Clawcipes, an agent is typically created by scaffolding a folder like:
+In Clawcipes, a **standalone** agent recipe scaffolds a dedicated workspace like:
 
 ```
-~/.openclaw/workspace/agents/<agentId>/
+~/.openclaw/workspace-<agentId>/
   SOUL.md
   AGENTS.md
+  TOOLS.md
   ...other recipe files...
 ```
 
@@ -92,8 +93,14 @@ openclaw recipes install <skill-slug>
 openclaw recipes install <skill-slug> --yes
 ```
 
-This runs ClawHub under the hood and installs into:
-- `~/.openclaw/workspace/skills/<skill-slug>` (by default)
+This runs ClawHub under the hood and installs into the **current OpenClaw workspace** skills dir:
+- `<workspace>/skills/<skill-slug>`
+
+Examples:
+- standalone agent workspace: `~/.openclaw/workspace-<agentId>/skills/<skill-slug>`
+- team workspace: `~/.openclaw/workspace-<teamId>/skills/<skill-slug>`
+
+> Note: in the new workspace policy, standalone agents live in `~/.openclaw/workspace-<agentId>` and teams live in `~/.openclaw/workspace-<teamId>`. Skill install targeting is still being refined during the experimental phase.
 
 ### Install the skills required by a recipe
 If a recipe declares skills in `requiredSkills` or `optionalSkills`:
@@ -108,7 +115,7 @@ That installs the recipe’s declared skills.
 Clawcipes currently does **not** implement a remove command.
 
 To remove a workspace-local skill:
-- delete the folder: `~/.openclaw/workspace/skills/<skill-slug>`
+- delete the folder: `<workspace>/skills/<skill-slug>`
 - restart: `openclaw gateway restart`
 
 (We can add `openclaw recipes uninstall <slug>` later if you want it to be first-class.)
@@ -118,10 +125,9 @@ Clawcipes does not (yet) include a first-class `remove-team` command.
 
 If you scaffolded a team with `scaffold-team --apply-config`, removal has two parts:
 
-1) Remove the team + agent folders (recommended: send to trash):
+1) Remove the team workspace (recommended: send to trash):
 ```bash
-trash ~/.openclaw/workspace/teams/<teamId>
-trash ~/.openclaw/workspace/agents/<teamId>-*
+trash ~/.openclaw/workspace-<teamId>
 ```
 
 2) Remove the agents from OpenClaw config:
@@ -133,9 +139,26 @@ openclaw gateway restart
 ```
 
 ## Teams: shared workspace + multiple agents
-A **team** recipe scaffolds:
-- a shared team folder under `teams/<teamId>/...`
-- multiple agents under `agents/<teamId>-<role>/...`
+A **team** recipe scaffolds a **shared workspace root** plus role folders:
+
+```
+~/.openclaw/workspace-<teamId>/
+  TEAM.md
+  inbox/
+  outbox/
+  shared/
+  notes/
+  work/
+    backlog/
+    in-progress/
+    done/
+    assignments/
+  roles/
+    <role>/
+      ...role-specific recipe files...
+```
+
+Each role agent is a separate OpenClaw agent id (`<teamId>-<role>`), but they share the same workspace root (`workspace-<teamId>`) so collaboration is file-based.
 
 The shared workspace is the source of truth for:
 - intake (`inbox/`)
@@ -148,7 +171,8 @@ Once an agent exists, there are **two layers** you can update:
 
 ### 1) The agent’s files (workspace)
 Agents are just folders under:
-- `~/.openclaw/workspace/agents/<agentId>/`
+- standalone: `~/.openclaw/workspace-<agentId>/`
+- team roles: `~/.openclaw/workspace-<teamId>/roles/<role>/`
 
 Common files:
 - `SOUL.md` — the persona / operating style
@@ -165,7 +189,7 @@ If the agent was created from a recipe, re-running scaffold with `--overwrite` w
 openclaw recipes scaffold <recipeId> --agent-id <agentId> --overwrite
 ```
 
-For teams, you typically re-run `scaffold-team`:
+For teams, you typically re-run `scaffold-team` (role files live under `roles/<role>/`):
 
 ```bash
 openclaw recipes scaffold-team <recipeId> --team-id <teamId> --overwrite

package/docs/COMMANDS.md

@@ -45,11 +45,11 @@ Options:
 - `--apply-config` (write/update `agents.list[]` in OpenClaw config)
 
 ## `scaffold-team <recipeId>`
-Scaffold a team workspace + multiple agents from a **team** recipe.
+Scaffold a shared **team workspace** + multiple agents from a **team** recipe.
 
 ```bash
 openclaw recipes scaffold-team development-team \
-  --team-id development-team \
+  --team-id development-team-team \
   --overwrite \
   --apply-config
 ```
@@ -60,35 +60,86 @@ Options:
 - `--overwrite`
 - `--apply-config`
 
-Creates a team directory with standard subfolders:
-- `teams/<teamId>/{shared,inbox,outbox,notes,work}`
-- `teams/<teamId>/work/{backlog,in-progress,done,assignments}`
+Creates a shared team workspace root:
 
-Also creates agent workspaces under:
-- `agents/<teamId>-<role>/...`
+- `~/.openclaw/workspace-<teamId>/...`
+
+Standard folders:
+- `inbox/`, `outbox/`, `shared/`, `notes/`
+- `work/{backlog,in-progress,done,assignments}`
+- `roles/<role>/...` (role-specific recipe files)
+
+Also creates agent config entries under `agents.list[]` (when `--apply-config`), with agent ids:
+- `<teamId>-<role>`
 
 ## `install <idOrSlug> [--yes]`
-Install skills into the **workspace-local** skills directory.
+Install skills from ClawHub (confirmation-gated).
+
+Default behavior: **global install** into `~/.openclaw/skills`.
 
 ```bash
-openclaw recipes install local-places
-openclaw recipes install local-places --yes
+# Global (shared across all agents)
+openclaw recipes install agentchat --yes
+
+# Agent-scoped (into workspace-<agentId>/skills)
+openclaw recipes install agentchat --yes --agent-id dev
+
+# Team-scoped (into workspace-<teamId>/skills)
+openclaw recipes install agentchat --yes --team-id development-team-team
 ```
 
 Behavior:
 - If `idOrSlug` matches a recipe id, installs that recipe’s `requiredSkills` + `optionalSkills`.
 - Otherwise treats it as a ClawHub skill slug.
 - Installs via:
-  - `npx clawhub@latest --workdir <workspaceRoot> --dir skills install <slug>`
+  - `npx clawhub@latest --workdir <targetWorkspace> --dir skills install <slug>` (agent/team)
+  - `npx clawhub@latest --workdir ~/.openclaw --dir skills install <slug>` (global)
 - Confirmation-gated unless `--yes`.
 - In non-interactive mode (no TTY), requires `--yes`.
 
+## `bind`
+Add/update a multi-agent routing binding (writes `bindings[]` in `~/.openclaw/openclaw.json`).
+
+Examples:
+
+```bash
+# Route one Telegram DM to an agent
+openclaw recipes bind --agent-id dev --channel telegram --peer-kind dm --peer-id 6477250615
+
+# Route all Telegram traffic to an agent (broad match)
+openclaw recipes bind --agent-id dev --channel telegram
+```
+
+Notes:
+- `peer.kind` must be one of: `dm|group|channel`.
+- Peer-specific bindings are inserted first (more specific wins).
+
+## `bindings`
+Print the current `bindings[]` from OpenClaw config.
+
+```bash
+openclaw recipes bindings
+```
+
+## `migrate-team`
+Migrate a legacy team scaffold into the new `workspace-<teamId>` layout.
+
+```bash
+openclaw recipes migrate-team --team-id development-team-team --dry-run
+openclaw recipes migrate-team --team-id development-team-team --mode move
+```
+
+Options:
+- `--dry-run`
+- `--mode move|copy`
+- `--overwrite` (merge into existing destination)
+
 ## `dispatch`
 Convert a natural-language request into file-first execution artifacts.
 
 ```bash
 openclaw recipes dispatch \
-  --team-id development-team \
+  --team-id development-team-team \
   --request "Add a customer-support team recipe" \
   --owner lead
 ```

package/docs/INSTALLATION.md

@@ -73,4 +73,8 @@ openclaw gateway restart
 ### `recipes install` fails
 - Run `npx clawhub@latest --help` to confirm the CLI can run.
 - Ensure you are logged into ClawHub if required (`npx clawhub@latest login`).
-- Confirm installs go into the workspace-local skills dir (default `~/.openclaw/workspace/skills`).
+- Confirm the install scope you intended:
+  - global: `~/.openclaw/skills/<skill>`
+  - agent: `~/.openclaw/workspace-<agentId>/skills/<skill>`
+  - team: `~/.openclaw/workspace-<teamId>/skills/<skill>`
+- If you change installs or config, restart: `openclaw gateway restart`.

package/index.ts

@@ -144,10 +144,10 @@ function skillInstallCommands(cfg: Required<RecipesConfig>, skills: string[]) {
   return lines;
 }
 
-async function detectMissingSkills(api: OpenClawPluginApi, cfg: Required<RecipesConfig>, skills: string[]) {
+async function detectMissingSkills(installDir: string, skills: string[]) {
   const missing: string[] = [];
   for (const s of skills) {
-    const p = workspacePath(api, cfg.workspaceSkillsDir, s);
+    const p = path.join(installDir, s);
     if (!(await fileExists(p))) missing.push(s);
   }
   return missing;
@@ -180,6 +180,20 @@ type AgentConfigSnippet = {
   tools?: { profile?: string; allow?: string[]; deny?: string[] };
 };
 
+type BindingMatch = {
+  channel: string;
+  accountId?: string;
+  // OpenClaw config schema uses: dm | group | channel
+  peer?: { kind: "dm" | "group" | "channel"; id: string };
+  guildId?: string;
+  teamId?: string;
+};
+
+type BindingSnippet = {
+  agentId: string;
+  match: BindingMatch;
+};
+
 function upsertAgentInConfig(cfgObj: any, snippet: AgentConfigSnippet) {
   if (!cfgObj.agents) cfgObj.agents = {};
   if (!Array.isArray(cfgObj.agents.list)) cfgObj.agents.list = [];
@@ -242,6 +256,43 @@ function ensureMainFirstInAgentsList(cfgObj: any, api: OpenClawPluginApi) {
   list.unshift(main);
 }
 
+function stableStringify(x: any) {
+  const seen = new WeakSet();
+  const sortObj = (v: any): any => {
+    if (v && typeof v === "object") {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+      if (Array.isArray(v)) return v.map(sortObj);
+      const out: any = {};
+      for (const k of Object.keys(v).sort()) out[k] = sortObj(v[k]);
+      return out;
+    }
+    return v;
+  };
+  return JSON.stringify(sortObj(x));
+}
+
+function upsertBindingInConfig(cfgObj: any, binding: BindingSnippet) {
+  if (!Array.isArray(cfgObj.bindings)) cfgObj.bindings = [];
+  const list: any[] = cfgObj.bindings;
+
+  const sig = stableStringify({ agentId: binding.agentId, match: binding.match });
+  const idx = list.findIndex((b) => stableStringify({ agentId: b?.agentId, match: b?.match }) === sig);
+
+  if (idx >= 0) {
+    // Update in place (preserve ordering)
+    list[idx] = { ...list[idx], ...binding };
+    return { changed: false, note: "already-present" as const };
+  }
+
+  // Most-specific-first: if a peer match is specified, insert at front so it wins.
+  // Otherwise append.
+  if (binding.match?.peer) list.unshift(binding);
+  else list.push(binding);
+
+  return { changed: true, note: "added" as const };
+}
+
 async function applyAgentSnippetsToOpenClawConfig(api: OpenClawPluginApi, snippets: AgentConfigSnippet[]) {
   // Load the latest config from disk (not the snapshot in api.config).
   const current = (api.runtime as any).config?.loadConfig?.();
@@ -262,6 +313,20 @@ async function applyAgentSnippetsToOpenClawConfig(api: OpenClawPluginApi, snippe
   return { updatedAgents: snippets.map((s) => s.id) };
 }
 
+async function applyBindingSnippetsToOpenClawConfig(api: OpenClawPluginApi, snippets: BindingSnippet[]) {
+  const current = (api.runtime as any).config?.loadConfig?.();
+  if (!current) throw new Error("Failed to load config via api.runtime.config.loadConfig()");
+  const cfgObj = (current.cfg ?? current) as any;
+
+  const results: any[] = [];
+  for (const s of snippets) {
+    results.push({ ...s, result: upsertBindingInConfig(cfgObj, s) });
+  }
+
+  await (api.runtime as any).config?.writeConfigFile?.(cfgObj);
+  return { updatedBindings: results };
+}
+
 async function scaffoldAgentFromRecipe(
   api: OpenClawPluginApi,
   recipe: RecipeFrontmatter,
@@ -389,7 +454,10 @@ const recipesPlugin = {
               const { frontmatter } = parseFrontmatter(md);
               if (id && frontmatter.id !== id) continue;
               const req = frontmatter.requiredSkills ?? [];
-              const missing = await detectMissingSkills(api, cfg, req);
+              const workspaceRoot = api.config.agents?.defaults?.workspace;
+              if (!workspaceRoot) throw new Error("agents.defaults.workspace is not set in config");
+              const installDir = path.join(workspaceRoot, cfg.workspaceSkillsDir);
+              const missing = await detectMissingSkills(installDir, req);
               out.push({
                 id: frontmatter.id,
                 requiredSkills: req,
@@ -401,11 +469,204 @@ const recipesPlugin = {
             console.log(JSON.stringify(out, null, 2));
           });
 
+        cmd
+          .command("bind")
+          .description("Add/update a multi-agent routing binding (writes openclaw.json bindings[])")
+          .requiredOption("--agent-id <agentId>", "Target agent id")
+          .requiredOption("--channel <channel>", "Channel name (telegram|whatsapp|discord|slack|...) ")
+          .option("--account-id <accountId>", "Channel accountId (if applicable)")
+          .option("--peer-kind <kind>", "Peer kind (dm|group|channel) (aliases: direct->dm)")
+          .option("--peer-id <id>", "Peer id (DM number/id, group id, or channel id)")
+          .option("--guild-id <guildId>", "Discord guildId")
+          .option("--team-id <teamId>", "Slack teamId")
+          .option("--match <json>", "Full match object as JSON/JSON5 (overrides flags)")
+          .action(async (options: any) => {
+            const agentId = String(options.agentId);
+            let match: BindingMatch;
+
+            if (options.match) {
+              match = JSON5.parse(String(options.match)) as BindingMatch;
+            } else {
+              match = {
+                channel: String(options.channel),
+              };
+              if (options.accountId) match.accountId = String(options.accountId);
+              if (options.guildId) match.guildId = String(options.guildId);
+              if (options.teamId) match.teamId = String(options.teamId);
+
+              if (options.peerKind || options.peerId) {
+                if (!options.peerKind || !options.peerId) {
+                  throw new Error("--peer-kind and --peer-id must be provided together");
+                }
+                let kind = String(options.peerKind);
+                // Back-compat alias
+                if (kind === "direct") kind = "dm";
+                if (kind !== "dm" && kind !== "group" && kind !== "channel") {
+                  throw new Error("--peer-kind must be dm|group|channel (or direct as alias for dm)");
+                }
+                match.peer = { kind, id: String(options.peerId) };
+              }
+            }
+
+            if (!match?.channel) throw new Error("match.channel is required");
+
+            const res = await applyBindingSnippetsToOpenClawConfig(api, [{ agentId, match }]);
+            console.log(JSON.stringify(res, null, 2));
+            console.error("Binding written. Restart gateway if required for changes to take effect.");
+          });
+
+        cmd
+          .command("bindings")
+          .description("Show current bindings from openclaw config")
+          .action(async () => {
+            const current = (api.runtime as any).config?.loadConfig?.();
+            if (!current) throw new Error("Failed to load config via api.runtime.config.loadConfig()");
+            const cfgObj = (current.cfg ?? current) as any;
+            console.log(JSON.stringify(cfgObj.bindings ?? [], null, 2));
+          });
+
+        cmd
+          .command("migrate-team")
+          .description("Migrate a legacy team scaffold into the new workspace-<teamId> layout")
+          .requiredOption("--team-id <teamId>", "Team id (must end with -team)")
+          .option("--mode <mode>", "move|copy", "move")
+          .option("--dry-run", "Print the plan without writing anything", false)
+          .option("--overwrite", "Allow merging into an existing destination (dangerous)", false)
+          .action(async (options: any) => {
+            const teamId = String(options.teamId);
+            if (!teamId.endsWith("-team")) throw new Error("teamId must end with -team");
+
+            const mode = String(options.mode ?? "move");
+            if (mode !== "move" && mode !== "copy") throw new Error("--mode must be move|copy");
+
+            const baseWorkspace = api.config.agents?.defaults?.workspace;
+            if (!baseWorkspace) throw new Error("agents.defaults.workspace is not set in config");
+
+            const legacyTeamDir = path.resolve(baseWorkspace, "teams", teamId);
+            const legacyAgentsDir = path.resolve(baseWorkspace, "agents");
+
+            const destTeamDir = path.resolve(baseWorkspace, "..", `workspace-${teamId}`);
+            const destRolesDir = path.join(destTeamDir, "roles");
+
+            const exists = async (p: string) => fileExists(p);
+
+            // Build migration plan
+            const plan: any = {
+              teamId,
+              mode,
+              legacy: { teamDir: legacyTeamDir, agentsDir: legacyAgentsDir },
+              dest: { teamDir: destTeamDir, rolesDir: destRolesDir },
+              steps: [] as any[],
+              agentIds: [] as string[],
+            };
+
+            const legacyTeamExists = await exists(legacyTeamDir);
+            if (!legacyTeamExists) {
+              throw new Error(`Legacy team directory not found: ${legacyTeamDir}`);
+            }
+
+            const destExists = await exists(destTeamDir);
+            if (destExists && !options.overwrite) {
+              throw new Error(`Destination already exists: ${destTeamDir} (re-run with --overwrite to merge)`);
+            }
+
+            // 1) Move/copy team shared workspace
+            plan.steps.push({ kind: "teamDir", from: legacyTeamDir, to: destTeamDir });
+
+            // 2) Move/copy each role agent directory into roles/<role>/
+            const legacyAgentsExist = await exists(legacyAgentsDir);
+            let legacyAgentFolders: string[] = [];
+            if (legacyAgentsExist) {
+              legacyAgentFolders = (await fs.readdir(legacyAgentsDir)).filter((x) => x.startsWith(`${teamId}-`));
+            }
+
+            for (const folder of legacyAgentFolders) {
+              const agentId = folder;
+              const role = folder.slice((teamId + "-").length);
+              const from = path.join(legacyAgentsDir, folder);
+              const to = path.join(destRolesDir, role);
+              plan.agentIds.push(agentId);
+              plan.steps.push({ kind: "roleDir", agentId, role, from, to });
+            }
+
+            const dryRun = !!options.dryRun;
+            if (dryRun) {
+              console.log(JSON.stringify({ ok: true, dryRun: true, plan }, null, 2));
+              return;
+            }
+
+            // Helpers
+            const copyDirRecursive = async (src: string, dst: string) => {
+              await ensureDir(dst);
+              const entries = await fs.readdir(src, { withFileTypes: true });
+              for (const ent of entries) {
+                const s = path.join(src, ent.name);
+                const d = path.join(dst, ent.name);
+                if (ent.isDirectory()) await copyDirRecursive(s, d);
+                else if (ent.isSymbolicLink()) {
+                  const link = await fs.readlink(s);
+                  await fs.symlink(link, d);
+                } else {
+                  await ensureDir(path.dirname(d));
+                  await fs.copyFile(s, d);
+                }
+              }
+            };
+
+            const removeDirRecursive = async (p: string) => {
+              // node 25 supports fs.rm
+              await fs.rm(p, { recursive: true, force: true });
+            };
+
+            const moveDir = async (src: string, dst: string) => {
+              await ensureDir(path.dirname(dst));
+              try {
+                await fs.rename(src, dst);
+              } catch {
+                // cross-device or existing: fallback to copy+remove
+                await copyDirRecursive(src, dst);
+                await removeDirRecursive(src);
+              }
+            };
+
+            // Execute plan
+            if (mode === "copy") {
+              await copyDirRecursive(legacyTeamDir, destTeamDir);
+            } else {
+              await moveDir(legacyTeamDir, destTeamDir);
+            }
+
+            // Ensure roles dir exists
+            await ensureDir(destRolesDir);
+
+            for (const step of plan.steps.filter((s: any) => s.kind === "roleDir")) {
+              if (!(await exists(step.from))) continue;
+              if (mode === "copy") await copyDirRecursive(step.from, step.to);
+              else await moveDir(step.from, step.to);
+            }
+
+            // Update config: set each team agent's workspace to destTeamDir (shared)
+            const agentSnippets: AgentConfigSnippet[] = plan.agentIds.map((agentId: string) => ({
+              id: agentId,
+              workspace: destTeamDir,
+            }));
+            if (agentSnippets.length) {
+              await applyAgentSnippetsToOpenClawConfig(api, agentSnippets);
+            }
+
+            console.log(JSON.stringify({ ok: true, migrated: teamId, destTeamDir, agentIds: plan.agentIds }, null, 2));
+          });
+
         cmd
           .command("install")
-          .description("Install a ClawHub skill into this OpenClaw workspace (confirmation-gated)")
+          .description(
+            "Install a skill from ClawHub (confirmation-gated). Default: global (~/.openclaw/skills). Use --agent-id or --team-id for scoped installs.",
+          )
           .argument("<idOrSlug>", "Recipe id OR ClawHub skill slug")
           .option("--yes", "Skip confirmation prompt")
+          .option("--global", "Install into global shared skills (~/.openclaw/skills) (default when no scope flags)")
+          .option("--agent-id <agentId>", "Install into a specific agent workspace (workspace-<agentId>)")
+          .option("--team-id <teamId>", "Install into a team workspace (workspace-<teamId>)")
           .action(async (idOrSlug: string, options: any) => {
             const cfg = getCfg(api);
 
@@ -420,10 +681,45 @@ const recipesPlugin = {
               recipe = null;
             }
 
-            const workspaceRoot = api.config.agents?.defaults?.workspace;
-            if (!workspaceRoot) throw new Error("agents.defaults.workspace is not set in config");
+            const baseWorkspace = api.config.agents?.defaults?.workspace;
+            if (!baseWorkspace) throw new Error("agents.defaults.workspace is not set in config");
 
-            const installDir = path.join(workspaceRoot, cfg.workspaceSkillsDir);
+            const stateDir = path.resolve(baseWorkspace, ".."); // ~/.openclaw
+
+            const scopeFlags = [options.global ? "global" : null, options.agentId ? "agent" : null, options.teamId ? "team" : null].filter(Boolean);
+            if (scopeFlags.length > 1) {
+              throw new Error("Use only one of: --global, --agent-id, --team-id");
+            }
+
+            const agentIdOpt = typeof options.agentId === "string" ? options.agentId.trim() : "";
+            const teamIdOpt = typeof options.teamId === "string" ? options.teamId.trim() : "";
+
+            // Default is global install when no scope is provided.
+            const scope = scopeFlags[0] ?? "global";
+
+            let workdir: string;
+            let dirName: string;
+            let installDir: string;
+
+            if (scope === "agent") {
+              if (!agentIdOpt) throw new Error("--agent-id cannot be empty");
+              const agentWorkspace = path.resolve(stateDir, `workspace-${agentIdOpt}`);
+              workdir = agentWorkspace;
+              dirName = cfg.workspaceSkillsDir;
+              installDir = path.join(agentWorkspace, dirName);
+            } else if (scope === "team") {
+              if (!teamIdOpt) throw new Error("--team-id cannot be empty");
+              const teamWorkspace = path.resolve(stateDir, `workspace-${teamIdOpt}`);
+              workdir = teamWorkspace;
+              dirName = cfg.workspaceSkillsDir;
+              installDir = path.join(teamWorkspace, dirName);
+            } else {
+              workdir = stateDir;
+              dirName = "skills";
+              installDir = path.join(stateDir, dirName);
+            }
+
+            await ensureDir(installDir);
 
             const skillsToInstall = recipe
               ? Array.from(new Set([...(recipe.requiredSkills ?? []), ...(recipe.optionalSkills ?? [])])).filter(Boolean)
@@ -434,11 +730,11 @@ const recipesPlugin = {
               return;
             }
 
-            const missing = await detectMissingSkills(api, cfg, skillsToInstall);
+            const missing = await detectMissingSkills(installDir, skillsToInstall);
             const already = skillsToInstall.filter((s) => !missing.includes(s));
 
             if (already.length) {
-              console.error(`Already present in workspace skills dir (${installDir}): ${already.join(", ")}`);
+              console.error(`Already present in skills dir (${installDir}): ${already.join(", ")}`);
             }
 
             if (!missing.length) {
@@ -446,9 +742,10 @@ const recipesPlugin = {
               return;
             }
 
+            const targetLabel = scope === "agent" ? `agent:${agentIdOpt}` : scope === "team" ? `team:${teamIdOpt}` : "global";
             const header = recipe
-              ? `Install skills for recipe ${recipe.id} into ${installDir}?\n- ${missing.join("\n- ")}`
-              : `Install skill into ${installDir}?\n- ${missing.join("\n- ")}`;
+              ? `Install skills for recipe ${recipe.id} into ${installDir} (${targetLabel})?\n- ${missing.join("\n- ")}`
+              : `Install skill into ${installDir} (${targetLabel})?\n- ${missing.join("\n- ")}`;
 
             const requireConfirm = !options.yes;
             if (requireConfirm) {
@@ -474,12 +771,12 @@ const recipesPlugin = {
               console.error(header);
             }
 
-            // Use clawhub CLI. Force workspace-local install path.
+            // Use clawhub CLI. Force install path based on scope.
             const { spawnSync } = await import("node:child_process");
             for (const slug of missing) {
               const res = spawnSync(
                 "npx",
-                ["clawhub@latest", "--workdir", workspaceRoot, "--dir", cfg.workspaceSkillsDir, "install", slug],
+                ["clawhub@latest", "--workdir", workdir, "--dir", dirName, "install", slug],
                 { stdio: "inherit" },
               );
               if (res.status !== 0) {
@@ -659,7 +956,10 @@ const recipesPlugin = {
             }
 
             const cfg = getCfg(api);
-            const missing = await detectMissingSkills(api, cfg, recipe.requiredSkills ?? []);
+            const workspaceRoot = api.config.agents?.defaults?.workspace;
+            if (!workspaceRoot) throw new Error("agents.defaults.workspace is not set in config");
+            const installDir = path.join(workspaceRoot, cfg.workspaceSkillsDir);
+            const missing = await detectMissingSkills(installDir, recipe.requiredSkills ?? []);
             if (missing.length) {
               console.error(`Missing skills for recipe ${recipeId}: ${missing.join(", ")}`);
               console.error(`Install commands (workspace-local):\n${skillInstallCommands(cfg, missing).join("\n")}`);
@@ -709,7 +1009,10 @@ const recipesPlugin = {
             }
 
             const cfg = getCfg(api);
-            const missing = await detectMissingSkills(api, cfg, recipe.requiredSkills ?? []);
+            const baseWorkspace = api.config.agents?.defaults?.workspace;
+            if (!baseWorkspace) throw new Error("agents.defaults.workspace is not set in config");
+            const installDir = path.join(baseWorkspace, cfg.workspaceSkillsDir);
+            const missing = await detectMissingSkills(installDir, recipe.requiredSkills ?? []);
             if (missing.length) {
               console.error(`Missing skills for recipe ${recipeId}: ${missing.join(", ")}`);
               console.error(`Install commands (workspace-local):\n${skillInstallCommands(cfg, missing).join("\n")}`);
@@ -717,9 +1020,6 @@ const recipesPlugin = {
               return;
             }
 
-            const baseWorkspace = api.config.agents?.defaults?.workspace;
-            if (!baseWorkspace) throw new Error("agents.defaults.workspace is not set in config");
-
             // Team workspace root (shared by all role agents): ~/.openclaw/workspace-<teamId>
             const teamDir = path.resolve(baseWorkspace, "..", `workspace-${teamId}`);
             await ensureDir(teamDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawcipes/recipes",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Clawcipes recipes plugin for OpenClaw (markdown recipes -> scaffold agents/teams)",
   "main": "index.ts",
   "type": "commonjs",