lathe-cli 1.1.0 → 1.3.0

package/bin/lathe-plan

@@ -0,0 +1,117 @@
+#!/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 --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/target"
-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}"
@@ -10,5 +10,5 @@ DEVELOP_WT="$(lathe_wt_for_branch develop)" || {
   exit 1
 }
 
-cd "$DEVELOP_WT/target"
+cd "$DEVELOP_WT"
 exec claude "$@"

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.1.0",
+  "version": "1.3.0",
   "description": "Agent harness CLI: target/meta git worktrees driven by Claude Code",
   "bin": {
-    "lathe": "./bin/lathe"
+    "lathe": "bin/lathe"
   },
   "files": [
     "bin/",

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