uctm 1.3.2 → 1.5.0

package/agents/shared-prompt-sections.md

@@ -28,7 +28,7 @@ elif [ -f "Cargo.toml" ]; then
 elif [ -f "go.mod" ]; then
   go build ./... 2>&1
 elif [ -f "pyproject.toml" ] || [ -f "setup.py" ]; then
-  python -m py_compile $(find . -name "*.py" -not -path "*/venv/*" | head -20) 2>&1
+  python -m py_compile $(find . -maxdepth 3 -name "*.py" -not -path "*/venv/*" 2>/dev/null) 2>&1
 elif [ -f "Makefile" ]; then
   make build 2>&1 || make 2>&1
 fi
@@ -68,22 +68,20 @@ works/{WORK_ID}/
 
 ## § 4. File System Discovery Scripts
 
-```bash
+```
 # Find latest WORK with incomplete TASKs
-for dir in $(ls -d works/WORK-* 2>/dev/null | sort -V -r); do
-  WORK_ID=$(basename $dir)
-  TOTAL=$(ls $dir/TASK-*.md 2>/dev/null | grep -v result | wc -l)
-  DONE=$(ls $dir/TASK-*_result.md 2>/dev/null | wc -l)
-  [ "$DONE" -lt "$TOTAL" ] && echo "$WORK_ID" && break
-done
+# Use Glob tool: pattern "works/WORK-*/" → list all WORK directories (sorted)
+# For each WORK (descending), compare:
+#   Glob "works/WORK-NN/TASK-*.md" (exclude *_result.md, *_progress.md) → TOTAL
+#   Glob "works/WORK-NN/TASK-*_result.md" → DONE
+# First WORK where DONE < TOTAL is the active WORK
 
 # List all WORKs
-ls -d works/WORK-* 2>/dev/null | sort -V
+# Use Glob tool: pattern "works/WORK-*/"
 
 # TASK completion status
-TOTAL=$(ls works/${WORK_ID}/TASK-*.md 2>/dev/null | grep -v result | wc -l)
-DONE=$(ls works/${WORK_ID}/TASK-*_result.md 2>/dev/null | wc -l)
-echo "$DONE / $TOTAL"
+# TOTAL = count of Glob "works/${WORK_ID}/TASK-??.md"
+# DONE  = count of Glob "works/${WORK_ID}/TASK-*_result.md"
 ```
 
 ---
@@ -164,28 +162,17 @@ Rules:
 
 ## § 10. Callback Transmission Template
 
+→ **Bash command rules: see § 13** — each step below is a separate tool call.
+
 Replace `{CallbackType}` with the actual key name (e.g., `ProgressCallback`, `TaskCallback`).
 
+**Step 1.** Use `Grep` tool to find `{CallbackType}:` line in CLAUDE.md. If not found, skip callback entirely.
+
+**Step 2.** Use `Grep` tool to find `CallbackToken:` line in CLAUDE.md (optional).
+
+**Step 3.** Send callback with a single `curl` command:
 ```bash
