lathe-cli 1.1.0 → 1.3.0

package/README.md

@@ -7,7 +7,7 @@ Claude Code を agent backend にした target/meta 二層 harness を、git bra
 | role | やること | 接点 |
 |---|---|---|
 | 開発者 | feature branch で vibe coding、PR を develop に出す | git / gh |
-| target agent | PR を polish 実装に置き換える、commit して PR を更新 | plan HTML 出力、approval で停止 |
+| target agent | PR を polish 実装に置き換える、commit して PR を更新 | plan HTML 出力、workflow gate / escalation |
 | overseer | plan HTML レビュー、PR レビュー、merge | claude UI + GitHub PR |
 | meta operator | runs/ を読み harness/ を改善、PR を develop に出す | meta agent と対話 |
 
@@ -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 が生成。
 
 ## 日常コマンド
 
@@ -47,9 +57,15 @@ 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 plan pr <pr#>         # PR pickup → tasks/<pr#>/ worktree → target が計画だけ作る
+lathe watch [--once]        # develop 宛ての新規 PR を監視し、自動で lathe plan --print pr
+lathe process <pr#>         # PR pickup/reuse → 計画承認待ちなしで target が実装まで進める
+lathe process --manual-prompt <pr#>
+                            # 旧式 Claude Code 用。prompt を手貼りする fallback
+lathe process --no-launch <pr#>
+                            # tasks/<pr#>/ 準備だけ行い、target は起動しない
+lathe target [args...]      # cd develop && claude args
+lathe meta   [args...]      # cd meta && claude args
 lathe sync                  # develop/bin/sync.sh 手動実行
 lathe help                  # ヘルプ
 ```
@@ -67,6 +83,17 @@ claude              # Lathe 操作の質問はここで聞ける
 
 helper は **Lathe 操作のアシスタント**で、target/meta のような実装エージェントではありません。`lathe feature` や PR 処理のフローに迷ったら相談する相手として常駐します。
 
+## develop PR の自動計画
+
+ローカルで PR を監視し、develop 宛ての新規 PR を見つけたら計画だけ自動作成できます。
+
+```sh
+cd myapp
+lathe watch --interval 60
+```
+
+watch は `lathe plan --print pr <pr#>` を呼び、`tasks/<pr#>/.lathe/task.json`、`.lathe/brief.md`、`.lathe/invocation.json` を target harness に渡します。`task.json` は source / branch / worktree などの transport 事実、`invocation.json` は planning-only 制約などの runtime dependency injection です。workflow・human gate・delivery は target harness 側で選びます。
+
 ## 標準ワークフロー
 
 ```sh
@@ -80,9 +107,12 @@ git push -u origin feature/X
 gh pr create --base develop --title "..." --body "..."
 
 # overseer
+lathe plan pr <pr#>         # 任意: 計画だけ先に作る。watch なら自動
 lathe process <pr#>
-# claude UI で「Read .lathe-task.md from the added directory and process it」を貼り付け
-# orchestrator が plan → 承認 → coder/reviewer dispatch → commit/push → PR 更新
+# tasks/<pr#>/ + task/pr-<pr#> が作られる（plan 済みなら reuse）
+# tasks/<pr#>/.lathe/task.json + .lathe/brief.md + .lathe/invocation.json は Lathe が作る入力 envelope
+# claude TUI が初回 prompt 入りで起動。process 実行自体が計画承認 gate になる
+# orchestrator が plan（既存があればreuse）→ coder/reviewer dispatch → commit → PR head へ push
 gh pr merge <pr#>           # develop に merge
 
 # meta operator（任意のタイミング）
@@ -106,9 +136,9 @@ 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/ が再生成される
+- **post-merge hook が auto-sync**：meta の harness 改善が develop に merge された瞬間に develop/.claude/ が再生成される
 
 ## 動作確認済み（v1）
 
@@ -116,13 +146,14 @@ git push origin main
 - `lathe init` で bare repo + 3 worktree + post-merge hook 設置
 - target session 実行、runs auto-commit on develop
 - meta worktree が `git merge develop` で runs/ 読込
-- meta が harness/CLAUDE.md 編集 → develop merge → post-merge hook → sync 自動 → target/CLAUDE.md 反映
+- meta が harness/CLAUDE.md 編集 → develop merge → post-merge hook → sync 自動 → develop/CLAUDE.md 反映
 - `lathe target` / `lathe meta` / `lathe sync` がどの worktree から実行しても正しい worktree を見つける
 
 ## 既知の v1 制限
 
 - meta → develop merge で meta/ + improvements/ overlay も develop に持ち込まれる（cherry-pick / 別 PR 機構で v2 解決）
-- `lathe process` の prompt 渡しは手動ペースト（claude TUI が piped 初期 prompt を確実に取らないため）
+- `lathe process` / `lathe plan` は Claude Code の prompt 引数で初回 prompt を自動投入する。古い Claude Code で動かない場合は `--manual-prompt` を使う
+- `lathe process` は workflow を固定せず、計画承認 grant と PR delivery adapter を `.lathe/invocation.json` で注入する。採用 workflow がそれを安全に消費できる場合は計画承認待ちを挟まず実装まで進み、仕様不明、high-risk 変更、検証不能などは human escalation として停止する
 - post-merge hook は local merge のみ発火、GitHub UI で merge した時は `git pull` 後に `lathe sync` 手動
 - v1 は新 project 専用、既存 repo の自動 migration なし
 - runs/ auto-commit は local commit のみ（remote push しない）。multi-machine 構成では別途 push 設計が必要
@@ -130,4 +161,4 @@ git push origin main
 ## 設計詳細
 
 target orchestrator の指示書: `template/develop/harness/CLAUDE.md`
-meta agent の指示書: `template/meta-overlay/meta/CLAUDE.md`
+meta agent の指示書: `template/develop/harness/meta/CLAUDE.md`

package/bin/_lathe-task.sh

@@ -0,0 +1,213 @@
+#!/usr/bin/env bash
+# Shared task-intake helpers for Lathe subcommands. Sourced, not executed.
+
+lathe_require_gh() {
+  command -v gh >/dev/null 2>&1 || {
+    echo "lathe: gh (GitHub CLI) is required" >&2
+    exit 1
+  }
+}
+
+lathe_write_exclude_once() {
+  local file="$1"
+  local pattern="$2"
+  touch "$file"
+  if ! grep -qxF "$pattern" "$file" 2>/dev/null; then
+    printf '%s\n' "$pattern" >> "$file"
+  fi
+}
+
+# Prepare a PR-backed task worktree and write Lathe's local transport envelope.
+#
+# Sets globals:
+#   PROJECT_ROOT DEVELOP_WT GIT_DIR PR_NUMBER PR_TITLE PR_BODY PR_URL
+#   BASE_REF HEAD_REF FETCH_REF TASK_BRANCH TASK_WT LATHE_TASK_DIR
+lathe_prepare_pr_task() {
+  local requested_pr="${1#\#}"
+  local current_branch exclude_file
+
+  lathe_require_gh
+
+  PROJECT_ROOT="$(lathe_project_root)" || {
+    echo "lathe: not inside a Lathe project" >&2
+    exit 1
+  }
+  DEVELOP_WT="$(lathe_wt_for_branch develop)" || {
+    echo "lathe: develop worktree not found" >&2
+    exit 1
+  }
+  GIT_DIR="$PROJECT_ROOT/.git"
+
+  echo "==> Fetching PR #$requested_pr metadata ..."
+  PR_JSON="$(gh pr view "$requested_pr" --json number,title,body,url,baseRefName,headRefName)"
+  PR_NUMBER="$(printf '%s' "$PR_JSON" | jq -r '.number // empty')"
+  [ -n "$PR_NUMBER" ] || PR_NUMBER="$requested_pr"
+  PR_TITLE="$(printf '%s' "$PR_JSON" | jq -r '.title // ""')"
+  PR_BODY="$(printf '%s' "$PR_JSON" | jq -r '.body // ""')"
+  PR_URL="$(printf '%s' "$PR_JSON" | jq -r '.url // ""')"
+  BASE_REF="$(printf '%s' "$PR_JSON" | jq -r '.baseRefName // "develop"')"
+  HEAD_REF="$(printf '%s' "$PR_JSON" | jq -r '.headRefName // empty')"
+  if [ -z "$HEAD_REF" ]; then
+    echo "lathe: PR #$requested_pr has no headRefName" >&2
+    exit 1
+  fi
+
+  FETCH_REF="refs/remotes/origin/lathe/pr-$PR_NUMBER"
+  TASK_BRANCH="task/pr-$PR_NUMBER"
+  TASK_WT="$PROJECT_ROOT/tasks/$PR_NUMBER"
+  LATHE_TASK_DIR="$TASK_WT/.lathe"
+
+  if ! git --git-dir="$GIT_DIR" fetch origin "+refs/pull/$PR_NUMBER/head:$FETCH_REF" >/dev/null 2>&1; then
+    git --git-dir="$GIT_DIR" fetch origin "+$HEAD_REF:$FETCH_REF" >/dev/null 2>&1 || {
+      echo "lathe: failed to fetch PR #$PR_NUMBER from origin" >&2
+      exit 1
+    }
+  fi
+
+  mkdir -p "$PROJECT_ROOT/tasks"
+  if [ -e "$TASK_WT" ]; then
+    if ! git -C "$TASK_WT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+      echo "lathe: $TASK_WT exists but is not a git worktree" >&2
+      exit 1
+    fi
+    current_branch="$(git -C "$TASK_WT" symbolic-ref --short HEAD 2>/dev/null || true)"
+    if [ "$current_branch" != "$TASK_BRANCH" ]; then
+      echo "lathe: $TASK_WT is on '$current_branch', expected '$TASK_BRANCH'" >&2
+      exit 1
+    fi
+    echo "==> Reusing task worktree at $TASK_WT (branch: $TASK_BRANCH)"
+  else
+    if git --git-dir="$GIT_DIR" rev-parse --verify "$TASK_BRANCH" >/dev/null 2>&1; then
+      echo "==> Creating task worktree at $TASK_WT (branch: $TASK_BRANCH)..."
+      git --git-dir="$GIT_DIR" worktree add --quiet "$TASK_WT" "$TASK_BRANCH"
+    else
+      echo "==> Creating task worktree at $TASK_WT (branch: $TASK_BRANCH from $HEAD_REF)..."
+      git --git-dir="$GIT_DIR" worktree add --quiet -b "$TASK_BRANCH" "$TASK_WT" "$FETCH_REF"
+    fi
+  fi
+
+  mkdir -p "$LATHE_TASK_DIR"
+  jq -n \
+    --arg source_type "pr" \
+    --arg source_id "$PR_NUMBER" \
+    --arg title "$PR_TITLE" \
+    --arg url "$PR_URL" \
+    --arg base_branch "$BASE_REF" \
+    --arg head_branch "$HEAD_REF" \
+    --arg task_branch "$TASK_BRANCH" \
+    --arg task_worktree "$TASK_WT" \
+    --arg brief ".lathe/brief.md" \
+    '{
+      schema_version: 1,
+      source: {
+        type: $source_type,
+        id: $source_id,
+        title: $title,
+        url: $url,
+        base_branch: $base_branch,
+        head_branch: $head_branch
+      },
+      worktree: {
+        path: $task_worktree,
+        branch: $task_branch
+      },
+      artifacts: {
+        brief: $brief
+      }
+    }' > "$LATHE_TASK_DIR/task.json"
+
+  cat > "$LATHE_TASK_DIR/brief.md" <<EOF
+# PR #$PR_NUMBER: $PR_TITLE
+
+Source: $PR_URL
+Base branch: $BASE_REF
+Head branch: $HEAD_REF
+Task branch: $TASK_BRANCH
+Task worktree: $TASK_WT
+
+## PR body
+
+$PR_BODY
+EOF
+
+  exclude_file="$(git -C "$TASK_WT" rev-parse --git-path info/exclude)"
+  mkdir -p "$(dirname "$exclude_file")"
+  touch "$exclude_file"
+  if ! grep -qxF "# Lathe local task metadata" "$exclude_file" 2>/dev/null; then
+    {
+      echo ""
+      echo "# Lathe local task metadata"
+    } >> "$exclude_file"
+  fi
+  lathe_write_exclude_once "$exclude_file" ".lathe/"
+  lathe_write_exclude_once "$exclude_file" ".lathe-task.md"
+}
+
+lathe_write_invocation() {
+  local mode="$1"
+  mkdir -p "$LATHE_TASK_DIR"
+
+  case "$mode" in
+    process)
+      jq -n \
+        --arg command "lathe process" \
+        --arg intent "execute_task" \
+        --arg plan_approval "granted_by_invocation" \
+        --arg delivery "update_pr_head" \
+        '{
+          schema_version: 1,
+          invocation: {
+            command: $command,
+            intent: $intent
+          },
+          injected_dependencies: {
+            plan_approval: {
+              grant: $plan_approval,
+              approver: "lathe process invocation",
+              meaning: "The overseer explicitly requested execution; do not stop solely for human plan approval if the selected workflow can consume this grant."
+            },
+            delivery: {
+              adapter: $delivery,
+              command_template: "git push origin HEAD:<source.head_branch>"
+            }
+          },
+          constraints: {
+            workflow_selection: "harness_owned",
+            human_escalation: "required_when_selected_workflow_cannot_safely_consume_injected_dependencies"
+          }
+        }' > "$LATHE_TASK_DIR/invocation.json"
+      ;;
+    plan)
+      jq -n \
+        --arg command "lathe plan" \
+        --arg intent "plan_only" \
+        '{
+          schema_version: 1,
+          invocation: {
+            command: $command,
+            intent: $intent
+          },
+          injected_dependencies: {},
+          constraints: {
+            workflow_selection: "harness_owned",
+            stop_at_contract_boundary: true,
+            dispatch_subagents: false,
+            edit_task_worktree: false,
+            commit_or_push: false
+          }
+        }' > "$LATHE_TASK_DIR/invocation.json"
+      ;;
+    *)
+      echo "lathe: unknown invocation mode '$mode'" >&2
+      exit 1
+      ;;
+  esac
+}
+
+lathe_task_process_prompt() {
+  printf 'Read .lathe/task.json, .lathe/brief.md, and .lathe/invocation.json from the added task worktree (%s), then process the task according to the target harness protocol. Treat task.json as transport facts only. Treat invocation.json as injected runtime dependencies, not as workflow selection. Select or construct the workflow in the harness. If an existing plan for this task exists, use it if it still matches task.json, brief, invocation dependencies, and the current diff; otherwise create a new plan. The process invocation injects a plan-approval grant and PR delivery adapter; consume those dependencies if the selected workflow supports them. Escalate to the human instead of implementing if the selected workflow cannot safely consume the injected dependencies.' "$TASK_WT"
+}
+
+lathe_task_plan_prompt() {
+  printf 'Read .lathe/task.json, .lathe/brief.md, and .lathe/invocation.json from the added task worktree (%s), then perform planning only according to the target harness protocol. Treat task.json as transport facts only and invocation.json as injected runtime dependencies/constraints. Select or construct the workflow in the harness. Create or update plans/<run_id>.html and stop at the contract/approval boundary. Do not dispatch coder/reviewer, do not edit the task worktree, and do not commit or push.' "$TASK_WT"
+}

package/bin/check-deps.sh

@@ -9,7 +9,7 @@ for cmd in git jq claude bash; do
   command -v "$cmd" >/dev/null 2>&1 || missing_required+=("$cmd")
 done
 
-command -v gh >/dev/null 2>&1 || missing_optional+=("gh (only needed for 'lathe process')")
+command -v gh >/dev/null 2>&1 || missing_optional+=("gh (needed for 'lathe process', 'lathe plan pr', and 'lathe watch')")
 
 if [ "${#missing_required[@]}" -gt 0 ]; then
   echo ""

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
@@ -40,13 +40,18 @@ Daily ops:
   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)
+  process [--manual-prompt|--no-launch] <pr#>
+                   Pick up a GitHub PR for target processing
+                   (creates ./tasks/<pr#>/ worktree, launches target with prompt)
+  plan [--print|--manual-prompt|--no-launch] pr <pr#>
+                   Prepare a task worktree and ask target to write a plan only
+  watch [--once] [--interval <seconds>] [--base develop]
+                   Poll open PRs and run 'lathe plan --print pr <pr#>' for new ones
   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,14 +157,15 @@ 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>/
+  lathe plan pr <pr#>    # have target write a plan for a PR
   lathe process <pr#>    # have target process a PR
   lathe ls               # list worktrees, branches, recent runs
 EOF

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 "$@"