@1aboveio/skills 1.0.8 → 1.0.9

package/skills/engineering/resolve-issues/scripts/github-reviews.test.mjs

@@ -1,264 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import {
-  collectExternal,
-  fetchPr,
-  permissionFetcher,
-  findStructured,
-  handledIds,
-  mergeExternal,
-  parsePr,
-  run,
-  severityTag,
-  STRUCTURED_MARKER,
-} from './github-reviews.mjs'
-
-const HEAD = 'abc1234'
-const ROLES = { vera932: 'write', alo335: 'admin', reader: 'read' }
-const permissionOf = (login) => ROLES[login] ?? 'none'
-const review = (id, login, state, body = '', at = '2026-10-08T10:00:00Z', commit = HEAD) => ({
-  databaseId: id, author: { login }, state, body, submittedAt: at, url: `https://github.com/o/r/pull/1#pullrequestreview-${id}`, commit: { oid: commit },
-})
-const thread = (id, login, body, extra = {}) => ({
-  isResolved: false, isOutdated: false, ...extra,
-  comments: { nodes: [{ databaseId: id, author: { login }, body, path: 'src/a.ts', line: 12, url: `https://github.com/o/r/pull/1#discussion_r${id}`, originalCommit: { oid: HEAD } }] },
-})
-const pr = (parts = {}) => ({
-  author: { login: 'cory-bot' },
-  reviews: { nodes: parts.reviews ?? [] },
-  reviewThreads: { nodes: parts.threads ?? [] },
-  comments: { nodes: parts.comments ?? [] },
-})
-
-test('severity tags are read from the first line in the usual forms only', () => {
-  for (const [body, tag] of [
-    ['P1: refund sign flips', 'P1'], ['**P0** token leaks', 'P0'], ['[P1] missing check', 'P1'],
-    ['![P1 Badge](https://img.shields.io/badge/P1-orange) Wrong total', 'P1'], ['P2: rename', 'P2'],
-    ['**<sub><sub>![P1 Badge](https://img.shields.io/badge/P1-orange?style=flat)</sub></sub>  Keep the lock**', 'P1'],
-    ['<!-- codex-pull-request-review-summary -->', null],
-    ['Pretty sure this is fine', null], ['P10 items', null], ['nit\nP1: on line two', null], ['', null],
-  ]) assert.equal(severityTag(body), tag, body)
-})
-
-test('a trusted changes request is a P1 finding; approvals, dismissals and later approvals clear it', () => {
-  const blocked = collectExternal(pr({ reviews: [review(11, 'vera932', 'CHANGES_REQUESTED', 'Refund rounds the wrong way\nmore')] }), HEAD, { permissionOf })
-  assert.deepEqual(blocked.findings.map((f) => [f.id, f.severity, f.summary, f.author]), [['gh-review-11', 'P1', 'Refund rounds the wrong way', 'vera932']])
-  assert.match(blocked.findings[0].detail, /more/)
-  const cleared = collectExternal(pr({ reviews: [
-    review(11, 'vera932', 'CHANGES_REQUESTED', 'x', '2026-10-08T10:00:00Z'),
-    review(12, 'vera932', 'COMMENTED', 'thanks', '2026-10-08T11:00:00Z'),
-    review(13, 'vera932', 'APPROVED', '', '2026-10-08T12:00:00Z'),
-  ] }), HEAD, { permissionOf })
-  assert.deepEqual(cleared.findings, [])
-  const dismissed = collectExternal(pr({ reviews: [review(11, 'vera932', 'CHANGES_REQUESTED', 'x'), review(14, 'vera932', 'DISMISSED', '', '2026-10-08T12:00:00Z')] }), HEAD, { permissionOf })
-  assert.deepEqual(dismissed.findings, [])
-})
-
-test('only write access counts, and never the PR author', () => {
-  const external = collectExternal(pr({
-    reviews: [review(21, 'reader', 'CHANGES_REQUESTED', 'no'), review(22, 'cory-bot', 'CHANGES_REQUESTED', 'self')],
-    threads: [thread(31, 'codex-bot', 'P1: bot says'), thread(32, 'alo335', 'P1: maintainer says')],
-  }), HEAD, { permissionOf })
-  assert.deepEqual(external.findings.map((f) => f.id), ['gh-comment-32'])
-  assert.deepEqual(external.ignored.map((i) => [i.author, i.reason]).sort(), [
-    ['codex-bot', 'permission none'], ['cory-bot', 'PR author'], ['reader', 'permission read'],
-  ])
-})
-
-test('tagged comments block until resolved; P2/P3 and untagged comments never do', () => {
-  const external = collectExternal(pr({
-    threads: [
-      thread(41, 'vera932', '**P0** tenant check missing'),
-      thread(42, 'vera932', 'P1: resolved already', { isResolved: true }),
-      thread(43, 'vera932', 'P2: rename'),
-      thread(44, 'vera932', 'looks off to me'),
-    ],
-    reviews: [review(45, 'vera932', 'COMMENTED', '[P1] the export drops currency')],
-    comments: [{ databaseId: 46, author: { login: 'alo335' }, body: 'P1: migration not reversible', createdAt: '2026-10-08T10:00:00Z', url: 'u46' }],
-  }), HEAD, { permissionOf })
-  assert.deepEqual(external.findings.map((f) => [f.id, f.severity]), [['gh-comment-41', 'P0'], ['gh-comment-45', 'P1'], ['gh-comment-46', 'P1']])
-  assert.equal(external.findings[0].file, 'src/a.ts')
-  assert.equal(external.findings[0].line, 12)
-  const badge = collectExternal(pr({ threads: [thread(49, 'vera932', '**<sub><sub>![P1 Badge](https://img.shields.io/badge/P1-orange)</sub></sub>  Keep the lock**')] }), HEAD, { permissionOf })
-  assert.equal(badge.findings[0].summary, 'Keep the lock')
-})
-
-test('a changes request whose body is tagged counts once', () => {
-  const external = collectExternal(pr({ reviews: [review(47, 'vera932', 'CHANGES_REQUESTED', 'P1: wrong total')] }), HEAD, { permissionOf })
-  assert.deepEqual(external.findings.map((f) => f.id), ['gh-review-47'])
-})
-
-test('after a fix brief carried them, a standing changes request is awaited and a comment is dropped', () => {
-  const handled = new Set(['gh-review-11', 'gh-comment-41'])
-  const external = collectExternal(pr({
-    reviews: [review(11, 'vera932', 'CHANGES_REQUESTED', 'x', '2026-10-08T10:00:00Z', 'old1234')],
-    threads: [thread(41, 'vera932', 'P1: still unresolved'), thread(48, 'vera932', 'P1: new one')],
-  }), HEAD, { permissionOf, handled })
-  assert.deepEqual(external.findings.map((f) => f.id), ['gh-comment-48'])
-  assert.deepEqual(external.awaiting.map((a) => [a.id, a.author, a.commit]), [['gh-review-11', 'vera932', 'old1234']])
-  const rerequested = collectExternal(pr({ reviews: [
-    review(11, 'vera932', 'CHANGES_REQUESTED', 'x', '2026-10-08T10:00:00Z', 'old1234'),
-    review(15, 'vera932', 'CHANGES_REQUESTED', 'still wrong', '2026-10-08T13:00:00Z'),
-  ] }), HEAD, { permissionOf, handled })
-  assert.deepEqual(rerequested.findings.map((f) => f.id), ['gh-review-15'], 'a new changes request is a new finding')
-  assert.deepEqual(rerequested.awaiting, [])
-})
-
-test('the handled ledger carries forward and merge replaces what it added before', () => {
-  const prior = { findings: [{ id: 'gh-review-11', severity: 'P1' }, { id: 'R1', severity: 'P1' }], external: { added: ['gh-review-11'], handled: ['gh-comment-41'] } }
-  const brief = { fix: [{ id: 'gh-review-11' }, { id: 'R1' }] }
-  assert.deepEqual([...handledIds(prior, brief)].sort(), ['gh-comment-41', 'gh-review-11'])
-  assert.deepEqual([...handledIds(prior, null)], ['gh-comment-41'], 'no fix brief: the prior round handed nothing on')
-  assert.deepEqual([...handledIds(null)], [])
-  const own = { id: 'R2', severity: 'P1' }
-  const stale = { id: 'gh-comment-1', severity: 'P1', source: 'github' }
-  const fresh = { findings: [{ id: 'gh-comment-2', severity: 'P1', source: 'github' }], awaiting: [], ignored: [], head: HEAD, prAuthor: 'cory-bot' }
-  const merged = mergeExternal({ version: 1, findings: [own, stale], external: { added: ['gh-comment-1'] } }, fresh, new Set(['gh-review-11']))
-  assert.deepEqual(merged.findings.map((f) => f.id), ['R2', 'gh-comment-2'])
-  assert.deepEqual(merged.external.added, ['gh-comment-2'])
-  assert.deepEqual(merged.external.handled, ['gh-review-11'])
-})
-
-const PASSES = { spec: 'done', correctness: 'done', tests: 'done', standards: 'done' }
-const structuredBody = (head, extra = {}) => `${STRUCTURED_MARKER}\nReview by Agentier\n\n\`\`\`json\n${JSON.stringify({ version: 1, head, complete: true, passes: PASSES, findings: [], commands: ['npm test'], ...extra })}\n\`\`\`\n`
-
-test('a structured result stands in only when trusted and of this HEAD, newest first', () => {
-  const comments = [
-    { databaseId: 51, author: { login: 'alo335' }, body: structuredBody(HEAD, { commands: ['older'] }), createdAt: '2026-10-08T10:00:00Z', url: 'u51' },
-    { databaseId: 52, author: { login: 'alo335' }, body: structuredBody(HEAD, { commands: ['newer'] }), createdAt: '2026-10-08T11:00:00Z', url: 'u52' },
-    { databaseId: 53, author: { login: 'alo335' }, body: structuredBody('other99'), createdAt: '2026-10-08T12:00:00Z', url: 'u53' },
-    { databaseId: 54, author: { login: 'reader' }, body: structuredBody(HEAD, { commands: ['untrusted'] }), createdAt: '2026-10-08T13:00:00Z', url: 'u54' },
-    { databaseId: 55, author: { login: 'cory-bot' }, body: structuredBody(HEAD, { commands: ['self'] }), createdAt: '2026-10-08T14:00:00Z', url: 'u55' },
-    { databaseId: 56, author: { login: 'alo335' }, body: `${STRUCTURED_MARKER}\n\`\`\`json\n{not json\n\`\`\``, createdAt: '2026-10-08T15:00:00Z', url: 'u56' },
-  ]
-  const found = findStructured(pr({ comments }), HEAD, { permissionOf })
-  assert.deepEqual(found.result.commands, ['newer'])
-  assert.deepEqual(found.source, { kind: 'github', author: 'alo335', url: 'u52' })
-  assert.equal(findStructured(pr({ comments: comments.slice(2) }), HEAD, { permissionOf }), null)
-  const tagged = collectExternal(pr({ comments: [{ ...comments[0], body: structuredBody(HEAD, { findings: [{ id: 'R1', severity: 'P1' }] }).replace('Review by', 'P1 Review by') }] }), HEAD, { permissionOf })
-  assert.deepEqual(tagged.findings, [], 'a structured result is never read as a tagged comment')
-})
-
-test('parsePr takes owner/name#N only', () => {
-  assert.deepEqual(parsePr('1aboveio/ai#1545'), { owner: '1aboveio', name: 'ai', number: 1545 })
-  assert.throws(() => parsePr('1545'), /owner\/name#N/)
-})
-
-test('run merges into the round file using the prior beside it, and writes a structured result with the caller\'s counters', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'github-reviews-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const deps = (node) => ({ fetch: () => node, permissions: () => permissionOf })
-  writeFileSync(join(dir, '7-r1.json'), JSON.stringify({ findings: [{ id: 'gh-review-11', severity: 'P1', source: 'github' }], external: { added: ['gh-review-11'] } }))
-  writeFileSync(join(dir, '7-r1.fix.json'), JSON.stringify({ fix: [{ id: 'gh-review-11' }] }))
-  const path = join(dir, '7-r2.json')
-  writeFileSync(path, JSON.stringify({ version: 1, unit: '7', round: 2, head: HEAD, findings: [] }))
-  const node = pr({ reviews: [review(11, 'vera932', 'CHANGES_REQUESTED', 'x', '2026-10-08T10:00:00Z', 'old1234')], threads: [thread(61, 'vera932', 'P1: new')] })
-  const merged = run(['merge', '--pr', 'o/r#1', '--head', HEAD, '--review', path], deps(node))
-  assert.deepEqual(merged.out.awaiting.map((a) => a.id), ['gh-review-11'])
-  const file = JSON.parse(readFileSync(path, 'utf8'))
-  assert.deepEqual(file.findings.map((f) => f.id), ['gh-comment-61'])
-  assert.deepEqual(file.external.awaiting.map((a) => a.id), ['gh-review-11'])
-  assert.deepEqual(file.external.handled, ['gh-review-11'])
-
-  const out = join(dir, '7-r3.json')
-  const none = run(['structured', '--pr', 'o/r#1', '--head', HEAD, '--out', out, '--unit', '7', '--round', '3', '--fix-round', '2'], deps(pr()))
-  assert.equal(none.out.found, false)
-  const withResult = pr({ comments: [{ databaseId: 71, author: { login: 'alo335' }, body: structuredBody(HEAD, { unit: 'theirs', round: 9, fixRound: 9 }), createdAt: '2026-10-08T10:00:00Z', url: 'u71' }] })
-  const written = run(['structured', '--pr', 'o/r#1', '--head', HEAD, '--out', out, '--unit', '7', '--round', '3', '--fix-round', '2'], deps(withResult))
-  assert.equal(written.out.found, true)
-  const result = JSON.parse(readFileSync(out, 'utf8'))
-  assert.deepEqual([result.unit, result.round, result.fixRound, result.source.author], ['7', 3, 2, 'alo335'])
-  assert.throws(() => run(['merge', '--pr', 'o/r#1', '--head', HEAD], deps(node)), /usage/)
-})
-
-test('a GitHub finding from an incomplete or handed-back round is not handled: it still blocks', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'github-reviews-nofix-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  // round 1 was incomplete (or handed back): the verdict wrote no fix brief
-  writeFileSync(join(dir, '7-r1.json'), JSON.stringify({ complete: false, findings: [{ id: 'gh-comment-1', severity: 'P1', source: 'github' }], external: { added: ['gh-comment-1'] } }))
-  const path = join(dir, '7-r2.json')
-  writeFileSync(path, JSON.stringify({ version: 1, unit: '7', round: 2, head: HEAD, findings: [] }))
-  run(['merge', '--pr', 'o/r#1', '--head', HEAD, '--review', path], { fetch: () => pr({ threads: [thread(1, 'vera932', 'P1: still broken')] }), permissions: () => permissionOf })
-  assert.deepEqual(JSON.parse(readFileSync(path, 'utf8')).findings.map((f) => f.id), ['gh-comment-1'])
-})
-
-test('merge never removes a reviewer finding that only claims github provenance', () => {
-  const forged = { id: 'R1', severity: 'P1', summary: 'real local blocker', source: 'github' }
-  const merged = mergeExternal({ version: 1, findings: [forged] }, { findings: [], awaiting: [], ignored: [], head: HEAD }, new Set())
-  assert.deepEqual(merged.findings, [forged])
-  const faked = mergeExternal({ version: 1, findings: [forged], external: { added: ['R1'] } }, { findings: [], awaiting: [], ignored: [], head: HEAD }, new Set())
-  assert.deepEqual(faked.findings, [forged], 'listing a reviewer id under external.added does not make it removable')
-})
-
-test('every page is read: a standing changes request behind 100 comments still blocks', () => {
-  const standing = review(1, 'vera932', 'CHANGES_REQUESTED', 'no', '2026-10-08T09:00:00Z')
-  const chatter = Array.from({ length: 150 }, (_, i) => review(100 + i, 'alo335', 'COMMENTED', 'ok', '2026-10-08T10:00:00Z'))
-  const all = { reviews: [standing, ...chatter], reviewThreads: [], comments: [] }
-  const calls = []
-  const query = (text, { after }) => {
-    const field = Object.keys(all).find((f) => text.includes(`${f}(first: 100`))
-    calls.push([field, after])
-    const start = after ? Number(after) : 0
-    const nodes = all[field].slice(start, start + 100)
-    const next = start + 100 < all[field].length
-    return { data: { repository: { pullRequest: { author: { login: 'cory-bot' }, [field]: { nodes, pageInfo: { hasNextPage: next, endCursor: next ? String(start + 100) : null } } } } } }
-  }
-  const fetched = fetchPr({ owner: 'o', name: 'r', number: 1 }, query)
-  assert.equal(fetched.reviews.nodes.length, 151)
-  assert.deepEqual(calls.filter(([f]) => f === 'reviews'), [['reviews', null], ['reviews', '100']])
-  assert.deepEqual(collectExternal(fetched, HEAD, { permissionOf }).findings.map((f) => f.id), ['gh-review-1'])
-  assert.throws(() => fetchPr({ owner: 'o', name: 'r', number: 1 }, () => ({ data: { repository: { pullRequest: { reviews: { nodes: [], pageInfo: { hasNextPage: true, endCursor: null } } } } } })), /without a cursor/)
-})
-
-test('an access lookup that fails stops the merge; only "not a user" means no access', () => {
-  const failing = (message) => permissionFetcher({ owner: 'o', name: 'r' }, () => { throw new Error(message) })
-  assert.throws(() => failing('gh api failed: connection reset')('vera932'), /cannot tell vera932's access/)
-  assert.equal(failing('gh: x is not a user (HTTP 404)')('x'), 'none')
-  const answering = (body) => permissionFetcher({ owner: 'o', name: 'r' }, () => JSON.stringify(body))
-  assert.equal(answering({ permission: 'none', role_name: '' })('codex[bot]'), 'none', 'a bot answers 200 with no access')
-  assert.equal(answering({ permission: 'write', role_name: 'maintain' })('alo335'), 'write')
-  assert.equal(answering({ permission: 'write', role_name: 'Security reviewer' })('sec'), 'write', 'a custom role keeps its base access')
-  const blocked = () => collectExternal(pr({ reviews: [review(1, 'alo335', 'CHANGES_REQUESTED', 'no')] }), HEAD, { permissionOf: failing('HTTP 502') })
-  assert.throws(blocked, /cannot tell alo335's access/)
-})
-
-test('a GitHub finding the reviewer carried forward is replaced, not doubled or refused', () => {
-  const carried = { id: 'gh-comment-1', severity: 'P1', summary: 'carried by the reviewer', trigger: 't', rule: 'r', paths: [{ path: 'a', status: 'open' }] }
-  const current = collectExternal(pr({ threads: [thread(1, 'vera932', 'P1: still broken')] }), HEAD, { permissionOf })
-  const merged = mergeExternal({ version: 1, findings: [carried, { id: 'R2', severity: 'P3' }] }, current, new Set())
-  assert.deepEqual(merged.findings.map((f) => [f.id, f.summary]), [['R2', undefined], ['gh-comment-1', 'still broken']])
-  const resolved = mergeExternal({ version: 1, findings: [carried] }, collectExternal(pr(), HEAD, { permissionOf }), new Set())
-  assert.deepEqual(resolved.findings, [], 'GitHub decides whether its finding is still open')
-})
-
-test('GitHub findings carry the blocking shape, so the verdict needs no exemption', () => {
-  const [finding] = collectExternal(pr({ threads: [thread(1, 'vera932', 'P1: still broken')] }), HEAD, { permissionOf }).findings
-  assert.match(finding.trigger, /vera932's P1 comment on GitHub/)
-  assert.ok(finding.rule)
-  assert.deepEqual(finding.paths, [{ path: 'src/a.ts:12', status: 'open' }])
-})
-
-test('a comment that only mentions the marker is still read as feedback', () => {
-  for (const body of [
-    `P1: Parser drops feedback containing ${STRUCTURED_MARKER}`,
-    `P1: Parser drops feedback containing ${STRUCTURED_MARKER}\n\n\`\`\`json\n{}\n\`\`\``,
-    `P1: wrong\n${STRUCTURED_MARKER}\n\`\`\`json\n{"head":"${HEAD}"}\n\`\`\``,
-  ]) {
-    const external = collectExternal(pr({ threads: [thread(1, 'vera932', body)] }), HEAD, { permissionOf })
-    assert.deepEqual(external.findings.map((f) => f.id), ['gh-comment-1'], body)
-  }
-})
-
-test('a posted result must be complete by the reviewer\'s own rules', () => {
-  const posted = (extra) => pr({ comments: [{ databaseId: 1, author: { login: 'alo335' }, body: structuredBody(HEAD, extra), createdAt: '2026-10-08T10:00:00Z', url: 'u1' }] })
-  assert.ok(findStructured(posted({}), HEAD, { permissionOf }))
-  assert.equal(findStructured(posted({ complete: undefined, passes: undefined }), HEAD, { permissionOf }), null)
-  assert.equal(findStructured(posted({ passes: { ...PASSES, tests: 'partial' } }), HEAD, { permissionOf }), null)
-  assert.equal(findStructured(posted({ commands: [] }), HEAD, { permissionOf }), null)
-  assert.equal(findStructured(posted({ findings: undefined }), HEAD, { permissionOf }), null)
-  assert.equal(findStructured(posted({ complete: undefined }), HEAD, { permissionOf }), null, 'all passes done but no complete: true')
-})

package/skills/engineering/resolve-issues/scripts/install-hooks.test.mjs

@@ -1,79 +0,0 @@
-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 { run, withHook, hookCommand, REHYDRATE } from './install-hooks.mjs'
-
-const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'install-hooks.mjs')
-
-function home(files = {}) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'install-hooks-'))
-  for (const [rel, body] of Object.entries(files)) {
-    fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true })
-    fs.writeFileSync(path.join(dir, rel), typeof body === 'string' ? body : JSON.stringify(body))
-  }
-  return dir
-}
-const read = (dir, rel) => JSON.parse(fs.readFileSync(path.join(dir, rel), 'utf8'))
-
-test('installs into both harnesses, keeps every other setting and hook, and a second run changes nothing', () => {
-  const herdr = { hooks: [{ type: 'command', command: 'bash herdr.sh session' }] }
-  const dir = home({
-    '.claude/settings.json': { model: 'opus', hooks: { SessionStart: [herdr], Stop: [{ hooks: [] }] } },
-    '.codex/hooks.json': { hooks: { SessionStart: [herdr] } },
-  })
-  assert.deepEqual(run({ home: dir }).map((r) => `${r.harness}:${r.status}`), ['claude:updated', 'codex:updated'])
-  const claude = read(dir, '.claude/settings.json')
-  assert.equal(claude.model, 'opus')
-  assert.deepEqual(claude.hooks.Stop, [{ hooks: [] }])
-  assert.deepEqual(claude.hooks.SessionStart, [herdr, { matcher: 'compact', hooks: [{ type: 'command', command: hookCommand(), timeout: 10 }] }])
-  assert.deepEqual(read(dir, '.codex/hooks.json').hooks.SessionStart[1].matcher, 'compact')
-  assert.deepEqual(run({ home: dir }).map((r) => r.status), ['installed', 'installed'])
-  assert.deepEqual(run({ home: dir, check: true }).map((r) => r.status), ['installed', 'installed'])
-})
-
-test('a moved skill updates the old entry in place instead of adding a second', () => {
-  const old = { hooks: { SessionStart: [{ matcher: 'compact', hooks: [{ type: 'command', command: 'node "/old/resolve-issues/scripts/rehydrate.mjs" --hook' }] }] } }
-  const { settings, changed } = withHook(old)
-  assert.equal(changed, true)
-  assert.equal(settings.hooks.SessionStart.length, 1)
-  assert.equal(settings.hooks.SessionStart[0].hooks[0].command, `node "${REHYDRATE}" --hook`)
-})
-
-test('check: a missing hook is reported in the output (exit 0; --exit-missing exits 1) and nothing is written; an enabled plugin counts; no harness home is absent', () => {
-  const dir = home({ '.claude/settings.json': { model: 'opus' } })
-  const out = spawnSync(process.execPath, [SCRIPT, '--check', '--home', dir], { encoding: 'utf8' })
-  assert.equal(out.status, 0, out.stderr)
-  assert.match(out.stdout, /claude {2}missing/)
-  assert.match(out.stdout, /codex {3}absent/)
-  assert.match(out.stdout, /^missing: claude/m)
-  const json = JSON.parse(spawnSync(process.execPath, [SCRIPT, '--check', '--json', '--home', dir], { encoding: 'utf8' }).stdout)
-  assert.deepEqual(json.missing, ['claude'])
-  assert.equal(spawnSync(process.execPath, [SCRIPT, '--check', '--exit-missing', '--home', dir], { encoding: 'utf8' }).status, 1)
-  assert.equal(spawnSync(process.execPath, [SCRIPT, '--bogus'], { encoding: 'utf8' }).status, 2)
-  assert.deepEqual(read(dir, '.claude/settings.json'), { model: 'opus' })
-  const plugin = home({ '.claude/settings.json': { enabledPlugins: { 'engineering-workflow@1aboveio-engineering-skills': true } } })
-  assert.deepEqual(run({ home: plugin, check: true, harness: 'claude' }).map((r) => r.status), ['plugin'])
-  assert.deepEqual(run({ home: plugin, harness: 'claude' }).map((r) => r.status), ['plugin'], 'the plugin ships the hook: no second copy')
-  assert.equal(read(plugin, '.claude/settings.json').hooks, undefined)
-})
-
-test('a settings root or SessionStart of the wrong shape is refused, not silently kept', () => {
-  for (const body of [[], { hooks: { SessionStart: {} } }]) {
-    const dir = home({ '.claude/settings.json': body })
-    assert.throws(() => run({ home: dir, harness: 'claude' }), /fix it by hand/)
-    assert.deepEqual(read(dir, '.claude/settings.json'), body)
-  }
-})
-
-test('a settings file that is not JSON is never overwritten', () => {
-  const dir = home({ '.claude/settings.json': '{ "model": "opus", // comment\n}' })
-  const out = spawnSync(process.execPath, [SCRIPT, '--home', dir, '--harness', 'claude'], { encoding: 'utf8' })
-  assert.equal(out.status, 2)
-  assert.match(out.stderr, /is not JSON/)
-  assert.equal(fs.readFileSync(path.join(dir, '.claude/settings.json'), 'utf8'), '{ "model": "opus", // comment\n}')
-})

