@nocville/npc 0.4.0 → 0.5.0

package/dist/cjs/npcs/gemini/defaults.js

@@ -6,7 +6,7 @@ const node_path_1 = require("node:path");
 exports.GEMINI_DEFAULTS = {
     stateDir: (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'nocville-gemini'),
     stateFileMaxAge: 24 * 60 * 60 * 1000,
-    heartbeatSeconds: 90,
+    heartbeatSeconds: 360,
     minPushGapMs: 1500,
     hookTimeoutMs: 5000,
 };

package/dist/cjs/npcs/web-page-watcher/pixelate.js

@@ -7,6 +7,7 @@ exports.quantize = quantize;
 exports.buildPixelImageScreen = buildPixelImageScreen;
 exports.fnv1a = fnv1a;
 exports.pngToPixelImage = pngToPixelImage;
+const node_zlib_1 = require("node:zlib");
 const pngjs_1 = require("pngjs");
 /** Default target resolution for the web-view TV (4:3 to match a 4×3 companion). */
 exports.TARGET_W = 160;
@@ -143,9 +144,9 @@ function buildPixelImageScreen(width, height, palette, indices) {
     return {
         layout: 'pixel-image',
         values: [
-            { label: 'fmt', value: `idx8;${width}x${height};p${paletteCount}` },
+            { label: 'fmt', value: `idx8;${width}x${height};p${paletteCount};z` },
             { label: 'palette', value: Buffer.from(palette).toString('base64') },
-            { label: 'pixels', value: Buffer.from(indices).toString('base64') },
+            { label: 'pixels', value: (0, node_zlib_1.deflateRawSync)(indices, { level: 9 }).toString('base64') },
         ],
     };
 }

package/dist/cli.js

