lathe-cli 1.0.1 → 1.2.0

package/README.md

@@ -28,30 +28,55 @@ 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 が生成。
 
 ## 日常コマンド
 
 ```sh
+lathe feature <name> [--from main|develop]
+                            # features/<name>/ worktree + feature/<name> 枝
+lathe feature-done <name>   # 安全に worktree + branch + remote を一掃
+lathe ls                    # worktree / branch / 最近の runs / improvements
+lathe process <pr#>         # PR pickup → tasks/<pr#>/ worktree → target 起動
 lathe target [args...]      # cd develop/target && claude args
 lathe meta   [args...]      # cd meta/meta && claude args
 lathe sync                  # develop/bin/sync.sh 手動実行
-lathe process <pr#>         # PR pickup → tasks/<pr#>/ worktree 作成 → target 起動
 lathe help                  # ヘルプ
 ```
 
 どの worktree や project root で実行しても、git の共通 dir から自動で正しい場所に移動します。
 
+## helper agent（project root の `.claude/`）
+
+`lathe init` 中に「helper agent を Claude Code か Codex か」を対話で聞かれます（デフォルト: Claude Code）。選んだ template が project root の `.claude/` に配置され、`lathe-cli` skill が入ります。
+
+```sh
+cd <project_root>
+claude              # Lathe 操作の質問はここで聞ける
+```
+
+helper は **Lathe 操作のアシスタント**で、target/meta のような実装エージェントではありません。`lathe feature` や PR 処理のフローに迷ったら相談する相手として常駐します。
+
 ## 標準ワークフロー
 
 ```sh
@@ -91,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

@@ -28,17 +28,28 @@ lathe — agent harness CLI
 Initialize a project with main / develop / meta worktrees backed by a
 shared bare git repo, then drive target / meta agents over Claude Code.
 
-Commands:
+Setup:
   init             Initialize Lathe in current (empty) directory.
-                   Creates ./.git (bare) and three worktrees:
-                     ./main      your app code
-                     ./develop   target harness, runs/ auto-commit here
-                     ./meta      meta agent + improvements/
+                   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
+                   feature/<name> branch (default base: main; --from develop)
+  feature-done <name>
+                   Tear down a feature: worktree + branch (+ remote if any).
+                   Refuses if uncommitted/unpushed unless --force.
   process <pr#>    Pick up a GitHub PR for target processing
                    (creates ./tasks/<pr#>/ worktree, launches target)
-  sync             Re-sync harness/ -> target/.claude/ in develop worktree
-  target [args]    Launch target agent (cd develop/target, claude args)
-  meta   [args]    Launch meta agent (cd meta/meta, claude args)
+  ls               List worktrees, branches, recent runs/improvements
+
+Agent launchers:
+  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:
   help             This message
 
 LATHE_HOME=$LATHE_HOME

package/bin/lathe-feature

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# lathe feature <name> [--from main|develop]
+#   Create a feature worktree at ./features/<name> on a new branch
+#   feature/<name>, branched from main (default) or develop.
+
+set -euo pipefail
+: "${LATHE_HOME:?must be set by lathe dispatcher}"
+source "$LATHE_HOME/bin/_lathe-lib.sh"
+
+NAME=""
+FROM="main"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --from)
+      FROM="$2"; shift 2 ;;
+    --from=*)
+      FROM="${1#--from=}"; shift ;;
+    -*)
+      echo "lathe feature: unknown flag $1" >&2; exit 1 ;;
+    *)
+      if [ -z "$NAME" ]; then NAME="$1"; else
+        echo "lathe feature: extra argument $1" >&2; exit 1
+      fi
+      shift ;;
+  esac
+done
+
+if [ -z "$NAME" ]; then
+  echo "Usage: lathe feature <name> [--from main|develop]" >&2
+  exit 1
+fi
+
+PROJECT_ROOT="$(lathe_project_root)" || {
+  echo "lathe feature: not inside a Lathe project" >&2
+  exit 1
+}
+
+GIT_DIR="$PROJECT_ROOT/.git"
+BRANCH="feature/$NAME"
+WT="$PROJECT_ROOT/features/$NAME"
+
+# Sanity: base branch exists
+if ! git --git-dir="$GIT_DIR" rev-parse --verify "$FROM" >/dev/null 2>&1; then
+  echo "lathe feature: base branch '$FROM' does not exist" >&2
+  exit 1
+fi
+
+# Sanity: feature branch / worktree don't already exist
+if git --git-dir="$GIT_DIR" rev-parse --verify "$BRANCH" >/dev/null 2>&1; then
+  echo "lathe feature: branch '$BRANCH' already exists" >&2
+  exit 1
+fi
+if [ -e "$WT" ]; then
+  echo "lathe feature: $WT already exists" >&2
+  exit 1
+fi
+
+mkdir -p "$PROJECT_ROOT/features"
+git --git-dir="$GIT_DIR" worktree add --quiet -b "$BRANCH" "$WT" "$FROM"
+
+cat <<EOF
+Created feature worktree:
+
+  branch: $BRANCH (from $FROM)
+  path:   $WT
+
+Next:
+  cd $WT
+  # vibe code, commit, push
+  git push -u origin $BRANCH
+  gh pr create --base develop --title "..." --body "..."
+EOF

package/bin/lathe-feature-done

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# lathe feature-done <name> [--keep-branch] [--keep-remote] [--force]
+#   Tear down a feature worktree safely:
+#     1. refuse if uncommitted changes exist (unless --force)
+#     2. refuse if local has commits not pushed to upstream (unless --force)
+#     3. git worktree remove features/<name>
+#     4. (unless --keep-branch) git branch -D feature/<name>
+#     5. (unless --keep-remote)  git push origin :feature/<name>
+
+set -euo pipefail
+: "${LATHE_HOME:?must be set by lathe dispatcher}"
+source "$LATHE_HOME/bin/_lathe-lib.sh"
+
+NAME=""
+KEEP_BRANCH=0
+KEEP_REMOTE=0
+FORCE=0
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --keep-branch) KEEP_BRANCH=1; shift ;;
+    --keep-remote) KEEP_REMOTE=1; shift ;;
+    --force)       FORCE=1; shift ;;
+    -*) echo "lathe feature-done: unknown flag $1" >&2; exit 1 ;;
+    *)
+      if [ -z "$NAME" ]; then NAME="$1"; else
+        echo "lathe feature-done: extra argument $1" >&2; exit 1
+      fi
+      shift ;;
+  esac
+done
+
+if [ -z "$NAME" ]; then
+  echo "Usage: lathe feature-done <name> [--keep-branch] [--keep-remote] [--force]" >&2
+  exit 1
+fi
+
+PROJECT_ROOT="$(lathe_project_root)" || {
+  echo "lathe feature-done: not inside a Lathe project" >&2
+  exit 1
+}
+
+GIT_DIR="$PROJECT_ROOT/.git"
+BRANCH="feature/$NAME"
+WT="$PROJECT_ROOT/features/$NAME"
+
+if [ ! -d "$WT" ]; then
+  echo "lathe feature-done: $WT does not exist" >&2
+  exit 1
+fi
+
+# 1. uncommitted changes?
+if [ -n "$(git -C "$WT" status --porcelain 2>/dev/null)" ]; then
+  if [ "$FORCE" = 0 ]; then
+    echo "lathe feature-done: uncommitted changes in $WT. Commit or use --force." >&2
+    exit 1
+  fi
+fi
+
+# 2. unpushed commits?
+if [ "$FORCE" = 0 ]; then
+  upstream="$(git -C "$WT" rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || true)"
+  if [ -n "$upstream" ]; then
+    ahead="$(git -C "$WT" rev-list --count "$upstream..HEAD" 2>/dev/null || echo 0)"
+    if [ "$ahead" -gt 0 ]; then
+      echo "lathe feature-done: $ahead local commit(s) ahead of $upstream. Push or use --force." >&2
+      exit 1
+    fi
+  fi
+fi
+
+echo "==> Removing worktree $WT ..."
+git --git-dir="$GIT_DIR" worktree remove "$WT"
+
+if [ "$KEEP_BRANCH" = 0 ]; then
+  echo "==> Deleting local branch $BRANCH ..."
+  git --git-dir="$GIT_DIR" branch -D "$BRANCH" 2>&1 || true
+fi
+
+if [ "$KEEP_REMOTE" = 0 ]; then
+  if git --git-dir="$GIT_DIR" remote get-url origin >/dev/null 2>&1; then
+    if git --git-dir="$GIT_DIR" ls-remote --exit-code --heads origin "$BRANCH" >/dev/null 2>&1; then
+      echo "==> Deleting remote branch origin/$BRANCH ..."
+      git --git-dir="$GIT_DIR" push origin --delete "$BRANCH" 2>&1 || true
+    fi
+  fi
+fi
+
+echo "Done."

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,43 +61,110 @@ 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"
+# 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 ""
+echo "Which CLI agent will you use as the project-root helper?"
+echo "(Helper sits at the project root and assists with Lathe commands. Doesn't"
+echo " participate in implementation — that's target/meta's job.)"
+echo ""
+echo "  1) Claude Code (recommended)"
+echo "  2) Codex CLI (WIP — falls back to Claude Code template for now)"
+echo "  3) skip (no helper config)"
+echo ""
+HELPER_CHOICE=""
+if [ -t 0 ]; then
+  printf "Choice [1]: "
+  read -r HELPER_CHOICE
+fi
+case "${HELPER_CHOICE:-1}" in
+  1|"") HELPER_KIND="claude" ;;
+  2)
+    echo "(Codex helper template not yet implemented; using Claude Code template)"
+    HELPER_KIND="claude"
+    ;;
+  3) HELPER_KIND="" ;;
+  *)
+    echo "(unrecognized choice; using Claude Code template)"
+    HELPER_KIND="claude"
+    ;;
+esac
+
+if [ -n "$HELPER_KIND" ]; then
+  HELPER_SRC="$LATHE_HOME/template/helper-${HELPER_KIND}"
+  if [ -d "$HELPER_SRC" ]; then
+    cp -R "$HELPER_SRC/." "$PROJECT_ROOT/"
+    echo "Helper config installed at $PROJECT_ROOT/.claude/"
+  else
+    echo "Warning: $HELPER_SRC not found, skipping helper install"
+  fi
+fi
 
-echo "==> [5/5] 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"
+# 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 (cd here to start working)
-  develop/   target harness (target launches from here)
-  meta/      meta agent (improvements/ live here)
-  .git/      shared bare repo
+  main/        your app code (or branch base)
+  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
+  echo "  .claude/     project-root helper (skill: lathe-cli)"
+fi
+cat <<EOF
 
-Next:
-  cd $PROJECT_ROOT/main
-  # vibe code; commit; PR a feature branch to develop
-  # then:  lathe process <pr#>
+Next (replace 'lathe' with '$LATHE_BIN' or an alias):
+  cd $PROJECT_ROOT
+EOF
+if [ -n "$HELPER_KIND" ]; then
+  echo "  claude                 # ask Lathe questions; lathe-cli skill loaded"
+fi
+cat <<EOF
+  lathe feature <name>   # start a new feature in features/<name>/
+  lathe process <pr#>    # have target process a PR
+  lathe ls               # list worktrees, branches, recent runs
 EOF

package/bin/lathe-ls

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# lathe ls — list worktrees, branches, runs, improvements at a glance.
+
+set -euo pipefail
+: "${LATHE_HOME:?must be set by lathe dispatcher}"
+source "$LATHE_HOME/bin/_lathe-lib.sh"
+
+PROJECT_ROOT="$(lathe_project_root)" || {
+  echo "lathe ls: not inside a Lathe project" >&2
+  exit 1
+}
+GIT_DIR="$PROJECT_ROOT/.git"
+
+echo "=== worktrees ==="
+git --git-dir="$GIT_DIR" worktree list
+
+echo ""
+echo "=== branches ==="
+git --git-dir="$GIT_DIR" branch -a
+
+DEVELOP_WT="$(lathe_wt_for_branch develop 2>/dev/null || true)"
+if [ -n "$DEVELOP_WT" ] && [ -d "$DEVELOP_WT/runs" ]; then
+  echo ""
+  echo "=== recent runs (develop/runs/) ==="
+  ls -1t "$DEVELOP_WT/runs/" 2>/dev/null | grep -v gitkeep | head -10 || echo "(none)"
+fi
+
+META_WT="$(lathe_wt_for_branch meta 2>/dev/null || true)"
+if [ -n "$META_WT" ] && [ -d "$META_WT/improvements" ]; then
+  echo ""
+  echo "=== recent improvements (meta/improvements/) ==="
+  ls -1t "$META_WT/improvements/" 2>/dev/null | grep -v gitkeep | head -10 || echo "(none)"
+fi

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.0.1",
+  "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/settings.json

@@ -0,0 +1,5 @@
+{
+  "env": {
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1"
+  }
+}

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

@@ -0,0 +1,163 @@
+---
+name: lathe-cli
+description: ユーザーが Lathe project（main/develop/meta worktree + bare .git の構成）の操作で詰まったときに参照する。コマンド一覧、branch / worktree モデル、典型操作（feature 作成・PR 処理・harness 改善・cleanup）、トラブル時の復旧手順を扱う。"lathe", "feature branch", "worktree", "develop", "meta", "PR を処理" 等の言葉が出たら起動する。
+---
+
+# Lathe CLI 操作リファレンス
+
+このプロジェクトは Lathe で初期化された agent harness。あなたはユーザーの **Lathe 操作のアシスタント**。実装そのものは target / meta agent が別 worktree で行うので、あなたは「コマンドを案内する / 代行する / 状態を説明する」役。
+
+## 構成（`lathe init` 直後の姿、v1.2 layout）
+
+```
+project_root/
+├── .git/         共有 bare repo（worktree 全部がここを参照）
+├── .claude/      この skill とユーザーの helper 設定（filesystem only at root）
+├── CLAUDE.md     helper の役割記述
+├── main/         worktree on main 枝（user の app code）
+├── 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/ から）
+```
+
+加えて、運用中に動的に増えるもの：
+
+- `features/<name>/` — `lathe feature <name>` で作る、user の vibe coding 用 worktree
+- `tasks/<pr#>/` — `lathe process <pr#>` で作る、target が PR を polish する用 worktree
+
+## branch モデル
+
+| branch | 役割 | 誰が触る |
+|---|---|---|
+| `main` | release stable | 普段は user、最終的に develop からの PR で更新 |
+| `develop` | integration、target の住処、runs/ の auto-commit 先 | target session、meta からの PR が merge される |
+| `meta` | harness 改善（含む harness/meta/）と improvements/ 蓄積 | meta operator + meta agent |
+| `feature/<name>` | user の vibe code | user が `lathe feature` で生やす |
+
+## コマンド一覧
+
+```
+lathe init                          ← 既に走った前提
+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]
+                                    features/<name>/ worktree 作成、新 feature/<name> 枝
+lathe feature-done <name> [--keep-branch] [--keep-remote] [--force]
+                                    feature 終了処理（worktree 削除、branch 削除、remote push :branch）
+lathe ls                            worktree / branch / runs / improvements を一覧
+lathe help                          help
+```
+
+## 典型操作
+
+### 新 feature を始める
+
+```sh
+cd project_root
+lathe feature <name>            # features/<name>/ ができる
+cd features/<name>
+# vibe code（claude を別 session で立ち上げて自由に）
+git add . && git commit -m "WIP: vibe ..."
+git push -u origin feature/<name>
+gh pr create --base develop --title "..." --body "..."
+```
+
+### PR を target に処理させる
+
+PR が立ったら（overseer 役）：
+
+```sh
+cd project_root
+lathe process <pr#>             # tasks/<pr#>/ worktree が新規作成、target が起動
+```
+
+claude TUI が立ち上がるので、表示された prompt：「Read .lathe-task.md from the added directory and process it.」を貼る。
+
+orchestrator が plan HTML を起こして承認待ちで止まる。承認したら coder/reviewer に dispatch、PR branch に commit/push されて PR が更新される。
+
+### feature を終わらせる
+
+```sh
+cd project_root
+gh pr merge <pr#>               # GitHub 側で merge
+lathe feature-done <name>       # local worktree + branch + remote branch を一掃
+```
+
+### meta で harness を改善する
+
+```sh
+cd project_root/meta
+git fetch && git merge --no-edit develop   # 最新 runs/ を取り込み
+lathe meta                                  # meta agent 起動
+# meta が runs/ 観察 → harness/ 編集 → improvements/<id>/ 記録 → commit
+git push -u origin meta
+gh pr create --base develop --head meta --title "harness: ..."
+gh pr merge <meta pr#>
+# → develop 側 post-merge hook が sync.sh 自動実行 → target/.claude/ 更新
+```
+
+### release（develop → main）
+
+```sh
+cd project_root/main
+git pull
+git merge develop
+git push origin main
+```
+
+### 全体俯瞰
+
+```sh
+lathe ls                        # worktree, branch, recent runs/improvements
+```
+
+## やってはいけない / 詰まりやすい点
+
+1. **`main/`, `develop/`, `meta/` の中で `git checkout` で別 branch に切り替えない**
+   - それぞれの worktree は固定の枝。別枝は別 worktree。switch すると `fatal: 'X' is already used by worktree at '...'`
+   - feature を始めたいなら `lathe feature <name>` を使う
+
+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` にゾンビが出る
+   - 正しい手順：`lathe feature-done <name>`（または `git --git-dir=.git worktree remove features/<name>`）
+
+4. **branch だけ消そうとして `git branch -D feature/X` でエラー**
+   - その branch を worktree が checkout 中だから。先に worktree を消す
+   - `lathe feature-done` は両方やる
+
+5. **post-merge hook は local merge のみ発火**
+   - GitHub UI で merge した場合は hook 走らない。`cd develop && git pull && lathe sync` で手動
+
+6. **runs/ の auto-commit は local のみ（remote push しない）**
+   - 別 machine の meta から見たいなら、`cd develop && git push origin develop` を手動 or 自動化要
+
+## トラブルシュート
+
+| 症状 | 対処 |
+|---|---|
+| `lathe target` が "develop worktree not found" | `git --git-dir=.git worktree list` で確認、抜けてたら `git worktree add` で復活 |
+| `git worktree list` にゾンビ entry | `git --git-dir=.git worktree prune` |
+| `git branch -D` で "checked out at" エラー | 該当 worktree を先に remove |
+| post-merge hook が走らない | `.git/hooks/post-merge` の存在・実行ビット確認、無ければ template から copy |
+| PR にコードが上がらない | task worktree から `git push` 忘れ、target session 内で確認 |
+
+## あなたの責任範囲
+
+- ユーザーが Lathe 操作で迷ったら **このコマンド使え** と案内
+- 求められれば Bash で代行実行
+- 構造（worktree / branch / 状態）の質問には git 直接叩いて答える
+- target / meta が何をしているかの質問には、各 worktree の CLAUDE.md（develop の harness/CLAUDE.md、meta の meta/CLAUDE.md）を Read してから答える
+
+実装そのもの（user の app コードを書くなど）は **しない**。それは feature worktree で user 自身か、target agent の仕事。