refactor(cmdline)!: an app's entrypoint provides values its rows read

Replaces the patch round trip. An app's entrypoint resolves the command
line into a service, and the rows it configures read that service from
their own config — port: !!js ctx.get('webStartup')?.port ?? 3080 — so the
resolved value beats the value written beside it and nothing is written
back into a row or handed to the launcher.

A bundle names the entrypoint row in its manifest (dsh.bundle.entrypoint),
which is what lets the boot mount in two passes: entrypoints alone, then
the whole composition. That ordering is required, not cosmetic — a row's
config expressions are evaluated when the include applies the row, and a
strict ctx.get only answers for a service whose providing fiber is already
active.

What this removes: ctx.appPatches and the launcher-owned patch layer, the
disable/re-enable recycle and its in-flight-mount barrier, overrideConfig,
and the reload hazard they existed for. A live config edit now re-applies
the second pass against services that are still up, so a served port
survives by construction.

What it adds: ctx.appReady, because Loader settlement no longer means the
app is up — a row mounted in the second pass can observe a settled tree
while that pass is still running, or already rolling back. The web URL line
waits for it, so a boot that fails in the second pass announces nothing.

packages/boot/app-boot/tests/profile.spec.ts

@@ -17,6 +17,7 @@ import {
   PROFILE_TEMPLATES,
   readProfileManifest,
   resolveBundleDir,
+  resolveEntrypoints,
   resolveProfileDir,
   writeProfileManifest,
 } from '../src/index.ts'
@@ -197,6 +198,37 @@ describe('loadProfile', () => {
   })
 })
 
