rvlib-shipkit 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.7.0
+
+- **Cmd-F in the shipkit app shows a find bar now.** Since the app shipped, the Find menu did nothing visible: NSTextFinder never shows its bar for a web view. The app now draws its own bar on WebKit's find API. Return and cmd-G go to the next match, shift-return and shift-cmd-G to the previous one, Esc closes the bar, and it says "no match" when the page does not hold the text. Rebuilt apps pick it up at their next launch.
+
+- **A new cross-repo page, `/insights`, and its console twin `sk insights`.** It shows a grid of boxes, each with tags, and a tag row filters which boxes show. Dependency usage lists every package by how many repos use it. Click a row to list each repo and the range it asks. Version drift lists the packages asked at more than one range. Script names lists every package.json script with its commands. The scope is the house repos or every folder of `~/dev`, and one filter searches every box.
+
+- **Every widget card has a refresh button.** It renders the widget now, off its clock, and passes `render({ force: true })`, so a widget that samples another machine can skip its cache or backoff. A widget that ignores the argument simply renders again.
+
+- **The traced audit groups files under a dir the task listed.** A build that lists an asset folder and stats each image in it proposed one `ignoredInputs` line per image. The files now group under the outermost dir the task also listed, keyed by content once more than three fall under it.
+
 ## 1.6.0
 
 - **lint, typecheck, test and every task that declares nothing are cached now.** Such a task is keyed on the whole work tree, plus the gitignored paths the new `ignoredInputs` lists for it (`{ test: ['dist/**'] }`, `'*'` for every task; a path by content, `dir/**` by the names under it), and the lockfile, the installed packages, the bun and node versions and the toolkit code behind it. `sk trace-audit` runs each gate task once under a file tracer and names the gitignored paths it reads that its key misses. Tracing is on wherever it can run (Apple silicon macOS): SK031 audits about daily, `sk trace-audit --disable` opts a machine out and `SHIPKIT_TRACE=0` one run, and each finding joins the key of the task that read it at once, in every worktree of the repo. SK032 and the fix pass of `sk ci` then write the findings into their own block of `repo.config.ts`, once the repo pins 1.6.0 or later. The tracer never decides a verdict. It needs Apple silicon macOS: on Linux and in CI nothing audits, and SK030's daily sample is the only net there.
@@ -10,8 +20,6 @@
 
 - **SK030 audits the cache.** About once a day, while somebody works in the repo, it re-runs a sample of the checks the cache would answer right now, fresh, and compares. A cached green that a fresh run disagrees with fails, naming the check whose key misses a path its body reads, and the stale answer is dropped so it is never served again. `sk cache-audit` is the same audit on demand (`--sample <n>`, `--only <id>`, `--json`).
 
-## Unreleased (patch)
-
 - **The hub tree groups assets by kit category.** Under media, each category is a row that folds, and its label opens the category page. An asset row reads by its kit label (`mon/brindon/front`), never its file id.
 
 - **SK001 no longer asks a comfy repo for a `comfy:up` script.** The box is a global process that `sk gp start comfyui` starts from any repo, so a per-repo script only copied that command. A `.shipkit/comfy/` folder now asks for nothing, and SK001 no longer probes it.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "1.6.0",
+    "version": "1.7.0",
     "funding": "https://github.com/sponsors/rvion",
     "description": "All-in-one repo companion: ci gate (task DAG), auto-discovered health checks, release-contract fulfillness, asks queue, md-wiki tools, asset atelier, live tui",
     "license": "MIT",

package/src/cli/cmd_Insights.ts

@@ -0,0 +1,78 @@
+// shipkit insights: the insights page in the console. The boxes come from
+// insightsOf, the one computation the daemon's route serves the page; this
+// file only renders them as text. It reads the manifests directly and needs no
+// daemon.
+import { homedir } from 'os'
+import { Command, Option } from 'clipanion'
+import { devRepos, insightsOf, placeWords, rowMatches, SCOPES, tagsOf, type InsightsAnswer, type Scope } from '../home/insights.ts'
+
+/** the boxes as text: a heading per box, then its rows, top `top` of each */
+export function renderInsights(a: InsightsAnswer, o: { tag?: string | null; query?: string; top: number; uses: boolean }): string[] {
+    const out: string[] = []
+    for (const b of a.boxes) {
+        if (o.tag != null && !b.tags.includes(o.tag)) continue
+        const rows = b.rows.filter((r) => rowMatches(b, r, o.query ?? ''))
+        out.push(`${b.title}  [${b.tags.join(', ')}]  ${rows.length} ${b.noun}${rows.length === 1 ? '' : 's'}`)
+        const width = Math.max(0, ...rows.slice(0, o.top).map((r) => r.key.length))
+        for (const r of rows.slice(0, o.top)) {
+            out.push(`  ${r.key.padEnd(width)}  ${String(r.repos).padStart(3)} repos  ${r.values.slice(0, 3).join('  ')}${r.values.length > 3 ? `  +${r.values.length - 3}` : ''}`)
+            if (o.uses) for (const u of r.uses) out.push(`      ${placeWords(u)}  ${u.value}${u.dev ? '  (dev)' : ''}`)
+        }
+        if (rows.length > o.top) out.push(`  … ${rows.length - o.top} more`)
+        out.push('')
+    }
+    out.push(`${a.repos} repos, ${a.files} package.json, read in ${a.ms}ms`)
+    for (const e of a.errors) out.push(`WARN ${e}`)
+    return out
+}
+
+export class InsightsCommand extends Command {
+    static override paths = [['insights']]
+
+    static override usage = Command.Usage({
+        category: 'Home',
+        description: 'the insights page as text: boxes about every repo, like which packages they use and by how many',
+        details: 'every package.json the house repos track (or every folder of ~/dev with --scope dev), turned into boxes: dependency usage sorted by how many repos use each package, version drift, script names. The same computation the page reads, no daemon needed',
+        examples: [
+            ['every box, the house repos', 'sk insights'],
+            ['every repo of ~/dev', 'sk insights --scope dev'],
+            ['where a package is used, and at which range', 'sk insights --scope dev --tag deps --query zod --uses'],
+            ['the whole list of one tag', 'sk insights --tag deps --top 1000'],
+            ['the route\'s exact payload', 'sk insights --json'],
+        ],
+    })
+
+    scope = Option.String('--scope', 'house', { description: 'house (the project list) or dev (every folder of ~/dev)' })
+    tag = Option.String('--tag', { required: false, description: 'only the boxes carrying this tag' })
+    query = Option.String('--query', { required: false, description: 'only the rows whose key or a value holds this text' })
+    top = Option.String('--top', '20', { description: 'rows shown per box' })
+    uses = Option.Boolean('--uses', false, { description: 'list every use under each row' })
+    json = Option.Boolean('--json', false, { description: 'the daemon route\'s exact payload: { now, scope, repos, files, boxes, errors, ms }' })
+
+    async execute(): Promise<number> {
+        if (!(SCOPES as readonly string[]).includes(this.scope)) {
+            this.context.stderr.write(`--scope must be one of ${SCOPES.join(', ')}, got ${JSON.stringify(this.scope)}\n`)
+            return 2
+        }
+        const scope = this.scope as Scope
+        const top = Number(this.top)
+        if (!(top >= 1)) {
+            this.context.stderr.write(`--top must be a number from 1, got ${JSON.stringify(this.top)}\n`)
+            return 2
+        }
+        const home = process.env.HOME || homedir()
+        // the hub route module draws app icons, so it loads only when this runs
+        const repos = scope === 'dev' ? devRepos(home) : (await import('../serve/project-gutter-route.ts')).railRepos(process.cwd(), home)
+        const a = await insightsOf(repos, scope)
+        if (this.json) {
+            this.context.stdout.write(`${JSON.stringify(a, null, 2)}\n`)
+            return 0
+        }
+        if (this.tag != null && !tagsOf(a.boxes).includes(this.tag)) {
+            this.context.stderr.write(`--tag must be one of ${tagsOf(a.boxes).join(', ')}, got ${JSON.stringify(this.tag)}\n`)
+            return 2
+        }
+        for (const l of renderInsights(a, { tag: this.tag ?? null, query: this.query, top, uses: this.uses })) this.context.stdout.write(`${l}\n`)
+        return 0
+    }
+}

package/src/cli.ts

@@ -13,6 +13,7 @@ import { aliasArgs, CrossRepoActivityCommand } from './cli/cmd_CrossRepoActivity
 import { ConfigKeysCommand } from './cli/cmd_ConfigKeys.ts'
 import { GlobalProcessesCommand, GlobalProcessRestartCommand, GlobalProcessStartCommand, GlobalProcessStopCommand } from './cli/cmd_GlobalProcesses.ts'
 import { PlannedCommand } from './cli/cmd_Planned.ts'
