lathe-cli 1.1.0 → 1.2.0

package/README.md

@@ -28,17 +28,27 @@ mkdir myapp && cd myapp
 lathe init
 ```
 
-これで以下ができます：
+これで以下ができます（v1.2 layout）：
 
 ```
 myapp/
 ├── .git/        共有 bare repo
+├── .claude/     project-root helper（lathe-cli skill）
+├── CLAUDE.md    helper の役割記述
 ├── main/        main worktree（あなたの app code）
-├── develop/     develop worktree（target が住む、target/.claude/ が sync で生成）
-└── meta/        meta worktree（harness/ + meta agent + improvements/）
+├── develop/     develop worktree
+│   ├── harness/      tracked、target + meta 両方の agent spec の正
+│   │   ├── CLAUDE.md, settings.json, skills/, agents/, ...   target 用
+│   │   └── meta/                                              meta 用
+│   ├── bin/sync.sh   tracked（branch-aware、target or meta runtime に展開）
+│   ├── runs/         tracked（hook auto-commit）
+│   └── (CLAUDE.md, .claude/, hooks/, workflow/, plan_template.html — gitignored sync output)
+└── meta/        meta worktree
+    ├── harness/, bin/, runs/, improvements/   tracked（develop から inherit）
+    └── (CLAUDE.md, .claude/ — gitignored sync output、harness/meta/ から)
 ```
 
-3 つの worktree は同じ bare repo を共有しているので、git で内容を相互伝搬できます。
+`harness/` が agent spec の唯一の正。target と meta の両方の指示書が `harness/`（target は root、meta は `harness/meta/`）に集約されているので、harness/ さえあれば同じ harness で再現可能。runtime の `.claude/` `CLAUDE.md` は gitignored で sync.sh が生成。
 
 ## 日常コマンド
 
@@ -106,7 +116,7 @@ git push origin main
 ## 設計の要点
 
 - **branch / worktree でロール分離**：各 agent / role が物理的に別ディレクトリで動くので、CLAUDE.md / settings.json / hooks が混ざらない
-- **harness は meta が編集し、sync で target/.claude/ に展開**：Claude Code 本体の `.claude/` sensitive-file guard を agent tool で突破できないため、meta は harness/ を編集（普通の dir、guard なし）→ develop で sync.sh が外部 shell から target/.claude/ を上書き、という回路で迂回
+- **harness/ は agent spec の単一の正**：target も meta も自分の設定は `harness/`（meta 用は `harness/meta/`）から sync.sh で worktree root の runtime ファイルに展開される。Claude Code 本体の `.claude/` sensitive-file guard を agent tool で突破できないため、harness/ を編集（普通の dir、guard なし）→ shell sync.sh で `.claude/` 上書き、という迂回経路
 - **runs/ は develop で auto-commit**：target session の Stop hook が `git commit` するので、meta は `git merge develop` で読める。symlink や中央 store 不要
 - **post-merge hook が auto-sync**：meta の harness 改善が develop に merge された瞬間に target/.claude/ が再生成される
 

package/bin/lathe

@@ -30,9 +30,9 @@ shared bare git repo, then drive target / meta agents over Claude Code.
 
 Setup:
   init             Initialize Lathe in current (empty) directory.
-                   Creates ./.git (bare), three worktrees, post-merge
-                   hook, and (interactively) a project-root .claude/
-                   helper for Lathe operations.
+                   Creates ./.git (bare), three worktrees (main/develop/meta),
+                   post-merge hook (auto-syncs harness on develop or meta merges),
+                   and (interactively) a project-root .claude/ helper for Lathe ops.
 
 Daily ops:
   feature <name>   Create features/<name>/ worktree on a new
@@ -45,8 +45,8 @@ Daily ops:
   ls               List worktrees, branches, recent runs/improvements
 
 Agent launchers:
-  target [args]    cd develop/target, claude args
-  meta   [args]    cd meta/meta, claude args
+  target [args]    cd develop, claude args  (target's runtime sync'd from harness/)
+  meta   [args]    cd meta, claude args     (meta's runtime sync'd from harness/meta/)
   sync             Re-run sync.sh in develop (only if post-merge missed)
 
 Other:

package/bin/lathe-init

@@ -1,14 +1,20 @@
 #!/usr/bin/env bash
 # lathe init — initialize a Lathe project in the current directory.
 #
-# Layout produced (nested under cwd):
+# Layout produced (v1.2):
 #   ./
-#   ├── .git/        (bare repo, shared by all worktrees)
-#   ├── main/        (worktree on 'main' branch — your app code)
-#   ├── develop/     (worktree on 'develop' — target harness)
-#   └── meta/        (worktree on 'meta' — meta agent + improvements/)
+#   ├── .git/        bare repo, shared by all worktrees
+#   ├── .claude/     project-root helper config (if chosen)
+#   ├── CLAUDE.md    project-root helper brief (if chosen)
+#   ├── main/        worktree on 'main' branch — your app code
+#   ├── develop/     worktree on 'develop' — target agent's runtime
+#   └── meta/        worktree on 'meta' — meta agent's runtime
 #
-# Requirements: cwd should be empty. Existing repos are not auto-migrated.
+# develop tracks harness/ (incl. harness/meta/) as the canonical agent spec.
+# bin/sync.sh on each side regenerates the gitignored runtime files at the
+# worktree root (CLAUDE.md, .claude/, etc.) from harness/. meta inherits
+# develop's harness/, so meta's spec lives at harness/meta/ on the develop
+# branch (and propagates to meta via cut/merge).
 
 set -euo pipefail
 
@@ -18,40 +24,36 @@ PROJECT_ROOT="$(pwd)"
 PROJECT_NAME="$(basename "$PROJECT_ROOT")"
 
 # --- Validation ---
+err=0
 if [ -e "$PROJECT_ROOT/.git" ]; then
-  echo "lathe init: $PROJECT_ROOT/.git already exists. Aborting." >&2
-  exit 1
+  echo "lathe init: $PROJECT_ROOT/.git already exists." >&2; err=1
 fi
 for d in main develop meta; do
   if [ -e "$PROJECT_ROOT/$d" ]; then
-    echo "lathe init: $PROJECT_ROOT/$d already exists. Aborting." >&2
-    exit 1
+    echo "lathe init: $PROJECT_ROOT/$d already exists." >&2; err=1
   fi
 done
+[ "$err" = 1 ] && exit 1
 
-# Warn (not error) if cwd has any other content.
 EXTRA="$(ls -A "$PROJECT_ROOT" 2>/dev/null | grep -vE '^(\.|\.\.)$' || true)"
 if [ -n "$EXTRA" ]; then
-  echo "Note: $PROJECT_ROOT is not empty. Existing files will remain at the project root and won't be in any worktree."
-  echo "      (Lathe v1 doesn't auto-migrate existing repos. Move files into main/ manually if needed.)"
+  echo "Note: $PROJECT_ROOT is not empty. Existing files will remain at the project root."
 fi
 
 GIT_DIR="$PROJECT_ROOT/.git"
 
-echo "==> [1/5] Initializing bare repo at $GIT_DIR ..."
+echo "==> [1/6] Initializing bare repo at $GIT_DIR ..."
 git init --bare --quiet "$GIT_DIR"
 
-echo "==> [2/5] Creating main worktree with initial commit (template/main)..."
-git --git-dir="$GIT_DIR" worktree add --quiet -b main "$PROJECT_ROOT/main" 2>/dev/null || {
-  # Empty bare repo: branch creation needs an existing commit. Make one via plumbing.
-  EMPTY_TREE="$(git --git-dir="$GIT_DIR" mktree </dev/null)"
-  INIT_COMMIT="$(printf 'lathe: empty initial\n' | git --git-dir="$GIT_DIR" commit-tree "$EMPTY_TREE")"
-  git --git-dir="$GIT_DIR" update-ref refs/heads/main "$INIT_COMMIT"
-  git --git-dir="$GIT_DIR" symbolic-ref HEAD refs/heads/main
-  git --git-dir="$GIT_DIR" worktree add --quiet "$PROJECT_ROOT/main" main
-}
+echo "==> [2/6] Creating main worktree with initial commit (template/main)..."
+# Bootstrap an initial commit so develop/meta have a base.
+EMPTY_TREE="$(git --git-dir="$GIT_DIR" mktree </dev/null)"
+INIT_COMMIT="$(printf 'lathe: empty initial\n' | git --git-dir="$GIT_DIR" commit-tree "$EMPTY_TREE")"
+git --git-dir="$GIT_DIR" update-ref refs/heads/main "$INIT_COMMIT"
+git --git-dir="$GIT_DIR" symbolic-ref HEAD refs/heads/main
+git --git-dir="$GIT_DIR" worktree add --quiet "$PROJECT_ROOT/main" main
+
 cp -R "$LATHE_HOME/template/main/." "$PROJECT_ROOT/main/"
-# Replace placeholder in README
 if [ -f "$PROJECT_ROOT/main/README.md" ]; then
   sed -i.bak "s/{{project_name}}/$PROJECT_NAME/g" "$PROJECT_ROOT/main/README.md"
   rm -f "$PROJECT_ROOT/main/README.md.bak"
@@ -59,31 +61,33 @@ fi
 git -C "$PROJECT_ROOT/main" add -A
 git -C "$PROJECT_ROOT/main" \
   -c user.email="lathe@local" -c user.name="lathe" \
-  commit --quiet --allow-empty -m "lathe: init main"
+  commit --quiet -m "lathe: init main"
 
-echo "==> [3/5] Creating develop worktree from main (template/develop)..."
+echo "==> [3/6] Creating develop worktree from main (template/develop)..."
 git --git-dir="$GIT_DIR" worktree add --quiet -b develop "$PROJECT_ROOT/develop" main
 cp -R "$LATHE_HOME/template/develop/." "$PROJECT_ROOT/develop/"
+# Initial sync writes gitignored runtime files to the develop worktree root.
 "$PROJECT_ROOT/develop/bin/sync.sh"
-mkdir -p "$PROJECT_ROOT/develop/runs" "$PROJECT_ROOT/develop/target/plans"
-touch "$PROJECT_ROOT/develop/runs/.gitkeep" "$PROJECT_ROOT/develop/target/plans/.gitkeep"
+mkdir -p "$PROJECT_ROOT/develop/runs" "$PROJECT_ROOT/develop/plans"
+touch "$PROJECT_ROOT/develop/runs/.gitkeep" "$PROJECT_ROOT/develop/plans/.gitkeep"
 git -C "$PROJECT_ROOT/develop" add -A
 git -C "$PROJECT_ROOT/develop" \
   -c user.email="lathe@local" -c user.name="lathe" \
   commit --quiet -m "lathe: target harness on develop"
 
-echo "==> [4/5] Creating meta worktree from develop (template/meta-overlay)..."
+echo "==> [4/6] Creating meta worktree from develop..."
 git --git-dir="$GIT_DIR" worktree add --quiet -b meta "$PROJECT_ROOT/meta" develop
-cp -R "$LATHE_HOME/template/meta-overlay/." "$PROJECT_ROOT/meta/"
-git -C "$PROJECT_ROOT/meta" add -A
-git -C "$PROJECT_ROOT/meta" \
-  -c user.email="lathe@local" -c user.name="lathe" \
-  commit --quiet -m "lathe: meta agent on meta"
-
-echo "==> [5/6] Installing post-merge hook (auto-sync on develop merges)..."
-mkdir -p "$GIT_DIR/hooks"
-cp "$LATHE_HOME/template/git-hooks/post-merge" "$GIT_DIR/hooks/post-merge"
-chmod +x "$GIT_DIR/hooks/post-merge"
+# Run sync on the meta worktree so meta's runtime files (gitignored)
+# get written from harness/meta/.
+"$PROJECT_ROOT/meta/bin/sync.sh"
+# No commits needed on meta branch here — it inherits develop's tracked
+# content, and runtime files are gitignored.
+
+echo "==> [5/6] Installing post-merge hook (auto-sync on develop/meta merges)..."
+COMMON_HOOKS="$(git --git-dir="$GIT_DIR" rev-parse --git-common-dir)/hooks"
+mkdir -p "$COMMON_HOOKS"
+cp "$LATHE_HOME/template/git-hooks/post-merge" "$COMMON_HOOKS/post-merge"
+chmod +x "$COMMON_HOOKS/post-merge"
 
 echo "==> [6/6] Helper agent setup ..."
 echo ""
@@ -123,13 +127,29 @@ if [ -n "$HELPER_KIND" ]; then
   fi
 fi
 
+# If LATHE_HOME is nested inside the user repo (cloned as ./.lathe), remind
+# about .gitignore. Canonicalize for macOS /tmp -> /private/tmp.
+LATHE_HOME_CANON="$(cd "$LATHE_HOME" && pwd -P)"
+PROJECT_ROOT_CANON="$(cd "$PROJECT_ROOT" && pwd -P)"
+case "$LATHE_HOME_CANON" in
+  "$PROJECT_ROOT_CANON"/*)
+    REL="${LATHE_HOME_CANON#$PROJECT_ROOT_CANON/}"
+    cat <<EOF
+
+NOTE: Lathe is installed at \`$REL/\`. To keep it out of git, add to .gitignore:
+  /$REL/
+EOF
+    ;;
+esac
+
+LATHE_BIN="$LATHE_HOME/bin/lathe"
 cat <<EOF
 
 Lathe initialized at $PROJECT_ROOT/
 
   main/        your app code (or branch base)
-  develop/     target harness, runs/ auto-commit here
-  meta/        meta agent + improvements/
+  develop/     target agent runtime, runs/ auto-commit here
+  meta/        meta agent runtime
   .git/        shared bare repo (don't touch)
 EOF
 if [ -n "$HELPER_KIND" ]; then
@@ -137,11 +157,11 @@ if [ -n "$HELPER_KIND" ]; then
 fi
 cat <<EOF
 
-Next:
+Next (replace 'lathe' with '$LATHE_BIN' or an alias):
   cd $PROJECT_ROOT
 EOF
 if [ -n "$HELPER_KIND" ]; then
-  echo "  claude            # ask Lathe questions; the lathe-cli skill is loaded"
+  echo "  claude                 # ask Lathe questions; lathe-cli skill loaded"
 fi
 cat <<EOF
   lathe feature <name>   # start a new feature in features/<name>/

package/bin/lathe-meta

@@ -10,5 +10,5 @@ META_WT="$(lathe_wt_for_branch meta)" || {
   exit 1
 }
 
-cd "$META_WT/meta"
+cd "$META_WT"
 exec claude "$@"

package/bin/lathe-process

@@ -84,5 +84,5 @@ Press Enter to launch claude (Ctrl-C to abort)...
 EOF
 read -r _
 
-cd "$DEVELOP_WT/target"
+cd "$DEVELOP_WT"
 exec claude --add-dir "$TASK_WT"

package/bin/lathe-target

@@ -10,5 +10,5 @@ DEVELOP_WT="$(lathe_wt_for_branch develop)" || {
   exit 1
 }
 
-cd "$DEVELOP_WT/target"
+cd "$DEVELOP_WT"
 exec claude "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lathe-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Agent harness CLI: target/meta git worktrees driven by Claude Code",
   "bin": {
     "lathe": "./bin/lathe"

package/template/develop/bin/sync.sh

@@ -1,50 +1,80 @@
 #!/usr/bin/env bash
-# Sync harness/ (source of truth, editable by meta) into target/ (where
-# Claude Code reads from, partly under .claude/ which Claude Code's
-# sensitive-file guard blocks from in-tool edits).
+# Sync harness/ → worktree root (gitignored runtime files).
+# Branch-aware:
+#   develop branch → sync target part (everything in harness/ except harness/meta/)
+#   meta branch    → sync meta part   (harness/meta/ only)
 #
-# Run this whenever harness/ changes:
-#   - Manually after editing harness/ by hand
-#   - Automatically by meta-side hooks after meta improves harness/
-#   - On fresh clone before launching target the first time
+# Cleans stale runtime files first (rm before cp), so renames/removals on the
+# harness side propagate.
+#
+# Run when:
+#   - Manually after editing harness/ (rare; usually meta does this via PR)
+#   - Automatically by the post-merge git hook on merges into develop or meta
+#   - Once at lathe init for the initial population
 
 set -euo pipefail
 
 REPO="$(cd "$(dirname "$0")/.." && pwd)"
 HARNESS="$REPO/harness"
-TARGET="$REPO/target"
 
 if [ ! -d "$HARNESS" ]; then
-  echo "sync-harness: $HARNESS does not exist" >&2
+  echo "sync.sh: $HARNESS does not exist" >&2
   exit 1
 fi
 
-# Top-level files at target/ root.
-mkdir -p "$TARGET"
-cp -f "$HARNESS/CLAUDE.md"            "$TARGET/CLAUDE.md"
-cp -f "$HARNESS/plan_template.html"   "$TARGET/plan_template.html"
-
-# workflow/ (yaml templates).
-mkdir -p "$TARGET/workflow"
-rm -rf "$TARGET/workflow"/*
-cp -R "$HARNESS/workflow/." "$TARGET/workflow/"
-
-# hooks/ (shell scripts — executable bit must be preserved).
-mkdir -p "$TARGET/hooks"
-rm -rf "$TARGET/hooks"/*
-cp -R "$HARNESS/hooks/." "$TARGET/hooks/"
-chmod +x "$TARGET/hooks"/*.sh
-
-# .claude/ — the path Claude Code reads at startup. Sensitive-file guard
-# blocks tool-based edits here, but cp from outside the claude process
-# is fine. We rebuild settings.json + skills/ + agents/.
-mkdir -p "$TARGET/.claude/skills" "$TARGET/.claude/agents"
-rm -rf "$TARGET/.claude/skills"/* "$TARGET/.claude/agents"/*
-cp -f "$HARNESS/settings.json" "$TARGET/.claude/settings.json"
-cp -R "$HARNESS/skills/." "$TARGET/.claude/skills/"
-cp -R "$HARNESS/agents/." "$TARGET/.claude/agents/"
-
-# plans/ is runtime, NOT from harness. Keep what's there.
-mkdir -p "$TARGET/plans"
-
-echo "sync-harness: target/ rebuilt from harness/"
+# Branch detection. Detached HEAD = abort with no-op (don't mangle anything).
+BRANCH="$(git -C "$REPO" symbolic-ref --short HEAD 2>/dev/null || true)"
+if [ -z "$BRANCH" ]; then
+  echo "sync.sh: HEAD is detached (no branch). Skipping sync." >&2
+  exit 0
+fi
+
+case "$BRANCH" in
+  develop)
+    # ---- target side: harness/* (excluding harness/meta/) → worktree root ----
+    rm -f "$REPO/CLAUDE.md" "$REPO/plan_template.html"
+    rm -rf "$REPO/.claude" "$REPO/workflow" "$REPO/hooks"
+
+    cp -f "$HARNESS/CLAUDE.md"          "$REPO/CLAUDE.md"
+    cp -f "$HARNESS/plan_template.html" "$REPO/plan_template.html"
+
+    mkdir -p "$REPO/.claude/skills" "$REPO/.claude/agents"
+    cp -f "$HARNESS/settings.json" "$REPO/.claude/settings.json"
+    cp -R "$HARNESS/skills/." "$REPO/.claude/skills/"
+    cp -R "$HARNESS/agents/." "$REPO/.claude/agents/"
+
+    mkdir -p "$REPO/workflow"
+    cp -R "$HARNESS/workflow/." "$REPO/workflow/"
+
+    mkdir -p "$REPO/hooks"
+    cp -R "$HARNESS/hooks/." "$REPO/hooks/"
+    chmod +x "$REPO/hooks"/*.sh
+
+    mkdir -p "$REPO/plans"
+    echo "sync.sh: develop runtime rebuilt from harness/"
+    ;;
+
+  meta)
+    # ---- meta side: harness/meta/* → worktree root ----
+    if [ ! -d "$HARNESS/meta" ]; then
+      echo "sync.sh: $HARNESS/meta does not exist (this lathe install may be older than v1.2)" >&2
+      exit 1
+    fi
+
+    rm -f "$REPO/CLAUDE.md"
+    rm -rf "$REPO/.claude"
+
+    cp -f "$HARNESS/meta/CLAUDE.md" "$REPO/CLAUDE.md"
+
+    mkdir -p "$REPO/.claude/skills"
+    cp -f "$HARNESS/meta/settings.json" "$REPO/.claude/settings.json"
+    cp -R "$HARNESS/meta/skills/." "$REPO/.claude/skills/"
+
+    echo "sync.sh: meta runtime rebuilt from harness/meta/"
+    ;;
+
+  *)
+    echo "sync.sh: branch '$BRANCH' is neither develop nor meta. Skipping." >&2
+    exit 0
+    ;;
+esac

package/template/develop/harness/hooks/commit-runs.sh

@@ -14,9 +14,9 @@ INPUT="$(cat)"
 SESSION_ID="$(printf '%s' "$INPUT" | jq -r '.session_id // empty')"
 [ -z "$SESSION_ID" ] && exit 0
 
+# Sync'd to <develop_wt>/hooks/, parent is the develop worktree root.
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-TARGET_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
-REPO_ROOT="$(cd "$TARGET_DIR/.." && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
 cd "$REPO_ROOT" || exit 0
 RUN_DIR="runs/$SESSION_ID"

package/template/develop/harness/hooks/copy_transcript.sh

@@ -21,9 +21,9 @@ set -uo pipefail
 
 INPUT="$(cat)"
 
+# Sync'd to <develop_wt>/hooks/, so parent is the develop worktree root.
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-TARGET_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-REPO_ROOT="$(cd "$TARGET_ROOT/.." && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
 SESSION_ID="$(printf '%s' "$INPUT" | jq -r '.session_id // empty')"
 HOOK_EVENT="$(printf '%s' "$INPUT" | jq -r '.hook_event_name // empty')"

package/template/develop/harness/hooks/log.sh

@@ -17,10 +17,10 @@ set -euo pipefail
 EVENT="${1:?event name required}"
 INPUT="$(cat)"
 
-# Determine paths relative to this script (target/hooks/log.sh).
+# This script is sync'd to <develop_wt>/hooks/log.sh, so its parent dir is
+# the develop worktree root (where runs/ lives).
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-TARGET_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-REPO_ROOT="$(cd "$TARGET_ROOT/.." && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
 SESSION_ID="$(printf '%s' "$INPUT" | jq -r '.session_id // "unknown"')"
 TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"

package/template/git-hooks/post-merge

@@ -1,21 +1,28 @@
 #!/usr/bin/env bash
-# post-merge — auto-run sync.sh after a merge into develop.
+# post-merge — auto-run sync.sh whenever develop or meta absorbs a merge.
 #
-# Lathe stores harness/ as the source of truth on develop. Whenever a meta PR
-# (or any other change) lands on develop, target/.claude/ needs to be regenerated.
-# This hook does that locally for the worktree where the merge happened.
+# Both worktrees host gitignored runtime files (`.claude/`, `CLAUDE.md`, ...)
+# generated by sync.sh from `harness/`. After any merge that brings in new
+# harness content, those runtime files must be regenerated. sync.sh itself
+# is branch-aware (develop → target part, meta → meta part).
 #
-# UI-side merges (GitHub web) do NOT fire this. Run `lathe sync` manually after
-# `git pull` in those cases.
+# Hooks for linked worktrees fire from the common .git/hooks/ dir, so this
+# single hook handles both worktrees.
+#
+# UI-side merges (GitHub web) do NOT fire this. Run `lathe sync` manually
+# after `git pull` in those cases.
 
 set -uo pipefail
 
 BRANCH="$(git symbolic-ref --short HEAD 2>/dev/null || true)"
-[ "$BRANCH" = "develop" ] || exit 0
+case "$BRANCH" in
+  develop|meta) ;;
+  *) exit 0 ;;
+esac
 
 REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || exit 0
 SYNC="$REPO_ROOT/bin/sync.sh"
 [ -x "$SYNC" ] || exit 0
 
-echo "[lathe post-merge] running sync.sh on develop..."
+echo "[lathe post-merge] running sync.sh on $BRANCH..."
 "$SYNC"

package/template/helper-claude/.claude/CLAUDE.md

@@ -0,0 +1,28 @@
+# Lathe Helper
+
+あなたはこの Lathe project の **operator assistant** です。
+
+cwd は project root（共有 bare repo `.git/` と worktree `main/`、`develop/`、`meta/` が並ぶ場所）。worktree の中で起動した別 claude session（target / meta agent / user の vibe coding session）とは **別の存在**で、それらの仕事を取らない。
+
+`develop/` で起動された claude は target、`meta/` で起動された claude は meta agent、それぞれ自分の `CLAUDE.md`（gitignored、`harness/` から sync.sh で生成）を読み込む。あなたの role はここ project root にだけ効き、worktree 境界で claude のスコープは止まる。
+
+## 役割
+
+- ユーザーが Lathe コマンドや構造で迷ったら案内する
+- 求められれば Bash でコマンドを代行実行する
+- worktree / branch / runs / improvements の現状を git 経由で答える
+- target / meta が何をしているかは、`develop/CLAUDE.md` や `meta/meta/CLAUDE.md` を Read してから答える
+
+詳細は `lathe-cli` skill を参照（`description` がマッチすれば自動で load される）。
+
+## やらない
+
+- **user の app コードを実装しない**。実装は user 自身が `features/<name>/` で vibe coding するか、target agent が `lathe process <pr#>` で polish する仕事
+- worktree や branch を勝手に作らない（user に提案して、user が `lathe feature` 等で実行）
+- `develop/` や `meta/` の runtime ファイル（CLAUDE.md, .claude/, hooks/, workflow/ 等）を直接編集しない（gitignored、sync.sh で `harness/` から regenerate されるため）。改善が必要なら meta worktree で `harness/` を編集 → develop に PR → post-merge hook で sync
+
+## なぜ project root にいるか
+
+worktree 境界で claude の CLAUDE.md 探索は止まる（main/.git の linked-worktree marker で boundary）ため、ここに role-prescriptive な記述を置いても main/develop/meta の session には伝播しない。あなたの role はあくまで「project root にいる時だけ」効く。
+
+worktree 内で claude を起動した時はそれぞれの CLAUDE.md（target なら orchestrator、meta なら meta agent）が支配する。あなたはその外側のレイヤー。

