@logicseek/hello-cc 1.1.3 → 1.1.5

package/CHANGELOG.md

@@ -7,6 +7,7 @@ Before publishing, run:
 
 ```bash
 npm run release:check
+npm run release:artifact:check
 npm run release:notes
 npm run release:github:dry-run
 ```
@@ -16,6 +17,52 @@ the release description from the current changelog section. Use
 `npm run release:github` with `GH_TOKEN` or `GITHUB_TOKEN` only for local
 backfills.
 
+## 1.1.5
+
+### Summary
+
+Require a verified immutable package before npm publication or GitHub Release
+creation so a missing release manifest fails before publication.
+
+### Highlights
+
+- Check the versioned frozen manifest, archive digest, packaged files and modes
+  before publishing. Reject a requested version that differs from the package.
+- Include the frozen npm archive and file manifest used by release-mode
+  DeepSeek Harness acceptance; preserve all previously published tags and files.
+- Keep the 1.1.4 runtime behavior, including opted-in App inbox listener recovery.
+
+### Validation
+
+Release preflight tests cover a matching immutable package, missing manifests,
+source drift and version mismatches. DeepSeek Harness 0.2.0-rc.2 and 0.2.1-rc.3
+are checked on Linux and macOS alongside repository, Web and native workflows.
+
+## 1.1.4
+
+### Summary
+
+Restore explicitly enabled Codex App inbox listeners when their project HCC
+MCP reconnects, without manually supplying the new App server PID or queue home.
+
+### Highlights
+
+- Add per-thread `app codex auto-enable` and `auto-disable`, with recovery state
+  in `dispatch-status`. Discover the current original App through process
+  ancestry and its open queue file; store no session capability or mail body.
+- Revalidate the project owner, App installation, queue home, executable version
+  and fresh process identities on MCP startup. Preserve live manual listeners
+  and refuse unreviewed CLI versions or a different App installation.
+- Close managed listeners with MCP transport shutdown. Keep durable uncertain
+  submissions across reconnects without replay, implicit ACK or thread restore.
+
+### Validation
+
+Lifecycle tests cover MCP reconnection, per-thread opt-in and disable, ownership
+revocation, manual lease conflicts, exact runtime discovery and no replay after
+an ambiguous queue outcome. Whole-App restart and cross-device acceptance remain
+separate from these tests and from original-App MCP reconnect evidence.
+
 ## 1.1.3
 
 ### Summary

package/docs/app-bridge.md

@@ -165,6 +165,25 @@ explicit receiver ACK unblocks the next message. Timeouts, ambiguous results
 and interrupted submissions retain `uncertain` receipts without automatic
 replay. `dispatch-status` lists these receipts. Queued is not read or executed.
 
+In 1.1.4, run `app codex auto-enable` in the original App terminal to opt this
+exact current thread into recovery. The command discovers and verifies its
+original App ancestry, executable and shared queue directory; it stores no
+session token. The project's HCC MCP then manages the listener. When that MCP
+reconnects after an App restart, it validates fresh process identities and
+restores explicitly enabled threads for the same project owner and App paths.
+An already running older MCP must reconnect once to load this feature. No hook
+definition or trust setting is changed.
+
+`app codex auto-disable` stops this thread's managed listener and recovery;
+other threads, tools and mail remain. `dispatch-status` includes `recovery`
+settings separately from the live listener. A live manual watcher is preserved;
+recovery waits for its lease. The same audited CLI version fence still applies:
+an unreviewed upgrade is blocked. MCP shutdown drains its own in-flight dispatch
+and closes its listeners. Crashed or uncertain submissions are never replayed.
+This does not cold-restore threads or deliver while the App is closed. Actual
+whole-App restarts, individual CLI upgrades and cross-device acceptance require
+separate evidence; MCP reconnect and simulated tests do not establish them.
+
 Notifications include scoped commands from the exact HCC installation. The
 `hcc_inbox` `message_id` filter reads only the selected message without ACK.
 Ctrl-C stops only the watcher. The App must remain running with this thread

package/docs/app-bridge.zh-CN.md

