@skitterbyte/skitterspec-jira 2.9.1 → 2.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -20,9 +20,15 @@ every phase. **`skitterspec status`** lists what is in flight across worktrees.
20
20
  At the end of the day, **`/spec-tada`** is the ta-da list: what you did across
21
21
  every project, grouped by spec — what landed, what was explored, what is still
22
22
  in flight — ending in a three-line standup (`skitterspec tada` is the engine).
23
- It covers the projects that share this one's `project.category`;
23
+ It covers the projects that share this one's `project.category`, leads with
24
+ the day's wins, and names only this project's work as the thing to do next;
24
25
  **`skitterspec project`** shows and sets the name and category, and
25
- `/spec-init` asks for both.
26
+ `/spec-init` asks for both. In the morning, **`/spec-todo`** answers the other
27
+ question: where each project was left on your last working day, what is
28
+ waiting on you, and what to pick up first. Both read across projects, and
29
+ neither acts on one: a session works on the project it was started in, and a
30
+ hook refuses its writes and lifecycle commands anywhere else until you type
31
+ `/allow-project <name>`.
26
32
 
27
33
  **Handing the review back.** The page takes marks: tick `✓ accept` per file as
28
34
  you read, note anything against a line or a whole file, answer the questions a
@@ -0,0 +1,28 @@
1
+ ---
2
+ description: Let this session work on another skitterspec project — name it (or its path); `off` guards it again
3
+ argument-hint: "<project> [off]"
4
+ allowed-tools: Bash({{exec}} skitterspec spec-env project allow:*)
5
+ disable-model-invocation: true
6
+ ---
7
+ !`{{exec}} skitterspec spec-env project allow $ARGUMENTS`
8
+
9
+ Relay the engine output above verbatim. Add nothing and run nothing else.
10
+
11
+ **Only you can run this, and that is the whole guard.** The project-guard hook
12
+ refuses a write, a `git` change or a `skitterspec` lifecycle command aimed at a
13
+ skitterspec project other than the one this session was started in. Its refusal
14
+ names two exits: open a session in that project and do the work there, or have
15
+ you lift the guard. Claude can take the first and can never take the second — a
16
+ guard the model can lift is decoration, which is the line `/allow-main` draws.
17
+
18
+ **Name the project the refusal named.** `/allow-project ereqs` lifts it for that
19
+ folder name; a path (`/allow-project ../ereqs`) pins it to that exact repo.
20
+
21
+ **It lapses with the session.** The lift is recorded against this session, so
22
+ a new session is guarded again. Where the harness exposes no session id it
23
+ degrades to a repo-wide lift that lasts until `/allow-project <project> off`;
24
+ the engine says which kind you got.
25
+
26
+ **It is machine-local and gitignored.** The project-wide switch is
27
+ `guards.projectBoundary` in `specs/.core/env.config.json`, and turning that off
28
+ is a different, committed decision.
@@ -5,7 +5,7 @@ stack + host dev servers + a front-door proxy per in-progress spec).
5
5
  Provisioning is folded into `/spec-start`, teardown into `/spec-complete` ·
6
6
  `/spec-cancel`, traffic diversion is `/spec-connect`, and reading a spec's diff