@@ -12,9 +12,9 @@ const USAGE = `
 nocville-npc <command> [options]
 
 Quick start (AI coworkers):
-  nocville-npc setup                        Paste your agent key (hidden prompt),
+  nocville-npc setup                        Connect your office in the browser,
                                             then hook up installed coding agents
-                                            (whichever are installed)
+  nocville-npc setup --reconnect            Choose an office and renew this connection
   nocville-npc setup --api-key=<agent key>   Same, non-interactive
   nocville-npc uninstall                    Remove all Nocville hooks
 
@@ -151,22 +151,27 @@ async function main() {
         console.log(USAGE);
         process.exit(1);
     }
-    const config = resolveConfig(parsed.flags);
+    let config = resolveConfig(parsed.flags);
     const logger = new Logger('cli', config.debug);
     // Setup-style commands resolve the key: --api-key > env > saved > hidden prompt.
     const isAgentSetup = ['claude-code', 'codex', 'gemini', 'cursor'].includes(parsed.command) &&
         parsed.subcommand === 'setup' &&
         !parsed.flags['uninstall'];
     if (isAgentSetup || parsed.command === 'setup') {
-        if (parsed.command === 'setup') {
-            const { codexHome } = await import('./npcs/codex/defaults.js');
-            if (!existsSync(join(homedir(), '.claude')) &&
-                !existsSync(codexHome()) &&
-                !existsSync(join(homedir(), '.gemini')) &&
-                !existsSync(join(homedir(), '.cursor'))) {
-                console.error('Nothing to set up: install Claude Code, Codex, Gemini CLI or Cursor first.');
-                process.exitCode = 1;
-                return;
+        if (!config.workspace || !config.apiKey.includes('.team_') || parsed.flags['reconnect']) {
+            const { connectCloudflareOffice } = await import('./core/browser-connect.js');
+            if (await connectCloudflareOffice(config.apiUrl)) {
+                const { loadUserConfig } = await import('./core/user-config.js');
+                const saved = loadUserConfig();
+                for (const [flag, value] of Object.entries({
+                    'api-key': saved.apiKey,
+                    'api-url': saved.apiUrl,
+                    map: saved.map,
+                    workspace: saved.workspace,
+                }))
+                    if (value)
+                        parsed.flags[flag] = value;
+                config = resolveConfig(parsed.flags);
             }
         }
         const key = await resolveSetupKey(parsed.flags);
@@ -174,6 +179,16 @@ async function main() {
             return;
         if (key !== undefined)
             parsed.flags['api-key'] = key;
+        config = resolveConfig(parsed.flags);
+        if (config.workspace) {
+            const { saveUserConfig } = await import('./core/user-config.js');
+            saveUserConfig({
+                workspace: config.workspace,
+                apiUrl: config.apiUrl,
+                apiKey: config.apiKey,
+                map: config.map,
+            });
+        }
     }
     // AI-agent integrations have their own config handling (hooks read the saved config).
     if (parsed.command === 'claude-code') {
@@ -256,6 +271,10 @@ async function main() {
         return;
     }
     // All other NPC types require api-url and token
+    if (!config.workspace &&
+        (config.apiKey.includes('.team_') ||
+            config.apiUrl.replace(/\/+$/, '') === 'https://nocville.com'))
+        throw new Error('Connect this computer to your office first: run npx @nocville/npc@latest setup. Existing legacy keys cannot publish encrypted NPC updates.');
     if (!config.apiKey) {
         console.error('Error: no API key — run `nocville-npc init --api-key=<key>`, or pass --api-key / NOCVILLE_API_KEY');
         process.exit(1);
@@ -604,8 +623,7 @@ async function runSetupAll(flags) {
         console.log('· Cursor not found (~/.cursor missing) — skipped');
     }
     if (!any) {
-        console.error('Nothing to set up: install Claude Code, Codex, Gemini CLI or Cursor first.');
-        process.exitCode = 1;
+        console.log('No supported coding agents found. You can still run NPC commands on this computer.');
     }
 }
 main().catch((err) => {

package/dist/core/base-npc.js

@@ -136,6 +136,15 @@ export class BaseNPC {
         catch {
             /* observer only */
         }
+        if (!result.success && [401, 410].includes(result.statusCode ?? 0)) {
+            // A revoked key or an SDK version the server retired: retrying forever only
+            // costs requests. Stop; restarting after fixing it resumes monitoring.
+            this.logger.error(result.statusCode === 410
+                ? 'This @nocville/npc version is no longer supported — upgrade it. Stopping.'
+                : 'API key rejected (HTTP 401) — check NOCVILLE_API_KEY / team settings. Stopping.');
+            void this.stop();
+            return;
+        }
         if (!result.success) {
             this.reportPushFailure(result.error);
         }

package/dist/core/browser-connect.d.ts

@@ -0,0 +1,16 @@
+import { type ProducerWorkspace } from '@nocville/node';
+export interface BrowserConnection {
+    apiKey: string;
+    workspace: ProducerWorkspace;
+}
+export declare function validateConnection(input: unknown, origin: string, deploymentId: string): BrowserConnection;
+/** A one-use loopback receiver. Credentials never appear in a URL or terminal output. */
+export declare function browserConnection(origin: string, deploymentId: string, save: (value: BrowserConnection) => void | Promise<void>, timeoutMs?: number): Promise<{
+    url: string;
+    done: Promise<void>;
+    close: () => void;
+}>;
+export declare function saveBrowserConnection(value: BrowserConnection): void;
+export declare function openConnectionBrowser(url: string): void;
+export declare function connectCloudflareOffice(apiUrl: string): Promise<boolean>;
+//# sourceMappingURL=browser-connect.d.ts.map

package/dist/core/browser-connect.js

@@ -0,0 +1,189 @@
+import { createServer } from 'node:http';
+import { randomBytes, createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { loadProducerWorkspace } from '@nocville/node';
+import { loadUserConfig, saveUserConfig, userConfigPath } from './user-config.js';
+export function validateConnection(input, origin, deploymentId) {
+    const value = input;
+    const e = value?.workspace?.encryption;
+    if (typeof value?.apiKey !== 'string' ||
+        !/^nvk_[a-f0-9]{64}\.team_[A-Za-z0-9_-]{1,64}$/.test(value.apiKey) ||
+        value.workspace?.apiUrl !== origin ||
+        e?.deploymentId !== deploymentId ||
+        !/^team_[A-Za-z0-9_-]{1,64}$/.test(e?.teamId ?? '') ||
+        !/^map_[A-Za-z0-9_-]{1,128}$/.test(e?.mapId ?? '') ||
+        !/^[A-Za-z0-9_-]{43}$/.test(e?.trustedRoot ?? '') ||
+        !value.apiKey.endsWith('.' + e.teamId) ||
+        e.profileDirectory !== undefined)
+        throw new Error('Invalid office connection. Start setup again.');
+    return {
+        apiKey: value.apiKey,
+        workspace: {
+            apiUrl: origin,
+            encryption: {
+                deploymentId,
+                teamId: e.teamId,
+                mapId: e.mapId,
+                trustedRoot: e.trustedRoot,
+            },
+        },
+    };
+}
+/** A one-use loopback receiver. Credentials never appear in a URL or terminal output. */
+export async function browserConnection(origin, deploymentId, save, timeoutMs = 300000) {
+    const target = new URL(origin);
+    if (target.origin !== origin ||
+        target.username ||
+        target.password ||
+        (target.protocol !== 'https:' &&
+            !(target.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(target.hostname))))
+        throw new Error('Use an HTTPS office address.');
+    const state = randomBytes(32).toString('hex');
+    let finish, fail;
+    const done = new Promise((resolve, reject) => {
+        finish = resolve;
+        fail = reject;
+    });
+    // A timeout may happen while the browser launcher is still opening.
+    void done.catch(() => { });
+    let consumed = false, port = 0;
+    const server = createServer(async (request, response) => {
+        response.setHeader('Cache-Control', 'no-store');
+        if (request.headers.host !== `127.0.0.1:${port}` ||
+            request.url !== '/complete' ||
+            request.headers.origin !== origin) {
+            response.writeHead(403).end();
+            return;
+        }
+        response.setHeader('Access-Control-Allow-Origin', origin);
+        response.setHeader('Vary', 'Origin');
+        if (request.method === 'OPTIONS') {
+            response.setHeader('Access-Control-Allow-Methods', 'POST');
+            response.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            response.setHeader('Access-Control-Allow-Private-Network', 'true');
+            response.writeHead(204).end();
+            return;
+        }
+        if (request.method !== 'POST' ||
+            request.headers['content-type']?.split(';')[0] !== 'application/json') {
+            response.writeHead(415).end();
+            return;
+        }
+        try {
+            let size = 0;
+            const chunks = [];
+            for await (const chunk of request) {
+                size += chunk.length;
+                if (size > 16384) {
+                    response.writeHead(413).end();
+                    return;
+                }
+                chunks.push(Buffer.from(chunk));
+            }
+            const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            if (body.state !== state || consumed) {
+                response.writeHead(403).end();
+                return;
+            }
+            const value = validateConnection(body, origin, deploymentId);
+            consumed = true;
+            await save(value);
+            response.once('finish', finish);
+            response.writeHead(200, { 'Content-Type': 'application/json' }).end('{"connected":true}');
+        }
+        catch {
+            response.writeHead(400).end('Could not save this office connection. Start setup again.');
+            if (consumed)
+                fail(new Error('Could not save the office connection. Start setup again.'));
+        }
+    });
+    server.requestTimeout = 15000;
+    server.headersTimeout = 10000;
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    port = server.address().port;
+    const timer = setTimeout(() => fail(new Error('Office connection timed out. Run setup again.')), timeoutMs);
+    const url = new URL('/npcs/connect', origin);
+    url.searchParams.set('port', String(port));
+    url.searchParams.set('state', state);
+    return {
+        url: url.href,
+        done,
+        close: () => {
+            clearTimeout(timer);
+            server.close();
+            server.closeAllConnections();
+        },
+    };
+}
+export function saveBrowserConnection(value) {
+    const saved = loadUserConfig();
+    if (saved.workspace) {
+        const old = loadProducerWorkspace(saved.workspace);
+        if (old.apiUrl === value.workspace.apiUrl &&
+            old.encryption.teamId === value.workspace.encryption.teamId &&
+            (old.encryption.deploymentId !== value.workspace.encryption.deploymentId ||
+                old.encryption.trustedRoot !== value.workspace.encryption.trustedRoot))
+            throw new Error('The office encryption identity changed. Reconnect only after checking with your team owner.');
+    }
+    const directory = join(dirname(userConfigPath()), 'workspaces');
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const name = createHash('sha256').update(JSON.stringify(value.workspace)).digest('hex');
+    const workspace = join(directory, name + '.json');
+    const temporary = workspace + '.' + randomBytes(8).toString('hex') + '.tmp';
+    writeFileSync(temporary, JSON.stringify(value.workspace, null, 2) + '\n', {
+        mode: 0o600,
+        flag: 'wx',
+    });
+    renameSync(temporary, workspace);
+    saveUserConfig({
+        workspace,
+        apiUrl: value.workspace.apiUrl,
+        apiKey: value.apiKey,
+        map: value.workspace.encryption.mapId,
+    });
+}
+export function openConnectionBrowser(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'rundll32.exe'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['url.dll,FileProtocolHandler', url] : [url];
+    const child = spawn(command, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => { }); // The printed URL also supports systems without a browser launcher.
+    child.unref();
+}
+export async function connectCloudflareOffice(apiUrl) {
+    const origin = new URL(apiUrl).origin;
+    const response = await fetch(new URL('/.well-known/nocville.json', origin), {
+        redirect: 'error',
+        signal: AbortSignal.timeout(8000),
+    });
+    if (response.status === 404)
+        return false;
+    if (!response.ok)
+        throw new Error('The office is unavailable. Try setup again shortly.');
+    const info = (await response.json());
+    if (!info.encryptedIngress)
+        return false;
+    if (typeof info.deploymentId !== 'string' || !/^[A-Za-z0-9:_-]{1,128}$/.test(info.deploymentId))
+        throw new Error('Invalid office identity.');
+    const connection = await browserConnection(origin, info.deploymentId, saveBrowserConnection);
+    console.log('Connect this computer in your browser. Sign in, choose your office, and click Connect.');
+    console.log(connection.url);
+    openConnectionBrowser(connection.url);
+    try {
+        await connection.done;
+        console.log('✓ Connected. Private NPC updates will be encrypted on this computer.');
+    }
+    finally {
+        connection.close();
+    }
+    return true;
+}
+//# sourceMappingURL=browser-connect.js.map

package/dist/core/pixel-art.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { deflateRawSync } from 'node:zlib';
 import { PNG } from 'pngjs';
 /**
  * Helpers for custom pixel-art companions (`screenType: 'pixel-device'`): your NPC's own
@@ -63,7 +64,9 @@ export function encodePixelArt(art) {
         const fps = Math.min(12, Math.max(1, Math.round(art.fps ?? 4)));
         tokens.push(`f${frames.length}`, `fps${fps}`);
     }
-    const encoded = pixels.toString('base64');
+    // Deflated indices (`z`) are typically 15–25× smaller for pixel art.
+    tokens.push('z');
+    const encoded = deflateRawSync(pixels, { level: 9 }).toString('base64');
     if (encoded.length > MAX_VALUE)
         throw new Error('Pixel art is too large to send; use fewer frames or a smaller size.');
     return {

package/dist/core/polling-npc.d.ts

@@ -6,8 +6,9 @@ export interface PollingNpcConfig extends NpcConfig {
     onCollection?: (metrics: CollectedMetrics) => void;
 }
 /**
- * Lower bound for any poll interval, so a typo can't exhaust the API's
- * per-service rate limit (60 pushes/min) or hammer the watched source.
+ * Lower bound for any poll interval, so a typo can't hammer the watched source.
+ * The SDK sends changed status at most every 10 s and heartbeats every 30 s;
+ * the server limits producers per key, team and NPC and answers 429.
  */
 export declare const MIN_POLL_INTERVAL_MS = 5000;
 export declare abstract class PollingNPC extends BaseNPC {

package/dist/core/polling-npc.js

@@ -1,7 +1,8 @@
 import { BaseNPC } from './base-npc.js';
 /**
- * Lower bound for any poll interval, so a typo can't exhaust the API's
- * per-service rate limit (60 pushes/min) or hammer the watched source.
+ * Lower bound for any poll interval, so a typo can't hammer the watched source.
+ * The SDK sends changed status at most every 10 s and heartbeats every 30 s;
+ * the server limits producers per key, team and NPC and answers 429.
  */
 export const MIN_POLL_INTERVAL_MS = 5000;
 /** How long `stop()` waits for an in-flight collection before pushing offline anyway. */

package/dist/npcs/agent-common/runtime.js

@@ -66,24 +66,57 @@ export function ensureStableCliPath(cliPath, _force = true) {
     const pngRoot = findPackageRoot(dirname(req.resolve('pngjs')), 'pngjs');
     if (!pngRoot)
         throw new Error('Cannot install hook runtime: pngjs is missing');
+    // Resolve the complete production dependency closure before copying. Encryption
+    // introduced nested SDK dependencies that the old two-package snapshot omitted.
+    const dependencies = new Map();
+    const collect = (root) => {
+        const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+        const previous = dependencies.get(manifest.name);
+        if (previous) {
+            if (readVersion(previous) !== manifest.version)
+                throw new Error(`Cannot install hook runtime: conflicting versions of ${manifest.name}`);
+            return;
+        }
+        dependencies.set(manifest.name, root);
+        const resolveDependency = createRequire(join(root, 'package.json'));
+        for (const name of Object.keys(manifest.dependencies ?? {}).sort()) {
+            const dependency = findPackageRoot(dirname(resolveDependency.resolve(name)), name);
+            if (!dependency)
+                throw new Error(`Cannot install hook runtime: ${name} is missing`);
+            collect(dependency);
+        }
+    };
+    collect(sdkRoot);
+    collect(pngRoot);
+    const files = (root, prefix = '') => readdirSync(join(root, prefix), { withFileTypes: true })
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .flatMap((entry) => {
+        if (entry.name === 'node_modules' ||
+            entry.name.startsWith('.') ||
+            entry.name.endsWith('.map'))
+            return [];
+        const relative = join(prefix, entry.name);
+        return statSync(join(root, relative)).isDirectory() ? files(root, relative) : [relative];
+    });
+    const dependencyFiles = [...dependencies].map(([name, root]) => ({
+        name,
+        root,
+        files: files(root),
+    }));
     const version = readVersion(pkgRoot);
     const hash = createHash('sha256');
-    const hashTree = (root) => {
-        for (const entry of readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-            hash.update(entry.name);
-            const path = join(root, entry.name);
-            if (entry.isDirectory())
-                hashTree(path);
-            else if (entry.isFile())
-                hash.update(readFileSync(path));
+    hash.update(readFileSync(join(pkgRoot, 'package.json')));
+    for (const file of files(join(pkgRoot, 'dist'))) {
+        hash.update(file);
+        hash.update(readFileSync(join(pkgRoot, 'dist', file)));
+    }
+    for (const dependency of dependencyFiles) {
+        hash.update(dependency.name);
+        for (const file of dependency.files) {
+            hash.update(file);
+            hash.update(readFileSync(join(dependency.root, file)));
         }
-    };
-    for (const root of [pkgRoot, sdkRoot]) {
-        hash.update(readFileSync(join(root, 'package.json')));
-        hashTree(join(root, 'dist'));
     }
-    hash.update(readFileSync(join(pngRoot, 'package.json')));
-    hashTree(join(pngRoot, 'lib'));
     // Immutable snapshots also support multiple development builds of one version.
     // Never remove files a running watchdog or the current pointer may still use.
     const dest = join(dirname(userConfigPath()), 'runtime', `${version}-${hash.digest('hex').slice(0, 16)}`);
@@ -94,14 +127,13 @@ export function ensureStableCliPath(cliPath, _force = true) {
         mkdirSync(stage, { recursive: true, mode: 0o700 });
         cpSync(join(pkgRoot, 'package.json'), join(stage, 'package.json'));
         cpSync(join(pkgRoot, 'dist'), join(stage, 'dist'), { recursive: true });
-        const sdkDest = join(stage, 'node_modules', '@nocville', 'node');
-        mkdirSync(sdkDest, { recursive: true });
-        cpSync(join(sdkRoot, 'package.json'), join(sdkDest, 'package.json'));
-        cpSync(join(sdkRoot, 'dist'), join(sdkDest, 'dist'), { recursive: true });
-        const pngDest = join(stage, 'node_modules', 'pngjs');
-        mkdirSync(pngDest, { recursive: true });
-        cpSync(join(pngRoot, 'package.json'), join(pngDest, 'package.json'));
-        cpSync(join(pngRoot, 'lib'), join(pngDest, 'lib'), { recursive: true });
+        for (const dependency of dependencyFiles) {
+            const target = join(stage, 'node_modules', dependency.name);
+            for (const file of dependency.files) {
+                mkdirSync(dirname(join(target, file)), { recursive: true });
+                cpSync(join(dependency.root, file), join(target, file), { dereference: true });
+            }
+        }
         try {
             renameSync(stage, dest);
         }

package/dist/npcs/agent-common/session.js

@@ -239,17 +239,43 @@ export function buildAgentPayload(adapter, state, config) {
         map: config.map,
     };
 }
+/**
+ * Clients reused within one process (a long-lived watchdog): a fresh client
+ * re-runs enrollment, manifest, version and session requests on every push.
+ * Any failure (e.g. a hook process took over the producer session) drops it.
+ */
+const clients = new Map();
 async function defaultPush(config, serviceId, payload, timeoutMs) {
-    const client = new NocvilleClient({
-        workspace: config.workspace,
-        apiUrl: config.apiUrl,
-        apiKey: config.apiKey,
+    const key = JSON.stringify([
+        config.workspace,
+        config.apiUrl,
+        config.apiKey,
         serviceId,
-        timeout: timeoutMs,
-        retries: 0,
-        debug: config.debug,
-    });
-    return client.pushStatus(payload);
+        timeoutMs,
+    ]);
+    let client = clients.get(key);
+    if (!client) {
+        client = new NocvilleClient({
+            workspace: config.workspace,
+            apiUrl: config.apiUrl,
+            apiKey: config.apiKey,
+            serviceId,
+            timeout: timeoutMs,
+            retries: 0,
+            debug: config.debug,
+        });
+        clients.set(key, client);
+    }
+    try {
+        const result = await client.pushStatus(payload);
+        if (!result.success)
+            clients.delete(key);
+        return result;
+    }
+    catch (error) {
+        clients.delete(key);
+        throw error;
+    }
 }
 /**
  * Push the session's current state if it has unpushed changes (or is offline),

package/dist/npcs/agent-common/watchdog.d.ts

@@ -2,7 +2,8 @@ import type { NpcConfig } from '../../core/types.js';
 import { isAgentAlive } from './liveness.js';
 import type { AgentAdapter, PushDeps } from './session.js';
 export declare const WATCHDOG_TICK_MS = 15000;
-export declare const WATCHDOG_HEARTBEAT_MS = 60000;
+/** Liveness only (status changes push at once); each heartbeat is a billed request. */
+export declare const WATCHDOG_HEARTBEAT_MS = 300000;
 export declare const WATCHDOG_OFFLINE_RETRY_MS: number;
 export declare function ensureWatchdog(adapter: AgentAdapter, config: NpcConfig, sessionId: string, cliPath?: string, lockWaitMs?: number): Promise<void>;
 export interface WatchdogDeps extends PushDeps {

package/dist/npcs/agent-common/watchdog.js

@@ -2,7 +2,8 @@ import { isAgentAlive } from './liveness.js';
 import { withStateLock } from './lock.js';
 import { flushSession, readSessionState, sleep, spawnDetachedAgent, stateFilePath, writeSessionState, } from './session.js';
 export const WATCHDOG_TICK_MS = 15_000;
-export const WATCHDOG_HEARTBEAT_MS = 60_000;
+/** Liveness only (status changes push at once); each heartbeat is a billed request. */
+export const WATCHDOG_HEARTBEAT_MS = 300_000;
 export const WATCHDOG_OFFLINE_RETRY_MS = 15 * 60_000;
 export async function ensureWatchdog(adapter, config, sessionId, cliPath, lockWaitMs) {
     if (adapter.processNames?.length === 0 ||
@@ -37,7 +38,7 @@ export async function runWatchdog(adapter, config, sessionId, deps = {}) {
     const delivery = {
         ...deps,
         onResult: (result) => {
-            if (!result.success && [400, 401, 403, 404].includes(result.statusCode ?? 0))
+            if (!result.success && [400, 401, 403, 404, 410].includes(result.statusCode ?? 0))
                 rejected = true;
             deps.onResult?.(result);
         },
@@ -118,7 +119,7 @@ export async function runWatchdog(adapter, config, sessionId, deps = {}) {
                     ...deps,
                     force: true,
                     onResult: (result) => {
-                        if (!result.success && [400, 401, 403, 404].includes(result.statusCode ?? 0))
+                        if (!result.success && [400, 401, 403, 404, 410].includes(result.statusCode ?? 0))
                             heartbeatRejected = true;
                         deps.onResult?.(result);
                     },

package/dist/npcs/claude-code/defaults.d.ts

@@ -3,7 +3,7 @@ export declare const DEFAULTS: {
     stateFilePrefix: string;
     stateFileMaxAge: number;
     httpTimeout: number;
-    /** Watchdog-backed sessions become unknown after three minutes without a heartbeat. */
+    /** Watchdog-backed sessions become unknown after twelve minutes without a heartbeat. */
     heartbeatSeconds: number;
     /** Number of recent activity lines kept in the desk-sign ticker. */
     activityBufferSize: number;

package/dist/npcs/claude-code/defaults.js

@@ -5,8 +5,8 @@ export const DEFAULTS = {
     stateFilePrefix: 'session-',
     stateFileMaxAge: 24 * 60 * 60 * 1000, // 24 hours
     httpTimeout: 4000,
-    /** Watchdog-backed sessions become unknown after three minutes without a heartbeat. */
-    heartbeatSeconds: 90,
+    /** Watchdog-backed sessions become unknown after twelve minutes without a heartbeat. */
+    heartbeatSeconds: 360,
     /** Number of recent activity lines kept in the desk-sign ticker. */
     activityBufferSize: 8,
     /** Coalesce same-phase activity pushes closer together than this. */

package/dist/npcs/codex/defaults.d.ts

@@ -2,7 +2,7 @@ export declare const CODEX_DEFAULTS: {
     /** Hook-mode per-session state (shared with the watcher to avoid double pushes). */
     stateDir: string;
     stateFileMaxAge: number;
-    /** Watchdog-backed sessions become unknown after three minutes without a heartbeat. */
+    /** Watchdog-backed sessions become unknown after twelve minutes without a heartbeat. */
     heartbeatSeconds: number;
     minPushGapMs: number;
     hookTimeoutSeconds: number;

package/dist/npcs/codex/defaults.js

@@ -4,8 +4,8 @@ export const CODEX_DEFAULTS = {
     /** Hook-mode per-session state (shared with the watcher to avoid double pushes). */
     stateDir: join(tmpdir(), 'nocville-codex'),
     stateFileMaxAge: 24 * 60 * 60 * 1000,
-    /** Watchdog-backed sessions become unknown after three minutes without a heartbeat. */
-    heartbeatSeconds: 90,
+    /** Watchdog-backed sessions become unknown after twelve minutes without a heartbeat. */
+    heartbeatSeconds: 360,
     minPushGapMs: 1500,
     hookTimeoutSeconds: 10,
     /** Watcher: Codex session rollout logs. */

package/dist/npcs/cursor/defaults.js

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 export const CURSOR_DEFAULTS = {
     stateDir: join(tmpdir(), 'nocville-cursor'),
     stateFileMaxAge: 24 * 60 * 60 * 1000,
-    heartbeatSeconds: 90,
+    heartbeatSeconds: 360,
     minPushGapMs: 1500,
     hookTimeoutSeconds: 10,
 };

package/dist/npcs/cursor/hook-handler.js

@@ -10,7 +10,7 @@ export const CURSOR_ADAPTER = {
     label: 'Cursor',
     family: 'cursor',
     stateDir: CURSOR_DEFAULTS.stateDir,
-    heartbeatSeconds: 90,
+    heartbeatSeconds: 360,
     processNames: [],
 };
 export function cursorServiceId(sessionId, cwd) {

package/dist/npcs/gemini/defaults.js

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 export const GEMINI_DEFAULTS = {
     stateDir: join(tmpdir(), 'nocville-gemini'),
     stateFileMaxAge: 24 * 60 * 60 * 1000,
-    heartbeatSeconds: 90,
+    heartbeatSeconds: 360,
     minPushGapMs: 1500,
     hookTimeoutMs: 5000,
 };