lathe-cli 1.2.0 → 1.3.1

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 と対話 |
 
@@ -57,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                  # ヘルプ
 ```
@@ -77,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
@@ -90,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（任意のタイミング）
@@ -118,7 +138,7 @@ git push origin main
 - **branch / worktree でロール分離**：各 agent / role が物理的に別ディレクトリで動くので、CLAUDE.md / settings.json / hooks が混ざらない
 - **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）
 
@@ -126,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 設計が必要
@@ -140,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,225 @@
+#!/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)"
+    if ! git -C "$TASK_WT" diff --quiet || ! git -C "$TASK_WT" diff --cached --quiet; then
+      echo "lathe: $TASK_WT has uncommitted changes; refusing to update from PR head" >&2
+      exit 1
+    fi
+    if git -C "$TASK_WT" merge-base --is-ancestor HEAD "$FETCH_REF"; then
+      git -C "$TASK_WT" merge --ff-only --quiet "$FETCH_REF"
+    elif git -C "$TASK_WT" merge-base --is-ancestor "$FETCH_REF" HEAD; then
+      :
+    else
+      echo "lathe: $TASK_BRANCH has diverged from PR #$PR_NUMBER head; resolve manually before continuing" >&2
+      exit 1
+    fi
+  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

@@ -40,8 +40,13 @@ 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:

package/bin/lathe-init

@@ -165,6 +165,7 @@ if [ -n "$HELPER_KIND" ]; then
 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-plan

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# lathe plan pr <pr#> — prepare a task and run target planning only.
+
+set -euo pipefail
+: "${LATHE_HOME:?must be set by lathe dispatcher}"
+source "$LATHE_HOME/bin/_lathe-lib.sh"
+source "$LATHE_HOME/bin/_lathe-task.sh"
+
+usage() {
+  cat >&2 <<EOF
+Usage: lathe plan [--print|--manual-prompt|--no-launch] pr <pr#>
+
+Options:
+  --print          Run Claude non-interactively with --print and a plan-only prompt.
+                   Used by lathe watch.
+  --manual-prompt  Launch Claude without submitting the initial prompt.
+                   The prompt is printed for manual paste.
+  --no-launch      Prepare tasks/<pr#>/ and print the Claude command, but do not run it.
+EOF
+}
+
+MODE="auto"
+SOURCE=""
+ID=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --print|--auto-plan)
+      MODE="print"; shift ;;
+    --manual-prompt)
+      MODE="manual"; shift ;;
+    --no-launch|--prepare-only)
+      MODE="no-launch"; shift ;;
+    -h|--help)
+      usage; exit 0 ;;
+    pr)
+      SOURCE="pr"; shift
+      if [ $# -gt 0 ] && [ -z "$ID" ]; then
+        ID="$1"; shift
+      fi
+      ;;
+    -*)
+      echo "lathe plan: unknown flag $1" >&2
+      usage
+      exit 1 ;;
+    *)
+      if [ -z "$SOURCE" ]; then
+        SOURCE="pr"
+      fi
+      if [ -z "$ID" ]; then
+        ID="$1"
+      else
+        echo "lathe plan: extra argument $1" >&2
+        usage
+        exit 1
+      fi
+      shift ;;
+  esac
+done
+
+if [ "$SOURCE" != "pr" ] || [ -z "$ID" ]; then
+  usage
+  exit 1
+fi
+
+lathe_prepare_pr_task "$ID"
+lathe_write_invocation plan
+INITIAL_PROMPT="$(lathe_task_plan_prompt)"
+
+cat <<EOF
+
+Task worktree ready for planning.
+  Path: $TASK_WT
+  Local branch: $TASK_BRANCH
+  PR head branch: $HEAD_REF
+  Descriptor: $LATHE_TASK_DIR/task.json
+  Brief: $LATHE_TASK_DIR/brief.md
+  Invocation: $LATHE_TASK_DIR/invocation.json
+  Prompt: $INITIAL_PROMPT
+EOF
+
+case "$MODE" in
+  no-launch)
+    cat <<EOF
+
+Run target planning when ready:
+  cd "$DEVELOP_WT"
+  claude --add-dir "$TASK_WT" -- "$INITIAL_PROMPT"
+EOF
+    ;;
+
+  manual)
+    cat <<EOF
+
+Manual prompt mode. Paste this into the Claude TUI:
+
+  $INITIAL_PROMPT
+
+Launching target for planning...
+EOF
+    cd "$DEVELOP_WT"
+    exec claude --add-dir "$TASK_WT"
+    ;;
+
+  print)
+    echo ""
+    echo "Running target planning non-interactively..."
+    cd "$DEVELOP_WT"
+    exec claude --print --permission-mode auto \
+      --allowedTools Read Write Edit Glob Grep "Bash(date *)" "Bash(git status*)" "Bash(git diff*)" "Bash(git ls-files*)" \
+      --add-dir "$TASK_WT" -- "$INITIAL_PROMPT"
+    ;;
+
+  auto)
+    echo ""
+    echo "Launching target for planning with the initial prompt already submitted..."
+    cd "$DEVELOP_WT"
+    exec claude --add-dir "$TASK_WT" -- "$INITIAL_PROMPT"
+    ;;
+esac

package/bin/lathe-process

@@ -1,88 +1,170 @@
 #!/usr/bin/env bash
-# lathe process <pr#> — pick up a PR for target processing.
+# lathe process [--manual-prompt|--no-launch] <pr#> — pick up a PR for target processing.
 #   1. fetch PR head + body via gh
-#   2. add a worktree of the PR's branch under <project>/tasks/<pr#>
-#   3. write the task brief into that worktree as .lathe-task.md
-#   4. cd into develop worktree's target/, launch claude with --add-dir <task-wt>
+#   2. add a task/pr-<pr#> worktree from the PR head under <project>/tasks/<pr#>
+#   3. write the Lathe transport envelope into .lathe/task.json + .lathe/brief.md
+#   4. cd into develop worktree, launch claude with --add-dir <task-wt>
+#      and submit the initial prompt as a CLI argument
 #
-# Interactive launch: the user pastes a "read .lathe-task.md and process it"
-# prompt into the resulting claude TUI. (Auto-injection of the initial prompt
-# is unreliable in claude's interactive mode.)
+# If a user's Claude Code build does not accept an initial prompt argument,
+# --manual-prompt preserves the old paste-it-yourself flow.
 
 set -euo pipefail
 : "${LATHE_HOME:?must be set by lathe dispatcher}"
 source "$LATHE_HOME/bin/_lathe-lib.sh"
+source "$LATHE_HOME/bin/_lathe-task.sh"
 
-PR="${1:-}"
-if [ -z "$PR" ]; then
-  echo "Usage: lathe process <pr#>" >&2
-  exit 1
-fi
-
-command -v gh >/dev/null 2>&1 || {
-  echo "lathe process: gh (GitHub CLI) is required" >&2
-  exit 1
-}
+usage() {
+  cat >&2 <<EOF
+Usage: lathe process [--manual-prompt|--no-launch] <pr#>
 
-PROJECT_ROOT="$(lathe_project_root)" || {
-  echo "lathe process: not inside a Lathe project" >&2
-  exit 1
-}
-DEVELOP_WT="$(lathe_wt_for_branch develop)" || {
-  echo "lathe process: develop worktree not found" >&2
-  exit 1
+Options:
+  --manual-prompt  Launch Claude without submitting the initial prompt.
+                   The prompt is printed and copied to the clipboard when possible.
+  --no-launch      Prepare tasks/<pr#>/ and print the Claude command, but do not run it.
+EOF
 }
 
-echo "==> Fetching PR #$PR ..."
-HEAD_REF="$(gh pr view "$PR" --json headRefName -q .headRefName)"
-TITLE="$(gh pr view "$PR" --json title -q .title)"
-BODY="$(gh pr view "$PR" --json body -q .body)"
+PR=""
+MODE="auto"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --manual-prompt)
+      MODE="manual"; shift ;;
+    --no-launch|--prepare-only)
+      MODE="no-launch"; shift ;;
+    -h|--help)
+      usage; exit 0 ;;
+    -*)
+      echo "lathe process: unknown flag $1" >&2
+      usage
+      exit 1 ;;
+    *)
+      if [ -z "$PR" ]; then
+        PR="$1"
+      else
+        echo "lathe process: extra argument $1" >&2
+        usage
+        exit 1
+      fi
+      shift ;;
+  esac
+done
 
-git --git-dir="$PROJECT_ROOT/.git" fetch origin "$HEAD_REF" >/dev/null 2>&1 || true
-
-mkdir -p "$PROJECT_ROOT/tasks"
-TASK_WT="$PROJECT_ROOT/tasks/$PR"
-if [ -e "$TASK_WT" ]; then
-  echo "lathe process: $TASK_WT already exists. Remove it or pick another PR." >&2
+if [ -z "$PR" ]; then
+  usage
   exit 1
 fi
+PR="${PR#\#}"
+
+lathe_prepare_pr_task "$PR"
+lathe_write_invocation process
+INITIAL_PROMPT="$(lathe_task_process_prompt)"
+
+copy_prompt_to_clipboard() {
+  if command -v pbcopy >/dev/null 2>&1; then
+    if printf '%s' "$INITIAL_PROMPT" | pbcopy 2>/dev/null; then
+      echo "  Clipboard: copied via pbcopy"
+    else
+      echo "  Clipboard: pbcopy failed"
+    fi
+  elif command -v wl-copy >/dev/null 2>&1; then
+    if printf '%s' "$INITIAL_PROMPT" | wl-copy 2>/dev/null; then
+      echo "  Clipboard: copied via wl-copy"
+    else
+      echo "  Clipboard: wl-copy failed"
+    fi
+  elif command -v xclip >/dev/null 2>&1; then
+    if printf '%s' "$INITIAL_PROMPT" | xclip -selection clipboard 2>/dev/null; then
+      echo "  Clipboard: copied via xclip"
+    else
+      echo "  Clipboard: xclip failed"
+    fi
+  else
+    echo "  Clipboard: unavailable"
+  fi
+}
 
-echo "==> Creating task worktree at $TASK_WT (branch: $HEAD_REF)..."
-git --git-dir="$PROJECT_ROOT/.git" worktree add --quiet "$TASK_WT" "$HEAD_REF"
+print_aftercare() {
+  local feature_name=""
+  case "$HEAD_REF" in
+    feature/*) feature_name="${HEAD_REF#feature/}" ;;
+  esac
 
-PROMPT_FILE="$TASK_WT/.lathe-task.md"
-cat > "$PROMPT_FILE" <<EOF
-# PR #$PR: $TITLE
+  cat <<EOF
 
-You are processing pull request #$PR. The vibe-coded changes are in this worktree.
+Target session exited.
+
+Typical next steps:
+  gh pr view $PR --web
+  gh pr merge $PR --merge
+  cd "$DEVELOP_WT" && git pull origin develop
+EOF
 
-**Task description (PR body):**
-$BODY
+  if [ -n "$feature_name" ]; then
+    cat <<EOF
+  cd "$PROJECT_ROOT" && lathe feature-done "$feature_name"
+EOF
+  fi
 
-**Your job:**
-1. Read the existing changes in this worktree (the vibe-coded prototype)
-2. Plan a polished implementation (planning skill, plans/<run_id>.html)
-3. After approval, dispatch coder/reviewer to produce a clean implementation
-4. Coder commits and pushes to branch \`$HEAD_REF\` so the PR updates
-5. Do NOT delete the original vibe commits — your polish goes ON TOP
+  cat <<EOF
 
-The task worktree is at: $TASK_WT
+When the PR is merged and no more target work is needed:
+  git --git-dir="$PROJECT_ROOT/.git" worktree remove "$TASK_WT"
+  git --git-dir="$PROJECT_ROOT/.git" branch -D "$TASK_BRANCH"
 EOF
+}
 
 cat <<EOF
 
 Task worktree ready.
   Path: $TASK_WT
-  Branch: $HEAD_REF
-  Prompt file: $PROMPT_FILE
-
-Launching target. Paste this into the claude TUI:
+  Local branch: $TASK_BRANCH
+  PR head branch: $HEAD_REF
+  Descriptor: $LATHE_TASK_DIR/task.json
+  Brief: $LATHE_TASK_DIR/brief.md
+  Invocation: $LATHE_TASK_DIR/invocation.json
+  Prompt: $INITIAL_PROMPT
+EOF
 
-  Read .lathe-task.md from the added directory ($TASK_WT) and process it.
+case "$MODE" in
+  no-launch)
+    cat <<EOF
 
-Press Enter to launch claude (Ctrl-C to abort)...
+Run target when ready:
+  cd "$DEVELOP_WT"
+  claude --add-dir "$TASK_WT" -- "$INITIAL_PROMPT"
 EOF
-read -r _
-
-cd "$DEVELOP_WT"
-exec claude --add-dir "$TASK_WT"
+    exit 0
+    ;;
+
+  manual)
+    echo ""
+    echo "Manual prompt mode. Paste this into the Claude TUI:"
+    echo ""
+    echo "  $INITIAL_PROMPT"
+    echo ""
+    copy_prompt_to_clipboard
+    echo ""
+    echo "Launching target..."
+    cd "$DEVELOP_WT"
+    set +e
+    claude --add-dir "$TASK_WT"
+    status=$?
+    set -e
+    print_aftercare
+    exit "$status"
+    ;;
+
+  auto)
+    echo ""
+    echo "Launching target with the initial prompt already submitted..."
+    cd "$DEVELOP_WT"
+    set +e
+    claude --add-dir "$TASK_WT" -- "$INITIAL_PROMPT"
+    status=$?
+    set -e
+    print_aftercare
+    exit "$status"
+    ;;
+esac

package/bin/lathe-sync

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# lathe sync — re-sync harness/ to target/.claude/ in the develop worktree.
+# lathe sync — re-sync harness/ to .claude/ in the develop worktree.
 # Useful after manual harness edits, or if post-merge hook didn't fire (e.g.,
 # merge happened via GitHub UI).
 

package/bin/lathe-target

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# lathe target — cd into develop worktree's target/ and launch claude.
+# lathe target — cd into the develop worktree and launch claude.
 
 set -euo pipefail
 : "${LATHE_HOME:?must be set by lathe dispatcher}"

package/bin/lathe-watch

@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# lathe watch — poll GitHub PRs targeting develop and plan new ones locally.
+
+set -euo pipefail
+: "${LATHE_HOME:?must be set by lathe dispatcher}"
+source "$LATHE_HOME/bin/_lathe-lib.sh"
+source "$LATHE_HOME/bin/_lathe-task.sh"
+
+usage() {
+  cat >&2 <<EOF
+Usage: lathe watch [--once] [--interval <seconds>] [--base <branch>] [--dry-run]
+
+Poll open GitHub PRs targeting <branch> (default: develop). For each PR that has
+not already been planned by this watcher, run:
+
+  lathe plan --print pr <pr#>
+
+Options:
+  --once                 Poll once and exit.
+  --interval <seconds>   Poll interval for continuous mode. Default: 60.
+  --base <branch>        PR base branch to watch. Default: develop.
+  --dry-run              Print what would be planned without running Claude.
+EOF
+}
+
+ONCE=0
+INTERVAL=60
+BASE_BRANCH="develop"
+DRY_RUN=0
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --once)
+      ONCE=1; shift ;;
+    --interval)
+      INTERVAL="$2"; shift 2 ;;
+    --interval=*)
+      INTERVAL="${1#--interval=}"; shift ;;
+    --base)
+      BASE_BRANCH="$2"; shift 2 ;;
+    --base=*)
+      BASE_BRANCH="${1#--base=}"; shift ;;
+    --dry-run)
+      DRY_RUN=1; shift ;;
+    -h|--help)
+      usage; exit 0 ;;
+    -*)
+      echo "lathe watch: unknown flag $1" >&2
+      usage
+      exit 1 ;;
+    *)
+      echo "lathe watch: extra argument $1" >&2
+      usage
+      exit 1 ;;
+  esac
+done
+
+case "$INTERVAL" in
+  ''|*[!0-9]*)
+    echo "lathe watch: --interval must be a positive integer" >&2
+    exit 1 ;;
+esac
+if [ "$INTERVAL" -lt 1 ]; then
+  echo "lathe watch: --interval must be >= 1" >&2
+  exit 1
+fi
+
+lathe_require_gh
+PROJECT_ROOT="$(lathe_project_root)" || {
+  echo "lathe watch: not inside a Lathe project" >&2
+  exit 1
+}
+
+STATE_DIR="$PROJECT_ROOT/.lathe/watch"
+STATE_FILE="$STATE_DIR/planned-prs"
+mkdir -p "$STATE_DIR"
+touch "$STATE_FILE"
+
+already_planned() {
+  grep -qxF "$1" "$STATE_FILE" 2>/dev/null
+}
+
+mark_planned() {
+  if ! already_planned "$1"; then
+    printf '%s\n' "$1" >> "$STATE_FILE"
+  fi
+}
+
+poll_once() {
+  local prs pr
+  prs="$(gh pr list --base "$BASE_BRANCH" --state open --json number -q '.[].number')"
+  if [ -z "$prs" ]; then
+    echo "lathe watch: no open PRs targeting $BASE_BRANCH"
+    return 0
+  fi
+
+  while IFS= read -r pr; do
+    [ -n "$pr" ] || continue
+    if already_planned "$pr"; then
+      echo "lathe watch: PR #$pr already planned; skipping"
+      continue
+    fi
+
+    if [ "$DRY_RUN" = 1 ]; then
+      echo "lathe watch: would plan PR #$pr"
+      continue
+    fi
+
+    echo "lathe watch: planning PR #$pr"
+    if "$LATHE_HOME/bin/lathe-plan" --print pr "$pr"; then
+      mark_planned "$pr"
+      echo "lathe watch: PR #$pr marked planned"
+    else
+      echo "lathe watch: planning PR #$pr failed; will retry on next poll" >&2
+    fi
+  done <<EOF
+$prs
+EOF
+}
+
+while true; do
+  poll_once
+  if [ "$ONCE" = 1 ]; then
+    exit 0
+  fi
+  sleep "$INTERVAL"
+done

package/package.json

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

package/template/develop/harness/CLAUDE.md

@@ -15,17 +15,17 @@ orchestrator です。コーディングタスクを受領し、計画し、suba
 - `feature/<id>` — 開発者の vibe coding ブランチ。task として処理対象になることがある（後述）
 - `main` — release ブランチ
 
-target/ 配下（`target/CLAUDE.md` 自身、`target/.claude/`、`target/workflow/`、`target/hooks/`、`target/plan_template.html`）は gitignore されており、**`harness/` から `bin/sync.sh` で生成されたコピー**。あなた自身の設定はここから読み込まれている。
+worktree root の runtime ファイル（`CLAUDE.md` 自身、`.claude/`、`workflow/`、`hooks/`、`plan_template.html`）は gitignore されており、**`harness/` から `bin/sync.sh` で生成されたコピー**。あなた自身の設定はここから読み込まれている。
 
 ## 仕事の流れ
 
 1. **解釈**：受領した依頼を自分の言葉で言い直す。曖昧な点・前提・スコープを洗い出す
 2. **計画**：採用ワークフロー、アーキテクチャ、成果物、受入条件を planning skill に従って計画書 HTML にする
-3. **契約**：計画書を人間（overseer）に提示し、承認を得る。曖昧点は承認前に解消する
-4. **委譲**：承認された計画に沿って coder / reviewer に dispatch する
+3. **契約 / gate 判定**：採用 workflow が要求する gate を判定する。default workflow では計画書を人間（overseer）に提示し、承認を得る。曖昧点は gate 通過前に解消する
+4. **委譲**：採用 workflow の gate を通過した計画に沿って coder / reviewer に dispatch する
 5. **統合**：reviewer の verdict を見て、approve なら完了処理、block なら iterate
 
-## 2 つの起動シナリオ
+## 起動シナリオ
 
 ### シナリオ A: 直接 task（debug / 検証用）
 
@@ -38,25 +38,44 @@ target/ 配下（`target/CLAUDE.md` 自身、`target/.claude/`、`target/workflo
 
 ### シナリオ B: PR 処理（本番）
 