package/skills/engineering/resolve-issues/scripts/issue-tree.test.mjs

@@ -1,107 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { DETAIL_QUERY, PAGE_QUERY, TREE_QUERY, WIDTHS, fetchTree, withRetry } from './issue-tree.mjs'
-
-// A fake GitHub GraphQL endpoint over issues keyed "o/r#n": { state, labels, blockedBy, children }.
-// It honors the query's level widths, so truncation and follow-ups behave as on GitHub.
-function fakeGraphql(issues, { fail = {} } = {}) {
-  const calls = []
-  const node = (key, depth, widths) => {
-    const i = issues[key]
-    const [repo, n] = key.split('#')
-    const labels = i.labels ?? []
-    const blockers = i.blockedBy ?? []
-    const out = {
-      number: Number(n), title: `t${n}`, state: (i.state ?? 'open').toUpperCase(), url: null, repository: { nameWithOwner: repo },
-      labels: { totalCount: labels.length, nodes: labels.slice(0, widths.labels).map((name) => ({ name })) },
-      blockedBy: { totalCount: blockers.length, nodes: blockers.slice(0, widths.blockers).map((b) => ({ number: Number(b.split('#')[1]), state: (issues[b]?.state ?? 'open').toUpperCase(), repository: { nameWithOwner: b.split('#')[0] } })) },
-    }
-    const kids = i.children ?? []
-    if (depth >= WIDTHS.length) out.subIssuesSummary = { total: kids.length }
-    else {
-      const shown = kids.slice(0, WIDTHS[depth])
-      out.subIssues = { totalCount: kids.length, pageInfo: { hasNextPage: kids.length > shown.length, endCursor: String(shown.length) }, nodes: shown.map((k) => node(k, depth + 1, widths)) }
-    }
-    return out
-  }
-  const graphql = (query, { owner, name, number, after }) => {
-    const key = `${owner}/${name}#${number}`
-    const kind = query === TREE_QUERY ? 'tree' : query === DETAIL_QUERY ? 'detail' : query === PAGE_QUERY ? 'page' : 'unknown'
-    calls.push(`${kind} ${key}`)
-    if (fail[key]) { const err = fail[key]; if (typeof err === 'number') { fail[key]--; throw new Error('HTTP 502 Bad Gateway') } throw new Error(err) }
-    if (!issues[key]) return { repository: { issue: null } }
-    if (kind === 'tree') return { repository: { issue: node(key, 0, { labels: 20, blockers: 10 }) } }
-    if (kind === 'detail') { const full = node(key, WIDTHS.length, { labels: 100, blockers: 100 }); delete full.subIssuesSummary; return { repository: { issue: full } } }
-    const kids = issues[key].children.slice(Number(after), Number(after) + 100)
-    return { repository: { issue: { subIssues: { pageInfo: { hasNextPage: Number(after) + 100 < issues[key].children.length, endCursor: String(Number(after) + 100) }, nodes: kids.map((k) => ({ number: Number(k.split('#')[1]), repository: { nameWithOwner: k.split('#')[0] } })) } } } }
-  }
-  return { graphql, calls }
-}
-const noSleep = () => {}
-
-test('one query fetches three levels with labels and blockers', () => {
-  const { graphql, calls } = fakeGraphql({
-    'o/r#1': { children: ['o/r#2', 'o/r#3'] },
-    'o/r#2': { state: 'closed', labels: ['ready-for-agent'] },
-    'o/r#3': { children: ['x/y#4'], blockedBy: ['o/r#2'] },
-    'x/y#4': { labels: ['ready-for-agent'] },
-  })
-  const tree = fetchTree({ repo: 'o/r', number: 1 }, { graphql, sleep: noSleep })
-  assert.equal(tree.complete, true)
-  assert.deepEqual(calls, ['tree o/r#1'])
-  assert.deepEqual(tree.nodes['o/r#3'].children, ['x/y#4'])
-  assert.deepEqual(tree.nodes['o/r#3'].blockedBy, [{ key: 'o/r#2', state: 'closed' }])
-  assert.equal(tree.nodes['x/y#4'].parent, 'o/r#3')
-  assert.equal(tree.nodes['o/r#2'].state, 'closed')
-})
-
-test('follow-ups run only where GitHub truncated: depth, child pages, wide labels or blockers', () => {
-  const many = Array.from({ length: 55 }, (_, i) => `o/r#${100 + i}`)
-  const issues = {
-    'o/r#1': { children: ['o/r#2', ...many] },
-    'o/r#2': { children: ['o/r#3'], blockedBy: Array.from({ length: 12 }, (_, i) => `o/r#${200 + i}`) },
-    'o/r#3': { children: ['o/r#4'] },
-    'o/r#4': { children: ['o/r#5'] },
-    'o/r#5': {},
-  }
-  for (const k of many) issues[k] = {}
-  const { graphql, calls } = fakeGraphql(issues)
-  const tree = fetchTree({ repo: 'o/r', number: 1 }, { graphql, sleep: noSleep })
-  assert.equal(tree.complete, true)
-  assert.equal(tree.nodes['o/r#1'].children.length, 56, 'every child, past the first level width')
-  assert.deepEqual(tree.nodes['o/r#4'].children, ['o/r#5'], 'the fourth level came from a re-rooted query')
-  assert.equal(tree.nodes['o/r#5'].parent, 'o/r#4')
-  assert.equal(tree.nodes['o/r#2'].blockedBy.length, 12, 'a wide detail query filled the blockers')
-  const pagedChildren = many.slice(49).map((k) => `tree ${k}`)
-  assert.deepEqual([...calls].sort(), ['tree o/r#1', 'detail o/r#2', 'tree o/r#4', 'page o/r#1', ...pagedChildren].sort(), 'one follow-up per truncation, nothing else')
-})
-
-test('transient failures retry; a lasting failure marks the tree incomplete', () => {
-  const issues = { 'o/r#1': { children: ['o/r#2'] }, 'o/r#2': {} }
-  const flaky = fakeGraphql(issues, { fail: { 'o/r#1': 2 } })
-  assert.equal(fetchTree({ repo: 'o/r', number: 1 }, { graphql: flaky.graphql, sleep: noSleep }).complete, true)
-  assert.equal(flaky.calls.length, 3)
-  const down = fakeGraphql(issues, { fail: { 'o/r#1': 5 } })
-  const tree = fetchTree({ repo: 'o/r', number: 1 }, { graphql: down.graphql, sleep: noSleep })
-  assert.equal(tree.complete, false)
-  assert.match(tree.errors[0].error, /502/)
-  const denied = fakeGraphql(issues, { fail: { 'o/r#1': 'Could not resolve to a Repository' } })
-  fetchTree({ repo: 'o/r', number: 1 }, { graphql: denied.graphql, sleep: noSleep })
-  assert.equal(denied.calls.length, 1, 'a non-transient error is not retried')
-})
-
-test('withRetry gives up after its attempts', () => {
-  let n = 0
-  const call = withRetry(() => { n++; throw new Error('read: EOF') }, { attempts: 3, sleep: noSleep })
-  assert.throws(call, /EOF/)
-  assert.equal(n, 3)
-})
-
-test('the tree query stays under GitHub’s 500,000-node limit', () => {
-  // GitHub multiplies `first:` down the nesting; each issue also asks for 20 labels and 10 blockers.
-  let issues = 1
-  let total = 0
-  for (const width of WIDTHS) { issues *= width; total += issues * (1 + 20 + 10) }
-  assert.ok(total < 500_000, `estimated ${total} nodes`)
-})

