@open-agent-toolkit/cli 0.0.70 → 0.1.0

package/assets/docs/provider-sync/manifest-and-drift.md

@@ -28,6 +28,8 @@ Tracks managed mappings so the CLI can:
 
 Install-triggered auto-sync narrows that removal scope further: after `oat tools install <pack>`, the follow-up sync only plans removals for canonical entries from the installed pack. This protects unrelated provider views if the current worktree has stale manifest entries for other packs whose canonical assets are missing locally.
 
+Autonomous worktree bootstrap also treats sync output as setup state. `oat-worktree-bootstrap-auto` checks inherited cleanliness before the all-scope sync run, then commits dirty sync-managed output as `chore: run sync` when needed. The commit is scoped to existing or tracked sync paths (`.oat/sync/manifest.json`, `.claude`, `.cursor`, `.codex`) and reports the result as `sync_commit: pass | fail | skip` in its structured status.
+
 For transformed mappings such as project-scoped rules, the manifest stores hashes for the rendered provider output that was actually written, not the canonical source markdown. This keeps drift detection aligned with the on-disk managed file.
 
 ## Drift states

package/assets/docs/workflows/projects/implementation-execution.md

@@ -75,6 +75,8 @@ oat_plan_parallel_groups: [['p02', 'p03'], ['p04', 'p05']]
 ### How a parallel group runs
 
 1. **Bootstrap worktrees** via `oat-worktree-bootstrap-auto`, one per phase, branch name `{project-name}/{pNN}`.
+   - The bootstrap checks inherited git cleanliness before the all-scope provider sync sweep.
+   - If that sync leaves `.oat/sync/manifest.json` or provider directories dirty, bootstrap commits only existing or tracked sync-managed paths (`.oat/sync/manifest.json`, `.claude`, `.cursor`, `.codex`) as `chore: run sync` and reports `sync_commit: pass | fail | skip`.
    - If any bootstrap fails, cancel successful worktrees and **degrade the entire group** to sequential inline execution.
 2. **Concurrent dispatch** of `oat-phase-implementer` into each worktree (Tier 1 only — Tier 2 cannot run concurrently and also degrades to sequential).
 3. **Wait for terminal verdicts** (`pass` or `failed`) across every phase in the group.

package/assets/docs/workflows/projects/lifecycle.md

@@ -110,7 +110,7 @@ See [Implementation Execution](implementation-execution.md) for the full executi
 
 ### Quick lane diagram
 
-1. `oat-project-quick-start` (adaptive discovery — provide a project name and optional description; if only the name is provided, quick-start asks for the missing description before discovery. Well-understood requests synthesize quickly, exploratory requests invest in solution space exploration)
+1. `oat-project-quick-start` (adaptive discovery — provide a project name and optional description; if only the name is provided, quick-start asks for the missing description before discovery. Well-understood requests synthesize quickly, exploratory requests invest in solution space exploration. Before scaffolding, the skill checks inherited git state and asks whether to commit, proceed, or abort when the worktree is already dirty.)
 2. Decision point: straight to plan, optional lightweight `design.md`, or promote to spec-driven
 3. Implement: `oat-project-implement` (sequential by default; parallel when `oat_plan_parallel_groups` is declared)
 4. `oat-project-review-provide` / `oat-project-pr-final`
@@ -118,7 +118,7 @@ See [Implementation Execution](implementation-execution.md) for the full executi
 
 ### Import lane diagram
 
-1. `oat-project-import-plan`
+1. `oat-project-import-plan` (checks inherited git state before import scaffolding so sync-generated or unrelated dirty files do not silently roll into project bookkeeping)
 2. Implement: `oat-project-implement` (sequential by default; parallel when `oat_plan_parallel_groups` is declared)
 3. `oat-project-review-provide` / `oat-project-pr-final`
 4. Optional `oat-project-promote-spec-driven` to switch project mode to spec-driven lifecycle
@@ -198,6 +198,7 @@ Capture lane progression:
 - Keep `state.md`, `plan.md`, and `implementation.md` synchronized.
 - Stop at configured HiLL checkpoints.
 - Do not move lifecycle forward when required review gates are unresolved.
