rvlib-shipkit 1.7.0 → 1.9.0

package/src/home/gui-app/ShipkitGui.swift

@@ -130,6 +130,7 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
 
     func applicationDidFinishLaunching(_ note: Notification) {
         if CommandLine.arguments.contains("--self-test-find") { return selfTestFind() }
+        if CommandLine.arguments.contains("--self-test-panels") { return selfTestPanels() }
         buildMenu()
         // esc closes the find bar of the key window, and reaches the page otherwise
         NSEvent.addLocalMonitorForEvents(matching: .keyDown) { e in
@@ -267,6 +268,61 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         web.loadHTMLString("<p>one needle, two needle</p>", baseURL: nil)
     }
 
+    /** hears every js panel once it shows: the self test answers it */
+    var onPanel: ((NSAlert) -> Void)?
+
+    // `--self-test-panels`: a page in an offscreen window calls prompt, confirm
+    // and alert, answered OK after typing over the prompt's text, then again,
+    // answered with esc. What the page got printed, exit 0 only when every
+    // answer reached it. Return is checked as OK being the sheet's default
+    // button: a synthetic return reaches it only in a key window, and the test
+    // must not take the focus
+    func selfTestPanels() {
+        let web = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        web.navigationDelegate = self
+        web.uiDelegate = self
+        let win = NSWindow(contentRect: NSRect(x: -4000, y: -4000, width: 600, height: 400), styleMask: [.titled], backing: .buffered, defer: false)
+        win.contentView = Pane(web: web)
+        win.orderFrontRegardless()
+        windows.append(win)
+        var accept = true
+        var panels = 0
+        var returnIsOK = true
+        var escHeard = true
+        onPanel = { alert in
+            panels += 1
+            DispatchQueue.main.async {
+                if alert.window.defaultButtonCell !== alert.buttons[0].cell { returnIsOK = false }
+                if accept {
+                    // typing replaces the default text only when it is selected in an active editor
+                    if let field = alert.accessoryView as? NSTextField { (field.currentEditor() as? NSTextView)?.insertText("typed", replacementRange: NSRange(location: NSNotFound, length: 0)) }
+                    return alert.buttons[0].performClick(nil)
+                }
+                if alert.buttons.count == 1 { return alert.buttons[0].performClick(nil) }
+                let esc = NSEvent.keyEvent(with: .keyDown, location: .zero, modifierFlags: [], timestamp: 0, windowNumber: alert.window.windowNumber, context: nil, characters: "\u{1b}", charactersIgnoringModifiers: "\u{1b}", isARepeat: false, keyCode: 53)
+                if let esc, alert.window.performKeyEquivalent(with: esc) { return }
+                escHeard = false
+                alert.buttons[1].performClick(nil)
+            }
+        }
+        let js = "JSON.stringify([prompt('name', 'x'), confirm('ok?'), (alert('hi'), 'alerted')])"
+        onLoad = { _ in
+            web.evaluateJavaScript(js) { a, _ in
+                accept = false
+                web.evaluateJavaScript(js) { b, _ in
+                    let ok = (a as? String) ?? "none", cancel = (b as? String) ?? "none"
+                    print("panels=\(panels)")
+                    print("return-is-ok=\(returnIsOK)")
+                    print("esc-heard=\(escHeard)")
+                    print("ok=\(ok)")
+                    print("cancel=\(cancel)")
+                    exit(panels == 6 && returnIsOK && escHeard && ok == "[\"typed\",true,\"alerted\"]" && cancel == "[null,false,\"alerted\"]" ? 0 : 1)
+                }
+            }
+        }
+        web.loadHTMLString("<p>panels</p>", baseURL: nil)
+    }
+
     func windowWillClose(_ note: Notification) {
         windows.removeAll { $0 === note.object as? NSWindow }
     }
@@ -293,6 +349,46 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         return nil
     }
 