-CALLBACK_URL=$(grep "^{CallbackType}:" CLAUDE.md 2>/dev/null | sed 's/^{CallbackType}: //' | tr -d '\r')
-CALLBACK_TOKEN=$(grep "^CallbackToken:" CLAUDE.md 2>/dev/null | sed 's/^CallbackToken: //' | tr -d '\r')
-
-if [ -n "$CALLBACK_URL" ] && [ "$CALLBACK_URL" != "{CallbackType}:" ]; then
-  PAYLOAD=$(cat <<EOF
-{
-  "workId": "${WORK_ID}",
-  "taskId": "${TASK_ID}",
-  ... agent-specific fields ...
-}
-EOF
-  )
-  AUTH_HEADER=""
-  [ -n "$CALLBACK_TOKEN" ] && AUTH_HEADER="-H \"X-Runner-Api-Key: ${CALLBACK_TOKEN}\""
-  curl -s -X POST "$CALLBACK_URL" \
-    -H "Content-Type: application/json" \
-    $AUTH_HEADER \
-    -d "$PAYLOAD" > /dev/null 2>&1
-fi
+curl -s -X POST "CALLBACK_URL" -H "Content-Type: application/json" -H "X-Runner-Api-Key: TOKEN" -d '{"workId":"WORK-01","taskId":"TASK-00",...}'
 ```
 
 Agent-specific payload fields:
@@ -201,13 +188,13 @@ Agent-specific payload fields:
 grep -oP '(?<=Language:\s?)[a-z]{2}' CLAUDE.md 2>/dev/null
 
 # 2. Tech stack
-cat package.json 2>/dev/null | head -50
-cat pyproject.toml 2>/dev/null | head -30
-cat Cargo.toml 2>/dev/null | head -20
-cat go.mod 2>/dev/null | head -10
+head -50 package.json 2>/dev/null
+head -30 pyproject.toml 2>/dev/null
+head -20 Cargo.toml 2>/dev/null
+head -10 go.mod 2>/dev/null
 
 # 3. Structure (when needed)
-find . -maxdepth 3 -type f \( -name "*.md" -o -name "*.json" -o -name "*.toml" \) | grep -v node_modules | head -30
+find . -maxdepth 3 -type f \( -name "*.md" -o -name "*.json" -o -name "*.toml" \) -not -path "*/node_modules/*" 2>/dev/null
 ```
 
 ---
@@ -223,7 +210,41 @@ On gate failure → return FAIL task-result immediately. Do not proceed to subse
 
 ---
 
+## § 13. Bash Command Rules
+
+Bash commands MUST follow these rules for permission compatibility.
+
+**MANDATORY:**
+- One simple command per Bash call — NO compound commands (`&&`, `||`, `;`, `|`)
+- NO `cd dir && command` — you are already in the project root
+- NO multi-line scripts — split into separate Bash calls
+- NO sub-shell expansions in arguments — e.g., `$(date ...)` inside `printf`
+- Use relative paths from project root (e.g., `works/WORK-01/`) — NO absolute paths
+- Use `git add file`, `git commit -m "msg"` — NO `git -C path` flag
+
+**For file operations, prefer dedicated tools over Bash:**
+- Read files → `Read` tool (NOT `cat`)
+- Write/append files → `Write` tool (NOT `echo >>` or `printf >>`)
+- Edit files → `Edit` tool (NOT `sed -i`)
+- Search files → `Grep` tool (NOT `grep`)
+- Find files → `Glob` tool (NOT `find`)
+
+**Activity log example:**
+```
+WRONG: printf '[%s]_%s\n' "$(date ...)" "INIT" >> work.log
+RIGHT: Use Write tool to append a line to the log file
+```
+
+**Git example:**
+```
+WRONG: cd /path/to/project && git add file && git commit -m "msg"
+RIGHT: git add file        (one call)
+       git commit -m "msg"  (next call)
+```
+
+---
+
 ## Version
 
 - Created: 2026-03-10
-- Updated: 2026-03-21
+- Updated: 2026-03-28

package/agents/specifier.md

@@ -34,12 +34,23 @@ You are the **Specifier** — the agent that transforms user requests into requi
 
 **Resolve REFERENCES_DIR**: Check your input for `REFERENCES_DIR=...` line. Use that absolute path. If not provided, default to `.claude/agents`.
 