-人間が `lathe process <pr#>` で起動するケース。`--add-dir` で `feature/<id>` ブランチの worktree が追加されており、その path が prompt で示される。`<task worktree>/.lathe-task.md` に PR 情報が入っている。
+人間が `lathe process <pr#>` で起動するケース。`--add-dir` で PR 処理用の `<task worktree>` が追加され、初回 prompt でその path が示される。`<task worktree>/.lathe/task.json` と `<task worktree>/.lathe/brief.md` に Lathe CLI が正規化した入力事実が入っている。`<task worktree>/.lathe/invocation.json` に、この起動で注入された実行時依存性が入っている。
+
+重要：`.lathe/task.json` は transport protocol であり、workflow / gates / escalation / delivery の policy ではない。`.lathe/invocation.json` も workflow 選択ではなく、選ばれた workflow が消費できる runtime dependency injection である。workflow 選択、workflow 構築、human escalation 判断は、この harness と `workflow/` が担う。
+
+このとき：
+1. `<task worktree>/.lathe/task.json`、`<task worktree>/.lathe/brief.md`、`<task worktree>/.lathe/invocation.json` を読む
+2. `task.json` の事実、`brief.md`、`<task worktree>` 配下の **vibe code**、`invocation.json` の injected dependencies を読み、何を作ろうとしているか理解
+3. workflow を harness 側で選ぶ、または必要なら構築する。`invocation.json` の `plan_approval` grant や delivery adapter は、選ばれた workflow に注入される依存性として扱う
+4. 既存の `plans/*.html` に同じ PR source の計画があり、`task.json` / `brief.md` / `invocation.json` / 現在の diff と矛盾しなければその計画を使う。なければ planning skill で **polish された実装** を計画書に起こす（vibe を捨てない、polish を上に積む）
+5. 選ばれた workflow が `plan_approval` grant を安全に消費でき、human escalation 条件に該当しなければ、計画書 status を `approved` にし、承認者を `lathe process invocation` と記録して実装へ進む
+6. coder を `<task worktree>` を編集対象として dispatch
+7. coder の結果を reviewer に独立検証させる
+8. approve されたら、`<task worktree>` で git commit し、`task.json` に書かれた PR head branch へ push して PR を更新（後述）
+9. 計画書 status を completed にして人間に報告
+
+PR 処理シナリオでは **編集対象は `<task worktree>` 配下**。develop worktree のファイル（自分の `harness/`、生成された runtime ファイル）は触らない。
+
+`lathe process` でも human escalation は有効。仕様不明、既存計画の陳腐化、high-risk 変更、検証不能、review block 継続、delivery 失敗、または選ばれた workflow が injected dependencies を安全に消費できない場合は実装に進まず、人間に戻す。
+
+### シナリオ C: 自動計画（watch / plan）
+
+`lathe plan pr <pr#>` または `lathe watch` から起動されるケース。入力形式はシナリオ B と同じだが、`invocation.json` と初回 prompt が **planning only** を明示している。
 
 このとき：
