spexcode 0.6.8 → 0.7.0-next.0

package/node_modules/@spexcode/session-application/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-application",
-  "version": "0.6.8",
+  "version": "0.7.0-next.0",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Adopter-owned composition of session protocol and topology transactions.",
@@ -16,10 +16,10 @@
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-events": "0.6.8",
-    "@spexcode/session-protocol": "0.6.8",
-    "@spexcode/session-runtime": "0.6.8",
-    "@spexcode/session-topology": "0.6.8"
+    "@spexcode/session-events": "0.7.0-next.0",
+    "@spexcode/session-protocol": "0.7.0-next.0",
+    "@spexcode/session-runtime": "0.7.0-next.0",
+    "@spexcode/session-topology": "0.7.0-next.0"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/session-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-events",
-  "version": "0.6.8",
+  "version": "0.7.0-next.0",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Append-only session facts and deterministic ordered replay inputs.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.6.8" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.0" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/session-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-protocol",
-  "version": "0.6.8",
+  "version": "0.7.0-next.0",
   "type": "module",
   "description": "A durable SQLite session message protocol.",
   "files": [

package/node_modules/@spexcode/session-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-runtime",
-  "version": "0.6.8",
+  "version": "0.7.0-next.0",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Adopter-owned bindings between protocol addresses and native runtime identities.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.6.8" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.0" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/session-selflaunch/dist/locality.d.ts

@@ -10,11 +10,22 @@ export interface FilesystemClassification {
 export declare function classifyFilesystemType(type: number | bigint): FilesystemClassification;
 export interface LocalityDetector {
     readonly platform: string;
-    statfsType(parentPath: string): number | bigint;
+    readonly classify?: (parentPath: string) => FilesystemClassification;
 }
+export declare const linuxLocalityDetector: (statfsType: (parentPath: string) => number | bigint) => LocalityDetector;
+interface DarwinMountEntry {
+    readonly mountPoint: string;
+    readonly fstype: string;
+    readonly flags: ReadonlySet<string>;
+}
+export declare function parseDarwinMountTable(output: string): DarwinMountEntry[];
+export declare function classifyDarwinMount(mountTable: string, resolvedPath: string): FilesystemClassification;
+export declare const darwinLocalityDetector: (readMountTable: () => string) => LocalityDetector;
 export declare function requireLocalDatabasePathWithDetector(databasePath: string, options: {
     assumeLocal?: boolean;
 }, detector: LocalityDetector): string;
+export declare function localityDetectorForPlatform(platform: string): LocalityDetector;
 export declare function requireLocalDatabasePath(databasePath: string, options?: {
     assumeLocal?: boolean;
 }): string;
+export {};

package/node_modules/@spexcode/session-selflaunch/dist/locality.js

@@ -1,4 +1,5 @@
-import { statfsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { realpathSync, statSync, statfsSync } from 'node:fs';
 import { isAbsolute, dirname } from 'node:path';
 import { DatabasePathError } from './path.js';
 export class LocalityError extends Error {
@@ -44,6 +45,54 @@ export function classifyFilesystemType(type) {
         return { locality: 'local', name: local.name };
     return { locality: 'undetermined', name: `0x${magic.toString(16)}` };
 }
+export const linuxLocalityDetector = (statfsType) => ({
+    platform: 'linux',
+    classify: parentPath => classifyFilesystemType(statfsType(parentPath)),
+});
+// Darwin filesystem type names that are network transports even when the mount table omits MNT_LOCAL. `local`
+// wins when present (it is the kernel's own verdict); this list only names the refusal, so the operator reads
+// "smbfs" instead of a bare "undetermined".
+const DARWIN_NETWORK_FILESYSTEM_NAMES = new Set(['nfs', 'smbfs', 'afpfs', 'webdav', 'cifs', 'ftp']);
+// `/sbin/mount` prints one `<device> on <mount point> (<fstype>, <flag>, …)` line per mount. The mount point may
+// contain spaces (`/Volumes/My Disk`); the parenthesised list is always last and never contains `)`.
+const DARWIN_MOUNT_LINE = /^.+ on (.+) \(([^)]*)\)$/;
+export function parseDarwinMountTable(output) {
+    const entries = [];
+    for (const line of output.split('\n')) {
+        const match = DARWIN_MOUNT_LINE.exec(line.trim());
+        if (!match)
+            continue;
+        const [fstype = '', ...flags] = match[2].split(',').map(part => part.trim()).filter(Boolean);
+        entries.push({ mountPoint: match[1], fstype, flags: new Set(flags) });
+    }
+    return entries;
+}
+const mountPointCovers = (mountPoint, path) => mountPoint === '/' || path === mountPoint || path.startsWith(mountPoint.endsWith('/') ? mountPoint : `${mountPoint}/`);
+export function classifyDarwinMount(mountTable, resolvedPath) {
+    let entry;
+    for (const candidate of parseDarwinMountTable(mountTable)) {
+        if (!mountPointCovers(candidate.mountPoint, resolvedPath))
+            continue;
+        if (!entry || candidate.mountPoint.length > entry.mountPoint.length)
+            entry = candidate;
+    }
+    if (!entry)
+        return { locality: 'undetermined', name: 'no mount table entry' };
+    if (entry.flags.has('local'))
+        return { locality: 'local', name: entry.fstype };
+    if (DARWIN_NETWORK_FILESYSTEM_NAMES.has(entry.fstype))
+        return { locality: 'network', name: entry.fstype };
+    return { locality: 'undetermined', name: entry.fstype };
+}
+export const darwinLocalityDetector = (readMountTable) => ({
+    platform: 'darwin',
+    classify: parentPath => {
+        // `mount` never fails for a missing directory, so the parent's absence must be raised here for the resolver
+        // to keep its actionable PROTOCOL_PATH_PARENT_MISSING error.
+        statSync(parentPath);
+        return classifyDarwinMount(readMountTable(), realpathSync(parentPath));
+    },
+});
 export function requireLocalDatabasePathWithDetector(databasePath, options, detector) {
     if (!isAbsolute(databasePath)) {
         throw new DatabasePathError('PROTOCOL_PATH_NOT_ABSOLUTE', 'databasePath must be absolute before locality detection');
@@ -51,12 +100,12 @@ export function requireLocalDatabasePathWithDetector(databasePath, options, dete
     if (options.assumeLocal)
         return databasePath;
     const parent = dirname(databasePath);
-    if (detector.platform !== 'linux') {
+    if (!detector.classify) {
         throw new LocalityError('LOCALITY_DETECTOR_UNAVAILABLE', `no filesystem locality detector for platform ${detector.platform}; pass --assume-local-storage only after auditing ${parent}`);
     }
-    let type;
+    let classification;
     try {
-        type = detector.statfsType(parent);
+        classification = detector.classify(parent);
     }
     catch (error) {
         // @@@missing-parent - Preserve the actionable path error without pretending locality was established.
@@ -65,7 +114,6 @@ export function requireLocalDatabasePathWithDetector(databasePath, options, dete
         }
         throw new LocalityError('LOCALITY_PROBE_FAILED', `could not determine the filesystem of ${parent}`, error);
     }
-    const classification = classifyFilesystemType(type);
     if (classification.locality === 'network') {
         throw new LocalityError('LOCALITY_NETWORK_FILESYSTEM', `${parent} is ${classification.name}; advisory locking is not admitted there`);
     }
@@ -74,10 +122,14 @@ export function requireLocalDatabasePathWithDetector(databasePath, options, dete
     }
     return databasePath;
 }
-const linuxDetector = {
-    platform: process.platform,
-    statfsType: parentPath => statfsSync(parentPath).type,
-};
+const readDarwinMountTable = () => execFileSync('/sbin/mount', [], { encoding: 'utf8', timeout: 5_000, stdio: ['ignore', 'pipe', 'ignore'] });
+export function localityDetectorForPlatform(platform) {
+    if (platform === 'linux')
+        return linuxLocalityDetector(parentPath => statfsSync(parentPath).type);
+    if (platform === 'darwin')
+        return darwinLocalityDetector(readDarwinMountTable);
+    return { platform };
+}
 export function requireLocalDatabasePath(databasePath, options = {}) {
-    return requireLocalDatabasePathWithDetector(databasePath, options, linuxDetector);
+    return requireLocalDatabasePathWithDetector(databasePath, options, localityDetectorForPlatform(process.platform));
 }

package/node_modules/@spexcode/session-selflaunch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-selflaunch",
-  "version": "0.6.8",
+  "version": "0.7.0-next.0",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "A fail-closed self-launch adopter for the SpexCode session protocol.",
@@ -24,8 +24,8 @@
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-protocol": "0.6.8",
-    "@spexcode/session-runtime": "0.6.8"
+    "@spexcode/session-protocol": "0.7.0-next.0",
+    "@spexcode/session-runtime": "0.7.0-next.0"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/session-topology/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-topology",
-  "version": "0.6.8",
+  "version": "0.7.0-next.0",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "A neutral SQLite relation model for session addresses.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.6.8" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.0" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/spec-cli/bin/spex.mjs

@@ -2,7 +2,8 @@
 // @@@ spex launcher ([[release-launcher]]) - package installs execute the package's compiled CLI directly;
 // tsx remains a development tool and never enters an adopter's runtime closure.
 import { spawn, spawnSync } from 'node:child_process'
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs'
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
 
@@ -16,7 +17,19 @@ const workspace = join(pkg, '..')
 // carry unresolved conflict markers, so hooks keep the retryable exit-75 contract during a merge.
 const sourceRoot = join(pkg, 'src')
 if (existsSync(sourceRoot)) {
-  const srcRoots = [sourceRoot, join(pkg, '..', 'packages', 'spec-core', 'src'), join(pkg, '..', 'spec-eval', 'src'), join(pkg, '..', 'spec-forge', 'src')]
+  const buildTargets = [
+    ['packages/session-protocol', 'dist/index.js'],
+    ['packages/session-topology', 'dist/index.js'],
+    ['packages/session-runtime', 'dist/index.js'],
+    ['packages/session-events', 'dist/index.js'],
+    ['packages/session-application', 'dist/index.js'],
+    ['packages/session-selflaunch', 'dist/index.js'],
+    ['packages/spec-core', 'dist/index.js'],
+    ['spec-eval', 'dist/index.js'],
+    ['spec-forge', 'dist/index.js'],
+    ['spec-cli', 'dist/cli.js'],
+  ]
+  const srcRoots = buildTargets.map(([packagePath]) => join(pkg, '..', packagePath, 'src'))
   const conflicted = srcRoots.flatMap((root) => {
     if (!existsSync(root)) return []
     return readdirSync(root, { recursive: true })
@@ -34,8 +47,10 @@ if (existsSync(sourceRoot)) {
   }
 
   // @@@ source-workspace build ([[release-launcher]]) - the git hooks invoke this launcher straight from a
-  // checkout, where dist is intentionally untracked. Rebuild the complete runtime closure before linting
-  // candidate source; an installed package has no src tree and stays a pure Node -> dist execution path.
+  // checkout, where dist is intentionally untracked. Import main's fresh closure and rebuild only changed
+  // packages plus dependents before linting candidate source; an untrusted baseline falls back to the complete
+  // ordered driver. Every package still publishes its dist atomically. An installed package has no src tree
+  // and stays a pure Node -> dist execution path.
   const runtimeEntries = [
     cli,
     join(workspace, 'packages', 'spec-core', 'dist', 'index.js'),
@@ -49,8 +64,9 @@ if (existsSync(sourceRoot)) {
       && !/\.d\.ts$/.test(path)
       && !/(^|[./])[^/]+\.test\.(ts|tsx|js|mjs)$/.test(path)
   }
-  const sourceIsStale = () => {
-    const newestSource = srcRoots.reduce((newest, root) => {
+  const newestRuntimeSource = (root) => {
+    const roots = buildTargets.map(([packagePath]) => join(root, packagePath, 'src'))
+    return roots.reduce((newest, root) => {
       if (!existsSync(root)) return newest
       for (const entry of readdirSync(root, { recursive: true })) {
         const path = join(root, String(entry))
@@ -60,6 +76,94 @@ if (existsSync(sourceRoot)) {
       }
       return newest
     }, 0)
+  }
+  const newestPackageSource = (root, packagePath) => {
+    const source = join(root, packagePath, 'src')
+    if (!existsSync(source)) return 0
+    let newest = 0
+    const visit = (dir) => {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const path = join(dir, entry.name)
+        if (entry.isDirectory()) visit(path)
+        else if (isRuntimeSource(path)) {
+          try { newest = Math.max(newest, statSync(path).mtimeMs) } catch { /* retry on the next launch */ }
+        }
+      }
+    }
+    visit(source)
+    return newest
+  }
+  const entriesAreFresh = (root) => {
+    const newestSource = newestRuntimeSource(root)
+    return buildTargets.every(([packagePath, entry]) => {
+      try { return statSync(join(root, packagePath, entry)).mtimeMs >= newestSource } catch { return false }
+    })
+  }
+  const packageFingerprint = (root, packagePath) => {
+    const hash = createHash('sha256')
+    const packageRoot = join(root, packagePath)
+    const files = ['package.json', 'tsconfig.build.json'].map((name) => join(packageRoot, name)).filter(existsSync)
+    const visit = (dir, relative = '') => {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const path = join(dir, entry.name)
+        const child = relative ? `${relative}/${entry.name}` : entry.name
+        if (entry.isDirectory()) visit(path, child)
+        else if (isRuntimeSource(path)) files.push(path)
+      }
+    }
+    const source = join(packageRoot, 'src')
+    if (existsSync(source)) visit(source)
+    files.sort()
+    for (const path of files) hash.update(path.slice(packageRoot.length)).update('\0').update(readFileSync(path)).update('\0')
+    return hash.digest('hex')
+  }
+  const packageDependents = {
+    'packages/session-protocol': ['packages/session-topology', 'packages/session-runtime', 'packages/session-events', 'packages/session-application', 'packages/session-selflaunch', 'spec-cli'],
+    'packages/session-topology': ['packages/session-application', 'spec-cli'],
+    'packages/session-runtime': ['packages/session-application', 'packages/session-selflaunch', 'spec-cli'],
+    'packages/session-events': ['packages/session-application', 'spec-cli'],
+    'packages/session-application': ['spec-cli'],
+    'packages/session-selflaunch': ['spec-cli'],
+    'packages/spec-core': ['spec-eval', 'spec-forge', 'spec-cli'],
+    'spec-eval': ['spec-cli'],
+    'spec-forge': ['spec-cli'],
+    'spec-cli': [],
+  }
+  const changedBuildPackages = (root) => {
+    const changed = new Set(buildTargets
+      .map(([packagePath]) => packagePath)
+      .filter((packagePath) => packageFingerprint(workspace, packagePath) !== packageFingerprint(root, packagePath)))
+    for (const [packagePath, entry] of buildTargets) {
+      try {
+        if (statSync(join(root, packagePath, entry)).mtimeMs < newestPackageSource(workspace, packagePath)) changed.add(packagePath)
+      } catch { changed.add(packagePath) }
+    }
+    for (const packagePath of [...changed]) for (const dependent of packageDependents[packagePath]) changed.add(dependent)
+    return buildTargets.map(([packagePath]) => packagePath).filter((packagePath) => changed.has(packagePath))
+  }
+  const mainRoot = (() => {
+    const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: workspace, encoding: 'utf8' })
+    if (result.status !== 0) return null
+    const commonDir = result.stdout.trim()
+    return commonDir ? dirname(commonDir) : null
+  })()
+  const reusableMainBuild = () => mainRoot && mainRoot !== workspace && entriesAreFresh(mainRoot)
+  const importMainBuild = () => {
+    for (const [packagePath] of buildTargets) {
+      const source = join(mainRoot, packagePath, 'dist')
+      const target = join(workspace, packagePath, 'dist')
+      const temporary = `${target}.from-main-${process.pid}`
+      const previous = `${target}.from-main-previous-${process.pid}`
+      rmSync(temporary, { recursive: true, force: true })
+      rmSync(previous, { recursive: true, force: true })
+      cpSync(source, temporary, { recursive: true })
+      if (existsSync(target)) renameSync(target, previous)
+      renameSync(temporary, target)
+      rmSync(previous, { recursive: true, force: true })
+    }
+  }
+  const sourceIsStale = () => {
+    const newestSource = newestRuntimeSource(workspace)
     return runtimeEntries.some((entry) => {
       try { return statSync(entry).mtimeMs < newestSource } catch { return true }
     })
@@ -90,10 +194,23 @@ if (existsSync(sourceRoot)) {
     }
     try {
       if (sourceIsStale()) {
-        const build = spawnSync('npm', ['run', 'build'], { cwd: workspace, stdio: 'inherit' })
-        if (build.error || build.status !== 0 || !existsSync(cli)) {
-          console.error('spex: source workspace build failed; fix it, then retry.')
-          process.exit(build.status ?? 1)
+        if (reusableMainBuild()) {
+          const changed = changedBuildPackages(mainRoot)
+          console.error(`spex: importing fresh runtime closure from main; rebuilding ${changed.length} package(s)`)
+          importMainBuild()
+          if (changed.length) {
+            const build = spawnSync(process.execPath, [join(workspace, 'scripts', 'build-workspaces.mjs'), ...changed], { cwd: workspace, stdio: 'inherit' })
+            if (build.error || build.status !== 0 || !existsSync(cli)) {
+              console.error('spex: source workspace selective build failed; fix it, then retry.')
+              process.exit(build.status ?? 1)
+            }
+          }
+        } else {
+          const build = spawnSync('npm', ['run', 'build'], { cwd: workspace, stdio: 'inherit' })
+          if (build.error || build.status !== 0 || !existsSync(cli)) {
+            console.error('spex: source workspace build failed; fix it, then retry.')
+            process.exit(build.status ?? 1)
+          }
         }
       }
     } finally {

package/node_modules/@spexcode/spec-cli/dist/cli.js

@@ -1831,6 +1831,25 @@ else if (cmd === 'internal') {
             process.exit(1);
         }
     }
+    else if (sub === 'codex-reopen') {
+        // A headless resume reloads its evicted thread into the shared app-server (thread/resume, no turn), so
+        // readiness — which proves online only for a RESIDENT thread — can see it. The visible TUI does this
+        // implicitly by attaching; headless has no TUI, so its launch.sh resume branch calls this.
+        const { codexReopenThread } = await import('./harness.js');
+        const sock = process.argv[4], tid = process.argv[5];
+        if (!sock || !tid) {
+            console.error('usage: spex internal codex-reopen <sock> <threadId>');
+            process.exit(2);
+        }
+        const r = await codexReopenThread(sock, tid);
+        if (r.ok) {
+            console.log('reopened');
+        }
+        else {
+            console.error(r.error);
+            process.exit(1);
+        }
+    }
     else if (sub === 'check-staged') {
         // the pre-commit hook's eval backstop: a staged stray evidence blob or malformed eval.md rejects the
         // commit. Logic lives in spec-eval; the hook shims here.

package/node_modules/@spexcode/spec-cli/dist/file-write.js

@@ -1,15 +1,27 @@
-import { copyFileSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, copyFileSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+// A differing target is replaced by rename, never rewritten in place: a concurrent reader — codex re-reading its
+// own config.toml, a harness loading its hooks file — sees the old bytes or the new bytes, never a truncated
+// middle. The replacement lands on the real file behind a symlink and keeps that file's mode.
 export function writeFileIfChanged(path, content) {
     const next = Buffer.from(content);
+    let target = path;
+    let mode;
     try {
         if (readFileSync(path).equals(next))
             return false;
+        target = realpathSync(path);
+        mode = statSync(target).mode;
     }
     catch (error) {
         if (error?.code !== 'ENOENT')
             throw error;
     }
-    writeFileSync(path, content);
+    const staged = join(dirname(target), `.${basename(target)}.${process.pid}.tmp`);
+    writeFileSync(staged, next);
+    if (mode !== undefined)
+        chmodSync(staged, mode);
+    renameSync(staged, target);
     return true;
 }
 export function copyFileIfChanged(source, target) {

package/node_modules/@spexcode/spec-cli/dist/guide.js

@@ -307,7 +307,7 @@ PORTABILITY, and picking the right one is the whole discipline:
                         below); a targeted env override (SPEXCODE_CODEX_SERVER_CMD, …) still wins at its read site.
 
 Rule of thumb — is the value TRUE FOR THE PROJECT or TRUE FOR THIS MACHINE? A branch name, a dashboard
-icon or launcher-visibility policy, upload policy, lint policy, resource and doctor health budgets, and a launcher's name+harness are project facts → committed spexcode.json. The ABSOLUTE
+icon, upload policy, lint policy, resource and doctor health budgets, and a launcher's name+harness are project facts → committed spexcode.json. The ABSOLUTE
 PATH of a launcher wrapper or a TLS cert path are machine facts → gitignored spexcode.local.json.
 Both files are optional; omit any field to take its default, except \`sessions.defaultLauncher\` when using
 \`spex session new\` or the dashboard without an explicit launcher choice.
@@ -339,13 +339,8 @@ Example — a repo whose trunk is \`staging\`, not \`main\`:
   dashboard.apiUrl  the per-project backend the dashboard proxies to (read frontend-side). For a SHARED
                     install prefer the API_URL env var; apiUrl here is the default only when the dashboard
                     lives inside the project.
-  dashboard.showHeadlessLaunchers
-                    include launchers whose harness declares itself headless in the dashboard New Session
-                    picker. Default: false. This changes dashboard visibility only; explicit CLI
-                    --launcher selection can still use every configured launcher.
 Example:
-  { "dashboard": { "title": "MyApp specs", "icon": "mdi:rocket-launch",
-                   "showHeadlessLaunchers": false } }
+  { "dashboard": { "title": "MyApp specs", "icon": "mdi:rocket-launch" } }
 
 ── HOST GATEWAY ($SPEXCODE_HOME/config.json — per-user host identity, never a project file) ──
   gateway.icon      the global /projects icon, using the same preset ids above. Default: "gateway".
@@ -403,14 +398,17 @@ A named launcher profile fixes BOTH a session's harness AND its exact launch com
 by name with --launcher/the dashboard dropdown, and the chosen name is persisted on the record so a resume
 reuses the same auth. There are NO magic built-ins: \`spex init\` SEEDS an ordinary named launcher for each
 harness the adopter SELECTED (--harness), from the template pool
-  "claude"   → { "harness": "claude",   "cmd": "claude" }
   "claude-headless" → { "harness": "claude-headless", "cmd": "claude" }
-  "codex"    → { "harness": "codex",    "cmd": "codex" }
+  "claude"   → { "harness": "claude",   "cmd": "claude" }
   "codex-headless" → { "harness": "codex-headless", "cmd": "codex --yolo" }
-  "opencode" → { "harness": "opencode", "cmd": "opencode" }
+  "codex"    → { "harness": "codex",    "cmd": "codex" }
   "opencode-headless" → { "harness": "opencode-headless", "cmd": "opencode --auto" }
-  "pi"       → { "harness": "pi",       "cmd": "pi" }
+  "opencode" → { "harness": "opencode", "cmd": "opencode" }
   "pi-headless" → { "harness": "pi-headless", "cmd": "pi" }
+  "pi"       → { "harness": "pi",       "cmd": "pi" }
+Each harness's headless (terminal-free) form leads its interactive one, and \`spex init\` makes the FIRST
+planted launcher the default — so an adoption that selects both forms of a harness creates its sessions
+headless by default, read through the dashboard's Conversation; the interactive TUI launcher is the opt-in.
 The interactive profiles preserve each harness's normal permission model. \`opencode-headless\` and
 \`codex-headless\` are deliberate seed exceptions: their terminal-free runs require \`opencode --auto\` and
 \`codex --yolo\`; interactive profiles stay plain. Other automatic-permission commands are NEVER clean-init

package/node_modules/@spexcode/spec-cli/dist/harness.d.ts

@@ -1,6 +1,5 @@
 import { type SlashCommand } from './slash-commands.js';
-import { type ExecutionTrace, type ExecutionTurn } from './execution-trace.js';
-import { type TranscriptRead, type TranscriptRange } from './transcript-reader.js';
+import { type TranscriptReader } from '@spexcode/transcript';
 import { type HarnessId } from '@spexcode/spec-core';
 export type { HarnessId } from '@spexcode/spec-core';
 export type HarnessLivenessRecord = {
@@ -123,8 +122,7 @@ export interface Harness {
     readonly events: readonly string[];
     readonly ownsRendezvous: boolean;
     readonly paneTitleIsSelfSummary: boolean;
-    executionTrace(threadId: string, turn: ExecutionTurn | null): ExecutionTrace | null;
-    readTranscript(threadId: string, range: TranscriptRange): Promise<TranscriptRead>;
+    readonly transcript: TranscriptReader;
     launchCmd(id: string, runtimeDir?: string, cmd?: string): string;
     baseCmd(cmd?: string): string;
     oneShotTurn?(prompt: string, cmd?: string): {
@@ -234,6 +232,9 @@ export declare const codexAppServerReceipt: (dir?: string) => string;
 export declare function deliverViaRendezvous(id: string, text: string, mid?: string, wallMs?: number): Promise<DispatchResult>;
 export declare function deliverViaClaudeRendezvous(id: string, text: string, mid?: string, runtimeDir?: string): Promise<DispatchResult>;
 export declare function deliverViaSocketOrWake(id: string, text: string, mid: string | undefined, coldWake: () => Promise<DispatchResult>, unprovenError: string): Promise<DispatchResult>;
+export declare function interruptViaRendezvous(id: string, harness: string, opts?: {
+    settle?: boolean;
+}): Promise<DispatchResult>;
 type JsonRpc = {
     id?: number;
     method?: string;
@@ -261,6 +262,12 @@ export declare function sessionIdentityEnvVars(): string[];
 export declare function codexLaunchCommand(id: string, codexCmd?: string, serverCmd?: string, dir?: string, attachTui?: boolean): string;
 export declare const CODEX_TURN_OBSERVER_SUBSCRIBE_MS = 30000;
 export declare function codexTurnFailureObserver(rec: HarnessDeliveryRecord, onFailure: (failure: TurnFailure) => void): FailureSubscription;
+export declare function codexReopenThread(sock: string, threadId: string, budgetMs?: number): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
 export declare const CODEX_THREAD_SOURCE_KINDS: readonly ["cli", "vscode", "exec", "appServer", "subAgent", "subAgentReview", "subAgentCompact", "subAgentThreadSpawn", "subAgentOther", "unknown"];
 export declare function codexLoadedReferenceIds(sock: string): Promise<{
     ok: true;
@@ -343,7 +350,6 @@ export type LauncherDefault = {
     error: string | null;
 };
 export declare function launcherList(root?: string): Launcher[];
-export declare function dashboardLauncherList(root?: string): Launcher[];
 export declare const MISSING_DEFAULT_LAUNCHER_ERROR = "sessions.defaultLauncher is required for a launch without --launcher; set it in spexcode.json or spexcode.local.json (for example {\"sessions\":{\"defaultLauncher\":\"claude\"}})";
 export declare function defaultLauncher(root?: string): string;
 export declare function launcherDefault(root?: string): LauncherDefault;