-| File | Purpose |
-|------|---------|
-| `{REFERENCES_DIR}/file-content-schema.md` | File format schema (PLAN.md, TASK, Requirement.md formats) |
-| `{REFERENCES_DIR}/shared-prompt-sections.md` | Common rules (TASK ID patterns, WORK-LIST rules, log_work function) |
-| `{REFERENCES_DIR}/xml-schema.md` | XML communication format (dispatch / task-result structure) |
-| `{REFERENCES_DIR}/work-activity-log.md` | Activity Log rules (log_work function, STAGE table) |
+#### Reference Loading (ref-cache)
+
+1. Check if `<ref-cache>` exists in the received dispatch XML
+2. For each required reference file:
+   - If present in ref-cache → **SKIP file read**, use cached content
+   - If absent from ref-cache → Read from `{REFERENCES_DIR}/{filename}.md` and add to ref-cache
+3. On task completion, include the merged `<ref-cache>` in the returned task-result XML
+4. **Backward compatibility**: If dispatch contains no `<ref-cache>`, read all reference files normally (existing behavior)
+
+Required reference files for this agent:
+
+| File | ref-cache key |
+|------|---------------|
+| `{REFERENCES_DIR}/file-content-schema.md` | `file-content-schema` |
+| `{REFERENCES_DIR}/shared-prompt-sections.md` | `shared-prompt-sections` |
+| `{REFERENCES_DIR}/xml-schema.md` | `xml-schema` |
+| `{REFERENCES_DIR}/work-activity-log.md` | `work-activity-log` |
 
 ### 3-2. WORK ID Determination
 
@@ -116,6 +127,7 @@ Requirement complexity assessment:
 ```
 
 → dispatch XML format: see `xml-schema.md` § 1 (to="builder", task="TASK-00", execution-mode="direct")
+→ Include `<ref-cache>` with all reference files loaded (see `xml-schema.md` § 6)
 
 ### 3-7. Planner Delegation — Complex Requirements (pipeline/full)
 
@@ -136,6 +148,7 @@ Requirement complexity assessment:
 ```
 
 → dispatch XML format: see `xml-schema.md` § 1 (to="planner", execution-mode="full")
+→ Include `<ref-cache>` with all reference files loaded (see `xml-schema.md` § 6)
 
 ### 3-8. Output Language Rule
 

package/agents/verifier.md

@@ -35,12 +35,23 @@ Verifies the results of TASKs completed by the Builder, checking build, lint, te
 
 **Resolve REFERENCES_DIR**: Check your input for `REFERENCES_DIR=...` line or `<references-dir>` XML element. Use that absolute path. If not provided, default to `.claude/agents`.
 
-| File | Purpose |
-|------|---------|
-| `{REFERENCES_DIR}/shared-prompt-sections.md` | Common rules |
-| `{REFERENCES_DIR}/xml-schema.md` | XML communication format |
-| `{REFERENCES_DIR}/context-policy.md` | Sliding Window rules |
-| `{REFERENCES_DIR}/work-activity-log.md` | Activity Log rules (log_work function, STAGE table) |
+#### Reference Loading (ref-cache)
+
+1. Check if `<ref-cache>` exists in the received dispatch XML
+2. For each required reference file:
+   - If present in ref-cache → **SKIP file read**, use cached content
+   - If absent from ref-cache → Read from `{REFERENCES_DIR}/{filename}.md` and add to ref-cache
+3. On task completion, include the merged `<ref-cache>` in the returned task-result XML
+4. **Backward compatibility**: If dispatch contains no `<ref-cache>`, read all reference files normally (existing behavior)
+
+Required reference files for this agent:
+
+| File | ref-cache key |
+|------|---------------|
+| `{REFERENCES_DIR}/shared-prompt-sections.md` | `shared-prompt-sections` |
+| `{REFERENCES_DIR}/xml-schema.md` | `xml-schema` |
+| `{REFERENCES_DIR}/context-policy.md` | `context-policy` |
+| `{REFERENCES_DIR}/work-activity-log.md` | `work-activity-log` |
 
 ### 3-2. XML Input Parsing
 
@@ -96,6 +107,7 @@ Only check conventions specified in CLAUDE.md or project config.
 
 → task-result XML base structure: see `xml-schema.md` § 2
 → context-handoff element: see `xml-schema.md` § 4
+→ ref-cache element: see `xml-schema.md` § 6
 
 Verifier-specific additional fields:
 
@@ -116,6 +128,12 @@ Verifier-specific additional fields:
     <suggested-fix>{suggestion}</suggested-fix>
   </failure>
 </failure-details>
