rvlib-shipkit 1.1.1 → 1.3.0

package/src/cli/cmd_Planned.ts

@@ -0,0 +1,117 @@
+// shipkit planned: the planned page in the console. The plan lives in the
+// daemon (its marks, the running batch, the catch up spread all exist only
+// there), so this asks the daemon's route, the one the page polls, and only
+// renders it: the order and every word come from plan-timeline.ts, the page's
+// own functions. Nothing is computed from disk: a plan rebuilt here would load
+// every repo's checks and still not know what the daemon's plan holds.
+import { Command, Option } from 'clipanion'
+import { daemonUrl } from '../home/home-paths.ts'
+import type { PlannedAnswer } from '../home/home-routes.ts'
+import { markOf, spanShort, timeline, titleWords, waitingRows, waitingWords, whenWords, type Section } from '../plan/plan-timeline.ts'
+import type { PlanRow } from '../plan/planner.ts'
+
+/** the daemon's planned answer, or null when it does not answer */
+export async function askPlanned(url = daemonUrl()): Promise<PlannedAnswer | null> {
+    try {
+        const r = await fetch(`${url}/api/home/planned.json`, { signal: AbortSignal.timeout(8_000) })
+        if (!r.ok) return null
+        return (await r.json()) as PlannedAnswer
+    } catch {
+        return null
+    }
+}
+
+/** the answer for one repo: its rows and its load error only */
+export function onlyRepo(a: PlannedAnswer, repo: string): PlannedAnswer {
+    return { ...a, rows: a.rows.filter((r) => r.repo === repo), errors: a.errors.filter((e) => e.repo === repo) }
+}
+
+const pad = (s: string, n: number): string => (s.length >= n ? s : s + ' '.repeat(n - s.length))
+
+const lastWords = (r: PlanRow, now: number): string =>
+    r.last == null ? 'never ran' : `last ${r.last.status} ${spanShort(Math.max(0, now - r.last.at))} ago${r.last.streak > 1 ? ` (${r.last.streak} in a row)` : ''}`
+
+const SECTION_WORDS: Record<Section, string> = { now: 'now', next: 'next' }
+
+/** the page's one list as text: its three sections in its order, a line per
+ *  row (when, repo, check and title, mark, last result) and the rule under
+ *  it; the checks that only wait for a save are counted, or listed with `all` */
+export function renderPlanned(a: PlannedAnswer, o: { all?: boolean } = {}): string[] {
+    const out: string[] = [...(a.held ?? [])]
+    const list = timeline(a.rows)
+    const idle = a.rows.filter((r) => r.state === 'idle')
+    const w = {
+        when: Math.max(0, ...list.map((x) => whenWords(x.row, a.now).length)),
+        what: Math.max(0, ...list.map((x) => `${x.row.repo} ${x.row.check}`.length)),
+    }
+    let prev: Section | null = null
+    for (const { section, row } of list) {
+        if (section !== prev) {
+            out.push(SECTION_WORDS[section])
+            prev = section
+        }
+        const m = markOf(row)
+        const title = titleWords(row.title, row.check)
+        const cells = [`  ${pad(whenWords(row, a.now), w.when)}`, pad(`${row.repo} ${row.check}`, w.what), m.words, lastWords(row, a.now)]
+        out.push(cells.filter((c) => c !== '').join('  '))
+        out.push(`      ${title == null ? '' : `${title} · `}${row.rule}`)
+        if (row.error != null) out.push(`      error: ${row.error}`)
+    }
+    if (list.length === 0) out.push(a.rows.length === 0 ? 'nothing is planned' : 'nothing has a time of its own')
+    const waiting = waitingRows(a.rows)
+    if (waiting.length > 0) {
+        out.push(`${waitingWords(a.rows)}${o.all === true ? '' : ' (--all lists them)'}`)
+        if (o.all === true) for (const r of waiting) out.push(`  ${r.repo} ${r.check}  ${lastWords(r, a.now)}  · ${r.rule}`)
+    }
+    if (o.all === true && idle.length > 0) {
+        out.push('on a save only')
+        for (const r of [...idle].sort((x, y) => x.repo.localeCompare(y.repo) || x.check.localeCompare(y.check))) out.push(`  ${r.repo} ${r.check}  ${lastWords(r, a.now)}  · ${r.rule}`)
+    }
+    for (const e of a.errors) out.push(`WARN ${e.repo}: ${e.error}`)
+    const n = { now: list.filter((x) => x.section === 'now').length, next: list.filter((x) => x.section === 'next').length }
+    out.push(`${n.now} now, ${n.next} next, ${waiting.length} waiting, ${idle.length} on a save only${o.all === true || idle.length === 0 ? '' : ' (--all lists them)'}`)
+    return out
+}
+
+export class PlannedCommand extends Command {
+    static override paths = [['planned']]
+
+    static override usage = Command.Usage({
+        category: 'Home',
+        description: 'the planned page in the console: every check the machine runs on its own time, running now, then next, each with its repo, check and title, when, the rule that planned it and its last result. Asks the daemon, which holds the plan. With the daemon down it says so and exits 0',
+        examples: [
+            ['the plan, as the page lists it', 'shipkit planned'],
+            ['one repo only', 'shipkit planned --repo my-app'],
+            ['also the checks that only a save runs', 'shipkit planned --all'],
+            ['the route\'s exact payload', 'shipkit planned --json'],
+        ],
+    })
+
+    json = Option.Boolean('--json', false, { description: 'the daemon route\'s exact payload: { now, rows, errors, running, held }' })
+    repo = Option.String('--repo', { required: false, description: 'only this repo\'s rows' })
+    all = Option.Boolean('--all', false, { description: 'also list the checks that only a save runs (the page leaves them out)' })
+
+    async execute(): Promise<number> {
+        const got = await askPlanned()
+        if (got == null) {
+            const why = `the daemon does not answer on ${daemonUrl()}, and the plan lives there: no plan is known (\`shipkit pm\` starts it)`
+            if (this.json) {
+                this.context.stdout.write('null\n')
+                this.context.stderr.write(`${why}\n`)
+            } else this.context.stdout.write(`${why}\n`)
+            return 0
+        }
+        const a = this.repo == null ? got : onlyRepo(got, this.repo)
+        if (this.json) {
+            this.context.stdout.write(`${JSON.stringify(a, null, 2)}\n`)
+            return 0
+        }
+        if (this.repo != null && a.rows.length === 0 && a.errors.length === 0) {
+            const known = [...new Set(got.rows.map((r) => r.repo))].sort()
+            this.context.stdout.write(`no planned check in ${this.repo}; the plan holds ${known.join(', ') || 'no repo'}\n`)
+            return 0
+        }
+        for (const l of renderPlanned(a, { all: this.all })) this.context.stdout.write(`${l}\n`)
+        return 0
+    }
+}