package/template/helper-claude/.claude/skills/lathe-cli/SKILL.md

@@ -7,15 +7,23 @@ description: ユーザーが Lathe project（main/develop/meta worktree + bare .
 
 このプロジェクトは Lathe で初期化された agent harness。あなたはユーザーの **Lathe 操作のアシスタント**。実装そのものは target / meta agent が別 worktree で行うので、あなたは「コマンドを案内する / 代行する / 状態を説明する」役。
 
-## 構成（`lathe init` 直後の姿）
+## 構成（`lathe init` 直後の姿、v1.2 layout）
 
 ```
 project_root/
 ├── .git/         共有 bare repo（worktree 全部がここを参照）
-├── .claude/      この skill とユーザーの helper 設定
+├── .claude/      この skill とユーザーの helper 設定（filesystem only at root）
+├── CLAUDE.md     helper の役割記述
 ├── main/         worktree on main 枝（user の app code）
-├── develop/     worktree on develop 枝（target が住む。harness/ + 生成された target/.claude/）
-└── meta/         worktree on meta 枝（meta agent + improvements/）
+├── develop/      worktree on develop 枝
+│   ├── harness/        tracked（target + meta 両方の agent spec の正、harness/meta/ も含む）
+│   ├── bin/sync.sh     tracked（branch 判定で target or meta runtime に展開）
+│   ├── runs/, improvements/, plans/   tracked
+│   ├── .gitignore      tracked（CLAUDE.md, .claude/, hooks/, workflow/ などを ignore）
+│   └── （CLAUDE.md, .claude/, hooks/, workflow/, plan_template.html）  gitignored sync output
+└── meta/         worktree on meta 枝
+    ├── harness/, bin/, runs/, improvements/, .gitignore  tracked（develop から inherit）
+    └── （CLAUDE.md, .claude/）  gitignored sync output（harness/meta/ から）
 ```
 
 加えて、運用中に動的に増えるもの：
