@soleur/opencode 0.0.0-stage → 3.354.2

package/skills/archive-kb/test/archive-kb-partial-run.test.sh

@@ -0,0 +1,276 @@
+#!/usr/bin/env bash
+# Pins the partial-run warning in archive-kb.sh (#8416).
+#
+# The gap: `discover_artifacts` derives ONE slug per run, and a feature's plan
+# and spec routinely carry different slugs. The unmatched class is then silently
+# absent while the run prints `Archived N artifact(s)` and exits 0. SKILL.md had
+# documented that in prose since it was first hit; it was hit again on #8325,
+# which is what makes a committed harness the fix rather than more prose
+# (`wg-when-a-workflow-gap-causes-a-mistake-fix`).
+#
+# Coverage is by STATE, not by count: all four plan/spec combinations run, so the
+# suite sees over-warning (the two silent states) as well as under-warning. A
+# suite carrying only the two must-warn states could not distinguish this guard
+# from one that warns unconditionally.
+set -uo pipefail
+
+SUT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../scripts" && pwd)/archive-kb.sh"
+[[ -x "$SUT" ]] || { printf 'FATAL: SUT not executable at %s\n' "$SUT" >&2; exit 2; }
+
+# Copied byte-identical from plugins/soleur/test/test-helpers.sh (not sourced:
+# this suite lives outside that tree). plugins/soleur/test/fixture-dir-operand-assert.test.sh
+# compares every copy.
+assert_fixture_dir() {
+  case "${1-}" in
+    "") printf 'FATAL: fixture dir is EMPTY; git -C "" would operate on %s\n' "$PWD" >&2; exit 2 ;;
+    */../*|*/..) printf 'FATAL: fixture dir %s contains ..; refusing\n' "$1" >&2; exit 2 ;;
+    /proc/*|/sys/*|/dev/*) printf 'FATAL: fixture dir %s is a synthetic-fs path; refusing\n' "$1" >&2; exit 2 ;;
+    /|//|/.) printf 'FATAL: fixture dir resolves to the filesystem root; refusing\n' >&2; exit 2 ;;
+    /*) : ;;
+    *)  printf 'FATAL: fixture dir %s is RELATIVE; refusing\n' "$1" >&2; exit 2 ;;
+  esac
+}
+
+# `cases` is incremented at every CALL SITE, never inside pass()/fail(). That is
+# what keeps the conservation identity below non-tautological: a verdict helper
+# rewritten to always-pass, or one whose counter is redirected, still leaves
+# `cases` where the call sites put it, so `PASS + FAIL == cases` breaks. A counter
+# incremented inside the helpers would move with them and prove nothing.
+PASS=0; FAIL=0; cases=0
+pass() { PASS=$((PASS + 1)); printf '  [ok] %s\n' "$1"; }
+fail() { FAIL=$((FAIL + 1)); printf '  [FAIL] %s\n' "$1"; }
+
+# Instrument self-test: drive BOTH verdict helpers once, require each counter to
+# move, then unwind. Reported via printf + exit, never through the helpers under
+# test. Runs before any real row (ADR-193).
+_p0=$PASS; _f0=$FAIL
+pass "instrument self-test (pass arm)" >/dev/null
+fail "instrument self-test (fail arm) — expected, unwound" >/dev/null
+[[ $PASS -eq $((_p0 + 1)) && $FAIL -eq $((_f0 + 1)) ]] || {
+  printf '[FATAL] verdict helpers do not both record; the suite cannot report.\n' >&2; exit 2; }
+PASS=$_p0; FAIL=$_f0
+
+ROOT="$(mktemp -d -p "${TMPDIR:-/var/tmp}" archive-kb-partial.XXXXXXXX)"
+trap 'rm -rf "$ROOT"' EXIT
+assert_fixture_dir "$ROOT"
+
+# `want` is the expected warning count, so each row asserts a DIRECTION rather
+# than merely that something was printed.
+run_case() {
+  local name="$1" mkplan="$2" mkspec="$3" want="$4"
+  local d="$ROOT/$name"
+  mkdir -p "$d/knowledge-base/project/plans" "$d/knowledge-base/project/specs"
+  assert_fixture_dir "$d"
+  git -C "$d" init -q
+  git -C "$d" config user.email t@example.invalid
+  git -C "$d" config user.name t
+  [[ "$mkplan" == yes ]] && printf 'x\n' > "$d/knowledge-base/project/plans/2026-01-01-feat-demo-plan.md"
+  if [[ "$mkspec" == yes ]]; then
+    mkdir -p "$d/knowledge-base/project/specs/feat-demo"
+    printf 'x\n' > "$d/knowledge-base/project/specs/feat-demo/tasks.md"
+  fi
+  local out rc got
+  out="$( cd "$d" && bash "$SUT" --dry-run demo 2>&1 )"; rc=$?
+  got="$(printf '%s' "$out" | grep -c 'WARNING: found a' || true)"
+  cases=$((cases + 1))
+  if [[ "$rc" -eq 0 && "$got" -eq "$want" ]]; then
+    pass "$name: rc=0, warnings=$want"
+  else
+    fail "$name: rc=$rc warnings=$got (want $want) out='$out'"
+  fi
+}
+
+run_case both      yes yes 0   # both classes present — must stay silent
+run_case plan-only yes no  1   # spec missing
+run_case spec-only no  yes 1   # the #8325 shape: plan named for its topic, not the branch
+run_case neither   no  no  0   # nothing discovered — the pre-existing message, not a warning
+
+# The warning must NAME the absent class, or it cannot tell the operator which
+# slug to re-run with. Anchored on the emitted sentence, not a bare token.
+d="$ROOT/spec-only"
+out="$( cd "$d" && bash "$SUT" --dry-run demo 2>&1 )"
+cases=$((cases + 1))
+if printf '%s' "$out" | grep -c >/dev/null 'but NO plan\.'; then
+  pass "spec-only warning names the missing class (plan)"
+else
+  fail "spec-only warning does not name the missing class: '$out'"
+fi
+d="$ROOT/plan-only"
+out="$( cd "$d" && bash "$SUT" --dry-run demo 2>&1 )"
+cases=$((cases + 1))
+if printf '%s' "$out" | grep -c >/dev/null 'but NO spec\.'; then
+  pass "plan-only warning names the missing class (spec)"
+else
+  fail "plan-only warning does not name the missing class: '$out'"
+fi
+
+# Anchor pin (#9091 review): the stamp this script mints at TIMESTAMP
+# (date +%Y%m%d-%H%M%S) is the FORMAT REFERENCE every worktree-manager reap
+# assertion cites, yet until this row nothing pinned the produced name — a
+# revert of the literal to the dashed form would have reintroduced the exact
+# divergence class of #9091 with every guard green. A real (non-dry) run is
+# required: --dry-run prints paths but writes nothing.
+d="$ROOT/stamp"
+mkdir -p "$d/knowledge-base/project/plans"
+assert_fixture_dir "$d"
+git -C "$d" init -q
+git -C "$d" config user.email t@example.invalid
+git -C "$d" config user.name t
+printf 'x\n' > "$d/knowledge-base/project/plans/2026-01-01-feat-demo-plan.md"
+out="$( cd "$d" && bash "$SUT" demo 2>&1 )"; rc=$?
+entry=""
+for f in "$d/knowledge-base/project/plans/archive/"*; do
+  [[ -f "$f" ]] || continue
+  entry="$(basename "$f")"
+done
+cases=$((cases + 1))
+if [[ "$rc" -eq 0 && -n "$entry" \
+      && "$entry" =~ ^[0-9]{8}-[0-9]{6}-2026-01-01-feat-demo-plan\.md$ ]]; then
+  pass "stamp: produced plans/archive basename carries the compact YYYYMMDD-HHMMSS stamp"
+else
+  fail "stamp: rc=$rc produced entry missing or not compact (got: '${entry:-<none>}') out='$out'"
+fi
+
+# --- Branch-diff axis (#9803): fixtures need origin/main + a real merge-base ---
+# Exercises the three shapes the slug axis cannot reach: a topic-named plan
+# (glob miss), a spec dir whose name isn't feat-<slug> (probe miss), and the
+# specs collapse emitting the DIRECTORY (the cut bug archived `knowledge-base`
+# itself — the regression the collapse row pins).
+
+d="$ROOT/diff-axis"
+mkdir -p "$d/knowledge-base/project/plans" "$d/knowledge-base/project/specs"
+assert_fixture_dir "$d"
+git -C "$d" init -q -b main
+git -C "$d" config user.email t@example.invalid
+git -C "$d" config user.name t
+# a main-side commit carrying an already-archived artifact — must NOT be seen
+mkdir -p "$d/knowledge-base/project/specs/archive/20260101-000000-feat-old" \
+         "$d/knowledge-base/project/plans/archive"
+printf 'old\n' > "$d/knowledge-base/project/specs/archive/20260101-000000-feat-old/tasks.md"
+git -C "$d" add -A && git -C "$d" commit -qm base
+# bare "origin/main" ref — merge-base resolution, no network
+git -C "$d" branch -f origin/main 2>/dev/null || git -C "$d" update-ref refs/remotes/origin/main main
+git -C "$d" update-ref refs/remotes/origin/main main
+git -C "$d" checkout -qb feat-mything
+# branch-side adds: a TOPIC-named plan (slug glob can't see it) and a spec dir
+printf 'plan\n' > "$d/knowledge-base/project/plans/2026-01-02-topic-named-plan.md"
+mkdir -p "$d/knowledge-base/project/specs/fix-mything"
+printf 'tasks\n' > "$d/knowledge-base/project/specs/fix-mything/tasks.md"
+git -C "$d" add -A && git -C "$d" commit -qm work
+
+out="$( cd "$d" && bash "$SUT" --dry-run mything 2>&1 )"; rc=$?
+cases=$((cases + 1))
+if [[ "$rc" -eq 0 ]] \
+  && grep -q 'plans/archive/.*-2026-01-02-topic-named-plan.md' <<<"$out" \
+  && grep -q 'specs/archive/.*-fix-mything' <<<"$out"; then
+  pass "diff-axis: topic-named plan + non-feat spec dir discovered"
+else
+  fail "diff-axis discovery missed: rc=$rc out='$out'"
+fi
+
+# The collapse must emit the spec DIR, never a truncated prefix — the bug
+# archived the literal path `knowledge-base` (whole-tree git mv). Pin both
+# directions: dir present in output, bare `knowledge-base` artifact absent.
+cases=$((cases + 1))
+if grep -q 'knowledge-base/project/specs/archive/.*-fix-mything$' <<<"$out" \
+  && ! grep -qE '(^| )archive/.*-knowledge-base$' <<<"$out"; then
+  pass "diff-axis: specs collapse emits the dir, not the tree root"
+else
+  fail "diff-axis collapse emitted a wrong artifact: '$out'"
+fi
+
+# An M row on a SIBLING feature's spec dir must NOT collapse it — mid-flight
+# work is not this branch's to archive.
+d="$ROOT/diff-axis-mrow"
+mkdir -p "$d/knowledge-base/project/specs"
+assert_fixture_dir "$d"
+git -C "$d" init -q -b main
+git -C "$d" config user.email t@example.invalid
+git -C "$d" config user.name t
+mkdir -p "$d/knowledge-base/project/specs/feat-sibling"
+printf 'sibling tasks\n' > "$d/knowledge-base/project/specs/feat-sibling/tasks.md"
+git -C "$d" add -A && git -C "$d" commit -qm base
+git -C "$d" update-ref refs/remotes/origin/main main
+git -C "$d" checkout -qb feat-other
+printf 'edited\n' >> "$d/knowledge-base/project/specs/feat-sibling/tasks.md"   # M row
+mkdir -p "$d/knowledge-base/project/plans"
+printf 'mine\n' > "$d/knowledge-base/project/plans/feat-other-plan.md"
+git -C "$d" add -A && git -C "$d" commit -qm work
+
+out="$( cd "$d" && bash "$SUT" --dry-run other 2>&1 )"; rc=$?
+cases=$((cases + 1))
+if [[ "$rc" -eq 0 ]] \
+  && grep -q 'plans/archive/.*-feat-other-plan.md' <<<"$out" \
+  && ! grep -q 'feat-sibling' <<<"$out"; then
+  pass "diff-axis: M row on a sibling spec dir does NOT collapse it"
+else
+  fail "diff-axis M-row over-collection: rc=$rc out='$out'"
+fi
+
+# --- Untracked axis (#7383 residual): `??` rows union in ---------------------
+# An UNCOMMITTED artifact is invisible to both prior axes — no guaranteed
+# filename match, no commit provenance. Only `git status --porcelain` `??` rows
+# see it. The same row asserts the two negative controls: a lone ROOT-LEVEL
+# specs file must not collapse (there is no dir to collapse to), and a staged
+# `A ` row must not leak through the `??`-only filter — tracked-file state is
+# branch-diff's axis.
+d="$ROOT/untracked-axis"
+mkdir -p "$d/knowledge-base/project/plans" "$d/knowledge-base/project/specs"
+assert_fixture_dir "$d"
+git -C "$d" init -q -b main
+git -C "$d" config user.email t@example.invalid
+git -C "$d" config user.name t
+printf 'base\n' > "$d/README.md"
+mkdir -p "$d/knowledge-base/project/specs/feat-tracked"
+printf 'tracked\n' > "$d/knowledge-base/project/specs/feat-tracked/tasks.md"
+git -C "$d" add -A && git -C "$d" commit -qm base
+git -C "$d" update-ref refs/remotes/origin/main main
+git -C "$d" checkout -qb feat-probe
+mkdir -p "$d/knowledge-base/project/specs/tmp-untracked-probe"
+printf 'spec\n' > "$d/knowledge-base/project/specs/tmp-untracked-probe/spec.md"
+printf 'plan\n' > "$d/knowledge-base/project/plans/9999-99-99-zz-probe-topic-plan.md"
+printf 'root\n' > "$d/knowledge-base/project/specs/probe-root-file.md"   # lone root file — must NOT fire
+mkdir -p "$d/knowledge-base/project/specs/feat-staged"
+printf 'staged\n' > "$d/knowledge-base/project/specs/feat-staged/tasks.md"
+git -C "$d" add "$d/knowledge-base/project/specs/feat-staged"            # `A ` row — must NOT fire
+printf 'edit\n' >> "$d/knowledge-base/project/specs/feat-tracked/tasks.md" # ` M` row — must NOT fire
+
+out="$( cd "$d" && bash "$SUT" --dry-run probe 2>&1 )"; rc=$?
+cases=$((cases + 1))
+if [[ "$rc" -eq 0 ]] \
+  && grep -q 'specs/archive/.*-tmp-untracked-probe$' <<<"$out" \
+  && grep -q 'plans/archive/.*-9999-99-99-zz-probe-topic-plan\.md' <<<"$out" \
+  && ! grep -q 'probe-root-file' <<<"$out" \
+  && ! grep -q 'feat-staged' <<<"$out" \
+  && ! grep -q 'feat-tracked' <<<"$out"; then
+  pass "untracked-axis: ?? rows find uncommitted spec dir + topic plan; root file + staged/modified rows do not fire"
+else
+  fail "untracked-axis discovery wrong: rc=$rc out='$out'"
+fi
+
+# An untracked SLUG-named file is reachable by two axes (slug glob + `??`) —
+# the union must still emit it exactly once.
+printf 'p\n' > "$d/knowledge-base/project/plans/2026-01-03-feat-probe-plan.md"
+out="$( cd "$d" && bash "$SUT" --dry-run probe 2>&1 )"
+cases=$((cases + 1))
+if [[ "$(grep -c 'feat-probe-plan' <<<"$out")" -eq 1 ]]; then
+  pass "untracked-axis: slug+?? double-hit dedupes to a single row"
+else
+  fail "untracked-axis dedupe emitted a dup or none: '$out'"
+fi
+
+# Conservation first, then the floor. Both emitted by printf + exit 1 and never
+# routed through the pass()/fail() they backstop (ADR-193) — a floor dispatched
+# through the helper it protects is disarmed by the same one-line edit.
+if [[ $((PASS + FAIL)) -ne "$cases" ]]; then
+  printf '[FATAL] accounting conservation: %s + %s != %s\n' "$PASS" "$FAIL" "$cases" >&2
+  exit 1
+fi
+MIN_ASSERTIONS=7
+if [[ "$cases" -lt "$MIN_ASSERTIONS" ]]; then
+  printf '[FATAL] anti-vacuity floor: only %s case(s) ran, floor is %s\n' "$cases" "$MIN_ASSERTIONS" >&2
+  exit 1
+fi
+
+printf '%s passed, %s failed (%s cases)\n' "$PASS" "$FAIL" "$cases"
+[[ "$FAIL" -eq 0 ]] || exit 1

package/skills/atdd-developer/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: atdd-developer
+description: "This skill should be used when implementing features using Acceptance Test Driven Development. It guides through the RED/GREEN/REFACTOR cycle with explicit permission gates between phases."
+---
+
+<!-- soleur-cloud-mode:start -->
+**Cloud Mode (Devin):** before pipeline work run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/cloud-detect.sh"`. If `CLAUDE_PLUGIN_ROOT` is unset (cloud exec shells do not export it), resolve the root by IDENTITY, never by script basename: for `d` in `"$HOME/.local/share/devin/cli/plugins/cache"` and `/opt/.devin/plugins`, skip unless `[ -d "$d" ]`, then `MANIFEST="$(find "$d" -path '*/.claude-plugin/plugin.json' -exec grep -l '"name"[[:space:]]*:[[:space:]]*"soleur"' {} + 2>/dev/null | head -1)"`, `ROOT="${MANIFEST%/.claude-plugin/plugin.json}"` — one resolution, two consumers: `$ROOT/scripts/cloud-detect.sh` and `$ROOT/scripts/precommit-guard.sh`. (Shape check, not authentication: a planted `{"name":"soleur"}` dir passes — ADR-179 A11.) `local` or `not-local:no-devin-env` proceeds normally; any other `not-local:<reason>` applies `<plugin-root>/devin/INSTRUCTIONS.md` §Cloud Mode: emit the `--banner`, fan out sequentially with `Reviewed-Coverage: sequential-fallback` disclosure (never claim an independent review ran), `message_user` ack before any secrets read or production mutation, and run `precommit-guard.sh` before any `git commit` — hooks do not fire in cloud.
+<!-- soleur-cloud-mode:end -->
+
+<!-- grok-harness-invoke:start -->
+**Grok Build (`plugins/soleur/lib/harness.ts` `invokeSkill()`):** Read this SKILL.md in this process and run it to completion. A one-segment `soleur:<name>` in this document names a SKILL — on Grok Build, Read `plugins/soleur/skills/<name>/SKILL.md` in this process; it is not a nested tool_use. A multi-segment id such as `soleur:<domain>:<name>` names an AGENT: spawn it, never Read it, and on Grok Build spawn_subagent takes the id with its colons replaced by hyphens (`agentIdToGrokSubagentType`). **Claude Code:** Skill tool for a skill (`soleur:<name>`), Task tool with `subagent_type` for an agent. Forbidden is executing a subset, not the Read.
+<!-- grok-harness-invoke:end -->
+
+# ATDD Developer
+
+Guide feature implementation through the Acceptance Test Driven Development cycle. Each phase requires explicit user approval before proceeding.
+
+## When to Use
+
+- Implementing a new feature with acceptance criteria
+- Practicing test-driven development on user stories
+- Teaching or reinforcing TDD discipline
+
+## The Cycle
+
+### RED Phase: Write Failing Acceptance Tests
+
+1. Read the user story or feature requirements
+2. Write acceptance tests in Given/When/Then format
+3. Run the tests -- confirm they fail
+4. **STOP and ask permission to proceed to GREEN**
+
+Do not write any implementation code during this phase.
+
+### GREEN Phase: Minimal Implementation
+
+1. Write the minimum code to make the acceptance tests pass
+2. Run the tests -- confirm they pass
+3. Do not refactor, optimize, or add extra code
+4. **STOP and ask permission to proceed to REFACTOR**
+
+The goal is passing tests, not beautiful code. Resist the urge to clean up.
+
+### REFACTOR Phase: Improve the Code
+
+1. Apply refactoring techniques while keeping all tests green
+2. Use soleur:engineering:review:code-simplicity-reviewer or soleur:engineering:review:code-quality-analyst via Task tool for guidance if needed
+3. Run the full test suite after each refactoring step
+4. **STOP and ask permission to proceed to COMMIT**
+
+If any test fails during refactoring, undo the last change immediately.
+
+### COMMIT Phase: Record the Change
+
+1. Create a commit with a meaningful message referencing the user story
+2. Use conventional commit format (e.g., `feat(scope): implement user story`)
+3. **Ask if there are more stories to implement**
+
+## Key Principles
+
+- Never skip phases or combine them
+- Always ask permission before transitioning between phases
+- The RED phase defines the contract; the GREEN phase fulfills it
+- Refactoring is only safe when tests are green
+- Small cycles are better than large ones