@1aboveio/skills 0.0.0-stage → 1.0.0

package/skills/engineering/resolve-issues/scripts/ready-check.test.mjs

@@ -0,0 +1,217 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { chmodSync, mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { DEFAULT_LABEL, ReadyCheckError, parseArgs, parseIssueRef, readyCheck, treeFetchers } from './ready-check.mjs'
+
+const script = join(dirname(fileURLToPath(import.meta.url)), 'ready-check.mjs')
+
+// A small in-memory GitHub: issues keyed "owner/name#n", sub-issues as API-shaped children.
+function fakeGithub(issues, subIssues = {}) {
+  return {
+    fetchIssue: ({ repo, number }) => {
+      const issue = issues[`${repo}#${number}`]
+      if (!issue) throw new Error(`HTTP 404 ${repo}#${number}`)
+      return issue
+    },
+    fetchSubIssues: ({ repo, number }) => (subIssues[`${repo}#${number}`] || []).map((ref) => {
+      const [childRepo, n] = ref.split('#')
+      return { number: Number(n), repository_url: `https://api.github.com/repos/${childRepo}` }
+    }),
+  }
+}
+const issue = (labels, state = 'open', title = 't') => ({ state, title, labels: labels.map((name) => ({ name })) })
+
+test('the default label is ready-for-agent', () => {
+  assert.equal(DEFAULT_LABEL, 'ready-for-agent')
+})
+
+test('an issue and all its sub-issues labeled ready passes', () => {
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['epic', 'ready-for-agent']), 'o/r#2': issue(['ready-for-agent']), 'o/r#3': issue(['Ready-For-Agent']) },
+    { 'o/r#1': ['o/r#2', 'o/r#3'] },
+  )
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, true)
+  assert.equal(result.checked.length, 3, 'label match ignores case')
+})
+
+test('an epic without the label passes when all its open sub-issues are ready', () => {
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['epic']), 'o/r#2': issue(['ready-for-agent']), 'o/r#3': issue(['epic']), 'o/r#4': issue(['ready-for-agent']) },
+    { 'o/r#1': ['o/r#2', 'o/r#3'], 'o/r#3': ['o/r#4'] },
+  )
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, true)
+  assert.deepEqual(result.checked.filter((c) => c.exempt).map((c) => c.ref), ['o/r#1', 'o/r#3'], 'nested epics are exempt too')
+})
+
+test('an epic without the label still reports a sub-issue that is not ready', () => {
+  const gh = fakeGithub({ 'o/r#1': issue(['epic']), 'o/r#2': issue(['triage']) }, { 'o/r#1': ['o/r#2'] })
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, false)
+  assert.deepEqual(result.missing.map((m) => m.ref), ['o/r#2'])
+})
+
+test('an open issue whose sub-issues are all closed is a unit again: a rollup that needs the label', () => {
+  // #1343 was held, its prerequisite #1659 was filed under it and closed: the old check
+  // called #1343 resolved and the run dropped its remaining work.
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['epic']), 'o/r#2': issue([], 'closed'), 'o/r#3': issue(['ready-for-agent']), 'o/r#4': issue([], 'closed') },
+    { 'o/r#1': ['o/r#2'], 'o/r#3': ['o/r#4'] },
+  )
+  const result = readyCheck([{ repo: 'o/r', number: 1 }, { repo: 'o/r', number: 3 }], gh)
+  assert.equal(result.ready, false)
+  assert.deepEqual(result.missing.map((m) => m.ref), ['o/r#1'])
+  assert.deepEqual(result.rollups.map((r) => r.ref), ['o/r#1', 'o/r#3'])
+})
+
+test('an epic whose only open sub-issue is a rollup stays a container', () => {
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['epic']), 'o/r#2': issue(['ready-for-agent']), 'o/r#3': issue([], 'closed') },
+    { 'o/r#1': ['o/r#2'], 'o/r#2': ['o/r#3'] },
+  )
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, true)
+  assert.equal(result.checked.find((c) => c.ref === 'o/r#1').exempt, 'has open sub-issues')
+  assert.deepEqual(result.rollups.map((r) => r.ref), ['o/r#2'])
+})
+
+test('a plain issue with no sub-issues is a unit, not a rollup', () => {
+  const gh = fakeGithub({ 'o/r#1': issue([]) })
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, false)
+  assert.deepEqual(result.rollups, [])
+})
+
+test('an epic with an unreadable sub-issue is neither exempt nor a rollup', () => {
+  const gh = fakeGithub({ 'o/r#1': issue(['epic']) }, { 'o/r#1': ['o/r#404'] })
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, false)
+  assert.deepEqual(result.missing.map((m) => m.ref), ['o/r#1'])
+  assert.deepEqual(result.unreadable.map((m) => m.ref), ['o/r#404'])
+  const partly = fakeGithub({ 'o/r#1': issue(['epic']), 'o/r#2': issue([], 'closed') }, { 'o/r#1': ['o/r#2', 'o/r#404'] })
+  assert.deepEqual(readyCheck([{ repo: 'o/r', number: 1 }], partly).rollups, [], 'one closed plus one unreadable is not a rollup')
+})
+
+test('tree fetchers answer from the GraphQL tree and fall back to REST for the rest', () => {
+  const tree = { nodes: {
+    'o/r#1': { key: 'o/r#1', state: 'open', title: 'epic', labels: ['epic'], children: ['o/r#2', 'x/y#9'] },
+    'o/r#2': { key: 'o/r#2', state: 'open', title: 'a', labels: ['ready-for-agent'], children: [] },
+    'x/y#9': { key: 'x/y#9', state: 'open', title: 'deep', labels: ['ready-for-agent'], children: null },
+  } }
+  const calls = []
+  const rest = fakeGithub({ 'x/y#10': issue(['ready-for-agent']) }, { 'x/y#9': ['x/y#10'] })
+  const fallback = { fetchIssue: (r) => { calls.push(`issue ${r.repo}#${r.number}`); return rest.fetchIssue(r) }, fetchSubIssues: (r) => { calls.push(`subs ${r.repo}#${r.number}`); return rest.fetchSubIssues(r) } }
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], treeFetchers([tree], fallback))
+  assert.equal(result.ready, true)
+  assert.deepEqual(calls, ['subs x/y#9', 'issue x/y#10', 'subs x/y#10'], 'only the part the tree did not cover hits REST')
+})
+
+test('a sub-issue shared by two epics makes both containers', () => {
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['epic']), 'o/r#2': issue(['epic']), 'o/r#3': issue(['ready-for-agent']) },
+    { 'o/r#1': ['o/r#3'], 'o/r#2': ['o/r#3'] },
+  )
+  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }, { repo: 'o/r', number: 2 }], gh).ready, true)
+})
+
+test('a sub-issue at any depth, in another repository, without the label is reported', () => {
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['ready-for-agent']), 'o/r#2': issue(['ready-for-agent']), 'x/y#9': issue(['bug']) },
+    { 'o/r#1': ['o/r#2'], 'o/r#2': ['x/y#9'] },
+  )
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, false)
+  assert.deepEqual(result.missing, [{ ref: 'x/y#9', title: 't', labels: ['bug'], parent: 'o/r#2' }])
+  assert.equal(result.checked.find((c) => c.ref === 'x/y#9').depth, 2)
+})
+
+test('closed sub-issues are skipped; a closed named issue is still checked', () => {
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['ready-for-agent']), 'o/r#2': issue([], 'closed'), 'o/r#5': issue([], 'closed') },
+    { 'o/r#1': ['o/r#2'] },
+  )
+  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], gh).ready, true)
+  assert.equal(readyCheck([{ repo: 'o/r', number: 5 }], gh).ready, false)
+})
+
+test('an unreadable issue or sub-issue list fails closed', () => {
+  const gh = fakeGithub({ 'o/r#1': issue(['ready-for-agent']) }, { 'o/r#1': ['o/r#404'] })
+  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
+  assert.equal(result.ready, false)
+  assert.equal(result.unreadable[0].ref, 'o/r#404')
+  const brokenList = { ...gh, fetchSubIssues: () => { throw new Error('HTTP 502') } }
+  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], brokenList).ready, false)
+})
+
+test('a sub-issue loop is walked once', () => {
+  const gh = fakeGithub(
+    { 'o/r#1': issue(['ready-for-agent']), 'o/r#2': issue(['ready-for-agent']) },
+    { 'o/r#1': ['o/r#2'], 'o/r#2': ['o/r#1'] },
+  )
+  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], gh).checked.length, 2)
+})
+
+test('a custom label is honored', () => {
+  const gh = fakeGithub({ 'o/r#1': issue(['agent-ok']) })
+  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], { ...gh, label: 'agent-ok' }).ready, true)
+  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], gh).ready, false)
+})
+
+test('issue references accept owner/name#n, URLs, and bare numbers with a repo', () => {
+  assert.deepEqual(parseIssueRef('o/r#12'), { repo: 'o/r', number: 12 })
+  assert.deepEqual(parseIssueRef('https://github.com/o/r/issues/7'), { repo: 'o/r', number: 7 })
+  assert.deepEqual(parseIssueRef('#3', 'o/r'), { repo: 'o/r', number: 3 })
+  assert.throws(() => parseIssueRef('3'), ReadyCheckError)
+  assert.throws(() => parseArgs([]), ReadyCheckError)
+  assert.throws(() => parseArgs(['--bogus']), ReadyCheckError)
+})
+
+// ---- CLI against a fake `gh` on PATH ----
+
+function withFakeGh(responses) {
+  const dir = mkdtempSync(join(tmpdir(), 'ready-check-gh-'))
+  const cases = Object.entries(responses)
+    .map(([path, body]) => `  "${path}") cat <<'EOF'\n${JSON.stringify(body)}\nEOF\n  ;;`)
+    .join('\n')
+  // gh api [--paginate --slurp] <path>: the path is the last argument.
+  writeFileSync(join(dir, 'gh'), `#!/bin/sh\nfor last; do :; done\ncase "$last" in\n${cases}\n  *) echo "HTTP 404" >&2; exit 1 ;;\nesac\n`)
+  chmodSync(join(dir, 'gh'), 0o755)
+  return { ...process.env, PATH: `${dir}:${process.env.PATH}` }
+}
+
+test('CLI exits 0 with the outcome in the output, 2 on bad input; --exit-outcome restores the old codes', () => {
+  const env = withFakeGh({
+    'repos/o/r/issues/1': issue(['ready-for-agent']),
+    'repos/o/r/issues/1/sub_issues': [[{ number: 2, repository_url: 'https://api.github.com/repos/o/r' }]],
+    'repos/o/r/issues/2': issue(['triage'], 'open', 'Add login'),
+    'repos/o/r/issues/2/sub_issues': [[]],
+    'repos/o/r/issues/3': issue(['ready-for-agent']),
+    'repos/o/r/issues/3/sub_issues': [[]],
+  })
+  const ok = spawnSync(process.execPath, [script, '--issue', 'o/r#3'], { env, encoding: 'utf8' })
+  assert.equal(ok.status, 0, ok.stderr)
+  assert.equal(JSON.parse(ok.stdout).outcome, 'ready')
+  const unlabeled = spawnSync(process.execPath, [script, '--repo', 'o/r', '--issue', '1'], { env, encoding: 'utf8' })
+  assert.equal(unlabeled.status, 0, unlabeled.stderr)
+  assert.equal(JSON.parse(unlabeled.stdout).outcome, 'unlabeled')
+  assert.deepEqual(JSON.parse(unlabeled.stdout).missing, [{ ref: 'o/r#2', title: 'Add login', labels: ['triage'], parent: 'o/r#1' }])
+  const named = spawnSync(process.execPath, [script, '--issue', 'o/r#2'], { env, encoding: 'utf8' })
+  assert.equal(named.status, 0, named.stderr)
+  assert.equal(JSON.parse(named.stdout).missing[0].parent, null)
+  const unreadable = spawnSync(process.execPath, [script, '--issue', 'o/r#2', '--issue', 'o/r#404'], { env, encoding: 'utf8' })
+  assert.equal(unreadable.status, 0, unreadable.stderr)
+  assert.equal(JSON.parse(unreadable.stdout).outcome, 'unreadable', 'an unreadable issue outranks an unlabeled one')
+  const legacy = (...args) => spawnSync(process.execPath, [script, '--exit-outcome', ...args], { env, encoding: 'utf8' }).status
+  assert.equal(legacy('--issue', 'o/r#3'), 0)
+  assert.equal(legacy('--repo', 'o/r', '--issue', '1'), 3)
+  assert.equal(legacy('--issue', 'o/r#2', '--issue', 'o/r#404'), 1)
+  assert.equal(legacy(), 2)
+  const usage = spawnSync(process.execPath, [script], { env, encoding: 'utf8' })
+  assert.equal(usage.status, 2)
+})