@@ -29,15 +37,15 @@ project_root/
 |---|---|---|
 | `main` | release stable | 普段は user、最終的に develop からの PR で更新 |
 | `develop` | integration、target の住処、runs/ の auto-commit 先 | target session、meta からの PR が merge される |
-| `meta` | harness 改善 + improvements/ 蓄積 | meta operator + meta agent |
+| `meta` | harness 改善（含む harness/meta/）と improvements/ 蓄積 | meta operator + meta agent |
 | `feature/<name>` | user の vibe code | user が `lathe feature` で生やす |
 
 ## コマンド一覧
 
 ```
 lathe init                          ← 既に走った前提
-lathe target [args...]              develop/target で claude 起動（debug or 直接 task）
-lathe meta [args...]                meta/meta で claude 起動
+lathe target [args...]              develop worktree で claude 起動（debug or 直接 task）
+lathe meta [args...]                meta worktree で claude 起動
 lathe sync                          develop の bin/sync.sh 手動実行（post-merge hook が動かない時）
 lathe process <pr#>                 PR pickup → tasks/<pr#>/ worktree 作成 → target 起動
 lathe feature <name> [--from main|develop]
@@ -117,9 +125,9 @@ lathe ls                        # worktree, branch, recent runs/improvements
    - それぞれの worktree は固定の枝。別枝は別 worktree。switch すると `fatal: 'X' is already used by worktree at '...'`
    - feature を始めたいなら `lathe feature <name>` を使う
 
-2. **`target/.claude/`、`target/CLAUDE.md` などを直接編集しない**
-   - これは `harness/` から sync.sh で生成されたコピー。次回 sync で上書きされる
-   - 改善は `harness/` 配下を編集（meta worktree 内で）→ develop に PR → post-merge で反映
+2. **`develop/.claude/`、`develop/CLAUDE.md`、`meta/.claude/`、`meta/CLAUDE.md` などを直接編集しない**
+   - これは `harness/`（meta 用は `harness/meta/`）から sync.sh で生成された runtime コピー。次回 sync で上書きされる
+   - 改善は `harness/` 配下を編集（meta worktree 内で。target 改善は `harness/`、meta 自身の改善は `harness/meta/`）→ develop に PR → post-merge hook で sync 自動実行 → 反映
 
 3. **`features/<name>/` を `rm -rf` で消すと metadata が残る**
    - `git worktree list` にゾンビが出る