package/skills/engineering/resolve-issues/scripts/manual-invocation.test.mjs

@@ -1,14 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { manualOnlyPolicyFindings } from '../../engineering-runtime/scripts/invocation-policy.mjs'
-
-const engineeringRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..')
-
-test('issue and release orchestrators require explicit invocation', () => {
-  for (const name of ['resolve-issues', 'rush-issues', 'rush-release', 'resolve-release']) {
-    assert.deepEqual(manualOnlyPolicyFindings(resolve(engineeringRoot, name)), [], name)
-  }
-})

package/skills/engineering/resolve-issues/scripts/next-actions-capacity.test.mjs

@@ -1,149 +0,0 @@
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import test from 'node:test'
-import { nextActions, parseCliArgs, NextActionsError } from './next-actions.mjs'
-
-const script = new URL('./next-actions.mjs', import.meta.url)
-const pending = (n) => Array.from({ length: n }, (_, i) => ({ id: `p${i}`, status: 'pending', stage: 'pending' }))
-const busy = (n) => Array.from({ length: n }, (_, i) => ({ id: `w${i}`, status: 'in-flight', stage: 'implement', worker: `run${i}`, workerKind: 'implement' }))
-const snapshot = (maxConcurrent, runningCount = 0, pendingCount = 0) => ({
-  revision: 'live-settings', maxConcurrent, runningCount, pendingCount,
-  occupiedSlots: runningCount + pendingCount,
-  availableSlots: Math.max(0, maxConcurrent - runningCount - pendingCount),
-})
-const starts = (result) => result.due.filter(a => ['fill-slot', 'resume', 'start-review', 'start-fix'].includes(a.action)).map(a => a.unit)
-
-test('the live Harness limit permits six independent units instead of a hidden four', () => {
-  const result = nextActions({ units: pending(6) }, {}, snapshot(6))
-  assert.deepEqual(starts(result), ['p0', 'p1', 'p2', 'p3', 'p4', 'p5'])
-  assert.deepEqual(result.waiting, [])
-})
-
-test('available capacity already subtracts workflow, outside, and reserved workers', () => {
-  const plan = { units: [...busy(2), ...pending(4)] }
-  const result = nextActions(plan, {}, snapshot(6, 3, 1))
-  assert.deepEqual(starts(result), ['p0', 'p1'])
-  assert.deepEqual(result.waiting.map(a => a.unit), ['p2', 'p3'])
-  assert.equal(result.busy, 2)
-})
-
-test('a lower cap preserves existing workers, blocks new starts, and permits coordination', () => {
-  const plan = { units: [...busy(4), ...pending(2),
-    { id: 'done', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'abc', reviewedHead: 'abc' }] }
-  const before = structuredClone(plan)
-  const result = nextActions(plan, {}, snapshot(2, 4))
-  assert.deepEqual(starts(result), [])
-  assert.deepEqual(result.waiting.map(a => a.unit), ['p0', 'p1'])
-  assert.deepEqual(result.due.map(a => a.action), ['deliver'])
-  assert.deepEqual(plan, before)
-})
-
-test('each scheduling pass uses its new snapshot, not a frozen run-start budget', () => {
-  const plan = { units: pending(6) }
-  assert.deepEqual(starts(nextActions(plan, {}, snapshot(1))), ['p0'])
-  assert.deepEqual(starts(nextActions(plan, {}, snapshot(6))), ['p0', 'p1', 'p2', 'p3', 'p4', 'p5'])
-  assert.deepEqual(starts(nextActions(plan, {}, snapshot(6, 6))), [])
-})
-
-test('dependency constraints still hold even with spare capacity', () => {
-  const plan = { units: [...pending(6), { id: 'child', status: 'pending', dependsOn: ['p0'] }] }
-  assert.deepEqual(starts(nextActions(plan, {}, snapshot(8))), ['p0', 'p1', 'p2', 'p3', 'p4', 'p5'])
-})
-
-test('inconsistent capacity refuses instead of guessing; no capacity at all means unlimited', () => {
-  for (const capacity of [{}, [], '6', -1, 1.5, Infinity,
-    { ...snapshot(6), availableSlots: 7 }, { ...snapshot(6), runningCount: -1 },
-    { ...snapshot(6), occupiedSlots: 1 }, { ...snapshot(6), pendingCount: 0.5 },
-    { ...snapshot(6), maxConcurrent: 0 }, { maxConcurrent: 6, availableSlots: 6 }]) {
-    assert.throws(() => nextActions({ units: pending(1) }, {}, capacity), NextActionsError)
-  }
-  assert.deepEqual(starts(nextActions({ units: pending(6) }, {}, 6)), ['p0', 'p1', 'p2', 'p3', 'p4', 'p5'])
-  assert.deepEqual(starts(nextActions({ units: pending(1) }, {}, 0)), [])
-  for (const none of [undefined, null]) {
-    const open = nextActions({ units: [...busy(2), ...pending(6)] }, {}, none)
-    assert.deepEqual(open.capacity, { source: 'none' })
-    assert.deepEqual(starts(open), ['p0', 'p1', 'p2', 'p3', 'p4', 'p5'], 'every worker action is due without a capacity source')
-    assert.deepEqual(open.waiting, [])
-    assert.ok(open.due.every((a) => /\[needs a free worker slot\]$/.test(a.detail)))
-  }
-})
-
-test('CLI takes at most one capacity source, none at all, and accepts an exhausted budget', () => {
-  assert.equal(parseCliArgs(['--run', '/run']).slots, undefined)
-  assert.equal(parseCliArgs(['--run', '/run']).capacity, undefined)
-  assert.throws(() => parseCliArgs(['--run', '/run', '--slots', '4', '--capacity-json', JSON.stringify(snapshot(6))]), NextActionsError)
-  assert.throws(() => parseCliArgs(['--run', '/run', '--capacity-json', '{broken']), NextActionsError)
-  assert.throws(() => parseCliArgs(['--run', '/run', '--capacity-json', JSON.stringify({ maxConcurrent: 6 })]), NextActionsError)
-  assert.equal(parseCliArgs(['--run', '/run', '--slots', '0']).slots, 0)
-})
-
-test('malformed CLI capacity refuses before sync, network access, or run-state writes', t => {
-  const run = mkdtempSync(join(tmpdir(), 'next-actions-capacity-refusal-'))
-  t.after(() => rmSync(run, { recursive: true, force: true }))
-  const contents = {
-    'task-plan.json': JSON.stringify({ skill: 'resolve-issues', spec: 'o/r#1', units: [{ id: '2', status: 'pending', stage: 'pending' }] }),
-    'issue-tree.json': JSON.stringify({ root: 'o/r#1', complete: true, nodes: {
-      'o/r#1': { key: 'o/r#1', repo: 'o/r', number: 1, state: 'open', children: ['o/r#2'], blockedBy: [] },
-      'o/r#2': { key: 'o/r#2', repo: 'o/r', number: 2, title: 'Pending unit', state: 'open', children: [], blockedBy: [] },
-    } }),
-    'next-actions-seen.json': JSON.stringify({ marker: 'preserve-seen-state' }),
-  }
-  for (const [file, value] of Object.entries(contents)) writeFileSync(join(run, file), value)
-  const gh = join(run, 'gh')
-  writeFileSync(gh, '#!/bin/sh\nprintf touched > "$CAPACITY_GH_SPY"\nexit 1\n')
-  chmodSync(gh, 0o755)
-  const spy = join(run, 'network-called')
-  for (const flag of ['--sync', '--resume']) {
-    for (const value of ['{broken', JSON.stringify({ maxConcurrent: 6 }), JSON.stringify({ ...snapshot(6), occupiedSlots: 1 })]) {
-      const result = spawnSync(process.execPath, [script.pathname, '--run', run, '--capacity-json', value, flag, '--json'], {
-        encoding: 'utf8', env: { ...process.env, PATH: run, CAPACITY_GH_SPY: spy },
-      })
-      assert.equal(result.status, 2, result.stderr)
-      assert.equal(result.stdout, '')
-      assert.equal(existsSync(spy), false, 'invalid capacity must not reach GitHub sync')
-      for (const [file, value] of Object.entries(contents)) assert.equal(readFileSync(join(run, file), 'utf8'), value)
-    }
-  }
-  const control = spawnSync(process.execPath, [script.pathname, '--run', run, '--capacity-json', JSON.stringify(snapshot(6)), '--sync', '--json', '--peek'], {
-    encoding: 'utf8', env: { ...process.env, PATH: run, CAPACITY_GH_SPY: spy },
-  })
-  assert.equal(control.status, 0, control.stderr)
-  assert.equal(existsSync(spy), true, 'positive control proves valid capacity reaches the same GitHub sync boundary')
-  assert.deepEqual(starts(JSON.parse(control.stdout)), ['2'])
-})
-
-test('CLI applies fresh capacity and reports its source without modifying the task plan', t => {
-  const run = mkdtempSync(join(tmpdir(), 'next-actions-capacity-'))
-  t.after(() => rmSync(run, { recursive: true, force: true }))
-  const path = join(run, 'task-plan.json')
-  const saved = JSON.stringify({ skill: 'resolve-issues', units: [...busy(2), ...pending(4)] })
-  writeFileSync(path, saved)
-  const call = (...args) => spawnSync(process.execPath, [script.pathname, '--run', run, ...args], { encoding: 'utf8' })
-  const unlimited = call('--json', '--peek')
-  assert.equal(unlimited.status, 0, unlimited.stderr)
-  assert.deepEqual(JSON.parse(unlimited.stdout).capacity, { source: 'none' })
-  assert.deepEqual(starts(JSON.parse(unlimited.stdout)), ['p0', 'p1', 'p2', 'p3'], 'with no capacity flag every worker action is due')
-  const unlimitedText = call('--peek')
-  assert.equal(unlimitedText.status, 0, unlimitedText.stderr)
-  assert.match(unlimitedText.stdout, /fill-slot\s+.*\[needs a free worker slot\]/)
-  assert.equal(unlimitedText.stdout.match(/no capacity given/g).length, 1, 'the capacity line says so once')
-  assert.equal(call('--exit-due', '--peek').status, 1)
-  assert.equal(call('--slots', '2', '--capacity-json', JSON.stringify(snapshot(6))).status, 2, 'two capacity sources are an error')
-  assert.equal(existsSync(join(run, 'next-actions-seen.json')), false)
-  const first = call('--capacity-json', JSON.stringify(snapshot(6, 3, 1)), '--json')
-  assert.equal(first.status, 0, first.stderr)
-  assert.equal(JSON.parse(first.stdout).exitDue, true)
-  const result = JSON.parse(first.stdout)
-  assert.deepEqual(starts(result), ['p0', 'p1'])
-  assert.deepEqual(result.capacity, { source: 'harness', ...snapshot(6, 3, 1) })
-  const exhausted = call('--capacity-json', JSON.stringify(snapshot(2, 4)), '--json')
-  assert.equal(exhausted.status, 0, exhausted.stderr)
-  assert.equal(JSON.parse(exhausted.stdout).exitDue, false)
-  assert.deepEqual(starts(JSON.parse(exhausted.stdout)), [])
-  assert.equal(readFileSync(path, 'utf8'), saved)
-  const text = call('--capacity-json', JSON.stringify(snapshot(6, 3, 1)))
-  assert.match(text.stdout, /Harness.*4\/6.*2 available/)
-})