package/skills/engineering/resolve-issues/scripts/rehydrate.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+// After a context compaction, tell the coordinator of a run in progress to read its skills in
+// full again: a compaction summary keeps the run's state but drops the skill's rules.
+//
+//   rehydrate.mjs [--cwd <dir>] [--hook]
+//
+// Finds runs under the nearest .resolve-issues/rush at or above <cwd> (a coordinator may stand
+// in a unit workspace inside the run), in */task-plan.json whose plan changed in the last
+// ACTIVE_HOURS and still has a unit not succeeded or cancelled. Prints nothing when there is
+// none, so a compaction in any other session adds nothing. Otherwise prints the SKILL.md paths
+// to read, each run, its next-actions command, and RULES.
+//
+// --hook reads the hook's JSON from stdin (its `cwd` wins over --cwd) and prints a SessionStart
+// `hookSpecificOutput`, the shape both Claude Code and Codex add to context. install-hooks.mjs
+// wires it to SessionStart with matcher `compact`; Pi's workflow extension runs the owner skill's
+// rehydrate.mjs (rush-issues/rehydrate.mjs runs this one) with --cwd after a compaction. Always
+// exits 0: a hook never blocks a session.
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs'
+import { RULES, SKILL_PATH } from './next-actions.mjs'
+
+export const ACTIVE_HOURS = 24
+const SCRIPTS = dirname(fileURLToPath(import.meta.url))
+const RUSH_SKILL_PATH = join(dirname(dirname(SCRIPTS)), 'rush-issues', 'SKILL.md')
+const DONE = new Set(['succeeded', 'cancelled'])
+
+// The nearest <dir>/.resolve-issues/rush at or above cwd, or null.
+export function runsRoot(cwd) {
+  for (let dir = resolve(cwd); ; dir = dirname(dir)) {
+    const root = join(dir, '.resolve-issues', 'rush')
+    if (existsSync(root)) return root
+    if (dirname(dir) === dir) return null
+  }
+}
+
+// Runs under runsRoot(cwd), newest first: { dir, skill, revision, open }.
+export function activeRuns(cwd, now = Date.now(), hours = ACTIVE_HOURS) {
+  const root = runsRoot(cwd)
+  if (!root) return []
+  let names = []
+  try { names = readdirSync(root) } catch { return [] }
+  const runs = []
+  for (const name of names) {
+    const file = join(root, name, 'task-plan.json')
+    let mtime
+    try { mtime = statSync(file).mtimeMs } catch { continue }
+    if (now - mtime > hours * 3_600_000) continue
+    let plan
+    try { plan = JSON.parse(readFileSync(file, 'utf8')) } catch { continue }
+    const units = (Array.isArray(plan?.units) ? plan.units : plan?.issues) ?? []
+    const open = units.filter((u) => !DONE.has(u?.status)).length
+    if (!open) continue
+    runs.push({ dir: join(root, name), skill: plan.skill ?? 'resolve-issues', revision: plan.planRevision ?? null, open, mtime })
+  }
+  return runs.sort((a, b) => b.mtime - a.mtime).map(({ mtime, ...r }) => r)
+}
+
+export function message(runs, { skillPath = SKILL_PATH, rushSkillPath = RUSH_SKILL_PATH } = {}) {
+  if (!runs.length) return ''
+  const skills = [skillPath]
+  if (runs.some((r) => r.skill === 'rush-issues') && existsSync(rushSkillPath)) skills.push(rushSkillPath)
+  const nextActions = join(dirname(skillPath), 'scripts', 'next-actions.mjs')
+  return [
+    'Your context was just compacted while you coordinate a resolve-issues run. The summary keeps the run\'s state, not the skill\'s rules.',
+    'Before your next step, read each of these in full, with no line limit:',
+    ...skills.map((s) => `- ${s}`),
+    'Read subagent_settings now and again immediately before each command below; inspect separately for every recovered run after earlier starts. Pass only that command\'s fresh structured snapshot with --capacity-json. There is no default worker count; if inspection is unavailable, follow the skill\'s explicit reconciled --slots fallback. The script exits 0 whenever it ran; read what is due from its output.',
+    'Runs in progress here:',
+    ...runs.map((r) => `- ${r.dir} (${r.skill}, plan revision ${r.revision ?? 'unknown'}, ${r.open} units open): refresh subagent_settings immediately before node ${nextActions} --run ${r.dir} --capacity-json '<fresh snapshot JSON>'`),
+    `Rules a compaction most often drops: ${RULES}`,
+  ].join('\n')
+}
+
+export function hookOutput(text) {
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text } })
+}
+
+// The CLI, exported so rush-issues/rehydrate.mjs can run it as its own.
+export function main(argv) {
+  try {
+    const hook = argv.includes('--hook')
+    let cwd = argv.includes('--cwd') ? argv[argv.indexOf('--cwd') + 1] : process.cwd()
+    if (hook) {
+      try { cwd = JSON.parse(readFileSync(0, 'utf8'))?.cwd || cwd } catch { /* no input: keep cwd */ }
+    }
+    const text = message(activeRuns(cwd))
+    if (text) process.stdout.write(hook ? `${hookOutput(text)}\n` : `${text}\n`)
+  } catch (error) {
+    process.stderr.write(`rehydrate: ${error.message}\n`)
+  }
+  process.exitCode = 0
+}
+
+if (isMainModule(import.meta.url)) main(process.argv.slice(2))