7
7
  is `/spec-diff`; the `skitterspec spec-env
8
- <up|bootstrap|nospec|main|down|prune|dev|connect|integrate|disposition|handoff|hotfix|live|review|stage|status|resolve|base>` CLI is
8
+ <up|bootstrap|nospec|main|project|down|prune|dev|connect|integrate|disposition|handoff|hotfix|live|review|stage|status|resolve|base>` CLI is
9
9
  the engine beneath them.
10
10
 
11
11
  **Once this file is present, isolation is the default policy:** `/spec-start` gives
@@ -161,7 +161,10 @@ through to a documented conservative default; see the field notes below.
161
161
  // An entry may also be { "run": "<cmd>", "when": ["<glob>", ...] }. `when` is
162
162
  // IGNORED here — a fresh worktree always runs every setup step — and exists
163
163
  // so `afterLand` can re-run that step after a land that changes its inputs
164
- // (`{ "setup": true }`, below).
164
+ // (`{ "setup": true }`, below), and so `live take` warns to restart the dev
165
+ // server when a branch changes one of those files. Name your stack's
166
+ // manifests here, e.g. { "run": "dotnet restore", "when": ["**/*.csproj",
167
+ // "Directory.Packages.props"] } — the npm/pnpm/yarn files always count.
165
168
  "setup": [],
166
169
 
167
170
  // Commands to run in the PRIMARY checkout after a land — the counterpart of
@@ -239,6 +242,13 @@ through to a documented conservative default; see the field notes below.
239
242
  // {portVar}/{port} expand here too. Omit for no health gate.
240
243
  // frontPort optional canonical origin this process fronts (e.g. 3000 for the
241
244
  // UI, 8080 for the API) — used by the proxy to route to it.
245
+ // reload "hot" (default) or "restart". `live take` probes a hot entry's
246
+ // frontPort and refuses when nothing answers. A "restart" entry —
247
+ // an API run from Visual Studio or Rider — is never probed: take
248
+ // and release name it to restart instead. An unrecognised value
249
+ // reads as "hot". e.g. { "name": "api", "command": "dotnet run",
250
+ // "portVar": "ASPNETCORE_HTTP_PORTS", "frontPort": 5000,
251
+ // "reload": "restart" }
242
252
  "dev": [],
243
253
 
244
254
  // Front-door proxy for `spec-env connect <spec>` — a small bundled Node
@@ -366,9 +376,17 @@ through to a documented conservative default; see the field notes below.
366
376
  // blocks when the commits are ALSO unmerged into the base branch — a branch
367
377
  // already landed on base tears down (and its branch is deleted) without
368
378
  // --force, even with no remote.
379
+ //
380
+ // `projectBoundary` (default true): a session works on the project it was
381
+ // started in. The project-guard hook refuses a write, a git change or a
382
+ // skitterspec lifecycle command aimed at ANOTHER skitterspec project (a
383
+ // checkout with specs/.core/); reads and every other program pass. The user
384
+ // lifts it for one session with /allow-project <name>; false turns it off
385
+ // for this project. Its sibling `mainIsLandingZone` is the main guard's switch.
369
386
  "guards": {
370
387
  "refuseTeardownIfDirty": true,
371
- "refuseTeardownIfUnpushed": true
388
+ "refuseTeardownIfUnpushed": true,
389
+ "projectBoundary": true
372
390
  },
373
391
 
374
392
  // What teardown cleans up beyond this machine. Nothing publishes a spec
@@ -398,8 +416,34 @@ through to a documented conservative default; see the field notes below.
398
416
  // `migrations` is a list of globs (`**`, `*`, `?`) marking migration files; a
399
417
  // branch that changes any of them is treated as STATEFUL and `live take`
400
418
  // refuses it (code-only v1 — use `/spec-connect` for those). Default: none.
419
+ // Nothing is detected for you: an EF Core project wants
420
+ // ["**/Migrations/**"], so a spec adding a migration is refused rather than
421
+ // applied to the shared dev database.
422
+ // A branch changing a manifest a `setup` entry's `when` names (or an npm
423
+ // lockfile) is let through with a "restart your dev server" warning.
424
+ // Under `land.strategy: "pr"` take fetches and rebases onto
425
+ // `<land.remote>/<base>`, since local base moves only when you pull; a
426
+ // failed fetch falls back to local base and says so.
427
+ //
428
+ // `afterSwitch` is `afterLand`'s grammar — a string, `{ "run", "when" }`, or
429
+ // `{ "setup": true }` — run in the PRIMARY checkout after `live take` checks
430
+ // the branch out, and again after `live release` switches back. Both decide
431
+ // `when` against the same files (what the branch changes from base), since
432
+ // release reverts what take brought in. Unlike `afterLand` the ENGINE runs
433
+ // these, because `/spec-live` and the page's live action have no caller turn
434
+ // to run anything after them: output is captured, the first failure stops the
435
+ // list with the tail of its output, and the switch is never undone.
436
+ // A separate list, not `afterLand`, because `afterLand` may hold a data
437
+ // migration, which must never run for a branch that has not landed:
438
+ //
439
+ // "afterSwitch": [{ "setup": true }]
440
+ //
441
+ // [] (or absent) = none, and take and release print what they always did. It
442
+ // does not replace the "restart your dev server" warning — an install is not
443
+ // a restart.
401
444
  "live": {
402
- "migrations": []
445
+ "migrations": [],
446
+ "afterSwitch": []
403
447
  },
404
448
 
405
449
  // Hotfix landing (`spec-env hotfix land` / `/spec-complete` on a Type: Hotfix
@@ -0,0 +1,161 @@
1
+ #!/usr/bin/env node
2
+ 'use strict'
3
+
4
+ /**
5
+ * Project guard — the harness half.
6
+ *
7
+ * A session belongs to the project it was started in. The skills say so, and a
8
+ * skill is prose: a report that ends on another repo's `/spec-complete` reads
9
+ * as an instruction, and nothing in prose stops a session `cd`-ing over there
10
+ * and doing it. So the rule is also enforced one level down, where a write or a
11
+ * shell command is a tool call the harness has to ask about first.
12
+ *
13
+ * WHAT IT GUARDS: a write tool whose path lands in another skitterspec project,
14
+ * and a Bash command that runs `git` (to change something) or the engine there.
15
+ * Reads, and every other program, pass.
16
+ *
17
+ * THIS SCRIPT DECIDES NOTHING. It hands the call to `spec-env project check`
18
+ * and turns one exit status into an answer, for `main-guard.cjs`'s reason: a
19
+ * hook with its own opinions is a second implementation nothing can test.
20
+ *
21
+ * HOME IS THIS SCRIPT'S PROJECT, NOT THE SESSION'S DIRECTORY. `cwd` is wherever
22
+ * the session has `cd`-ed to — which is exactly the thing being judged — so the
23
+ * project this hook was installed into is the one the session belongs to.
24
+ *
25
+ * IT FAILS OPEN, EVERYWHERE: no engine, an unreadable payload, a crash, a
26
+ * timeout. Being wrong the permissive way costs one act the skills also warn
27
+ * against; being wrong the other way stops ordinary work with no reason given.
28
+ */
29
+
30
+ const fs = require('node:fs')
31
+ const path = require('node:path')
32
+ const { spawnSync } = require('node:child_process')
33
+
34
+ function allow() {
35
+ process.exit(0)
36
+ }
37
+
38
+ // The JSON route rather than exit-2, so the reason reaches Claude — who has to
39
+ // act on it by leaving the work to a session in that project.
40
+ function deny(reason) {
41
+ process.stdout.write(
42
+ JSON.stringify({
43
+ hookSpecificOutput: {
44
+ hookEventName: 'PreToolUse',
45
+ permissionDecision: 'deny',
46
+ permissionDecisionReason: reason,
47
+ },
48
+ }) + '\n',
49
+ )
50
+ process.exit(0)
51
+ }
52
+
53
+ function readPayload() {
54
+ try {
55
+ const parsed = JSON.parse(fs.readFileSync(0, 'utf8'))
56
+ return parsed && typeof parsed === 'object' ? parsed : null
57
+ } catch {
58
+ return null
59
+ }
60
+ }
61
+
62
+ // Identical to `main-guard.cjs`'s, deliberately — see the reasons there.
63
+ const ENGINES = ['skitterspec', 'skitterspec-linear', 'skitterspec-jira', 'skitterspec-github', 'skitterspec-azure-boards']
64
+
65
+ function findEngine(projectDir, platform = process.platform) {
66
+ if (process.env.SKITTERSPEC_BIN) return process.env.SKITTERSPEC_BIN
67
+ let at = projectDir
68
+ for (let i = 0; i < 6 && at; i++) {
69
+ for (const name of ENGINES) {
70
+ const candidate =
71
+ platform === 'win32'
72
+ ? path.join(at, 'node_modules', '@skitterbyte', name, 'bin', `${name}.js`)
73
+ : path.join(at, 'node_modules', '.bin', name)
74
+ if (fs.existsSync(candidate)) return candidate
75
+ }
76
+ const up = path.dirname(at)
77
+ if (up === at) break
78
+ at = up
79
+ }
80
+ return 'skitterspec'
81
+ }
82
+
83
+ function engineCommand(projectDir, platform = process.platform) {
84
+ const engine = findEngine(projectDir, platform)
85
+ return /\.[cm]?js$/i.test(engine) ? { file: process.execPath, args: [engine] } : { file: engine, args: [] }
86
+ }
87
+
88
+ const WRITE_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit', 'MultiEdit'])
89
+
90
+ function writeTarget(input) {
91
+ if (!input || typeof input !== 'object') return null
92
+ for (const key of ['file_path', 'notebook_path']) {
93
+ if (typeof input[key] === 'string' && input[key]) return input[key]
94
+ }
95
+ return null
96
+ }
97
+
98
+ // A command that cannot be one the guard is about — no git, no engine — is let
99
+ // through without starting the engine at all. This hook fires on every Bash
100
+ // call, and most of them are neither.
101
+ function mayConcern(command) {
102
+ return /\bgit\b|skitterspec/.test(command)
103
+ }
104
+
105
+ // Inside the home checkout itself: certainly home, no engine needed. A
106
+ // worktree lives elsewhere, so a path outside this is still asked about.
107
+ function insideHome(home, target) {
108
+ const rel = path.relative(home, path.resolve(home, target))
109
+ return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))
110
+ }
111
+
112
+ function isRefusal(stdout) {
113
+ return /^spec-env project: /m.test(stdout || '')
114
+ }
115
+
116
+ function homeDir() {
117
+ // `${CLAUDE_PROJECT_DIR}` is the project the harness started in; the script's
118
+ // own location is the same answer when it is not set.
119
+ return process.env.CLAUDE_PROJECT_DIR || path.resolve(__dirname, '..', '..')
120
+ }
121
+
122
+ function main() {
123
+ const payload = readPayload()
124
+ if (!payload) allow()
125
+
126
+ const home = homeDir()
127
+ const cwd = typeof payload.cwd === 'string' && payload.cwd ? payload.cwd : process.cwd()
128
+ const session = typeof payload.session_id === 'string' ? payload.session_id : ''
129
+ const argv = ['spec-env', 'project', 'check', '--dir', home, '--cwd', cwd]
130
+
131
+ if (WRITE_TOOLS.has(payload.tool_name)) {
132
+ const target = writeTarget(payload.tool_input)
133
+ if (!target || insideHome(home, path.resolve(cwd, target))) allow()
134
+ argv.push('--path', path.resolve(cwd, target))
135
+ } else if (payload.tool_name === 'Bash') {
136
+ const command = payload.tool_input && payload.tool_input.command
137
+ if (typeof command !== 'string' || !mayConcern(command)) allow()
138
+ argv.push('--command', command)
139
+ } else {
140
+ allow()
141
+ }
142
+ if (session) argv.push('--session', session)
143
+
144
+ const engine = engineCommand(home)
145
+ const result = spawnSync(engine.file, [...engine.args, ...argv], { cwd: home, encoding: 'utf8', timeout: 8000 })
146
+ if (result.error || result.status !== 1) allow()
147
+ // Exit 1 alone is a crash as often as a refusal; the printed line decides.
148
+ const said = (result.stdout || '').trim()
149
+ if (!isRefusal(said)) allow()
150
+ deny(said)
151
+ }
152
+
153
+ if (require.main === module) {
154
+ try {
155
+ main()
156
+ } catch {
157
+ allow()
158
+ }
159
+ }
160
+
161
+ module.exports = { findEngine, engineCommand, WRITE_TOOLS, writeTarget, mayConcern, insideHome, isRefusal }
@@ -21,6 +21,7 @@ and lifecycle stay consistent. Each sets a status on the spec header
21
21
  | `/spec-complete` | Verify all phases done + tests green; land + tear down | `Complete` | `specs/complete/` |
22
22
  | `/spec-cancel` | Record progress, stamp a reason on the header; tear down | `Cancelled` | `specs/cancelled/` |
23
23
  | `/spec-tada` | A ta-da list — recap what you did in Claude Code over a window, across every project, by project then spec, ending in a standup. Read-only | (unchanged) | (unchanged) |
24
+ | `/spec-todo` | The morning half — where each project was left on the last working day, what is waiting on you, what to pick up first. Read-only | (unchanged) | (unchanged) |
24
25
  | `/spec-init` | Bootstrap/repair this workflow in a project (idempotent) | — | — |
25
26
 
26
27
  **Skills vs commands.** The table above lists **skills** — Claude reads them and
@@ -84,6 +85,17 @@ by a branch that happens to contain it — a spec branch cut this afternoon
84
85
  contains all of this morning. It is model-invocable, because "what did I do
85
86
  today?" should reach it.
86
87
 
88
+ **It leads with the wins, and it acts on nothing outside home.** The digest
89
+ marks a completed bug, hotfix or incident as `★ saved bacon` and any other
90
+ completed spec or a cut release as `★ win`, so the evening answer to *did I get
91
+ anything done?* opens with the evidence. It also marks the project the run
92
+ started from as `(here)`, and the report's closing `Next` — the line a reader
93
+ copies — names only that project's work: other projects' next steps are
94
+ suggestions in their own sections. **`/spec-todo`** is the morning half
95
+ (`skitterspec todo`): the last day with any activity, up to 14 days back, each
96
+ open spec where it was left, the verdicts waiting and gates armed, and today
97
+ so far — home first, and listed even when nothing happened there.
98
+
87
99
  **A report covers one category.** `project.category` in `env.config.json`
88
100
  decides which projects share a report — only those with the category of the
89
101
  repo it runs from, and an uncategorised project is in nobody's but its own
@@ -131,6 +143,21 @@ the guard, and only a person can type it. That asymmetry is the same line
131
143
  `/spec-reviewed` draws, and `spec-planning.md` already records that prose alone
132
144
  did not hold it once.
133
145
 
146
+ **`/allow-project` is its twin, for the other direction.** The main guard
147
+ stops work landing where it should not happen; `.claude/hooks/project-guard.cjs`
148
+ stops a session doing work that is **not its project's**. A session belongs to
149
+ the project it was started in, and a report read across projects once ended on
150
+ another repo's `/spec-complete` — which the session ran, `cd`-ing over there to
151
+ do it. So a write, a `git` change or a `skitterspec` lifecycle command aimed at
152
+ another skitterspec project (a checkout with `specs/.core/`) is refused, while
153
+ reads (`git log`, `skitterspec tada`) and every other program pass. Home is the
154
+ project the hook is installed in, never the session's cwd, because after a `cd`
155
+ the cwd is the thing being judged. `skitterspec spec-env project
156
+ <check|allow|status>` is the engine, `guards.projectBoundary` turns it off, and
157
+ it fails open on every cannot-tell. `/allow-project <name>` lifts it for one
158
+ session, and it is user-only for `/allow-main`'s reason: Claude must not be
159
+ able to lift a guard aimed at Claude.
160
+
134
161
  **`/spec-skip` is the fifth command**, and it is user-only for `/allow-main`'s
135
162
  reason rather than the mild one: it lifts the review gate, which is a guard
136
163
  aimed at Claude. It pre-executes `skitterspec spec-env review skip "<reason>"`
@@ -214,7 +241,7 @@ your canonical `localhost` ports so you can test it at the normal URL
214
241
  move, header edits, the code) happens on the spec's branch in the worktree; `main`
215
242
  changes only when it merges. Teardown is folded into `/spec-complete` ·
216
243
  `/spec-cancel`. Beneath the skills, `skitterspec spec-env