+<ref-cache>
+  <!-- Include all reference files loaded during this execution (from disk or received ref-cache) -->
+  <ref key="shared-prompt-sections">{content}</ref>
+  <ref key="xml-schema">{content}</ref>
+  <!-- ... other keys loaded ... -->
+</ref-cache>
 ```
 
 ---

package/agents/work-activity-log.md

@@ -10,19 +10,21 @@ Defines the rules for each agent to record WORK progress in the `works/{WORK_ID}
 * During work: Work items and work content
 * On task completion: The prompt message sent to other agents** Content of the prompt message received at agent startup (Required)
 
-## log_work Function
-
-```bash
-AGENT_NAME="SPECIFIER"  # Set appropriately in each agent file
-
-log_work() {
-  local WORK_ID="$1" AGENT="$2" STAGE="$3" DESC="$4"
-  mkdir -p "works/${WORK_ID}"
-  printf '[%s]_%s_%s_%s\n' \
-    "$(date '+%Y-%m-%dT%H:%M:%S')" "$AGENT" "$STAGE" "$DESC" \
-    >> "works/${WORK_ID}/work_${WORK_ID}.log"
-}
+## log_work Method
+
+**Do NOT use Bash** for activity log writes. Use the `Write` tool (or `Edit` tool to append).
+
+Format each log entry as:
 ```
+[YYYY-MM-DDTHH:MM:SS]_AGENT_STAGE_description
+```
+
+Example: to log an INIT stage, use the **Write** tool to append to `works/{WORK_ID}/work_{WORK_ID}.log`:
+```
+[2026-03-28T14:30:00]_SPECIFIER_INIT_WORK-09 created — Execution-Mode: direct
+```
+
+→ **Bash command rules: see `shared-prompt-sections.md` § 13**
 
 ---
 

package/agents/xml-schema.md

@@ -8,6 +8,13 @@ XML communication format definition for uc-taskmanager agents.
 
 ```xml
 <dispatch to="{receiver}" work="{WORK_ID}" task="{TASK_ID}" execution-mode="{direct|pipeline|full}">
+  <ref-cache>                                        <!-- optional -->
+    <ref key="shared-prompt-sections">{file content}</ref>
+    <ref key="file-content-schema">{file content}</ref>
+    <ref key="xml-schema">{file content}</ref>
+    <ref key="context-policy">{file content}</ref>
+    <ref key="work-activity-log">{file content}</ref>
+  </ref-cache>
   <references-dir>{absolute path to references directory}</references-dir>
   <context>
     <project>{project name}</project>
@@ -47,6 +54,13 @@ XML communication format definition for uc-taskmanager agents.
     <check name="{type}" status="{PASS|FAIL|N/A}">{output}</check>
   </verification>
   <notes>{notes}</notes>
