@iceinvein/agent-skills 0.12.0 → 0.14.0

package/dist/cli/index.js

@@ -20,7 +20,7 @@ var __toESM = (mod, isNodeMode, target) => {
       return cached;
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   if (mod && typeof mod === "object" || typeof mod === "function") {
     for (let key of __getOwnPropNames(mod))
       if (!__hasOwnProp.call(to, key))
@@ -1032,9 +1032,9 @@ async function removeSkill(cwd, skillName) {
   const warnings = [];
   for (const file of entry.files) {
     if (isSharedConfigFile(file)) {
-      const fullPath2 = join7(cwd, file);
-      if (existsSync6(fullPath2)) {
-        await unwireSessionStartHook(fullPath2, skillName);
+      const fullPath = join7(cwd, file);
+      if (existsSync6(fullPath)) {
+        await unwireSessionStartHook(fullPath, skillName);
       }
       warnings.push(`Manifest unavailable (${manifestResult.error}). Left '${file}' in place, only removing '${skillName}'s SessionStart hook from it; any MCP server entries it owns were not touched.`);
       continue;
@@ -1125,9 +1125,9 @@ async function removeSkill2(cwd, skillName) {
   const warnings = [];
   for (const file of entry.files) {
     if (isSharedConfigFile2(file)) {
-      const fullPath2 = join8(cwd, file);
-      if (existsSync7(fullPath2)) {
-        await unwireSessionStartHook(fullPath2, skillName);
+      const fullPath = join8(cwd, file);
+      if (existsSync7(fullPath)) {
+        await unwireSessionStartHook(fullPath, skillName);
       }
       warnings.push(`Manifest unavailable (${manifestResult.error}). Left '${file}' in place, only removing '${skillName}'s SessionStart hook from it; any MCP server entries it owns were not touched.`);
       continue;
@@ -1518,7 +1518,7 @@ function isFactory(value) {
 }
 function useState(defaultValue) {
   return withPointer((pointer) => {
-    const setState = AsyncResource2.bind(function setState2(newValue) {
+    const setState = AsyncResource2.bind(function setState(newValue) {
       if (pointer.get() !== newValue) {
         pointer.set(newValue);
         handleChange();
@@ -2387,7 +2387,7 @@ if (process.platform === "linux") {
 }
 
 // node_modules/signal-exit/dist/mjs/index.js
-var processOk = (process3) => !!process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+var processOk = (process2) => !!process2 && typeof process2 === "object" && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function";
 var kExitEmitter = Symbol.for("signal-exit emitter");
 var global = globalThis;
 var ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -2477,15 +2477,15 @@ class SignalExit extends SignalExitBase {
   #originalProcessReallyExit;
   #sigListeners = {};
   #loaded = false;
-  constructor(process3) {
+  constructor(process2) {
     super();
-    this.#process = process3;
+    this.#process = process2;
     this.#sigListeners = {};
     for (const sig of signals) {
       this.#sigListeners[sig] = () => {
         const listeners = this.#process.listeners(sig);
         let { count } = this.#emitter;
-        const p = process3;
+        const p = process2;
         if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
           count += p.__signal_exit_emitter__.count;
         }
@@ -2494,12 +2494,12 @@ class SignalExit extends SignalExitBase {
           const ret = this.#emitter.emit("exit", null, sig);
           const s = sig === "SIGHUP" ? this.#hupSig : sig;
           if (!ret)
-            process3.kill(process3.pid, s);
+            process2.kill(process2.pid, s);
         }
       };
     }
-    this.#originalProcessReallyExit = process3.reallyExit;
-    this.#originalProcessEmit = process3.emit;
+    this.#originalProcessReallyExit = process2.reallyExit;
+    this.#originalProcessEmit = process2.emit;
   }
   onExit(cb, opts) {
     if (!processOk(this.#process)) {
@@ -2725,8 +2725,8 @@ function createPrompt(view) {
       signal.addEventListener("abort", abort);
       cleanups.add(() => signal.removeEventListener("abort", abort));
     }
-    cleanups.add(onExit((code, signal2) => {
-      reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+    cleanups.add(onExit((code, signal) => {
+      reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal}`));
     }));
     const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
     rl.on("SIGINT", sigint);
@@ -2847,12 +2847,12 @@ function normalizeChoices(choices) {
     if (Separator.isSeparator(choice))
       return choice;
     if (typeof choice !== "object" || choice === null || !("value" in choice)) {
-      const name2 = String(choice);
+      const name = String(choice);
       return {
         value: choice,
-        name: name2,
-        short: name2,
-        checkedName: name2,
+        name,
+        short: name,
+        checkedName: name,
         disabled: false,
         checked: false
       };
@@ -2957,8 +2957,8 @@ var dist_default4 = createPrompt((config, done) => {
       const cursor = isActive ? theme.icon.cursor : " ";
       if (item.disabled) {
         const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
-        const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
-        return theme.style.disabled(`${cursor}${checkbox2} ${item.name} ${disabledLabel}`);
+        const checkbox = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+        return theme.style.disabled(`${cursor}${checkbox} ${item.name} ${disabledLabel}`);
       }
       if (isActive) {
         description = item.description;
@@ -3021,11 +3021,11 @@ function normalizeChoices2(choices) {
     if (Separator.isSeparator(choice))
       return choice;
     if (typeof choice !== "object" || choice === null || !("value" in choice)) {
-      const name2 = String(choice);
+      const name = String(choice);
       return {
         value: choice,
-        name: name2,
-        short: name2,
+        name,
+        short: name,
         disabled: false
       };
     }
@@ -3095,8 +3095,8 @@ var dist_default5 = createPrompt((config, done) => {
     } else if (isNumberKey(key) && !Number.isNaN(Number(rl.line))) {
       const selectedIndex = Number(rl.line) - 1;
       let selectableIndex = -1;
-      const position = items.findIndex((item2) => {
-        if (Separator.isSeparator(item2))
+      const position = items.findIndex((item) => {
+        if (Separator.isSeparator(item))
           return false;
         selectableIndex++;
         return selectableIndex === selectedIndex;
@@ -3477,10 +3477,10 @@ Installing ${names.length} skills...
         }
         const other = await otherScopeSkillCount(updateDir);
         if (other.count > 0) {
-          const command2 = other.scope === "global" ? "agent-skills update --all -g" : "agent-skills update --all";
+          const command = other.scope === "global" ? "agent-skills update --all -g" : "agent-skills update --all";
           const noun = other.count === 1 ? "skill" : "skills";
           console.log(`
-Note: ${other.count} ${noun} installed in the ${other.scope} scope. Run \`${command2}\` to update those too.`);
+Note: ${other.count} ${noun} installed in the ${other.scope} scope. Run \`${command}\` to update those too.`);
         }
         break;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Install agent skills into AI coding tools",
   "author": "iceinvein",
   "license": "MIT",

package/skills/index.json

@@ -283,7 +283,7 @@
     "name": "sluice",
     "description": "Routes work by change shape into four channels (bypass, fast, main, deep) and applies only the rules each channel needs, so a one-line fix does not pay the cost of a multi-subsystem build. Carries seven rules as one-liners in the router and the full treatment in references read only on friction. Checks the finished plan with plan.sh validate rather than trusting it to memory, seeds the run state from it, keeps a deep run's task breakdown in .sluice/run.json so a statusline segment and one status command can answer where the run is, and closes each run with a ledger read out of the session transcript: elapsed, tools, tokens, and what each dispatched agent cost where the transcript recorded it. Claude Code only; stands down where the superpowers pipeline governs the repo.",
     "type": "prompt",
-    "version": "0.13.0"
+    "version": "0.15.0"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/sluice/SKILL.md

@@ -56,8 +56,8 @@ yourself wanting to skip the rule, or arguing that this one is the exception.
   it down. `references/intent.md`
 - **Test first.** The test comes before the code; run it while it should
   still be failing, then write the least code that turns it green. Skip that
-  watching step and a green result is only an unchecked guess.
-  `references/test-first.md`
+  watching step and a green result is only an unchecked guess. A test no
+  plausible change could turn red is not one you owe. `references/test-first.md`
 - **Root cause** before fix. A fix that only hides the symptom has not fixed
   anything. Three failed fixes point at the design, not your guesswork.
   `references/root-cause.md`

package/skills/sluice/references/deep-channel.md

@@ -285,7 +285,9 @@ reads the run state rather than the plan: it sees what has actually landed.
 - Isolate the workspace before a multi-task plan: the harness's worktree
   tool, not `git worktree` yourself. Implementing straight onto main or
   master needs your partner's say-so, which pre-flight is where you got, and
-  it forecloses concurrent implementers for the whole run.
+  it forecloses concurrent implementers for the whole run. The run state
+  follows the set rather than the tree, so a worktree cut after the plan still
+  reads the rows the plan seeded and flips them where you are watching.
 - **The agent that built the task commits it**, once its own tests pass, and
   only the paths in its `Touches`. Never `git add -A`: the tree is shared, and
   on a branch you did not isolate it holds work that is not this task's. The
@@ -351,7 +353,7 @@ and it fails by printing success rather than by erroring.
 
 | Tier | Task shape | Review |
 |------|------------|--------|
-| 0 | Created files only, executable tests exist and pass, Contract matches | No dispatch. Read the commit stat yourself. |
+| 0 | Created files only, tests that meet `references/test-first.md` exist and pass, Contract matches | No dispatch. Read the commit stat yourself. |
 | 1 | Modified existing code, or later tasks build on it | One reviewer dispatch |
 | 2 | No executable test covers it: prose, config, docs | One reviewer dispatch; a stat cannot confirm the words are right |
 | 3 | Auth, data, money, concurrency, or the plan flags it | One reviewer dispatch; the task may not be downshifted |
@@ -380,6 +382,13 @@ number, not the row order and not which shape sounds more serious. A task that
 only creates files but ships prose is tier 2, and a suite re-bless paired with
 an ADR is tier 2 rather than the free row it resembles.
 
+**A test written to earn tier 0 does not earn it.** The row is a discount on
+review, and a task whose only executable test fails
+`references/test-first.md`'s question, that some plausible change to the code
+turns it red, is a tier 2 task carrying a green line rather than a covered
+one. Price it as tier 2. Buying this table's savings with the one kind of test the rest of the
+skill argues against is the cheapest way to lose them.
+
 Ordering inert tasks first is what keeps this affordable. An inert task that
 only creates files takes tier 0, so a nine-task plan usually buys three
 or four dispatches rather than nine. If most of your plan qualifies for a

package/skills/sluice/references/status.md

@@ -7,7 +7,7 @@ session that is running it: your partner has to ask, and asking costs a turn
 and gets an answer from memory.
 
 `.sluice/run.json` is that answer in a form something else can read. One file
-per tree, holding only what changes as the run moves.
+per worktree set, holding only what changes as the run moves.
 
 ```
 bash <skill-dir>/scripts/status.sh init --topic <t> --channel deep \
@@ -24,7 +24,9 @@ bash <skill-dir>/scripts/status.sh line --full
 bash <skill-dir>/scripts/status.sh close
 ```
 
-`--dir <path>` reads another tree, which is what the statusline uses. Statuses
+`--dir <path>` reads another tree, which is what the statusline uses; it names
+a tree in the set rather than a state file, so a worktree resolves to the same
+run as the tree it was cut from. Statuses
 are `todo`, `active`, `review`, `done` and `blocked`. A new id needs `--name`;
 after that every call is a bare flip, so keeping it current costs one command
 per transition rather than a paragraph. `close` archives the run under
@@ -42,6 +44,31 @@ everything durable in it lands somewhere else anyway: the commits are in git and
 the reasons are in the record, which is the file that does get committed. Delete
 that `.gitignore` if you want a run tracked; it is only written when absent.
 
+## Worktrees
+
+Ignoring itself is what makes the run invisible to a worktree unless something
+is done about it, and a `deep` run makes worktrees after the plan is written:
+`git worktree add` gives the implementer a clean checkout, and an ignored
+directory is not in a checkout. Read from the tree it was called in, the run
+the plan seeded would be absent from every implementer, `init` there would
+start a second run nothing else reads, and the worktree would take that state
+with it when it went.
+
+So every command anchors on the main worktree of whatever tree it is pointed
+at, and one run covers the set. The statusline renders the same run in every
+window, a flip made by an implementer lands where the controller is watching,
+and `init` from a worktree reports the run that is already live rather than
+replacing it. A submodule anchors on its own checkout, not the superproject's,
+and a directory that is no git work tree keeps its run exactly where it sits.
+
+One file for several writers is one file to contend on, so `init`, `task`,
+`preflight` and `close` take a lock first: four implementers each flipping
+their own row would otherwise have the later write built on a snapshot taken
+before the earlier one landed, dropping that row without saying so. The lock
+carries its holder's pid, so a killed run is broken through rather than waited
+out. Reads take nothing, state being installed through a rename, which is what
+keeps `line` cheap enough to render on.
+
 Open it with `init` when you open the run record, at the same point and for the
 same reason, then seed the rows with `plan.sh import <plan>` rather than a
 command per task. The ids, names, the flip, the `Model` marks and the tiers are
@@ -169,7 +196,7 @@ state file existing so a session with no run spawns no process at all:
 
 ```bash
 sluice_line=""
-if [ -n "$cwd" ] && [ -f "$cwd/.sluice/run.json" ]; then
+if [ -n "$cwd" ] && { [ -f "$cwd/.sluice/run.json" ] || [ -f "$cwd/.git" ]; }; then
   for sluice_sh in "$cwd/.claude/skills/sluice/scripts/status.sh" \
                    "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/skills/sluice/scripts/status.sh" \
                    "$HOME/.claude/skills/sluice/scripts/status.sh"; do
@@ -186,6 +213,12 @@ then print it last, after whatever else the command emits:
 if [ -n "$sluice_line" ]; then printf '%s\n' "$sluice_line"; fi
 ```
 
+The gate is two tests because a linked worktree holds no state file of its own:
+there `.git` is a regular file naming the tree it was cut from, and the script
+resolves the run from it. In a tree with no run and no worktree behind it `.git`
+is a directory, so both tests fail and no process is spawned, which is the
+property the gate is for.
+
 `if` rather than `[ ... ] &&`: as the last command of a statusline script the
 short form makes it exit 1 on every render with no run live, which is the common
 case. `%s` rather than `%b`: the render already carries real escape bytes, and

package/skills/sluice/references/test-first.md

@@ -10,26 +10,64 @@ alone cannot tell you which. A test that passes the first time you run it is
 not testing your change, it is testing behaviour that already existed. When
 that happens, fix the test, not the code.
 
-A test is only a test if some change to the implementation would turn it red.
-Work out which change before you write the body; if there isn't one, what you
-have is an assertion that stays green whatever you build.
-
-Assertions belong on what the run actually produced: the value returned, the
-state left behind, the output written. Never point one at a mock: a green
-result then proves only that you called the mock the way you meant to, which
-you knew already. Before a mock stands in for a dependency, learn what the real
-one does on the paths your test never exercises; one that quietly drops a side
-effect will hold a broken change green.
-
-Keep helpers that exist only for tests inside the test files. If a production
-class grows a method whose only caller is a test reaching inside it, the test
-has started reshaping your design.
-
-Three cases are worth asking to skip: generated or scaffolded code, a config
-file with no logic in it, and a prototype headed for the bin before anyone
-sees it. Ask rather than assume, and treat that list as closed.
-
-The friction line: "this case is obvious enough to skip straight to the
-code." A test written once the code already works can only confirm what you
-already believe about it. By that point you have stopped hunting for the cases
-you never thought of, so the test does not find them either.
+**Name the change that would turn it red.** A test is only a test if some
+change to the implementation makes it fail, so work out which change before you
+write the body, and hold the answer to being one a person would plausibly make
+to this code later. An answer nobody would ever write, or one the type checker,
+the linter or the framework already rejects on your behalf, means there is no
+test to write here. Write nothing and move on. What you were reaching for is an
+assertion that stays green whatever you build, and it bills a run on every
+commit from now on to keep saying so.
+
+**Some shapes never survive that question.** A getter, a constant, a
+framework's own behaviour, a mock's call log. Coverage is a smoke detector,
+not a target, and a test added to move the number is the purest case of the
+thing this rule refuses.
+
+**Skipping is a judgement, not a list.** Generated or scaffolded code, a config
+file with no logic in it, and a prototype headed for the bin are the usual
+cases that fail the question outright, but they are instances of the criterion
+rather than the whole of it. What you owe in exchange for the judgement is one
+sentence in your reply naming the behaviour you left untested and why: a skip
+nobody hears about cannot be told apart from an oversight.
+
+**Assertions belong on what the run actually produced**: the value returned,
+the state left behind, the output written. Never point one at a mock, because
+a green result then proves only that you called the mock the way you meant to,
+which you knew already. Before a mock stands in for a dependency, learn what
+the real one does on the paths your test never exercises; one that quietly
+drops a side effect will hold a broken change green. Where the wiring is what
+breaks, one real integration test is worth five mocked unit ones.
+
+**Expected values are written by hand or taken from the spec.** Never produce
+one by running the code under test and keeping what came back: a blessed
+snapshot checks the implementation against itself, so it stays green whatever
+that implementation does, which is the same as having no test at all. The
+re-bless is where this goes wrong at scale, the diff too large to read and
+every value in it exactly as authoritative as the bug you are freezing.
+
+**One behaviour per test**, named for the behaviour it pins rather than for the
+function it calls. Keep helpers that exist only for tests inside the test
+files. If a production class grows a method whose only caller is a test
+reaching inside it, the test has started reshaping your design.
+
+**A test goes when the behaviour it pinned is gone.** Delete it alongside the
+code, in the same commit, like anything else the change orphaned. Two tests
+pinning one behaviour are a test and a maintenance bill, so keep the clearer.
+None of that reaches a red test. A failure is the suite claiming your change
+broke something, and deleting it, skipping it, loosening the assertion or
+special-casing the input it feeds answers the claim by silencing the witness.
+Believe the test itself is wrong and you say so and get agreement first.
+
+Two friction lines, one in each direction:
+
+"This case is obvious enough to skip straight to the code." A test written
+once the code already works can only confirm what you already believe about
+it. By that point you have stopped hunting for the cases you never thought of,
+so the test does not find them either.
+
+"Better add a test here to be safe." Safe against what? You are one sentence
+away from the answer, so finish it and name the change this would catch. If
+the sentence will not finish, what moved you was diligence rather than
+evidence, and what it buys is a permanently green line nobody later dares
+delete.

package/skills/sluice/scripts/status.sh

@@ -92,8 +92,27 @@ if [ -z "$SUB" ]; then
 	exit 4
 fi
 
+# A linked worktree is another view of the same run, not a new one. The run
+# directory ignores itself, so `git worktree add` never carries it across: read
+# from the tree it was called in, the run a plan seeded is absent from every
+# implementer created after that plan, and an `init` there lands a rival state
+# file that dies with the worktree. Every tree in a set anchors on the main
+# worktree instead, which is the one path all of them agree on.
+#
+# `git worktree list` names the main worktree first. A submodule names its own
+# checkout there rather than the superproject's, which is what keeps a
+# submodule's run beside its own working tree, and a directory that is no git
+# work tree at all is left exactly as it was given.
+if [ "$(git -C "$DIR" rev-parse --is-inside-work-tree 2>/dev/null)" = "true" ]; then
+	MAIN_TREE="$(git -C "$DIR" worktree list --porcelain 2>/dev/null | sed -n '1s/^worktree //p')"
+	if [ -n "${MAIN_TREE:-}" ] && [ -d "$MAIN_TREE" ]; then
+		DIR="$MAIN_TREE"
+	fi
+fi
+
 STATE="$DIR/.sluice/run.json"
 ARCHIVE="$DIR/.sluice/archive"
+LOCK="$DIR/.sluice/run.lock"
 
 # `line` swallows everything: a missing jq, unreadable state, no run at all.
 # Any of those printing would put permanent clutter in the status bar.
@@ -252,6 +271,45 @@ write_state() {
 	mv "$tmp" "$STATE" || { rm -f "$tmp"; err "could not replace $STATE"; exit 1; }
 }
 
+# One state file now serves a whole worktree set, so two implementers can flip
+# their own task at the same moment. A flip reads the whole file, edits it with
+# jq and writes it back, so unserialised the later write is built on a snapshot
+# taken before the earlier one landed and drops that row without saying so.
+# mkdir is the atomic primitive every platform this runs on has; flock is Linux
+# only. Reads do not take it: write_state installs through a rename, so a reader
+# sees either the whole old file or the whole new one.
+#
+# The holder's pid goes inside the directory so a killed run cannot wedge every
+# later one. A lock whose holder is gone is broken rather than waited out, and
+# one whose holder is alive is waited on for a bounded time and then reported,
+# because a command that hangs in a status bar is worse than one that fails.
+lock_taken=0
+release_lock() {
+	[ "$lock_taken" -eq 1 ] || return 0
+	rm -rf "$LOCK"
+	lock_taken=0
+}
+
+take_lock() {
+	local waited=0 holder
+	while ! mkdir "$LOCK" 2>/dev/null; do
+		holder="$(cat "$LOCK/pid" 2>/dev/null)"
+		if [ -n "$holder" ] && ! kill -0 "$holder" 2>/dev/null; then
+			rm -rf "$LOCK"
+			continue
+		fi
+		if [ "$waited" -ge 100 ]; then
+			err "another sluice command has held $LOCK for 10s; remove it if nothing is running"
+			exit 1
+		fi
+		sleep 0.1
+		waited=$((waited + 1))
+	done
+	printf '%s\n' "$$" >"$LOCK/pid" 2>/dev/null || true
+	lock_taken=1
+	trap release_lock EXIT INT TERM
+}
+
 case "$SUB" in
 	init)
 		TOPIC="" CHANNEL="" PLAN="" RECORD="" FORCE=0
@@ -269,13 +327,14 @@ case "$SUB" in
 		[ -n "$CHANNEL" ] || { err "init needs --channel"; exit 4; }
 		in_set "$CHANNEL" "$CHANNELS" || { err "unknown channel: $CHANNEL (one of: $CHANNELS)"; exit 4; }
 
+		mk_dir "$DIR/.sluice"
+		take_lock
 		if [ -f "$STATE" ] && [ "$FORCE" -eq 0 ]; then
 			live="$(jq -r '.topic // "?"' "$STATE" 2>/dev/null || echo "?")"
 			err "a run is already live (topic: $live); pass --force to replace it"
 			exit 3
 		fi
 
-		mk_dir "$DIR/.sluice"
 		jq -n \
 			--arg topic "$TOPIC" \
 			--arg channel "$CHANNEL" \
@@ -332,6 +391,7 @@ case "$SUB" in
 		fi
 
 		require_run
+		take_lock
 		require_readable
 
 		# A row with no name is a number nobody can act on, so a new id has to
@@ -404,6 +464,7 @@ case "$SUB" in
 			exit 4
 		fi
 		require_run
+		take_lock
 		require_readable
 
 		jq --arg review "$REVIEW" --arg model "$MODEL" --arg workspace "$WORKSPACE" '
@@ -528,6 +589,7 @@ case "$SUB" in
 	close)
 		[ $# -eq 0 ] || { err "close takes no arguments"; exit 4; }
 		require_run
+		take_lock
 
 		# Deliberately not `require_readable`. The parse error every other
 		# subcommand raises names close as the way out, so close is the one

package/skills/sluice/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "sluice",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Routes work by change shape into four channels (bypass, fast, main, deep) and applies only the rules each channel needs, so a one-line fix does not pay the cost of a multi-subsystem build. Carries seven rules as one-liners in the router and the full treatment in references read only on friction. Checks the finished plan with plan.sh validate rather than trusting it to memory, seeds the run state from it, keeps a deep run's task breakdown in .sluice/run.json so a statusline segment and one status command can answer where the run is, and closes each run with a ledger read out of the session transcript: elapsed, tools, tokens, and what each dispatched agent cost where the transcript recorded it. Claude Code only; stands down where the superpowers pipeline governs the repo.",
   "author": "iceinvein",
   "type": "prompt",