@openchambery/web 1.19.11 → 1.19.13-beta.1

package/server/lib/llm/temp-directory.test.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureLlmTempDirectory, stopLlmTempDirectory } from './temp-directory.js';
+
+const readAgent = async (root, agentName) =>
+  fs.readFile(path.join(root, '.opencode', 'agent', `${agentName}.md`), 'utf8');
+
+afterEach(async () => {
+  await stopLlmTempDirectory();
+});
+
+describe('ensureLlmTempDirectory', () => {
+  it('shares one directory across concurrent first ensures and applies each markdown body', async () => {
+    const firstBody = '---\nname: a\n---\nFIRST\n';
+    const secondBody = '---\nname: a\n---\nSECOND\n';
+    const [first, second] = await Promise.all([
+      ensureLlmTempDirectory({ agentName: 'openchamber-llm', agentMarkdown: firstBody }),
+      ensureLlmTempDirectory({ agentName: 'openchamber-llm', agentMarkdown: secondBody }),
+    ]);
+    expect(first).toBe(second);
+    const written = await readAgent(first, 'openchamber-llm');
+    // Last writer wins; both callers must have completed a full write after settle.
+    expect(written === firstBody || written === secondBody).toBe(true);
+    expect(written).toMatch(/FIRST|SECOND/);
+  });
+
+  it('refreshes markdown on a warm directory under concurrent ensure', async () => {
+    const root = await ensureLlmTempDirectory({
+      agentName: 'openchamber-llm',
+      agentMarkdown: '---\nname: a\n---\nSEED\n',
+    });
+    const bodies = Array.from({ length: 8 }, (_, index) => `---\nname: a\n---\nREFRESH-${index}\n`);
+    const roots = await Promise.all(
+      bodies.map((agentMarkdown) => ensureLlmTempDirectory({ agentName: 'openchamber-llm', agentMarkdown })),
+    );
+    expect(new Set(roots)).toEqual(new Set([root]));
+    const written = await readAgent(root, 'openchamber-llm');
+    expect(bodies).toContain(written);
+    expect(written).toMatch(/REFRESH-\d+/);
+  });
+
+  it('stop clears the singleton so the next ensure creates a fresh directory', async () => {
+    const first = await ensureLlmTempDirectory({
+      agentName: 'openchamber-llm',
+      agentMarkdown: '---\nname: a\n---\nA\n',
+    });
+    await stopLlmTempDirectory();
+    const second = await ensureLlmTempDirectory({
+      agentName: 'openchamber-llm',
+      agentMarkdown: '---\nname: a\n---\nB\n',
+    });
+    expect(second).not.toBe(first);
+    await expect(fs.access(first)).rejects.toThrow();
+    expect(await readAgent(second, 'openchamber-llm')).toContain('B');
+  });
+});

package/server/lib/notifications/APNS.md

@@ -13,10 +13,12 @@ registered them — so a leaked device token alone can't be used to push.
    `POST /v1/push/register-token`, signed with its auto-generated ECDSA P-256 key
    (`getOrCreateRelayKeypair`, persisted in settings like the VAPID keys). The relay records
    `token → serverId` where `serverId = SHA-256(publicKey)`.