@@ -111,6 +111,20 @@ hcc --root /absolute/project --json app codex dispatch-status
 
 当前版本官方队列源码固定于 [6905ecede7816e91373e9eabda3f6b0368fc747b](https://github.com/openai/codex/blob/6905ecede7816e91373e9eabda3f6b0368fc747b/codex-rs/tui/src/session_queue_commands.rs)，同版本 [watcher](https://github.com/openai/codex/blob/6905ecede7816e91373e9eabda3f6b0368fc747b/codex-rs/ext/queue/src/service.rs) 每十秒处理外部变化。OpenAI Docs 的 [App Server 文档](https://learn.chatgpt.com/docs/app-server) 描述了通用生命周期；队列路径另以这个版本的官方源码核验。
 
+从 1.1.4 开始，可以在原 App 的当前线程内启用自动恢复：
+
+```sh
+hcc --root /absolute/project --json app codex auto-enable
+hcc --root /absolute/project --json app codex dispatch-status
+hcc --root /absolute/project --json app codex auto-disable
+```
+
+`auto-enable` 自动从本次终端的进程祖先识别原 App server、它正在执行的 CLI 及持有的队列文件，校验后只保存当前 `CODEX_THREAD_ID` 的启用设置，不保存 session token。该项目的 HCC MCP 启动后管理监听器；App 重启后，当插件重新连接 HCC MCP 时，会按新进程身份恢复已经单独启用的线程。需要使用包含此功能的 HCC MCP；正在运行的旧版 MCP 需要先正常重新连接一次。无需修改 Hook 定义或跳过信任审核。
+
+恢复要求同一项目 owner、同一 App 安装路径和队列目录，仍只接受上述已审阅的 CLI 版本。新二进制会重新检查版本、文件及进程映射；未知升级版本显示 `blocked`，不能靠自动恢复绕过兼容性审核。`dispatch-status` 同时显示当前监听进程和 `recovery` 设置；保存的启用设置不代表进程正在运行。已在运行的手动监听器保持原状，自动恢复显示冲突，等其正常停止后再接管派送租约。`auto-disable` 仅关闭当前线程的自动恢复与受管监听器，其他线程、消息历史和 MCP 工具保留。
+
+MCP 断开时会排空自己正在执行的派送并关闭受管监听器。进程异常退出时，由既有持久化记录阻止不明确派送重试；新 MCP 不会自动重发、ACK 或恢复线程。App 关闭时不派送，也不替用户加载未打开的线程。本机整 App 重启、特定升级版本和跨设备验收，应分别记录，不能由 MCP 重连或模拟测试替代。
+
 另外仍保留端点诊断：
 
 ```sh

package/lib/cli/commands/app-bridge.mjs

@@ -14,6 +14,8 @@ export function appBridgeHelp() {
   hcc --root PROJECT app codex session
   hcc --root PROJECT app codex watch --cli ABSOLUTE_APP_EXECUTABLE --sqlite-home DIRECTORY --app-server-pid PID [--poll-ms 1000]
   hcc --root PROJECT app codex dispatch-status
+  hcc --root PROJECT app codex auto-enable
+  hcc --root PROJECT app codex auto-disable
   hcc --root PROJECT app codex disable
   hcc app claude capability --version VERSION
 
@@ -34,6 +36,9 @@ acknowledge; explicit reply/ack does. Optional watch forwards unread-message
 notifications through the audited official CLI queue to this current App thread.
 Keep watch running. It never acknowledges mail or starts/resumes a thread.
 The original App must remain running with this thread loaded and uninterrupted.
+auto-enable opts this current thread into recovery when its project MCP reconnects.
+It discovers the original App ancestry and shared queue; no PID options are needed.
+auto-disable stops its managed listener. Unreviewed CLI versions stay blocked.
 
 DSH App: use the Cordis integration (hcc dsh setup --mode cordis).
 Its inboxPollMs setting controls idle wakeup; 0 disables automatic polling.`);
