@friedbotstudio/create-baseline 0.2.1 → 0.3.0

package/obj/template/.claude/skills/audit-baseline/audit.sh

@@ -19,6 +19,14 @@ results = []  # (name, status, detail)
 def add(name, status, detail=""):
     results.append((name, status, detail))
 
+def is_valid_preamble(text):
+    if not text.startswith("---"):
+        return False, "missing frontmatter"
+    remainder = text[3:]
+    if "\n---\n" in remainder or remainder.endswith("\n---"):
+        return True, ""
+    return False, "malformed frontmatter: missing closing separator"
+
 # ---------- expected canonical sets (mirror seed.md §4) ----------
 EXPECTED_HOOKS = {
     # Write/Bash boundary guards (17)
@@ -65,12 +73,12 @@ def read_skill_owner(slug):
     m = re.search(r'^owner:\s*(\S+)\s*$', fm.group(1), re.MULTILINE)
     return m.group(1) if m else None
 
-EXPECTED_COMMANDS = {"approve-spec", "approve-swarm", "grant-commit", "init-project"}
+EXPECTED_COMMANDS = {"approve-spec", "approve-swarm", "grant-commit", "grant-push", "init-project"}
 
 EXPECTED_MEMORY_FILES = {
-    # Canonical files (six)
+    # Canonical files (seven)
     "landmarks", "libraries", "decisions", "landmines", "conventions",
-    "pending-questions",
+    "pending-questions", "backlog",
     # Auto-extraction inbox (one); body gitignored, file committed
     "_pending",
     # Cross-session continuity snapshot (one); written by memory_stop &
@@ -128,7 +136,7 @@ agents_dir  = root / ".claude/agents"
 skills_dir  = root / ".claude/skills"
 cmds_dir    = root / ".claude/commands"
 
-disk_hooks    = {p.stem for p in hooks_dir.glob("*.sh")} if hooks_dir.exists() else set()
+disk_hooks    = ({p.stem for p in hooks_dir.glob("*.sh")} | {p.stem for p in hooks_dir.glob("*.mjs")}) if hooks_dir.exists() else set()
 disk_agents   = {p.stem for p in agents_dir.glob("*.md")} if agents_dir.exists() else set()
 disk_skills   = {p.name for p in skills_dir.iterdir() if p.is_dir()} if skills_dir.exists() else set()
 disk_commands = {p.stem for p in cmds_dir.glob("*.md")} if cmds_dir.exists() else set()
@@ -171,7 +179,7 @@ skills_claimed  = find_count(
     r"\b(\d+|twenty-(?:four|five|six|seven|eight|nine)|"
     r"thirty|thirty-(?:one|two|three|four|five|six|seven|eight|nine)|forty)\s+skills?\b")
 gates_claimed   = find_count(r"\b(\d+|three)\s+consent\s+gates?\b")
-cmds_claimed    = 4 if re.search(r"three\s+consent\s+gates?\s*\+\s*one\s+bootstrap", seed, re.IGNORECASE) else None
+cmds_claimed    = 5 if re.search(r"four\s+consent\s+gates?\s*\+\s*one\s+bootstrap", seed, re.IGNORECASE) else None
 
 def check_count(label, claimed, actual):
     if claimed is None:
@@ -295,28 +303,29 @@ else:
         add("memory files present", "FAIL", "; ".join(bits))
     else:
         add("memory files present", "PASS", f"{len(disk_memory)} files")
-    # Each canonical file should have frontmatter (--- ... ---) and at least one entry.
+    # Record count is not an audit signal — a freshly-initialized project
+    # legitimately has zero entries in every canonical file (overlaid from
+    # pristine src/memory/<name>.template.md). Entry count is reported
+    # informationally.
     for name in sorted(EXPECTED_MEMORY_FILES):
         p = mem_dir / f"{name}.md"
         if not p.is_file():
             continue
         text = p.read_text(encoding="utf-8", errors="replace")
-        if not text.startswith("---"):
-            add(f"memory shape: {name}.md", "FAIL", "missing frontmatter")
+        ok, reason = is_valid_preamble(text)
+        if not ok:
+            add(f"memory shape: {name}.md", "FAIL", reason)
             continue
-        # _pending body may be empty; canonical must have at least one entry.
         if name == "_pending":
             add(f"memory shape: {name}.md", "PASS", "")
             continue
-        body = text.split("---", 2)[-1] if text.startswith("---") else text
+        body = text.split("---", 2)[-1]
         # Strip fenced code blocks so example "## <stable key>" lines inside
         # ```markdown ... ``` don't count as entries.
         body_no_fence = re.sub(r"(?ms)^```.*?^```\s*$", "", body)
         entry_count = len(re.findall(r'(?m)^##\s+\S', body_no_fence))
-        if entry_count == 0:
-            add(f"memory shape: {name}.md", "FAIL", "no entries (## headings) in body")
-        else:
-            add(f"memory shape: {name}.md", "PASS", f"{entry_count} entries")
+        detail = f"{entry_count} entries" if entry_count > 0 else "empty (preamble-only)"
+        add(f"memory shape: {name}.md", "PASS", detail)
     # README inside memory/ is a structural expectation
     add("memory README", "PASS" if (mem_dir / "README.md").is_file() else "FAIL",
         "" if (mem_dir / "README.md").is_file() else "missing .claude/memory/README.md")
@@ -419,7 +428,7 @@ else:
         try:
             s_text = src_settings.read_text(encoding="utf-8")
             json.loads(s_text)
-            missing_wired = sorted(h for h in EXPECTED_HOOKS if f"{h}.sh" not in s_text)
+            missing_wired = sorted(h for h in EXPECTED_HOOKS if (f"{h}.sh" not in s_text and f"{h}.mjs" not in s_text))
             if missing_wired:
                 head = missing_wired[:3]
                 tail = f" + {len(missing_wired) - 3} more" if len(missing_wired) > 3 else ""
@@ -502,7 +511,7 @@ else:
     except Exception as e:
         add("settings.json parses", "FAIL", str(e))
     for h in sorted(EXPECTED_HOOKS):
-        if f"{h}.sh" in settings_text:
+        if f"{h}.sh" in settings_text or f"{h}.mjs" in settings_text:
             add(f"hook wired: {h}", "PASS", "")
         else:
             add(f"hook wired: {h}", "FAIL", "not in settings.json")
@@ -535,6 +544,9 @@ else:
         ("swarm.enforced_path_prefixes",        ["swarm", "enforced_path_prefixes"]),
         ("consent.commit_ttl_seconds",          ["consent", "commit_ttl_seconds"]),
         ("consent.gate_marker_ttl_seconds",     ["consent", "gate_marker_ttl_seconds"]),
+        ("consent.push_ttl_seconds",            ["consent", "push_ttl_seconds"]),
+        ("git.protected_branches",              ["git", "protected_branches"]),
+        ("git.branch_pattern",                  ["git", "branch_pattern"]),
         ("additions.agents",                    ["additions", "agents"]),
         ("additions.skills",                    ["additions", "skills"]),
         ("additions.hooks",                     ["additions", "hooks"]),

package/obj/template/.claude/skills/audit-baseline/tests/fixtures/_pending_opener_only.md

@@ -0,0 +1,3 @@
+---
+owners: [memory_stop.sh writes; /memory-flush clears]
+category: auto-extracted candidates awaiting curation

package/obj/template/.claude/skills/audit-baseline/tests/fixtures/preamble_full_empty_body.md

@@ -0,0 +1,4 @@
+---
+owners: [test]
+key: full-preamble-no-entries
+---

package/obj/template/.claude/skills/audit-baseline/tests/fixtures/preamble_full_with_entries.md

@@ -0,0 +1,9 @@
+---
+owners: [test]
+key: full-preamble-one-entry
+---
+
+## sample-entry
+
+- role: synthetic test fixture
+- verified-at: HEAD

package/obj/template/.claude/skills/audit-baseline/tests/fixtures/preamble_no_opener.md

@@ -0,0 +1,3 @@
+# Some content without frontmatter
+
+This file has no `---` opener at all.

package/obj/template/.claude/skills/audit-baseline/tests/fixtures/preamble_opener_only.md

@@ -0,0 +1,3 @@
+---
+owners: [test]
+key: opener-only-no-closer

package/obj/template/.claude/skills/audit-baseline/tests/preamble_check_test.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# Fixture-based integration tests for the audit-baseline preamble validator.
+# Covers the strict-preamble tightening in .claude/skills/audit-baseline/audit.sh.
+#
+# Each test builds a synthetic .claude/memory/ tree under a tempdir (with all
+# 9 expected canonical filenames), substitutes one file with a fixture, then
+# runs audit.sh with CLAUDE_PROJECT_DIR pointed at the tempdir and greps the
+# captured output for the "memory shape: <name>.md" line.
+#
+# The audit will exit non-zero in the stub tree because hook/skill/agent
+# counts won't match — that's expected. We only assert on the specific
+# memory-shape line each test cares about.
+#
+# Not wired into project.json -> test.cmd; run manually during /tdd and
+# /integrate alongside .claude/hooks/tests/memory_session_start_test.sh.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$HERE/../../../.." && pwd)"
+AUDIT="$REPO_ROOT/.claude/skills/audit-baseline/audit.sh"
+FIXTURES="$HERE/fixtures"
+
+PASS=0; FAIL=0; FAILED=()
+
+# --- assertion helpers --------------------------------------------------------
+
+fail() { echo "  FAIL: $*"; return 1; }
+
+# Seed a stub .claude/memory/ tree under $1. The file basename $2 is replaced
+# with the fixture content from $3; the other 8 expected files get a valid
+# synthetic preamble so they don't pollute the audit output we grep against.
+seed_stub_tree() {
+  local root="$1" under_test="$2" fixture_path="$3"
+  mkdir -p "$root/.claude/memory"
+  # README is checked separately by audit.sh; copy the real one so that check
+  # passes and doesn't tangle our grep.
+  cp "$REPO_ROOT/.claude/memory/README.md" "$root/.claude/memory/README.md"
+  local mem_name
+  for mem_name in landmarks libraries decisions landmines conventions \
+                  pending-questions backlog _pending _resume; do
+    if [ "$mem_name" = "$under_test" ]; then
+      cp "$fixture_path" "$root/.claude/memory/${mem_name}.md"
+    else
+      cat > "$root/.claude/memory/${mem_name}.md" <<'EOF'
+---
+owners: [test]
+key: test
+---
+
+# Synthetic valid preamble
+EOF
+    fi
+  done
+}
+
+# Run audit.sh against the stub tree at $1 and print the line matching
+# "memory shape: $2.md" to stdout. Returns 1 if no such line found.
+audit_memory_shape_line() {
+  local root="$1" name="$2"
+  CLAUDE_PROJECT_DIR="$root" bash "$AUDIT" 2>&1 \
+    | grep -E "^memory shape: ${name}\.md[[:space:]]" \
+    | head -1
+}
+
+# Assert that the memory-shape line for $2 in the audit run against $1 has
+# status $3 and a detail matching the extended-regex $4.
+assert_memory_shape() {
+  local root="$1" name="$2" want_status="$3" want_detail_re="$4"
+  local line; line="$(audit_memory_shape_line "$root" "$name")"
+  if [ -z "$line" ]; then
+    fail "no 'memory shape: ${name}.md' line in audit output"
+    return 1
+  fi
+  if ! printf '%s' "$line" | grep -qE "[[:space:]]${want_status}[[:space:]]"; then
+    fail "expected status ${want_status} for ${name}.md; got: ${line}"
+    return 1
+  fi
+  if ! printf '%s' "$line" | grep -qE "${want_detail_re}"; then
+    fail "expected detail matching '${want_detail_re}' for ${name}.md; got: ${line}"
+    return 1
+  fi
+  return 0
+}
+
+run() {
+  local name="$1"
+  echo "RUN  $name"
+  if "$name"; then
+    PASS=$((PASS+1)); echo "PASS $name"
+  else
+    FAIL=$((FAIL+1)); FAILED+=("$name"); echo "FAIL $name"
+  fi
+}
+
+# --- tests --------------------------------------------------------------------
+
+test_when_memory_file_has_opener_only_then_audit_reports_fail() {
+  local tmp; tmp="$(mktemp -d)"; trap "rm -rf $tmp" RETURN
+  seed_stub_tree "$tmp" "landmarks" "$FIXTURES/preamble_opener_only.md"
+  assert_memory_shape "$tmp" "landmarks" "FAIL" \
+    "malformed frontmatter: missing closing separator"
+}
+
+test_when_memory_file_has_no_opener_then_audit_reports_fail() {
+  local tmp; tmp="$(mktemp -d)"; trap "rm -rf $tmp" RETURN
+  seed_stub_tree "$tmp" "libraries" "$FIXTURES/preamble_no_opener.md"
+  assert_memory_shape "$tmp" "libraries" "FAIL" \
+    "missing frontmatter"
+}
+
+test_when_memory_file_has_valid_full_preamble_no_body_then_audit_reports_pass_preamble_only() {
+  local tmp; tmp="$(mktemp -d)"; trap "rm -rf $tmp" RETURN
+  seed_stub_tree "$tmp" "decisions" "$FIXTURES/preamble_full_empty_body.md"
+  assert_memory_shape "$tmp" "decisions" "PASS" \
+    "empty \\(preamble-only\\)"
+}
+
+test_when_memory_file_has_valid_preamble_with_entries_then_audit_reports_pass_with_count() {
+  local tmp; tmp="$(mktemp -d)"; trap "rm -rf $tmp" RETURN
+  seed_stub_tree "$tmp" "landmines" "$FIXTURES/preamble_full_with_entries.md"
+  assert_memory_shape "$tmp" "landmines" "PASS" \
+    "1 entries"
+}
+
+test_when_pending_file_has_opener_only_then_audit_reports_fail() {
+  local tmp; tmp="$(mktemp -d)"; trap "rm -rf $tmp" RETURN
+  seed_stub_tree "$tmp" "_pending" "$FIXTURES/_pending_opener_only.md"
+  assert_memory_shape "$tmp" "_pending" "FAIL" \
+    "malformed frontmatter: missing closing separator"
+}
+
+# --- runner -------------------------------------------------------------------
+
+run test_when_memory_file_has_opener_only_then_audit_reports_fail
+run test_when_memory_file_has_no_opener_then_audit_reports_fail
+run test_when_memory_file_has_valid_full_preamble_no_body_then_audit_reports_pass_preamble_only
+run test_when_memory_file_has_valid_preamble_with_entries_then_audit_reports_pass_with_count
+run test_when_pending_file_has_opener_only_then_audit_reports_fail
+
+echo "----"
+echo "Passed: $PASS  Failed: $FAIL"
+if [ "$FAIL" -gt 0 ]; then
+  echo "Failed tests:"
+  for t in "${FAILED[@]}"; do echo "  - $t"; done
+fi
+exit $((FAIL > 0))

package/obj/template/.claude/skills/chore/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: chore
 owner: baseline
-description: Workflow track for tasks that need no TDD — documentation edits, governance count bumps, vendored-skill content updates, configuration tweaks, formatting, typo fixes, dependency bumps where no project code changes. Skips `/scenario` and `/implement` (no failing test to drive) and runs the work directly. `verify`, `archive`, `/grant-commit`, and `/commit` remain mandatory. `simplify`, `integrate`, and `document` are conditional — required when the diff hits one of the listed triggers, optional otherwise. Chore is a stripped-down pipeline, not a bypass; never silently skip a conditional phase whose triggers apply.
+description: Workflow track for tasks that need no TDD — documentation edits, governance count bumps, vendored-skill content updates, configuration tweaks, formatting, typo fixes, dependency bumps where no project code changes. Skips `/scenario` and `/implement` (no failing test to drive) and runs the work directly. `verify`, `archive`, `memory-flush`, `/grant-commit`, and `/commit` remain mandatory. `simplify`, `integrate`, and `document` are conditional — required when the diff hits one of the listed triggers, optional otherwise. Chore is a stripped-down pipeline, not a bypass; never silently skip a conditional phase whose triggers apply.
 argument-hint: "<one-line description of the chore>"
 ---
 
@@ -44,7 +44,8 @@ The classification rule is: *if there is no failing test that should exist for t
 1. **Edit** — apply the change directly. No `/scenario`, no `/implement` — there is no failing test to drive.
 2. **`verify`** — run the project test command and stamp `.claude/state/last_test_result`. FAIL means stop, surface, and route the user to `/triage` for a proper bugfix track. The verdict is binding (the `verify_pass_guard` hook reads this file).
 3. **`archive`** — empty bundle is fine; `/commit`'s prereq requires `archive` in `completed`.
-4. **`/grant-commit` then `/commit`** — user-required consent + commit. Same as every other workflow.
+4. **`memory-flush`** — Phase 10.6. Empty pending is fine (fast-path runs Step 0 sweeps and short-circuits). `/commit`'s prereq requires `memory-flush` in `completed`.
+5. **`/grant-commit` then `/commit`** — user-required consent + commit. Same as every other workflow.
 
 ### Conditional phases (required when triggers apply, optional otherwise)
 
@@ -81,7 +82,8 @@ If a conditional phase is required, run it **before** `/grant-commit`. If you sk
    - **Required** → invoke the phase skill and append it to `workflow.json → completed`.
    - **Skipped** → record the rationale in your end-of-chore summary; do not append to `completed`.
 6. Invoke `Skill(archive)` — mandatory.
-7. Append `"chore"`, `"archive"`, and any conditional phases that ran to `workflow.json → completed`. Update `updated_at` to the current epoch.
+6.5. Invoke `Skill(memory-flush)` — mandatory (Phase 10.6). Runs Step 0 canonical sweeps and, if `_pending.md` is non-empty, full triage. On empty pending the fast-path returns success in ≤ 3 sweep.py invocations.
+7. Append `"chore"`, `"archive"`, `"memory-flush"`, and any conditional phases that ran to `workflow.json → completed`. Update `updated_at` to the current epoch.
 8. **Marker op FIRST, then write `harness_state`, then emit end-of-chore summary.** On `state: "continue"` (more phases follow, e.g. archive is still pending): `echo "<slug>" > .claude/state/.harness_active` to refresh the active marker, then write `.claude/state/harness_state` with `{state: "continue", slug, reason}`. On `state: "done"` (archive just appended and no further phases remain): `rm -f .claude/state/.harness_active`, then write `harness_state` with `{state: "done", slug, reason}`. The state file carries exactly three keys; no `written_at`, no `tick_count`. Then tell the user:
    - "Chore green."
    - Files changed.

package/obj/template/.claude/skills/commit/SKILL.md

@@ -5,7 +5,7 @@ description: Workflow Phase 11 — Commit Preparation and Execution. Stages and
 argument-hint: "[optional commit message; otherwise drafted from the spec/intake]"
 ---
 
-Prereq: `archive` in `completed` (i.e., Phase 10.5 has moved all slug artifacts to `docs/archive/<date>/<slug>/`) AND a valid consent token at `.claude/state/commit_consent` (the Git Commit Guard hook enforces this independently).
+Prereq: BOTH `archive` AND `memory-flush` in `completed` (Phase 10.5 moved slug artifacts to `docs/archive/<date>/<slug>/`; Phase 10.6 curated `_pending.md` and applied canonical memory writes) AND a valid consent token at `.claude/state/commit_consent` (the Git Commit Guard hook enforces this independently). On any workflow where `memory-flush` is in `exceptions` (rare), this skill SHALL refuse to proceed unless that exception is explicit in `workflow.json`.
 
 **Applicability.** This skill applies only when the project is a git repository. Non-git projects auto-except `commit` at `/triage` time (CLAUDE.md Article IV); the workflow ends after `/archive`.
 
@@ -13,9 +13,10 @@ Steps:
 
 0. **Git-repo precheck.** Run `git rev-parse --is-inside-work-tree 2>/dev/null`. If exit non-zero, exit cleanly with: "Not a git repository — `/commit` is inapplicable. Per CLAUDE.md Article IV, `commit` is auto-excepted on non-git projects; the workflow ended at `/archive`. Persistence outside git is your responsibility." Do not run any subsequent step.
 1. **Archive `workflow.json` itself.** This is the final piece of the archival bundle, held back until now so phase-ordering checks worked up through this point. Read `.claude/state/workflow.json` to get the slug, then move the file into the already-existing archive bundle: `docs/archive/<date>/<slug>/workflow.json`. Use the bundle's `<date>` directory (the one `/archive` created — inspect `docs/archive/` to find the most recent bundle matching the slug).
-2. Verify workflow prereq: `archive` is the final non-commit entry in `completed`; no open consent gates remain.
+2. Verify workflow prereq: memory-flush is the final non-commit entry in `completed`; `archive` is the entry immediately before it; no open consent gates remain.
 3. `git status` + `git diff --stat` to confirm the change set. The diff now includes: production code changes + archive bundle additions + the workflow.json move. Stage named paths explicitly (never `git add -A` / `git add .` — seed.md forbids it).
 4. Draft the commit message from the spec + diff. Conventional-style prefix (`feat:` / `fix:` / `refactor:` / `docs:` / `test:`) followed by a 1-line summary and a short body explaining the WHY. The subject line is a fixed-register one-liner — leave it alone. The body is reviewer-facing prose — pass it through `Skill(humanizer)` before step 5 so AI-writing tells (em-dash overuse, rule of three, inflated verbs, vague attributions) get scrubbed. Keep the brief tight: tell humanizer the register is "factual reviewer-facing commit body — describe the diff faithfully, do not invent rationale, preserve any spec quotes verbatim".
 5. Run `git commit` with the message via HEREDOC. The Git Commit Guard hook will verify consent. If consent is missing/expired, stop and ask the user to run `/grant-commit`.
-6. Do NOT run `git push`, `git commit --amend`, or pass `--no-verify`/`--no-gpg-sign` unless the user explicitly named the operation in their current request.
-7. Append `"commit"` to `completed` — but note this only matters for logs; the workflow.json is now in the archive and the live `.claude/state/workflow.json` no longer exists. Report the commit SHA to the user.
+6. **Stamp source backlog entries (post-commit, only when populated).** Read `workflow.json → source_backlog_keys` BEFORE Step 1 archived the file (or read the archived copy at `docs/archive/<date>/<slug>/workflow.json`). If the array is absent OR empty, skip this step entirely. Otherwise invoke `python3 .claude/skills/memory-flush/sweep.py --mode stamp-closure --memory-dir .claude/memory --backlog-keys <comma-separated keys>`. Parse the JSON report and report `stamped`/`missing`/`already_closed` counts in the terminal message alongside the commit SHA. `sweep.py` is the only writer to `backlog.md`; `commit/SKILL.md` SHALL NOT edit canonical memory files directly. If the stamp invocation fails (filesystem error), surface it but do NOT roll back the commit — the entries can be stamped manually or by the next workflow's `/memory-flush`.
+7. Do NOT run `git push`, `git commit --amend`, or pass `--no-verify`/`--no-gpg-sign` unless the user explicitly named the operation in their current request.
+8. Append `"commit"` to `completed` — but note this only matters for logs; the workflow.json is now in the archive and the live `.claude/state/workflow.json` no longer exists. Report the commit SHA to the user.

package/obj/template/.claude/skills/copywriting/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) coreyhaines31 (https://github.com/coreyhaines31/marketingskills)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/obj/template/.claude/skills/copywriting/NOTICE

@@ -0,0 +1,23 @@
+copywriting
+===========
+
+This skill is vendored from the `copywriting` skill in the `marketingskills`
+collection published by coreyhaines31 and is redistributed here under the
+terms of the MIT License (see LICENSE in this directory).
+
+Upstream:
+  Repository: https://github.com/coreyhaines31/marketingskills
+  Author:     coreyhaines31
+  Skill:      copywriting/
+
+Vendored into:  .claude/skills/copywriting/
+Vendored on:    2026-05-15 (this commit) — prior install date unknown; LICENSE
+                + NOTICE added retroactively as part of the licensing-attribution
+                drift fix in the branch-aware-git-policy workflow.
+
+Local changes:
+  - References to five companion skills (`copy-editing`, `email-sequence`,
+    `popup-cro`, etc.) that do not ship in this baseline are flagged in the
+    SKILL.md body with explicit "do not ship with this baseline" notes.
+  - Frontmatter `owner: baseline` added so the audit-baseline drift check
+    tracks this file as a shipped baseline artifact.

package/obj/template/.claude/skills/copywriting/SKILL.md

@@ -243,7 +243,7 @@ For headlines and CTAs, provide 2-3 options:
 
 ## Related Skills
 
-These five are upstream companion skills (from the `claude-code-setup` plugin family) and **do not ship with this baseline**. Listed for reference only — for the capabilities they describe, ask the user inline or install the plugin separately.
+These five are upstream companion skills from the same source repo as `copywriting` ([`coreyhaines31/marketingskills`](https://github.com/coreyhaines31/marketingskills)) and **do not ship with this baseline**. Listed for reference only — for the capabilities they describe, ask the user inline or vendor them separately following the same MIT terms.
 
 - **copy-editing**: For polishing existing copy (use after your draft)
 - **page-cro**: If page structure/strategy needs work, not just copy

package/obj/template/.claude/skills/design-ui/SKILL.md

@@ -17,7 +17,7 @@ These are not preferences. They are structural commitments locked by spec `docs/
 - **You ALWAYS invoke impeccable.** Every design move goes through `Skill(impeccable, …)`. No exceptions, no shortcuts.
 - **You NEVER pick aesthetic direction.** Register, palette, type scale, motion vocabulary — all decided inside impeccable's subcommands in main context. You decide *which* subcommand to invoke, not *what* design to produce.
 - **You NEVER write product code.** Files under `app/`, `site-src/`, `components/`, `src/` — all flow through impeccable's writing subcommands (`craft`, `polish`, refines, enhances, fixes). You write only thin glue: state JSON, brief snapshots, audit snapshots.
-- **You ALWAYS classify before acting.** A misrouted `task_brief` (development or copy concern) returns immediately with `final_state: "not_a_design_task"` and a pointer to the correct lane. Design tasks proceed; everything else stops at Stage 0.
+- **You ALWAYS classify before acting.** A misrouted `task_brief` returns at Stage 0 with one of two terminal states: **`not_a_design_task`** (when all surfaces classify as a single non-design lane — pure development or pure copy) with a `correct_lane` pointer, OR **`mixed_brief`** (when target_files span ≥ 2 lanes per the per-concern rule in `references/design-vs-development.md`) with a structured `lane_split` array. Design tasks proceed; everything else stops at Stage 0 without invoking impeccable or writing product code.
 
 ## Mandatory first step
 
@@ -47,7 +47,9 @@ Decide which lane this `task_brief` belongs to. The classification rule lives in
 
 Stage 0 evaluates two signals: (1) the intent string against the [`references/intent-table.md`](references/intent-table.md) rows, and (2) the `target_files` extensions as a tie-breaker.
 
-If the classification is anything other than **design**, return immediately:
+If the classification is anything other than **design**, return immediately with one of two misroute terminals.
+
+**Single-lane misroute** (all surfaces classify as pure development OR pure copy):
 
 ```jsonc
 {
@@ -58,7 +60,22 @@ If the classification is anything other than **design**, return immediately:
 }
 ```
 
-design-ui still writes a checkpoint state file even on misroute — the orchestration history is traceable.
+**Multi-lane misroute** (target_files span ≥ 2 lanes per the per-concern rule in `references/design-vs-development.md`):
+
+```jsonc
+{
+  "final_state": "mixed_brief",
+  "lane_split": [
+    { "surface": "<path>", "lane": "design" | "development" | "copy", "reason": "<plain-language>" }
+  ],
+  "reason": "task_brief spans <N> lanes",
+  "state_file": ".claude/state/design/<slug>.json"
+}
+```
+
+When `target_files` span ≥ 2 lanes, Stage 0 returns `mixed_brief` with a `lane_split` array (one entry per surface) instead of `not_a_design_task`. The caller fans out per row; design-ui does NOT execute any lane in this case (no impeccable invocation, no product-code writes). SKILL.md is the canonical source for this contract; `references/design-vs-development.md` mirrors it.
+
+design-ui still writes a checkpoint state file even on misroute — the orchestration history is traceable. See `references/state-machine.md` for the sticky-resume rule that applies to both misroute terminals.
 
 ### Stage 1 — Capture
 
@@ -117,12 +134,13 @@ Return a structured `Report`:
   "slug":              "<the slug>",
   "intent":            "<the intent>",
   "recipe_executed":   ["shape", "craft", "audit", "polish"],
-  "final_state":       "complete" | "needs_human" | "blocked" | "not_a_design_task",
+  "final_state":       "complete" | "needs_human" | "blocked" | "not_a_design_task" | "mixed_brief",
   "files_touched":     ["<path>", ...],
   "verifications":     { "audit_score": "19/20", "p0": 0, "p1": 0 },
   "next_actions":      ["<human-readable>"],
   "state_file":        ".claude/state/design/<slug>.json",
-  "thin_glue_written": ["docs/design/<slug>.brief.md", "docs/design/<slug>.audit.md"]
+  "thin_glue_written": ["docs/design/<slug>.brief.md", "docs/design/<slug>.audit.md"],
+  "lane_split":        [ { "surface": "<path>", "lane": "design" | "development" | "copy", "reason": "<plain-language>" } ]  // present only when final_state == "mixed_brief"
 }
 ```
 

package/obj/template/.claude/skills/design-ui/references/design-vs-development.md

@@ -21,7 +21,7 @@ When a `task_brief` arrives, Stage 0 evaluates **two signals** in order:
    - All paths match `tdd.ui_globs` AND no logic-file extensions → **design**.
    - All paths are logic files (`.ts`, `.js`, `.go`, `.py`, `.rs`, etc., excluding `.tsx` / `.jsx` / `.vue` / `.svelte`) → **development**.
    - All paths are `.md` / `.mdx` and the intent mentions "write", "rewrite", "improve", "draft" → **copy**.
-   - Mixed → return to step 1 with the user surfaced; ask which concern they mean.
+   - Mixed → Stage 0 returns `final_state: "mixed_brief"` with a `lane_split` array (one entry per surface). See `SKILL.md` (canonical) for the return shape.
 
 ## Overlap is normal — same file, three lanes
 
@@ -67,7 +67,11 @@ Backend / data-fetching performance, query optimization, memoization for re-rend
 
 ## Misroute handling
 
-If Stage 0 classifies the intent as **development** or **copy** (not design), `design-ui` immediately returns:
+*`SKILL.md` is the canonical source for Stage 0 misroute prose; this file mirrors it.*
+
+Stage 0 has two misroute terminals.
+
+**Single-lane misroute** — all surfaces classify as one non-design lane (pure development OR pure copy):
 
 ```jsonc
 {
@@ -78,12 +82,29 @@ If Stage 0 classifies the intent as **development** or **copy** (not design), `d
 }
 ```
 
-The caller (a workflow phase or the user) reads `correct_lane` and re-routes. `design-ui` never silently passes a non-design brief through to `impeccable` — that would muddy impeccable's contract.
+The caller reads `correct_lane` and re-routes.
+
+**Multi-lane misroute** — target_files span ≥ 2 lanes:
+
+```jsonc
+{
+  "final_state": "mixed_brief",
+  "lane_split": [
+    { "surface": "<path>", "lane": "design" | "development" | "copy", "reason": "<plain-language>" }
+  ],
+  "reason": "task_brief spans <N> lanes",
+  "state_file": ".claude/state/design/<slug>.json"
+}
+```
+
+The caller reads `lane_split` and fans out per row; see `references/orchestration.md` caller-policy. `design-ui` never silently passes a non-design brief through to `impeccable` — that would muddy impeccable's contract. On a `mixed_brief`, `design-ui` invokes nothing and writes no product code: the structured `lane_split` is the entire response.
 
 ## When in doubt
 
-If the per-concern split is ambiguous *and* both signals (intent string + target_files) fail to resolve, surface to the user with a one-line question:
+Multi-lane briefs (target_files span ≥ 2 lanes) route automatically to `mixed_brief` — Stage 0 returns the structured `lane_split` without asking the user. The interactive-ask path below is reserved for the rarer **single-lane ambiguity** case: the intent matches no row in `references/intent-table.md` AND `target_files` doesn't disambiguate (e.g., a single `.md` file but the intent reads like a design ask, not a copy ask).
+
+In that case, surface to the user with a one-line question:
 
-> "This task seems to span design and development: <intent>. Which concern are you asking about? (a) design — surface, motion, visual a11y; (b) development — behavior, logic, data; (c) both, in sequence — start with `/tdd` for behavior, then this skill for design."
+> "This task is ambiguous within a single lane: <intent>. Which concern are you asking about? (a) design — surface, motion, visual a11y; (b) development — behavior, logic, data; (c) copy — prose rewrite."
 
 Do not guess. The clean separation is what makes the lanes structural.

package/obj/template/.claude/skills/design-ui/references/orchestration.md

@@ -119,3 +119,4 @@ This is the same cap-3 shape as the polish loop, with `critique` as the gating s
 | `needs_human` | Warn and continue. design-ui has surfaced; the user can re-invoke later. /tdd Step 6 does NOT fail. The audit report path goes in /tdd's notes. |
 | `blocked` | Stop /tdd Step 6. Surface the blocker to the user. /tdd's `## 7. Decide on the result` step receives this and decides whether to escalate to a spec change. |
 | `not_a_design_task` | Stage 0 misroute. /tdd surfaces "design-ui returned not_a_design_task — was this design_call mis-classified in the spec?" and stops to reconcile. |
+| `mixed_brief` | Stage 0 multi-lane misroute. Read `lane_split`. For each row: lane=design → re-invoke design-ui with a surface-scoped sub-brief; lane=development → record on `next_actions` and surface to the user; lane=copy → record on `next_actions` and surface to the user. Do NOT auto-invoke `/tdd` or `prose` in this tick — the spec author can split the `## Design calls` row deliberately. /tdd Step 6 surfaces a one-line summary and proceeds. |

package/obj/template/.claude/skills/design-ui/references/state-machine.md

@@ -21,7 +21,7 @@ The first invocation creates the directory if it does not exist (`mkdir -p`). Su
   "step_index":   <int, 0-based; index of the NEXT step to run>,
   "invocations":  [InvocationRecord, ...],
   "verifications": [VerificationRecord, ...],
-  "state":        "in_progress" | "complete" | "needs_human" | "blocked" | "not_a_design_task",
+  "state":        "in_progress" | "complete" | "needs_human" | "blocked" | "not_a_design_task" | "mixed_brief",
   "next_actions": ["<human-readable action>", ...]
 }
 ```
@@ -69,7 +69,7 @@ Every state file MUST carry these fields. Stage 3's checkpoint writes them all o
 | `step_index` | yes | The position to resume from. 0 = nothing run yet; N = N steps completed. |
 | `invocations` | yes | Append-only list. Each step's invocation appears here. |
 | `verifications` | yes | Subset of invocations[] limited to evaluation steps (audit, critique). |
-| `state` | yes | One of the five terminal/transitional states. |
+| `state` | yes | One of the six terminal/transitional states. |
 
 Optional fields:
 - `register`, `updated_at`, `next_actions` — present when the orchestration has produced them; absent before Stage 1 completes the capture.
@@ -77,7 +77,7 @@ Optional fields:
 
 ## Terminal states
 
-The five values of `state` and their meaning:
+The six values of `state` and their meaning:
 
 | State | Meaning | Caller action |
 |---|---|---|
@@ -86,6 +86,7 @@ The five values of `state` and their meaning:
 | `needs_human` | Loop cap fired (3 iterations on audit→polish or critique-driven refine). P1 issues remain unresolved. | Caller decides whether to surface and stop, or warn and continue. Per `/tdd` Step 6 policy: warn and continue. |
 | `blocked` | A gate fired. P0 blockers, register conflict declined, target_files parent missing, malformed state file, user refused recipe. | Caller surfaces the reason and stops the immediate flow. |
 | `not_a_design_task` | Stage 0 classified the intent as development or copy. Set on the first checkpoint write of the orchestration. | Caller routes to `correct_lane` (`/tdd` or `/document`). |
+| `mixed_brief` | Stage 0 classified the task_brief as spanning ≥ 2 lanes (multi-lane misroute). Set on the first checkpoint write of the orchestration; `lane_split` is persisted alongside. | Caller reads `lane_split` and fans out per row; see `references/orchestration.md` caller-policy. |
 
 ## Resume logic
 
@@ -99,6 +100,7 @@ On any `Skill(design-ui, task_brief)` invocation:
    - **Present and `state` is `needs_human`** → caller must signal intent to resume. If `task_brief` is identical to the stored intent and the caller is re-invoking explicitly, restart the loop from `step_index` (which points at the audit that fired the cap). The user is asserting that conditions have changed (e.g., P1 issues were addressed externally) and the loop should re-run.
    - **Present and `state` is `blocked`** → return the existing Report with the blocker reason. User must materially change the input (re-state intent, expand write_set, etc.) before progress.
    - **Present and `state` is `not_a_design_task`** → return the existing Report; the misroute is sticky for this slug.
+   - **Present and `state` is `mixed_brief`** → return the existing Report (including the cached `lane_split`); the misroute is sticky for this slug (mirrors `not_a_design_task`). Delete the state file to re-classify.
    - **Present but malformed JSON** → return `Report { final_state: "blocked", reason: "state file malformed", state_file }`. Do NOT overwrite — preserve for human inspection.
 
 The resume rule: **skip steps prior to `step_index`; start at `step_index`**. Completed steps are never re-run unless the user explicitly requests it (e.g., by deleting the state file and re-invoking).