+import { InsightsCommand } from './cli/cmd_Insights.ts'
 import { OverviewCommand } from './cli/cmd_Overview.ts'
 import { CiCommand } from './cli/cmd_Ci.ts'
 import { ContractsCommand } from './cli/cmd_Contracts.ts'
@@ -99,6 +100,7 @@ export function buildCli(): Cli {
     cli.register(GlobalProcessRestartCommand)
     cli.register(CrossRepoActivityCommand)
     cli.register(PlannedCommand)
+    cli.register(InsightsCommand)
     cli.register(OverviewCommand)
     cli.register(ChecksCommand)
     cli.register(WhenCommand)

package/src/core/trace-audit.ts

@@ -47,18 +47,27 @@ function covered(p: string, listing: boolean, extras: string[]): boolean {
     return extras.some((e) => (isNamesInput(e) ? listing && under(p, e.slice(0, -3)) : under(p, e)))
 }
 
-/** the fewest entries that cover what was read: each file by itself, or its
- *  dir once more than three files there were read; each listed dir as
- *  `dir/**`, the outermost one only */
+/** the fewest entries that cover what was read: each file by itself, or a
+ *  dir by content once more than three files under it were read (its own
+ *  dir, or the outermost dir the task also listed); each listed dir as
+ *  `dir/**`, the outermost one only, unless a content entry covers it */
 export function proposeInputs(content: string[], listed: string[]): string[] {
-    const byDir = new Map<string, string[]>()
-    for (const f of content) byDir.set(posix.dirname(f), [...(byDir.get(posix.dirname(f)) ?? []), f])
-    const bytes = [...byDir].flatMap(([dir, files]) => (files.length > 3 && dir !== '.' ? [dir] : files))
     const minimal = (xs: string[]): string[] => {
         const sorted = [...new Set(xs)].sort()
         return sorted.filter((x) => !sorted.some((y) => y !== x && under(x, y)))
     }
-    return [...minimal(bytes), ...minimal(listed).map((d) => `${d}/**`)].sort()
+    const tops = minimal(listed)
+    const byDir = new Map<string, string[]>()
+    for (const f of content) {
+        const d = tops.find((t) => under(f, t)) ?? posix.dirname(f)
+        byDir.set(d, [...(byDir.get(d) ?? []), f])
+    }
+    // a listed dir holding three or fewer: each file under its own dir
+    const regroup = [...byDir].flatMap(([dir, files]) => (tops.includes(dir) && files.length <= 3 ? files.map((f) => [posix.dirname(f), f] as const) : files.map((f) => [dir, f] as const)))
+    const again = new Map<string, string[]>()
+    for (const [d, f] of regroup) again.set(d, [...(again.get(d) ?? []), f])
+    const bytes = minimal([...again].flatMap(([dir, files]) => (files.length > 3 && dir !== '.' ? [dir] : files)))
+    return [...bytes, ...tops.filter((d) => !bytes.some((b) => under(d, b))).map((d) => `${d}/**`)].sort()
 }
 
 /** trace every gate task of the repo once and report what its key misses */

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

@@ -17,55 +17,110 @@ func stays(_ url: URL) -> Bool {
     url.host == "127.0.0.1" || url.host == "localhost" || url.host == startURL.host
 }
 
-/** a window's content: the web view, and the find bar above it when shown.
- *  WKWebView is an NSTextFinderClient, so the platform find bar searches the
- *  page; this view is the bar's container */
-final class Pane: NSView, NSTextFinderBarContainer {
+/** a window's content: the find bar above the web view when shown. WebKit's
+ *  public find api searches the page: NSTextFinder never shows its bar for a
+ *  WKWebView, which is no NSTextFinderClient at runtime */
+final class Pane: NSView, NSSearchFieldDelegate {
     let web: WKWebView
-    let finder = NSTextFinder()
+    let bar = NSStackView()
+    let field = NSSearchField()
+    let status = NSTextField(labelWithString: "")
+    static let barHeight: CGFloat = 34
 
     init(web: WKWebView) {
         self.web = web
         super.init(frame: .zero)
         addSubview(web)
-        finder.client = web
-        finder.findBarContainer = self
-        finder.isIncrementalSearchingEnabled = true
-        finder.incrementalSearchingShouldDimContentView = false
+        field.placeholderString = "find in page"
+        field.delegate = self
+        field.sendsSearchStringImmediately = true
+        status.textColor = .secondaryLabelColor
+        let prev = NSButton(title: "‹", target: self, action: #selector(findPrevious))
+        let next = NSButton(title: "›", target: self, action: #selector(findNext))
+        let done = NSButton(title: "Done", target: self, action: #selector(hideFind))
+        prev.toolTip = "previous match (⇧⌘G, ⇧↩)"
+        next.toolTip = "next match (⌘G, ↩)"
+        for b in [prev, next, done] { b.bezelStyle = .rounded; b.controlSize = .small }
+        field.controlSize = .small
+        field.widthAnchor.constraint(greaterThanOrEqualToConstant: 220).isActive = true
+        bar.orientation = .horizontal
+        bar.spacing = 6
+        bar.edgeInsets = NSEdgeInsets(top: 4, left: 8, bottom: 4, right: 8)
+        for v in [field, status, prev, next, done] as [NSView] { bar.addArrangedSubview(v) }
+        bar.setHuggingPriority(.defaultLow, for: .horizontal)
+        bar.isHidden = true
+        addSubview(bar)
     }
 
     required init?(coder: NSCoder) { fatalError("not from a nib") }
 
     override var isFlipped: Bool { true }
 
-    var findBarView: NSView? {
+    var isFindBarVisible = false {
         didSet {
-            oldValue?.removeFromSuperview()
-            if let bar = findBarView { addSubview(bar) }
+            bar.isHidden = !isFindBarVisible
             needsLayout = true
         }
     }
 
-    var isFindBarVisible = false {
-        didSet {
-            findBarView?.isHidden = !isFindBarVisible
-            needsLayout = true
+    override func layout() {
+        super.layout()
+        let top = isFindBarVisible ? Pane.barHeight : 0
+        bar.frame = NSRect(x: 0, y: 0, width: bounds.width, height: Pane.barHeight)
+        web.frame = NSRect(x: 0, y: top, width: bounds.width, height: max(0, bounds.height - top))
+    }
+
+    @objc func showFind() {
+        isFindBarVisible = true
+        window?.makeFirstResponder(field)
+        field.currentEditor()?.selectAll(nil)
+    }
+
+    @objc func hideFind() {
+        isFindBarVisible = false
+        window?.makeFirstResponder(web)
+    }
+
+    @objc func findNext() { search(backwards: false) }
+    @objc func findPrevious() { search(backwards: true) }
+
+    /** the next match of the field's text from the page's selection, wrapping;
+     *  `done` hears whether one was found */
+    func search(backwards: Bool, done: ((Bool) -> Void)? = nil) {
+        let q = field.stringValue
+        if q.isEmpty {
+            status.stringValue = ""
+            done?(false)
+            return
+        }
+        let c = WKFindConfiguration()
+        c.backwards = backwards
+        c.wraps = true
+        c.caseSensitive = false
+        web.find(q, configuration: c) { r in
+            self.status.stringValue = r.matchFound ? "" : "no match"
+            done?(r.matchFound)
         }
     }
 
-    func findBarViewDidChangeHeight() { needsLayout = true }
+    /** typing searches again from the top of the page */
+    func fromTop(done: ((Bool) -> Void)? = nil) {
+        web.evaluateJavaScript("getSelection().removeAllRanges()") { _, _ in self.search(backwards: false, done: done) }
+    }
 
-    func contentView() -> NSView? { web }
+    func controlTextDidChange(_ note: Notification) { fromTop() }
 
-    override func layout() {
-        super.layout()
-        var top: CGFloat = 0
-        if let bar = findBarView, isFindBarVisible {
-            let h = bar.frame.height
-            bar.frame = NSRect(x: 0, y: 0, width: bounds.width, height: h)
-            top = h
+    // in the field: return is the next match, shift return the previous, esc closes
+    func control(_ control: NSControl, textView: NSTextView, doCommandBy sel: Selector) -> Bool {
+        if sel == #selector(NSResponder.insertNewline(_:)) {
+            search(backwards: NSApp.currentEvent?.modifierFlags.contains(.shift) == true)
+            return true
         }
-        web.frame = NSRect(x: 0, y: top, width: bounds.width, height: max(0, bounds.height - top))
+        if sel == #selector(NSResponder.cancelOperation(_:)) {
+            hideFind()
+            return true
+        }
+        return false
     }
 }
 
@@ -74,12 +129,12 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     var opened = false
 
     func applicationDidFinishLaunching(_ note: Notification) {
+        if CommandLine.arguments.contains("--self-test-find") { return selfTestFind() }
         buildMenu()
         // esc closes the find bar of the key window, and reaches the page otherwise
         NSEvent.addLocalMonitorForEvents(matching: .keyDown) { e in
             if e.keyCode == 53, let pane = self.keyPane(), pane.isFindBarVisible {
-                pane.finder.performAction(.hideFindInterface)
-                pane.window?.makeFirstResponder(pane.web)
+                pane.hideFind()
                 return nil
             }
             return e
@@ -128,11 +183,10 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     @objc func zoomOut(_ sender: Any?) { zoom = zoom / 1.1 }
     @objc func zoomReset(_ sender: Any?) { zoom = 1 }
 
-    // the menu item's tag is the NSTextFinder.Action it performs
-    @objc func findAction(_ sender: NSMenuItem) {
-        guard let pane = keyPane(), let action = NSTextFinder.Action(rawValue: sender.tag) else { return }
-        pane.finder.performAction(action)
-    }
+    @objc func showFind(_ sender: Any?) { keyPane()?.showFind() }
+    @objc func hideFind(_ sender: Any?) { keyPane()?.hideFind() }
+    @objc func findNext(_ sender: Any?) { keyPane()?.findNext() }
+    @objc func findPrevious(_ sender: Any?) { keyPane()?.findPrevious() }
 
     // no public api opens the inspector: `_inspector` then `show` is the
     // WebKit call the context menu's Inspect Element makes. Where it is gone,
@@ -151,10 +205,9 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     }
 
     func validateMenuItem(_ item: NSMenuItem) -> Bool {
-        if item.action == #selector(findAction(_:)) {
-            guard let pane = keyPane(), let action = NSTextFinder.Action(rawValue: item.tag) else { return false }
-            return pane.finder.validateAction(action)
-        }
+        if item.action == #selector(hideFind(_:)) { return keyPane()?.isFindBarVisible == true }
+        if item.action == #selector(findNext(_:)) || item.action == #selector(findPrevious(_:)) { return keyPane()?.field.stringValue.isEmpty == false }
+        if item.action == #selector(showFind(_:)) { return keyPane() != nil }
         if item.action == #selector(devTools(_:)) || item.action == #selector(reload(_:)) { return keyPane() != nil }
         return true
     }
@@ -184,12 +237,43 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         NSApp.activate(ignoringOtherApps: true)
     }
 
+    var onLoad: ((WKWebView) -> Void)?
+
+    // `--self-test-find`: an offscreen window on a page holding a word twice,
+    // the find bar opened, a word on the page searched, then one that is not;
+    // what happened printed, exit 0 only when the bar shows and finds
+    func selfTestFind() {
+        let web = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        web.navigationDelegate = self
+        let pane = Pane(web: web)
+        let win = NSWindow(contentRect: NSRect(x: -4000, y: -4000, width: 600, height: 400), styleMask: [.titled], backing: .buffered, defer: false)
+        win.contentView = pane
+        win.orderFrontRegardless()
+        windows.append(win)
+        onLoad = { _ in
+            pane.showFind()
+            pane.field.stringValue = "needle"
+            pane.fromTop { found in
+                pane.field.stringValue = "haystack"
+                pane.fromTop { absent in
+                    print("find-bar-visible=\(pane.isFindBarVisible)")
+                    print("found=\(found)")
+                    print("absent-found=\(absent)")
+                    print("status=\(pane.status.stringValue)")
+                    exit(pane.isFindBarVisible && found && !absent ? 0 : 1)
+                }
+            }
+        }
+        web.loadHTMLString("<p>one needle, two needle</p>", baseURL: nil)
+    }
+
     func windowWillClose(_ note: Notification) {
         windows.removeAll { $0 === note.object as? NSWindow }
     }
 
     // the page title names the window, so cmd-tab and the window menu tell pages apart
     func webView(_ web: WKWebView, didFinish nav: WKNavigation!) {
+        onLoad?(web)
         web.window?.title = (web.title?.isEmpty == false) ? web.title! : appName
     }
 
@@ -242,10 +326,10 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         edit.addItem(.separator())
         let findItem = edit.addItem(withTitle: "Find", action: nil, keyEquivalent: "")
         let find = NSMenu(title: "Find")
-        item(find, "Find…", #selector(findAction(_:)), "f", tag: NSTextFinder.Action.showFindInterface.rawValue)
-        item(find, "Find Next", #selector(findAction(_:)), "g", tag: NSTextFinder.Action.nextMatch.rawValue)
-        item(find, "Find Previous", #selector(findAction(_:)), "g", [.command, .shift], tag: NSTextFinder.Action.previousMatch.rawValue)
-        item(find, "Hide Find Bar", #selector(findAction(_:)), "", [], tag: NSTextFinder.Action.hideFindInterface.rawValue)
+        item(find, "Find…", #selector(showFind(_:)), "f")
+        item(find, "Find Next", #selector(findNext(_:)), "g")
+        item(find, "Find Previous", #selector(findPrevious(_:)), "g", [.command, .shift])
+        item(find, "Hide Find Bar", #selector(hideFind(_:)), "", [])
         edit.setSubmenu(find, for: findItem)
         editItem.submenu = edit
         let viewItem = NSMenuItem()

package/src/home/home-routes.ts

@@ -17,6 +17,7 @@ import { Hubs, type WorkerView } from './hubs.ts'
 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 { HouseRuns } from '../serve/house-runs.ts'
 
 /** how far back a repo's git page lists its commits */
@@ -111,6 +112,8 @@ export function homeRoutes(d: HomeDeps) {
     const modernizing = new Map<string, ModernizeView & { log: string }>()
     // read only while the activity page asks, never on the tick
     const activity = new ActivityCache({ declared: (name) => d.plan?.declared(name) ?? null, titles: (name) => d.plan?.titles(name) ?? null })
+    // read only while the insights page asks, one answer per scope
+    const insights = new InsightsCache()
     const modernizeLog = (repo: string): string => join(d.dir, 'modernize', `${repo}.log`)
     // the dock: every loaded repo's recent runs, read only while a page asks
     const house = new HouseRuns(() => repos)
@@ -176,6 +179,12 @@ export function homeRoutes(d: HomeDeps) {
             const q = new URL(req.url).searchParams
             return Response.json(await activity.get(repos, windowMinutes(q.get('m')), { fresh: q.get('fresh') === '1' }))
         }
+        if (path === '/api/home/insights.json') {
+            if (repos.length === 0) await refresh()
+            const q = new URL(req.url).searchParams
+            const scope: Scope = q.get('scope') === 'dev' ? 'dev' : 'house'
+            return Response.json(await insights.get(scope, () => (scope === 'dev' ? devRepos() : repos), { fresh: q.get('fresh') === '1' }))
+        }
         // one repo's git for its git page: a week of commits, and HEAD's last
         // one past that, whatever window the activity page shows
         if (path === '/api/home/git.json') {
@@ -209,6 +218,12 @@ export function homeRoutes(d: HomeDeps) {
             if (b.act === 'restart') return Response.json(await d.hubs.restart(r))
             return new Response(`act must be ensure, stop or restart`, { status: 400 })
         }
+        if (path === '/api/home/widgets/refresh') {
+            const b = await body(req)
+            const v = await d.widgets?.refresh(String(b.repo), String(b.id))
+            if (v == null) return new Response(`no widget ${String(b.id)} in ${String(b.repo)}`, { status: 404 })
+            return Response.json(v)
+        }
         if (path === '/api/home/planned/run') {
             const b = await body(req)
             if (d.plan == null || !d.plan.ask(String(b.repo), String(b.check))) return new Response(`no planned check ${String(b.check)} in ${String(b.repo)}`, { status: 404 })

package/src/home/insights-shape.ts

@@ -0,0 +1,124 @@
+// the insights page's boxes, computed from every package.json a scope of repos
+// tracks. Pure: no disk, so the page, `sk insights` and the tests share it.
+// Every box has one shape (a row per key, the repos using it, one value per
+// use), so a new box is one function in BOXES and the page draws it unchanged.
+
+/** one package.json, read: its repo, its dir inside the repo ('' at the root) */
+export type Manifest = {
+    repo: string
+    where: string
+    json: { dependencies?: Record<string, string>; devDependencies?: Record<string, string>; peerDependencies?: Record<string, string>; scripts?: Record<string, string> }
+}
+
+/** one package.json using the row's key, and what it says for it */
+export type InsightUse = { repo: string; where: string; value: string; dev?: boolean }
+
+export type InsightRow = {
+    key: string
+    /** distinct repos using it: the sort */
+    repos: number
+    /** its distinct values, most used first (the version ranges of a package) */
+    values: string[]
+    uses: InsightUse[]
+}
+
+export type InsightBox = {
+    id: string
+    title: string
+    tags: string[]
+    /** one line on what it lists and how it sorts */
+    hint: string
+    /** what a row's key is, for the filter's placeholder */
+    noun: string
+    /** the filter reads the values too (a script's command), not only the key */
+    searchValues?: boolean
+    rows: InsightRow[]
+}
+
+export const SCOPES = ['house', 'dev'] as const
+export type Scope = (typeof SCOPES)[number]
+
+export type InsightsAnswer = {
+    now: number
+    scope: Scope
+    /** repos read, and package.json files found in them */
+    repos: number
+    files: number
+    boxes: InsightBox[]
+    /** a manifest that would not parse, as `repo/where: why` */
+    errors: string[]
+    ms: number
+}
+
+const byCount = <T>(xs: T[]): T[] => {
+    const n = new Map<T, number>()
+    for (const x of xs) n.set(x, (n.get(x) ?? 0) + 1)
+    return [...n.keys()].sort((a, b) => n.get(b)! - n.get(a)!)
+}
+
+/** one row per key, the uses gathered, sorted by distinct repos then key */
+function rowsOf(uses: [string, InsightUse][]): InsightRow[] {
+    const by = new Map<string, InsightUse[]>()
+    for (const [k, u] of uses) {
+        if (!by.has(k)) by.set(k, [])
+        by.get(k)!.push(u)
+    }
+    return [...by]
+        .map(([key, us]) => ({ key, repos: new Set(us.map((u) => u.repo)).size, values: byCount(us.map((u) => u.value)), uses: us.sort((a, b) => a.repo.localeCompare(b.repo) || a.where.localeCompare(b.where)) }))
+        .sort((a, b) => b.repos - a.repos || a.key.localeCompare(b.key))
+}
+
+/** a range that names no published version: a workspace or local link */
+export const localRange = (v: string): boolean => /^(workspace:|file:|link:|portal:)/.test(v)
+
+function depUses(ms: Manifest[]): [string, InsightUse][] {
+    return ms.flatMap((m) => [
+        ...Object.entries(m.json.dependencies ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v }]),
+        ...Object.entries(m.json.devDependencies ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v, dev: true }]),
+    ])
+}
+
+export const BOXES: ((ms: Manifest[]) => InsightBox)[] = [
+    (ms) => ({
+        id: 'deps',
+        title: 'dependency usage',
+        tags: ['deps'],
+        hint: 'every package in a dependencies or devDependencies, by how many repos use it',
+        noun: 'package',
+        rows: rowsOf(depUses(ms)),
+    }),
+    (ms) => ({
+        id: 'drift',
+        title: 'version drift',
+        tags: ['deps', 'health'],
+        hint: 'packages asked at more than one version range across repos, by how many ranges',
+        noun: 'package',
+        rows: rowsOf(depUses(ms).filter(([, u]) => !localRange(u.value)))
+            .filter((r) => r.values.length > 1)
+            .sort((a, b) => b.values.length - a.values.length || b.repos - a.repos || a.key.localeCompare(b.key)),
+    }),
+    (ms) => ({
+        id: 'scripts',
+        title: 'script names',
+        tags: ['scripts'],
+        hint: 'every package.json script name, by how many repos declare it, each with its command',
+        noun: 'script',
+        searchValues: true,
+        rows: rowsOf(ms.flatMap((m) => Object.entries(m.json.scripts ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v }]))),
+    }),
+]
+
+/** a row matches a query on its key, or on a value when its box searches them */
+export const rowMatches = (b: InsightBox, r: InsightRow, q: string): boolean => {
+    const s = q.trim().toLowerCase()
+    return s === '' || r.key.toLowerCase().includes(s) || (b.searchValues === true && r.values.some((v) => v.toLowerCase().includes(s)))
+}
+
+/** every box over these manifests */
+export const boxesOf = (ms: Manifest[]): InsightBox[] => BOXES.map((b) => b(ms))
+
+/** every tag the boxes carry, in first seen order */
+export const tagsOf = (boxes: InsightBox[]): string[] => [...new Set(boxes.flatMap((b) => b.tags))]
+
+/** a use's place, as the page and the cli print it */
+export const placeWords = (u: InsightUse): string => (u.where === '' ? u.repo : `${u.repo}/${u.where}`)

package/src/home/insights.ts

@@ -0,0 +1,90 @@
+// the insights page's data: every package.json a scope of repos tracks, read
+// and turned into boxes (insights-shape.ts). Two scopes: the house repos, or
+// every folder of ~/dev with a package.json or a .git, so a package used in an
+// unwired repo can still be found and reused.
+//
+// the one constraint a reader breaks first: this runs only when the page or
+// `sk insights` asks (no tick), and an answer is kept per scope for
+// INSIGHTS_TTL_MS, so a page left open never walks ~/dev twice a minute.
+import { existsSync, readdirSync, readFileSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { gitBin } from '../core/git-bin.ts'
+import { boxesOf, type InsightsAnswer, type Manifest, type Scope } from './insights-shape.ts'
+
+export * from './insights-shape.ts'
+
+export const INSIGHTS_TTL_MS = 5 * 60_000
+export const INSIGHTS_CONCURRENCY = 12
+
+export type InsightRepo = { name: string; path: string }
+
+/** every folder of ~/dev that holds a package.json or a .git, by name */
+export function devRepos(userHome: string = homedir()): InsightRepo[] {
+    const root = join(userHome, 'dev')
+    let names: string[] = []
+    try {
+        names = readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith('.')).map((e) => e.name)
+    } catch {
+        return []
+    }
+    return names
+        .map((name) => ({ name, path: join(root, name) }))
+        .filter((r) => existsSync(join(r.path, 'package.json')) || existsSync(join(r.path, '.git')))
+        .sort((a, b) => a.name.localeCompare(b.name))
+}
+
+/** the package.json paths a repo tracks; the root one alone outside git */
+async function manifestPaths(dir: string): Promise<string[]> {
+    if (!existsSync(join(dir, '.git'))) return existsSync(join(dir, 'package.json')) ? ['package.json'] : []
+    const p = Bun.spawn([gitBin(), 'ls-files', '-z', '--', 'package.json', '**/package.json'], { cwd: dir, stdout: 'pipe', stderr: 'ignore', env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } })
+    const [out, code] = await Promise.all([new Response(p.stdout).text(), p.exited])
+    if (code !== 0) return existsSync(join(dir, 'package.json')) ? ['package.json'] : []
+    return out.split('\0').filter(Boolean)
+}
+
+/** one repo's manifests, read; a file that does not parse is an error line */
+export async function repoManifests(r: InsightRepo): Promise<{ manifests: Manifest[]; errors: string[] }> {
+    const manifests: Manifest[] = []
+    const errors: string[] = []
+    for (const rel of await manifestPaths(r.path)) {
+        const where = rel === 'package.json' ? '' : rel.slice(0, -'/package.json'.length)
+        try {
+            manifests.push({ repo: r.name, where, json: JSON.parse(readFileSync(join(r.path, rel), 'utf8')) })
+        } catch (e) {
+            // a deleted but still tracked file is no error, only nothing to read
+            if ((e as NodeJS.ErrnoException).code !== 'ENOENT') errors.push(`${r.name}/${rel}: ${(e as Error).message}`)
+        }
+    }
+    return { manifests, errors }
+}
+
+/** THE computation: the daemon's route and `sk insights` both call it */
+export async function insightsOf(repos: InsightRepo[], scope: Scope, now = Date.now()): Promise<InsightsAnswer> {
+    const t0 = performance.now()
+    const all: { manifests: Manifest[]; errors: string[] }[] = []
+    for (let i = 0; i < repos.length; i += INSIGHTS_CONCURRENCY) all.push(...(await Promise.all(repos.slice(i, i + INSIGHTS_CONCURRENCY).map(repoManifests))))
+    const manifests = all.flatMap((a) => a.manifests)
+    return { now, scope, repos: repos.length, files: manifests.length, boxes: boxesOf(manifests), errors: all.flatMap((a) => a.errors), ms: Math.round(performance.now() - t0) }
+}
+
+/** one answer per scope, shared for INSIGHTS_TTL_MS; `fresh` always reads */
+export class InsightsCache {
+    private kept = new Map<Scope, InsightsAnswer>()
+    private running = new Map<Scope, Promise<InsightsAnswer>>()
+
+    constructor(private o: { ttlMs?: number; now?: () => number } = {}) {}
+
+    get(scope: Scope, repos: () => InsightRepo[], o: { fresh?: boolean } = {}): Promise<InsightsAnswer> {
+        const now = (this.o.now ?? Date.now)()
+        const k = this.kept.get(scope)
+        if (k != null && o.fresh !== true && now - k.now < (this.o.ttlMs ?? INSIGHTS_TTL_MS)) return Promise.resolve(k)
+        const going = this.running.get(scope)
+        if (going != null) return going
+        const p = insightsOf(repos(), scope, now)
+            .then((a) => { this.kept.set(scope, a); return a })
+            .finally(() => this.running.delete(scope))
+        this.running.set(scope, p)
+        return p
+    }
+}

package/src/home/serve-web.ts

@@ -14,7 +14,7 @@ import { hubBase } from './home-paths.ts'
 /** the page routes: ONE app for the overview, the plan, and the hub page of
  *  each known repo, which moves between them in place (home-st.ts) */
 export function pageRoutes<T>(names: string[], page: T): Record<string, T> {
-    const out: Record<string, T> = { '/': page, '/planned': page, '/activity': page, '/archived': page }
+    const out: Record<string, T> = { '/': page, '/planned': page, '/activity': page, '/archived': page, '/insights': page }
     for (const n of names) out[`${hubBase(n)}/`] = page
     return out
 }
@@ -51,8 +51,8 @@ export const REPO_ANSWER_MS = 30_000
 export const LIST_EVERY_MS = 30_000
 export const LIST_RETRY_MS = 1_000
 
-/** the home answers that can wait on git: the activity page's first read of a window, and a repo's git page */
-export const readsGit = (path: string): boolean => path === '/api/home/activity.json' || path === '/api/home/git.json'
+/** the home answers that can wait on git: the activity page's first read of a window, a repo's git page, and the insights page's read of every manifest */
+export const readsGit = (path: string): boolean => path === '/api/home/activity.json' || path === '/api/home/git.json' || path === '/api/home/insights.json'
 
 /** a run or a check run streams for minutes, and a silent one is never cut */
 export const streams = (path: string): boolean => /\/api\/(run|check\/run)$/.test(path)

package/src/home/widgets.ts

@@ -104,12 +104,12 @@ export class Widgets {
     }
 
     /** one render, bounded, its result or its error kept */
-    async render(s: Slot): Promise<void> {
+    async render(s: Slot, force = false): Promise<void> {
         s.busy = true
         let timer: ReturnType<typeof setTimeout> | undefined
         try {
             const html = await Promise.race([
-                Promise.resolve().then(() => s.w.def.render()),
+                Promise.resolve().then(() => s.w.def.render({ force })),
                 new Promise<never>((_, no) => { timer = setTimeout(() => no(new Error(`render took more than ${WIDGET_RENDER_MS / 1000}s`)), WIDGET_RENDER_MS) }),
             ])
             if (typeof html !== 'string') throw new Error(`render returned ${typeof html}, not an html string`)
@@ -123,6 +123,16 @@ export class Widgets {
         }
     }
 
+    /** a reader's refresh: one widget rendered now with force, its view after
+     *  it; null when no widget has that repo and id */
+    async refresh(repo: string, id: string): Promise<WidgetView | null> {
+        const s = this.slots.get(`${repo}/${id}`)
+        if (s == null) return null
+        this.readAt = this.now()
+        await this.render(s, true)
+        return s.view
+    }
+
     /** the last html of each; a read that keeps the clocks running */
     views(): WidgetView[] {
         this.readAt = this.now()

package/src/serve/hub-app/home-st.ts

@@ -18,6 +18,7 @@ import { DockSt } from './dock-st.ts'
 import { PaletteSt } from './palette-st.ts'
 import { PlannedSt } from './planned-st.ts'
 import { ActivitySt } from './activity-st.ts'
+import { InsightsSt } from './insights-st.ts'
 import { ProjectsSvc } from './projects-svc.ts'
 import { parseFilter, RepoSt } from './repo-st.ts'
 import { openSection, repoSections, sectionOfRepo } from './repo-sections.ts'
@@ -25,11 +26,11 @@ import { openSection, repoSections, sectionOfRepo } from './repo-sections.ts'
 /** the longest one repo's read ahead holds the next one back */
 export const PREFETCH_WAIT_MS = 10_000
 
-/** what the page shows: the machine overview, the plan, the activity, or one repo */
-export type Page = 'overview' | 'planned' | 'activity' | 'archived' | 'repo'
+/** what the page shows: the machine overview, the plan, the activity, the insights, the archived repos, or one repo */
+export type Page = 'overview' | 'planned' | 'activity' | 'insights' | 'archived' | 'repo'
 
 /** the address of each page of the home that is no repo's */
-export const PLACE_PATH = { overview: '/', planned: '/planned', activity: '/activity', archived: '/archived' } as const
+export const PLACE_PATH = { overview: '/', planned: '/planned', activity: '/activity', insights: '/insights', archived: '/archived' } as const
 
 /** where a repo's hub answers on the home */
 export const repoBase = (name: string): string => `/r/${encodeURIComponent(name)}`
@@ -46,6 +47,7 @@ export function routeOf(pathname: string): { page: Page; repo: string | null } {
     if (m != null) return { page: 'repo', repo: decodeURIComponent(m[1]!) }
     if (/^\/planned\/?$/.test(pathname)) return { page: 'planned', repo: null }
     if (/^\/activity\/?$/.test(pathname)) return { page: 'activity', repo: null }
+    if (/^\/insights\/?$/.test(pathname)) return { page: 'insights', repo: null }
     if (/^\/archived\/?$/.test(pathname)) return { page: 'archived', repo: null }
     return { page: 'overview', repo: null }
 }
@@ -69,6 +71,7 @@ export class HomeSt {
     planned: PlannedSt
     /** what every repo committed and holds, polled while it is the page */
     activity: ActivitySt
+    insights: InsightsSt
     /** the one picker, cmd+j */
     palette: PaletteSt
     /** the widths of the project list and a repo's sidebar */
@@ -91,12 +94,13 @@ export class HomeSt {
         this.projects = new ProjectsSvc()
         this.planned = new PlannedSt(this)
         this.activity = new ActivitySt(this)
+        this.insights = new InsightsSt(this)
         this.palette = new PaletteSt(this)
         this.layout = new LayoutSt()
         this.dock = new DockSt(this)
         this.machine = o.home ? new MachineSt(this, o) : null
         this.page = o.home ? 'overview' : 'repo'
-        makeAutoObservable<this, 'disposers' | 'onUrl' | 'prefetching'>(this, { machine: false, projects: false, planned: false, activity: false, palette: false, layout: false, dock: false, repos: observableShallow, disposers: false, onUrl: false, prefetching: false })
+        makeAutoObservable<this, 'disposers' | 'onUrl' | 'prefetching'>(this, { machine: false, projects: false, planned: false, activity: false, insights: false, palette: false, layout: false, dock: false, repos: observableShallow, disposers: false, onUrl: false, prefetching: false })
         const m = this.machine
         if (m != null) {
             this.projects.onSelect = (name) => this.select(name)
@@ -129,6 +133,7 @@ export class HomeSt {
         if (this.page === 'overview') return 'home'
         if (this.page === 'planned') return 'planned'
         if (this.page === 'activity') return 'activity'
+        if (this.page === 'insights') return 'insights'
         if (this.page === 'archived') return 'archived'
         const r = this.shown
         return r == null || r.name === '' ? 'hub' : `${r.name} · hub`
@@ -222,6 +227,7 @@ export class HomeSt {
      *  everything; the one shown resumes once its hub answers */
     private show(page: Page, repo: string | null, how: 'push' | 'replace' | 'none'): void {
         const prev = this.shown
+        const prevPage = this.page
         const next = page === 'repo' && repo != null ? this.repo(repo) : null
         // the page already shown is never a second history entry
         if (how === 'push' && page === this.page && next === prev && page !== 'planned') how = 'none'
@@ -234,12 +240,13 @@ export class HomeSt {
         this.projects.away = next == null
         this.projects.place = page === 'repo' || page === 'archived' ? null : page
         if (how !== 'none') {
-            const to = next != null ? `${repoPage(next.key)}${next.search}${next.hash}` : page === 'planned' ? this.planned.address : page === 'activity' || page === 'archived' ? PLACE_PATH[page] : '/'
+            const to = next != null ? `${repoPage(next.key)}${next.search}${next.hash}` : page === 'planned' ? this.planned.address : page === 'activity' || page === 'insights' || page === 'archived' ? PLACE_PATH[page] : '/'
             if (how === 'push') history.pushState(null, '', to)
             else history.replaceState(null, '', to)
         }
         if (page === 'planned') this.planned.start()
         else this.planned.stop()
+        if (page === 'insights' && prevPage !== 'insights') this.insights.start()
         if (page === 'activity') this.activity.start()
         else this.activity.stop()
         if (next != null && next !== prev && this.machine?.data != null) void this.machine.hub(next.key, 'ensure')

package/src/serve/hub-app/home-strip.css

@@ -57,6 +57,8 @@
 .hwidget{flex:0 1 auto;max-width:100%;padding:var(--s0) var(--s2);border:1px solid var(--line);border-radius:3px;font-size:12px;line-height:1.4;overflow:auto}
 .hwidget h3{margin:0;font-size:12px;font-weight:650;white-space:nowrap}
 .hwidget h3 .hdim{font-weight:400}
+.hwidget h3 .hwre{width:16px;height:16px;margin-left:var(--s1)}
+.hwidget h3 .hwre .hico{width:12px;height:12px}
 /* meters in two columns: <table class="wmeters">, label · bar · value, twice a row */
 .wmeters td{padding-right:var(--s1)}
 .wmeters td:nth-child(3n){padding-right:var(--s3)}

package/src/serve/hub-app/home-strip.tsx

@@ -211,6 +211,10 @@ const Monitor = observer(({ m }: { m: MachineSt }) => {
                                 {x.title}
                                 {head == null ? null : <span className="hdim"> · <span dangerouslySetInnerHTML={{ __html: head }} /></span>}
                                 {x.error != null && x.html != null ? <i className="gpwarn" title={x.error} /> : null}
+                                <button className="gpi hwre" aria-label="refresh" disabled={m.refreshing.has(`${x.repo}/${x.id}`)} onClick={() => void m.refreshWidget(x.repo, x.id)}
+                                    title="render it again now, skipping any wait it keeps between samples">
+                                    {m.refreshing.has(`${x.repo}/${x.id}`) ? <span className="spin" /> : <Icon d={ICON.restart} />}
+                                </button>
                             </h3>
                             {x.html != null ? <div dangerouslySetInnerHTML={{ __html: body }} />
                                 : x.error != null ? <div className="hwerr">{x.error}</div>

package/src/serve/hub-app/home.html

@@ -11,6 +11,7 @@
   <link rel="stylesheet" href="./planned.css" />
   <link rel="stylesheet" href="./when.css" />
   <link rel="stylesheet" href="./activity.css" />
+  <link rel="stylesheet" href="./insights.css" />
   <link rel="stylesheet" href="./readme.css" />
   <link rel="stylesheet" href="./dock.css" />
   <link rel="stylesheet" href="./controls.css" />

package/src/serve/hub-app/hub-app.tsx

@@ -37,6 +37,7 @@ import { LIST, SIDEBAR } from './layout-st.ts'
 import { ArchivedView, HomeStrip, NotUp, Overview } from './home-strip.tsx'
 import { PlannedView } from './planned-view.tsx'
 import { ActivityView } from './activity-view.tsx'
+import { InsightsView } from './insights-view.tsx'
 import { Palette } from './palette-view.tsx'
 import { SCREEN_WAIT_MS } from './screen-cache.ts'
 import { isSearchKey, pageKey, sectionKey } from './keys.ts'
@@ -320,6 +321,7 @@ const App = observer(() => {
                             {home.page === 'overview' ? <Overview app={home} /> : null}
                             {home.page === 'planned' ? <PlannedView app={home} /> : null}
                             {home.page === 'activity' ? <ActivityView app={home} /> : null}
+                            {home.page === 'insights' ? <InsightsView app={home} /> : null}
                             {home.page === 'archived' ? <ArchivedView app={home} /> : null}
                             {home.visited.map((r) => <RepoView key={r.key} app={r} />)}
                         </Panel>

package/src/serve/hub-app/icons.tsx

@@ -12,6 +12,7 @@ export const ICON = {
     reflections: 'M4 3.5h12v9H9l-4 3.5v-3.5H4zM7.5 7h5M7.5 9.5h3',
     monitor: 'M3 4h14v9H3zM7 16.5h6M10 13v3.5',
     archived: 'M2.5 4h15v3.5h-15zM4 7.5V16h12V7.5M8 10.5h4',
+    insights: 'M3 16.5h14M5 16.5V11M9 16.5V5M13 16.5V8.5M17 16.5V12',
     home: 'M3 9.5 10 3.5l7 6M5 8v8.5h10V8M8.5 16.5v-4.5h3v4.5',
     planned: 'M5.5 3h9M5.5 17h9M6.5 3c0 4 7 4 7 7s-7 3-7 7M13.5 3c0 4-7 4-7 7s7 3 7 7',
     browser: 'M10 2.5a7.5 7.5 0 1 0 0 15a7.5 7.5 0 1 0 0-15M2.5 10h15M10 2.5c-3 3-3 12 0 15M10 2.5c3 3 3 12 0 15',

package/src/serve/hub-app/index.html

@@ -11,6 +11,7 @@
   <link rel="stylesheet" href="./planned.css" />
   <link rel="stylesheet" href="./when.css" />
   <link rel="stylesheet" href="./activity.css" />
+  <link rel="stylesheet" href="./insights.css" />
   <link rel="stylesheet" href="./readme.css" />
   <link rel="stylesheet" href="./dock.css" />
   <link rel="stylesheet" href="./controls.css" />

package/src/serve/hub-app/insights-st.ts

@@ -0,0 +1,111 @@
+// the insights page's state: the daemon's boxes for one scope, the tag that
+// filters which boxes show, and one query that filters every box's rows. It
+// reads once when the page shows and on the refresh button, never on a clock:
+// manifests change far slower than anyone reads them. The scope and the tag
+// are remembered per viewer.
+import { makeAutoObservable, observableRef, runInAction } from 'mobx'
+import { rowMatches, SCOPES, tagsOf, type InsightBox, type InsightRow, type InsightsAnswer, type Scope } from '../../home/insights-shape.ts'
+import type { HomeSt } from './home-st.ts'
+import { ownTrouble, reach } from './reach.ts'
+
+/** the rows a box shows before its "show all" */
+export const BOX_ROWS = 25
+const SCOPE_KEY = 'home:insights:scope'
+const TAG_KEY = 'home:insights:tag'
+
+function kept(key: string): string | null {
+    try {
+        return globalThis.localStorage?.getItem(key) ?? null
+    } catch {
+        return null
+    }
+}
+function keep(key: string, v: string): void {
+    try { globalThis.localStorage?.setItem(key, v) } catch { /* private window: the pick lasts the tab */ }
+}
+
+export class InsightsSt {
+    data: InsightsAnswer | null = null
+    error = ''
+    loading = false
+    scope: Scope = (SCOPES as readonly string[]).includes(kept(SCOPE_KEY) ?? '') ? (kept(SCOPE_KEY) as Scope) : 'house'
+    /** the tag whose boxes show, null for every box */
+    tag: string | null = kept(TAG_KEY) || null
+    query = ''
+    /** boxes showing every row, past BOX_ROWS */
+    full = new Set<string>()
+    /** `box/key` of each row whose uses show under it */
+    open = new Set<string>()
+    private gen = 0
+
+    constructor(private st: HomeSt) {
+        makeAutoObservable<this, 'st' | 'gen'>(this, { st: false, gen: false, data: observableRef })
+    }
+
+    get tags(): string[] {
+        return tagsOf(this.data?.boxes ?? [])
+    }
+
+    /** the boxes the tag lets through, each with the rows the query lets through */
+    get boxes(): { box: InsightBox; rows: InsightRow[] }[] {
+        return (this.data?.boxes ?? [])
+            .filter((b) => this.tag == null || !this.tags.includes(this.tag) || b.tags.includes(this.tag))
+            .map((box) => ({ box, rows: box.rows.filter((r) => rowMatches(box, r, this.query)) }))
+    }
+
+    setScope(s: Scope): void {
+        if (s === this.scope) return
+        this.scope = s
+        keep(SCOPE_KEY, s)
+        void this.load()
+    }
+
+    setTag(t: string | null): void {
+        this.tag = t
+        keep(TAG_KEY, t ?? '')
+    }
+
+    setQuery(q: string): void {
+        this.query = q
+    }
+
+    toggleFull(box: string): void {
+        if (this.full.has(box)) this.full.delete(box)
+        else this.full.add(box)
+    }
+
+    toggleRow(box: string, key: string): void {
+        const k = `${box}/${key}`
+        if (this.open.has(k)) this.open.delete(k)
+        else this.open.add(k)
+    }
+
+    openRepo(name: string): void {
+        this.st.select(name)
+    }
+
+    /** the refresh button: the daemon reads every manifest again */
+    refresh(): void {
+        if (!this.loading) void this.load(true)
+    }
+
+    async load(fresh = false): Promise<void> {
+        const id = ++this.gen
+        this.loading = true
+        try {
+            const r = await reach(`/api/home/insights.json?scope=${this.scope}${fresh ? '&fresh=1' : ''}`, { signal: AbortSignal.timeout(60_000) })
+            if (!r.ok) throw new Error(`${r.status} ${await r.text()}`)
+            const j = (await r.json()) as InsightsAnswer
+            runInAction(() => { if (id === this.gen) { this.data = j; this.error = '' } })
+        } catch (e) {
+            runInAction(() => { if (id === this.gen) this.error = ownTrouble(e, this.st.machine) })
+        } finally {
+            runInAction(() => { if (id === this.gen) this.loading = false })
+        }
+    }
+
+    /** reads when the page shows */
+    start(): void {
+        void this.load()
+    }
+}

package/src/serve/hub-app/insights-view.tsx

@@ -0,0 +1,112 @@
+// `/insights`: boxes about every repo of a scope, each carrying tags. On top:
+// the scope (house repos or all of ~/dev), the tag row that filters the boxes,
+// one query that filters every box's rows, and the refresh. A box lists its
+// rows by how many repos use each key; a click on a row shows every use, the
+// house repos as links to their page.
+import { observer } from 'mobx-react-lite'
+import { placeWords, type InsightBox, type InsightRow, type Scope } from '../../home/insights-shape.ts'
+import type { HomeSt } from './home-st.ts'
+import { plainClick, repoPage } from './home-st.ts'
+import { BOX_ROWS } from './insights-st.ts'
+
+const SCOPE_WORDS: Record<Scope, { label: string; title: string }> = {
+    house: { label: 'house', title: 'the repos on the project list' },
+    dev: { label: '~/dev', title: 'every folder of ~/dev with a package.json or a .git, wired or not' },
+}
+
+/** the values a row shows inline before "+n" */
+const VALUES_SHOWN = 3
+
+const Row = observer(({ app, box, r }: { app: HomeSt; box: InsightBox; r: InsightRow }) => {
+    const st = app.insights
+    const open = st.open.has(`${box.id}/${r.key}`)
+    const house = new Set(app.projects.list.map((p) => p.name))
+    return (
+        <>
+            <tr className={`inrow${open ? ' open' : ''}`} onClick={() => st.toggleRow(box.id, r.key)} title={`${r.uses.length} use${r.uses.length === 1 ? '' : 's'}: click to list them`}>
+                <td className="inkey">{r.key}</td>
+                <td className="incount">{r.repos}</td>
+                <td className="invals">
+                    {r.values.slice(0, VALUES_SHOWN).map((v) => <code key={v}>{v}</code>)}
+                    {r.values.length > VALUES_SHOWN ? <span className="acdim"> +{r.values.length - VALUES_SHOWN}</span> : null}
+                </td>
+            </tr>
+            {!open ? null : r.uses.map((u, i) => (
+                <tr key={i} className="inuse">
+                    <td className="inplace">
+                        {house.has(u.repo) ? (
+                            <a href={repoPage(u.repo)} onClick={(e) => {
+                                if (!plainClick(e)) return
+                                e.preventDefault()
+                                st.openRepo(u.repo)
+                            }}>{placeWords(u)}</a>
+                        ) : placeWords(u)}
+                    </td>
+                    <td colSpan={2} className="invals"><code>{u.value}</code>{u.dev ? <span className="acdim"> dev</span> : null}</td>
+                </tr>
+            ))}
+        </>
+    )
+})
+
+const Box = observer(({ app, box, rows }: { app: HomeSt; box: InsightBox; rows: InsightRow[] }) => {
+    const st = app.insights
+    const full = st.full.has(box.id)
+    const shown = full ? rows : rows.slice(0, BOX_ROWS)
+    return (
+        <section className="inbox">
+            <h3>
+                <span>{box.title}</span>
+                {box.tags.map((t) => <button key={t} className={`intag${st.tag === t ? ' on' : ''}`} onClick={() => st.setTag(st.tag === t ? null : t)}>{t}</button>)}
+                <span className="sp" />
+                <span className="acdim">{rows.length === box.rows.length ? rows.length : `${rows.length} of ${box.rows.length}`}</span>
+            </h3>
+            <p className="acdim">{box.hint}</p>
+            {rows.length === 0 ? <p className="acdim">no {box.noun} matches</p> : (
+                <table className="intable">
+                    <colgroup><col /><col className="c-count" /><col /></colgroup>
+                    <thead><tr><th>{box.noun}</th><th>repos</th><th>values</th></tr></thead>
+                    <tbody>{shown.map((r) => <Row key={r.key} app={app} box={box} r={r} />)}</tbody>
+                </table>
+            )}
+            {rows.length > BOX_ROWS ? <button className="ghost hsm inmore" onClick={() => st.toggleFull(box.id)}>{full ? `show the first ${BOX_ROWS}` : `show all ${rows.length}`}</button> : null}
+        </section>
+    )
+})
+
+export const InsightsView = observer(({ app }: { app: HomeSt }) => {
+    const st = app.insights
+    const d = st.data
+    return (
+        <div className="hall activity insights">
+            <div className="actop">
+                <div className="acwin" role="radiogroup" aria-label="which repos">
+                    {(Object.keys(SCOPE_WORDS) as Scope[]).map((s) => (
+                        <button key={s} role="radio" aria-checked={st.scope === s} className={st.scope === s ? 'on' : ''} title={SCOPE_WORDS[s].title} onClick={() => st.setScope(s)}>{SCOPE_WORDS[s].label}</button>
+                    ))}
+                </div>
+                <div className="acwin" role="radiogroup" aria-label="which boxes">
+                    <button role="radio" aria-checked={st.tag == null} className={st.tag == null ? 'on' : ''} onClick={() => st.setTag(null)}>all</button>
+                    {st.tags.map((t) => <button key={t} role="radio" aria-checked={st.tag === t} className={st.tag === t ? 'on' : ''} onClick={() => st.setTag(t)}>{t}</button>)}
+                </div>
+                <input className="inquery" type="search" placeholder="filter: a package, a script…" aria-label="filter every box" value={st.query} onChange={(e) => st.setQuery(e.currentTarget.value)} />
+                <button type="button" className="acpill" disabled={st.loading} onClick={() => st.refresh()} title="read every package.json again now · an answer is kept 5 minutes">
+                    <span className={`acring${st.loading ? ' on' : ''}`}>↻</span>
+                </button>
+                {d == null ? <span className="acdim">reading every package.json…</span> : (
+                    <>
+                        <span className="acpill">{d.repos} repos</span>
+                        <span className="acpill">{d.files} package.json</span>
+                        <span className="acpill">read in {d.ms}ms</span>
+                    </>
+                )}
+            </div>
+            {st.error !== '' ? <div className="hnote">{st.error}</div> : null}
+            {d != null && d.errors.length > 0 ? <div className="hnote" title={d.errors.join('\n')}>{d.errors.length} package.json would not parse</div> : null}
+            <div className={`ingrid${d != null && d.scope !== st.scope ? ' stale' : ''}`}>
+                {st.boxes.map(({ box, rows }) => <Box key={box.id} app={app} box={box} rows={rows} />)}
+            </div>
+            <p className="hdim">in the console: shipkit insights</p>
+        </div>
+    )
+})

package/src/serve/hub-app/insights.css

@@ -0,0 +1,24 @@
+/* the insights page (insights-view.tsx): the activity page's top bar, then a
+   grid of boxes. A row opens in place to list its uses. */
+.ingrid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,460px),1fr));gap:var(--s3);align-items:start}
+.ingrid.stale{opacity:.5}
+.inbox{border:1px solid var(--line);border-radius:4px;padding:var(--s2) var(--s3);min-width:0}
+.inbox h3{display:flex;align-items:center;gap:var(--s2);margin:0;font-size:13px;font-weight:650}
+.inbox > p{margin:var(--s0) 0 var(--s2);font-size:12px}
+.intag{border:1px solid var(--line);border-radius:999px;padding:0 var(--s2);background:none;color:var(--dim);font-size:11px;font-weight:400;line-height:18px;cursor:pointer}
+.intag:hover,.intag.on{color:var(--accent);border-color:var(--accent)}
+.inquery{height:22px;min-width:200px;box-sizing:border-box;background:var(--bg);color:var(--ink);border:1px solid var(--line);border-radius:4px;padding:0 var(--s2);font:inherit;font-size:12px}
+.inquery:focus{outline:none;border-color:var(--accent)}
+.intable{width:100%;table-layout:fixed;border-collapse:collapse}
+.intable col.c-count{width:56px}
+.intable th{text-align:left;font-weight:400;color:var(--dim);font-size:11.5px;padding:var(--s0) var(--s1);border-bottom:1px solid var(--line)}
+.intable td{padding:0 var(--s1);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;vertical-align:top}
+.inrow{cursor:pointer}
+.inrow:hover td,.inrow.open td{background:var(--panel2)}
+.inkey{font-weight:600}
+.incount{font-variant-numeric:tabular-nums;text-align:right;padding-right:var(--s3) !important}
+.invals code{margin-right:var(--s1);font-size:11.5px;color:var(--dim)}
+.inuse td{font-size:12px}
+.inuse .inplace{padding-left:var(--s3)}
+.inuse .inplace a{color:var(--accent);text-decoration:none}
+.inmore{margin-top:var(--s1)}

package/src/serve/hub-app/keys.ts

@@ -27,7 +27,7 @@ export function pageKey(e: KeyLike): PageKey | null {
 }
 
 /** the shortcut each place of the home carries on its button */
-export const PLACE_KEY = { overview: '⌘K', planned: "⌘'", activity: '⌘L' } as const
+export const PLACE_KEY: Record<'overview' | 'planned' | 'activity', string> & Partial<Record<string, string>> = { overview: '⌘K', planned: "⌘'", activity: '⌘L' }
 /** the picker's shortcut, on the first button, before home */
 export const PICKER_KEY = '⌘J'
 /** the repo above and below, hinted at the project list's foot */

package/src/serve/hub-app/machine-st.ts

@@ -7,6 +7,7 @@
 // of this (HomeSt.machine is null).
 import { makeAutoObservable, observableRef, runInAction } from 'mobx'
 import type { HomeAnswer, WidgetsAnswer } from '../../home/home-routes.ts'
+import type { WidgetView } from '../../home/widgets.ts'
 import type { WorkerView } from '../../home/hubs.ts'
 import type { OpenHow, ResourceView } from '../../home/resources.ts'
 import type { PmAnswer, Role } from '../../home/pm.ts'
@@ -51,6 +52,8 @@ export class MachineSt {
     pm: PmAnswer | null = null
     /** every house repo's widgets, as the daemon last rendered them */
     widgets: WidgetsAnswer | null = null
+    /** `repo/id` of each widget a refresh is rendering */
+    refreshing = new Set<string>()
     /** why pm did not answer the last poll, or '' while it does */
     pmDown = ''
     /** the last action that failed */
@@ -261,6 +264,26 @@ export class MachineSt {
         }
     }
 
+    /** one widget rendered now by the daemon, with force (its cache or
+     *  backoff skipped), its new view swapped in */
+    async refreshWidget(repo: string, id: string): Promise<void> {
+        const k = `${repo}/${id}`
+        if (this.refreshing.has(k)) return
+        this.refreshing.add(k)
+        try {
+            const r = await reach('/api/home/widgets/refresh', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ repo, id }) })
+            if (!r.ok) throw new Error(await r.text())
+            const v = (await r.json()) as WidgetView
+            runInAction(() => {
+                if (this.widgets != null) this.widgets = { ...this.widgets, widgets: this.widgets.widgets.map((w) => (w.repo === repo && w.id === id ? v : w)) }
+            })
+        } catch (e) {
+            runInAction(() => { this.error = ownTrouble(e, this) })
+        } finally {
+            runInAction(() => { this.refreshing.delete(k) })
+        }
+    }
+
     hub(name: string, act: 'ensure' | 'restart'): Promise<boolean> {
         return this.post('/api/home/hub', { name, act })
     }

package/src/serve/hub-app/palette-st.ts

@@ -1,5 +1,5 @@
 // the one picker of the page (cmd+j, keys.ts), a node of the root: the
-// home's places (home, activity, planned, in the list's order) first, then the shown repo's own jump
+// home's places (home, activity, planned, insights, archived) first, then the shown repo's own jump
 // targets, then every other house repo as a place to go. Another repo's
 // resources are never listed: a jump to a repo selects it in place, and its
 // own targets are one more cmd+j away.
@@ -27,6 +27,7 @@ export class PaletteSt {
             { id: 'place:home', label: 'home', section: 'place', face: { place: 'home' }, run: () => st.navigate('/') },
             { id: 'place:activity', label: 'activity', section: 'place', face: { place: 'activity' }, run: () => st.navigate('/activity') },
             { id: 'place:planned', label: 'planned', section: 'place', face: { place: 'planned' }, run: () => st.navigate('/planned') },
+            { id: 'place:insights', label: 'insights', section: 'place', face: { place: 'insights' }, run: () => st.navigate('/insights') },
             { id: 'place:archived', label: 'archived', section: 'place', face: { place: 'archived' }, run: () => st.navigate('/archived') },
         ]
     }

package/src/serve/hub-app/project-list.tsx

@@ -37,6 +37,7 @@ const PLACES: { id: Place | 'picker'; label: string; title: string }[] = [
     { id: 'overview', label: 'overview', title: 'the overview: shipkit, every global process and every repo on this machine' },
     { id: 'activity', label: 'activity', title: 'what every repo committed lately, what it holds uncommitted, its branch and whether it is pushed' },
     { id: 'planned', label: 'planned', title: 'every check the machine runs on its own: now, next, late, and why' },
+    { id: 'insights', label: 'insights', title: 'boxes about every repo: the packages they use and by how many, version drift, script names' },
 ]
 
 /** the icon's size on a row, in px, as attributes and in the sheet */
@@ -165,10 +166,10 @@ export const ProjectList = observer(({ app }: { app: ListHost }) => {
                         const on = id === 'picker' ? s.pickerOpen() : s.place === id
                         const key = id === 'picker' ? PICKER_KEY : PLACE_KEY[id]
                         return (
-                            <button key={id} className={`pjpl${on ? ' cur' : ''}`} aria-label={pl.label} title={`${pl.title} (${key})`} onClick={run}>
+                            <button key={id} className={`pjpl${on ? ' cur' : ''}`} aria-label={pl.label} title={key == null ? pl.title : `${pl.title} (${key})`} onClick={run}>
                                 <Icon d={ICON[id === 'picker' ? 'search' : id === 'overview' ? 'home' : id]} />
                                 <span className="pjname">{pl.label}</span>
-                                <kbd className="pjkey">{key}</kbd>
+                                {key == null ? null : <kbd className="pjkey">{key}</kbd>}
                             </button>
                         )
                     })}

package/src/serve/hub-app/projects-svc.ts

@@ -178,7 +178,7 @@ export function cardModel(p: Project, now: number): CardModel {
 }
 
 /** a page of the home that is no repo's */
-export type Place = 'overview' | 'planned' | 'activity'
+export type Place = 'overview' | 'planned' | 'activity' | 'insights'
 
 export class ProjectsSvc {
     /** the last list this browser saw until the first poll answers, so the

package/src/serve/hub-app/repo-st.ts

@@ -30,7 +30,7 @@ export type Sel = HashSel | null
 
 /** one picker target (cmd+j): run() fires the SAME action clicking would */
 /** what a picker entry wears: a repo's own icon, or a place's button icon */
-export type JumpFace = { repo: string } | { place: 'home' | 'planned' | 'activity' | 'archived' }
+export type JumpFace = { repo: string } | { place: 'home' | 'planned' | 'activity' | 'insights' | 'archived' }
 /** `key`: the shortcut that does the same, printed at the entry's end */
 export type Jump = { id: string; label: string; section: string; run: () => void; face?: JumpFace; key?: string }
 

package/src/shipkit-files.ts

@@ -61,8 +61,9 @@ export type WidgetDef = {
     title?: string
     /** how often the daemon renders it again (default 5000, at least 1000) */
     everyMs?: number
-    /** the html it shows, rendered in the daemon. A throw shows as its error */
-    render: () => string | Promise<string>
+    /** the html it shows, rendered in the daemon. A throw shows as its error.
+     *  `force`: a reader pressed refresh, so skip any cache or backoff */
+    render: (o: { force: boolean }) => string | Promise<string>
 }
 
 export type GlobalProcessUnit = GlobalProcessDef & { kind: 'globalProcess' }