@standardagents/cli 0.11.12 → 0.12.0

package/dist/index.js

@@ -139,13 +139,25 @@ interface ThreadState {
 
 Access in tools:
 \`\`\`typescript
-export default defineTool('...', schema, async (flow, args) => {
-  const threadId = flow.threadId;
-  const { messages } = await flow.getMessages();
+export default defineTool('...', schema, async (state, args) => {
+  const threadId = state.threadId;
+  const { messages } = await state.getMessages();
   // ...
 });
 \`\`\`
 
+Access in hooks:
+\`\`\`typescript
+export default defineHook({
+  hook: 'before_create_message',
+  id: 'my_hook',
+  execute: async (state, message) => {
+    console.log(\`Thread: \${state.threadId}, Agent: \${state.agentId}\`);
+    return message;
+  }
+});
+\`\`\`
+
 ## Quick Reference
 
 | Function | Purpose | Directory |
@@ -180,7 +192,7 @@ Full documentation: https://docs.standardagentbuilder.com
 - [Agents](https://docs.standardagentbuilder.com/core-concepts/agents)
 - [Tools](https://docs.standardagentbuilder.com/core-concepts/tools)
 - [Hooks](https://docs.standardagentbuilder.com/core-concepts/hooks)
-- [FlowState](https://docs.standardagentbuilder.com/core-concepts/flowstate)
+- [ThreadState](https://docs.standardagentbuilder.com/core-concepts/threadstate)
 - [Thread API](https://docs.standardagentbuilder.com/core-concepts/api)
 `;
 
@@ -291,6 +303,7 @@ Prompts define system instructions, model selection, and available tools for LLM
 | \`parallelToolCalls\` | \`boolean\` | No | Allow multiple concurrent tool calls |
 | \`toolChoice\` | \`'auto' \\| 'none' \\| 'required'\` | No | Tool calling strategy |
 | \`requiredSchema\` | \`z.ZodObject\` | No | Input validation when called as tool |
+| \`hooks\` | \`string[]\` | No | Hook IDs to run for this prompt (overrides agent hooks) |
 | \`reasoning\` | \`ReasoningConfig\` | No | Extended thinking configuration |
 
 ## Basic Example
@@ -389,6 +402,22 @@ reasoning: {
 },
 \`\`\`
 
+## Hooks
+
+Attach lifecycle hooks to a prompt:
+
+\`\`\`typescript
+export default definePrompt({
+  name: 'customer_support',
+  toolDescription: 'Handle customer support',
+  model: 'default',
+  prompt: 'You are a support agent...',
+  hooks: ['limit_to_20', 'redact_pii'],  // Hook IDs from agents/hooks/
+});
+\`\`\`
+
+Prompt hooks take precedence over agent hooks. See \`agents/hooks/CLAUDE.md\` for details.
+
 ## Best Practices
 
 - **Write clear instructions** - Structure with headers and bullet points
@@ -418,6 +447,7 @@ Agents orchestrate conversations by defining prompts, stop conditions, and turn
 | \`maxSessionTurns\` | \`number\` | No | Max total turns across both sides |
 | \`exposeAsTool\` | \`boolean\` | No | Allow other prompts to hand off to this agent |
 | \`toolDescription\` | \`string\` | No | Description when used as tool (required if exposeAsTool) |
+| \`hooks\` | \`string[]\` | No | Hook IDs to run for this agent (fallback if prompt has no hooks) |
 | \`tags\` | \`string[]\` | No | Tags for categorization and filtering |
 
 ## Side Configuration
@@ -500,6 +530,23 @@ Other prompts can then include the agent name in their \`tools\` array to enable
 4. **stopOnResponse** - Ends turn when LLM returns text
 5. **maxSessionTurns** - Ends conversation (hard limit: 250)
 
+## Hooks
+
+Attach lifecycle hooks at the agent level:
+
+\`\`\`typescript
+export default defineAgent({
+  name: 'support_agent',
+  type: 'ai_human',
+  hooks: ['log_all_messages', 'sanitize_results'],
+  sideA: {
+    prompt: 'customer_support',
+  },
+});
+\`\`\`
+
+Agent hooks run as a fallback when the active prompt has no hooks defined. Prompt hooks always take precedence. See \`agents/hooks/CLAUDE.md\` for details.
+
 ## Naming Convention
 
 Agent names **must** end with the \`_agent\` suffix (e.g., \`support_agent\`, \`research_agent\`).
@@ -748,31 +795,69 @@ Hooks intercept and modify agent execution at specific lifecycle points.
 
 | Hook | Signature | Purpose |
 |------|-----------|---------|
-| \`filter_messages\` | \`(state, rows) => Message[]\` | Filter raw message rows before LLM context |
-| \`prefilter_llm_history\` | \`(state, messages) => Message[]\` | Modify messages after filtering, before LLM |
-| \`before_create_message\` | \`(state, message) => Message\` | Modify message before database insert |
-| \`after_create_message\` | \`(state, message) => void\` | Run logic after message created |
-| \`before_update_message\` | \`(state, id, updates) => Updates\` | Modify updates before message update |
-| \`after_update_message\` | \`(state, message) => void\` | Run logic after message updated |
-| \`before_store_tool_result\` | \`(state, toolCall, result) => Result\` | Modify tool result before storage |
-| \`after_tool_call_success\` | \`(state, toolCall, result) => Result\` | Process successful tool execution |
-| \`after_tool_call_failure\` | \`(state, toolCall, result) => Result\` | Process failed tool execution |
+| \`filter_messages\` | \`(state: ThreadState, messages: Message[]) => Message[]\` | Filter raw messages before LLM context |
+| \`prefilter_llm_history\` | \`(state: ThreadState, messages: LLMMessage[]) => LLMMessage[]\` | Modify chat completion messages before LLM |
+| \`before_create_message\` | \`(state: ThreadState, message: Message) => Message\` | Modify message before database insert |
+| \`after_create_message\` | \`(state: ThreadState, message: Message) => void\` | Run logic after message created |
+| \`before_update_message\` | \`(state: ThreadState, id: string, updates: Record) => Record\` | Modify updates before message update |
+| \`after_update_message\` | \`(state: ThreadState, message: Message) => void\` | Run logic after message updated |
+| \`before_store_tool_result\` | \`(state: ThreadState, toolCall: HookToolCall, result: HookToolResult) => HookToolResult\` | Modify tool result before storage |
+| \`after_tool_call_success\` | \`(state: ThreadState, toolCall: HookToolCall, result: HookToolResult) => HookToolResult \\| null\` | Process successful tool execution |
+| \`after_tool_call_failure\` | \`(state: ThreadState, toolCall: HookToolCall, result: HookToolResult) => HookToolResult \\| null\` | Process failed tool execution |
+
+All hooks receive \`ThreadState\` as their first parameter, providing access to thread identity, message history, and resource loading.
+
+## Creating a Hook
+
+Each hook file exports a default \`defineHook\` call with three properties:
+
+\`\`\`typescript
+import { defineHook } from '@standardagents/builder';
+
+export default defineHook({
+  hook: 'filter_messages',       // Hook type
+  id: 'limit_recent_messages',   // Unique ID (snake_case)
+  execute: async (state, messages) => {
+    return messages.slice(-20);
+  }
+});
+\`\`\`
+
+## Hook Scoping
+
+Hooks are scoped to **prompts** or **agents** via their ID:
+
+\`\`\`typescript
+// In a prompt definition
+definePrompt({
+  name: 'customer_support',
+  hooks: ['limit_recent_messages', 'redact_pii'],
+  // ...
+});
+
+// In an agent definition
+defineAgent({
+  name: 'support_agent',
+  hooks: ['log_all_messages'],
+  // ...
+});
+\`\`\`
+
+- **Prompt hooks** take precedence over agent hooks
+- If a prompt defines hooks, only those run (agent hooks are skipped)
+- If no prompt hooks are defined, agent hooks run as fallback
+- Hooks are filtered by type at runtime
 
 ## File Naming
 
-Hook files **must** be named exactly as the hook type:
+Hook files can use **any name** \u2014 the hook type and ID are defined inside the file:
 
 \`\`\`
 agents/hooks/
-\u251C\u2500\u2500 filter_messages.ts
-\u251C\u2500\u2500 prefilter_llm_history.ts
-\u251C\u2500\u2500 before_create_message.ts
-\u251C\u2500\u2500 after_create_message.ts
-\u251C\u2500\u2500 before_update_message.ts
-\u251C\u2500\u2500 after_update_message.ts
-\u251C\u2500\u2500 before_store_tool_result.ts
-\u251C\u2500\u2500 after_tool_call_success.ts
-\u2514\u2500\u2500 after_tool_call_failure.ts
+\u251C\u2500\u2500 my_filter.ts              # Could contain any hook type
+\u251C\u2500\u2500 redact_sensitive_data.ts
+\u251C\u2500\u2500 log_tool_usage.ts
+\u2514\u2500\u2500 add_metadata.ts
 \`\`\`
 
 ## Examples
@@ -782,23 +867,31 @@ agents/hooks/
 \`\`\`typescript
 import { defineHook } from '@standardagents/builder';
 
-export default defineHook('filter_messages', async (state, rows) => {
-  // Only include last 20 messages
-  return rows.slice(-20);
+export default defineHook({
+  hook: 'filter_messages',
+  id: 'limit_to_20',
+  execute: async (state, messages) => {
+    return messages.slice(-20);
+  }
 });
 \`\`\`
 
-### Prefilter LLM History (Modify Content)
+### Prefilter LLM History (Redact Content)
 
 \`\`\`typescript
 import { defineHook } from '@standardagents/builder';
 
-export default defineHook('prefilter_llm_history', async (state, messages) => {
-  // Remove sensitive data from message content
-  return messages.map(msg => ({
-    ...msg,
-    content: msg.content?.replace(/\\b\\d{4}-\\d{4}-\\d{4}-\\d{4}\\b/g, '[REDACTED]'),
-  }));
+export default defineHook({
+  hook: 'prefilter_llm_history',
+  id: 'redact_pii',
+  execute: async (state, messages) => {
+    return messages.map(msg => ({
+      ...msg,
+      content: typeof msg.content === 'string'
+        ? msg.content.replace(/\\b\\d{4}-\\d{4}-\\d{4}-\\d{4}\\b/g, '[REDACTED]')
+        : msg.content,
+    }));
+  }
 });
 \`\`\`
 
@@ -807,15 +900,34 @@ export default defineHook('prefilter_llm_history', async (state, messages) => {
 \`\`\`typescript
 import { defineHook } from '@standardagents/builder';
 
-export default defineHook('before_create_message', async (state, message) => {
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      createdAt: Date.now(),
-      agentVersion: '1.0.0',
-    },
-  };
+export default defineHook({
+  hook: 'before_create_message',
+  id: 'add_version_metadata',
+  execute: async (state, message) => {
+    if (message.role === 'user' && message.content) {
+      return { ...message, content: \`[v1.0] \${message.content}\` };
+    }
+    return message;
+  }
+});
+\`\`\`
+
+### Before Store Tool Result (Sanitize)
+
+\`\`\`typescript
+import { defineHook } from '@standardagents/builder';
+
+export default defineHook({
+  hook: 'before_store_tool_result',
+  id: 'sanitize_results',
+  execute: async (state, toolCall, toolResult) => {
+    // toolCall: { id, type: 'function', function: { name, arguments } }
+    // toolResult: { status, result?, error?, stack?, attachments? }
+    if (toolResult.result) {
+      return { ...toolResult, result: toolResult.result.replace(/secret/gi, '[REDACTED]') };
+    }
+    return toolResult;
+  }
 });
 \`\`\`
 
@@ -824,9 +936,13 @@ export default defineHook('before_create_message', async (state, message) => {
 \`\`\`typescript
 import { defineHook } from '@standardagents/builder';
 
-export default defineHook('after_tool_call_success', async (state, toolCall, result) => {
-  console.log(\`Tool \${toolCall.function.name} succeeded:\`, result);
-  return result;  // Return result unchanged, or modify it
+export default defineHook({
+  hook: 'after_tool_call_success',
+  id: 'log_tool_success',
+  execute: async (state, toolCall, result) => {
+    console.log(\`Tool \${toolCall.function.name} succeeded\`);
+    return null;  // Return null to use original result
+  }
 });
 \`\`\`
 
@@ -835,15 +951,18 @@ export default defineHook('after_tool_call_success', async (state, toolCall, res
 \`\`\`typescript
 import { defineHook } from '@standardagents/builder';
 
-export default defineHook('after_tool_call_failure', async (state, toolCall, result) => {
-  // Override error with fallback result
-  if (toolCall.function.name === 'fetch_weather') {
-    return {
-      status: 'success',
-      result: JSON.stringify({ temp: 'unavailable', fallback: true }),
-    };
+export default defineHook({
+  hook: 'after_tool_call_failure',
+  id: 'weather_fallback',
+  execute: async (state, toolCall, result) => {
+    if (toolCall.function.name === 'fetch_weather') {
+      return {
+        status: 'success',
+        result: JSON.stringify({ temp: 'unavailable', fallback: true }),
+      };
+    }
+    return null;  // Use original error for other tools
   }
-  return result;  // Return original error
 });
 \`\`\`
 
@@ -855,8 +974,8 @@ export default defineHook('after_tool_call_failure', async (state, toolCall, res
 - \`before_create_message\`
 - \`before_update_message\`
 - \`before_store_tool_result\`
-- \`after_tool_call_success\`
-- \`after_tool_call_failure\`
+- \`after_tool_call_success\` (return modified result or null)
+- \`after_tool_call_failure\` (return modified result or null)
 
 **Event hooks** (side effects only):
 - \`after_create_message\`
@@ -865,8 +984,9 @@ export default defineHook('after_tool_call_failure', async (state, toolCall, res
 ## Best Practices
 
 - **Keep hooks fast** - target <100ms execution
-- **Wrap in try-catch** - hooks continue on error
-- **Validate input data** before processing
+- **Wrap in try-catch** - hooks continue on error (original data preserved)
+- **Use unique IDs** - hook IDs must be snake_case and unique across the project
+- **Scope appropriately** - assign hooks to prompts or agents that need them
 - **Document purpose** with clear comments
 - **Use for cross-cutting concerns** - logging, redaction, enrichment
 
@@ -1582,7 +1702,7 @@ function getPackageVersion() {
   if (process.env.STANDARDAGENTS_WORKSPACE === "1") {
     return "workspace:*";
   }
-  return "0.11.12";
+  return "0.12.0";
 }
 async function selectPackageManager(detected) {
   const options = ["npm", "pnpm", "yarn", "bun"];
@@ -2375,13 +2495,437 @@ out
   pageTsx = pageTsx.replace(/from '\.\.\/\.\.\/src\//g, "from '../src/");
   fs3.writeFileSync(path3.join(projectPath, "app", "page.tsx"), pageTsx, "utf-8");
 }
+async function selectAgent(agents) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = 0;
+    const renderOptions = () => {
+      stdout.write("\x1B[?25l");
+      stdout.write(`\x1B[${agents.length + 1}A`);
+      stdout.write("\x1B[0J");
+      stdout.write("Select an agent to pack (use arrows, enter to confirm):\n");
+      agents.forEach((agent, i) => {
+        const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+        stdout.write(`${prefix} ${highlight}${agent}\x1B[0m
+`);
+      });
+    };
+    stdout.write("Select an agent to pack (use arrows, enter to confirm):\n");
+    agents.forEach((agent, i) => {
+      const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+      stdout.write(`${prefix} ${highlight}${agent}\x1B[0m
+`);
+    });
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + agents.length) % agents.length;
+        renderOptions();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % agents.length;
+        renderOptions();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(agents[selectedIndex]);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function selectItemModes(items, _agentName) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = 0;
+    const getDisplayLines = () => {
+      const lines = [];
+      lines.push("");
+      lines.push("Remove originals? (space to toggle, enter to confirm)");
+      lines.push("");
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const isSelected = i === selectedIndex;
+        const cursor = isSelected ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const modeText = item.mode === "extract" ? "\x1B[32m(extract)\x1B[0m" : "\x1B[90m(copy)\x1B[0m";
+        lines.push(`${cursor} ${item.name} \x1B[90m(${item.type})\x1B[0m ${modeText}`);
+      }
+      lines.push("");
+      return lines;
+    };
+    const render = (initial = false) => {
+      const lines = getDisplayLines();
+      if (!initial) {
+        stdout.write("\x1B[?25l");
+        stdout.write(`\x1B[${lines.length}A`);
+        stdout.write("\x1B[0J");
+      }
+      stdout.write(lines.join("\n") + "\n");
+    };
+    render(true);
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + items.length) % items.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % items.length;
+        render();
+      } else if (key === " ") {
+        items[selectedIndex].mode = items[selectedIndex].mode === "extract" ? "copy" : "extract";
+        render();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(items);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function isStandardAgentsProject() {
+  if (!fs3.existsSync("agents")) {
+    return false;
+  }
+  try {
+    const pkgJson = JSON.parse(fs3.readFileSync("package.json", "utf-8"));
+    const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    return "@standardagents/builder" in deps;
+  } catch {
+    return false;
+  }
+}
+async function pack(agentName, options) {
+  logger.info("Packing agent...\n");
+  if (!isStandardAgentsProject()) {
+    logger.error("This does not appear to be a Standard Agents project.");
+    logger.info("Make sure you have @standardagents/builder installed and an agents/ directory.");
+    process.exit(1);
+  }
+  const rootDir = process.cwd();
+  let PackingService;
+  try {
+    const packing = await import('@standardagents/builder/packing');
+    PackingService = packing.PackingService;
+  } catch (err) {
+    logger.error("Failed to load packing service from @standardagents/builder");
+    logger.info("Make sure @standardagents/builder is installed and built.");
+    if (err instanceof Error) {
+      logger.info(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+  const packingService = new PackingService();
+  if (!agentName) {
+    const agents = packingService.listAgents(rootDir);
+    if (agents.length === 0) {
+      logger.error("No agents found in agents/agents/");
+      process.exit(1);
+    }
+    if (agents.length === 1) {
+      agentName = agents[0];
+      logger.info(`Found one agent: ${agentName}`);
+    } else {
+      console.log("");
+      agentName = await selectAgent(agents);
+      console.log("");
+    }
+  }
+  if (!agentName) {
+    logger.error("No agent selected");
+    process.exit(1);
+  }
+  const selectedAgent = agentName;
+  logger.info(`Analyzing agent: ${selectedAgent}`);
+  const analysis = await packingService.analyzeAgent(selectedAgent, rootDir);
+  if (analysis.errors.length > 0) {
+    logger.error("Analysis failed:");
+    for (const error of analysis.errors) {
+      console.log(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+  console.log("");
+  logger.info("Discovered constituents:");
+  console.log(`  Agents:  ${analysis.constituents.agents.map((a) => a.name).join(", ") || "(none)"}`);
+  console.log(`  Prompts: ${analysis.constituents.prompts.map((p) => p.name).join(", ") || "(none)"}`);
+  console.log(`  Tools:   ${analysis.constituents.tools.map((t) => t.name).join(", ") || "(none)"}`);
+  console.log(`  Models:  ${analysis.constituents.models.map((m) => m.name).join(", ") || "(none)"}`);
+  console.log(`  Hooks:   ${analysis.constituents.hooks.map((h) => h.name).join(", ") || "(none)"}`);
+  if (analysis.warnings.length > 0) {
+    console.log("");
+    logger.warning("Warnings:");
+    for (const warning of analysis.warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+  const selectionItems = [];
+  for (const agent of analysis.constituents.agents) {
+    selectionItems.push({
+      name: agent.name,
+      type: "agent",
+      filePath: agent.filePath,
+      mode: agent.sharedWith.length > 0 ? "copy" : "extract",
+      isShared: agent.sharedWith.length > 0,
+      sharedWith: agent.sharedWith
+    });
+  }
+  for (const prompt3 of analysis.constituents.prompts) {
+    selectionItems.push({
+      name: prompt3.name,
+      type: "prompt",
+      filePath: prompt3.filePath,
+      mode: prompt3.sharedWith.length > 0 ? "copy" : "extract",
+      isShared: prompt3.sharedWith.length > 0,
+      sharedWith: prompt3.sharedWith
+    });
+  }
+  for (const tool of analysis.constituents.tools) {
+    selectionItems.push({
+      name: tool.name,
+      type: "tool",
+      filePath: tool.filePath,
+      mode: tool.sharedWith.length > 0 ? "copy" : "extract",
+      isShared: tool.sharedWith.length > 0,
+      sharedWith: tool.sharedWith
+    });
+  }
+  for (const model of analysis.constituents.models) {
+    selectionItems.push({
+      name: model.name,
+      type: "model",
+      filePath: model.filePath,
+      mode: model.sharedWith.length > 0 ? "copy" : "extract",
+      isShared: model.sharedWith.length > 0,
+      sharedWith: model.sharedWith
+    });
+  }
+  for (const hook of analysis.constituents.hooks) {
+    selectionItems.push({
+      name: hook.name,
+      type: "hook",
+      filePath: hook.filePath,
+      mode: hook.sharedWith.length > 0 ? "copy" : "extract",
+      isShared: hook.sharedWith.length > 0,
+      sharedWith: hook.sharedWith
+    });
+  }
+  let itemSelections;
+  if (!options.noInteractive && process.stdin.isTTY && selectionItems.length > 0) {
+    console.log("");
+    const selections = await selectItemModes(selectionItems);
+    itemSelections = selections.map((s) => ({
+      name: s.name,
+      type: s.type,
+      filePath: s.filePath,
+      mode: s.mode
+    }));
+    console.log("");
+  }
+  const outputDir = options.output || path3.join(rootDir, "agents", "packed");
+  logger.info(`Packing to: ${outputDir}`);
+  const result = await packingService.pack({
+    agentName: selectedAgent,
+    rootDir,
+    outputDir,
+    version: options.version || "1.0.0",
+    npm: options.npm || false,
+    removeOriginals: itemSelections ? false : !options.noRemove,
+    // Let itemSelections handle removal
+    packageId: `standardagent-${selectedAgent.replace(/_/g, "-")}`,
+    itemSelections
+  });
+  if (!result.success) {
+    logger.error(`Packing failed: ${result.error}`);
+    process.exit(1);
+  }
+  console.log("");
+  logger.success("Packing complete!");
+  console.log(`  Package ID: ${result.packageId}`);
+  console.log(`  Output:     ${result.outputPath}`);
+  console.log(`  Files:      ${result.filesCreated.length} created`);
+  if (result.filesRemoved && result.filesRemoved.length > 0) {
+    console.log(`  Removed:    ${result.filesRemoved.length} original files`);
+  }
+  if (result.warnings.length > 0) {
+    console.log("");
+    logger.warning("Warnings:");
+    for (const warning of result.warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+  if (options.npm) {
+    console.log("");
+    logger.info("NPM package structure created. To publish:");
+    console.log(`  cd ${result.outputPath}`);
+    console.log("  npm publish");
+  }
+}
+function isStandardAgentsProject2() {
+  if (!fs3.existsSync("agents")) {
+    return false;
+  }
+  try {
+    const pkgJson = JSON.parse(fs3.readFileSync("package.json", "utf-8"));
+    const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    return "@standardagents/builder" in deps;
+  } catch {
+    return false;
+  }
+}
+async function unpack(pkgIdentifier, options) {
+  logger.info("Unpacking agent...\n");
+  if (!isStandardAgentsProject2()) {
+    logger.error("This does not appear to be a Standard Agents project.");
+    logger.info("Make sure you have @standardagents/builder installed and an agents/ directory.");
+    process.exit(1);
+  }
+  const rootDir = process.cwd();
+  let UnpackingService;
+  try {
+    const builder = await import('@standardagents/builder/runtime');
+    UnpackingService = builder.UnpackingService;
+    if (!UnpackingService) {
+      const packing = await import('@standardagents/builder');
+      UnpackingService = packing.UnpackingService;
+    }
+  } catch (err) {
+    logger.error("Failed to load unpacking service from @standardagents/builder");
+    logger.info("Make sure @standardagents/builder is installed.");
+    process.exit(1);
+  }
+  const unpackingService = new UnpackingService();
+  if (!pkgIdentifier) {
+    const packages = await unpackingService.listPackages(rootDir);
+    if (packages.length === 0) {
+      logger.info("No packed agents found.");
+      logger.info("Pack an agent with: agents pack <agent-name>");
+      process.exit(0);
+    }
+    logger.info("Available packed agents:");
+    for (const pkg of packages) {
+      console.log(`  - ${pkg.packageId} (${pkg.version}) [${pkg.source}]`);
+      console.log(`    Entry: ${pkg.entryAgent}`);
+      console.log(`    Path:  ${pkg.path}`);
+      console.log("");
+    }
+    logger.info("Run: agents unpack <package-id>");
+    process.exit(0);
+  }
+  logger.info(`Unpacking: ${pkgIdentifier}`);
+  const result = await unpackingService.unpack({
+    package: pkgIdentifier,
+    rootDir,
+    keepSignatures: !options.noSignatures
+  });
+  if (!result.success) {
+    logger.error(`Unpacking failed: ${result.error}`);
+    process.exit(1);
+  }
+  console.log("");
+  logger.success("Unpacking complete!");
+  console.log(`  Package:    ${result.packageId}`);
+  console.log(`  Files:      ${result.filesCreated.length} created`);
+  if (result.filesCreated.length > 0) {
+    console.log("");
+    logger.info("Created files:");
+    for (const file of result.filesCreated) {
+      const relPath = path3.relative(rootDir, file);
+      console.log(`  - ${relPath}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log("");
+    logger.warning("Warnings:");
+    for (const warning of result.warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+  if (options.noSignatures) {
+    console.log("");
+    logger.info("Package signatures removed - files are fully editable.");
+  } else {
+    console.log("");
+    logger.info("Package signatures preserved - files are editable but marked as packed.");
+  }
+}
+async function listPacked() {
+  if (!isStandardAgentsProject2()) {
+    logger.error("This does not appear to be a Standard Agents project.");
+    logger.info("Make sure you have @standardagents/builder installed and an agents/ directory.");
+    process.exit(1);
+  }
+  const rootDir = process.cwd();
+  let UnpackingService;
+  try {
+    const builder = await import('@standardagents/builder/runtime');
+    UnpackingService = builder.UnpackingService;
+    if (!UnpackingService) {
+      const packing = await import('@standardagents/builder');
+      UnpackingService = packing.UnpackingService;
+    }
+  } catch (err) {
+    logger.error("Failed to load unpacking service from @standardagents/builder");
+    logger.info("Make sure @standardagents/builder is installed.");
+    process.exit(1);
+  }
+  const unpackingService = new UnpackingService();
+  const packages = await unpackingService.listPackages(rootDir);
+  if (packages.length === 0) {
+    logger.info("No packed agents found.");
+    logger.info("Pack an agent with: agents pack <agent-name>");
+    return;
+  }
+  logger.info("Discovered packed agents:\n");
+  for (const pkg of packages) {
+    console.log(`${pkg.packageId} (${pkg.version})`);
+    console.log(`  Source:  ${pkg.source}`);
+    console.log(`  Entry:   ${pkg.entryAgent}`);
+    console.log(`  Path:    ${pkg.path}`);
+    console.log("");
+  }
+}
 
 // src/index.ts
 var program = new Command();
-program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.11.12");
+program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.12.0");
 program.command("init [project-name]").description("Create a new Standard Agents project (runs create vite, then scaffold)").option("-y, --yes", "Skip prompts and use defaults").option("--template <template>", "Vite template to use", "vanilla-ts").action(init);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
 program.command("init-chat [project-name]").description("Scaffold a frontend chat application").option("-y, --yes", "Skip prompts and use defaults").option("--framework <framework>", "Framework to use (vite or nextjs)").action(initChat);
+program.command("pack [agent-name]").description("Pack an agent with all its dependencies").option("--output <dir>", "Output directory (default: agents/packed)").option("--npm", "Generate npm-ready package structure").option("--version <version>", "Package version (default: 1.0.0)").option("--no-remove", "Keep original files after packing").option("--no-interactive", "Skip interactive item mode selector").action(pack);
+program.command("unpack [package]").description("Unpack a packed agent to the local agents directory").option("--no-signatures", "Remove package signatures (fully editable)").action(unpack);
+program.command("list-packed").description("List all discovered packed agents").action(listPacked);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map