@ours.network/install 1.2.1-nightly.4 → 1.2.1-nightly.41

package/assets/release.json

@@ -1,43 +1,61 @@
 {
   "schema": 1,
   "channel": "nightly",
-  "installerVersion": "1.2.1-nightly.4",
+  "installerVersion": "1.2.1-nightly.41",
   "packages": {
     "@ours.network/sdk": {
-      "version": "3.8.1-nightly.3",
-      "integrity": "sha512-iUVCs+jryoeR2Ip/uHzpkJwbpoJeLDASUaE3lC+eYDj8dbI1MBwTpeOXFemUK052O6lA4ZWrhyRgE9pJU3a+Kw=="
+      "version": "3.8.1-nightly.17",
+      "integrity": "sha512-GCPbGzh0IxFJluyRk4y1O+9419kZcnHapnr42FQKs4u2kKU7EcDRLBlINqSYgF0YUCZyZUDv/9Rk1//GKs/6oQ=="
     },
     "@ours.network/cli": {
-      "version": "2.8.1-nightly.1",
-      "integrity": "sha512-1Rmbqlr790FhqQW/wQ//YEL7b0Q2KVSCA2TlpjaLRkj9Xh55rOoazBJjFuW/fUpTz3Z1B3MUPK9LWiYd+A0kNA=="
+      "version": "2.8.1-nightly.15",
+      "integrity": "sha512-ht96LfYH7Du19YWeht+5eRsZxuF1Fobfj6sPSH+aFgWD9hYdrWTeG/5rrCTAClQflnl49Qaskk4n/TclkWrkRw=="
     },
     "@ours.network/tg-connector": {
-      "version": "1.0.1-nightly.1",
-      "integrity": "sha512-/Do7EfINknDks3yYndOi9aLc1alxB50qk+WKv8DRuZpDB89DDMQ+DoSGQerdvsMp32nQ3LICL8TPjcdFMZfx8Q=="
+      "version": "1.0.1-nightly.11",
+      "integrity": "sha512-ZT/51g+YgjCpPoYKF+6zuWhn/rAUa49Qq/mChOHZmZf2WJR16VLPGCc31LDA26kRE+kQtdkWiuGf2v0XOa7CXg=="
     },
     "@ours.network/cowork": {
-      "version": "1.3.2-nightly.20260918.4d9242e",
-      "integrity": "sha512-04D2lJ97SrTrkVRRbdTZ0y+KvQdG/bpnmFFjsyUqQTij+5zEkNizTG/xhcCL8m7Mb0XvVFL8WzJ62Xgh5ahlRw=="
+      "version": "1.3.3-nightly.20261005.f549477",
+      "integrity": "sha512-9RYvgAPrsKtzAOUSYsNLws3zhse3BvKu4Z2xC5vUYniWhyU8s2RiHO6bH7oBrjcRyjpCiFwnNpOE6oobi1Vllg=="
     },
     "@ours.network/messenger-server": {
-      "version": "1.0.31-nightly.1",
-      "integrity": "sha512-XB6N+Ppd4txmI0+2ZVFMWJxXi4DtMIDlFSHOzszNM5hopFebpw1Df+KKCK4Cgd/LZUkoOOYWGEYpib9m3RbHWw=="
+      "version": "1.0.31-nightly.17",
+      "integrity": "sha512-03qDDGRgN9pBGsBsCcvArhPuYfMblqsaXS9HinxAzOSiI3PaoNOh+4MxIAOoHXoE/12xxCDf7kbMdEAR0CPIfg=="
+    },
+    "@ours.network/notifications": {
+      "version": "0.3.1-nightly.2",
+      "integrity": "sha512-OjnrJ8ZuOfKYT4KAmiRLU7czfiuacs6rShwOvvqxqBaUKcs1UwjsYwHARNb6erMxG4am3xxcE0ItahL+d2vt4A=="
     },
     "@ours.network/fleet": {
-      "version": "1.2.0-nightly.1",
-      "integrity": "sha512-vioCobVbosmp9BgYo2XccjpPoVQd1wwV+Mt64Bm41/Vxtro2j85PUdy4AWcsY9jEFnJmj/UQfc5E5AxvlpPnrw=="
+      "version": "1.2.0-nightly.54",
+      "integrity": "sha512-Sh3t8iRGBoYzbyslS+IKuqQ573Zn+M0GVhR0cGepy/hlyNMAwXD2TBM+j7d8QiA1+ALugkMhKnanivE97JBmhQ=="
     },
     "@ours.network/mcp": {
-      "version": "1.2.0-nightly.3",
-      "integrity": "sha512-z0N5jn1jj9iwGRqU1d3AM2RX9mCr4T/WhASEKr+Vh52yNDMzhVjFlx0U0v8aS+GTfOQaPZTfL3TGMc17ETjh3g=="
+      "version": "1.2.0-nightly.13",
+      "integrity": "sha512-/SxWOeiQfOu0i+jV3su2khYQ4eUCH+exe6CjSUZ9u5FmTUfXmg7cBnPOzFT2PKbNulsSLf9vnU+QBGBwSa/Iag=="
     },
     "@ours.network/codex": {
-      "version": "1.2.0-nightly.3",
-      "integrity": "sha512-dIWDqbo6hJzujegHRO6x1SsBnh5p1c6gRGj/WkPha/hcN7s/27P4jqBnJ7czQyVGiNVFZ1aAxj4c9+CDLzHENw=="
+      "version": "1.2.0-nightly.13",
+      "integrity": "sha512-m5tcTu6QoMhrcrKgglTyG+nxe1nwRLc2t7nPJcjVRqf/5m8e9CRGqXssrioOAS/wD7qGKl2jPVwJr/0ZmMltVQ=="
     },
     "@ours.network/claude-code": {
-      "version": "1.2.0-nightly.3",
-      "integrity": "sha512-7ta6KnvoHB2i/yoaykhXvzKFQTIOPtDHeTzG1PRwHjdTJ4vcGEh4jWYMd2c1jjj73lC3q9qW3LYSRutIJovtQg=="
+      "version": "1.2.0-nightly.13",
+      "integrity": "sha512-KnVGMyZAL9i8vqFTvI3V6OEpbOqk4YH106jfeB0JlTCRkk0Oy5H1rx764GucIxmYCiasAF1NKExHe2tDLlmiXQ=="
+    },
+    "@ours.network/daemon": {
+      "version": "3.8.1-nightly.9",
+      "integrity": "sha512-KQUAmd/Ae97DcaxKFinsVuyQiREUuXp6uiv0FeOsU59patpFKUcw7gYpmifBeywnvsDVrS+XX33CubYYkpMacw=="
+    }
+  },
+  "hostCli": {
+    "@ours.network/sdk": {
+      "version": "3.8.1-nightly.17",
+      "integrity": "sha512-GCPbGzh0IxFJluyRk4y1O+9419kZcnHapnr42FQKs4u2kKU7EcDRLBlINqSYgF0YUCZyZUDv/9Rk1//GKs/6oQ=="
+    },
+    "@ours.network/cli": {
+      "version": "2.8.1-nightly.15",
+      "integrity": "sha512-ht96LfYH7Du19YWeht+5eRsZxuF1Fobfj6sPSH+aFgWD9hYdrWTeG/5rrCTAClQflnl49Qaskk4n/TclkWrkRw=="
     }
   }
 }