+- Project entry skills (`oat-project-new`, `oat-project-quick-start`, and `oat-project-import-plan`) surface inherited dirty git state before scaffolding. If the dirty list includes `.oat/sync/manifest.json`, `.claude/`, `.cursor/`, or `.codex/`, the skill calls out that those paths are typically sync output and offers Commit now, Proceed anyway, or Abort.
 
 ## Reducing lifecycle friction with workflow preferences
 

package/assets/public-package-versions.json

@@ -1,6 +1,6 @@
 {
-  "cli": "0.0.70",
-  "docs-config": "0.0.70",
-  "docs-theme": "0.0.70",
-  "docs-transforms": "0.0.70"
+  "cli": "0.1.0",
+  "docs-config": "0.1.0",
+  "docs-theme": "0.1.0",
+  "docs-transforms": "0.1.0"
 }

package/assets/skills/oat-project-import-plan/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-project-import-plan
-version: 1.2.1
+version: 1.3.0
 description: Use when you have an external markdown plan to execute with OAT. Preserves the source plan and normalizes it into canonical plan.md format.
 argument-hint: '<path-to-plan.md> [--provider codex|cursor|claude] [--project <name>]'
 disable-model-invocation: true
@@ -56,15 +56,33 @@ When executing this skill, provide lightweight progress feedback so the user can
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 - Before multi-step work, print step indicators, e.g.:
-  - `[1/5] Resolving project + source plan…`
-  - `[2/5] Preserving imported source…`
-  - `[3/5] Normalizing plan to OAT task structure…`
-  - `[4/5] Updating project metadata + state…`
-  - `[5/5] Refreshing dashboard…`
+  - `[0/6] Checking inherited git state...`
+  - `[1/6] Resolving project + source plan…`
+  - `[2/6] Preserving imported source…`
+  - `[3/6] Normalizing plan to OAT task structure…`
+  - `[4/6] Updating project metadata + state…`
+  - `[5/6] Refreshing dashboard…`
+  - `[6/6] Ensuring implementation tracker…`
 
 ## Process
 
-### Step 0: Resolve Active Project
+### Step 0 (Preflight): Inherited Git State
+
+Before scaffolding, surface the working tree state so unrelated changes don't get carried into the project workflow's bookkeeping commits.
+
+1. Run `git status --porcelain`. If empty, continue silently to the next step.
+2. If non-empty, present the dirty list to the user.
+3. If `.oat/sync/manifest.json` or paths under `.claude/`, `.cursor/`, `.codex/` appear in the list, note: "These are generated by `oat sync` (often by `pnpm run worktree:init` or `oat-worktree-bootstrap-auto`) and are typically safe to commit as `chore: run sync`."
+4. Offer three choices via `AskUserQuestion`:
+   - **Commit now** (recommended when only sync output is dirty) — stage and commit. For sync-only diffs, default the message to `chore: run sync`; otherwise ask the user for the commit message.
+   - **Proceed anyway** — start the project workflow with the dirty state acknowledged.
+   - **Abort** — exit the skill so the user can clean up manually.
+
+> **Tool availability is not the same as interactivity.** If `AskUserQuestion` is unavailable but chat is available, present the three choices as a plain chat message and wait for the user's reply. Only fall back to "Proceed anyway" when `OAT_NON_INTERACTIVE=1` is set or there is no user-response channel at all.
+
+Do not advance past this gate without an explicit choice.
+
+### Step 0.5: Resolve Active Project
 
 ```bash
 PROJECT_PATH=$(oat config get activeProject 2>/dev/null || true)

package/assets/skills/oat-project-new/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: oat-project-new
-version: 1.2.0
+version: 1.3.0
 description: Use when starting a spec-driven OAT project from scratch. Scaffolds a new project under PROJECTS_ROOT and sets it active.
 argument-hint: '<project-name> [--force]'
 disable-model-invocation: true
 user-invocable: true
-allowed-tools: Read, Write, Bash(pnpm:*), Glob, Grep, AskUserQuestion
+allowed-tools: Read, Write, Bash, Glob, Grep, AskUserQuestion
 ---
 
 # New OAT Project
@@ -21,13 +21,30 @@ Create a new OAT project directory, scaffold standard artifacts from `.oat/templ
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 - Before multi-step work, print step indicators, e.g.:
+  - `[0/3] Checking inherited git state...`
   - `[1/3] Validating project name…`
   - `[2/3] Scaffolding project artifacts…`
   - `[3/3] Refreshing dashboard…`
 
 ## Process
 
