@iceinvein/agent-skills 0.22.0 → 0.23.0

package/skills/magpie/scripts/__tests__/server.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { type ServerHandle, startServer } from '../server.ts'
@@ -37,6 +37,35 @@ test('serves the newest HTML file verbatim (HTML is self-contained at render tim
   expect(html).toContain('inline-helper')
 })
 
+/** Writes a screen page with an explicit mtime, in seconds since the epoch. */
+async function writeScreen(name: string, body: string, mtime: number): Promise<void> {
+  const path = join(runDir, 'screen', name)
+  await writeFile(path, body)
+  await utimes(path, mtime, mtime)
+}
+
+test('a progress page rendered after the findings page does not replace it', async () => {
+  await writeScreen('findings.html', '<h1>Findings</h1>', 1000)
+  await writeScreen('progress-v9.html', '<h1>Progress, report done</h1>', 2000)
+  server = await startServer({ runDir, idleMs: 60_000 })
+  expect(await fetchHtml(server)).toContain('<h1>Findings</h1>')
+})
+
+test('before any findings page exists, the newest progress page is served', async () => {
+  await writeScreen('progress.html', '<h1>Progress one</h1>', 1000)
+  await writeScreen('progress-v2.html', '<h1>Progress two</h1>', 2000)
+  server = await startServer({ runDir, idleMs: 60_000 })
+  expect(await fetchHtml(server)).toContain('<h1>Progress two</h1>')
+})
+
+test('the newest findings version is served when several exist', async () => {
+  await writeScreen('findings.html', '<h1>Findings one</h1>', 1000)
+  await writeScreen('findings-v2.html', '<h1>Findings two</h1>', 2000)
+  await writeScreen('progress-v5.html', '<h1>Progress</h1>', 3000)
+  server = await startServer({ runDir, idleMs: 60_000 })
+  expect(await fetchHtml(server)).toContain('<h1>Findings two</h1>')
+})
+
 test('POST /events appends a JSON line to state/events', async () => {
   await writeFile(join(runDir, 'screen', 'a.html'), '<h1>X</h1>')
   server = await startServer({ runDir, idleMs: 60_000 })

package/skills/magpie/scripts/__tests__/setup-cmd.test.ts

@@ -1,7 +1,17 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
-import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import {
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  realpath,
+  rm,
+  symlink,
+  writeFile,
+} from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { diffSha256, localBranchDiff } from '../local-diff.ts'
 import { runSetup } from '../setup-cmd.ts'
 
 const FAKE_GH = new URL('../../fixtures/fake-gh.sh', import.meta.url).pathname
@@ -42,6 +52,7 @@ afterEach(async () => {
 
 test('runSetup completes happy path: writes pr.json, diff.patch, worktree', async () => {
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -52,10 +63,13 @@ test('runSetup completes happy path: writes pr.json, diff.patch, worktree', asyn
   expect(contents).toContain('pr.json')
   expect(contents).toContain('diff.patch')
   expect(contents).toContain('worktree')
+  const target = JSON.parse(await readFile(join(runDir, 'target.json'), 'utf8'))
+  expect(target).toEqual({ mode: 'pr', root: join(runDir, 'worktree') })
 })
 
 test('runSetup with missing dep returns non-zero and cleans up', async () => {
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -68,6 +82,7 @@ test('runSetup with missing dep returns non-zero and cleans up', async () => {
 
 test('runSetup filters excluded files by default and preserves raw diff', async () => {
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -93,6 +108,7 @@ test('runSetup filters excluded files by default and preserves raw diff', async
 
 test('runSetup with no excludable files does not write filter sidecars', async () => {
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -107,6 +123,7 @@ test('runSetup with no excludable files does not write filter sidecars', async (
 test('runSetup honors .magpie.json useDefaults=false', async () => {
   await writeFile(join(repo, '.magpie.json'), JSON.stringify({ useDefaults: false, exclude: [] }))
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -129,6 +146,7 @@ test('runSetup writes incremental.json when a prior run for the same PR exists',
   process.env.MAGPIE_HOME = magpieHome
   try {
     const exit = await runSetup({
+      mode: 'pr',
       runDir,
       prNumber: 1234,
       repoPath: repo,
@@ -152,6 +170,7 @@ test('runSetup omits incremental.json when no prior run exists', async () => {
   process.env.MAGPIE_HOME = magpieHome
   try {
     const exit = await runSetup({
+      mode: 'pr',
       runDir,
       prNumber: 1234,
       repoPath: repo,
@@ -169,6 +188,7 @@ test('runSetup omits incremental.json when no prior run exists', async () => {
 
 test('runSetup with failing gh removes any partial state', async () => {
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -178,10 +198,12 @@ test('runSetup with failing gh removes any partial state', async () => {
   const contents = await readdir(runDir).catch(() => [])
   expect(contents).not.toContain('worktree')
   expect(contents).not.toContain('pr.json')
+  expect(contents).not.toContain('target.json')
 })
 
 test('runSetup shards the filtered diff and logs the result', async () => {
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -210,6 +232,7 @@ test('runSetup cleans up a populated shards/ when worktree creation fails after
   await writeFile(join(runDir, 'worktree', 'occupied'), 'x')
 
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -230,6 +253,7 @@ test('runSetup cleans up a populated shards/ when worktree creation fails after
   const contents = await readdir(runDir).catch(() => [])
   expect(contents).not.toContain('shards')
   expect(contents).not.toContain('worktree')
+  expect(contents).not.toContain('target.json')
 })
 
 test('runSetup treats a shardDiff throw as a hard stop: logs, cleans up, exits 6', async () => {
@@ -242,6 +266,7 @@ test('runSetup treats a shardDiff throw as a hard stop: logs, cleans up, exits 6
   await writeFile(join(runDir, 'shards'), 'not a directory')
 
   const exit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,
@@ -261,3 +286,301 @@ test('runSetup treats a shardDiff throw as a hard stop: logs, cleans up, exits 6
   const contents = await readdir(runDir).catch(() => [])
   expect(contents.filter((c) => c !== 'log.jsonl')).toHaveLength(0)
 })
+
+const LOCAL_DEPS = { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' }
+
+async function prepareLocalBranch(): Promise<void> {
+  await sh(repo, 'git', 'checkout', '-q', 'feature-x')
+  await writeFile(join(repo, 'b.txt'), 'two\n')
+  await sh(repo, 'git', 'add', 'b.txt')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'add b')
+  await writeFile(join(repo, 'a.txt'), 'one\nedited\n')
+  await writeFile(join(repo, 'new.txt'), 'untracked\n')
+}
+
+async function setupCapturingStderr(
+  input: Parameters<typeof runSetup>[0],
+): Promise<{ exit: number; stderr: string }> {
+  const errs: string[] = []
+  const origWrite = process.stderr.write.bind(process.stderr)
+  process.stderr.write = ((s: string) => {
+    errs.push(s)
+    return true
+  }) as typeof process.stderr.write
+  try {
+    const exit = await runSetup(input)
+    return { exit, stderr: errs.join('') }
+  } finally {
+    process.stderr.write = origWrite
+  }
+}
+
+async function readLog(): Promise<Array<Record<string, unknown>>> {
+  const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+  return log
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => JSON.parse(l))
+}
+
+test('local setup writes the diff, its sidecars and a target rooted at the repo', async () => {
+  await prepareLocalBranch()
+  const exit = await runSetup({
+    mode: 'local',
+    runDir,
+    repoPath: repo,
+    baseRef: 'main',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(0)
+  const contents = await readdir(runDir)
+  expect(contents).not.toContain('pr.json')
+  expect(contents).not.toContain('incremental.json')
+  expect(contents).not.toContain('worktree')
+
+  const diff = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(diff).toContain('+++ b/b.txt')
+  expect(diff).toContain('+edited')
+  expect(diff).toContain('+++ b/new.txt')
+
+  const source = JSON.parse(await readFile(join(runDir, 'diff-source.json'), 'utf8'))
+  expect(source.source).toBe('local')
+  expect(source.baseRef).toBe('main')
+  expect(source.mergeBase).toMatch(/^[0-9a-f]{40}$/)
+  expect(source.head).toMatch(/^[0-9a-f]{40}$/)
+  expect(source.diffSha256).toMatch(/^[0-9a-f]{64}$/)
+
+  const meta = JSON.parse(await readFile(join(runDir, 'local.json'), 'utf8'))
+  expect(meta.branch).toBe('feature-x')
+  expect(meta.baseRef).toBe('main')
+  expect(meta.dirty).toBe(true)
+  expect(meta.intentFile).toBeNull()
+
+  const target = JSON.parse(await readFile(join(runDir, 'target.json'), 'utf8'))
+  expect(target).toEqual({ mode: 'local', root: repo })
+
+  expect((await readLog()).find((e) => e.stage === 'setup')).toMatchObject({
+    status: 'done',
+    root: repo,
+  })
+})
+
+test('local setup hashes the raw diff, not the path-filtered patch', async () => {
+  await sh(repo, 'git', 'checkout', '-q', 'feature-x')
+  await writeFile(join(repo, 'bun.lock'), 'lock\n')
+  await writeFile(join(repo, 'src.ts'), 'export const x = 1\n')
+  await sh(repo, 'git', 'add', '.')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'lock and src')
+
+  const exit = await runSetup({
+    mode: 'local',
+    runDir,
+    repoPath: repo,
+    baseRef: 'main',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(0)
+  const filtered = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(filtered).not.toContain('bun.lock')
+
+  const raw = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!raw.ok) throw new Error(raw.error)
+  const source = JSON.parse(await readFile(join(runDir, 'diff-source.json'), 'utf8'))
+  expect(source.diffSha256).toBe(diffSha256(raw.diff))
+})
+
+test('local setup with an unresolvable base logs the error and keeps only the log', async () => {
+  await prepareLocalBranch()
+  const exit = await runSetup({
+    mode: 'local',
+    runDir,
+    repoPath: repo,
+    baseRef: 'nope',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(4)
+  expect((await readLog()).find((e) => e.stage === 'local-diff')).toMatchObject({
+    status: 'error',
+  })
+  expect(await readdir(runDir)).toEqual(['log.jsonl'])
+})
+
+test('local setup with a missing intent file fails naming the path', async () => {
+  await prepareLocalBranch()
+  const missing = join(runDir, 'no-such-intent.md')
+  const { exit, stderr } = await setupCapturingStderr({
+    mode: 'local',
+    runDir,
+    repoPath: repo,
+    baseRef: 'main',
+    intentFile: missing,
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).not.toBe(0)
+  expect(stderr).toContain(`magpie: intent file ${missing} does not exist`)
+  expect((await readLog()).find((e) => e.stage === 'local-diff')).toMatchObject({
+    status: 'error',
+  })
+  expect(await readdir(runDir)).toEqual(['log.jsonl'])
+})
+
+test('local setup with an intent path that is a directory fails naming the path', async () => {
+  await prepareLocalBranch()
+  const intentDir = await mkdtemp(join(tmpdir(), 'magpie-intent-dir-'))
+  try {
+    const { exit, stderr } = await setupCapturingStderr({
+      mode: 'local',
+      runDir,
+      repoPath: repo,
+      baseRef: 'main',
+      intentFile: intentDir,
+      deps: LOCAL_DEPS,
+    })
+    expect(exit).not.toBe(0)
+    expect(stderr).toContain(`magpie: intent file ${intentDir} is not a file`)
+    expect((await readLog()).find((e) => e.stage === 'local-diff')).toMatchObject({
+      status: 'error',
+    })
+    expect(await readdir(runDir)).toEqual(['log.jsonl'])
+  } finally {
+    await rm(intentDir, { recursive: true, force: true })
+  }
+})
+
+test('local setup refuses a run dir that is the repository and leaves it untouched', async () => {
+  await prepareLocalBranch()
+  await mkdir(join(repo, 'findings'))
+  await writeFile(join(repo, 'findings', 'user.txt'), 'mine\n')
+  await sh(repo, 'git', 'add', 'findings/user.txt')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'user findings')
+  const before = (await readdir(repo)).sort()
+
+  const { exit, stderr } = await setupCapturingStderr({
+    mode: 'local',
+    runDir: repo,
+    repoPath: repo,
+    baseRef: 'nope',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(2)
+  expect(stderr).toContain(
+    `magpie: run dir ${repo} is inside the repository under review ${await realpath(repo)}\n`,
+  )
+  expect(await readFile(join(repo, 'findings', 'user.txt'), 'utf8')).toBe('mine\n')
+  expect((await readdir(repo)).sort()).toEqual(before)
+})
+
+test('local setup refuses a not-yet-created run dir under the repository and creates nothing', async () => {
+  await prepareLocalBranch()
+  const before = (await readdir(repo)).sort()
+  const nested = join(repo, 'runs', 'r1')
+
+  const { exit, stderr } = await setupCapturingStderr({
+    mode: 'local',
+    runDir: nested,
+    repoPath: repo,
+    baseRef: 'main',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(2)
+  expect(stderr).toContain(`magpie: run dir ${nested} is inside the repository under review`)
+  expect((await readdir(repo)).sort()).toEqual(before)
+})
+
+async function gitStatus(cwd: string): Promise<string> {
+  const proc = Bun.spawn(['git', 'status', '--porcelain'], { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const out = await new Response(proc.stdout).text()
+  expect(await proc.exited).toBe(0)
+  return out
+}
+
+test('local setup with --repo at a subdirectory fails before writing a run dir into the repository', async () => {
+  await mkdir(join(repo, 'sub'))
+  await writeFile(join(repo, 'sub', 's.txt'), 's\n')
+  await sh(repo, 'git', 'add', '.')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'sub')
+  const before = (await readdir(repo)).sort()
+  const statusBefore = await gitStatus(repo)
+  const sub = join(repo, 'sub')
+
+  const { exit, stderr } = await setupCapturingStderr({
+    mode: 'local',
+    runDir: join(repo, 'run'),
+    repoPath: sub,
+    baseRef: 'main',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(2)
+  expect(stderr).toContain(`magpie: --repo ${sub} is not the repository root`)
+  expect((await readdir(repo)).sort()).toEqual(before)
+  expect(await gitStatus(repo)).toBe(statusBefore)
+})
+
+test('local setup with a run dir that climbs out of a symlink into the repository leaves the repository unchanged', async () => {
+  await mkdir(join(repo, 'sub'))
+  await writeFile(join(repo, 'sub', 's.txt'), 's\n')
+  await sh(repo, 'git', 'add', '.')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'sub')
+  await symlink(join(repo, 'sub'), join(runDir, 'L'))
+  const before = (await readdir(repo)).sort()
+  const statusBefore = await gitStatus(repo)
+
+  await setupCapturingStderr({
+    mode: 'local',
+    runDir: `${join(runDir, 'L')}/../run5`,
+    repoPath: repo,
+    baseRef: 'nope',
+    deps: LOCAL_DEPS,
+  })
+  expect((await readdir(repo)).sort()).toEqual(before)
+  expect(await gitStatus(repo)).toBe(statusBefore)
+})
+
+test('local setup with a --repo that does not exist fails with exit 2 and creates no run dir', async () => {
+  const missing = join(runDir, 'no-such-repo')
+  const nested = join(runDir, 'r1')
+  const { exit, stderr } = await setupCapturingStderr({
+    mode: 'local',
+    runDir: nested,
+    repoPath: missing,
+    baseRef: 'main',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(2)
+  expect(stderr).toBe(`magpie: --repo ${missing} does not exist\n`)
+  expect(await readdir(runDir)).toEqual([])
+})
+
+test('local setup with a --repo that is a file fails with exit 2 and creates no run dir', async () => {
+  const file = join(repo, 'a.txt')
+  const nested = join(runDir, 'r1')
+  const { exit, stderr } = await setupCapturingStderr({
+    mode: 'local',
+    runDir: nested,
+    repoPath: file,
+    baseRef: 'main',
+    deps: LOCAL_DEPS,
+  })
+  expect(exit).toBe(2)
+  expect(stderr).toBe(`magpie: --repo ${file} is not a directory\n`)
+  expect(await readdir(runDir)).toEqual([])
+})
+
+test('local setup with --repo outside any git repository fails with exit 2 and creates no run dir', async () => {
+  const notRepo = await mkdtemp(join(tmpdir(), 'magpie-setup-notrepo-'))
+  const nested = join(runDir, 'r1')
+  try {
+    const { exit, stderr } = await setupCapturingStderr({
+      mode: 'local',
+      runDir: nested,
+      repoPath: notRepo,
+      baseRef: 'main',
+      deps: LOCAL_DEPS,
+    })
+    expect(exit).toBe(2)
+    expect(stderr).toContain(`magpie: --repo ${notRepo} is not inside a git work tree: `)
+    expect(await readdir(runDir)).toEqual([])
+  } finally {
+    await rm(notRepo, { recursive: true, force: true })
+  }
+})

package/skills/magpie/scripts/__tests__/skill-lint.test.ts

@@ -180,7 +180,7 @@ test('references/scout.md holds the scout prompt and the brief contract', async
   }
   expect(text).toContain('brief: <N> changes, <K> watch items, <R> review rules')
   expect(text).not.toContain('"subsystems"')
-  for (const ph of ['<<RUN_DIR>>', '<<PR_NUMBER>>']) {
+  for (const ph of ['<<RUN_DIR>>', '<<WORKTREE>>', '<<TARGET>>']) {
     expect(text).toContain(ph)
   }
   // watchItems are context for specialists, not findings in their own right.
@@ -219,8 +219,9 @@ test('SKILL.md no longer inlines the prompt bodies it moved out', async () => {
   }
   // The walkthrough is the always-read part; keep it small enough to be cheap.
   // Raised from 2600 when the sharded-dispatch and fallback-diff prose was added:
-  // that's real, load-bearing procedure, not bloat.
-  expect(text.split(/\s+/).length).toBeLessThan(3000)
+  // that's real, load-bearing procedure, not bloat. Raised from 3000 for the
+  // local-mode section, which the walkthrough already sat 3 words under.
+  expect(text.split(/\s+/).length).toBeLessThan(3500)
 })
 
 test('styles.css declares a prefers-color-scheme:dark block that overrides core tokens', async () => {
@@ -413,11 +414,13 @@ test('the stage-4 gate offers only options the pipeline can carry out', async ()
   expect(gate).toContain('--max-files')
   // Option 3 must name a mechanism that exists. There is no unreviewed marker in
   // the report, so the record is a diagnostic log entry, on a stage outside
-  // status-cmd's ORDER ladder and never `status: error`.
-  const { ORDER } = await import('../status-cmd.ts')
+  // status-cmd's ladders (a local run can hit the same gate) and never
+  // `status: error`.
+  const { ORDER, LOCAL_ORDER } = await import('../status-cmd.ts')
   const stage = gate.match(/\{stage: ([a-z-]+), status: ([a-z-]+)/)
   expect(stage?.[1]).toBeDefined()
   expect(ORDER as readonly string[]).not.toContain(stage?.[1])
+  expect(LOCAL_ORDER as readonly string[]).not.toContain(stage?.[1])
   expect(stage?.[2]).not.toBe('error')
   expect(gate).toMatch(/skipped/)
 })

package/skills/magpie/scripts/__tests__/status-cmd.test.ts

@@ -53,3 +53,47 @@ test('error stage halts progression', async () => {
   expect(result.lastCompleted).toBe('setup')
   expect(result.error).toBe('context')
 })
+
+function logLines(entries: [string, string][]): string {
+  return entries.map(([stage, status]) => `${JSON.stringify({ stage, status })}\n`).join('')
+}
+
+const throughPeerReview: [string, string][] = [
+  ['setup', 'done'],
+  ['context', 'done'],
+  ['specialists', 'done'],
+  ['dedupe', 'done'],
+  ['critic', 'done'],
+  ['peer-review', 'done'],
+]
+
+test('a local run after peer-review resumes at handoff', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: runDir }))
+  await writeFile(join(runDir, 'log.jsonl'), logLines(throughPeerReview))
+  const result = await runStatus(runDir)
+  expect(result.lastCompleted).toBe('peer-review')
+  expect(result.next).toBe('handoff')
+})
+
+test('a local run with handoff done goes to cleanup', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: runDir }))
+  await writeFile(join(runDir, 'log.jsonl'), logLines([...throughPeerReview, ['handoff', 'done']]))
+  const result = await runStatus(runDir)
+  expect(result.lastCompleted).toBe('handoff')
+  expect(result.next).toBe('cleanup')
+})
+
+test('a PR or archived run with no target.json resumes at report after peer-review', async () => {
+  await writeFile(join(runDir, 'log.jsonl'), logLines(throughPeerReview))
+  const result = await runStatus(runDir)
+  expect(result.lastCompleted).toBe('peer-review')
+  expect(result.next).toBe('report')
+})
+
+test('a PR run with target.json resumes at report after peer-review', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'pr', root: runDir }))
+  await writeFile(join(runDir, 'log.jsonl'), logLines(throughPeerReview))
+  const result = await runStatus(runDir)
+  expect(result.lastCompleted).toBe('peer-review')
+  expect(result.next).toBe('report')
+})

package/skills/magpie/scripts/__tests__/target.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { readTarget, reviewRoot, writeTarget } from '../target.ts'
+
+let runDir: string
+
+beforeEach(async () => {
+  runDir = await mkdtemp(join(tmpdir(), 'magpie-target-'))
+})
+
+afterEach(async () => {
+  await rm(runDir, { recursive: true, force: true })
+})
+
+test('a run without target.json reads as PR mode rooted at its worktree', async () => {
+  await writeFile(join(runDir, 'log.jsonl'), '')
+  expect(await readTarget(runDir)).toEqual({ mode: 'pr', root: join(runDir, 'worktree') })
+})
+
+test('a directory with neither target.json nor log.jsonl is not a run', async () => {
+  await expect(readTarget(runDir)).rejects.toThrow(
+    `${runDir}: not a magpie run (no target.json or log.jsonl)`,
+  )
+})
+
+test('a missing directory is not a run', async () => {
+  const missing = join(runDir, 'mistyped')
+  await expect(reviewRoot(missing)).rejects.toThrow(
+    `${missing}: not a magpie run (no target.json or log.jsonl)`,
+  )
+})
+
+test('a written local target reads back', async () => {
+  await writeTarget(runDir, { mode: 'local', root: '/x' })
+  expect(await readTarget(runDir)).toEqual({ mode: 'local', root: '/x' })
+})
+
+test('writeTarget writes two-space JSON with a trailing newline', async () => {
+  await writeTarget(runDir, { mode: 'local', root: '/x' })
+  expect(await readFile(join(runDir, 'target.json'), 'utf8')).toBe(
+    '{\n  "mode": "local",\n  "root": "/x"\n}\n',
+  )
+})
+
+test('reviewRoot returns the root named in target.json', async () => {
+  await writeTarget(runDir, { mode: 'local', root: '/repo' })
+  expect(await reviewRoot(runDir)).toBe('/repo')
+})
+
+test('an unknown mode throws naming target.json', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'other', root: '/x' }))
+  await expect(readTarget(runDir)).rejects.toThrow(/target\.json.*mode/)
+})
+
+test('a non-string root throws naming target.json', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: 7 }))
+  await expect(readTarget(runDir)).rejects.toThrow(/target\.json.*root/)
+})
+
+test('an empty root throws as not absolute', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: '' }))
+  await expect(readTarget(runDir)).rejects.toThrow(
+    `${join(runDir, 'target.json')}: root must be an absolute path`,
+  )
+})
+
+test('a relative root throws as not absolute', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: 'repo' }))
+  await expect(readTarget(runDir)).rejects.toThrow(
+    `${join(runDir, 'target.json')}: root must be an absolute path`,
+  )
+})
+
+test('a target.json that cannot be read for a reason other than absence rejects', async () => {
+  await mkdir(join(runDir, 'target.json'))
+  await expect(readTarget(runDir)).rejects.toThrow(/EISDIR/)
+})
+
+test('unparseable target.json throws naming the file', async () => {
+  await writeFile(join(runDir, 'target.json'), 'not json')
+  await expect(readTarget(runDir)).rejects.toThrow(/target\.json/)
+})

package/skills/magpie/scripts/__tests__/types.test.ts

@@ -10,13 +10,14 @@ import {
   parseFinding,
 } from '../types.ts'
 
-test('FOCUS_IDS contains the LLM focuses plus the deterministic tests domain', () => {
+test('FOCUS_IDS contains the LLM focuses, the checks pass and the deterministic tests domain', () => {
   expect(FOCUS_IDS).toEqual([
     'security',
     'bugs',
     'performance',
     'code-smells',
     'architecture',
+    'checks',
     'tests',
   ])
 })

package/skills/magpie/scripts/cleanup-cmd.ts

@@ -1,6 +1,7 @@
 import { appendFile, readFile, rename, stat } from 'node:fs/promises'
 import { join } from 'node:path'
 import { writeLabels } from './labels-cmd.ts'
+import { readTarget } from './target.ts'
 import { removeWorktree } from './worktree.ts'
 
 export type RunCleanupInput = {
@@ -67,6 +68,9 @@ export async function killServer(
 }
 
 export async function runCleanup(input: RunCleanupInput): Promise<number> {
+  // Read before any side effect, so a malformed target.json leaves the run untouched.
+  // Local mode promises the caller no report, so its cleanup does not point at one.
+  const { mode } = await readTarget(input.runDir)
   const worktreePath = join(input.runDir, 'worktree')
   const worktreeExists = await stat(worktreePath)
     .then(() => true)
@@ -95,7 +99,7 @@ export async function runCleanup(input: RunCleanupInput): Promise<number> {
   await rename(input.runDir, target)
   process.stdout.write(`archived to ${target}\n`)
   const archivedId = target.split('/').filter(Boolean).pop()
-  if (archivedId) {
+  if (archivedId && mode !== 'local') {
     process.stdout.write(`view later: magpie open ${archivedId}\n`)
   }
   if (kill.outcome === 'failed') {