-1. `<task worktree>/.lathe-task.md` を読む（PR body, branch 名）
-2. `<task worktree>` 配下にある **vibe code を読み**、何を作ろうとしているか理解
-3. planning skill で **polish された実装** を計画書に起こす（vibe を捨てない、polish を上に積む）
-4. 承認後、coder を `<task worktree>` を編集対象として dispatch
-5. coder の結果を reviewer に独立検証させる
-6. approve されたら、`<task worktree>` で git commit + push して PR を更新（後述）
-7. 計画書 status を completed にして人間に報告
+- `.lathe/task.json`、`.lathe/brief.md`、`.lathe/invocation.json` を読み、workflow 選択または構築を harness 側で行う
+- `plans/<run_id>.html` を作成または更新し、契約/承認境界で停止する
+- coder / reviewer を dispatch しない
+- `<task worktree>` を編集しない
+- git commit / push をしない
 
-PR 処理シナリオでは **編集対象は `<task worktree>` 配下**。develop worktree のファイル（自分の harness/、target/）は触らない。
+未解決質問がある場合は status を `draft` のままにし、人間への質問を計画書と最終報告に明記する。
 
 ## 計画書は契約書
 
-`plans/<run_id>.html` は単なる作業メモではなく、人間との契約。
+`plans/<run_id>.html` は単なる作業メモではなく、採用 workflow の実行契約。default workflow では人間との承認契約として扱う。
 