+describe('resolveEntrypoints', () => {
+  const profile = (layers: { packageName: string; entrypoint?: string }[]): Parameters<typeof resolveEntrypoints>[1] => ({
+    name: 'p',
+    dir: '/p',
+    patchPath: '/p/cordis.patch.yml',
+    patches: [],
+    layers: layers.map(layer => ({ ...layer, packageDir: '/b', patchPath: '/b/cordis.patch.yml', patches: [] })),
+  })
+
+  it('names each bundle entrypoint in bundle order', () => {
+    expect(resolveEntrypoints(
+      'dsh',
+      profile([{ packageName: 'a' }, { packageName: 'b', entrypoint: 'b-startup' }, { packageName: 'c', entrypoint: 'c-startup' }]),
+      [{ id: 'b-startup' }, { id: 'c-startup' }, { id: 'other' }],
+    )).toEqual(['b-startup', 'c-startup'])
+  })
+
+  it('skips an entrypoint a later layer disabled, which is how one app takes over another', () => {
+    expect(resolveEntrypoints(
+      'dsh',
+      profile([{ packageName: 'web', entrypoint: 'web-startup' }, { packageName: 'one-shot', entrypoint: 'one-shot-startup' }]),
+      [{ id: 'web-startup', disabled: true }, { id: 'one-shot-startup' }],
+    )).toEqual(['one-shot-startup'])
+  })
+
+  it('fails loud when a bundle declares an entrypoint its patch never inserts', () => {
+    expect(() => resolveEntrypoints('dsh', profile([{ packageName: 'b', entrypoint: 'absent' }]), [{ id: 'other' }]))
+      .toThrow('declares entrypoint "absent", which the composed tree has no row for')
+  })
+})
+
 describe('composeEntries', () => {
   it('applies layers over an empty root and reports skipped patches', () => {
     const warnings: string[] = []

packages/boot/app-boot/tests/user-patches.spec.ts

@@ -13,7 +13,9 @@ import { Context } from '@deepseek-ai/cordis'
 import Hmr from '@deepseek-ai/cordis-plugin-hmr'
 import Loader from '@deepseek-ai/cordis-plugin-loader'
 import Timer from '@deepseek-ai/cordis-plugin-timer'
+import type { PatchOptions } from '@deepseek-ai/cordis-plugin-include'
 import {
+  applyRootPatches,
   boot,
   loadOptionalPatches,
   PROFILE_PATCH_FILENAME,
@@ -92,23 +94,81 @@ describe('loadOptionalPatches', () => {
   })
 })
 
-describe('boot with user patches', () => {
-  function writeTree(dir: string): string {
-    writeFileSync(join(dir, 'noop.mjs'), [
-      'export const name = "noop"',
-      'export function apply(_ctx, config = {}) {',
-      '  if (config.fail) throw new Error("candidate config failed")',
-      '}',
+function writeTree(dir: string): string {
+  writeFileSync(join(dir, 'noop.mjs'), [
+    'export const name = "noop"',
+    'export function apply(_ctx, config = {}) {',
+    '  if (config.fail) throw new Error("candidate config failed")',
+    '}',
+    '',
+  ].join('\n'))
+  writeFileSync(join(dir, 'cordis.yml'), '- id: noop\n  name: ./noop.mjs\n  config:\n    value: base\n')
+  return join(dir, 'cordis.yml')
+}
+
+function entryConfig(ctx: Context, id: string): unknown {
+  return [...ctx.loader.entries()].find(entry => entry.options.id === id)?.options.config
+}
+
+describe('applyRootPatches', () => {
+  it('mounts a later phase whose rows read what the first phase provided', async () => {
+    // The phased boot in one test: a row's `!!js` config is evaluated when the
+    // include applies it, so a value an earlier phase provided is what a later
+    // phase's rows read.
+    const dir = tmp()
+    writeFileSync(join(dir, 'provider.mjs'), [
+      'export const name = "provider"',
+      'export function apply(ctx) { ctx.provide("phaseOne", { value: "resolved" }) }',
       '',
     ].join('\n'))
-    writeFileSync(join(dir, 'cordis.yml'), '- id: noop\n  name: ./noop.mjs\n  config:\n    value: base\n')
-    return join(dir, 'cordis.yml')
-  }
+    writeFileSync(join(dir, 'reader.mjs'), [
+      'export const name = "reader"',
+      'export const inject = ["phaseOne"]',
+      'export function apply() {}',
+      '',
+    ].join('\n'))
+    writeFileSync(join(dir, 'cordis.yml'), '[]\n')
+    const composition: PatchOptions[] = [{
+      insert: [
+        { id: 'provider', name: './provider.mjs' },
+        {
+          id: 'reader',
+          name: './reader.mjs',
+          inject: ['phaseOne'],
+          config: { value: { __jsExpr: "ctx.get('phaseOne')?.value ?? 'fallback'" } },
+        },
+      ],
+    }]
+    const ctx = await boot(NAME, join(dir, 'cordis.yml'), [
+      ...structuredClone(composition),
+      { id: 'reader', disabled: true },
+    ])
+    try {
+      // Phase one leaves the reader disabled, so the plugin never ran.
+      const reader = [...ctx.loader.entries()].find(entry => entry.options.id === 'reader')
+      expect(reader?.fiber).toBeUndefined()
+      await applyRootPatches(ctx, structuredClone(composition))
+      // Phase two evaluates its config expression against the provided value.
+      expect(entryConfig(ctx, 'reader')).toEqual({ value: 'resolved' })
+    } finally {
+      await ctx.fiber.dispose()
+    }
+  })
 
-  function entryConfig(ctx: Context, id: string): unknown {
-    return [...ctx.loader.entries()].find(entry => entry.options.id === id)?.options.config
-  }
+  it('does nothing on a tree that was already disposed', async () => {
+    const dir = tmp()
+    const ctx = await boot(NAME, writeTree(dir))
+    await ctx.fiber.dispose()
+    await expect(applyRootPatches(ctx, [])).resolves.toBeUndefined()
+  })
 
+  it('fails loud when the tree was booted without the root include', async () => {
+    const ctx = new Context()
+    await expect(applyRootPatches(ctx, [])).rejects.toThrow('requires the root Include entry')
+  })
+})
+
+describe('boot with user patches', () => {
   it('applies id-targeted overrides, inserts, and interpolates !!js from the environment', async () => {
     const dir = tmp()
     const userDir = tmp()