package/assets/scripts/build/build-common.mjs

@@ -7,7 +7,8 @@ export const ROOT = resolve(process.env.OURS_BUILD_ROOT || '/opt/ours');
 export const SOURCE_ROOT = resolve(process.env.OURS_SOURCE_ROOT || '/src');
 export const OUT = join(ROOT, 'docker/vendor');
 export const CONFIG = JSON.parse(readFileSync(join(ROOT, 'sources.json'), 'utf8'));
-export const SELECTED = new Set((process.env.OURS_BUILD_PACKAGES || 'sdk,cli,mcp,tg-connector,cowork,messenger-server').split(',').map(name => '@ours.network/' + name));
+// Notifications joined the server set later; retained selections without it still build.
+export const SELECTED = new Set((process.env.OURS_BUILD_PACKAGES || ['sdk,cli,daemon,tg-connector,cowork,messenger-server', ...(CONFIG.packages?.['@ours.network/notifications'] ? ['notifications'] : [])].join(',')).split(',').map(name => '@ours.network/' + name));
 export const inheritedLock = process.env.OURS_INSTALLER_LOCK_FD === '3' ? [3] : [];
 export const run = (args, cwd) => execFileSync(args[0], args.slice(1), { cwd, stdio: ['inherit', 'inherit', 'inherit', ...inheritedLock] });
 export const capture = (args, cwd, env = process.env) => execFileSync(args[0], args.slice(1), { cwd, env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit', ...inheritedLock] });

package/assets/scripts/build/build-sdk.mjs

@@ -2,8 +2,13 @@ import { join } from 'node:path';
 import { SOURCE_ROOT, SELECTED, pack, run } from './build-common.mjs';
 const source = join(SOURCE_ROOT, 'sdk');
 run(['npm', 'ci', '--no-audit', '--no-fund'], source);
-run(['bash', 'scripts/compile-mufl.sh'], source);
+if (SELECTED.has('@ours.network/daemon')) run(['bash', 'scripts/compile-mufl.sh'], source);
 run(['npm', 'run', 'build'], source);
 if (SELECTED.has('@ours.network/cli')) run(['npm', 'run', 'build:cli'], source);
 pack(source, '@ours.network/sdk', 'sdk');
 pack(join(source, 'packages/cli'), '@ours.network/cli', 'sdk');
+
+if (SELECTED.has('@ours.network/daemon')) {
+  run(['npm', 'run', 'build:daemon'], source);
+  pack(join(source, 'packages/daemon'), '@ours.network/daemon', 'sdk');
+}

package/assets/scripts/maintenance/build-context.mjs

@@ -8,7 +8,7 @@ import { semanticRecordEqual } from './provenance-compare.mjs';
 export const BASE_RECORDS = ['package-lock.json', 'dependency-tree.json'];
 export const CONTEXT = 'build-context.json';
 const admitted = new WeakMap();
-const packages = new Set(['sdk', 'cli', 'mcp', 'tg-connector', 'cowork', 'messenger-server', 'fleet', 'codex', 'claude-code', 'install'].map(n => '@ours.network/' + n));
+const packages = new Set(['sdk', 'cli', 'daemon', 'mcp', 'tg-connector', 'cowork', 'messenger-server', 'notifications', 'fleet', 'codex', 'claude-code', 'install'].map(n => '@ours.network/' + n));
 const digest = (bytes, algorithm = 'sha256', encoding = 'hex') => createHash(algorithm).update(bytes).digest(encoding);
 const fail = text => { throw new Error(`Build context: ${text}`); };
 const keys = (v, expected) => v && !Array.isArray(v) && typeof v === 'object' && Object.keys(v).sort().join('\0') === [...expected].sort().join('\0');

package/assets/scripts/maintenance/daemon-owner.mjs

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+// Native callers provide an exact selected executable. Compose mounts the
+// selected runtime and supplies its bin directory, including retained releases.
+export function daemonOwner(env = process.env) {
+  if (env.OURS_CLI_PATH) return env.OURS_CLI_PATH;
+  const bin = env.OURS_DAEMON_BIN_DIR;
+  if (!bin) throw new Error('daemon maintenance requires its selected executable or bin directory');
+  const daemon = join(bin, 'ours-daemon');
+  if (existsSync(daemon)) return daemon;
+  const legacy = join(bin, 'ours');
+  if (existsSync(legacy)) return legacy;
+  throw new Error('selected runtime contains no daemon administrator');
+}

package/assets/scripts/maintenance/docker-layout-conversion.mjs

@@ -6,6 +6,8 @@ import { pathToFileURL } from 'node:url';
 import { copyPrivateTree, scanSource, createArchive, validateArchive } from './state-archive.mjs';
 import { publishNoReplace } from './state-native.mjs';
 
+import { daemonOwner } from './daemon-owner.mjs';
+
 const COMPONENTS = ['daemon', 'telegram', 'cowork', 'messenger'];
 import { recordNames, readBuildRecords, validateBuildRecordSet } from './build-context.mjs';
 const DAEMON_STATE = '/var/lib/ours';
@@ -113,12 +115,14 @@ export function validateDockerLayout(tree, options) {
     const config = join(tree, component, 'config.json');
     if (fs.existsSync(config)) objectAt(config, options);
   }
+  // Fresh managed installs keep the MCP profile separately until configured.
+  // Retained embedded configuration, when present, must still match exactly.
   const daemon = objectAt(join(tree, 'daemon/config.json'), options);
   const profile = objectAt(join(tree, 'mcp/profile.json'), options);
   validateProfile(profile, options.instanceId);
   if (daemon.stateDir !== DAEMON_STATE || daemon.port !== 3050
-    || daemon.networkMcp?.applicationConfigPath !== join(MCP_STATE, 'config.json')
-    || JSON.stringify(daemon.networkMcp.profile) !== JSON.stringify(profile)
+    || (daemon.networkMcp !== undefined && (daemon.networkMcp?.applicationConfigPath !== join(MCP_STATE, 'config.json')
+      || JSON.stringify(daemon.networkMcp?.profile) !== JSON.stringify(profile)))
     || objectAt(join(tree, 'cowork/config.json'), options).stateDir !== '/var/lib/ours-cowork') {
     throw new Error('Converted Docker deployment configuration is inconsistent');
   }
@@ -207,7 +211,7 @@ export async function runDockerLayoutCommand(argv, env = process.env) {
   const build = env.OURS_BUILD_ROOT || '/opt/ours';
   const options = {
     uid: process.getuid(), gid: process.getgid(), instanceId: env.OURS_DAEMON_ID,
-    cli: env.OURS_CLI_PATH || '/opt/ours/node_modules/.bin/ours',
+    cli: daemonOwner({ OURS_DAEMON_BIN_DIR: '/opt/ours/node_modules/.bin', ...env }),
     configPath: env.OURS_DAEMON_CONFIG || '/var/lib/ours/config.json',
     provenance: readBuildRecords(build),
   };

package/assets/scripts/maintenance/recover-notifications.mjs

@@ -0,0 +1,26 @@
+/** Non-secret retained build evidence arrives on stdin, never in argv/env. */
+import * as fs from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runStateOperation } from './state-operation.mjs';
+
+const root = fs.mkdtempSync(join(tmpdir(), 'ours-notifications-recovery-'));
+fs.chmodSync(root, 0o700);
+try {
+  const evidence = JSON.parse(fs.readFileSync(0, 'utf8'));
+  if (!evidence || Object.keys(evidence).sort().join(',') !== 'phase,previous,target'
+    || !['prepared', 'state-updated', 'runtime-activated'].includes(evidence.phase)) throw new Error('Invalid recovery evidence');
+  for (const name of ['previous', 'target']) {
+    const records = evidence[name], names = Object.keys(records).sort();
+    if (!['dependency-tree.json,package-lock.json', 'build-context.json,dependency-tree.json,package-lock.json'].includes(names.join(','))) throw new Error('Invalid recovery record set');
+    const directory = join(root, name); fs.mkdirSync(directory, { mode: 0o700 });
+    for (const file of names) {
+      if (typeof records[file] !== 'string') throw new Error('Invalid recovery record bytes');
+      fs.writeFileSync(join(directory, file), Buffer.from(records[file], 'base64'), { flag: 'wx', mode: 0o600 });
+    }
+  }
+  const result = await runStateOperation(['recover-notifications', 'server', '--compatible'], {
+    ...process.env, OURS_PREVIOUS_BUILD_ROOT: join(root, 'previous'), OURS_EXPECTED_BUILD_ROOT: join(root, 'target'), OURS_RECOVERY_PHASE: evidence.phase,
+  });
+  console.log(JSON.stringify(result));
+} finally { fs.rmSync(root, { recursive: true }); }

package/assets/scripts/maintenance/release-graph.mjs

@@ -20,10 +20,19 @@ export function releaseBinding(policy) {
   if (release?.schema !== 1 || !['stable', 'nightly'].includes(release.channel)) fail('invalid release binding');
   const pattern = release.channel === 'nightly' ? nightly : stable;
   if (typeof release.installerVersion !== 'string' || !pattern.test(release.installerVersion)) fail('invalid installer version/channel');
-  if (!release.packages || JSON.stringify(Object.keys(release.packages).sort()) !== JSON.stringify([...names].sort())) fail('release must select exactly nine ours packages');
+  if (release.scope !== undefined && release.scope !== 'host-cli') fail('invalid release scope');
+  const required = release.scope === 'host-cli' ? ['@ours.network/cli', '@ours.network/sdk'] : [...names, ...['@ours.network/daemon', '@ours.network/notifications'].filter(name => release.packages?.[name])];
+  if (!release.packages || JSON.stringify(Object.keys(release.packages).sort()) !== JSON.stringify([...required].sort())) fail('release must select exactly the required ours packages');
+  if (release.scope === 'host-cli' && Object.hasOwn(release, 'hostCli')) fail('nested host CLI selection');
   for (const [name, entry] of Object.entries(release.packages)) {
     if (typeof entry?.version !== 'string' || !pattern.test(entry.version) || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(entry.integrity ?? '')) fail(`invalid release artifact: ${name}`);
   }
+  if (Object.hasOwn(release, 'hostCli')) {
+    if (!release.hostCli || Object.keys(release.hostCli).sort().join(',') !== '@ours.network/cli,@ours.network/sdk') fail('host CLI must select exactly CLI and SDK');
+    for (const [name, entry] of Object.entries(release.hostCli)) {
+      if (typeof entry?.version !== 'string' || !pattern.test(entry.version) || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(entry.integrity ?? '')) fail(`invalid host CLI artifact: ${name}`);
+    }
+  }
   if (!policy.packages || !Object.keys(policy.packages).length) fail('missing release source selection');
   for (const [name, entry] of Object.entries(policy.packages)) {
     if (entry?.type !== 'npm' || entry.version !== release.packages[name]?.version || Object.keys(entry).sort().join(',') !== 'type,version') fail(`source selection differs from release: ${name}`);
@@ -92,3 +101,11 @@ export function verifyRuntimeRelease(root) {
   if (!existsSync(path)) return { verified: false, reason: 'legacy runtime without sources' };
   return verifyReleaseGraph(root, json(path));
 }
+
+/** The client command has its own exact dependency selection, never a graph bypass. */
+export function hostCliPolicy(policy) {
+  const release = releaseBinding(policy);
+  if (!release?.hostCli) return null;
+  const { hostCli, ...base } = release;
+  return { release: { ...base, scope: 'host-cli', packages: hostCli }, packages: Object.fromEntries(Object.entries(hostCli).map(([name, p]) => [name, { type: 'npm', version: p.version }])) };
+}

package/assets/scripts/maintenance/state-operation.mjs

@@ -9,6 +9,8 @@ import { createArchive, extractArchive, validateArchive, scanSource, copyPrivate
 import { exchange, tryLock, setMtimeNs } from './state-native.mjs';
 import { recordNames, readBuildRecords, equalBuildRecords, initializeBuildMarker } from './build-context.mjs';
 
+import { daemonOwner } from './daemon-owner.mjs';
+
 const PROVENANCE = '.ours-provenance';
 const APPLICATIONS = ['daemon', 'telegram', 'cowork', 'messenger'];
 const exists = path => { try { fs.lstatSync(path); return true; } catch (e) { if (e.code === 'ENOENT') return false; throw e; } };
@@ -35,11 +37,12 @@ export async function runStateOperation(argv, env = process.env, checkpoints = {
   const operation = argv[0];
   const paired = domain === 'daemon' && ['backup', 'restore', 'reset'].includes(operation);
   const commonTree = domain === 'server' || paired;
-  if (compatible && !['restore', 'update'].includes(operation)) fail('compatibility attestation applies only to update or restore');
-  if (domain === 'server' && !['backup', 'restore', 'update', 'rebuild'].includes(operation)) fail('full-server scope supports only backup, restore, update and rebuild');
+  const recovery = operation === 'recover-notifications' && domain === 'server' && compatible;
+  if (compatible && !['restore', 'update'].includes(operation) && !recovery) fail('compatibility attestation applies only to update or restore');
+  if (domain === 'server' && !['backup', 'restore', 'update', 'rebuild'].includes(operation) && !recovery) fail('full-server scope supports only backup, restore, update and rebuild');
   if (operation === 'rebuild' && domain !== 'server') fail('rebuild selects the complete server');
   const adopt = operation === 'init' && argv[2] === '--adopt-existing';
-  const valid = (['init', 'update', 'rebuild'].includes(operation) && argv.length === 2) || (adopt && argv.length === 3) || (['backup', 'restore'].includes(operation) && argv.length === 3) || (operation === 'reset' && argv.length === 3 && argv[2] === '--confirm');
+  const valid = ((['init', 'update', 'rebuild'].includes(operation) || recovery) && argv.length === 2) || (adopt && argv.length === 3) || (['backup', 'restore'].includes(operation) && argv.length === 3) || (operation === 'reset' && argv.length === 3 && argv[2] === '--confirm');
   if (!valid) fail('usage: init DOMAIN | backup DOMAIN LABEL | restore DOMAIN LABEL | reset DOMAIN --confirm | update DOMAIN');
   const uid = process.getuid(), gid = process.getgid();
   if (!uid || !gid) fail('state maintenance requires a non-root UID and GID');
@@ -86,6 +89,14 @@ export async function runStateOperation(argv, env = process.env, checkpoints = {
   }
   function validateTree(tree, records) {
     const roots = domain === 'server' ? APPLICATIONS.map(name => join(tree, name)) : [tree];
+    // Notifications shares Messenger's service, but owns a separate state directory.
+    // Older installations/backups may contain only its empty mount placeholder.
+    // Include every retained notification generation in full-server maintenance.
+    if (domain === 'server' && exists(join(tree, 'notifications'))) {
+      const notifications = join(tree, 'notifications');
+      privateStat(notifications, true, 0o700);
+      if (exists(join(notifications, PROVENANCE))) roots.push(notifications);
+    }
     for (const root of roots) if (!sameRecords(readRecords(join(root, PROVENANCE)), records)) fail('restored component provenance does not match the archive build');
     if (domain === 'server') for (const name of ['mcp', 'credentials']) privateStat(join(tree, name), true, 0o700);
     if (paired) privateStat(join(tree, '.mcp'), true, 0o700);
@@ -145,9 +156,9 @@ export async function runStateOperation(argv, env = process.env, checkpoints = {
   }
   function retainAuthority(staging) {
     if (!['daemon', 'server'].includes(domain)) return;
-    if (!env.OURS_CLI_PATH || !env.OURS_DAEMON_CONFIG) fail('daemon maintenance requires its selected executable and configuration');
+    if (!env.OURS_DAEMON_CONFIG) fail('daemon maintenance requires its selected executable and configuration');
     const daemon = commonTree ? join(staging, 'daemon') : staging;
-    owner([env.OURS_CLI_PATH, 'config', 'access-retain', '--config', env.OURS_DAEMON_CONFIG, '--target-state-dir', daemon, '--json']);
+    owner([daemonOwner(env), 'config', 'access-retain', '--config', env.OURS_DAEMON_CONFIG, '--target-state-dir', daemon, '--json']);
     if (!commonTree) return;
     const credentials = join(live, 'credentials'), destination = join(staging, 'credentials');
     for (const name of ['telegram', 'cowork', 'messenger']) if (!privateStat(join(credentials, name, 'daemon-token'), false, 0o600).size) fail('current managed credential is empty');
@@ -174,6 +185,52 @@ export async function runStateOperation(argv, env = process.env, checkpoints = {
     try { if (!sameInode(fs.fstatSync(fd), fs.fstatSync(check))) fail('domain state changed while acquiring its lock'); }
     finally { fs.closeSync(check); }
     let records;
+    if (recovery) {
+      // Only the installer supplies the retained transition's previous and
+      // candidate records. Never infer compatibility from a mixed live tree.
+      const previous = readRecords(selected('OURS_PREVIOUS_BUILD_ROOT'), false);
+      const expected = readRecords(selected('OURS_EXPECTED_BUILD_ROOT'), false);
+      if (!sameRecords(target, expected)) fail('recovery runtime differs from the retained candidate');
+      const core = APPLICATIONS.map(name => readRecords(join(live, name, PROVENANCE)));
+      const oldCore = core.every(records => sameRecords(records, previous));
+      const newCore = core.every(records => sameRecords(records, target));
+      if (!newCore && !(env.OURS_RECOVERY_PHASE === 'prepared' && oldCore)) fail('recovery core provenance differs from the retained candidate');
+      for (const name of ['mcp', 'credentials']) privateStat(join(live, name), true, 0o700);
+      const notifications = join(live, 'notifications'), marker = join(notifications, PROVENANCE);
+      if (!exists(notifications)) return { stateUpdated: newCore };
+      privateStat(notifications, true, 0o700);
+      if (!exists(marker)) { scanSource(notifications, { uid, gid }); return { stateUpdated: newCore }; }
+      privateStat(marker, true, 0o700);
+      if (!fs.readdirSync(marker).length) { scanSource(notifications, { uid, gid }); return { stateUpdated: newCore }; }
+      const retained = readRecords(marker);
+      if (newCore && sameRecords(retained, target)) return { stateUpdated: true }; // Already repaired, including retries after exchange.
+      if (!sameRecords(retained, previous)) fail('recovery notification provenance differs from the retained previous build');
+      if (!newCore) return { stateUpdated: false }; // Prepared journal with untouched state: use the regular state operation.
+      prepare(); layout();
+      const archive = labelPath(`pre-notifications-recovery-${new Date().toISOString().replace(/[-:.]/g, '')}-${randomBytes(4).toString('hex')}`);
+      checkpoints.beforeBackup?.();
+      await createArchive(notifications, archive, { domain: 'notifications', uid, gid, provenance: previous });
+      checkpoints.afterBackup?.();
+      const staging = join(maintenance, `recovery-${randomBytes(12).toString('hex')}`);
+      try {
+        const entries = scanSource(live, { uid, gid });
+        copyTree(live, staging);
+        // Ordinary maintenance emits private copies; recovery retains every
+        // accepted payload mode and timestamp outside the replaced marker.
+        for (const entry of entries.reverse()) {
+          const path = entry.name === 'state' ? staging : join(staging, entry.name.slice(6));
+          fs.chmodSync(path, Number(entry.st.mode) & 0o777);
+          setMtimeNs(path, entry.st.mtimeNs);
+        }
+        const replacement = join(staging, 'notifications', PROVENANCE);
+        fs.rmSync(replacement, { recursive: true }); mkdir(replacement);
+        for (const name of recordNames(target)) writeRecord(join(replacement, name), target[name]);
+        setMtimeNs(dirname(replacement), fs.lstatSync(notifications, { bigint: true }).mtimeNs);
+        validateTree(staging, target);
+        replace(staging);
+      } finally { if (exists(staging)) fs.rmSync(staging, { recursive: true }); }
+      return { stateUpdated: true };
+    }
     if (domain === 'server') { records = readRecords(join(live, 'daemon', PROVENANCE)); validateTree(live, records); }
     else if (paired) { records = readRecords(join(live, 'daemon', PROVENANCE)); privateStat(join(live, 'mcp'), true, 0o700); }
     else if (operation !== 'init') records = readRecords(join(live, PROVENANCE));

package/assets/scripts/runtime/README.md

@@ -22,3 +22,10 @@ mode. Docker uses one named `server-storage` volume: `state/daemon`, `state/mcp`
 Preparation mounts the storage root; running applications mount only their own
 state children and selected credentials. Backups and maintenance staging are
 outside `state/`. The owner-lock volume contains transient runtime locks.
+
+`recover.mjs` supervises the locked entrypoints with timed health probes and three
+automatic recovery attempts per container start. It kills the entire child group
+and waits for lock release before a new generation. Exhaustion holds unhealthy
+until explicit restart. `dependency-ready.mjs` waits for the authenticated pinned
+daemon without consuming the consumer's failure circuit. Host boot still depends
+on an independently configured Docker Engine or Desktop startup.

package/assets/scripts/runtime/client-setup.mjs

@@ -1,8 +1,9 @@
 import { readBuildRecords, initializeBuildMarker } from '../maintenance/build-context.mjs';
+import { redactDiagnostic } from './diagnostics.mjs';
 import { spawnSync } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
+import { generateKeyPairSync, randomBytes } from 'node:crypto';
 import {
-  closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync,
+  existsSync, closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync,
   realpathSync, renameSync, unlinkSync, writeFileSync, readdirSync, chmodSync, chownSync,
 } from 'node:fs';
 
@@ -12,6 +13,7 @@ const DELIVERY_FILES = [
   '/credentials/messenger/daemon-token',
 ];
 const fail = (message) => { throw new Error(message); };
+let diagnosticStage = 'validation';
 const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 
 function privatePath(path, directory, exact = directory ? 0o700 : 0o600) {
@@ -67,7 +69,7 @@ function validateCommon(idName = 'OURS_DAEMON_ID') {
 
 function composeConfig(domain) {
   if (domain === 'daemon') {
-    const value = { stateDir: '/var/lib/ours', port: 3050, apiVisibility: 'owner', networkMcp: { profile: { endpoint: 'http://127.0.0.1:3050', expectedInstanceId: process.env.OURS_DAEMON_ID, credentialPath: '/var/lib/ours/daemon-token' }, applicationConfigPath: '/var/lib/ours-mcp/config.json' } };
+    const value = { stateDir: '/var/lib/ours', port: 3050, apiVisibility: 'owner' };
     if (process.env.OURS_BROKER_URL) value.brokerUrl = process.env.OURS_BROKER_URL;
     return value;
   }
@@ -79,6 +81,61 @@ function composeConfig(domain) {
   return null;
 }
 
+const NOTIFICATIONS_PORT = 49677;
+const NOTIFICATION_FILES = {
+  config: '/storage/state/notifications/config.json',
+  messenger: '/storage/state/credentials/messenger/notifications-producer',
+  // Read through the Messenger service by local client setup.
+  fleet: '/storage/state/notifications/fleet-producer',
+};
+
+function privateText(path, value) {
+  if (existingPrivate(path, false) && readFileSync(path, 'utf8') === value) return;
+  const temp = `${path}.setup-${randomBytes(8).toString('hex')}`;
+  try { writeFileSync(temp, value, { encoding: 'utf8', mode: 0o600, flag: 'wx' }); renameSync(temp, path); }
+  finally { try { unlinkSync(temp); } catch (error) { if (error.code !== 'ENOENT') throw error; } }
+}
+
+function notificationConfig() {
+  const token = () => randomBytes(32).toString('base64url');
+  const { publicKey, privateKey } = generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
+  const pub = publicKey.export({ format: 'jwk' }), key = privateKey.export({ format: 'jwk' });
+  const raw = Buffer.concat([Buffer.from([4]), Buffer.from(pub.x, 'base64url'), Buffer.from(pub.y, 'base64url')]);
+  return {
+    host: '0.0.0.0', port: NOTIFICATIONS_PORT, stateFile: '/var/lib/ours-notifications/state.json',
+    users: [{ userId: 'owner', token: token() }],
+    producers: [{ userId: 'owner', source: 'fleet', token: token() }, { userId: 'owner', source: 'messenger', token: token() }],
+    vapid: { subject: 'https://ours.network', publicKey: raw.toString('base64url'), privateKey: key.d },
+  };
+}
+
+/** Exact retained shape; any other content is operator state the installer will not rewrite. */
+function validNotificationConfig(config) {
+  const tokens = [...(config.users ?? []), ...(config.producers ?? [])].map(entry => entry?.token);
+  return config.host === '0.0.0.0' && config.port === NOTIFICATIONS_PORT && config.stateFile === '/var/lib/ours-notifications/state.json'
+    && Array.isArray(config.users) && config.users.length === 1 && config.users[0].userId === 'owner'
+    && Array.isArray(config.producers) && config.producers.length === 2
+    && ['fleet', 'messenger'].every(source => config.producers.some(p => p?.source === source && p.userId === 'owner'))
+    && tokens.every(t => typeof t === 'string' && t.length >= 32) && new Set(tokens).size === tokens.length
+    && typeof config.vapid?.subject === 'string' && /^[A-Za-z0-9_-]{87}$/.test(config.vapid.publicKey ?? '') && /^[A-Za-z0-9_-]{43}$/.test(config.vapid.privateKey ?? '');
+}
+
+/**
+ * Notification secrets are created once and then only validated: rotating the
+ * owner token or VAPID keys would orphan every browser subscription. Producer
+ * delivery files are derived from the retained configuration on every run.
+ */
+function prepareNotifications() {
+  // Messenger mounts this directory whether or not this runtime ships the service.
+  ensureDirectory('/storage/state/notifications');
+  if (!existsSync('/opt/ours/node_modules/@ours.network/notifications/package.json')) return;
+  initializeBuildMarker('/storage/state/notifications/.ours-provenance', readBuildRecords('/opt/ours'));
+  if (!existingPrivate(NOTIFICATION_FILES.config, false)) atomicJson(NOTIFICATION_FILES.config, notificationConfig());
+  const config = jsonObject(NOTIFICATION_FILES.config);
+  if (!validNotificationConfig(config)) fail('Existing notification configuration differs; use the supported maintenance workflow');
+  for (const source of ['messenger', 'fleet']) privateText(NOTIFICATION_FILES[source], config.producers.find(p => p.source === source).token);
+}
+
 function prepare() {
   const uid = Number(process.env.OURS_UID), gid = Number(process.env.OURS_GID);
   if (![uid, gid].every((n) => Number.isSafeInteger(n) && n > 0)) fail('Configure non-root numeric OURS_UID and OURS_GID');
@@ -123,15 +180,19 @@ function prepare() {
     const config = jsonObject(coworkPath);
     if (config.version !== 1 || config.stateDir !== cowork.stateDir || config.rest?.enabled !== true || config.rest?.host !== '0.0.0.0') fail('Existing cowork configuration conflicts with Compose');
   }
+  prepareNotifications();
   console.log('OURS persistent volumes are ready');
 }
 
 function finishDaemonSetup() {
   const state = '/var/lib/ours';
+  diagnosticStage = 'daemon-provenance';
   initializeBuildMarker(`${state}/.ours-provenance`, readBuildRecords('/opt/ours'));
+  diagnosticStage = 'mcp-directory';
   privatePath('/var/lib/ours-mcp', true);
   const mcpProfile = { endpoint: 'http://127.0.0.1:3050', expectedInstanceId: process.env.OURS_DAEMON_ID, credentialPath: `${state}/daemon-token` };
   const mcpPath = '/var/lib/ours-mcp/profile.json';
+  diagnosticStage = 'mcp-profile';
   if (!existingPrivate(mcpPath, false)) atomicJson(mcpPath, mcpProfile);
   else if (JSON.stringify(jsonObject(mcpPath)) !== JSON.stringify(mcpProfile)) fail('Existing MCP profile differs from the selected daemon');
 }
@@ -155,10 +216,19 @@ async function telegramInput() {
 }
 
 function cliJson(args) {
-  const result = spawnSync(process.execPath, ['/opt/ours/node_modules/@ours.network/cli/dist/cli.js', ...args], {
+  diagnosticStage = 'official-cli';
+  const result = spawnSync(process.execPath, [existsSync('/opt/ours/node_modules/@ours.network/daemon/dist/cli.js') ? '/opt/ours/node_modules/@ours.network/daemon/dist/cli.js' : '/opt/ours/node_modules/@ours.network/cli/dist/cli.js', ...args], {
     encoding: 'utf8', timeout: 60_000, maxBuffer: 1024 * 1024,
   });
-  if (result.status !== 0) fail('Official OURS CLI operation failed');
+  if (result.error || result.status !== 0) {
+    // --json writes failures on stderr. Successful credential stdout is never
+    // forwarded, even if a later operation exits unsuccessfully.
+    let reason = 'CLI supplied no structured error reason';
+    for (const line of String(result.stderr ?? '').split('\n').reverse()) {
+      try { const value = JSON.parse(line); if (typeof value?.error?.message === 'string') { reason = value.error.message; break; } } catch {}
+    }
+    fail(`Official OURS CLI operation failed (${args[1]}; exit=${result.status ?? 'none'}; signal=${result.signal ?? 'none'}; system=${result.error?.code ?? 'none'}): ${reason}`);
+  }
   try { return JSON.parse(result.stdout); }
   catch { fail('Official OURS CLI returned malformed JSON'); }
 }
@@ -192,6 +262,10 @@ try {
   else if (['access-init', 'access-issue', 'access-replace'].includes(operation)) access(operation, process.argv[3]);
   else fail('usage: client-setup.mjs prepare | telegram-input | access-init | access-issue [OUTPUT] | access-replace');
 } catch (error) {
-  console.error(`OURS client setup refused: ${error.message}`);
+  // Structured stderr retains the failing stage across sensitive Compose
+  // capture. The installer redacts secrets before exposing this envelope.
+  const message = redactDiagnostic(error.message);
+  console.error(JSON.stringify({ oursInstallerError: { stage: diagnosticStage, message } }));
+  console.error(`OURS client setup refused: ${message}`);
   process.exit(1);
 }

package/assets/scripts/runtime/dependency-ready.mjs

@@ -0,0 +1,13 @@
+import { attachOursClient } from '@ours.network/sdk/client';
+let client;
+try {
+  const service = process.argv[2];
+  if (!['telegram', 'cowork', 'messenger'].includes(service)) throw new Error('Unknown dependency');
+  client = await attachOursClient({ endpoint: 'http://daemon:3050',
+    expectedInstanceId: process.env[service === 'telegram' ? 'OURS_TG_DAEMON_ID' : 'OURS_DAEMON_ID'],
+    credentialPath: `/credentials/${service}/daemon-token`,
+    requiredCapabilities: ['external-sessions-v1'], sessionMode: 'external',
+    leaseToken: `container-dependency-${service}`, env: {} });
+  await client.listIdentities();
+} catch { process.exitCode = 1; }
+finally { await client?.close(); }

package/assets/scripts/runtime/diagnostics.mjs

@@ -0,0 +1,72 @@
+/** Retain actionable failure details without emitting credential output. */
+export function redactDiagnostic(value, env = process.env) {
+  let text = String(value ?? '').replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '').replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+  for (const [key, secret] of Object.entries(env)) {
+    if (/(?:token|password|secret|api.?key|private.?key|invitation|enrollment|authorization|credential|access.?token|refresh.?token)/i.test(key) && typeof secret === 'string' && secret)
+      text = text.split(secret).join('[redacted]');
+  }
+  return text
+    .replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g, '[redacted private key]')
+    .replace(/(Bearer\s+)[^\s"',;]+/gi, '$1[redacted]')
+    .replace(/((?:["']?(?:api[-_]?token|token|password|secret|api[-_]?key|private[-_]?key|invitation|enrollment|authorization|credential|access.?token|refresh.?token)["']?)\s*[:=]\s*)(?:"[^"\n]*"|'[^'\n]*'|[^\s,;}]+)/gi, '$1[redacted]')
+    .replace(/(--(?:setup-workspace|password|token|secret|api-key|private-key|invitation|enrollment)(?:=|\s+))\S+/gi, '$1[redacted]')
+    .replace(/(https?:\/\/)[^\s/@:]+:[^\s/@]+@/g, '$1[redacted]@')
+    .replace(/\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, '[redacted credential]')
+    .replace(/[A-Za-z0-9_+/=-]{43,}/g, '[redacted opaque value]');
+}
+
+const bounded = text => text.length <= 65536 ? text : text.slice(0, 65536) + '\n[Diagnostic output exceeds 64 KiB; remainder omitted.]';
+function credentialFailure(stderr) {
+  // Credential stdout can be a successful issuance followed by failure: never
+  // include it. Only a structured error envelope or shipped helper refusal is
+  // accepted from stderr; arbitrary lines/warnings remain private.
+  const lines = String(stderr ?? '').split('\n').reverse();
+  for (const line of lines) {
+    try {
+      const value = JSON.parse(line);
+      if (typeof value?.oursInstallerError?.message === 'string') {
+        const detail = value.oursInstallerError;
+        const stage = /^[a-z][a-z-]{0,40}$/.test(detail.stage ?? '') ? detail.stage : 'credential-operation';
+        return `Stage: ${stage}\nReason: ${detail.message}`;
+      }
+      if (typeof value?.error?.message === 'string') return `Reason: ${value.error.message}`;
+    } catch {}
+  }
+  const prefix = 'OURS client setup refused: ';
+  const legacy = lines.find(line => line.startsWith(prefix));
+  if (legacy) return `Reason: ${legacy.slice(prefix.length)}`;
+  return 'The credential operation provided no structured reason. Its raw output was withheld because it can contain credentials.';
+}
+
+export function commandFailure(command, args, result, { sensitive = false, cwd, env = process.env } = {}) {
+  const visibleArgs = [...args];
+  if (sensitive) {
+    for (let i = 0; i < visibleArgs.length - 1; i++) if (['-e', '--eval'].includes(visibleArgs[i])) visibleArgs[i + 1] = '[captured installer helper]';
+  }
+  const details = [`Command: ${command} ${visibleArgs.join(' ')}${result.status != null ? ` exited ${result.status}` : ''}`];
+  if (cwd) details.push(`Working directory: ${cwd}`);
+  if (result.status !== null && result.status !== undefined) details.push(`Exit code: ${result.status}`);
+  if (result.signal) details.push(`Signal: ${result.signal}`);
+  if (result.error?.code) details.push(`System error: ${result.error.code}`);
+  if (result.error?.code === 'ETIMEDOUT') details.push('Reason: command timed out.');
+  if (sensitive) details.push(credentialFailure(result.stderr));
+  else {
+    const stderr = String(result.stderr ?? '').trim(), stdout = String(result.stdout ?? '').trim();
+    if (stderr) details.push(`Standard error:\n${stderr}`);
+    if (stdout) details.push(`Standard output:\n${stdout}`);
+    if (!stderr && !stdout) details.push('No captured command output. Streaming commands print their output above.');
+  }
+  details.push('Keep installation data intact. Include this error and the preceding installation stage when requesting help.');
+  return new Error(bounded(redactDiagnostic(details.join('\n'), env)), result.error ? { cause: result.error } : undefined);
+}
+
+export function installerFailure(error, env = process.env) {
+  const details = []; const seen = new Set();
+  for (let cause = error; cause && !seen.has(cause) && seen.size < 8; cause = cause.cause) {
+    seen.add(cause);
+    const message = cause instanceof Error ? cause.message : String(cause);
+    if (!details.includes(message)) details.push(message);
+    if (typeof cause.code === 'string' && /^[A-Z_0-9]+$/.test(cause.code)) details.push(`System error: ${cause.code}`);
+  }
+  return bounded(redactDiagnostic(details.join('\nCaused by: '), env));
+}

package/assets/scripts/runtime/entrypoint.sh

@@ -1,4 +1,8 @@
 #!/bin/sh
+# Re-enter this entrypoint for every recovery, including its locks and checks.
+if [ "${OURS_RECOVERY_CHILD:-}" != 1 ]; then
+  exec node "${OURS_RUNTIME_ROOT:-/opt/ours}/docker/recover.mjs" daemon
+fi
 set -eu
 umask 077
 exec 3</var/lib/ours
@@ -10,4 +14,4 @@ else
   exit "$status"
 fi
 node /opt/ours/docker/check-start.mjs
-exec node /opt/ours/node_modules/@ours.network/cli/dist/cli.js daemon serve
+exec node /opt/ours/node_modules/@ours.network/daemon/dist/cli.js serve

package/assets/scripts/runtime/health-messenger.mjs

@@ -1,6 +1,7 @@
-try {
-  const response = await fetch('http://127.0.0.1:8420/api/healthz', {
-    signal: AbortSignal.timeout(3000), redirect: 'error',
-  });
-  process.exitCode = response.ok ? 0 : 1;
-} catch { process.exitCode = 1; }
+import { existsSync } from 'node:fs';
+
+const healthy = async url => {
+  try { return (await fetch(url, { signal: AbortSignal.timeout(3000), redirect: 'error' })).ok; } catch { return false; }
+};
+const notifications = process.env.OURS_NOTIFICATIONS_CONFIG && existsSync('/opt/ours/node_modules/@ours.network/notifications/package.json') && existsSync(process.env.OURS_NOTIFICATIONS_CONFIG);
+process.exitCode = await healthy('http://127.0.0.1:8420/api/healthz') && (!notifications || await healthy('http://127.0.0.1:49677/healthz')) ? 0 : 1;