217
- <up|bootstrap|nospec|main|down|prune|dev|connect|integrate|disposition|handoff|hotfix|live|review|stage|status|resolve|base>` is the CLI
244
+ <up|bootstrap|nospec|main|project|down|prune|dev|connect|integrate|disposition|handoff|hotfix|live|review|stage|status|resolve|base>` is the CLI
218
245
  engine. `up` plans the fork;
219
246
  **`bootstrap` then runs the worktree's own steps itself** — seeding the gitignored files, the env file, `setup`, the stack — so
220
247
  the command a skill runs names no file, and a secrets hook that refuses any
@@ -236,7 +263,8 @@ when `env.config.json` is absent — every skill then behaves as it does today.
236
263
  runs a spec's *own* dev stack and proxies the canonical ports to it (one stack per
237
264
  spec). **Live overlay** instead reuses the one dev server you already have running:
238
265
  `/spec-live <spec>` — or a bare `/spec-live`, which takes the spec you are
239
- standing on — rebases the branch onto base, frees it from its worktree, and
266
+ standing on — rebases the branch onto base (the fetched remote base under PR
267
+ landing), frees it from its worktree, and
240
268
  checks it out **in the primary checkout**, so your running server hot-reloads the
241
269
  feature at the normal URL — no second stack, no proxy. Bare only acts when there