+  <ref-cache>                                        <!-- optional -->
+    <ref key="shared-prompt-sections">{file content}</ref>
+    <ref key="file-content-schema">{file content}</ref>
+    <ref key="xml-schema">{file content}</ref>
+    <ref key="context-policy">{file content}</ref>
+    <ref key="work-activity-log">{file content}</ref>
+  </ref-cache>
 </task-result>
 ```
 
@@ -107,3 +121,39 @@ Invariants (regardless of mode):
 | `TASK-XX_result.md` | Committer | Committer |
 | COMMITTER DONE callback | Committer | Committer |
 | `WORK-LIST.md` IN_PROGRESS | Specifier | Specifier |
+
+---
+
+## 6. ref-cache Element Definition
+
+`<ref-cache>` is an optional container element that carries pre-loaded reference file contents within dispatch and task-result XML. When present, receiving agents MUST use these contents instead of reading files from disk.
+
+### Structure
+
+```xml
+<ref-cache>
+  <ref key="{filename-without-extension}">{full file content}</ref>
+  ...
+</ref-cache>
+```
+
+| Element | Required | Description |
+|---------|----------|-------------|
+| `<ref-cache>` | Optional | Container for cached reference files. Omit entirely if no cache is available. |
+| `<ref key="...">` | — | Individual reference file. `key` is the filename without extension (e.g., `shared-prompt-sections`). |
+
+### Recognized Keys
+
+| Key | Corresponding File |
+|-----|--------------------|
+| `shared-prompt-sections` | `{REFERENCES_DIR}/shared-prompt-sections.md` |
+| `file-content-schema` | `{REFERENCES_DIR}/file-content-schema.md` |
+| `xml-schema` | `{REFERENCES_DIR}/xml-schema.md` |
+| `context-policy` | `{REFERENCES_DIR}/context-policy.md` |
+| `work-activity-log` | `{REFERENCES_DIR}/work-activity-log.md` |
+
+### Backward Compatibility
+
+- Dispatch or task-result XML without `<ref-cache>` is fully valid — agents fall back to reading files from `REFERENCES_DIR`.
+- Agents that do not yet support ref-cache simply ignore the element and read files normally.
+- Partial ref-cache (only some keys present) is allowed — missing keys are read from disk.

package/bin/cli.mjs

@@ -100,7 +100,7 @@ async function main() {
       lang = await promptLang();
     }
     const { init } = await import('../lib/init.mjs');
-    init(isGlobal, lang);
+    await init(isGlobal, lang);
     return;
   }
 

package/lib/constants.mjs

@@ -31,34 +31,63 @@ export function getAgentsSrcDir(lang) {
   return join(__dirname, '..', 'agents', lang);
 }
 
-export const CLAUDE_MD_SECTION_KO = `
-## Agent 호출 규칙
 
-\`[]\` 태그로 시작하는 요청 → \`.claude/agents/agent-flow.md\` 를 읽고 파이프라인을 실행한다.
+/**
+ * Bash permissions required by uc-taskmanager agents.
+ * Merged into .claude/settings.local.json during init.
+ *
+ * Categories:
+ *   - File discovery: ls, cat, basename, find, wc, sort, tail, head
+ *   - Pattern matching: grep, sed, cut, tr
+ *   - Formatting: printf, echo
+ *   - Build/Lint: node, npm, bun, yarn, cargo, go, python, ruff, make
+ *   - Git: git add, git commit, git log, git rev-parse
+ *   - Network: curl (callback)
+ */
+export const REQUIRED_PERMISSIONS = [
+  // File read/write tools (project-root scoped)
+  'Read(/**)',
+  'Edit(/**)',
+  'Write(/**)',
+  'Read(**)',
+  'Edit(**)',
+  'Write(**)',
 
-- **Main Claude가 오케스트레이터**다. 모든 에이전트 호출은 Main Claude가 직접 수행한다.
-- \`[]\` 태그 감지 시 → specifier 호출 (첫 번째 에이전트)
-- 각 에이전트는 작업 완료 후 결과(dispatch XML 또는 task-result XML)만 반환한다.
-- Main Claude가 반환값을 받아 다음 에이전트를 순서대로 호출한다.
-- 파이프라인 흐름은 \`.claude/agents/agent-flow.md\` 기준을 따른다.
+  // File discovery & text utilities
+  'Bash(ls:*)',
+  'Bash(cat:*)',
+  'Bash(mkdir:*)',
+  'Bash(basename:*)',
+  'Bash(find:*)',
+  'Bash(wc:*)',
+  'Bash(sort:*)',
+  'Bash(tail:*)',
+  'Bash(head:*)',
+  'Bash(echo:*)',
+  'Bash(printf:*)',
 
-예: \`[추가기능]\`, \`[버그수정]\`, \`[리팩토링]\`, \`[WORK 시작]\` 등
-`.trimStart();
+  // Pattern matching & text processing
+  'Bash(grep:*)',
+  'Bash(sed:*)',
+  'Bash(cut:*)',
+  'Bash(tr:*)',
 
