@defrex/autobuild 0.9.0 → 0.10.0

package/packages/core/src/cli/dispatch.ts

@@ -140,6 +140,7 @@ import {
   type LaunchRunnerResult,
   type TickReport,
 } from '../processes/dispatcher'
+import { RepoViewStore } from '../processes/repo-view'
 import {
   BuildControlError,
   buildControlUser,
@@ -597,6 +598,8 @@ interface ActiveBuildExecution {
    * running, so the completion chain must append no `execution.ended`, release
    * no lease, settle no publication, and record no wait failure. */
   detaching?: boolean
+  /** A wait failure being recorded; teardown lets it finish rather than drop it. */
+  recording?: Promise<void>
 }
 
 /** The dispatch loop owns deterministic decisions and supervises one
@@ -604,6 +607,10 @@ interface ActiveBuildExecution {
  * Store; child completion is liveness evidence used for reaping/single-flight. */
 class DispatchLoop {
   private readonly dispatcher: Dispatcher
+  /** The incremental repository view (AUT-647) the dispatcher and this
+   * frontend's tick-path journal reads and writes share. Resident for a
+   * watch loop; `--once` builds it cold for its single tick. */
+  private readonly repoView: RepoViewStore
   private readonly host = hostname()
   private readonly maxHarvestRecoveryAttempts = DEFAULT_MAX_HARVEST_RECOVERY_ATTEMPTS
   /** In-flight build and harvest runs (fire-and-forget) — awaited before a
@@ -749,6 +756,8 @@ class DispatchLoop {
     private readonly liveConfig: LiveConfig,
     private readonly wiring: DispatchWiring,
     private readonly opts: DispatchOpts,
+    /** The view `abDispatch` already used for its lifecycle appends. */
+    view?: RepoViewStore,
   ) {
     const config = liveConfig.current().config
     // Minted exactly once per invocation: `wiring.ids` is `randomIds()` and a
@@ -785,8 +794,16 @@ class DispatchLoop {
       return result.text
     }
 
+    // `abDispatch` hands over a view it already used for the lifecycle appends,
+    // so those rows are folded, not re-read, and one flush covers them all.
+    this.repoView =
+      view ??
+      new RepoViewStore(wiring.store, {
+        repo: this.repoIdentity,
+        resident: opts.once !== true,
+      })
     this.dispatcher = new Dispatcher({
-      store: wiring.store,
+      store: this.repoView,
       tickets: wiring.tickets,
       workspaces: wiring.workspaces,
       ...(wiring.retiredWorkspaces === undefined
@@ -839,7 +856,7 @@ class DispatchLoop {
       // the record's `branch` (when present) is the same fact. Using the event
       // keeps this read to the events the caller already needs and avoids an
       // extra build-record lookup on the hot launch path.
-      const events = await this.wiring.store.getEvents(slug)
+      const events = await this.repoView.getEvents(slug)
       const workspace = selectOpenWorkspace(events)
       const source = await resolvePipelineSource({
         slug,
@@ -1019,7 +1036,7 @@ class DispatchLoop {
   }
 
   private async appendStatus(event: RepositoryEventWrite): Promise<void> {
-    await this.wiring.store.appendRepo(this.repoIdentity, event)
+    await this.repoView.appendRepo(this.repoIdentity, event)
   }
 
   private async refreshConfig(): Promise<void> {
@@ -1084,9 +1101,10 @@ class DispatchLoop {
   }
 
   private async readDispatchSettings(): Promise<ReturnType<typeof reduceDispatchSettings>> {
-    // Bounded read (AUT-489): the settings reducer consumes durable types only.
-    const events = await this.wiring.store.getRepoStateEvents(this.repoIdentity)
-    return reduceDispatchSettings(events)
+    // The view's bounded subset (AUT-489): the settings reducer consumes
+    // durable types only. `refresh()` ran first in the tick, so this is the
+    // delta-current journal, never a store read.
+    return reduceDispatchSettings(this.repoView.recordedJournal())
   }
 
   private dispatcherTick(resumeCurrent: boolean): Promise<Awaited<ReturnType<Dispatcher['tick']>>> {
@@ -1127,6 +1145,7 @@ class DispatchLoop {
 
       // Sample inside the serialized tick, not at process startup. Every
       // dispatcher therefore gates claims from the latest repository facts.
+      await this.repoView.refresh()
       const settings = await this.readDispatchSettings()
       const readyObservation =
         settings.intake || (!this.dashboard && this.opts.kernelRunId === undefined)
@@ -1134,6 +1153,7 @@ class DispatchLoop {
           : await this.dispatcher.observeReady()
       const report = await this.dispatcher.tick({
         resumeCurrent,
+        viewRefreshed: true,
         acceptNewWork: settings.intake,
         defaultAutoMerge: settings.defaultAutoMerge,
         autoMergeUser: buildControlUser(this.opts.env),
@@ -2286,10 +2306,11 @@ class DispatchLoop {
       // the pure Store-read pressure check; the guest rescans authoritatively
       // once provisioned, so a threshold crossing between gate and guest scan
       // is never suppressed by this check.
-      const record = await store.getRepo(repo)
-      // Bounded read (AUT-489): the harvest control decision reduces durable
-      // types only.
-      const events = record === null ? [] : await store.getRepoStateEvents(repo)
+      // The view's bounded subset (AUT-489): the harvest control decision
+      // reduces durable types only. Take the journal delta first — guests and
+      // other dispatchers write harvest facts between ticks.
+      await this.repoView.refreshJournal()
+      const events = this.repoView.recordedJournal()
       const state = reduceHarvest(events)
       const control = decideHarvestControl(state, this.maxHarvestRecoveryAttempts)
       const resumePending =
@@ -2331,7 +2352,7 @@ class DispatchLoop {
         )
       }
       this.hostedHarvest = { execution, handle, detached }
-      const started = await store.appendRepo(repo, {
+      const started = await this.repoView.appendRepo(repo, {
         actor: DISPATCHER,
         type: 'harvest.execution.started',
         payload: {
@@ -2406,8 +2427,10 @@ class DispatchLoop {
     startedSeq: number,
   ): Promise<HarvestRunnerResult> {
     const { store } = this.wiring
-    // Bounded read (AUT-489): classifyHarvestOutcome reduces harvest facts only.
-    const events = await store.getRepoStateEvents(repo)
+    // Bounded subset (AUT-489): classifyHarvestOutcome reduces harvest facts
+    // only. A guest wrote the facts through its own handle, so read the delta.
+    await this.repoView.refreshJournal()
+    const events = this.repoView.recordedJournal()
     const record = await store.getRepo(repo)
     return classifyHarvestOutcome(events, {
       executionStartedSeq: startedSeq,
@@ -2433,7 +2456,7 @@ class DispatchLoop {
       branch: '',
     }
     const reap = await this.reapHostedWorkspace(workspaceHandle)
-    await this.wiring.store.appendRepo(repo, {
+    await this.repoView.appendRepo(repo, {
       actor: DISPATCHER,
       type: 'harvest.execution.released',
       payload: {
@@ -2590,9 +2613,11 @@ class DispatchLoop {
   }
 
   private async settlePendingPublication(slug: string): Promise<void> {
+    // The guest appended through its own handle; settle against fresh state.
+    await this.repoView.refreshBuild(slug)
     await settleWorkspacePublication(
       {
-        store: this.wiring.store,
+        store: this.repoView,
         storeRef: this.wiring.storeRef,
         publication: this.wiring.workspaces.publication,
         forge: this.wiring.forge,
@@ -2615,11 +2640,13 @@ class DispatchLoop {
     cleanupPending: boolean
     identity?: BuildExecutionHandle['identity']
   }): Promise<void> {
+    // The failed executor may have appended through its own handle.
+    await this.repoView.refreshBuild(input.slug)
     await appendInfrastructureFailure(
-      { store: this.wiring.store, ids: this.wiring.ids },
+      { store: this.repoView, ids: this.wiring.ids },
       {
         slug: input.slug,
-        events: await this.wiring.store.getEvents(input.slug),
+        events: await this.repoView.getEvents(input.slug),
         maxAttempts: this.currentConfig().config.policy.maxInfrastructureAttempts,
         provider: input.identity?.provider ?? this.wiring.workspaces.name,
         workspaceRef: input.workspaceRef,
@@ -2650,11 +2677,7 @@ class DispatchLoop {
 
     try {
       await this.publishBuildConfig(slug)
-      leaseClaimed = await this.wiring.store.claimLease(
-        slug,
-        instance,
-        BUILD_EXECUTION_LEASE_TTL_MS,
-      )
+      leaseClaimed = await this.repoView.claimLease(slug, instance, BUILD_EXECUTION_LEASE_TTL_MS)
       if (!leaseClaimed) {
         this.activeBuildRuns.delete(slug)
         await this.appendStatus({
@@ -2665,7 +2688,7 @@ class DispatchLoop {
         this.failureNotice(`build ${slug} already held by another runner — skipped`)
         return 'already-active'
       }
-      const launchEvents = await this.wiring.store.getEvents(slug)
+      const launchEvents = await this.repoView.getEvents(slug)
       let workspaceRef: string | undefined
       let workspaceProvider: string | undefined
       for (const event of launchEvents) {
@@ -2709,7 +2732,7 @@ class DispatchLoop {
         provider: owning.name,
         workspaceRef,
       }
-      await this.wiring.store.append(slug, {
+      await this.repoView.append(slug, {
         actor: DISPATCHER,
         type: 'execution.started',
         payload: { ...identity, instance },
@@ -2724,7 +2747,7 @@ class DispatchLoop {
             // supervisor settles the execution from the Store.
             if (active.detaching) return
             try {
-              await this.wiring.store.append(slug, {
+              await this.repoView.append(slug, {
                 actor: DISPATCHER,
                 type: 'execution.ended',
                 payload: {
@@ -2746,7 +2769,8 @@ class DispatchLoop {
                 return
               }
 
-              const state = reduceBuild(await this.wiring.store.getEvents(slug))
+              await this.repoView.refreshBuild(slug)
+              const state = reduceBuild(await this.repoView.getEvents(slug))
               if (diagnostic === null && exit.exitCode === 0) {
                 await this.appendStatus({
                   actor: DISPATCHER,
@@ -2772,7 +2796,7 @@ class DispatchLoop {
               })
               this.warn(`build ${slug} runner failed: ${detail}`)
             } finally {
-              await this.wiring.store.releaseLease(slug, instance)
+              await this.repoView.releaseLease(slug, instance)
               await this.settlePendingPublication(slug)
             }
           },
@@ -2783,7 +2807,7 @@ class DispatchLoop {
             // A rejected executor completion cannot prove the remote VM was
             // stopped. Keep the lease until expiry: recovery fences and reaps
             // the exact recorded identity before authorizing a replacement.
-            await this.recordInfrastructureFailure({
+            active.recording = this.recordInfrastructureFailure({
               slug,
               instance,
               workspaceRef,
@@ -2792,6 +2816,7 @@ class DispatchLoop {
               cleanupPending: true,
               identity,
             })
+            await active.recording
           },
         )
         .finally(() => {
@@ -2810,7 +2835,9 @@ class DispatchLoop {
         this.activeBuildRuns.delete(slug)
       }
       if (leaseClaimed) {
-        const events = await this.wiring.store.getEvents(slug)
+        // The runner appended through its own handle: take the delta.
+        await this.repoView.refreshBuild(slug)
+        const events = await this.repoView.getEvents(slug)
         let workspaceRef = ''
         for (const event of events) {
           if (event.type === 'workspace.provisioned') workspaceRef = event.payload.ref
@@ -2829,7 +2856,7 @@ class DispatchLoop {
         // Local start failures have no possible remote holder. Remote failures
         // retain the lease until its TTL fences an ambiguous start.
         if (this.wiring.workspaces.recovery === undefined) {
-          await this.wiring.store.releaseLease(slug, instance)
+          await this.repoView.releaseLease(slug, instance)
         }
       }
       await this.appendStatus({
@@ -2925,6 +2952,9 @@ class DispatchLoop {
           } catch {
             // Detach is best-effort: an unresolvable wait still exits.
           }
+          // A wait failure already being recorded is durable work, not
+          // supervision: let it land before the process exits.
+          await entry.recording?.catch(() => {})
           this.activeBuildRuns.delete(slug)
           if (entry.settled !== undefined) {
             this.inFlight.delete(entry.settled)
@@ -3409,7 +3439,7 @@ class DispatchLoop {
       const holder = record?.lease?.holder
       if (holder === undefined || this.yieldedTo === holder) return
       this.yieldedTo = holder
-      await this.wiring.store.appendRepo(this.repoIdentity, {
+      await this.repoView.appendRepo(this.repoIdentity, {
         actor: DISPATCHER,
         type: 'dispatcher.tick-yielded',
         payload: {
@@ -3890,23 +3920,32 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
   // another dispatcher cannot clobber the latest operator choice with a value
   // it inferred at startup. Fresh-repository fallbacks live in the reducer.
   await wiring.store.ensureRepo(state.repo)
+  // Every own lifecycle append goes through one view, restored from snapshots
+  // before the first of them, so a quiet invocation reads none of its own
+  // rows back and the final flush covers `run-stopped` too.
+  const view = new RepoViewStore(wiring.store, {
+    // The loop's store-keyed identity (an explicit `repo` pins it).
+    repo: resolvedOpts.repo ?? resolvedOpts.targetRepo,
+    resident: resolvedOpts.once !== true,
+  })
+  await view.startJournal()
   const actor = humanActor(buildControlUser(resolvedOpts.env))
   if (resolvedOpts.intake !== undefined) {
-    await wiring.store.appendRepo(state.repo, {
+    await view.appendRepo(state.repo, {
       actor,
       type: 'dispatcher.intake-set',
       payload: { enabled: resolvedOpts.intake, run: runId },
     })
   }
   if (resolvedOpts.defaultAutoMerge !== undefined) {
-    await wiring.store.appendRepo(state.repo, {
+    await view.appendRepo(state.repo, {
       actor,
       type: 'dispatcher.auto-merge-default-set',
       payload: { enabled: resolvedOpts.defaultAutoMerge, run: runId },
     })
   }
 
-  await wiring.store.appendRepoWithArtifacts(
+  await view.appendRepoWithArtifacts(
     state.repo,
     [
       {
@@ -3931,10 +3970,10 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
     },
   )
 
-  const loop = new DispatchLoop(liveConfig, wiring, resolvedOpts)
+  const loop = new DispatchLoop(liveConfig, wiring, resolvedOpts, view)
   try {
     await loop.run()
-    await wiring.store.appendRepo(state.repo, {
+    await view.appendRepo(state.repo, {
       actor: DISPATCHER,
       type: 'dispatcher.run-stopped',
       payload: {
@@ -3946,7 +3985,7 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
     })
   } catch (error) {
     try {
-      await wiring.store.appendRepo(state.repo, {
+      await view.appendRepo(state.repo, {
         actor: DISPATCHER,
         type: 'dispatcher.run-stopped',
         payload: {
@@ -3961,6 +4000,10 @@ export async function abDispatch(opts: DispatchOpts): Promise<void> {
     }
     throw error
   } finally {
+    // Every append this invocation made, `run-stopped` included, is in the
+    // view; leave the reduced state behind so the next cold process reads
+    // only what is newer than it.
+    await view.persistSnapshots({ force: true })
     if (resolvedOpts.wire === undefined) await wiring.store.close()
   }
 }

package/packages/core/src/cli/help.ts

@@ -165,6 +165,8 @@ export const HELP_CATALOG: readonly HelpEntry[] = [
       '  ab ticket list [--state <state>] [--labels a,b] [--json]',
       '  ab ticket show <id> [--store <ref>] [--json]',
       '  ab ticket move <id> <state> [--json]',
+      '  ab ticket states [--json]',
+      '  ab ticket state create <name> [--about <text>] [--json]',
       '  ab ticket attach <id> <kind> <path> [--name <name>] [--store <ref>] [--json]',
       '  ab ticket asset get <id> <kind> <name> <dest> [--rev <n>] [--store <ref>] [--json]',
       '  ab ticket asset rm <id> <kind> <name> [--store <ref>] [--json]',
@@ -194,9 +196,21 @@ export const HELP_CATALOG: readonly HelpEntry[] = [
       'its source naming the asset and how to download it. Assets over the store',
       'limit (25 MiB by default, lower on a hosted deployment) are refused.',
       '',
+      'states lists every state of the source: lifecycle states first (triage, ready,',
+      'doing, done), then custom ones alphabetically, each with the roles it plays',
+      'under the current config (create, ready, claimed, triage, proposal, done, or',
+      'none), its ticket count, and its purpose when set. --json emits one bare',
+      'array of {name, roles, tickets, about?}. state create makes a state, e.g.',
+      'icebox, and is idempotent: an existing state is reported, and --about (one',
+      'line) records or replaces its purpose. A name is one to forty lowercase',
+      'letters, digits, and hyphens, starting with a letter, and may not match an',
+      'existing state case-insensitively. There is no rename or delete. Only the file',
+      'source supports both; others exit nonzero naming the source. A state with no',
+      'purpose and no tickets is an empty directory that git does not track.',
+      '',
       'Ticket ids are source-local (for example AUT-8 or file-1). For block and',
       'unblock, the first id is always the ticket being changed. State names and',
-      'unknown-id errors come from the configured source.',
+      'unknown-id errors come from the configured source; ab ticket states lists them.',
     ]),
   },
   {

package/packages/core/src/cli/init-validation.ts

@@ -22,6 +22,7 @@ import type { VercelSandboxFacade } from '../ports/workspace/vercel-sandbox'
 import { diagnosePlugins, loadPlugins } from '../plugins/load'
 import { materializePluginRuntimes } from '../plugins/runtimes'
 import { createTicketSource } from '../ports/tickets/create'
+import { LinearTicketSource } from '../ports/tickets/linear'
 import { inspectLocalStoreSnapshot } from '../store/local/store'
 import type { StoreOpener } from './store-opening'
 import { openProductionStore } from './store-opening'
@@ -402,6 +403,7 @@ export async function validateInitReadiness(opts: {
     providerConfig !== undefined ? (builtinCaps?.guestEnvNames?.(providerConfig) ?? []) : [],
   )
   let caps: WorkspaceProviderCapabilities | undefined
+  let assigneeLine: string | undefined
   try {
     hostPreflight(config, opts.env)
     // Ticket acquisition is a host responsibility for both workspace providers.
@@ -460,7 +462,22 @@ export async function validateInitReadiness(opts: {
       await ticketSource.listReady({
         ...(config.tickets.readyLabels !== undefined ? { labels: config.tickets.readyLabels } : {}),
         state: config.tickets.readyState,
+        ...(config.tickets.readyAssignee !== undefined
+          ? { assignee: config.tickets.readyAssignee }
+          : {}),
       })
+      const assignee = config.tickets.readyAssignee
+      if (assignee !== undefined && ticketSource instanceof LinearTicketSource) {
+        const user = await ticketSource.resolveAssignee(assignee)
+        if (user === null) {
+          throw new Error(
+            assignee === 'me'
+              ? '[tickets].readyAssignee = "me" but LINEAR_API_KEY did not resolve to a Linear user — check the key'
+              : `[tickets].readyAssignee "${assignee}" matches no user in the Linear workspace — check the address or use "me"`,
+          )
+        }
+        assigneeLine = `Ticket assignee gate: ${assignee} → ${user.name} <${user.email}>`
+      }
     }
   } catch (error) {
     throw new Error(redact(error))
@@ -586,6 +603,7 @@ export async function validateInitReadiness(opts: {
   stdout(`Readiness: ${report.context} (${report.provider})`)
   stdout(`Store: ${state.storeRef}`)
   stdout(`Forge: ${config.forge}`)
+  if (assigneeLine !== undefined) stdout(assigneeLine)
   // Same raw `[workspace.config]` fallback guestEnvNames gets (f_55ba7591): a
   // provider that declares describeEnvironment without a configSchema still
   // receives a defined argument — the raw table — never undefined.

package/packages/core/src/cli/installation.ts

@@ -21,13 +21,25 @@ export type InstallScope = 'local' | 'global'
  * forge dependency, or a version range satisfied from the npm registry. */
 export type InstallChannel = 'github' | 'npm'
 
+/** The owning manifest sections a self-update target may be declared in. */
+export type DependencySection = 'dependencies' | 'devDependencies'
+
+/** Searched in this order; when a manifest declares the package in both, the
+ * first wins (the runtime declaration, which a plain `bun add` would rewrite). */
+const DEPENDENCY_SECTIONS: readonly DependencySection[] = ['dependencies', 'devDependencies']
+const SEARCHED_SECTIONS = DEPENDENCY_SECTIONS.join(' or ')
+
 interface ManagedInstallationBase extends DistributionIdentity {
   sourceCheckout: false
   ownerRoot: string
   ownerManifest: string
   ownerLock: string
-  /** The owning manifest's direct dependency value, byte for byte. */
+  /** The owning manifest's direct dependency value in `section`, byte for byte. */
   dependency: string
+  /** The manifest section the dependency was chosen from. */
+  section: DependencySection
+  /** The manifest also declares the package in the other section. */
+  dual: boolean
   scope: InstallScope
 }
 
@@ -180,9 +192,27 @@ async function parseJsonc(path: string): Promise<Record<string, unknown>> {
   }
 }
 
-function lockDependency(lock: Record<string, unknown>, packageName: string): unknown {
+function lockDependency(
+  lock: Record<string, unknown>,
+  packageName: string,
+  section: DependencySection,
+): unknown {
   const workspace = object(object(lock.workspaces)?.[''])
-  return object(workspace?.dependencies)?.[packageName]
+  return object(workspace?.[section])?.[packageName]
+}
+
+/** Pick the section that declares the package: a pure function of the
+ * manifest, in fixed `DEPENDENCY_SECTIONS` order. */
+function declaredSection(
+  manifest: Record<string, unknown>,
+  packageName: string,
+): { section: DependencySection; value: string; dual: boolean } | undefined {
+  const declared = DEPENDENCY_SECTIONS.flatMap((section) => {
+    const value = object(manifest[section])?.[packageName]
+    return typeof value === 'string' ? [{ section, value }] : []
+  })
+  const first = declared[0]
+  return first === undefined ? undefined : { ...first, dual: declared.length > 1 }
 }
 
 function lockPackageRecord(
@@ -235,21 +265,29 @@ export async function inspectInstallation(options: {
   try {
     const manifest = await parseJson(ownerManifest)
     const lock = await parseJsonc(ownerLock)
-    const dependency = object(manifest.dependencies)?.[identity.packageName]
+    const declared = declaredSection(manifest, identity.packageName)
+    if (declared === undefined) {
+      return {
+        kind: 'unknown',
+        identity,
+        reason: `${ownerManifest} does not declare ${identity.packageName} under ${SEARCHED_SECTIONS} as a direct github: dependency or an npm registry version range satisfied by ${identity.version}`,
+      }
+    }
+    const { section, value: dependency, dual } = declared
     const repository = githubDependency(dependency)
     const registry = repository === undefined && registryDependency(dependency, identity.version)
-    if ((repository === undefined && !registry) || typeof dependency !== 'string') {
+    if (repository === undefined && !registry) {
       return {
         kind: 'unknown',
         identity,
-        reason: `${ownerManifest} does not declare ${identity.packageName} as a direct github: dependency or an npm registry version range satisfied by ${identity.version}`,
+        reason: `${ownerManifest} declares ${identity.packageName} under ${section} as "${dependency}", which is neither a direct github: dependency nor an npm registry version range satisfied by ${identity.version}`,
       }
     }
-    if (lockDependency(lock, identity.packageName) !== dependency) {
+    if (lockDependency(lock, identity.packageName, section) !== dependency) {
       return {
         kind: 'unknown',
         identity,
-        reason: `${ownerLock} does not agree with the direct dependency in ${ownerManifest}`,
+        reason: `${ownerLock} does not agree with the direct ${section} entry in ${ownerManifest}`,
       }
     }
     const scope: InstallScope = (await samePath(join(options.globalBin, 'ab'), identity.binaryPath))
@@ -280,6 +318,8 @@ export async function inspectInstallation(options: {
           ownerManifest,
           ownerLock,
           dependency,
+          section,
+          dual,
           scope,
         },
       }
@@ -320,6 +360,8 @@ export async function inspectInstallation(options: {
         owner: repository.owner,
         repository: repository.repository,
         dependency,
+        section,
+        dual,
         scope,
       },
     }

package/packages/core/src/cli/self-update.ts

@@ -1,3 +1,4 @@
+import { readFile, writeFile } from 'node:fs/promises'
 import semver from 'semver'
 import type { ExecResult } from '../ports/workspace/git-worktree'
 import { registryBaseUrl, registryVersionUrl } from '../registry'
@@ -230,6 +231,36 @@ export function updateDependency(install: ManagedInstallation, version: string):
     : `${install.packageName}@${version}`
 }
 
+/** The specifier written into package.json for a resolved version: what
+ * `bun add <pkg>@<version>` writes (the exact version) for the registry, the tag for a forge. */
+function manifestSpecifier(install: ManagedInstallation, version: string): string {
+  return install.channel === 'github'
+    ? `github:${install.owner}/${install.repository}#v${version}`
+    : version
+}
+
+/** Set the package's specifier in every section that declares it, preserving
+ * key order, indentation, and the trailing newline. Returns the new bytes. */
+export function rewriteDeclaredSpecifiers(
+  manifestText: string,
+  packageName: string,
+  specifier: string,
+): string {
+  const manifest = JSON.parse(manifestText) as Record<string, unknown>
+  for (const section of ['dependencies', 'devDependencies']) {
+    const entries = manifest[section]
+    if (
+      typeof entries === 'object' &&
+      entries !== null &&
+      typeof (entries as Record<string, unknown>)[packageName] === 'string'
+    ) {
+      ;(entries as Record<string, unknown>)[packageName] = specifier
+    }
+  }
+  const indent = /^([ \t]+)"/m.exec(manifestText)?.[1] ?? 2
+  return JSON.stringify(manifest, null, indent) + (manifestText.endsWith('\n') ? '\n' : '')
+}
+
 /** Silently determine whether this installation has a newer published release.
  * This read-only courtesy intentionally collapses every unsupported install,
  * command failure, malformed response, and cancellation to no result. */
@@ -244,7 +275,9 @@ export async function availableRelease(
     const identity = await readDistributionIdentity(distRoot)
     if (identity.sourceCheckout || signalAborted(options.signal)) return undefined
 
-    const globalBin = await command(['bun', 'pm', 'bin', '-g'], { signal: options.signal })
+    const globalBin = await command(['bun', 'pm', 'bin', '-g'], {
+      signal: options.signal,
+    })
     if (
       globalBin.exitCode !== 0 ||
       globalBin.stdout.trim() === '' ||
@@ -369,11 +402,53 @@ export async function selfUpdate(options: SelfUpdateOptions): Promise<SelfUpdate
     options.stdout(
       `Updating Autobuild to v${resolved} in ${install.ownerRoot}; Bun will rewrite ${install.ownerManifest} and ${install.ownerLock}.`,
     )
-    updateCommand = ['bun', 'add', '--cwd', install.ownerRoot, dependency]
+    if (install.dual) {
+      // Bun cannot reconcile two differing specifiers through `bun add`: it
+      // exits 0 yet keeps the old version. Bring both entries to the new
+      // specifier and let `bun install` apply it.
+      options.stdout(
+        `${install.packageName} is declared in both dependencies and devDependencies; updating both entries.`,
+      )
+      updateCommand = ['bun', 'install', '--cwd', install.ownerRoot]
+    } else {
+      updateCommand = [
+        'bun',
+        'add',
+        '--cwd',
+        install.ownerRoot,
+        ...(install.section === 'devDependencies' ? ['-d'] : []),
+        dependency,
+      ]
+    }
+  }
+
+  let originalManifest: string | undefined
+  if (install.scope === 'local' && install.dual) {
+    try {
+      originalManifest = await readFile(install.ownerManifest, 'utf8')
+      await writeFile(
+        install.ownerManifest,
+        rewriteDeclaredSpecifiers(
+          originalManifest,
+          install.packageName,
+          manifestSpecifier(install, resolved),
+        ),
+      )
+    } catch (error) {
+      const reason = `rewriting ${install.ownerManifest}: ${error instanceof Error ? error.message : String(error)}`
+      if (explicit) {
+        options.stderr(`self-update failed: ${reason}`)
+        return { kind: 'failed' }
+      }
+      return warn(options, reason)
+    }
   }
 
   const update = await invoke(updateCommand, {})
   if (update.exitCode !== 0) {
+    if (originalManifest !== undefined) {
+      await writeFile(install.ownerManifest, originalManifest).catch(() => undefined)
+    }
     const reason = commandFailure(`installing v${resolved}`, update)
     if (explicit) {
       options.stderr(`self-update failed: ${reason}`)

package/packages/core/src/cli/status.ts

@@ -205,7 +205,7 @@ function leaseInfo(record: BuildRecord, now: Date): LeaseInfo {
  * The summary over an ALREADY-reduced state — so `detail` reduces the log
  * once and builds both projections from it, rather than reducing twice.
  */
-function summarizeFrom(record: BuildRecord, state: BuildState, now: Date): BuildSummary {
+export function summarizeFrom(record: BuildRecord, state: BuildState, now: Date): BuildSummary {
   // `phase`, `round`, and `attempt` describe ONE phase occurrence, so they come
   // from ONE source: the in-flight phase, else the last completed one — the
   // same `currentPhase ?? lastCompletedPhase` the reducer uses to derive