+    // alert, confirm and prompt: without these WebKit answers each one at once
+    // (no panel, confirm false, prompt null), so a page's dialogs do nothing.
+    // WebKit throws when a handler is dropped or called twice: `panel` calls
+    // `done` exactly once on every path
+
+    /** one js panel: a sheet on the page's window, a modal where there is
+     *  none. Return is OK, esc is Cancel; `done` hears whether OK was pressed */
+    func panel(_ web: WKWebView, _ message: String, cancel: Bool, field: NSTextField? = nil, done: @escaping (Bool) -> Void) {
+        let alert = NSAlert()
+        alert.messageText = message
+        alert.addButton(withTitle: "OK").keyEquivalent = "\r"
+        if cancel { alert.addButton(withTitle: "Cancel").keyEquivalent = "\u{1b}" }
+        if let field {
+            alert.accessoryView = field
+            alert.window.initialFirstResponder = field
+        }
+        guard let win = web.window else {
+            onPanel?(alert)
+            return done(alert.runModal() == .alertFirstButtonReturn)
+        }
+        alert.beginSheetModal(for: win) { r in done(r == .alertFirstButtonReturn) }
+        // first responder selects the whole default text, so typing replaces it
+        if let field { alert.window.makeFirstResponder(field) }
+        onPanel?(alert)
+    }
+
+    func webView(_ web: WKWebView, runJavaScriptAlertPanelWithMessage message: String, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping () -> Void) {
+        panel(web, message, cancel: false) { _ in completionHandler() }
+    }
+
+    func webView(_ web: WKWebView, runJavaScriptConfirmPanelWithMessage message: String, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping (Bool) -> Void) {
+        panel(web, message, cancel: true) { ok in completionHandler(ok) }
+    }
+
+    func webView(_ web: WKWebView, runJavaScriptTextInputPanelWithPrompt prompt: String, defaultText: String?, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping (String?) -> Void) {
+        let field = NSTextField(string: defaultText ?? "")
+        field.frame = NSRect(x: 0, y: 0, width: 300, height: 24)
+        panel(web, prompt, cancel: true, field: field) { ok in completionHandler(ok ? field.stringValue : nil) }
+    }
+
     func item(_ menu: NSMenu, _ title: String, _ action: Selector, _ key: String, _ mods: NSEvent.ModifierFlags = [.command], tag: Int = 0) {
         let i = menu.addItem(withTitle: title, action: action, keyEquivalent: key)
         i.keyEquivalentModifierMask = mods

package/src/home/home-routes.ts

@@ -18,6 +18,7 @@ import type { Planner, PlanRow } from '../plan/planner.ts'
 import type { Widgets, WidgetView } from './widgets.ts'
 import { ActivityCache, repoActivity, windowMinutes } from './activity.ts'
 import { devRepos, InsightsCache, type Scope } from './insights.ts'
+import { GLOBAL_CONTEXT_EVERY_MS, houseContext, writeIfChanged } from './global-context.ts'
 import { HouseRuns } from '../serve/house-runs.ts'
 
 /** how far back a repo's git page lists its commits */
@@ -126,6 +127,7 @@ export function homeRoutes(d: HomeDeps) {
     }
 
     let active = new Set<string>()
+    let contextAt = -Infinity
     if (d.plan != null) d.plan.active = (name) => active.has(name)
 
     async function tick(): Promise<void> {
@@ -133,6 +135,14 @@ export function homeRoutes(d: HomeDeps) {
         active = activeSet(rows, d.state.data.active, rows.find((r) => r.path === d.root)?.name ?? d.name)
         // the plan's clock: one look per tick, and it starts at most one batch
         d.plan?.tick()
+        // the house's generated context: rewritten only when a source moved,
+        // and never held on
+        if (Date.now() - contextAt >= GLOBAL_CONTEXT_EVERY_MS) {
+            contextAt = Date.now()
+            void houseContext(d.root)
+                .then((c) => { if (c != null && writeIfChanged(c.path, c.text)) console.log(`ok: wrote ${c.path}`) })
+                .catch((e) => console.error(`WARN the global context could not be written: ${(e as Error).message}`))
+        }
         // a widget render never holds the tick back
         void d.widgets?.tick(repos.map((r) => ({ name: r.name, path: r.path }))).catch((e) => console.error(`WARN the widgets broke: ${(e as Error).message}`))
         await d.hubs.tick(active)

package/src/home/resources.ts

@@ -285,6 +285,9 @@ export class Resource {
      *  while it answers, else it starts and opens once it does */
     async open(how: OpenHow): Promise<void> {
         if (this.decl.url == null) throw new Error(`${this.decl.id} declares no url to open`)
+        // the status is the last tick's: a process that died since would get
+        // a window on a dead port and never start
+        await this.tick()
         if (this.status === 'up') {
             this.show(how, this.decl.url)
             return

package/src/plan/planner.ts

@@ -11,7 +11,8 @@
 //
 // what keeps it off the cpu: a save burst is asked about once the repo is
 // quiet (QUIET_MS, or MAX_WAIT_MS into a burst that never stops), a check a
-// save moved waits COST_FACTOR times its last measured run, and nothing it
+// save moved waits COST_FACTOR times its last measured run and GATED_HOLD_MS
+// after the latest gate someone else started in its repo, and nothing it
 // starts on its own starts while the load per core is above LOAD_MAX.
 import { availableParallelism, loadavg } from 'os'
 import { CATCH_UP_BEAT_MS, resumeCatchUp, type CatchUpStore } from './catch-up.ts'
@@ -39,6 +40,9 @@ export type PlanSource = {
     checks: () => Promise<PlanCheck[]>
     /** every check's last result on record */
     last: () => Record<string, LastResult>
+    /** when the latest run someone asked for started here (a terminal, an
+     *  agent, a click), never one the plan started; null when none did */
+    gatedAt?: () => number | null
     /** the checks a save moved: their answer would not replay */
     changed: () => Promise<string[]>
     /** run these checks now, in the background; resolves to the exit code */
@@ -88,6 +92,11 @@ export const MAX_WAIT_MS = 10 * 60_000
  *  measured run: a 30s suite at most every 10 minutes, a 200ms lint at once */
 export const COST_FACTOR = 20
 
+/** a save moved check waits this long after the latest run someone else
+ *  started in its repo (a terminal, an agent, a click): whoever gates that
+ *  tree is still at work, and its own gate measures what it changed */
+export const GATED_HOLD_MS = 10 * 60_000
+
 /** above this 1 minute load average per core, the plan starts nothing on its
  *  own: every core already has a process waiting for it */
 export const LOAD_MAX = 1
@@ -112,6 +121,7 @@ type Repo = {
     src: PlanSource
     checks: PlanCheck[]
     last: Record<string, LastResult>
+    gatedAt: number | null
     lastRead: number
     marks: Map<string, Mark>
     timer: unknown
@@ -169,7 +179,7 @@ export class Planner {
     async add(src: PlanSource): Promise<void> {
         const old = this.repos.get(src.repo)
         if (old?.timer != null) this.timers.clear(old.timer)
-        const r: Repo = { src, checks: [], last: {}, lastRead: -Infinity, marks: old?.marks ?? new Map(), timer: null, burstAt: null, settleAt: null, detecting: null, again: false, error: null }
+        const r: Repo = { src, checks: [], last: {}, gatedAt: null, lastRead: -Infinity, marks: old?.marks ?? new Map(), timer: null, burstAt: null, settleAt: null, detecting: null, again: false, error: null }
         this.repos.set(src.repo, r)
         await this.reload(src.repo)
         try {
@@ -223,6 +233,7 @@ export class Planner {
         r.lastRead = now
         try {
             r.last = r.src.last()
+            r.gatedAt = r.src.gatedAt?.() ?? null
         } catch (e) {
             this.fail(r.src.repo, e)
         }
@@ -315,7 +326,9 @@ export class Planner {
             // a check pays for its own runs: one save cannot run it again
             // before COST_FACTOR times its last measured run has passed
             const spaced = last?.cost != null ? last.cost.at + COST_FACTOR * last.cost.ms : -Infinity
-            const at = Math.max(m.changedAt, spaced)
+            // and it waits for whoever gates this tree by hand to stop
+            const gated = r.gatedAt != null ? r.gatedAt + GATED_HOLD_MS : -Infinity
+            const at = Math.max(m.changedAt, spaced, gated)
             return { ...base, state: at > now ? 'next' : 'due', reason: 'changed', dueAt: at }
         }
         const lastAt = Math.max(last?.at ?? -Infinity, m.attemptAt ?? -Infinity)
@@ -354,8 +367,12 @@ export class Planner {
     held(): string[] {
         const now = this.now()
         const out: string[] = []
-        for (const r of this.repos.values())
+        for (const r of this.repos.values()) {
             if (r.settleAt != null) out.push(`settling: ${r.src.repo}, ${Math.max(0, Math.ceil((r.settleAt - now) / 1_000))}s`)
+            const until = r.gatedAt == null ? null : r.gatedAt + GATED_HOLD_MS
+            if (until != null && until > now && [...r.marks.values()].some((m) => m.changedAt != null))
+                out.push(`deferred: ${r.src.repo}, a gate someone started there ${Math.floor((now - r.gatedAt!) / 60_000)}m ago, so what a save moved waits ${Math.ceil((until - now) / 60_000)}m`)
+        }
         if (this.holdReason != null) out.push(this.holdReason)
         return out
     }

package/src/plan/repo-source.ts

@@ -82,12 +82,15 @@ export function readLastCosts(path: string): Record<string, { at: number; ms: nu
     return out
 }
 
-/** when the latest run on record started, whoever ran it, or null */
-export function lastStarted(path: string): number | null {
+/** when the latest run on record started, or null. `asked`: only a run
+ *  someone asked for (a terminal, an agent, a click), never one the plan
+ *  started on its own */
+export function lastStarted(path: string, o: { asked?: boolean } = {}): number | null {
     const opened = openDb(path, { create: false })
     if (opened == null) return null
     try {
-        const r = opened.db.query('select max(started) as at from invocations').get() as { at: number | null } | null
+        const sql = o.asked === true ? "select max(started) as at from invocations where by != 'schedule'" : 'select max(started) as at from invocations'
+        const r = opened.db.query(sql).get() as { at: number | null } | null
         return r?.at == null ? null : Number(r.at)
     } catch {
         return null
@@ -144,6 +147,7 @@ export function repoSource(d: RepoSourceDeps): PlanSource {
             for (const [id, cost] of Object.entries(costs)) if (all[id] != null) all[id] = { ...all[id]!, cost }
             return all
         },
+        gatedAt: () => (d.record === '' ? null : lastStarted(d.record, { asked: true })),
         changed: async () => {
             const decls = rows.map((r) => r.decl)
             if (decls.length === 0) return []

package/src/release/run-release.ts

@@ -12,7 +12,7 @@ import { runCi } from '../core/run-ci.ts'
 import { extractChangelogSection } from './changelog.ts'
 import { deriveRemote, dirtyPaths, git, remoteTagState, tagExistsLocally, type RemoteTagState } from './git-facts.ts'
 import { releaseScope } from './release-scope.ts'
-import { npmPublishArgv, unitBlockers } from './unit-gate.ts'
+import { publishCommand, unitBlockers, type Publisher } from './unit-gate.ts'
 import { formatUnitError, resolveUnits, unitById, unknownUnit, type ReleaseUnit } from './units.ts'
 import type { RepoConfig } from '../repo-config.ts'
 import { nestedIn, nestedRefusal } from '../core/nesting.ts'
@@ -37,6 +37,10 @@ export type ReleaseConfig = {
      *  Absent = rely on ambient npm auth. Never put a token in config.
      *  Repo-wide: one account publishes every unit. */
     npmTokenCommand?: string[]
+    /** the tool that packs and publishes every npm unit (default 'npm'). A
+     *  repo that tests its tarball with `bun pm pack` publishes with 'bun', so
+     *  the packer it tests is the packer that ships. */
+    publisher?: Publisher
     /** cut a GitHub release for the ROOT unit with `gh` (default true) */
     githubRelease?: boolean
     /** make a NON-blocking check failure block the release too. Blocking
@@ -301,18 +305,23 @@ export async function releaseUnit(root: string, config: RepoConfig, unit: Releas
         if (wantNpm && !alreadyPublished) {
             const env: Record<string, string> = { ...process.env as Record<string, string> }
             const argv = rc.npmTokenCommand
+            const publisher = rc.publisher ?? 'npm'
             let npmrc: string | null = null
+            let token: string | null = null
             if (argv != null && argv[0] != null) {
                 const t = Bun.spawnSync(argv)
-                const token = t.exitCode === 0 ? t.stdout.toString().trim() : ''
+                token = t.exitCode === 0 ? t.stdout.toString().trim() : ''
                 if (token === '') { print(`FAIL: release.npmTokenCommand produced no token (exit ${t.exitCode})`); return 1 }
-                // token via a throwaway userconfig, never argv, never a
-                // committed .npmrc, never a line in a log
-                npmrc = join(work, 'npmrc')
-                writeFileSync(npmrc, `//registry.npmjs.org/:_authToken=${token}\n`, { mode: 0o600 })
+                // token via a throwaway userconfig (npm) or the env (bun),
+                // never argv, never a committed .npmrc, never a line in a log
+                if (publisher === 'npm') {
+                    npmrc = join(work, 'npmrc')
+                    writeFileSync(npmrc, `//registry.npmjs.org/:_authToken=${token}\n`, { mode: 0o600 })
+                }
             }
-            const p = Bun.spawnSync(npmPublishArgv({ npmrc }), { cwd: unit.dir, env, stdout: 'inherit', stderr: 'inherit' })
-            if (p.exitCode !== 0) { print(`FAIL: npm publish failed for ${unit.id} (exit ${p.exitCode})`); return 1 }
+            const cmd = publishCommand({ publisher, npmrc, token })
+            const p = Bun.spawnSync(cmd.argv, { cwd: unit.dir, env: { ...env, ...cmd.env }, stdout: 'inherit', stderr: 'inherit' })
+            if (p.exitCode !== 0) { print(`FAIL: ${publisher} publish failed for ${unit.id} (exit ${p.exitCode})`); return 1 }
             print(`ok: published ${name}@${version}`)
         }
 

package/src/release/unit-gate.ts

@@ -9,11 +9,18 @@ import { dirtyPaths } from './git-facts.ts'
 import type { ReleaseUnit } from './units.ts'
 import type { RepoConfig } from '../repo-config.ts'
 
-/** the publish argv. `--access public` is not a default: npm restricts a
- *  scoped package unless it is asked, and a restricted publish looks
- *  successful right up until a consumer cannot install it. */
-export function npmPublishArgv(o: { npmrc?: string | null } = {}): string[] {
-    return ['npm', 'publish', '--access', 'public', ...(o.npmrc != null ? ['--userconfig', o.npmrc] : [])]
+/** the tool that packs and publishes an npm unit (`release.publisher`) */
+export const PUBLISHERS = ['npm', 'bun'] as const
+export type Publisher = (typeof PUBLISHERS)[number]
+
+/** the publish argv and the env its token rides in. `--access public` is not
+ *  a default: npm restricts a scoped package unless it is asked, and a
+ *  restricted publish looks successful right up until a consumer cannot
+ *  install it. npm reads the token from a throwaway userconfig; `bun publish`
+ *  has no `--userconfig` and reads NPM_CONFIG_TOKEN instead. */
+export function publishCommand(o: { publisher?: Publisher; npmrc?: string | null; token?: string | null } = {}): { argv: string[]; env: Record<string, string> } {
+    if (o.publisher === 'bun') return { argv: ['bun', 'publish', '--access', 'public'], env: o.token != null ? { NPM_CONFIG_TOKEN: o.token } : {} }
+    return { argv: ['npm', 'publish', '--access', 'public', ...(o.npmrc != null ? ['--userconfig', o.npmrc] : [])], env: {} }
 }
 
 /** everything that must hold for this unit, checked before anything is

package/src/repo-config.ts

@@ -25,6 +25,7 @@ import type { Rule } from './check.ts'
 import { leakAllowProblems } from './hooks/leak-guard.ts'
 import type { HooksConfig } from './hooks/run-hooks.ts'
 import type { ReleaseConfig } from './release/run-release.ts'
+import { PUBLISHERS } from './release/unit-gate.ts'
 import { TEST_ONLY_UNIT_KEYS, UNIT_DECL_KEYS, type UnitDecl } from './release/unit-resolve.ts'
 import { TASK_DEF_KEYS, type TaskDef } from './check.ts'
 import { testsConfigProblems, type TestsConfig } from './suite/judge-suites.ts'
@@ -41,6 +42,10 @@ export type ServeConfig = {
      *  its own port — house range 5800+, default = the hub port plus 1000
      *  (build/comfyui.md owns that surface) */
     comfyPort?: number
+    /** false hides the asset kit from the hub page (no asset rows, an empty
+     *  studio) and from `shipkit needs`, for a repo whose own tool mounts
+     *  `studioRoutes` and owns the picking. Default true */
+    assets?: boolean
     /** custom wiki-graph provider for repos with their own link semantics.
      *  Default: a generic md scan of the repo root. */
     wikiGraph?: {
@@ -320,6 +325,8 @@ export function defineRepo(c: RepoConfig): RepoConfig {
     for (const k of Object.keys(c))
         if (!KNOWN_KEYS.has(k))
             throw new Error(`defineRepo: unknown key '${k}'${k === 'checks' ? ` — checks:[] was removed; drop a <name>.check.ts file instead ('shipkit check' auto-discovers it)` : k === 'home' ? ` — home.resources was removed; declare each one in a <name>.shipkit.ts file as \`export default globalProcess({...})\`` : ''}`)
+    if (c.release?.publisher != null && !(PUBLISHERS as readonly string[]).includes(c.release.publisher))
+        throw new Error(`defineRepo: release.publisher '${String(c.release.publisher)}' is not a publisher (${PUBLISHERS.join(', ')})`)
     // a typo'd unit key would silently drop a target and release the wrong shape
     for (const u of c.units ?? []) {
         if (typeof u.dir !== 'string' || u.dir === '') throw new Error(`defineRepo: every units[] entry needs a 'dir'`)

package/src/serve/hub-runtime.ts

@@ -41,6 +41,7 @@ import { autoGatePool, takeSlot } from '../core/slots.ts'
 import { liveJobs, startJob } from '../core/jobs.ts'
 import { followJob } from '../core/job-follow.ts'
 import { RUN_JOB } from '../home/home-words.ts'
+import { RunLanes, runKey, treeStamp, writesTree } from './run-lanes.ts'
 import { OtherRepos } from './other-repos.ts'
 import { HouseRuns } from './house-runs.ts'
 import { recordStamp } from './project-gutter.ts'
@@ -157,9 +158,10 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
         graphs.push({ id: 'agent', label: 'agent/', title: `${c.name} agent/`, load: () => scanMdGraph({ root: agentRoot, index: c.serve?.agentIndex }), lint: { root: agentRoot, index: c.serve?.agentIndex } })
     // ONE page for every repo: the studio ALWAYS
     // mounts — kit-less repos get an empty media section, never a second
-    // page. A broken kit degrades to the same empty kit, loudly.
+    // page. A broken kit degrades to the same empty kit, loudly, and a repo
+    // whose own tool owns the picking turns the kit off here
     let kit: ResolvedKit | null = null
-    if (existsSync(join(root, '.shipkit/assets/kit.ts'))) {
+    if (c.serve?.assets !== false && existsSync(join(root, '.shipkit/assets/kit.ts'))) {
         try {
             kit = await loadKit(root)
         } catch (e) {
@@ -185,9 +187,11 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
     const port = o?.port ?? c.serve?.port ?? defaultHubPort(c.name)
     // every run this process has going, whoever started it
     let active = 0
-    // ONE run at a time, whoever asked: two gates over one tree would measure
-    // the same checks twice and race each other's repair pass
-    let chain: Promise<unknown> = Promise.resolve()
+    // every run, whoever asked: an identical one attaches, a repair pass goes
+    // alone, the rest overlap under the machine slot pool (run-lanes.ts)
+    const lanes = new RunLanes(() => treeStamp(root))
+    // the gate jobs this runtime started: one beside another is the lanes' call
+    const mine = new Set<string>()
     // the latest verdict of every check, printed as one problem frame after
     // each run for the vscode problems pane (problems/problem-line.ts)
     const board = new ProblemBoard()
@@ -215,13 +219,22 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
             }
         }
         // a job still running here, started before this image or by a terminal's --detach
-        while (liveJobs(root).length > 0) await Bun.sleep(jobs.pollMs ?? 250)
+        const foreign = (): boolean => liveJobs(root).some((j) => !mine.has(j.id))
+        if (foreign()) tap.line('note: a gate job this hub did not start is running here, so this one starts when it ends')
+        while (foreign()) await Bun.sleep(jobs.pollMs ?? 250)
         const j = startJob(root, { cli: jobs.cli, kind, args: [], job: { opts, oneLib: true, turn: background, ...(env == null ? {} : { env }) } })
+        mine.add(j.id)
         tap.job?.(j.id)
-        return (await followJob(root, j.id, tap, { pollMs: jobs.pollMs })) ?? 1
+        try {
+            return (await followJob(root, j.id, tap, { pollMs: jobs.pollMs })) ?? 1
+        } finally {
+            mine.delete(j.id)
+        }
     }
     const runChecks: HubDeps['runChecks'] = (tap, o) => {
-        const run = chain.then(async () => {
+        // only a whole gate the hub was asked for runs the repair pass (hubGateOpts)
+        const writes = o?.auto !== true && o?.gate === true && (o.only == null || o.only.length === 0)
+        return lanes.submit({ key: null, writes, print: tap.line }, async () => {
             active++
             // a run the hub starts on its own takes the machine's background
             // turn, once it is this hub's turn, never while it queues
@@ -243,27 +256,25 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
                 for (const l of board.frame()) io.print(l)
             }
         })
-        chain = run.catch(() => {})
-        return run
     }
     // a `shipkit ci` or `shipkit check` from a terminal, run HERE (home/via-hub.ts):
-    // in the same one-at-a-time chain as the hub's own runs, feeding the same
-    // problems frame, recorded as the cli's
+    // in the same lanes as the hub's own runs, feeding the same problems
+    // frame, recorded as the cli's
     const runCli: HubDeps['runCli'] = (kind, opts, print) => {
-        // never on a --json run: its output is the json and nothing else
-        if ((active > 0 || (jobs != null && liveJobs(root).length > 0)) && opts.json !== true) print('note: this hub has a run in flight, so this one starts when it ends')
-        const run = chain.then(async () => {
+        // a --json run prints the json and nothing else, so it never shares
+        const key = opts.json === true ? null : runKey(kind, opts)
+        // `check --fix` runs in process (home/via-hub.ts), so a check here never repairs
+        const writes = kind === 'ci' && writesTree(opts)
+        return lanes.submit({ key, writes, print, quiet: opts.json === true }, async (tee) => {
             active++
             try {
                 await refresh()
-                return await exec(kind, { ...opts, invokedBy: 'cli' }, { line: print, check: onBoard, job: (id) => print(`${RUN_JOB}${id}`) }, false)
+                return await exec(kind, { ...opts, invokedBy: 'cli' }, { line: tee, check: onBoard, job: (id) => tee(`${RUN_JOB}${id}`) }, false)
             } finally {
                 active--
                 for (const l of board.frame()) io.print(l)
             }
         })
-        chain = run.catch(() => {})
-        return run
     }
     const runIn = async (tap: CheckTap, o: Parameters<HubDeps['runChecks']>[1], background: boolean): Promise<number> => {
         const only = o?.only != null && o.only.length > 0 ? o.only : undefined
@@ -287,11 +298,11 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
         if (adopted.length > 0) {
             io.print(`ok: following ${adopted.length} gate job(s) still running: ${adopted.map((j) => j.id).join(', ')}`)
             active++
-            const run = Promise.all(adopted.map((j) => followJob(root, j.id, { line: () => {}, check: onBoard }, { pollMs: jobs.pollMs }))).finally(() => {
-                active--
-                for (const l of board.frame()) io.print(l)
-            })
-            chain = run.catch(() => {})
+            void lanes.submit({ key: null, writes: true, print: () => {} }, () =>
+                Promise.all(adopted.map((j) => followJob(root, j.id, { line: () => {}, check: onBoard }, { pollMs: jobs.pollMs }))).then(() => 0).finally(() => {
+                    active--
+                    for (const l of board.frame()) io.print(l)
+                })).catch(() => {})
         }
     }
     // resolved once: it shells out to git, and the page asks on every poll

package/src/serve/project-gutter.ts

@@ -9,7 +9,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { basename, dirname, join, resolve, sep } from 'path'
 import { fileURLToPath } from 'url'
-import { gitRoot } from '../core/git-root.ts'
+import { gitRoot, isLinkedWorktree } from '../core/git-root.ts'
 import { DB_FILE } from '../ledger/db.ts'
 import { defaultHubPort } from './hub-port.ts'
 import { LAYOUT } from '../core/layout.ts'
@@ -52,7 +52,9 @@ export const ICON_FILES = ['.shipkit/identity/icon.png', 'public/favicon.png', '
 
 export const ICON_TYPES: Record<string, string> = { png: 'image/png', svg: 'image/svg+xml', ico: 'image/x-icon' }
 
-/** every direct child of `parent` that includes `index`, sorted by name */
+/** every direct child of `parent` that includes `index`, sorted by name. A
+ *  linked worktree of one is that repo checked out again, never a repo of its
+ *  own: its processes would collide with the main checkout's ids and ports */
 export function wiredRepos(parent: string, index: string, home: string): WiredRepo[] {
     let names: string[]
     try {
@@ -65,6 +67,7 @@ export function wiredRepos(parent: string, index: string, home: string): WiredRe
         if (name.startsWith('.')) continue
         const path = join(parent, name)
         if (!includeTargets(path, home).includes(index)) continue
+        if (isLinkedWorktree(path)) continue
         out.push({ name, path, icon: ICON_FILES.find((f) => existsSync(join(path, f))) ?? null })
     }
     return out