@friedbotstudio/create-baseline 0.2.1 → 0.4.0

package/obj/template/.claude/skills/changelog/tests/preview-only_test.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# Fixture-based integration test for AC-012: the changelog actuator's
+# --preview-only mode prints projected next semver + draft fragment to stdout,
+# requires no commit_consent gesture, and writes no files.
+#
+# Pre-implement RED: actuator does not exist; test fails on missing file.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$HERE/../../../.." && pwd)"
+ACTUATOR="$REPO_ROOT/.claude/skills/changelog/changelog.mjs"
+
+PASS=0; FAIL=0; FAILED=()
+
+fail() { echo "  FAIL: $*"; return 1; }
+
+# Build a tempdir project WITHOUT commit_consent (preview must work without it).
+seed_preview_project() {
+  local proj="$1"
+  mkdir -p "$proj/.claude/state"
+  cd "$proj"
+  git init -q
+  git config user.email "test@example.com"
+  git config user.name "Test"
+  git commit --allow-empty -q -m "chore: initial"
+  git tag v0.1.0
+  echo "preview" > thing.txt
+  git add thing.txt
+  git commit -q -m "feat: preview path"
+  # NO commit_consent file.
+  # NO workflow.json — preview must not require one.
+  cat > "$proj/.releaserc.json" <<'EOF'
+{
+  "branches": ["main"],
+  "plugins": [
+    ["@semantic-release/commit-analyzer", { "preset": "angular" }]
+  ]
+}
+EOF
+}
+
+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
+}
+
+# --- AC-012 -------------------------------------------------------------------
+
+test_when_preview_only_flag_then_stdout_projection_no_writes() {
+  local proj; proj="$(mktemp -d)"; trap "rm -rf $proj" RETURN
+  seed_preview_project "$proj"
+  if [ ! -f "$ACTUATOR" ]; then
+    fail "AC-012 actuator not yet at $ACTUATOR — expected pre-implement RED state"
+    return 1
+  fi
+  local out
+  out="$(node "$ACTUATOR" --preview-only --slug demo --project-root "$proj" 2>/tmp/preview-stderr.$$)"
+  local ec=$?
+  if [ "$ec" -ne 0 ]; then
+    fail "AC-012 preview-only must exit 0; got $ec; stderr: $(cat /tmp/preview-stderr.$$)"
+    return 1
+  fi
+  # stdout matches Projected: <semver>.
+  if ! printf '%s' "$out" | grep -qE 'Projected:\s*[0-9]+\.[0-9]+\.[0-9]+'; then
+    fail "AC-012 stdout must contain Projected: <semver>; got: $out"
+    return 1
+  fi
+  # No state file written.
+  if [ -f "$proj/.claude/state/changelog/demo.json" ]; then
+    fail "AC-012 preview-only must NOT write state file"
+    return 1
+  fi
+  # CHANGELOG.md is either absent (we never created one) or unchanged.
+  if [ -f "$proj/CHANGELOG.md" ]; then
+    fail "AC-012 preview-only must NOT create CHANGELOG.md when absent"
+    return 1
+  fi
+}
+
+# --- runner -------------------------------------------------------------------
+
+run test_when_preview_only_flag_then_stdout_projection_no_writes
+
+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/changelog/tests/run.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Aggregate test runner for .claude/skills/changelog/.
+# Invokes each sibling *_test.sh AND any *_test.mjs (node --test) and exits
+# non-zero if any fail.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+FAIL=0
+
+for t in "$HERE"/*_test.sh; do
+  [ -f "$t" ] || continue
+  echo "=== $(basename "$t") ==="
+  bash "$t" || FAIL=$((FAIL+1))
+done
+
+for t in "$HERE"/*_test.mjs; do
+  [ -f "$t" ] || continue
+  echo "=== $(basename "$t") ==="
+  node --test "$t" || FAIL=$((FAIL+1))
+done
+
+if [ "$FAIL" -gt 0 ]; then
+  echo "changelog/tests: $FAIL suite(s) failed"
+  exit 1
+fi
+echo "changelog/tests: all suites passed"
+exit 0

package/obj/template/.claude/skills/changelog/unreleased-writer.mjs

@@ -0,0 +1,155 @@
+// CHANGELOG.md curation under ## [Unreleased].
+//
+// Two exports:
+//   appendUnderUnreleased(changelogPath, entries) — per-commit RMW.
+//   reinsertUnreleasedHeading(changelogPath)       — AC-013 fallback for the
+//     case where @semantic-release/changelog has prepended versioned notes
+//     above the `# Changelog` and `## [Unreleased]` headings. Restores the
+//     canonical order: `# Changelog\n\n## [Unreleased]\n\n<rest>`.
+//
+// File shape we maintain (keepachangelog 1.0.0):
+//
+//   # Changelog
+//
+//   ## [Unreleased]
+//
+//   ### Added
+//   - <entry>
+//
+//   ### Fixed
+//   - <entry>
+//
+//   ## [0.1.0] - 2026-01-01
+//
+//   ...
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+
+const UNRELEASED_HEADING = '## [Unreleased]';
+const CHANGELOG_HEADING = '# Changelog';
+
+const CATEGORY_ORDER = ['Added', 'Changed', 'Deprecated', 'Removed', 'Fixed', 'Security'];
+
+function groupBySection(entries) {
+  const map = new Map();
+  for (const entry of entries) {
+    if (!map.has(entry.section)) map.set(entry.section, []);
+    map.get(entry.section).push(entry);
+  }
+  return map;
+}
+
+function renderUnreleasedBody(entries) {
+  if (entries.length === 0) return '';
+  const grouped = groupBySection(entries);
+  const lines = [];
+  for (const section of CATEGORY_ORDER) {
+    const items = grouped.get(section);
+    if (!items || items.length === 0) continue;
+    lines.push('');
+    lines.push(`### ${section}`);
+    lines.push('');
+    for (const item of items) {
+      const prefix = item.breaking ? '**BREAKING:** ' : '';
+      lines.push(`- ${prefix}${item.body}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+// Split text into { preamble, unreleasedBody, rest } where preamble is
+// everything up to and including the `## [Unreleased]` line, unreleasedBody
+// is the content between that and the next `##` heading, and rest is from
+// the next `##` heading onward.
+function splitAroundUnreleased(text) {
+  const unreleasedIdx = text.indexOf(UNRELEASED_HEADING);
+  if (unreleasedIdx < 0) return null;
+  const afterHeading = text.indexOf('\n', unreleasedIdx);
+  const headingEnd = afterHeading < 0 ? text.length : afterHeading + 1;
+  // Find the next `## ` heading after the Unreleased heading.
+  const restMatch = text.slice(headingEnd).match(/\n## [^\n]+\n/);
+  const restOffset = restMatch ? headingEnd + restMatch.index + 1 : text.length;
+  return {
+    preamble: text.slice(0, headingEnd),
+    unreleasedBody: text.slice(headingEnd, restOffset),
+    rest: text.slice(restOffset),
+  };
+}
+
+function defaultChangelogText() {
+  return `# Changelog\n\n## [Unreleased]\n\n`;
+}
+
+export async function appendUnderUnreleased(changelogPath, entries) {
+  let text;
+  if (existsSync(changelogPath)) {
+    text = await readFile(changelogPath, 'utf8');
+  } else {
+    text = defaultChangelogText();
+  }
+  if (!text.includes(CHANGELOG_HEADING)) {
+    text = `${CHANGELOG_HEADING}\n\n${text}`;
+  }
+  if (!text.includes(UNRELEASED_HEADING)) {
+    text = text.replace(
+      new RegExp(`(${CHANGELOG_HEADING}\\n)`, ''),
+      `$1\n${UNRELEASED_HEADING}\n\n`,
+    );
+  }
+  const parts = splitAroundUnreleased(text);
+  if (!parts) {
+    // Defensive: should be unreachable after the insertions above.
+    throw new Error(`could not locate ${UNRELEASED_HEADING} in ${changelogPath}`);
+  }
+  const body = renderUnreleasedBody(entries);
+  const merged = `${parts.preamble}${body}\n${parts.rest.startsWith('\n') ? parts.rest : '\n' + parts.rest}`;
+  await writeFile(changelogPath, merged, 'utf8');
+}
+
+export async function reinsertUnreleasedHeading(changelogPath) {
+  const text = await readFile(changelogPath, 'utf8');
+  // If the first `##` heading in the file is already `## [Unreleased]`, the
+  // file is structurally correct; do nothing.
+  const firstH2 = text.match(/^## .+$/m);
+  if (firstH2 && firstH2[0].includes('[Unreleased]')) {
+    return;
+  }
+  // Otherwise: find the existing Unreleased heading (which may sit deeper in
+  // the file because @semantic-release/changelog prepended notes above it)
+  // and lift it to the canonical top position.
+  const lines = text.split('\n');
+  // Identify the Unreleased section's start and the next `##` start.
+  let unreleasedStart = -1;
+  let unreleasedEnd = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (unreleasedStart < 0 && lines[i] === UNRELEASED_HEADING) {
+      unreleasedStart = i;
+      continue;
+    }
+    if (unreleasedStart >= 0 && /^## /.test(lines[i])) {
+      unreleasedEnd = i;
+      break;
+    }
+  }
+  if (unreleasedStart < 0) {
+    // No Unreleased heading anywhere; insert a fresh one at the top.
+    const top = `${CHANGELOG_HEADING}\n\n${UNRELEASED_HEADING}\n\n`;
+    await writeFile(changelogPath, top + text, 'utf8');
+    return;
+  }
+  if (unreleasedEnd < 0) unreleasedEnd = lines.length;
+  const unreleasedBlock = lines.slice(unreleasedStart, unreleasedEnd);
+  const without = lines.slice(0, unreleasedStart).concat(lines.slice(unreleasedEnd));
+  // Strip any leading blank lines from the without-block so the result starts
+  // with the `# Changelog` heading (we'll insert one if absent).
+  const withoutText = without.join('\n');
+  const head = withoutText.startsWith(CHANGELOG_HEADING)
+    ? withoutText
+    : `${CHANGELOG_HEADING}\n\n${withoutText.replace(/^\n+/, '')}`;
+  const restored = head.replace(
+    new RegExp(`^(${CHANGELOG_HEADING})\\n\\n?`),
+    `$1\n\n${unreleasedBlock.join('\n')}\n\n`,
+  );
+  await writeFile(changelogPath, restored, 'utf8');
+}

package/obj/template/.claude/skills/changelog/version-preview.mjs

@@ -0,0 +1,124 @@
+// Projected-version preview via semantic-release JS API.
+//
+// Returns { version, type, commits } where commits is the analyzer's list
+// of conventional-parsed commits between the last release tag and HEAD.
+
+import { execFileSync } from 'node:child_process';
+
+// Parse conventional-commit subject lines: type(scope)?: subject  +  breaking-suffix.
+function parseConventional(subject) {
+  const match = subject.match(/^([a-z]+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/i);
+  if (!match) return { type: 'unknown', scope: null, breaking: false, subject };
+  return {
+    type: match[1].toLowerCase(),
+    scope: match[2] || null,
+    breaking: Boolean(match[3]),
+    subject: match[4],
+  };
+}
+
+// List commits between the latest tag and HEAD via plain git (no semantic-release
+// dep needed for the commit list itself; semantic-release is only used for the
+// projected version computation).
+function listCommitsSinceLastTag(cwd) {
+  let lastTag;
+  try {
+    lastTag = execFileSync('git', ['describe', '--tags', '--abbrev=0'], {
+      cwd, encoding: 'utf8',
+    }).trim();
+  } catch {
+    lastTag = null;
+  }
+  const range = lastTag ? `${lastTag}..HEAD` : 'HEAD';
+  let raw;
+  try {
+    raw = execFileSync('git', ['log', range, '--format=%H%x09%s%x09%b%x00'], {
+      cwd, encoding: 'utf8',
+    });
+  } catch {
+    return [];
+  }
+  return raw.split('\0').filter(Boolean).map((entry) => {
+    const [sha, subject, body] = entry.split('\t');
+    const parsed = parseConventional(subject || '');
+    const breakingBody = /^BREAKING CHANGE:/m.test(body || '');
+    return {
+      sha,
+      subject: parsed.subject,
+      body: (body || '').trim(),
+      type: parsed.type,
+      scope: parsed.scope,
+      breaking: parsed.breaking || breakingBody,
+    };
+  });
+}
+
+// Use semantic-release's JS API to compute the next version.
+async function semanticReleaseDryRun(cwd) {
+  const mod = await import('semantic-release');
+  const semanticRelease = mod.default || mod;
+  const noopWritable = { write: () => true, end: () => {} };
+  const result = await semanticRelease(
+    {
+      dryRun: true,
+      ci: false,
+      branches: ['main', 'master'],
+    },
+    {
+      cwd,
+      env: { ...process.env },
+      stdout: noopWritable,
+      stderr: noopWritable,
+    },
+  );
+  if (result && result.nextRelease) {
+    return { version: result.nextRelease.version, type: result.nextRelease.type };
+  }
+  return { version: null, type: null };
+}
+
+// Fallback: derive a projection locally if semantic-release rejects the run
+// (e.g., no .releaserc.json, no remote, no commits since last tag).
+function localProjection(cwd, commits) {
+  let lastTag;
+  try {
+    lastTag = execFileSync('git', ['describe', '--tags', '--abbrev=0'], {
+      cwd, encoding: 'utf8',
+    }).trim();
+  } catch {
+    lastTag = 'v0.0.0';
+  }
+  const baseSemver = lastTag.replace(/^v/, '');
+  const baseParts = baseSemver.split('.').map((s) => parseInt(s, 10) || 0);
+  let bumpType = null;
+  for (const commit of commits) {
+    if (commit.breaking) { bumpType = bumpType === 'major' ? 'major' : 'minor'; continue; }
+    if (commit.type === 'feat') { bumpType = bumpType === 'major' ? 'major' : (bumpType === 'minor' ? 'minor' : 'minor'); continue; }
+    if (commit.type === 'fix' || commit.type === 'perf' || commit.type === 'refactor') {
+      if (!bumpType) bumpType = 'patch';
+    }
+  }
+  if (!bumpType) return { version: baseSemver, type: null };
+  const [maj, min, pat] = baseParts;
+  if (bumpType === 'major') return { version: `${maj + 1}.0.0`, type: 'major' };
+  if (bumpType === 'minor') return { version: `${maj}.${min + 1}.0`, type: 'minor' };
+  return { version: `${maj}.${min}.${pat + 1}`, type: 'patch' };
+}
+
+export async function previewProjectedVersion(cwd) {
+  const commits = listCommitsSinceLastTag(cwd);
+  let projection;
+  try {
+    projection = await semanticReleaseDryRun(cwd);
+    if (!projection.version) {
+      projection = localProjection(cwd, commits);
+    }
+  } catch {
+    projection = localProjection(cwd, commits);
+  }
+  return {
+    version: projection.version || '0.0.0',
+    type: projection.type,
+    commits,
+  };
+}

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: ALL of `archive` AND `memory-flush` AND `changelog` in `completed` (Phase 10.5 archives slug artifacts; Phase 10.6 curates `_pending.md`; Phase 11.5 appends keepachangelog entries under `## [Unreleased]` in `CHANGELOG.md`) AND a valid consent token at `.claude/state/commit_consent` (the Git Commit Guard hook enforces this independently). On any workflow where `memory-flush` or `changelog` is in `exceptions` (e.g. non-git projects auto-except both), this skill SHALL refuse to proceed unless those exceptions are 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. |