-### Step 0: Resolve Projects Root
+### Step 0 (Preflight): Inherited Git State
+
+Before scaffolding, surface the working tree state so unrelated changes don't get carried into the project workflow's bookkeeping commits.
+
+1. Run `git status --porcelain`. If empty, continue silently to the next step.
+2. If non-empty, present the dirty list to the user.
+3. If `.oat/sync/manifest.json` or paths under `.claude/`, `.cursor/`, `.codex/` appear in the list, note: "These are generated by `oat sync` (often by `pnpm run worktree:init` or `oat-worktree-bootstrap-auto`) and are typically safe to commit as `chore: run sync`."
+4. Offer three choices via `AskUserQuestion`:
+   - **Commit now** (recommended when only sync output is dirty) — stage and commit. For sync-only diffs, default the message to `chore: run sync`; otherwise ask the user for the commit message.
+   - **Proceed anyway** — start the project workflow with the dirty state acknowledged.
+   - **Abort** — exit the skill so the user can clean up manually.
+
+> **Tool availability is not the same as interactivity.** If `AskUserQuestion` is unavailable but chat is available, present the three choices as a plain chat message and wait for the user's reply. Only fall back to "Proceed anyway" when `OAT_NON_INTERACTIVE=1` is set or there is no user-response channel at all.
+
+Do not advance past this gate without an explicit choice.
+
+### Step 0.5: Resolve Projects Root
 
 Resolve `{PROJECTS_ROOT}` (same order as other OAT skills):
 

package/assets/skills/oat-project-quick-start/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-project-quick-start
-version: 2.0.2
+version: 2.1.0
 description: Use when a task is small enough for quick mode or rapid iteration is preferred. Scaffolds a lightweight OAT project from discovery directly to a runnable plan, with optional brainstorming and lightweight design.
 argument-hint: '<project-name> ["project description"]'
 disable-model-invocation: true
@@ -57,6 +57,7 @@ When executing this skill, provide lightweight progress feedback so the user can
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 - Before multi-step work, print step indicators, e.g.:
+  - `[0/6] Checking inherited git state...`
   - `[1/6] Scaffolding quick-mode project…`
   - `[2/6] Exploring solution space + capturing discovery…`
   - `[3/6] Decision point: design depth…`
@@ -74,7 +75,23 @@ When executing this skill, provide lightweight progress feedback so the user can
 
 ## Process
 
-### Step 0: Resolve Active Project
+### Step 0 (Preflight): Inherited Git State
+
+Before scaffolding, surface the working tree state so unrelated changes don't get carried into the project workflow's bookkeeping commits.
+
+1. Run `git status --porcelain`. If empty, continue silently to the next step.
+2. If non-empty, present the dirty list to the user.
+3. If `.oat/sync/manifest.json` or paths under `.claude/`, `.cursor/`, `.codex/` appear in the list, note: "These are generated by `oat sync` (often by `pnpm run worktree:init` or `oat-worktree-bootstrap-auto`) and are typically safe to commit as `chore: run sync`."
+4. Offer three choices via `AskUserQuestion`:
+   - **Commit now** (recommended when only sync output is dirty) — stage and commit. For sync-only diffs, default the message to `chore: run sync`; otherwise ask the user for the commit message.
+   - **Proceed anyway** — start the project workflow with the dirty state acknowledged.
+   - **Abort** — exit the skill so the user can clean up manually.
+
+> **Tool availability is not the same as interactivity.** If `AskUserQuestion` is unavailable but chat is available, present the three choices as a plain chat message and wait for the user's reply. Only fall back to "Proceed anyway" when `OAT_NON_INTERACTIVE=1` is set or there is no user-response channel at all.
+
+Do not advance past this gate without an explicit choice.
+
+### Step 0.5: Resolve Active Project
 
 ```bash
 PROJECT_PATH=$(oat config get activeProject 2>/dev/null || true)

package/assets/skills/oat-worktree-bootstrap-auto/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-worktree-bootstrap-auto
-version: 1.2.2
+version: 1.3.0
 description: Use when an orchestrator/subagent needs autonomous worktree bootstrap. Non-interactive companion to oat-worktree-bootstrap.
 argument-hint: '<branch-name> [--base <ref>] [--path <root>] [--baseline-policy <strict|allow-failing>]'
 disable-model-invocation: true
@@ -158,9 +158,13 @@ Execute in the target worktree directory:
 pnpm run worktree:init          # install + build + sync
 oat status --scope project
 pnpm test
-git status --porcelain
 ```
 