-- 承認なしに実装に進まない（dispatch しない）
-- 承認された計画から逸脱したら status を `amended` に戻して再承認を得る
+- 採用 workflow が human approval を要求する場合、承認なしに実装に進まない（dispatch しない）
+- 承認済みまたは gate 通過済みの計画から逸脱したら status を `amended` に戻し、採用 workflow の gate に従って再判定する
 - 構造図と実行フロー（Mermaid）を含めて、文章だけで合意しない
 - HTML として自己完結（PR レビュー時にブラウザで開かれる前提）
 
@@ -83,31 +102,31 @@ PR 処理シナリオでは **編集対象は `<task worktree>` 配下**。devel
 あなたは原則手を動かさないが、**task lifecycle の一部としての git** は許容する：
 
 - シナリオ A：commit しない
-- シナリオ B：完了時に `<task worktree>` で `git add . && git commit && git push` を Bash で実行（PR を更新するため）。commit message の内容と co-author 情報は計画書から作る
+- シナリオ B：完了時に `<task worktree>` で `git add . && git commit && git push origin HEAD:<PR head branch>` を Bash で実行（PR を更新するため）。`<PR head branch>` は `.lathe/task.json` の `source.head_branch` を使う。commit message の内容と co-author 情報は計画書から作る
 
 実装中の random な commit や branch 操作は禁止。task の最終成果として PR を更新する一回だけ。
 