-export const CLAUDE_MD_SECTION_EN = `
-## Agent Invocation Rules
+  // Build & Lint (auto-detect per project type)
+  'Bash(node:*)',
+  'Bash(npm run:*)',
+  'Bash(npm test:*)',
+  'Bash(bun run:*)',
+  'Bash(yarn:*)',
+  'Bash(cargo:*)',
+  'Bash(go build:*)',
+  'Bash(go test:*)',
+  'Bash(python:*)',
+  'Bash(ruff:*)',
+  'Bash(make:*)',
 
-Requests starting with a \`[]\` tag → read \`.claude/agents/agent-flow.md\` and execute the pipeline.
+  // Git operations (committer)
+  'Bash(git:*)',
 
-- **Main Claude is the orchestrator.** All agent invocations are performed directly by Main Claude.
-- On \`[]\` tag detection → invoke specifier (first agent)
-- Each agent only returns results (dispatch XML or task-result XML) after completing its work.
-- Main Claude receives return values and invokes the next agent in sequence.
-- Pipeline flow follows \`.claude/agents/agent-flow.md\`.
-
-Examples: \`[new-feature]\`, \`[bugfix]\`, \`[enhancement]\`, \`[new-work]\`, etc.
-`.trimStart();
-
-export function getClaudeMdSection(lang) {
-  return lang === 'ko' ? CLAUDE_MD_SECTION_KO : CLAUDE_MD_SECTION_EN;
-}
+  // Network (callback transmission)
+  'Bash(curl:*)',
+];

package/lib/init.mjs