+Continue to Step 4 for provider directory setup, the `git_clean` baseline
+check, and the all-scope sync. The `git_clean` check must run after provider
+directory creation but before the all-scope sync sweep, so it measures inherited
+worktree state plus setup output rather than the sync sweep's generated output.
+
 Check behavior per baseline policy:
 
 **strict mode:**
@@ -175,21 +179,38 @@ Check behavior per baseline policy:
   - If active project with `implementation.md` exists → append timestamped baseline-failure note.
   - Otherwise → console output only (no fallback file creation).
 
-### Step 4: Create Provider Directories
+### Step 4: Create Provider Directories and Sync
 
-Worktrees do not inherit gitignored provider directories. Create them if missing:
+Worktrees do not inherit gitignored provider directories. Create them if
+missing, run the `git_clean` baseline check, and then run sync:
 
 ```bash
 mkdir -p "{target-path}/.claude/skills"
 mkdir -p "{target-path}/.cursor/rules"
+git status --porcelain
+oat sync --scope all
 ```
 
-Then re-run sync to establish symlinks:
+After sync completes, commit sync-managed output if any scoped path is dirty:
 
 ```bash
-oat sync --scope all
+SYNC_PATHS=(.oat/sync/manifest.json .claude .cursor .codex)
+SYNC_STAGE_PATHS=(existing-or-tracked sync paths)
+git status --porcelain -- "${SYNC_STAGE_PATHS[@]}"
+git add -A -- "${SYNC_STAGE_PATHS[@]}"
+STAGED_SYNC_FILES=(staged sync-managed files from git diff --cached)
+git commit -m "chore: run sync" -- "${STAGED_SYNC_FILES[@]}"
 ```
 
+Use a staged-diff guard so no empty commit is created. After scoped staging,
+derive the concrete staged sync-managed files from
+`git diff --cached --name-only --no-renames -- "${SYNC_STAGE_PATHS[@]}"` and
+commit only those file paths. Do not pass provider directory pathspecs to
+`git commit`, because empty provider directories can make the commit fail. This
+file-list isolation is what keeps `chore: run sync` limited to sync-managed
+paths even if unrelated files were already staged. If no scoped path is dirty,
+or staging produces no diff, report `sync_commit: skip`.
+
 ### Step 5: Return Structured Status
 
 Return a structured status object (for orchestrator consumption):
@@ -207,6 +228,7 @@ checks:
   tests: pass | fail | skip
   git_clean: pass | fail | skip
   provider_sync: pass | fail | skip
+  sync_commit: pass | fail | skip
 warnings: [] # List of warning messages (allow-failing mode)
 error: null # Error message (strict mode failure)
 reason: null # Structured reason on failure (e.g., base-mismatch)
@@ -221,6 +243,8 @@ baseline_policy: strict | allow-failing
 - `success`: All checks passed and Step 2.7 base-resolution verification passed.
 - `warning`: Some checks failed under `allow-failing` policy (Step 2.7 still passed).
 - `error`: A baseline check failed under `strict` policy, or worktree creation failed.
+- `error`: `sync_commit` failed under `strict` policy.
+- `warning`: `sync_commit` failed under `allow-failing` policy.
 - `failed` (with `reason: base-mismatch`): Step 2.7 base-resolution verification failed. Callers should treat this distinctly from a generic baseline error — it is a contract violation, not a flaky check.
 
 ## Error Handling

