@iceinvein/agent-skills 0.12.0 → 0.13.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.13.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.14.0"
   },
   {
     "name": "temporal-coupling-detector",

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

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/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.14.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",