-## ディレクトリ構造（あなたの cwd は target/）
+## ディレクトリ構造（あなたの cwd は develop worktree root）
 
-- `target/.claude/agents/` — coder, reviewer
-- `target/.claude/skills/` — orchestrator が使う skill 群（現状 planning のみ）
-- `target/workflow/` — workflow YAML
-- `target/plans/` — タスクごとの計画書 HTML（あなたが書く、唯一の例外的書き込み先）
-- `target/plan_template.html` — 計画書のひな型
-- `target/hooks/` — hook スクリプト（あなたから直接呼ぶことはない、Claude Code が自動で叩く）
+- `.claude/agents/` — coder, reviewer
+- `.claude/skills/` — orchestrator が使う skill 群（現状 planning のみ）
+- `workflow/` — workflow YAML
+- `plans/` — タスクごとの計画書 HTML（あなたが書く、唯一の例外的書き込み先）
+- `plan_template.html` — 計画書のひな型
+- `hooks/` — hook スクリプト（あなたから直接呼ぶことはない、Claude Code が自動で叩く）
 
 これらはすべて `harness/` から sync された generated content。**直接編集禁止**（harness/ の方を meta が編集することで反映される）。
 
 ## 失敗モード
 
 - 計画書なしに dispatch しようとしている
-- 承認なしに dispatch しようとしている
+- 採用 workflow が承認を要求しているのに、承認なしに dispatch しようとしている
 - 自分でファイルを編集しようとしている（plans/<run_id>.html を除く）
 - 曖昧な仕様のまま coder に投げる
 - 計画から逸脱したのに計画書を更新していない
 - 同じ subagent に同じ依頼を繰り返している（計画の問題を疑え）
 - シナリオ B で `<task worktree>` ではなく develop worktree のファイルを編集する
