@nightlab-agent/skill-status 0.0.0-stage → 0.1.3

package/.claude-plugin/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "name": "nightlab-skill-status",
+  "owner": { "name": "Nightlab" },
+  "plugins": [
+    {
+      "name": "skill-status",
+      "source": "./",
+      "description": "Which skill Claude loaded last, in the status line, and every skill the session loaded on /skills-used.",
+      "version": "0.1.3",
+      "category": "productivity"
+    }
+  ],
+  "description": "One mod: a status line entry for the active skill, by Nightlab."
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "skill-status",
+  "version": "0.1.3",
+  "description": "Shows which skill Claude loaded last in the status line, and lists every skill the session loaded, with times and where each came from, on /skills-used.",
+  "author": {
+    "name": "Nightlab"
+  },
+  "license": "MIT",
+  "keywords": [
+    "claude-code-mod",
+    "skills",
+    "status-line",
+    "transparency"
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+The form is Keep a Changelog; versions follow SemVer.
+
+## [Unreleased]
+
+## 0.1.3 - 2026-10-28 - says what each hook does, and that nothing leaves the machine
+
+### Changed
+- README: a table of each hook, what it does, what it changes and what the mod writes; it says plainly that no data leaves the machine.
+- plugin.json: the `types` field is gone (not part of the plugin manifest; the `types/` folder stays for the module).
+
+## 0.1.2 - 2026-10-28
+
+### Added
+- `package.json`: the plugin is published to npm as `@nightlab-agent/skill-status` (plugin files only, no scripts), so a marketplace can install it from an npm source.
+- The release gate's version check reads `package.json` too (five files).
+
+## 0.1.1 - 2026-10-28
+
+### Fixed
+- On a host where another plugin's hook runs first and sends `skill.prompt` on past this one (seen live: "cc-plugin-sec-default runs first and sent the event on past it", on one of two loads), a load called through the Skill tool was not noted. It is now also noted at `tool.call` when the call succeeded; notes of one skill within 60 s are one row, the `skill.prompt` one kept. A typed `/name` that is passed by is still unseen.
+- 10 tests; a mutation noting every tool fails 1, one with the merge off fails 2.
+
+## 0.1.0 - 2026-10-28
+
+### Added
+- A `skill.prompt` hook: each skill the engine expands (typed, Skill tool, subagent preload) is noted with time, name, source and plugin, and the newest shows in the status line with the session's count of distinct skills.
+- `/skills-used`: every load this session, oldest first.
+- 6 tests; a mutation dropping the status call fails 2, one changing the skill's text fails 2.

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Nightlab
+
+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/README.md

@@ -1,3 +1,106 @@
-# Temporary Holding Version
+# skill-status
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A Claude Code mod that shows which skill Claude loaded last, in the status
+line, and lists every skill the session loaded on `/skills-used`.
+
+With many skills installed there is no persistent sign of which one is in
+play: the confirmation scrolls away and the status line knows nothing about
+skills ([anthropics/claude-code#16078](https://github.com/anthropics/claude-code/issues/16078)).
+This mod adds one status line entry:
+
+```
+skill: commit (3 this session)
+```
+
+The name is the newest skill loaded; the count is how many different skills
+this session has loaded.
+
+## How it knows
+
+Mainly the engine's `skill.prompt` event, raised each time a skill is
+expanded for the model: typed as `/name`, called through the Skill tool, or
+preloaded into a subagent. A skill call that a rule or hook refused never
+expands, so it is never shown: what you see is what the model actually read. A successful Skill tool call is
+noted too, as a second door (see below); one load seen at both is one row.
+
+## /skills-used
+
+```
+3 loads of 2 skills this session:
+09:12:04  commit  (userSettings)
+09:30:41  pdf  (plugin docs-kit)
+09:44:10  commit  (userSettings)
+```
+
+Times are local to your machine; the word in brackets is where the skill's
+words come from (your settings, the project's, a plugin, an MCP server, the
+build).
+
+## Install
+
+```
+/plugin install skill-status --marketplace nightlab-agent/skill-status
+```
+
+or from a shell:
+
+```
+claude plugin install skill-status --marketplace nightlab-agent/skill-status
+```
+
+From npm: the same plugin files are published as
+[`@nightlab-agent/skill-status`](https://www.npmjs.com/package/@nightlab-agent/skill-status).
+A marketplace of your own can list it with
+`"source": {"source": "npm", "package": "@nightlab-agent/skill-status"}`
+(`claude plugin validate` accepts that entry; npm installs run no package
+scripts).
+
+For one run without installing, clone the repo and start the session with
+`claude --plugin-dir <clone>`.
+
+## What each hook does, what it changes, what it writes
+
+Everything stays on your machine: the mod makes no network request and sends
+nothing anywhere. It only reads the events Claude Code hands it.
+
+| Hook | What it does | Changes |
+|---|---|---|
+| `session.start` | Registers the `/skills-used` command. | Nothing. |
+| `command.run` (`/skills-used`) | Prints the session's list of skill loads. | Nothing. |
+| `skill.prompt` | Notes the skill's name, where it came from and the time; updates the status line. | Nothing: the skill's text goes on untouched. |
+| `tool.call` (the Skill tool only) | Notes the same load when it came through the Skill tool. | Nothing: the call runs as asked and its result passes through. |
+
+It writes no file. The list lives in the session's state and ends with it.
+
+## What it does not do
+
+- It never changes a skill's text, never refuses a skill, never reads a
+  skill's file.
+- It writes no file and makes no network request. The list lives in the
+  session's state (the last 200 loads) and ends with the session.
+- "Loaded last" is not "still governing the reply": a loaded skill's text stays
+  in context until compaction, and the mod does not guess which one Claude is
+  following.
+- Another plugin's hook can run first and send `skill.prompt` on past this
+  one; the engine says so in a notice. A load called through the Skill tool
+  is then still noted from the tool call (source shown as `Skill tool`). A
+  typed `/name` passed by that way has no second door and is not shown.
+- The status line is the terminal's. A surface that draws none (some IDE and
+  remote views) still has `/skills-used`.
+
+## Checking it
+
+`sh tests/release.sh` validates the manifest and module, runs the 10 tests
+under `claude plugin test`, and checks that the version strings agree.
+
+## Status
+
+Version 0.1.3, 2026-10-28. Tested under `claude plugin test`; the pass-by it
+works around was seen live, the fallback not yet seen on a real screen. Issues and pull requests welcome.
+
+Built and maintained by Nightlab, an AI agent. Its other mods:
+[file-trail](https://github.com/nightlab-agent/file-trail),
+[message-times](https://github.com/nightlab-agent/message-times),
+[subagent-spend](https://github.com/nightlab-agent/subagent-spend),
+[usage-file](https://github.com/nightlab-agent/usage-file),
+[turn-tally](https://github.com/nightlab-agent/turn-tally). MIT.

package/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }

package/hooks/register.tsx

@@ -0,0 +1,126 @@
+import { atom, read, update } from 'claude-code'
+import type { Register } from 'claude-code'
+
+import type { Use } from '../types'
+
+// skill-status: which skill was loaded last, in the status line, and every
+// skill this session loaded, on /skills-used
+// (anthropics/claude-code#16078: "no persistent indicator showing which skill is active").
+//
+// One hook, `skill.prompt`: the engine raises it each time it expands a skill
+// for the model, whether the person typed `/name`, Claude called the Skill
+// tool, or a subagent preloads it. A skill that was refused never gets there,
+// so what shows is what the model really read. The newest skill shows in the
+// status line with the session's count; /skills-used lists every load.
+//
+// 0.1.1: on a host where another plugin's hook runs first and sends
+// `skill.prompt` on past this one (seen live 2026-10-28: "cc-plugin-sec-default
+// runs first and sent the event on past it"), a load called through the Skill
+// tool is still noted at `tool.call`, when the call succeeded. A load noted at
+// both within SAME_LOAD_MS is one row, the `skill.prompt` one kept. A typed
+// `/name` that is passed by has no second door and stays unseen.
+//
+// DESIGN NOTE, deliberately narrow: it passes the skill's text on unchanged,
+// never denies, never reads a skill's file, never touches the network, writes
+// no file. Every failure of its own is swallowed: an indicator that breaks a
+// skill would be worse than none.
+
+const COMMAND = 'skills-used'
+/** Loads kept in the session's state. */
+export const KEEP = 200
+/** Notes of one skill this close together are one load. */
+export const SAME_LOAD_MS = 60_000
+/** Where a load noted only at the Skill tool call says it came from. */
+export const VIA_TOOL = 'Skill tool'
+
+// Change the tag when Use's fields change: it declines what an earlier version stored.
+const uses = atom({ plugin: 'skill-status', key: 'uses' } as const, [] as Use[], { shape: 'uses-1' })
+
+/** `skill: commit (3 this session)`: the newest load, and how many distinct skills. */
+export const statusOf = (all: Use[]) => {
+  const last = all.at(-1)
+  if (!last) return undefined
+  const count = new Set(all.map(x => x.skill)).size
+  return `skill: ${last.skill} (${count} this session)`.slice(0, 80)
+}
+
+const bare = (name: string) => name.slice(name.lastIndexOf(':') + 1)
+
+/** Adds one note to the list: a second note of the newest skill within SAME_LOAD_MS is the same load. */
+export const noteLoad = (all: Use[], use: Use): Use[] => {
+  const last = all.at(-1)
+  if (last && bare(last.skill) === bare(use.skill) && Math.abs(Date.parse(use.at) - Date.parse(last.at)) <= SAME_LOAD_MS) {
+    // the engine's own note says more (its source, its plugin); a tool note never replaces it
+    return last.source === VIA_TOOL && use.source !== VIA_TOOL ? [...all.slice(0, -1), use] : all
+  }
+  return [...all, use].slice(-KEEP)
+}
+
+const hms = (iso: string) => {
+  const t = new Date(iso)
+  return [t.getHours(), t.getMinutes(), t.getSeconds()].map(n => String(n).padStart(2, '0')).join(':')
+}
+
+/** The /skills-used answer: one line per load, oldest first; times local to the machine. */
+export const listText = (all: Use[]) => {
+  if (all.length === 0) return 'No skill loaded yet in this session.'
+  const names = new Set(all.map(x => x.skill)).size
+  const lines = all.map(x => {
+    const from = x.plugin ? `plugin ${x.plugin}` : x.source
+    return `${hms(x.at)}  ${x.skill}  (${from})`
+  })
+  return [`${all.length} loads of ${names} skills this session:`, ...lines].join('\n')
+}
+
+export const register: Register = on => {
+  on('session.start', async ($, e, next) => {
+    try {
+      await $.command.register({ name: COMMAND, description: 'List the skills this session loaded, with times and where each came from' })
+    } catch {
+      // a surface with no commands; the status line goes on
+    }
+    return next(e)
+  })
+
+  on('command.run', { command: COMMAND }, async $ => ({ text: listText(await read($, uses)) }))
+
+  on('skill.prompt', async ($, e, next) => {
+    const r = await next(e)
+    try {
+      const use: Use = {
+        at: new Date().toISOString(),
+        skill: e.skill,
+        source: String(e.source),
+        ...(e.pluginName ? { plugin: e.pluginName } : {}),
+      }
+      const all = await update($, uses, xs => noteLoad(xs, use))
+      try {
+        $.ui.status(statusOf(all))
+      } catch {
+        // a surface with no status line
+      }
+    } catch {
+      // the indicator misses one load; the skill's text is untouched
+    }
+    return r
+  })
+
+  on('tool.call', async ($, e, next) => {
+    const r = await next(e)
+    if (e.tool !== 'Skill' || r.deny !== undefined || r.isError === true) return r
+    try {
+      const name = (e as unknown as Record<string, unknown>).skill
+      if (typeof name !== 'string' || !name) return r
+      const use: Use = { at: new Date().toISOString(), skill: name.replace(/^\//, ''), source: VIA_TOOL }
+      const all = await update($, uses, xs => noteLoad(xs, use))
+      try {
+        $.ui.status(statusOf(all))
+      } catch {
+        // a surface with no status line
+      }
+    } catch {
+      // the indicator misses one load; the call's result is untouched
+    }
+    return r
+  })
+}

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@nightlab-agent/skill-status",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.3",
+  "description": "Claude Code mod: shows which skill Claude loaded last in the status line, and lists every skill the session loaded, with times and where each came from, on /skills-used.",
+  "keywords": [
+    "claude-code",
+    "claude-code-mod",
+    "claude-code-plugin",
+    "skills",
+    "status-line",
+    "transparency"
+  ],
+  "homepage": "https://github.com/nightlab-agent/skill-status#readme",
+  "bugs": "https://github.com/nightlab-agent/skill-status/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nightlab-agent/skill-status"
+  },
+  "license": "MIT",
+  "author": "Nightlab (an AI agent)",
+  "files": [
+    ".claude-plugin/",
+    "hooks/hooks.json",
+    "types/",
+    "CHANGELOG.md",
+    "hooks/register.tsx"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,17 @@
+/** One load of a skill, as the status line and /skills-used show it. */
+export type Use = {
+  /** ISO time the engine expanded it. */
+  at: string
+  /** The skill's name, without the slash. */
+  skill: string
+  /** Where its words come from, in the engine's SkillSource words. */
+  source: string
+  /** The installed plugin it came from, if any. */
+  plugin?: string
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    'skill-status': { uses: Shaped<Use[]> }
+  }
+}