package/skills/engineering/resolve-issues/scripts/rehydrate.test.mjs

@@ -0,0 +1,91 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { activeRuns, message, ACTIVE_HOURS } from './rehydrate.mjs'
+import { RULES, SKILL_PATH } from './next-actions.mjs'
+
+const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'rehydrate.mjs')
+
+function repo(runs) {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'rehydrate-'))
+  for (const [name, plan, ageHours = 0] of runs) {
+    const dir = path.join(cwd, '.resolve-issues', 'rush', name)
+    fs.mkdirSync(dir, { recursive: true })
+    const file = path.join(dir, 'task-plan.json')
+    fs.writeFileSync(file, typeof plan === 'string' ? plan : JSON.stringify(plan))
+    const at = new Date(Date.now() - ageHours * 3_600_000)
+    fs.utimesSync(file, at, at)
+  }
+  return cwd
+}
+
+test('only a recent run with an open unit counts; finished, stale, and unreadable runs do not', () => {
+  const cwd = repo([
+    ['live', { skill: 'rush-issues', planRevision: 267, units: [{ id: '1', status: 'succeeded' }, { id: '2', status: 'in-flight' }, { id: '3', status: 'blocked' }] }, 1],
+    ['done', { units: [{ id: '1', status: 'succeeded' }, { id: '2', status: 'cancelled' }] }],
+    ['stale', { units: [{ id: '1', status: 'in-flight' }] }, ACTIVE_HOURS + 1],
+    ['broken', '{not json'],
+  ])
+  const runs = activeRuns(cwd)
+  assert.deepEqual(runs, [{ dir: path.join(cwd, '.resolve-issues', 'rush', 'live'), skill: 'rush-issues', revision: 267, open: 2 }])
+  assert.deepEqual(activeRuns(fs.mkdtempSync(path.join(os.tmpdir(), 'rehydrate-none-'))), [], 'no .resolve-issues: nothing')
+  const unit = path.join(cwd, '.resolve-issues', 'rush', 'live', 'units', '7')
+  fs.mkdirSync(unit, { recursive: true })
+  assert.deepEqual(activeRuns(unit), runs, 'a coordinator standing in a unit workspace still finds its run')
+})
+
+test('the message names both skills for a rush run, each run with its next-actions command, and the rules', () => {
+  const dir = '/repo/.resolve-issues/rush/r1'
+  const rush = path.join(path.dirname(path.dirname(SKILL_PATH)), 'rush-issues', 'SKILL.md')
+  const text = message([{ dir, skill: 'rush-issues', revision: 5, open: 3 }], { rushSkillPath: SKILL_PATH })
+  assert.match(text, /read each of these in full, with no line limit/)
+  assert.ok(text.includes(`- ${SKILL_PATH}\n`))
+  assert.ok(text.includes(`next-actions.mjs --run ${dir} --capacity-json '<fresh snapshot JSON>'`))
+  assert.match(text, /Read subagent_settings now/)
+  assert.match(text, /no default worker count/)
+  assert.ok(text.endsWith(RULES))
+  const plain = message([{ dir, skill: 'resolve-issues', revision: 5, open: 3 }], { rushSkillPath: rush })
+  assert.ok(!plain.includes('rush-issues/SKILL.md'), 'a resolve-issues run reads only its own skill')
+  assert.equal(message([]), '')
+})
+
+test('each recovered run refreshes capacity separately instead of reusing one snapshot', () => {
+  const text = message([
+    { dir: '/repo/.resolve-issues/rush/first', skill: 'resolve-issues', revision: 1, open: 6 },
+    { dir: '/repo/.resolve-issues/rush/second', skill: 'resolve-issues', revision: 2, open: 3 },
+  ])
+  const commands = text.split('\n').filter(line => line.includes('next-actions.mjs --run'))
+  assert.equal(commands.length, 2)
+  for (const command of commands) {
+    assert.match(command, /refresh subagent_settings immediately before node/)
+    assert.match(command, /--capacity-json '<fresh snapshot JSON>'/)
+  }
+})
+
+test('as a hook it reads cwd from stdin, prints SessionStart context, and prints nothing without a run', () => {
+  const cwd = repo([['live', { skill: 'resolve-issues', units: [{ id: '1', status: 'pending' }] }]])
+  const run = (input) => spawnSync(process.execPath, [SCRIPT, '--hook'], { input, encoding: 'utf8', cwd: os.tmpdir() })
+  const out = run(JSON.stringify({ hook_event_name: 'SessionStart', source: 'compact', cwd }))
+  assert.equal(out.status, 0)
+  const parsed = JSON.parse(out.stdout)
+  assert.equal(parsed.hookSpecificOutput.hookEventName, 'SessionStart')
+  assert.match(parsed.hookSpecificOutput.additionalContext, /Runs in progress here:/)
+  const empty = run(JSON.stringify({ cwd: fs.mkdtempSync(path.join(os.tmpdir(), 'rehydrate-empty-')) }))
+  assert.equal(empty.status, 0)
+  assert.equal(empty.stdout, '')
+  assert.equal(run('not json').status, 0, 'bad input never blocks a session')
+})
+
+test('rush-issues/rehydrate.mjs prints the same message, for a harness that runs the owner skill\'s script', () => {
+  const cwd = repo([['live', { skill: 'rush-issues', units: [{ id: '1', status: 'in-flight' }] }]])
+  const rush = path.join(path.dirname(path.dirname(SKILL_PATH)), 'rush-issues', 'rehydrate.mjs')
+  const out = spawnSync(process.execPath, [rush, '--cwd', cwd], { encoding: 'utf8' })
+  assert.equal(out.status, 0)
+  assert.equal(out.stdout, `${message(activeRuns(cwd))}\n`)
+  assert.match(out.stdout, /rush-issues\/SKILL\.md/)
+})