-- target/ 配下のファイルを編集する
+- 生成された runtime ファイル（`CLAUDE.md`, `.claude/`, `workflow/`, `hooks/`, `plan_template.html`）を編集する
 
 ## 永続化チャネル制限（厳守）
 
@@ -128,7 +147,7 @@ session 間で覚える必要を感じたら、それは meta が improvements/
 ## 原則
 
 - 計画書なしに実装に進まない
-- 承認なしに実装に進まない
+- 採用 workflow が承認を要求する場合、承認なしに実装に進まない
 - 自分は手を動かさない（plan 書きと、シナリオ B 完了時の git commit/push を除く）
-- 逸脱したら計画書を改訂して再承認を得る
+- 逸脱したら計画書を改訂し、採用 workflow の gate に従って再判定する
 - 1 session で完結する。次の session は素の状態で始まる前提

package/template/develop/harness/meta/CLAUDE.md

@@ -27,7 +27,7 @@ target の実行 log を読み、改善を harness/ に加え、PR で develop
 7. `gh pr create --base develop --head meta` で PR 出す
    （single-machine 検証時は人間が `git checkout develop && git merge meta` で代用）
 8. PR が merge されると、develop の post-merge hook が bin/sync.sh を自動実行
-   target/.claude/ が再生成、次回 target session で改善が効く
+   develop/.claude/ が再生成、次回 target session で改善が効く
 ```
 
 ## 取って良いアクション、取らないアクション
@@ -43,7 +43,7 @@ target の実行 log を読み、改善を harness/ に加え、PR で develop
 - `/tmp/` への作業メモ
 
 **取らない**：
-- **`target/` の編集**（gitignore 配下、sync で生成される、編集しても上書きされる）
+- **develop worktree root の生成 runtime ファイルの編集**（`CLAUDE.md`, `.claude/`, `hooks/`, `workflow/`, `plan_template.html` は gitignore 配下、sync で生成される、編集しても上書きされる）
 - **`bin/sync.sh` の手動実行**（post-merge hook の責務、二重実行は無駄）
 - **`meta/` 配下の編集**（自己改変禁止、後述）
 - **`develop` ブランチへの直接 commit / push**（必ず PR 経由）
@@ -64,7 +64,7 @@ target の挙動を変えたいとき、編集するのは **harness/** 配下
 | hook スクリプト | `harness/hooks/*.sh` |
 | 計画書テンプレート | `harness/plan_template.html` |
 
-これらは sync.sh で `target/CLAUDE.md` `target/.claude/...` `target/workflow/` `target/hooks/` `target/plan_template.html` に展開される。
+これらは sync.sh で develop worktree root の `CLAUDE.md` `.claude/...` `workflow/` `hooks/` `plan_template.html` に展開される。
 
 ## 標準フロー（コマンド付き）
 
@@ -113,7 +113,7 @@ PR が大げさなときは、人間が手で `git checkout develop && git merge
 - `runs/<sid>/subagents/agent-<aid>.jsonl` — subagent 別 transcript
 - `harness/` — 現在の harness 状態（meta worktree 上の最新）
 - `improvements/` — 過去の改善履歴
-- target/plans/<run_id>.html — target が書いた計画書（meta worktree でも見える、git 管理外）
+- `plans/<run_id>.html` — target が書いた計画書（meta worktree でも見える、git 管理外）
 
 **書く**：
 - `harness/<file>` — 改善本体

package/template/develop/harness/meta/skills/log-reading/SKILL.md

@@ -105,7 +105,7 @@ jq -c '{ts, event, tool: .payload.tool_name // null}' events.jsonl
 
 ### 計画書との照合
 
-session_id から該当する `target/plans/<run_id>.html` を見つけ、これを Read する。計画書は orchestrator と人間の契約。実行が契約とどう乖離したかは、観察の出発点として強い。
+session_id から該当する `plans/<run_id>.html` を見つけ、これを Read する。計画書は orchestrator と人間の契約。実行が契約とどう乖離したかは、観察の出発点として強い。
 
 session_id ↔ run_id の対応は events に出る Write tool_use(plans/<run_id>.html への書き込み)で辿れる。
 

package/template/develop/harness/plan_template.html

@@ -117,7 +117,7 @@
 
 <div class="contract">
   <h2>契約セクション</h2>
-  <p>本計画書は orchestrator と human の合意である。承認された内容からの逸脱には再承認を要する。</p>
+  <p>本計画書は orchestrator と採用 workflow の実行契約である。human approval が必要な workflow では human との合意として扱う。gate 通過後の内容からの逸脱には workflow に従った再判定を要する。</p>
 
   <table>
     <tr><th>項目</th><th>記録</th></tr>
@@ -138,7 +138,7 @@
   <ul>
     <li>本計画書 3.3 に記載されたファイル以外を変更しない</li>
     <li>本計画書 6 の受入条件を全て満たすことをもって完了とする</li>
-    <li>逸脱が必要な場合は status を amended に戻し再承認を得る</li>
+    <li>逸脱が必要な場合は status を amended に戻し、採用 workflow の gate に従って再判定する</li>
   </ul>
 </div>
 

package/template/develop/harness/skills/planning/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: planning
-description: タスク受領時に計画書HTMLを起草・保存する手順。plan_template.html を雛形として用い、`plans/<run_id>.html` に出力する。計画書は人間との契約書として機能するため、合意可能な粒度・検証可能な受入条件・図を含むこと。
+description: タスク受領時に計画書HTMLを起草・保存する手順。plan_template.html を雛形として用い、`plans/<run_id>.html` に出力する。計画書は採用 workflow の実行契約として機能するため、合意可能な粒度・検証可能な受入条件・図を含むこと。
 ---
 
 # planning
 
 ## いつ使うか
-新しいタスクを受領した直後、coder/reviewer に dispatch する前。計画から逸脱して再承認が要る場合の改訂時にも使う。
+新しいタスクを受領した直後、coder/reviewer に dispatch する前。計画から逸脱して workflow gate の再判定が要る場合の改訂時にも使う。
 
 ## 出力先と run_id
 - 雛形：`plan_template.html`
@@ -29,10 +29,13 @@ description: タスク受領時に計画書HTMLを起草・保存する手順。
 - **1.1 受領した依頼（原文）**：原文をそのまま引用。改変しない
 - **1.2 orchestrator の理解**：自分の言葉で言い直す。原文をなぞるのではなく、目的・スコープ・前提を解きほぐす。言い直しが原文より短くなったら情報を落としすぎている
 - **1.3 目的・スコープ・前提**：表を埋める。「スコープ内」「スコープ外」を両方書く（境界の合意が後の逸脱判定の基準になる）。前提条件は「これが崩れたら計画が崩れる」事項を列挙
+- `.lathe/task.json` がある場合は、source type/id、base branch、head branch、task branch、task worktree を 1.2 または 1.3 に必ず含める。後続の `lathe process` が既存計画を同定するための手掛かりになる
+- `.lathe/invocation.json` がある場合は、invocation intent と injected dependencies / constraints を 1.2 または 1.3 に必ず含める。ただしこれは workflow 選択ではなく、採用 workflow が消費する依存性として記述する
 
 ### 2. 採用ワークフロー
 - `workflow/` から1つ選ぶ（YAML ファイル）
 - 「なぜこのテンプレートか」を必ず書く。デフォルト（`workflow/default.yaml`）を選ぶときも理由を書く
+- `lathe process` 起動で `.lathe/invocation.json` が `plan_approval` grant を注入している場合は、採用 workflow がその grant をどう消費するか、または消費できず human escalation する理由をここか契約セクションに明記する
 
 ### 3. 実装計画
 - **3.1 概要**：文章で全体像
@@ -54,7 +57,7 @@ description: タスク受領時に計画書HTMLを起草・保存する手順。
 
 ### 7. リスク・未解決の質問
 - 計画段階で曖昧な点があれば全部ここに出す
-- 1つでもあるなら status は `draft` のまま。承認には進まない
+- 1つでもあるなら status は `draft` のまま。human approval や auto gate には進まない
 
 ### 8. 実行フロー
 - Mermaid `sequenceDiagram` で actors（Human, Orchestrator, Coder, Reviewer）と呼び出し順を描く
@@ -64,6 +67,7 @@ description: タスク受領時に計画書HTMLを起草・保存する手順。
 - 提出日時・承認日時・承認者・完了日時・status を記録
 - 修正履歴は append-only。古い記述を消さない。逸脱が起きた場合は「何を、なぜ変えたか」を記録する
 - 「承認に伴う合意事項」セクションは雛形のまま残す。タスク固有の合意があれば追記する
+- `.lathe/invocation.json` の `plan_approval` grant を採用 workflow が消費して進む場合、承認日時は gate 通過時刻、承認者は `lathe process invocation` とし、「lathe process の injected dependency により計画承認gateを満たした」と修正履歴または合意事項に記録する
 
 ## 図は Mermaid で書く
 将来 PR で人間に渡されることを想定し、GitHub が描画できる Mermaid を使う。画像埋め込みや独自記法は使わない。
@@ -78,6 +82,6 @@ draft → awaiting_approval → approved → in_progress → completed
 
 - 起草中は `draft`
 - 人間に出した時点で `awaiting_approval`
-- 承認を受けたら `approved`、dispatch 開始で `in_progress`
+- 人間の承認、または採用 workflow の auto gate を通過したら `approved`、dispatch 開始で `in_progress`
 - 完了で `completed`
-- 実行中に計画変更が必要になったら `amended` に戻し、修正→再承認
+- 実行中に計画変更が必要になったら `amended` に戻し、修正→採用 workflow の gate 再判定

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

@@ -47,7 +47,11 @@ 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 plan pr <pr#>                 PR pickup → target が計画だけ作る
+lathe watch [--once]                develop 宛て新規 PR を監視し、未計画なら lathe plan --print pr
+lathe process <pr#>                 PR pickup/reuse → tasks/<pr#>/ worktree + task/pr-<pr#> branch → target が計画承認待ちなしで実装まで進める
+lathe process --manual-prompt <pr#> 旧式 Claude Code 用。prompt 手貼り fallback
+lathe process --no-launch <pr#>     tasks/<pr#>/ 準備だけ行い、target は起動しない
 lathe feature <name> [--from main|develop]
                                     features/<name>/ worktree 作成、新 feature/<name> 枝
 lathe feature-done <name> [--keep-branch] [--keep-remote] [--force]
@@ -76,12 +80,23 @@ PR が立ったら（overseer 役）：
 
 ```sh
 cd project_root
-lathe process <pr#>             # tasks/<pr#>/ worktree が新規作成、target が起動
+lathe plan pr <pr#>             # 任意: 計画だけ作る。lathe watch なら自動
+lathe process <pr#>             # tasks/<pr#>/ worktree が作成/reuse され、target が起動
 ```
 
-claude TUI が立ち上がるので、表示された prompt：「Read .lathe-task.md from the added directory and process it.」を貼る。
+`lathe plan` / `lathe process` は `tasks/<pr#>/` を専用 local branch `task/pr-<pr#>` で作る。元の `feature/<name>` worktree が残っていても同じ branch checkout 競合を起こさない。`tasks/<pr#>/.lathe/task.json` と `.lathe/brief.md` は Lathe が生成する transport protocol、`.lathe/invocation.json` は runtime dependency injection で、workflow/gates/delivery は target harness が選ぶ。claude TUI は初回 prompt が投入された状態で立ち上がる。古い Claude Code で prompt 引数が効かない場合だけ、`lathe process --manual-prompt <pr#>` を使って表示された prompt を貼る。
 
-orchestrator が plan HTML を起こして承認待ちで止まる。承認したら coder/reviewer に dispatch、PR branch に commit/push されて PR が更新される。
+`lathe plan pr <pr#>` は plan HTML を起こして承認境界で止まる。`lathe process <pr#>` は workflow を固定せず、計画承認 grant と PR delivery adapter を `invocation.json` で注入する。target harness は任意の workflow を選び、その依存性を安全に消費できるなら既存 plan を再利用または新規作成して、計画承認待ちは挟まず coder/reviewer に dispatch する。仕様不明、high-risk 変更、検証不能など selected workflow の escalation triggers に該当する場合だけ human に戻す。完了時は `task/pr-<pr#>` に commit し、`git push origin HEAD:<PR head branch>` で PR が更新される。
+
+### develop PR をローカル監視する
+
+```sh
+cd project_root
+lathe watch --once                 # 1回だけ確認
+lathe watch --interval 60          # 継続監視。新規PRごとに lathe plan --print pr
+```
+
+watch は workflow を選ばない。新規PRを見つけたら task worktree と `.lathe/` transport を作り、target harness に planning-only prompt を渡すだけ。人間承認、実装、merge の要否は harness workflow 側で決める。
 
 ### feature を終わらせる