@@ -1,13 +1,16 @@
-import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
-import { AGENT_FILES, getAgentsSrcDir, getClaudeMdSection } from './constants.mjs';
+import { AGENT_FILES, getAgentsSrcDir, REQUIRED_PERMISSIONS } from './constants.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+import { createInterface } from 'node:readline';
+
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 
 function copyAgents(destDir, lang) {
   const srcDir = getAgentsSrcDir(lang);
@@ -22,6 +25,41 @@ function copyAgents(destDir, lang) {
   return count;
 }
 
+function copyDirRecursive(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  let count = 0;
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      count += copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+      count++;
+    }
+  }
+  return count;
+}
+
+function copyPluginResources(destBaseDir) {
+  const pkgRoot = join(__dirname, '..');
+  let count = 0;
+
+  // .claude-plugin/
+  const pluginSrc = join(pkgRoot, '.claude-plugin');
+  if (existsSync(pluginSrc)) {
+    count += copyDirRecursive(pluginSrc, join(destBaseDir, '.claude-plugin'));
+  }
+
+  // skills/
+  const skillsSrc = join(pkgRoot, 'skills');
+  if (existsSync(skillsSrc)) {
+    count += copyDirRecursive(skillsSrc, join(destBaseDir, 'skills'));
+  }
+
+  return count;
+}
+
 function ensureRouterConfig(projectDir) {
   const configDir = join(projectDir, '.agent');
   const configPath = join(configDir, 'router_rule_config.json');
@@ -41,31 +79,68 @@ function ensureWorksDir(projectDir) {
   return true;
 }
 
-function updateClaudeMd(projectDir, lang) {
-  const section = getClaudeMdSection(lang);
-  const claudeMdPath = join(projectDir, 'CLAUDE.md');
-  if (existsSync(claudeMdPath)) {
-    const content = readFileSync(claudeMdPath, 'utf8');
-    if (content.includes('Agent 호출 규칙') || content.includes('Agent Invocation Rules') || content.includes('agent-flow.md')) {
-      return false;
+function mergePermissions(projectDir) {
+  const settingsPath = join(projectDir, '.claude', 'settings.local.json');
+  let settings = {};
+
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    } catch {
+      settings = {};
     }
-    writeFileSync(claudeMdPath, content.trimEnd() + '\n\n' + section);
-  } else {
-    writeFileSync(claudeMdPath, '# CLAUDE.md\n\n' + section);
   }
-  return true;
+
+  if (!settings.permissions) settings.permissions = {};
+  if (!Array.isArray(settings.permissions.allow)) settings.permissions.allow = [];
+
+  const existing = new Set(settings.permissions.allow);
+  let added = 0;
+
+  for (const perm of REQUIRED_PERMISSIONS) {
+    if (!existing.has(perm)) {
+      settings.permissions.allow.push(perm);
+      added++;
+    }
+  }
+
+  if (added > 0) {
+    const dir = dirname(settingsPath);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+
+  return { added, total: settings.permissions.allow.length };
 }
 
-export function init(isGlobal, lang) {
+async function promptPermissions() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    console.log(`\n  ${yellow('?')} Auto-configure Bash permissions for agents? (recommended)`);
+    console.log(`    ${dim('Adds required permissions to .claude/settings.local.json')}`);
+    rl.question('    [Y/n] ', (answer) => {
+      rl.close();
+      const choice = answer.trim().toLowerCase();
+      resolve(choice === '' || choice === 'y' || choice === 'yes');
+    });
+  });
+}
+
+export async function init(isGlobal, lang) {
   const exampleTag = lang === 'ko'
     ? `[추가기능] Add a hello world feature`
     : `[new-feature] Add a hello world feature`;
 
   if (isGlobal) {
-    const globalDir = join(homedir(), '.claude', 'agents');
+    const globalClaudeDir = join(homedir(), '.claude');
+    const globalDir = join(globalClaudeDir, 'agents');
     const count = copyAgents(globalDir, lang);
     console.log(`\n  Installing to ${dim('~/.claude/agents/')} (${lang}) ...`);
     console.log(`    ${green('✓')} ${count} agent files copied`);
+    const globalResCount = copyPluginResources(globalClaudeDir);
+    if (globalResCount > 0) {
+      console.log(`    ${green('✓')} ${globalResCount} plugin resource files copied`);
+    }
     console.log(`\n  ${dim('Next steps:')}`);
     console.log(`    1. Open any project and run ${dim("'claude'")}`);
     console.log(`    2. Type: ${dim(exampleTag)}\n`);
@@ -80,24 +155,36 @@ export function init(isGlobal, lang) {
   const count = copyAgents(destDir, lang);
   console.log(`    ${green('✓')} ${count} agent files copied`);
 
+  const claudeDir = join(projectDir, '.claude');
+  const resCount = copyPluginResources(claudeDir);
+  if (resCount > 0) {
+    console.log(`    ${green('✓')} ${resCount} plugin resource files copied (.claude-plugin, skills)`);
+  }
+
   if (ensureRouterConfig(projectDir)) {
     console.log(`    ${green('✓')} .agent/router_rule_config.json created`);
   } else {
     console.log(`    ${dim('-')} .agent/router_rule_config.json already exists`);
   }
 
-  if (updateClaudeMd(projectDir, lang)) {
-    console.log(`    ${green('✓')} CLAUDE.md updated`);
-  } else {
-    console.log(`    ${dim('-')} CLAUDE.md already has agent rules`);
-  }
-
   if (ensureWorksDir(projectDir)) {
     console.log(`    ${green('✓')} works/ directory created`);
   } else {
     console.log(`    ${dim('-')} works/ directory already exists`);
   }
 
+  const wantPermissions = await promptPermissions();
+  if (wantPermissions) {
+    const { added, total } = mergePermissions(projectDir);
+    if (added > 0) {
+      console.log(`    ${green('✓')} ${added} permissions added to .claude/settings.local.json (total: ${total})`);
+    } else {
+      console.log(`    ${dim('-')} All permissions already configured (${total})`);
+    }
+  } else {
+    console.log(`    ${dim('-')} Skipped permission setup`);
+  }
+
   console.log(`\n  ${dim('Next steps:')}`);
   console.log(`    1. Run ${dim("'claude'")} to start Claude Code`);
   console.log(`    2. Type: ${dim(exampleTag)}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uctm",
-  "version": "1.3.2",
+  "version": "1.5.0",
   "description": "Universal Claude Task Manager — SDD-based task pipeline subagent system for Claude Code CLI",
   "type": "module",
   "bin": {
@@ -10,7 +10,9 @@
     "bin/",
     "lib/",
     "agents/",
-    ".agent/"
+    ".agent/",
+    ".claude-plugin/",
+    "skills/"
   ],
   "engines": {
     "node": ">=18"