- 3. On a trigger (ready/error/question/permission/goal_*), the server composes **generic,
-    content-free** text — a **locale-specific** scenario title (from `apns-titles.js`, keyed off
-    the locale stored with each device token at `POST /api/push/apns-token`) + the **session name**
-    as the body, no model/project/message content — plus a **`badge`** count (see below).
+3. On a trigger (ready/error/question/permission/goal_*), the server composes **generic,
+     content-free** text — a **locale-specific** scenario title (from `apns-titles.js`, keyed off
+     the locale stored with each device token at `POST /api/push/apns-token`) + the **session name**
+     as the body, no model/project/message content — plus a **`badge`** count (see below).
+     Scheduled-task runs add `task_complete` / `task_error` scenario titles (task name as the
+     body, error text never crosses), gated by their own settings toggle.
     **Contact turns are the exception:** APNs keeps the assistant nickname as the title and the
     spoken message as the body (`preserveAlert`), and forwards `assistantID` so a tap opens that
     conversation. Tokens are grouped by locale (relay signatures cover `title`, so mixed locales
@@ -60,6 +62,20 @@ dismissalDate?, staleDate?, publicKeyJwk, ts, sig }` signed over
 Direct mode uses HTTP/2 token auth, `apns-topic: ${bundleId}.push-type.liveactivity`,
 `apns-push-type: liveactivity`, and no alert.
 
+While sessions are still working, a periodic refresh
+(`live-activity-refresh-runtime.js`, default every 30s,
+`OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS`, `0` disables) recomputes each
+persisted Live Activity snapshot from the authoritative server-side session
+states and pushes an **update** only when something changed — a busy→retry
+transition, a newly visible top-level session, a missed idle completion, or a
+stale row recovering to working. Unchanged snapshots never send, because APNs
+budgets Live Activity updates per hour. Update payloads reuse the signed
+live-activity contract above (`staleDate = updatedAt + 20min`, snapshot `items`
+with `sessionID`/`title`/`status` rows — the same shape the foreground app
+writes via ActivityKit); when the recomputed snapshot has no working row left,
+the refresh sends `end` and clears accepted tokens locally. A tick is a no-op
+(one token-store read) when no device registered a Live Activity token.
+
 The APNs / relay payload **must not** carry `sessionId` or user/session content.
 `contentState` is only `{ status, eventVersion, updatedAt, endedAt }`.
 `complete` uses a 15-minute dismissal and `error` a 60-minute dismissal (same as

package/server/lib/notifications/DOCUMENTATION.md

@@ -10,6 +10,7 @@ This module provides notification message preparation utilities for the web serv
 - `packages/web/server/lib/notifications/apns-runtime.js`: native iOS APNs device-token persistence + delivery, plus a separate Live Activity token store and `end` send path. Two modes: **relay** (default — sign + POST tokens + generic text to the isolated Push Relay in `packages/relay-server/src/push/`, which holds the project APNs key) and **direct** (fallback — sign ES256 JWT with Node crypto + HTTP/2, when `OPENCHAMBER_PUSH_RELAY_DISABLED=true`). Unless `OPENCHAMBER_PUSH_RELAY_URL` is set, the Host maps the effective Relay `wss`/`ws` URL to the same host as `https`/`http` `/v1/push/send`. Before each relay send, the runtime checks an in-memory registration success cache (keyed by current register URL + token + platform) and only POSTs `/v1/push/register-token` for cache misses; only successfully bound tokens are sent. Switching Relay/Push URL clears that cache so persisted tokens re-bind to the new origin on the next send or `reRegisterAllTokens()`. Each server has an auto-generated ECDSA P-256 keypair (`getOrCreateRelayKeypair`, persisted in settings); it binds tokens on the relay (`/v1/push/register-token`) and signs every relay request, so the relay only delivers to tokens bound to that server. APNs is the native app's sole notification channel (no local notifications) and is NOT gated on UI visibility — iOS suppresses the foreground banner instead. Mobile push carries only generic text (scenario title + session name) — see `APNS.md`. Live Activity tokens are persisted beside alert tokens in the same file (`version` 2, `liveActivityTokensBySession`) without mixing the two token types; v1 files remain readable. Live Activity relay bind/send uses `/v1/push/register-live-activity-token`, `/v1/push/unregister-live-activity-token`, and `/v1/push/live-activity`.
 - `packages/web/server/lib/notifications/emitter-runtime.js`: desktop/stdout + UI SSE notification emission runtime.
 - `packages/web/server/lib/notifications/runtime.js`: trigger runtime for OpenCode event-driven notification fanout.
+- `packages/web/server/lib/notifications/live-activity-refresh-runtime.js`: periodic Live Activity snapshot refresh (default 30s, `OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS` overrides, `0` disables). Each tick snapshots the authoritative session states once, recomputes every persisted Live Activity token's snapshot, and pushes updates only for real changes — busy→retry transitions, newly visible top-level sessions, idle completions the event path missed, and stale-row recovery. Entries whose recomputed snapshot is unchanged never send (APNs budgets Live Activity updates per hour). Rows for sessions without authoritative server state are preserved as-is; server-side-only sub-states (`permission`/`input`/`tool`) keep their last value while the session stays busy. When no row is working anymore the refresh sends `end` and clears accepted tokens.
 - `packages/web/server/lib/notifications/template-runtime.js`: notification template variables and session text/title enrichment runtime. Zen-model helpers are retained as compatibility stubs only.
 - `packages/web/server/lib/notifications/message.js`: helper implementation module.
 - `packages/web/server/lib/notifications/message.test.js`: unit tests for notification message helpers.
@@ -46,8 +47,11 @@ This module provides notification message preparation utilities for the web serv
 - `createNotificationTriggerRuntime(dependencies)`: creates runtime-owned debounced trigger handling for OpenCode events.
 - Returned API:
   - `maybeSendPushForTrigger(payload)`
+  - `resolveLiveActivitySessionCandidate(sessionId)` — sidebar candidate for a new Live Activity refresh row: `{ title, visible }` under the same suppression rules as ordinary push. Cache-first across any cached directory, then the directory-less OpenCode session endpoint; a missing meta resolves as not-visible.
+  - `sendScheduledTaskRunNotification({ projectID, taskID, taskName, status, sessionId?, reason, errorMessage? })` — scheduled-tasks runtime callback when a scheduled (non-manual) run settles. Gated by `notifyOnScheduledTasks`; manual runs always skip. Desktop/UI SSE carry the task name (plus error text on failure); push follows the generic contract (`task_complete`/`task_error` scenario titles, task name as APNs body, `scheduled-<projectID>-<taskID>` collapse tag).
 - Owns:
   - top-level completion/question/permission trigger routing; completion is the sole task-status notification. Ordinary push is limited to sidebar-visible root sessions. Child/subagent sessions, Assistant bindings (`openchamber.assistant.assistantID` unless `assigned.from === 'contact'`), scheduled-task sessions, small-model system sessions (`metadata.openchamber.smallModel.purpose`), LLM gateway throwaway sessions (`metadata.openchamber.llm.purpose`), and `smartfetch-secondary` titles are suppressed. Contact-assigned workers stay visible and still notify.
+  - per-event settings gates: `notifyOnCompletion` (ready), `notifyOnQuestion` (question), `notifyOnPermission` (permission — independent of the question toggle), `notifyOnAssistants` (contact turns), `notifyOnGoals` (goal settle push), `notifyOnScheduledTasks` (scheduled task runs); all default to enabled via the settings migration.
   - contact-turn notifications (`sendContactTurnNotification`) are a separate SMS-style path: title is the assistant nickname, body is the spoken message text, on desktop / UI SSE / web-push / APNs. APNs does **not** rewrite these into the generic "Task completed" scenario title.
   - top-level completion/error Live Activity `end` (`sendLiveActivityEnd`), independent of ordinary push settings and UI visibility, with the same hidden-session suppression; duplicate terminal events are idempotent at the token store
   - session meta cache for sidebar-visibility suppression
@@ -77,6 +81,7 @@ This module provides notification message preparation utilities for the web serv
   - `addOrUpdateLiveActivityToken(uiSessionToken, token, activityId, sessionId)` — idempotent upsert bound to the UI session + OpenCode `sessionId` + ActivityKit `activityId`. Token refresh replaces that activity's previous token. Caps per UI session and lazily expires stale entries. Binds on the relay (`/v1/push/register-live-activity-token`, `kind: "liveactivity"`). Does not log tokens or session ids.
   - `removeLiveActivityToken(uiSessionToken, token)` — owning UI session only; unregisters from the relay when no local copies remain.
   - `sendLiveActivityEnd({ sessionId, status, eventVersion?, endedAt? })` — looks up Live Activity tokens for that OpenCode session and sends `event: "end"` with `contentState` `{ status, eventVersion, updatedAt, endedAt }` only. `complete` dismisses after 15 minutes, `error` after 60 minutes (same as native). `staleDate` (`updatedAt + 20min`) is update-only and omitted on end. `eventVersion` is monotonic per session using current milliseconds. Relay body follows the signed live-activity contract; direct mode uses token auth, topic `${bundleId}.push-type.liveactivity`, `apns-push-type: liveactivity`, and no alert. APNs payloads must not carry `sessionId` or user content. Successfully accepted tokens are cleared locally; failures do not drop alert tokens or block ordinary push.
+  - `refreshLiveActivityTokens({ computeSnapshot })` — periodic refresh entrypoint for `live-activity-refresh-runtime.js`. The async `computeSnapshot(entry)` returns `{ items }` (unix seconds) when that entry's snapshot changed or `null` to skip; unchanged entries never send. Changed snapshots bump the aggregate `liveActivityEventVersions` entry, persist, and deliver an `update` (with `staleDate`) grouped by identical snapshot — or an `end` plus local token cleanup once no row is working. Delivery shares the same relay/direct path as `sendLiveActivityEnd`.
   - `sendApnsToAllUiSessions(payload)` — localizes scenario titles per stored token locale (`apns-titles.js`), groups tokens by locale, then signs + sends (no UI-visibility gate; iOS suppresses the foreground banner). Before a relay send, each token is checked against the in-memory registration success cache for the current register URL; cache hits skip `/v1/push/register-token`, misses are registered with bounded concurrency, and only successfully bound tokens are sent. Switching Relay/Push URL clears that cache so the next send re-binds persisted tokens to the new origin. No-ops with a single warning when APNs is unconfigured. Drops tokens on `410` / `BadDeviceToken` / `Unregistered`. Never sends Live Activity tokens.
   - `reRegisterAllTokens()` — binds every persisted device token to the current Push origin (same success cache and URL-switch invalidation as send).
   - `resolveApnsConfig()`

package/server/lib/notifications/apns-runtime.js

@@ -1120,6 +1120,140 @@ export const createApnsRuntime = (deps) => {
     return entries;
   };
 
+  // Shared Live Activity delivery path (relay register-then-send, or direct APNs).
+  // Returns the tokens APNs accepted; callers decide what an accepted `end` means.
+  const deliverLiveActivityPayload = async (tokens, payload) => {
+    const accepted = [];
+    const relay = await resolveRelayConfig();
+    if (relay) {
+      rememberLiveActivityRelayRegisterUrl(relay.liveActivityRegisterUrl);
+      const outcomes = await mapWithBoundedConcurrency(
+        tokens,
+        RELAY_REGISTER_CONCURRENCY,
+        async (token) => {
+          const registered = await registerLiveActivityTokenWithRelay(token, relay);
+          return registered ? token : null;
+        },
+      );
+      const readyTokens = outcomes.filter((token) => typeof token === 'string');
+      if (readyTokens.length > 0) {
+        accepted.push(...await sendLiveActivityViaRelay(readyTokens, payload, relay));
+      }
+    } else {
+      accepted.push(...await sendLiveActivityViaDirectApns(tokens, payload));
+    }
+    return accepted;
+  };
+
+  // Periodic refresh entrypoint (see live-activity-refresh-runtime.js). For every
+  // persisted Live Activity entry the async `computeSnapshot(entry)` returns the
+  // next snapshot items (unix seconds) or null to skip; unchanged snapshots send
+  // nothing. Changed snapshots bump the aggregate event version, persist, and
+  // deliver an `update` — or an `end` (clearing accepted tokens) once no row is
+  // working anymore.
+  const refreshLiveActivityTokens = async ({ computeSnapshot } = {}) => {
+    if (typeof computeSnapshot !== 'function') return;
+    const now = Date.now();
+    const store = await readTokensFromDisk();
+    const pruned = pruneLiveActivityTokensBySession(store.liveActivityTokensBySession, now);
+    const entries = [];
+    const seen = new Set();
+    for (const record of Object.values(pruned)) {
+      for (const entry of record) {
+        if (seen.has(entry.token)) continue;
+        seen.add(entry.token);
+        entries.push(entry);
+      }
+    }
+    if (entries.length === 0) return;
+
+    const nextItemsByToken = new Map();
+    for (const entry of entries) {
+      let next = null;
+      try {
+        next = await computeSnapshot(entry);
+      } catch {
+        next = null;
+      }
+      if (next && Array.isArray(next.items)) nextItemsByToken.set(entry.token, next.items);
+    }
+    if (nextItemsByToken.size === 0) return;
+
+    const planned = [];
+    let nextVersion = 0;
+    await persistTokenUpdate((current) => {
+      const liveActivityTokensBySession = pruneLiveActivityTokensBySession(
+        current.liveActivityTokensBySession,
+        now,
+      );
+      const previous = current.liveActivityEventVersions?.[LIVE_ACTIVITY_AGGREGATE_SESSION_ID];
+      nextVersion = nextLiveActivityEventVersion(now, previous);
+      let plannedInRun = [];
+      for (const [uiSessionToken, record] of Object.entries(liveActivityTokensBySession)) {
+        const nextRecord = record.map((entry) => {
+          const items = nextItemsByToken.get(entry.token);
+          if (!items) return entry;
+          plannedInRun.push({ token: entry.token, items });
+          return { ...entry, snapshot: items };
+        });
+        liveActivityTokensBySession[uiSessionToken] = nextRecord;
+      }
+      planned.push(...plannedInRun);
+      return {
+        ...current,
+        liveActivityTokensBySession,
+        liveActivityEventVersions: {
+          ...(current.liveActivityEventVersions || {}),
+          [LIVE_ACTIVITY_AGGREGATE_SESSION_ID]: nextVersion,
+        },
+      };
+    });
+    if (planned.length === 0) return;
+
+    // Entries with identical snapshots share one APNs payload.
+    const signatureOf = (items) => items
+      .map((item) => `${item.sessionId}\0${item.title}\0${item.status}\0${item.endedAt ?? ''}`)
+      .join('\n');
+    const groups = new Map();
+    for (const plan of planned) {
+      const working = plan.items.filter((item) => liveActivityItemIsWorking(item.status));
+      const key = signatureOf(plan.items);
+      const group = groups.get(key) ?? { items: plan.items, tokens: [] };
+      group.tokens.push(plan.token);
+      groups.set(key, group);
+    }
+
+    const updatedAtSeconds = now / 1000;
+    const tokensToEnd = [];
+    for (const group of groups.values()) {
+      const working = group.items.filter((item) => liveActivityItemIsWorking(item.status));
+      const isEnd = working.length === 0;
+      const status = isEnd
+        ? (group.items.some((item) => item.status === 'error') ? 'error' : 'complete')
+        : (working[0]?.status || 'working');
+      const payload = {
+        event: isEnd ? 'end' : 'update',
+        contentState: contentStateFromSnapshot(
+          group.items,
+          status,
+          nextVersion,
+          updatedAtSeconds,
+          isEnd ? updatedAtSeconds : undefined,
+        ),
+        ...liveActivityPushDates(isEnd ? 'end' : 'update', status, updatedAtSeconds, now),
+      };
+      let accepted = [];
+      try {
+        accepted = await deliverLiveActivityPayload(group.tokens, payload);
+      } catch (error) {
+        console.warn('[Live Activity] refresh failed:', error?.message ?? error);
+        continue;
+      }
+      if (isEnd && accepted.length > 0) tokensToEnd.push(...accepted);
+    }
+    if (tokensToEnd.length > 0) await removeLiveActivityTokens(tokensToEnd);
+  };
+
   const sendLiveActivityEnd = async ({ sessionId, status, eventVersion, endedAt, title } = {}) => {
     const trimmedSessionId = typeof sessionId === 'string' ? sessionId.trim() : '';
     if (!isLimitedId(trimmedSessionId, MAX_LIVE_ACTIVITY_ID_CHARS)) return;
@@ -1217,24 +1351,7 @@ export const createApnsRuntime = (deps) => {
     const tokens = pendingEntries.map((entry) => entry.token);
     let accepted = [];
     try {
-      const relay = await resolveRelayConfig();
-      if (relay) {
-        rememberLiveActivityRelayRegisterUrl(relay.liveActivityRegisterUrl);
-        const outcomes = await mapWithBoundedConcurrency(
-          tokens,
-          RELAY_REGISTER_CONCURRENCY,
-          async (token) => {
-            const registered = await registerLiveActivityTokenWithRelay(token, relay);
-            return registered ? token : null;
-          },
-        );
-        const readyTokens = outcomes.filter((token) => typeof token === 'string');
-        if (readyTokens.length > 0) {
-          accepted = await sendLiveActivityViaRelay(readyTokens, payload, relay);
-        }
-      } else {
-        accepted = await sendLiveActivityViaDirectApns(tokens, payload);
-      }
+      accepted = await deliverLiveActivityPayload(tokens, payload);
     } catch (error) {
       console.warn('[Live Activity] end failed:', error?.message ?? error);
       return;
@@ -1332,6 +1449,7 @@ export const createApnsRuntime = (deps) => {
     addOrUpdateLiveActivityToken,
     removeLiveActivityToken,
     sendLiveActivityEnd,
+    refreshLiveActivityTokens,
     sendApnsToAllUiSessions,
     reRegisterAllTokens,
     resolveApnsConfig,

package/server/lib/notifications/apns-runtime.test.js

@@ -1175,3 +1175,131 @@ describe('apns live activity host-relay compatibility', () => {
     expect(apnsCalls).toHaveLength(0);
   });
 });
+
+describe('apns live activity refresh', () => {
+  it('sends nothing when no snapshot changed', async () => {
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    const deps = makeDeps();
+    const runtime = createApnsRuntime(deps);
+    await runtime.addOrUpdateLiveActivityToken('s1', 'la-token', 'act-1', 'live', [
+      { sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 },
+    ]);
+
+    fetchMock.mockClear();
+    await runtime.refreshLiveActivityTokens({ computeSnapshot: async () => null });
+    expect(fetchMock.mock.calls.filter(isLiveActivitySend)).toHaveLength(0);
+    const store = JSON.parse(await deps.fsPromises.readFile('/tmp/apns-tokens.json'));
+    expect(store.liveActivityTokensBySession.s1).toHaveLength(1);
+  });
+
+  it('pushes an update with the recomputed snapshot and bumps the event version monotonically', async () => {
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    const deps = makeDeps();
+    const runtime = createApnsRuntime(deps);
+    await runtime.addOrUpdateLiveActivityToken('s1', 'la-token', 'act-1', 'live', [
+      { sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 },
+    ]);
+
+    fetchMock.mockClear();
+    await runtime.refreshLiveActivityTokens({
+      computeSnapshot: async () => ({
+        items: [{ sessionId: 'ses_1', title: 'One', status: 'retry', startedAt: 1 }],
+      }),
+    });
+    const sent = JSON.parse(fetchMock.mock.calls.find(isLiveActivitySend)[1].body);
+    expect(sent.tokens).toEqual(['la-token']);
+    expect(sent.event).toBe('update');
+    expect(sent.contentState.status).toBe('retry');
+    expect(sent.contentState.workingCount).toBe(1);
+    expect(sent.contentState.items[0]).toMatchObject({ sessionID: 'ses_1', status: 'retry' });
+    expect(sent.staleDate).toBeGreaterThan(0);
+    expect(sent.dismissalDate).toBeUndefined();
+
+    const store = JSON.parse(await deps.fsPromises.readFile('/tmp/apns-tokens.json'));
+    expect(store.liveActivityTokensBySession.s1[0].snapshot[0].status).toBe('retry');
+    const firstVersion = store.liveActivityEventVersions.live;
+
+    fetchMock.mockClear();
+    await runtime.refreshLiveActivityTokens({
+      computeSnapshot: async () => ({
+        items: [{ sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 }],
+      }),
+    });
+    const second = JSON.parse(fetchMock.mock.calls.find(isLiveActivitySend)[1].body);
+    expect(second.contentState.eventVersion).toBeGreaterThan(firstVersion);
+  });
+
+  it('ends and clears the token when nothing is working anymore', async () => {
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    const deps = makeDeps();
+    const runtime = createApnsRuntime(deps);
+    await runtime.addOrUpdateLiveActivityToken('s1', 'la-token', 'act-1', 'live', [
+      { sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 },
+    ]);
+
+    fetchMock.mockClear();
+    await runtime.refreshLiveActivityTokens({
+      computeSnapshot: async () => ({
+        items: [{ sessionId: 'ses_1', title: 'One', status: 'complete', startedAt: 1, endedAt: 5 }],
+      }),
+    });
+    const sent = JSON.parse(fetchMock.mock.calls.find(isLiveActivitySend)[1].body);
+    expect(sent.event).toBe('end');
+    expect(sent.contentState.status).toBe('complete');
+    expect(sent.dismissalDate).toBeGreaterThan(0);
+    expect(sent.staleDate).toBeUndefined();
+
+    const store = JSON.parse(await deps.fsPromises.readFile('/tmp/apns-tokens.json'));
+    expect(store.liveActivityTokensBySession.s1).toBeUndefined();
+  });
+
+  it('groups entries with identical snapshots into one send and keeps distinct snapshots separate', async () => {
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    const runtime = createApnsRuntime(makeDeps());
+    await runtime.addOrUpdateLiveActivityToken('s1', 'la-token-a', 'act-1', 'live', [
+      { sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 },
+    ]);
+    await runtime.addOrUpdateLiveActivityToken('s2', 'la-token-b', 'act-2', 'live', [
+      { sessionId: 'ses_2', title: 'Two', status: 'working', startedAt: 2 },
+    ]);
+
+    fetchMock.mockClear();
+    await runtime.refreshLiveActivityTokens({
+      computeSnapshot: async (entry) => {
+        if (entry.token === 'la-token-a') {
+          return { items: [{ sessionId: 'ses_1', title: 'One', status: 'retry', startedAt: 1 }] };
+        }
+        return { items: [{ sessionId: 'ses_2', title: 'Two', status: 'retry', startedAt: 2 }] };
+      },
+    });
+    const sends = fetchMock.mock.calls.filter(isLiveActivitySend).map((call) => JSON.parse(call[1].body));
+    expect(sends).toHaveLength(2);
+  });
+
+  it('treats a computeSnapshot rejection as skip, not failure', async () => {
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    const deps = makeDeps();
+    const runtime = createApnsRuntime(deps);
+    await runtime.addOrUpdateLiveActivityToken('s1', 'la-token', 'act-1', 'live', [
+      { sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 },
+    ]);
+
+    fetchMock.mockClear();
+    await expect(runtime.refreshLiveActivityTokens({
+      computeSnapshot: async () => {
+        throw new Error('boom');
+      },
+    })).resolves.toBeUndefined();
+    expect(fetchMock.mock.calls.filter(isLiveActivitySend)).toHaveLength(0);
+  });
+});

package/server/lib/notifications/apns-titles.js

@@ -16,7 +16,7 @@ export const APNS_LOCALES = Object.freeze([
   'ja',
 ]);
 
-/** @typedef {'ready'|'error'|'question'|'permission'|'goal_complete'|'goal_blocked'|'goal_budget'|'update'} ApnsTitleType */
+/** @typedef {'ready'|'error'|'question'|'permission'|'goal_complete'|'goal_blocked'|'goal_budget'|'task_complete'|'task_error'|'update'} ApnsTitleType */
 
 const TITLES = Object.freeze({
   en: Object.freeze({
@@ -27,6 +27,8 @@ const TITLES = Object.freeze({
     goal_complete: 'Goal completed',
     goal_blocked: 'Goal blocked',
     goal_budget: 'Token budget reached',
+    task_complete: 'Scheduled task completed',
+    task_error: 'Scheduled task failed',
     update: 'Update',
     session: 'Session',
   }),
@@ -38,6 +40,8 @@ const TITLES = Object.freeze({
     goal_complete: 'Objectif atteint',
     goal_blocked: 'Objectif bloqué',
     goal_budget: 'Budget de tokens atteint',
+    task_complete: 'Tâche planifiée terminée',
+    task_error: 'Échec de la tâche planifiée',
     update: 'Mise à jour',
     session: 'Session',
   }),
@@ -49,6 +53,8 @@ const TITLES = Object.freeze({
     goal_complete: '目标已完成',
     goal_blocked: '目标受阻',
     goal_budget: '已达用量上限',
+    task_complete: '定时任务已完成',
+    task_error: '定时任务失败',
     update: '有新进展',
     session: '会话',
   }),
@@ -60,6 +66,8 @@ const TITLES = Object.freeze({
     goal_complete: '目標已完成',
     goal_blocked: '目標受阻',
     goal_budget: '已達用量上限',
+    task_complete: '排程任務已完成',
+    task_error: '排程任務失敗',
     update: '有新進展',
     session: '工作階段',
   }),
@@ -71,6 +79,8 @@ const TITLES = Object.freeze({
     goal_complete: 'Цілі досягнуто',
     goal_blocked: 'Цілі заблоковано',
     goal_budget: 'Досягнуто ліміт токенів',
+    task_complete: 'Заплановане завдання виконано',
+    task_error: 'Заплановане завдання не вдалося',
     update: 'Оновлення',
     session: 'Сесія',
   }),
@@ -82,6 +92,8 @@ const TITLES = Object.freeze({
     goal_complete: 'Objetivo completado',
     goal_blocked: 'Objetivo bloqueado',
     goal_budget: 'Presupuesto de tokens alcanzado',
+    task_complete: 'Tarea programada completada',
+    task_error: 'La tarea programada falló',
     update: 'Actualización',
     session: 'Sesión',
   }),
@@ -93,6 +105,8 @@ const TITLES = Object.freeze({
     goal_complete: 'Objetivo concluído',
     goal_blocked: 'Objetivo bloqueado',
     goal_budget: 'Orçamento de tokens atingido',
+    task_complete: 'Tarefa agendada concluída',
+    task_error: 'A tarefa agendada falhou',
     update: 'Atualização',
     session: 'Sessão',
   }),
@@ -104,6 +118,8 @@ const TITLES = Object.freeze({
     goal_complete: '목표 완료',
     goal_blocked: '목표 차단됨',
     goal_budget: '토큰 한도 도달',
+    task_complete: '예약 작업 완료',
+    task_error: '예약 작업 실패',
     update: '업데이트',
     session: '세션',
   }),
@@ -115,6 +131,8 @@ const TITLES = Object.freeze({
     goal_complete: 'Cel ukończony',
     goal_blocked: 'Cel zablokowany',
     goal_budget: 'Osiągnięto limit tokenów',
+    task_complete: 'Zadanie zaplanowane ukończone',
+    task_error: 'Zadanie zaplanowane nie powiodło się',
     update: 'Aktualizacja',
     session: 'Sesja',
   }),
@@ -126,6 +144,8 @@ const TITLES = Object.freeze({
     goal_complete: '目標完了',
     goal_blocked: '目標がブロックされました',
     goal_budget: 'トークン上限に達しました',
+    task_complete: 'スケジュールタスクが完了しました',
+    task_error: 'スケジュールタスクに失敗しました',
     update: '更新',
     session: 'セッション',
   }),