@@ -44,16 +49,36 @@ export function createAppBridgeCommands() {
     if (!args.length || wantsHelp(args)) return appBridgeHelp();
     const [provider, action, ...rest] = args;
     const opts = parseOpts(rest);
-    if (provider === 'codex' && ['setup', 'session', 'call', 'mcp', 'hook', 'disable', 'status', 'watch', 'dispatch-status'].includes(action)) {
+    if (provider === 'codex' && ['setup', 'session', 'call', 'mcp', 'hook', 'disable', 'status', 'watch', 'dispatch-status', 'auto-enable', 'auto-disable'].includes(action)) {
       if (ctx.dbPath !== projectDbPath(ctx.root)) throw new CliError('BAD_ARGS', 'App cooperation uses the selected project managed database; omit --db');
       const { createCodexAppCooperation, codexShellSession, codexCooperationHook } = await import('../../integrations/codex-app-cooperation.mjs');
       const service = createCodexAppCooperation({ root: ctx.root, initialRootIdentity: ctx.initialRootIdentity });
+      if (action === 'auto-enable' || action === 'auto-disable') {
+        validateOpts(`app codex ${action}`, opts, []);
+        const sessionId = codexShellSession();
+        const { configureCodexAppRecovery } = await import('../../integrations/codex-app-recovery.mjs');
+        let runtime;
+        if (action === 'auto-enable') {
+          const { discoverCodexAppRuntime, createCodexAppQueueTransport } = await import('../../integrations/codex-app-queue.mjs');
+          runtime = discoverCodexAppRuntime();
+          await createCodexAppQueueTransport({ root: ctx.root, threadId: sessionId, ...runtime });
+          service.issueSession({ sessionId, cwd: ctx.root, source: 'codex-shell-environment' });
+        }
+        const result = configureCodexAppRecovery({ root: ctx.root, sessionId, enabled: action === 'auto-enable',
+          runtime, initialRootIdentity: ctx.initialRootIdentity });
+        printResult(ctx, result, value => value.enabled
+          ? 'Automatic recovery enabled for this thread. The project HCC MCP restores its listener when it reconnects to the same supported App installation.'
+          : 'Automatic recovery disabled for this thread. Its managed listener stops; cooperation and message history remain.');
+        return result;
+      }
       if (action === 'watch' || action === 'dispatch-status') {
         validateOpts(`app codex ${action}`, opts, action === 'watch' ? ['cli', 'sqlite-home', 'app-server-pid', 'poll-ms'] : []);
         const sessionId = codexShellSession();
         const { createCodexAppDelivery, codexAppDeliveryStatus } = await import('../../integrations/codex-app-delivery.mjs');
         if (action === 'dispatch-status') {
-          const result = codexAppDeliveryStatus({ root: ctx.root, sessionId, initialRootIdentity: ctx.initialRootIdentity });
+          const { codexAppRecoveryStatus } = await import('../../integrations/codex-app-recovery.mjs');
+          const result = { ...codexAppDeliveryStatus({ root: ctx.root, sessionId, initialRootIdentity: ctx.initialRootIdentity }),
+            recovery: codexAppRecoveryStatus({ root: ctx.root, sessionId, initialRootIdentity: ctx.initialRootIdentity }) };
           printResult(ctx, result, value => JSON.stringify(value));
           return result;
         }
@@ -97,7 +122,11 @@ export function createAppBridgeCommands() {
       if (action === 'mcp') {
         const { serveMcpStdio } = await import('../../mcp/stdio.mjs');
         if (!service.isEnabled()) throw new CliError('CODEX_APP_SCOPE_INVALID', 'Enable cooperation for this project first');
-        return serveMcpStdio({ tools: service, concurrentToolCalls: true });
+        const { createCodexAppRecoveryManager } = await import('../../integrations/codex-app-recovery.mjs');
+        const recovery = createCodexAppRecoveryManager({ root: ctx.root, initialRootIdentity: ctx.initialRootIdentity,
+          onStatus: value => process.stderr.write(JSON.stringify(value) + '\n') });
+        try { return await serveMcpStdio({ tools: service, concurrentToolCalls: true }); }
+        finally { await recovery.close(); }
       }
       if (action === 'hook') {
         let text = '';

package/lib/integrations/codex-app-cooperation.mjs

@@ -189,6 +189,15 @@ export function createCodexAppCooperation({ root, initialRootIdentity = null, no
     return { scope: { root: ctx.root, dbPath: ctx.dbPath, peer, sessionId, executorId: expected },
       connect, assertOwnership };
   }
+  function recoverySettings() {
+    const db = connect();
+    try {
+      enabled(db);
+      const prefix = 'codex-app.dispatch.recovery.';
+      return db.prepare('SELECT value FROM meta WHERE substr(key,1,?)=? LIMIT 100').all(prefix.length, prefix)
+        .map(row => JSON.parse(row.value));
+    } finally { db.close(); }
+  }
   function owned(auth, operation, transactional = false) {
     const db = connect();
     try { const run = () => { auth.assertOwnership(db); return operation(db); }; return transactional ? tx(db, run) : run(); }
@@ -270,7 +279,7 @@ export function createCodexAppCooperation({ root, initialRootIdentity = null, no
     }
   }
   return { ctx, enable, disable, isEnabled, issueSession, authority, deliveryAuthority, call,
-    list: () => structuredClone(definitions), has: name => definitions.some(item => item.name === name) };
+    recoverySettings, list: () => structuredClone(definitions), has: name => definitions.some(item => item.name === name) };
 }
 
 export function codexShellSession(env = process.env) {

package/lib/integrations/codex-app-delivery.mjs

@@ -35,6 +35,7 @@ export function codexDeliveryNotice({ root, sessionId, messageId }) {
 // Intent is durable before invoking the external queue. Ambiguous submissions
 // are retained without retry; only the receiving session can ACK the HCC mail.
 export function createCodexAppDelivery({ root, sessionId, transport, initialRootIdentity = null,
+  recoveryPolicyId = null,
   pollMs = 1000, now = () => Math.floor(Date.now() / 1000), inspect = inspectProcessIdentity,
   schedule = setInterval, unschedule = clearInterval, onStatus = () => {} } = {}) {
   if (!transport || typeof transport.enqueue !== 'function' || typeof transport.assertValid !== 'function' ||
@@ -65,7 +66,8 @@ export function createCodexAppDelivery({ root, sessionId, transport, initialRoot
       const item = JSON.parse(row.value);
       if (item.status === 'dispatching') save(db, row.key, { ...item, status: 'uncertain', reason: 'dispatcher_restarted', updatedAt: now() });
     }
-    save(db, key, { version: 1, owner, identity: identity.identity, sessionId, startedAt: now(), ready: false, lastError: null });
+    save(db, key, { version: 1, owner, identity: identity.identity, sessionId, recoveryPolicyId,
+      startedAt: now(), ready: false, lastError: null });
   }, false);
 
   async function runTick() {
@@ -153,7 +155,7 @@ export function codexAppDeliveryStatus({ root, sessionId, initialRootIdentity =
     const running = observed?.state === 'live' && compareProcessIdentity(saved.identity, observed.identity) === 'live';
     const prefix = deliveryPrefix(auth.scope.peer);
     return { peer: auth.scope.peer, sessionId, running: Boolean(running), ready: Boolean(running && saved.ready), error: saved?.lastError || null,
-      dispatcherPid: saved?.identity?.pid || null,
+      dispatcherPid: saved?.identity?.pid || null, recoveryPolicyId: running ? saved?.recoveryPolicyId || null : null,
       deliveries: db.prepare('SELECT value FROM meta WHERE substr(key,1,?)=?').all(prefix.length, prefix).map(row => JSON.parse(row.value)) };
   } finally { db.close(); }
 }

package/lib/integrations/codex-app-install.mjs

@@ -31,7 +31,7 @@ export function writeCodexCooperationPlugin({ root, directory, initialRootIdenti
       plugins: [{ name: pluginName, source: { source: 'local', path: './plugin' },
         policy: { installation: 'AVAILABLE', authentication: 'ON_INSTALL' }, category: 'Developer Tools' }] });
     write('plugin/.codex-plugin/plugin.json', { name: pluginName, version: '1.0.0',
-      description: 'Coordinate this project from the original Codex App session. Explicit session capabilities; no idle wakeup.',
+      description: 'Coordinate this project from the original Codex App session. Explicit session capabilities; optional inbox delivery.',
       author: { name: 'hello-cc' }, hooks: './hooks/hooks.json' });
     write('plugin/.mcp.json', { mcpServers: { hcc_cooperation: { command: prefix[0], args: [...prefix.slice(1), 'app', 'codex', 'mcp'],
       cwd: service.ctx.root } } });

package/lib/integrations/codex-app-queue.mjs

@@ -29,6 +29,34 @@ function runSync(command, args) {
   return result.stdout.trim();
 }
 
+// Discover only this process's ancestors. A newly launched project MCP can
+// renew an opted-in delivery after an App restart without selecting a thread
+// from a shared session_id or scanning other applications and sockets.
+export function discoverCodexAppRuntime({ pid = process.pid, sync = runSync,
+  realpath = fs.realpathSync, platform = process.platform } = {}) {
+  if (platform !== 'darwin') throw new CliError('CODEX_APP_QUEUE_UNSUPPORTED', 'Automatic App delivery is currently verified only on macOS');
+  const seen = new Set();
+  for (let depth = 0; depth < 24 && Number.isSafeInteger(pid) && pid > 1 && !seen.has(pid); depth++) {
+    seen.add(pid);
+    const match = sync('/bin/ps', ['-p', String(pid), '-o', 'ppid=', '-o', 'comm=']).match(/^\s*(\d+)\s+(.+)$/);
+    if (!match) throw invalid();
+    const parent = Number(match[1]), executable = match[2];
+    if (path.basename(executable) === 'codex') {
+      const appExecutable = sync('/bin/ps', ['-p', String(parent), '-o', 'comm=']);
+      if (/\/(?:Codex|ChatGPT)\.app\/Contents\/MacOS\/(?:Codex|ChatGPT)$/.test(appExecutable)) {
+        const files = sync('/usr/sbin/lsof', ['-nP', '-a', '-p', String(pid), '-F', 'n']);
+        const queues = [...new Set(files.split('\n').filter(line => line.startsWith('n/') &&
+          path.basename(line.slice(1)) === 'queue_1.sqlite').map(line => realpath(line.slice(1))))];
+        if (queues.length !== 1) throw invalid();
+        return { cli: realpath(executable), appServerPid: pid, sqliteHome: path.dirname(queues[0]),
+          appExecutable: realpath(appExecutable) };
+      }
+    }
+    pid = parent;
+  }
+  throw invalid();
+}
+
 // Uses the audited official queue CLI; never writes Codex SQLite or sends
 // thread/start, thread/resume, turn/start or a private socket request. Queued
 // means only queued. The original App and explicit HCC ACK prove consumption.

package/lib/integrations/codex-app-recovery.mjs

@@ -0,0 +1,159 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { CliError } from '../shared/errors.mjs';
+import { tx } from '../db/schema.mjs';
+import { createCodexAppCooperation } from './codex-app-cooperation.mjs';
+import { createCodexAppDelivery, codexAppDeliveryStatus } from './codex-app-delivery.mjs';
+import { createCodexAppQueueTransport, discoverCodexAppRuntime } from './codex-app-queue.mjs';
+
+const prefix = 'codex-app.dispatch.recovery.';
+const key = auth => prefix + auth.scope.peer;
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const get = (db, auth) => {
+  const row = db.prepare('SELECT value FROM meta WHERE key=?').get(key(auth));
+  return row ? JSON.parse(row.value) : null;
+};
+const put = (db, auth, value) => db.prepare('INSERT INTO meta(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value')
+  .run(key(auth), JSON.stringify(value));
+function owned(auth, operation) {
+  const db = auth.connect();
+  try { return tx(db, () => { auth.assertOwnership(db); return operation(db); }); }
+  finally { db.close(); }
+}
+const stateOf = setting => setting ? { enabled: setting.enabled, status: setting.status,
+  error: setting.error || null, lastStartedAt: setting.lastStartedAt || null,
+  activeHostPid: setting.activeHostPid || null } : { enabled: false, status: 'disabled', error: null };
+
+// This opt-in names one previously enrolled thread. It contains no model
+// capability, hook session_id, message body, or permission to restore a thread.
+export function configureCodexAppRecovery({ root, sessionId, enabled, runtime,
+  initialRootIdentity = null, now = () => Math.floor(Date.now() / 1000) } = {}) {
+  if (!uuid.test(sessionId || '') || typeof enabled !== 'boolean' || enabled &&
+      !['cli', 'sqliteHome', 'appExecutable'].every(name => typeof runtime?.[name] === 'string' && path.isAbsolute(runtime[name]))) {
+    throw new CliError('BAD_ARGS', 'Automatic recovery requires this current App thread and a verified original runtime');
+  }
+  const service = createCodexAppCooperation({ root, initialRootIdentity });
+  const auth = service.deliveryAuthority(sessionId);
+  return owned(auth, db => {
+    const previous = get(db, auth);
+    const setting = { version: 1, policyId: randomUUID(), sessionId, peer: auth.scope.peer, owner: auth.scope.executorId,
+      enabled, status: enabled ? 'pending' : 'disabled', error: null, updatedAt: now(),
+      ...(enabled ? { runtime: { cli: runtime.cli, sqliteHome: runtime.sqliteHome, appExecutable: runtime.appExecutable } } : {}),
+      createdAt: previous?.createdAt || now() };
+    put(db, auth, setting);
+    return { root: auth.scope.root, sessionId, peer: auth.scope.peer, ...stateOf(setting) };
+  });
+}
+
+export function codexAppRecoveryStatus({ root, sessionId, initialRootIdentity = null } = {}) {
+  const auth = createCodexAppCooperation({ root, initialRootIdentity }).deliveryAuthority(sessionId);
+  const setting = owned(auth, db => get(db, auth));
+  if (setting && setting.owner !== auth.scope.executorId) return { enabled: false, status: 'revoked', error: 'CODEX_APP_SCOPE_INVALID' };
+  const state = stateOf(setting);
+  if (state.status === 'active') {
+    const listener = codexAppDeliveryStatus({ root, sessionId, initialRootIdentity });
+    if (!listener.running || listener.recoveryPolicyId !== setting.policyId) return { ...state,
+      status: listener.running ? 'blocked' : 'pending', activeHostPid: null,
+      error: listener.running ? 'CODEX_APP_DISPATCH_CONFLICT' : null };
+  }
+  return state;
+}
+
+// The original App starts this project MCP again when its plugin reconnects.
+// That new process supplies fresh App/server ancestry. Only explicitly saved
+// policies for this project and exact executable/home may start a dispatcher.
+// The manager owns no App lifecycle and never starts/resumes/forks a thread.
+export function createCodexAppRecoveryManager({ root, initialRootIdentity = null,
+  discover = discoverCodexAppRuntime, createTransport = createCodexAppQueueTransport,
+  createDelivery = createCodexAppDelivery, schedule = setInterval, unschedule = clearInterval,
+  now = () => Math.floor(Date.now() / 1000), onStatus = () => {} } = {}) {
+  const service = createCodexAppCooperation({ root, initialRootIdentity });
+  const active = new Map();
+  let closed = false, closing = false, currentTick = null, runtime = null;
+  function update(auth, setting, values) {
+    owned(auth, db => {
+      const current = get(db, auth);
+      if (!current || current.owner !== setting.owner || current.policyId !== setting.policyId || !current.enabled) return;
+      if (Object.entries(values).every(([name, value]) => current[name] === value)) return;
+      put(db, auth, { ...current, ...values });
+    });
+  }
+  const notify = value => { try { onStatus(value); } catch {} };
+  async function runTick() {
+    let settings;
+    try { settings = service.isEnabled() ? service.recoverySettings() : []; }
+    catch (error) {
+      for (const item of active.values()) await item.delivery.close();
+      active.clear();
+      notify({ error: error instanceof CliError ? error.code : 'CODEX_APP_RECOVERY_FAILED' });
+      return;
+    }
+    const enabled = new Map(settings.filter(item => item.enabled === true).map(item => [item.peer, item]));
+    for (const [peer, item] of active) {
+      const setting = enabled.get(peer);
+      if (!setting || setting.owner !== item.setting.owner || setting.policyId !== item.setting.policyId) {
+        await item.delivery.close(); active.delete(peer);
+      }
+    }
+    for (const setting of enabled.values()) {
+      if (closing) break;
+      let auth;
+      try {
+        auth = service.deliveryAuthority(setting.sessionId);
+        if (setting.version !== 1 || !uuid.test(setting.policyId || '') || setting.peer !== auth.scope.peer || setting.owner !== auth.scope.executorId) {
+          throw new CliError('CODEX_APP_SCOPE_INVALID', 'Automatic recovery policy belongs to a previous cooperation owner');
+        }
+        if (!active.has(setting.peer)) {
+          const existing = codexAppDeliveryStatus({ root: service.ctx.root, sessionId: setting.sessionId, initialRootIdentity });
+          if (existing.running && existing.recoveryPolicyId === setting.policyId) {
+            // Several App threads can hold a project MCP connection. Reuse
+            // that policy's live listener without changing or closing its lease.
+            update(auth, setting, { status: existing.ready ? 'active' : 'blocked',
+              error: existing.error, activeHostPid: existing.dispatcherPid });
+            continue;
+          }
+          if (existing.running) throw new CliError('CODEX_APP_DISPATCH_CONFLICT', 'A different live dispatcher owns this thread');
+          runtime ||= await discover();
+          if (!['cli', 'sqliteHome', 'appExecutable'].every(name => runtime[name] === setting.runtime?.[name])) {
+            throw new CliError('CODEX_APP_RECOVERY_RUNTIME_CHANGED', 'This MCP belongs to a different App installation or queue home');
+          }
+          const transport = await createTransport({ root: service.ctx.root, threadId: setting.sessionId, ...runtime });
+          if (closing) break;
+          const delivery = createDelivery({ root: service.ctx.root, sessionId: setting.sessionId,
+            initialRootIdentity, transport, recoveryPolicyId: setting.policyId,
+            schedule: () => null, unschedule: () => {}, onStatus: notify });
+          active.set(setting.peer, { delivery, setting });
+          update(auth, setting, { status: 'active', error: null, lastStartedAt: now(), activeHostPid: process.pid });
+          notify({ peer: setting.peer, status: 'active', automaticRecovery: true });
+        }
+        const item = active.get(setting.peer);
+        await item.delivery.tick();
+        if (item.delivery.status().error) {
+          throw new CliError(item.delivery.status().error, 'Automatic delivery stopped pending runtime validation');
+        }
+      } catch (error) {
+        const item = active.get(setting.peer);
+        if (item) { await item.delivery.close(); active.delete(setting.peer); }
+        const code = error instanceof CliError ? error.code : 'CODEX_APP_RECOVERY_FAILED';
+        // Failures never break the MCP protocol or relax its per-call scope.
+        if (auth) try { update(auth, setting, { status: 'blocked', error: code, activeHostPid: null }); } catch {}
+      }
+    }
+  }
+  function tick() {
+    if (closed || closing) return Promise.resolve();
+    if (!currentTick) currentTick = runTick().finally(() => { currentTick = null; });
+    return currentTick;
+  }
+  const timer = schedule(() => { void tick().catch(() => {}); }, 1000);
+  void tick().catch(() => {});
+  return {
+    tick,
+    async close() {
+      if (closed) return;
+      closing = true; unschedule(timer); await currentTick;
+      for (const item of active.values()) await item.delivery.close();
+      active.clear(); closed = true;
+    }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logicseek/hello-cc",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Local control plane for coordinating Claude Code, Codex, and other coding CLI sessions.",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
   "scripts": {
     "release:notes": "node ./scripts/release-notes.mjs",
     "release:check": "node ./scripts/release-notes.mjs --check",
+    "release:artifact:check": "node ./scripts/dsh-package-provenance.mjs --check-release",
     "release:github": "node ./scripts/github-release.mjs",
     "release:github:dry-run": "node ./scripts/github-release.mjs --dry-run",
     "smoke": "node ./bin/hcc.mjs --help",
@@ -41,7 +42,7 @@
     "build:native:cwd-handoff": "node ./scripts/build-cwd-handoff.mjs",
     "release:native:verify": "node ./scripts/verify-cwd-handoff-package.mjs",
     "release:native:pack": "node ./scripts/pack-cwd-handoff.mjs",
-    "prepublishOnly": "npm run release:native:verify"
+    "prepublishOnly": "npm run release:check && npm run release:artifact:check && npm run release:native:verify"
   },
   "repository": {
     "type": "git",

package/scripts/dsh-package-provenance.mjs

@@ -2,11 +2,13 @@
 // Harness, calling a model, changing an archive, or publishing a package.
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { DSH_BASELINE_VERSION, DSH_SUPPORTED_VERSIONS } from '../lib/integrations/dsh-versions.mjs';
+import { normalizeVersion } from '../lib/release/release-notes.mjs';
 
 const ARCHIVED_BASELINE = 'docs/verification/dsh-1.0.3-package.json';
 const hash = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
@@ -69,7 +71,9 @@ export function freezeAcceptancePackage({ root, repo = fileURLToPath(new URL('..
   const run = (command, args) => execFileSync(command, args, { cwd: repo, env: childEnv, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
   const npm = args => env.npm_execpath
     ? run(process.execPath, [env.npm_execpath, ...args]) : run('npm', args);
-  const metadata = JSON.parse(npm(['pack', '--ignore-scripts', '--json', '--pack-destination', path.join(root, 'candidate')]))[0];
+  // A parent npm publish --dry-run exports npm_config_dry_run. The preflight
+  // still needs real local archive bytes in order to verify the package.
+  const metadata = JSON.parse(npm(['pack', '--ignore-scripts', '--dry-run=false', '--json', '--pack-destination', path.join(root, 'candidate')]))[0];
   if (env.GITHUB_REF?.startsWith('refs/tags/v')) {
     assert.equal(mode, 'release', 'Version tags require immutable release acceptance');
     assert.equal(env.GITHUB_REF.slice('refs/tags/v'.length), metadata.version, 'Version tag must match the package version');
@@ -103,17 +107,40 @@ export function freezeAcceptancePackage({ root, repo = fileURLToPath(new URL('..
   return receipt;
 }
 
+export function checkReleaseArtifact({ repo, env = process.env, version } = {}) {
+  const expectedVersion = version ? normalizeVersion(version) : null;
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-release-artifact-check-'));
+  try {
+    const receipt = freezeAcceptancePackage({ repo, root, mode: 'release',
+      env: { ...env, GITHUB_OUTPUT: '' } });
+    if (expectedVersion) assert.equal(receipt.package.version, expectedVersion,
+      'Requested release must match the checked package version');
+    return receipt;
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
 if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
   try {
     const options = new Map();
-    for (let index = 2; index < process.argv.length; index += 2) {
-      const key = process.argv[index], value = process.argv[index + 1];
-      assert.ok(['--mode', '--output-dir'].includes(key) && value && !value.startsWith('--'), `Invalid option: ${key}`);
+    for (let index = 2; index < process.argv.length; index += 1) {
+      const key = process.argv[index];
+      if (key === '--check-release') { options.set(key, true); continue; }
+      const value = process.argv[++index];
+      assert.ok(['--mode', '--output-dir', '--version'].includes(key) && value && !value.startsWith('--'), `Invalid option: ${key}`);
       options.set(key, value);
     }
-    const mode = options.get('--mode') || resolveAcceptanceMode({ eventName: process.env.GITHUB_EVENT_NAME,
-      ref: process.env.GITHUB_REF, dispatchMode: process.env.HCC_DSH_DISPATCH_MODE });
-    console.log(JSON.stringify(freezeAcceptancePackage({ root: options.get('--output-dir') || process.env.HCC_DSH_ACCEPTANCE_ROOT, mode }), null, 2));
+    if (options.get('--check-release')) {
+      assert.ok(!options.has('--mode') && !options.has('--output-dir'),
+        '--check-release uses release mode and its own temporary directory');
+      console.log(JSON.stringify(checkReleaseArtifact({ version: options.get('--version') }), null, 2));
+    } else {
+      assert.ok(!options.has('--version'), '--version requires --check-release');
+      const mode = options.get('--mode') || resolveAcceptanceMode({ eventName: process.env.GITHUB_EVENT_NAME,
+        ref: process.env.GITHUB_REF, dispatchMode: process.env.HCC_DSH_DISPATCH_MODE });
+      console.log(JSON.stringify(freezeAcceptancePackage({ root: options.get('--output-dir') || process.env.HCC_DSH_ACCEPTANCE_ROOT, mode }), null, 2));
+    }
   } catch (error) {
     const details = String(error.stack || error.message || error).replaceAll('%', '%25').replaceAll('\r', '%0D').replaceAll('\n', '%0A');
     console.error(`::error::${details}`); process.exitCode = 1;