242
270
  is exactly one answer *and* the workbench is free; anything else prints the
@@ -248,6 +276,10 @@ thumb: **live overlay is the light default for *testing* a code-only spec** —
248
276
  is not how work gets started, and no lifecycle skill invokes it; it *refuses*
249
277
  stateful ones (`Stack: worktree + docker`, or a branch touching migrations) — keep
250
278
  `/spec-connect` + a Docker stack for those, and for genuinely parallel testing.
279
+ `live.afterSwitch` is the switch's counterpart of `afterLand` — the same
280
+ `{ run, when }` entries, run in the primary checkout after take and again after
281
+ release, so a changed lockfile or schema is caught up both ways. The engine runs
282
+ them itself, since `/spec-live` has no turn to run anything after it.
251
283
  Beneath it, `skitterspec spec-env live <take|release|abort|status>` is the engine.
252
284
 
253
285
  **Authoring a spec is work, so it happens off the base branch too (`/spec`).**
@@ -27,7 +27,7 @@ clobber customised content. Finish with a summary of created vs already-present.
27
27
  > **Leave alone**. Non-interactively it only adds what's missing; `--resync` /
28
28
  > `--reset` (reset needs `--yes`) drive the stronger actions.
29
29
 
30
- The system is **sixteen skills**: `spec` (feature, chore or issue), `spec-bug` (bug),
30
+ The system is **seventeen skills**: `spec` (feature, chore or issue), `spec-bug` (bug),
31
31
  `spec-hotfix` (a bug fixed on a released tag),