package/assets/skills/oat-worktree-bootstrap-auto/scripts/bootstrap.sh

@@ -152,11 +152,12 @@ fi
 
 run_check "project_status" oat status --scope project
 run_check "tests" pnpm test
-run_check "git_clean" test -z "$(git status --porcelain)"
 
 # ─── Step 4: Create Provider Directories ────────────────────────────────────
 mkdir -p "$TARGET_PATH/.claude/skills"
 mkdir -p "$TARGET_PATH/.cursor/rules"
+run_check "git_clean" test -z "$(git status --porcelain)"
+
 if oat sync --scope all >/dev/null 2>&1; then
   CHECK_RESULTS["provider_sync"]="pass"
 else
@@ -168,6 +169,46 @@ else
   fi
 fi
 
+# ─── Step 4.5: Commit Sync Output ───────────────────────────────────────────
+SYNC_PATHS=(.oat/sync/manifest.json .claude .cursor .codex)
+SYNC_STAGE_PATHS=()
+for sync_path in "${SYNC_PATHS[@]}"; do
+  if [[ -e "$sync_path" ]] || [[ -n "$(git ls-files -- "$sync_path")" ]]; then
+    SYNC_STAGE_PATHS+=("$sync_path")
+  fi
+done
+
+SYNC_DIRTY=""
+if [[ ${#SYNC_STAGE_PATHS[@]} -gt 0 ]]; then
+  SYNC_DIRTY=$(git status --porcelain -- "${SYNC_STAGE_PATHS[@]}" 2>/dev/null || true)
+fi
+if [[ -n "$SYNC_DIRTY" ]]; then
+  git add -A -- "${SYNC_STAGE_PATHS[@]}" 2>/dev/null || true
+  if ! git diff --cached --quiet -- "${SYNC_STAGE_PATHS[@]}"; then
+    STAGED_SYNC_FILES=()
+    while IFS= read -r -d '' staged_sync_file; do
+      STAGED_SYNC_FILES+=("$staged_sync_file")
+    done < <(git diff --cached --name-only -z --no-renames -- "${SYNC_STAGE_PATHS[@]}")
+
+    if [[ ${#STAGED_SYNC_FILES[@]} -eq 0 ]]; then
+      CHECK_RESULTS["sync_commit"]="skip"
+    elif git commit -m "chore: run sync" -- "${STAGED_SYNC_FILES[@]}" >/dev/null 2>&1; then
+      CHECK_RESULTS["sync_commit"]="pass"
+    else
+      CHECK_RESULTS["sync_commit"]="fail"
+      if [[ "$BASELINE_POLICY" == "strict" ]]; then
+        HAS_ERROR=true
+      else
+        WARNINGS+=("sync_commit: commit failed")
+      fi
+    fi
+  else
+    CHECK_RESULTS["sync_commit"]="skip"
+  fi
+else
+  CHECK_RESULTS["sync_commit"]="skip"
+fi
+
 # ─── Step 5: Return Structured Status ───────────────────────────────────────
 if [[ "$HAS_ERROR" == true ]]; then
   STATUS="error"
@@ -188,6 +229,7 @@ checks:
   tests: ${CHECK_RESULTS[tests]:-skip}
   git_clean: ${CHECK_RESULTS[git_clean]:-skip}
   provider_sync: ${CHECK_RESULTS[provider_sync]:-skip}
+  sync_commit: ${CHECK_RESULTS[sync_commit]:-skip}
 warnings: [$(IFS=','; echo "${WARNINGS[*]:-}")]
 error: ${HAS_ERROR:+baseline check failed under strict policy}
 baseline_policy: $BASELINE_POLICY

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-agent-toolkit/cli",
-  "version": "0.0.70",
+  "version": "0.1.0",
   "private": false,
   "description": "Open Agent Toolkit CLI",
   "homepage": "https://github.com/voxmedia/open-agent-toolkit/tree/main/packages/cli",
@@ -33,7 +33,7 @@
     "ora": "^9.0.0",
     "yaml": "2.8.2",
     "zod": "^3.25.76",
-    "@open-agent-toolkit/control-plane": "0.0.70"
+    "@open-agent-toolkit/control-plane": "0.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",