instar 1.3.1600 → 1.3.1602

package/dist/commands/server.js

@@ -22870,6 +22870,44 @@ export async function startServer(options) {
                 });
                 setActiveDrainRehearsal(rehearsal);
                 rehearsal.start();
+                // Honest lock reading (Part A): a read of the session, never the flag alone.
+                const { MachineLockStateReader, setActiveMachineLockStateReader } = await import('../core/MachineLockStateReader.js');
+                setActiveMachineLockStateReader(new MachineLockStateReader());
+                // Browser care (Part B), watch-only: the sweep records what it WOULD close and has
+                // no way to close anything. Only the macOS normal-Chrome helpers keep a ledger.
+                if (process.platform === 'darwin') {
+                    const { BrowserCareSweep, normalizeBrowserCare, parseChromeProcesses, setActiveBrowserCare, DOWNLOAD_FRESH_MS } = await import('../monitoring/machineMaintenance/BrowserCare.js');
+                    const { makeTabChecker, makeDownloadCheck } = await import('../core/BrowserCareProbes.js');
+                    const { parseHidIdleMs } = await import('../monitoring/machineMaintenance/readings.js');
+                    const read = makeReadOnlyRunner(config.sessions.tmuxPath);
+                    const browserCare = new BrowserCareSweep({
+                        agentName: config.projectName,
+                        agentHome: projectDir,
+                        operatorChromeDir: path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome'),
+                        ledgerDir: path.join(config.stateDir, 'state', 'browser-instances'),
+                        logPath: path.join(config.stateDir, '..', 'logs', 'browser-care.jsonl'),
+                        settings: () => normalizeBrowserCare(liveConfig.get('machineMaintenance.browserCare', undefined)),
+                        listChrome: async () => { const out = await read('chromeProcesses'); return out === null ? null : parseChromeProcesses(out); },
+                        tmuxSessions: async () => { const out = await read('tmuxSessions'); return out === null ? null : out.split('\n').map((l) => l.trim()).filter(Boolean); },
+                        inputIdleMs: async () => { const out = await read('inputIdle'); return out === null ? null : parseHidIdleMs(out); },
+                        signInRepairOpen: () => {
+                            const runtime = subscriptionReloginRuntime;
+                            if (!runtime)
+                                return false;
+                            try {
+                                return runtime.store.list({ limit: 500 }).some((e) => !['succeeded', 'refused', 'cancelled', 'failed'].includes(e.state));
+                            }
+                            catch {
+                                return null;
+                            } // @silent-fallback-ok — null reads as "repair state unknown", which keeps every browser
+                        },
+                        downloadActive: makeDownloadCheck(DOWNLOAD_FRESH_MS),
+                        checkTabs: makeTabChecker(projectDir),
+                        log: (line) => console.log(pc.yellow(`  [browser-care] ${line}`)),
+                    });
+                    setActiveBrowserCare(browserCare);
+                    browserCare.start();
+                }
             }
         }
         catch (err) {
@@ -25105,6 +25143,14 @@ export async function startServer(options) {
                         // a mixed-version caller gets a clean answer, never no-handler
                         // surprises within one version); answers 'disabled' until the
                         // §3.7 replication gate constructs the serve side above.
+                        // mobile-native-chat-media §4.12 — the app media copy verb. Registered always (a
+                        // mixed-version caller gets a clean answer); 'disabled' without native conversations.
+                        // The serve side answers only for blobs an unpurged local event references.
+                        'app-media-pull': (cmd) => {
+                            if (!_appConversationService)
+                                return { ok: false, reason: 'app-media disabled' };
+                            return _appConversationService.replicator.serve(cmd);
+                        },
                         'working-set-pull': (cmd) => {
                             if (!workingSetPullServer)
                                 return { ok: false, reason: 'working-set disabled' };
@@ -25460,6 +25506,25 @@ export async function startServer(options) {
                         return resolveMeshPeerUrl(meshResolver, machineId, entry.endpoints, entry.lastKnownUrl);
                     };
                     _meshSelfId = meshSelfId;
+                    // App media copying (mobile-native-chat-media §4.12): the replicator rides this same
+                    // signed transport. Peers are this agent's registered machines; online comes from the
+                    // pool registry when it has a capacity row (unknown otherwise).
+                    if (_appConversationService) {
+                        const { getActiveWorkAdmission } = await import('../core/workAdmission.js');
+                        _appConversationService.replicator.attachTransport({
+                            peers: () => meshIdMgr.getActiveMachines().filter((m) => m.machineId !== meshSelfId).map((m) => {
+                                const cap = machinePoolRegistry?.getCapacities().find((c) => c.machineId === m.machineId);
+                                return { machineId: m.machineId, nickname: cap?.nickname ?? m.entry?.name, online: cap ? cap.online !== false : null };
+                            }),
+                            send: async (machineId, command, timeoutMs) => {
+                                const url = peerUrl(machineId);
+                                if (!url)
+                                    return { ok: false, reason: 'no-url' };
+                                return meshClient.send({ machineId, url }, command, 0, { timeoutMs });
+                            },
+                            loadVerdict: () => String(getActiveWorkAdmission()?.status().lastVerdict ?? 'unknown'),
+                        });
+                    }
                     _identityMeshSend = async (machineId, command, timeoutMs) => {
                         const url = peerUrl(machineId);
                         if (!url)