32
32
  `spec-incident` (a live outage, recorded as it happens),
33
33
  `no-spec` (work that genuinely has none — off the base branch all the same),
@@ -36,6 +36,7 @@ The system is **sixteen skills**: `spec` (feature, chore or issue), `spec-bug` (
36
36
  `spec-reviewed` (pick up a review you approved on that page),
37
37
  `spec-epic-next` (name the epic member that can start now), `spec-to-main`,
38
38
  `spec-complete`, `spec-cancel`, `spec-tada` (a ta-da list of what got done),
39
+ `spec-todo` (where you left off, and what is ahead),
39
40
  and this `spec-init`. The lifecycle is `backlog → in-progress → complete / cancelled`,
40
41
  with `.core` holding always-apply project rules.
41
42
 
@@ -69,6 +69,15 @@ do not paste it anywhere else, and never publish it.
69
69
 
70
70
  ## 2. Write the recap
71
71
 
72
+ **Open with the wins.** The evening question this answers is usually *did I
73
+ get anything done?*, and the answer is nearly always more than it felt like.
74
+ Before the projects, a short **Wins** list from the digest's `★` lines:
75
+ `★ saved bacon` (a bug, hotfix or incident finished — something was broken and
76
+ now is not) first, then `★ win` (a spec completed, a release cut). You may
77
+ promote **one** more from the prompts — a long fight with one problem that
78
+ ended in a fix, say — and only with its evidence in the same line. Never
79
+ invent one, and leave the section out on a day with none.
80
+
72
81
  One section per project, then one entry per group. A group headed by a spec
73
82
  (`feat-orders [#12]`) is that spec's work wherever it happened — its branch, its
74
83
  worktree, or a commit on the base naming it. A group headed `<branch> — no spec`
@@ -88,6 +97,14 @@ For each group, say what applies and skip what does not:
88
97
  - **In flight** — the `in flight:` line: where the spec stands and its next
89
98
  action, as the engine wrote it.
90
99
 
100
+ **Only the `(here)` project's next actions are commands.** The project marked
101
+ `(here)` is the one this session was started in, and it is the only one this
102
+ session acts on. For every other project, say where it stands as a suggestion
103
+ in its own section — *"ereqs has chore-perf-alerts ready to complete"* — never
104
+ as a bare `/spec-…` command. A command at the bottom of a report is what gets
105
+ copied and run, and running it from here means working on another repo from a
106
+ session that does not belong to it.
107
+
91
108
  Name a spec by its folder and its ticket exactly as the digest gives them. Keep
92
109
  each entry to a line or two; a project with only in-flight rows gets one line
93
110
  listing them.
@@ -95,9 +112,13 @@ listing them.
95
112
  Then the **standup** — three lines, no more:
96
113
 
97
114
  - **Done:** the work that landed or moved, across every project.
98
- - **Next:** the in-flight next actions that matter most.
99
- - **Blockers:** a verdict waiting, a gate armed, a wait unmet — or `none`.
100
- Only what the digest shows; never invent one.
115
+ - **Next:** the `(here)` project's in-flight next actions that matter most —
116
+ or `nothing in flight here`.
117
+ - **Blockers:** the `(here)` project's — a verdict waiting, a gate armed, a
118
+ wait unmet — or `none`. Only what the digest shows; never invent one.
119
+
120
+ **A quiet today points at the morning.** Run with no window flag and nothing
121
+ in it, say once in `Notes` that `/spec-todo` answers *where did I leave off*.
101
122
 
102
123
  ## 3. The page — only when asked
103
124
 
@@ -147,7 +168,8 @@ what is specific here.
147
168
  page's tiers (or its `file://` path) when one was rendered. `Notes` carries the digest's own closing
148
169
  lines (`cannot tell`, torn-down worktrees counted elsewhere) and, when no page
149
170
  was asked for, that `--page` renders one. `Next` is the one
150
- in-flight action the standup put first, or `nothing in flight`.
171
+ in-flight action the standup put first — the `(here)` project's, never
172
+ another's — or `nothing in flight here`.
151
173
 
152
174
  **`Follow-ups` is always `none` here.** This skill reports work; anything it
153
175
  notices belongs to the spec it is about.
@@ -0,0 +1,101 @@
1
+ ---
2
+ name: spec-todo
3
+ description: The morning half of the ta-da list — where each project was left on the last day you worked (Monday reads Friday), what is still open, what is waiting on you, and what to pick up first, ending in a three-line standup. Read-only. Use when the user says "/spec-todo", "where did I leave off", "what's on today", "what was I doing", "morning summary", or starts a day asking what is next.
4
+ ---
5
+
6
+ # /spec-todo — where you left off, and what is ahead
7
+
8
+ > Stay silent while this runs — speak only to ask something you cannot answer
9
+ > yourself, or to report a failure at the moment it happens. Read
10
+ > `.claude/rules/spec-reports.md` before reporting; it defines the block this
11
+ > skill ends with.
12
+
13
+ Read-only. It writes nothing, commits nothing and publishes nothing. `/spec-tada`
14
+ answers the evening question — *did I get anything done?* — and this answers the
15
+ morning one: *where was I, and what now?*
16
+
17
+ ## 1. Get the to-do
18
+
19
+ ```
20
+ skitterspec todo [--here | --all-projects]
21
+ ```
22
+
23
+ - **`--here`** — "this repo", "this project": only the repo the session is
24
+ standing in.
25
+ - **`--all-projects`** — "everything", "work and personal": every project on the
26
+ machine.
27
+
28
+ There is no window to choose. The engine finds the **last day with any activity**
29
+ before today — up to 14 days back, so a Monday reads Friday and a day off is
30
+ skipped — and reads that day, plus today so far. It is scoped by
31
+ `project.category` exactly as `/spec-tada` is, and names the category on its
32
+ first line when there is one.
33
+
34
+ **Read the text form, never `--json`**, and **never read a transcript yourself** —
35
+ the same two rules, for the same reasons, as `/spec-tada`. The output quotes the
36
+ person's own prompts; it stays in this conversation and is never published.
37
+
38
+ What the lines mean:
39
+
40
+ - `(here)` — the project this session was started in. It is listed first, and
41
+ it is listed even on a morning nothing happened there, with its open specs.
42
+ - `left:` — the last move or commit on that spec, the day it was left.
43
+ - `- …` — the last thing typed on it: what was on the person's mind when they
44
+ stopped.
45
+ - `in flight:` — where the spec stands now, and its next action.
46
+ - `finished:` — the specs that day completed or cancelled, by name.
47
+ - `blocked:` — a review verdict waiting, or a gate armed by a phase that ended
48
+ and still owes an answer. Read only for specs in flight.
49
+ - `today:` — commits and moves since midnight, when there are any.
50
+
51
+ ## 2. Write the recap
52
+
53
+ One short section per project, `(here)` first. For each open spec, one line:
54
+ where it was left and what is next, in plain words. Then `finished:` as one line
55
+ and `blocked:` lines as they are — a blocker is the thing most worth seeing in
56
+ the morning.
57
+
58
+ **Only the `(here)` project's next actions are commands.** Every other project's
59
+ are suggestions in its own section — *"ereqs has chore-perf-alerts ready to
60
+ complete"* — never a bare `/spec-…`. This session acts on the project it was
61
+ started in; the others are picked up in a session of their own.
62
+
63
+ Then the **standup** — three lines, no more:
64
+
65
+ - **Left off:** where yesterday (or the last working day) ended, across every
66
+ project — a line, not a list.
67
+ - **Today:** the `(here)` project's first one or two actions — or
68
+ `nothing in flight here`.
69
+ - **Blockers:** the `(here)` project's `blocked:` lines — or `none`. Only what
70
+ the output shows; never invent one.
71
+
72
+ A fortnight with nothing in it is still an answer: say so, and name what is in
73
+ flight in the home project if anything is.
74
+
75
+ ## 3. The page — only when asked
76
+
77
+ Exactly as `/spec-tada` §3, with `skitterspec todo <the same flags> --page
78
+ --summary <that file>`. It is served beside the ta-da page where the project has
79
+ a review server, and is a `file://` page where it does not. Never publish it.
80
+
81
+ ## Report
82
+
83
+ The recap and standup are the body of the message; the block follows them and
84
+ is the last thing in it.
85
+
86
+ **Verdicts**
87
+
88
+ - `✅` — the to-do is written. Nothing in 14 days is still `✅`, said as such.
89
+ - `⚠️` — written, but the output said `cannot tell` somewhere. Name it in
90
+ `Notes`.
91
+
92
+ **Fields:** `Built` · `Notes` · `Follow-ups` · `Next`
93
+
94
+ `Built` is the day it read as "left off" and the counts — projects, open specs,
95
+ blockers — and the page's tiers (or its `file://` path) when one was rendered.
96
+ `Notes` carries the output's own closing lines and, when no page was asked for,
97
+ that `--page` renders one. `Next` is the `(here)` project's first action, or
98
+ `nothing in flight here` — never another project's.
99
+
100
+ **`Follow-ups` is always `none` here.** This skill reports work; anything it
101
+ notices belongs to the spec it is about.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@skitterbyte/skitterspec-jira",
3
- "version": "2.9.1",
3
+ "version": "2.11.0",
4
4
  "description": "Spec-driven development for Claude Code, with one-way Jira Cloud sync — a superset of @skitterbyte/skitterspec: the base filesystem workflow plus /spec-status · /spec-push and the spec-sync CLI. The repo is canonical; Jira is a generated mirror. Install this OR the base OR the Linear superset — exactly one.",
5
5
  "keywords": [
6
6
  "claude",