package/src/cli.ts

@@ -9,10 +9,15 @@ import { AssetsAddCommand, AssetsCheckCommand, AssetsFillCommand, AssetsGenComma
 import { BumpCommand } from './cli/cmd_Bump.ts'
 import { CheckCommand } from './cli/cmd_Check.ts'
 import { CommandsCommand } from './cli/cmd_Commands.ts'
+import { aliasArgs, CrossRepoActivityCommand } from './cli/cmd_CrossRepoActivity.ts'
 import { ConfigKeysCommand } from './cli/cmd_ConfigKeys.ts'
+import { GlobalProcessesCommand } from './cli/cmd_GlobalProcesses.ts'
+import { PlannedCommand } from './cli/cmd_Planned.ts'
+import { OverviewCommand } from './cli/cmd_Overview.ts'
 import { CiCommand } from './cli/cmd_Ci.ts'
 import { ContractsCommand } from './cli/cmd_Contracts.ts'
 import { FleetCommand } from './cli/cmd_Fleet.ts'
+import { DaemonCommand, GuiCommand, PmCommand, PmInstallCommand, PmUninstallCommand, WebCommand } from './cli/cmd_Home.ts'
 import { HooksCommitMsgCommand, HooksInstallCommand, HooksListCommand, HooksPreCommitCommand } from './cli/cmd_Hooks.ts'
 import { InitCommand } from './cli/cmd_Init.ts'
 import { KeysCommand } from './cli/cmd_Keys.ts'
@@ -59,6 +64,12 @@ export function buildCli(): Cli {
     cli.register(CheckCommand)
     cli.register(TuiCommand)
     cli.register(ServeCommand)
+    cli.register(PmCommand)
+    cli.register(DaemonCommand)
+    cli.register(WebCommand)
+    cli.register(PmInstallCommand)
+    cli.register(PmUninstallCommand)
+    cli.register(GuiCommand)
     cli.register(ContractsCommand)
     cli.register(AsksCommand)
     cli.register(AsksCheckCommand)
@@ -79,6 +90,10 @@ export function buildCli(): Cli {
     cli.register(SmokeCommand)
     cli.register(ReflectCommand)
     cli.register(KeysCommand)
+    cli.register(GlobalProcessesCommand)
+    cli.register(CrossRepoActivityCommand)
+    cli.register(PlannedCommand)
+    cli.register(OverviewCommand)
     cli.register(ChecksCommand)
     cli.register(UnitsAliasCommand)
     cli.register(CommandsCommand)
@@ -87,5 +102,18 @@ export function buildCli(): Cli {
     return cli
 }
 
-// only when this file IS the process, so importing it costs nothing
-if (import.meta.main) void buildCli().runExit(process.argv.slice(2))
+// only when this file IS the process, so importing it costs nothing. A repo's
+// installed copy first hands the command to the house source (handoff.ts). One copy
+// of the lib per process: a repo config that imports its own install lands on
+// this one (one-lib.ts), so the machine's version runs in every repo. Then pm
+// is started when it is down (autostart.ts), before the command runs
+if (import.meta.main) {
+    const argv = aliasArgs(process.argv.slice(2))
+    const { handoff } = await import('./home/handoff.ts')
+    handoff(argv)
+    const { useOneLib } = await import('./core/one-lib.ts')
+    useOneLib()
+    const { autostart } = await import('./home/autostart.ts')
+    await autostart(argv)
+    void buildCli().runExit(argv)
+}

package/src/collections/checks.ts

@@ -18,7 +18,7 @@ import { homedir } from 'os'
 import { isAbsolute, join, relative, resolve } from 'path'
 import { rawName, routesToShipkit } from '../core/canonical-scripts.ts'
 import { FLOOR_IDS } from '../core/floor.ts'
-import { formatLine, parseDuration } from '../core/wire.ts'
+import { FOREVER_MS, formatLine, ttlMsOf } from '../core/wire.ts'
 import { gateInventory, type CheckRow } from '../ledger/gate-checks.ts'
 import { readLastLines, readRuns, runsPath, type LastLine, type RunRow } from '../ledger/run-log.ts'
 import { checkStatsFor, type CheckStat } from '../ledger/check-stats.ts'
@@ -166,7 +166,8 @@ function instanceOf(root: string, c: RepoConfig, row: CheckRow, stat: CheckStat
 export function keepsUntil(ttl: string | undefined, stat: Pick<CheckStat, 'measuredAt' | 'measuredStatus'> | undefined): number | null {
     if (ttl == null || ttl === '' || stat?.measuredAt == null) return null
     let ms = 0
-    try { ms = parseDuration(ttl) } catch { return null }
+    try { ms = ttlMsOf(ttl) } catch { return null }
+    if (ms >= FOREVER_MS && stat.measuredStatus === 'pass') return null
     if (ms <= 0) return null
     return stat.measuredAt + (stat.measuredStatus === 'pass' ? ms : Math.min(ms, NEGATIVE_TTL_CAP_MS))
 }

package/src/collections/providers.ts

@@ -31,7 +31,7 @@ import { testsCollection } from './tests.ts'
 import { checksCollection } from './checks.ts'
 import { LAYOUT } from '../core/layout.ts'
 import { isBudgetLine } from '../core/budget.ts'
-import { GH_LOGIN_CRED } from '../checks/SK021-github-login.check.ts'
+import { GH_LOGIN_CRED } from '../core/gh-login.ts'
 
 const askDirOf = (root: string, c: RepoConfig): string => join(root, c.asks?.dir ?? LAYOUT.asks)
 // read path must not mint an asks/ dir (listAsks mkdirs on read)

package/src/collections/test-time.ts

@@ -127,9 +127,15 @@ export type TestCheckRow = {
     shape: Shape | null
 }
 
+/** one file of any test check, named with the check that runs it */
+export type TestFileRow = FileTime & { check: string }
+
 export type TestsRootView = {
     /** slowest wall first, the never ran ones last */
     checks: TestCheckRow[]
+    /** every file of every test check, slowest first, the never ran ones
+     *  last: each check's own list, merged */
+    files: TestFileRow[]
     failing: FailingFile[]
 }
 
@@ -270,8 +276,10 @@ function lastRunOf(checkId: string, at: number, files: FileTime[], sumMs: number
 
 export function shapeTestsRoot(o: TestTimeInput): TestsRootView {
     const ids = [...new Set(o.facts.filter((f) => f.standing === 'runs' && f.checkId != null).map((f) => f.checkId!))]
+    const files: TestFileRow[] = []
     const checks = ids.map((checkId): TestCheckRow => {
         const v = shapeTestCheck(checkId, o)
+        for (const f of v.files) files.push({ ...f, check: checkId })
         const top = v.files.find((f) => f.ms != null)
         return {
             checkId,
@@ -284,5 +292,6 @@ export function shapeTestsRoot(o: TestTimeInput): TestsRootView {
             shape: v.last?.shape ?? null,
         }
     }).sort((a, b) => (b.wallMs ?? -1) - (a.wallMs ?? -1) || a.checkId.localeCompare(b.checkId))
-    return { checks, failing: failingOf(o.facts) }
+    files.sort((a, b) => (b.ms ?? -1) - (a.ms ?? -1) || a.file.localeCompare(b.file))
+    return { checks, files, failing: failingOf(o.facts) }
 }

package/src/comfy/comfy-panel.ts

@@ -8,6 +8,7 @@
 import { existsSync, readdirSync, readFileSync } from 'fs'
 import { join, resolve } from 'path'
 import { defaultHubPort } from '../serve/hub-port.ts'
+import { portHolders } from '../core/port-holders.ts'
 
 export type ComfyWorkflow = { id: string; file: string }
 export type ComfyPanelUp = { url: string; port: number }
@@ -127,22 +128,6 @@ const KILL_STEP_MS = 25
 const QUIET_TRIES = 60
 const QUIET_STEP_MS = 50
 
-/** the pids LISTENING on a tcp port, on darwin and linux. `-sTCP:LISTEN`
- *  carries the whole answer: `-i tcp:<port>` alone also matches every client
- *  connected to it, this process included, and those must never be killed.
- *  lsof sits in /usr/sbin on darwin, which a gui-launched shell can miss */
-function portHolders(port: number): number[] {
-    const lsof = Bun.which('lsof') ?? ['/usr/sbin/lsof', '/usr/bin/lsof'].find((p) => existsSync(p))
-    if (lsof == null) return []
-    const r = Bun.spawnSync([lsof, '-ti', `tcp:${port}`, '-sTCP:LISTEN'], { stdout: 'pipe', stderr: 'ignore' })
-    const pids = r.stdout
-        .toString()
-        .split('\n')
-        .map((l) => Number(l.trim()))
-        .filter((n) => Number.isInteger(n) && n > 0)
-    return [...new Set(pids)]
-}
-
 /** a pid that died between the scan and the signal is the outcome we wanted */
 function kill(pid: number, signal: 'SIGTERM' | 'SIGKILL'): void {
     try {

package/src/core/agent-spawn.ts

@@ -0,0 +1,46 @@
+// AGENT SPAWN, found statically: code that starts a Claude or agent process on
+// its own (a spawn or exec of `claude`, `claude -p`, the agent sdk). No tool
+// here starts an agent unless its owner asks in person, so the sweep tests
+// (tests/no-agent-spawn.test.ts, and the house repo's own) fail on any hit.
+//
+// a string that only MENTIONS claude (a url, `~/.claude/projects`, a help
+// line naming the product) is no spawn, and comments are skipped.
+
+export type AgentSpawn = { line: number; what: string }
+
+const SHAPES: { re: RegExp; what: string }[] = [
+    // the sdks that run an agent loop in process or spawn the cli
+    { re: /(['"`])@anthropic-ai\/(?:claude-agent-sdk|claude-code)(?:\/[^'"`]*)?\1/, what: 'imports the agent sdk' },
+    // an argv whose command is claude: spawn(['claude', …]), c.exec(['claude'])
+    { re: /\[\s*(['"`])(?:[^'"`\s]*\/)?claude\1/, what: 'an argv that runs claude' },
+    // spawn('claude', …), execSync('claude -p …'), execFile('claude')
+    { re: /\b(?:spawn|spawnSync|exec|execSync|execFile|execFileSync|execa|execaSync|fork)\s*\(\s*(['"`])(?:[^'"`\s]*\/)?claude(?:\s[^'"`]*)?\1/, what: 'a process call that runs claude' },
+    // the bun shell: $`claude -p …`
+    { re: /\$\s*`\s*(?:[^`\s]*\/)?claude(?:\s|`)/, what: 'a bun shell line that runs claude' },
+    // the headless form, wherever the string goes
+    { re: /(['"`])(?:[^'"`\s]*\/)?claude\s+(?:-p|--print)\b/, what: 'a claude -p command line' },
+]
+
+/** the first agent spawn in one source text, 1-based line, comments skipped */
+export function agentSpawnIn(src: string): AgentSpawn | null {
+    const lines = src.split('\n')
+    let inBlock = false
+    for (let i = 0; i < lines.length; i++) {
+        let l = lines[i]!
+        if (inBlock) {
+            const end = l.indexOf('*/')
+            if (end < 0) continue
+            l = l.slice(end + 2)
+            inBlock = false
+        }
+        l = l.replace(/\/\*.*?\*\//g, '')
+        const open = l.indexOf('/*')
+        if (open >= 0) {
+            inBlock = true
+            l = l.slice(0, open)
+        }
+        l = l.replace(/(^|\s)\/\/.*$/, '$1')
+        for (const s of SHAPES) if (s.re.test(l)) return { line: i + 1, what: s.what }
+    }
+    return null
+}

package/src/core/archived.ts

@@ -0,0 +1,82 @@
+// `archived: true` in repo.config.ts: the repo stays known and listed, and
+// nothing runs there (no hub load, so no watch, no plan rows, no gates, no
+// processes, no widgets, no identity fill). Read and written as TEXT, never by
+// loading the config: the daemon and the page rows read many configs per poll,
+// and the toggle moves that one key and no other byte.
+import { readFileSync } from 'fs'
+import { join } from 'path'
+import { atomicWrite } from './locked-write.ts'
+import { configDepths } from './identity-color.ts'
+
+const KEY_RE = /(?:^|[{,])\s*(['"]?)archived\1\s*:\s*(true|false)\b/gm
+
+/** every top level `archived` key of `defineRepo({…})` with its value and the
+ *  offsets of the whole `archived: <value>` token */
+function archivedKeys(text: string): { on: boolean; start: number; end: number }[] {
+    const depth = configDepths(text)
+    const out: { on: boolean; start: number; end: number }[] = []
+    for (const m of text.matchAll(KEY_RE)) {
+        const lead = /^[{,]/.test(m[0]) ? 1 : 0
+        const sep = lead === 1 ? m.index : m.index - 1
+        if (sep < 0 || depth[sep] !== 1) continue
+        const start = m.index + lead + /^[{,]?(\s*)/.exec(m[0])![1]!.length
+        out.push({ on: m[2] === 'true', start, end: m.index + m[0].length })
+    }
+    return out
+}
+
+/** does the config text archive the repo */
+export const archivedOfText = (text: string): boolean => archivedKeys(text).some((k) => k.on)
+
+/** the config text with the repo archived or not. On: the key reads true, a
+ *  missing one lands as the first key of `defineRepo({`. Off: the key goes,
+ *  so a round trip gives the text back byte for byte */
+export function setArchivedText(text: string, on: boolean): string {
+    const keys = archivedKeys(text)
+    if (keys.length > 1) throw new Error('repo.config.ts declares `archived` more than once, set it by hand')
+    const k = keys[0]
+    if (on) {
+        if (k != null) return k.on ? text : `${text.slice(0, k.start)}archived: true${text.slice(k.end)}`
+        const lines = text.split('\n')
+        const open = lines.findIndex((l) => /defineRepo\(\s*\{/.test(l))
+        if (open === -1) throw new Error('repo.config.ts has no `defineRepo({` to write `archived` into, set it by hand')
+        const line = lines[open]!
+        if (/defineRepo\(\s*\{\s*$/.test(line)) {
+            const next = lines.slice(open + 1).find((l) => l.trim() !== '' && !/^\s*}/.test(l))
+            const pad = next != null ? /^(\s*)/.exec(next)![1]! : `${/^(\s*)/.exec(line)![1]!}    `
+            return [...lines.slice(0, open + 1), `${pad}archived: true,`, ...lines.slice(open + 1)].join('\n')
+        }
+        lines[open] = line.replace(/defineRepo\(\s*\{\s*/, (m) => `${m}archived: true, `)
+        return lines.join('\n')
+    }
+    if (k == null) return text
+    // a line of its own goes whole, an inline key goes with its comma
+    const lineStart = text.lastIndexOf('\n', k.start - 1) + 1
+    const lineEnd = text.indexOf('\n', k.end)
+    const rest = text.slice(k.end, lineEnd === -1 ? text.length : lineEnd)
+    if (text.slice(lineStart, k.start).trim() === '' && /^\s*,?\s*$/.test(rest)) return text.slice(0, lineStart) + text.slice(lineEnd === -1 ? text.length : lineEnd + 1)
+    const after = /^\s*,\s*/.exec(text.slice(k.end))
+    if (after != null) return text.slice(0, k.start) + text.slice(k.end + after[0].length)
+    const before = /,\s*$/.exec(text.slice(0, k.start))
+    return before != null ? text.slice(0, k.start - before[0].length) + text.slice(k.end) : text.slice(0, k.start) + text.slice(k.end)
+}
+
+const CONFIG_FILE = 'repo.config.ts'
+
+/** is this repo archived; false when it has no readable config */
+export function isArchived(root: string): boolean {
+    try {
+        return archivedOfText(readFileSync(join(root, CONFIG_FILE), 'utf8'))
+    } catch {
+        return false
+    }
+}
+
+/** archive the repo or bring it back: only that key of its config moves */
+export function writeArchived(root: string, on: boolean): boolean {
+    const path = join(root, CONFIG_FILE)
+    const text = readFileSync(path, 'utf8')
+    const out = setArchivedText(text, on)
+    if (out !== text) atomicWrite(path, out)
+    return on
+}

package/src/core/attach.ts

@@ -39,9 +39,11 @@ export type ShareOpts = {
     abort?: () => boolean
 }
 
-/** how long an answer file stays on disk. Only an in flight asker can adopt
- *  one, so this is housekeeping, not a validity window. */
-const KEEP_MS = 60 * 60 * 1000
+/** how long a slot file stays on disk. Only an in flight asker can adopt an
+ *  answer, so this is housekeeping, not a validity window. A live holder
+ *  heartbeats its lock (locked-write.ts), so a lock this old is one a killed
+ *  run left behind. */
+export const INFLIGHT_KEEP_MS = 60 * 60 * 1000
 
 const readShared = <T>(path: string): Shared<T> | null => {
     try {
@@ -50,12 +52,15 @@ const readShared = <T>(path: string): Shared<T> | null => {
     } catch { return null }
 }
 
-const sweep = (dir: string, now: number): void => {
+/** every slot file past the keep window goes: answers, the locks killed runs
+ *  left, the graves of a steal. One level of namespace dirs below `dir` is
+ *  walked too. */
+export function sweepSlots(dir: string, now: number, keepMs = INFLIGHT_KEEP_MS): void {
     try {
-        for (const f of readdirSync(dir)) {
-            if (f.endsWith('.lock')) continue
-            const p = `${dir}/${f}`
-            try { if (statSync(p).mtimeMs < now - KEEP_MS) rmSync(p, { force: true }) } catch { /* raced: gone either way */ }
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+            const p = `${dir}/${e.name}`
+            if (e.isDirectory()) { sweepSlots(p, now, keepMs); continue }
+            try { if (statSync(p).mtimeMs < now - keepMs) rmSync(p, { force: true }) } catch { /* raced: gone either way */ }
         }
     } catch { /* housekeeping never fails a run */ }
 }
@@ -86,7 +91,7 @@ export async function shareRun<T>(slot: string, o: ShareOpts, body: () => Promis
                 // an answer nobody can adopt costs the waiters a measurement, never a verdict
             }
         }
-        sweep(dirname(slot), now)
+        sweepSlots(dirname(slot), now)
         return { kind: 'measured', value: r.value }
     })
     if (leased.ok) return leased.value

package/src/core/canonical-scripts.ts

@@ -65,12 +65,21 @@ export function routesToShipkit(body: string): boolean {
     return /\bshipkit\b\S*(?:\s+\S+)*?\s+ci(?:\s|$)/.test(body.split(/&&|\|\||;/)[0] ?? body)
 }
 
-// recover the consumption style from existing scripts: any shipkit command
-// already running `bun <path>/cli.ts <cmd>` fixes the style for new bodies
+/** is this path shipkit's own cli: a file named exactly `cli.ts` under a
+ *  directory whose name says shipkit. A repo's own cli (`src/cli.ts`,
+ *  `src/cli/comfy-ts-cli.ts`) is not, and taking it for shipkit writes
+ *  scripts that call a command that cli does not have */
+export function isShipkitCli(path: string): boolean {
+    const parts = path.split('/')
+    return parts.at(-1) === 'cli.ts' && parts.slice(0, -1).some((d) => /shipkit/.test(d))
+}
+
+// recover the consumption style from existing scripts: any script already
+// running shipkit's cli by path fixes the style for new bodies
 export function inferBin(scripts: Record<string, string>): string | undefined {
     for (const body of Object.values(scripts)) {
         const m = body.match(/^bun (?:--watch )?(\S+cli\.ts) /)
-        if (m != null && m[1] !== 'node_modules/rvlib-shipkit/src/cli.ts') return m[1]
+        if (m != null && isShipkitCli(m[1]!) && m[1] !== 'node_modules/rvlib-shipkit/src/cli.ts') return m[1]
     }
     return undefined
 }

package/src/core/check-file-names.ts

@@ -5,6 +5,14 @@
 import { basename, relative } from 'path'
 
 export const CHECK_SUFFIX = '.check.ts'
+/** the unit file: a check, a global process or a widget, by its default
+ *  export (shipkit-files.ts). Discovery reads both suffixes, and will later
+ *  read this one alone */
+export const UNIT_SUFFIX = '.shipkit.ts'
+
+/** the name a unit file answers to when it declares no id: its basename,
+ *  `.check` dropped too, so `x.check.shipkit.ts` is `x` */
+export const unitBase = (file: string): string => basename(file).slice(0, -UNIT_SUFFIX.length).replace(/\.check$/, '')
 
 /** dirs discovery never walks into, beside every dot dir: installs, build
  *  output, scratch, and templates meant for other repos */