claude-code-session-manager 0.106.0 → 0.108.0

package/src/preload/api.d.ts

@@ -758,7 +758,7 @@ export interface ScheduleJobStatusHistoryEntry {
   at: string;
 }
 
-export type SchedulePauseReason = 'rate_limit' | 'auth' | 'network' | 'manual' | 'reset_failure';
+export type SchedulePauseReason = 'rate_limit' | 'auth' | 'network' | 'manual' | 'agent' | 'reset_failure';
 
 export interface SchedulePauseInfo {
   reason: SchedulePauseReason;
@@ -767,6 +767,8 @@ export interface SchedulePauseInfo {
   /** ISO timestamp at which auto-resume will fire (typically next 5h reset).
    *  null means "indefinite — wait for manual Run now". */
   resumeAt: string | null;
+  /** Present when reason is 'agent': who paused and why. */
+  by?: { originClaudeSessionId: string | null; cwd: string | null; reason: string | null } | null;
 }
 
 export interface ScheduleHealthSnapshot {
@@ -1582,6 +1584,46 @@ export type CreateProjectFolderResult =
   | { ok: true; path: string }
   | { ok: false; code: 'invalid-name' | 'invalid-parent' | 'exists' | 'io'; error: string; path?: string };
 
+// ────────────────────────────────────────────── Web Remote (PRD 08)
+
+export interface WebRemoteDevice {
+  deviceId: string;
+  deviceName: string;
+  issuedAt: string;
+  lastConnectedAt: string | null;
+}
+
+export interface WebRemoteStatus {
+  enabled: boolean;
+  remoteControlEnabled: boolean;
+  connected: boolean;
+  e2eActive: boolean;
+  /** True once the user has confirmed the SAS on the desktop. */
+  e2eAuthenticated: boolean;
+  /** Explicit E2E session state for UI rendering. */
+  e2eState: 'idle' | 'pending_sas' | 'authenticated' | 'failed';
+  /** 6-digit Short Authentication String pending user confirmation, or null. */
+  pendingSas: string | null;
+  devices: WebRemoteDevice[];
+}
+
+export interface WebRemotePairResult {
+  ok: boolean;
+  deviceId?: string;
+  error?: string;
+}
+
+export interface WebRemoteMutationResult {
+  ok: boolean;
+  error?: string;
+}
+
+export interface WebRemoteAuditTailResult {
+  ok: boolean;
+  lines?: string[];
+  error?: string;
+}
+
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
@@ -2069,6 +2111,27 @@ export interface SessionManagerAPI {
      *  renderer needs per-row badges without a separate git call per file. */
     fileStatus: (cwd: string) => Promise<GitFileStatusMap>;
   };
+  webRemote: {
+    getStatus: () => Promise<WebRemoteStatus>;
+    enable: () => Promise<WebRemoteMutationResult>;
+    disable: () => Promise<WebRemoteMutationResult>;
+    /** Allow MUTATE-tier commands (pty spawn/write, scheduler writes). Default off. */
+    enableControl: () => Promise<WebRemoteMutationResult>;
+    /** Block MUTATE-tier commands — mobile becomes read-only mirror. */
+    disableControl: () => Promise<WebRemoteMutationResult>;
+    pair: (otp: string) => Promise<WebRemotePairResult>;
+    revokeDevice: (deviceId: string) => Promise<WebRemoteMutationResult>;
+    auditTail: (lines?: number) => Promise<WebRemoteAuditTailResult>;
+    onStatus: (handler: (status: WebRemoteStatus) => void) => () => void;
+    onTokenRevoked: (handler: (ev: { deviceId: string }) => void) => () => void;
+    /** Revoke ALL paired devices and tear down every session immediately (panic). */
+    revokeAll: () => Promise<WebRemoteMutationResult>;
+    /** Subscribe to the completion event broadcast after revokeAll. */
+    onRevokedAll: (handler: (ev: { revokedCount: number }) => void) => () => void;
+    /** Confirm that the SAS shown on the desktop matches the browser — marks the
+     *  E2E session as authenticated and unblocks MUTATE-tier commands. */
+    confirmSas: () => Promise<WebRemoteMutationResult>;
+  };
   chat: {
     /** Spawn a headless `claude -p` run for a tab. Results arrive via the on* listeners. */
     run: (payload: ChatRunPayload) => Promise<{ ok: boolean }>;

package/src/preload/index.cjs

@@ -392,6 +392,45 @@ contextBridge.exposeInMainWorld('api', {
     status: (cwd) => ipcRenderer.invoke('git:status', { cwd }),
     fileStatus: (cwd) => ipcRenderer.invoke('git:file-status', { cwd }),
   },
+  webRemote: {
+    /** Current connection state (no token values). */
+    getStatus: () => ipcRenderer.invoke('webRemote:get-status'),
+    /** Turn remote control on. Initiates relay connection if a device is paired. */
+    enable: () => ipcRenderer.invoke('webRemote:enable'),
+    /** Turn remote control off. Immediately drops relay connection. */
+    disable: () => ipcRenderer.invoke('webRemote:disable'),
+    /** Allow MUTATE-tier commands (pty spawn/write, scheduler writes). Default off. */
+    enableControl: () => ipcRenderer.invoke('webRemote:enable-control'),
+    /** Block MUTATE-tier commands — mobile becomes read-only mirror. */
+    disableControl: () => ipcRenderer.invoke('webRemote:disable-control'),
+    /** Pair a new device using the 8-character OTP shown in the web UI. */
+    pair: (otp) => ipcRenderer.invoke('webRemote:pair', { otp }),
+    /** Revoke a paired device by its deviceId. */
+    revokeDevice: (deviceId) => ipcRenderer.invoke('webRemote:revoke-device', { deviceId }),
+    /** Read the last N lines of today's audit log (default 50). */
+    auditTail: (lines) => ipcRenderer.invoke('webRemote:audit-tail', lines ? { lines } : {}),
+    /** Push event from main when connection status changes. */
+    onStatus: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('webRemote:status', listener);
+      return () => ipcRenderer.removeListener('webRemote:status', listener);
+    },
+    /** Push event when the relay revokes this device's token. */
+    onTokenRevoked: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('webRemote:token-revoked', listener);
+      return () => ipcRenderer.removeListener('webRemote:token-revoked', listener);
+    },
+    /** Revoke ALL paired devices and tear down every session immediately. */
+    revokeAll: () => ipcRenderer.invoke('webRemote:revoke-all'),
+    confirmSas: () => ipcRenderer.invoke('webRemote:confirm-sas'),
+    /** Push event when revokeAll completes (main broadcasts webRemote:revoked-all). */
+    onRevokedAll: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('webRemote:revoked-all', listener);
+      return () => ipcRenderer.removeListener('webRemote:revoked-all', listener);
+    },
+  },
   chat: {
     /** Spawn a headless claude -p job. Results arrive via the on* listeners. */
     run: (payload) => ipcRenderer.invoke('chat:run', payload),

package/src/seed/agents/demo-video-builder.md

@@ -5,7 +5,7 @@ tools: Read, Grep, Glob, Bash, Write, Edit
 title: 'Project Home — Demo Video'
 model: sonnet
 effort: medium
-seedVersion: 2
+seedVersion: 3
 ---
 
 You are the demo-video-builder. You make a 30-second animated demo that shows someone what this
@@ -52,54 +52,73 @@ Produce exactly one complete HTML document:
 - Expose `window.smDemo = { duration: 30, seek(t), play(), pause() }`, where `seek(t)` renders
   the exact frame for time `t` in seconds, independent of whatever played before it.
 - Autoplays once on load; shows play/pause, restart, and a progress bar.
-- Optional narration audio (see `<audio_policy>`); the video must still make sense muted.
-- No network: no `fetch`, `XMLHttpRequest`, `WebSocket`, `import()`, or `<iframe>`. No external
-  fonts or images — system font stack only, and any images as `data:` URIs.
-- Respects `prefers-reduced-motion` by rendering the scenes as a static, steppable storyboard
-  instead of animating them.
-- Under 2 MB total.
-- A light/dark neutral palette with sufficient contrast in both.
-</output_contract>
+- Narration audio built per `<audio_policy>
+Narration is the default deliverable: every video ships with a natural-sounding on-device voice
+track reading the storyboard captions. Generate it at build time, never at playback time; the
+shipped document never calls out to a network TTS service. A silent video is allowed ONLY when
+the install or model download below genuinely fails — then your final report must state the exact
+failing command and its error. Generating a track and then saving the HTML without it is a failed run.
 
-<audio_policy>
-Narrate the storyboard captions with a short, pleasant on-device voice track — optional, never
-block the video on it. Generate it at build time, not at playback time; the shipped document
-never calls out to a network TTS service.
+- **TTS: Kokoro-82M via `kokoro-onnx`** (Apache-2.0, ONNX runtime, no PyTorch). Install with
+  `python3 -m pip install --user --break-system-packages kokoro-onnx soundfile`. If
+  `python3 -m pip` is missing, bootstrap it first:
+  `curl -sS https://bootstrap.pypa.io/get-pip.py | python3 - --user --break-system-packages`.
+  `ffmpeg` must be on PATH.
+- **Shared model cache:** `MODEL_DIR=~/.cache/kokoro-onnx`, reused across projects. Only if
+  `kokoro-v1.0.onnx` (~325 MB) or `voices-v1.0.bin` (~28 MB) is missing there, download it with
+  `curl -L --max-time 600 -o "$MODEL_DIR/<file>" https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/<file>`.
+  Never download into /tmp or the project tree.
+- **Voices** (all `lang='en-us'`, speed 1.0; raise speed only to fit a line into its scene, max 1.15):
+  female narrator `af_heart` (Kokoro's top-graded voice; alt `af_bella`) is the default; male
+  narrator `am_michael` (alt `am_fenrir`) when the human asks for it or the project's audience or
+  brand suggests it. A two-voice video may alternate `af_heart` / `am_michael` per scene. Never use
+  Piper `-medium` or espeak (robotic). Piper `en_US-lessac-high` is the fallback only when Kokoro
+  cannot be installed.
+- **Build recipe.** Work in a fresh `mktemp -d` directory outside the project. Save this as
+  `build.py` there, fill in `SCENES` and `TEMPLATE`, and run it:
 
-- Use **Kokoro-82M via the `kokoro-onnx` package** (`pip install kokoro-onnx`, Apache-2.0,
-  ONNX runtime only — no PyTorch needed despite earlier guidance here claiming otherwise;
-  confirmed by running it for real). If `python3 -m pip` isn't on PATH, bootstrap it first:
-  `curl -sS https://bootstrap.pypa.io/get-pip.py | python3 - --user --break-system-packages`,
-  then `python3 -m pip install --user --break-system-packages kokoro-onnx soundfile`. Pull the
-  model once: `kokoro-v1.0.onnx` (~325 MB) + `voices-v1.0.bin` (~28 MB) from
-  `https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/`. Use the
-  **`af_heart`** or **`af_bella`** voice (both are Kokoro's top-rated English voices and read
-  as clearly more natural than Piper, including Piper's `-high` tier — but which one of the
-  two sounds better is a taste call, not a settled fact; if the human reacts to a generated
-  video with "still not it," try the other one before reaching for a different library).
-  `Kokoro(model, voices).create(line, voice='af_heart', speed=1.0, lang='en-us')` returns
-  `(samples, sample_rate)` (24000 Hz); write each scene's line with `soundfile.write`. If
-  `kokoro-onnx`/its model download genuinely isn't available (offline, no bandwidth for a
-  ~350 MB pull), fall back to **Piper** (`pip install piper-tts`) with a `-high` voice tier
-  (e.g. `en_US-lessac-high`, not `-medium` — `-medium` reads as noticeably robotic) from
-  `https://huggingface.co/rhasspy/piper-voices`.
-- Synthesize one short line per scene, sized to fit that scene's on-screen hold time. Lay the
-  scene clips onto one mono track (at the model's native sample rate) at each scene's start
-  offset, encode the result with `ffmpeg -c:a libmp3lame -b:a 64k` **at that native sample
-  rate — do not downsample or drop below ~48 kbps; both make speech sound crushed/robotic for
-  only a small size win** (a 30 s mono track at 64 kbps is still only ~235 KB). Base64 it into
-  a single `<audio src="data:audio/mpeg;base64,...">` tag. Keep the whole document — markup
-  plus audio — under the 2 MB cap (plenty of headroom at this bitrate).
+```python
+import base64, os, subprocess
+import numpy as np, soundfile
+from kokoro_onnx import Kokoro
+
+MODEL_DIR = os.path.expanduser('~/.cache/kokoro-onnx')
+SCENES = [  # (start_s, end_s, line, voice) — one per scene, from the storyboard captions
+    (0.0, 4.0, 'Project name. One-line purpose.', 'af_heart'),
+]
+k = Kokoro(f'{MODEL_DIR}/kokoro-v1.0.onnx', f'{MODEL_DIR}/voices-v1.0.bin')
+buf, sr = None, None
+for start, end, line, voice in SCENES:
+    samples, sr = k.create(line, voice=voice, speed=1.0, lang='en-us')
+    room = end - start - 0.3
+    if len(samples) / sr > room:  # overruns its scene: speed up, never past 1.15
+        speed = min(1.15, len(samples) / sr / room)
+        samples, sr = k.create(line, voice=voice, speed=speed, lang='en-us')
+    if buf is None:
+        buf = np.zeros(30 * sr, dtype=np.float32)
+    at = int((start + 0.15) * sr)
+    clip = samples[: len(buf) - at]
+    buf[at : at + len(clip)] += clip
+soundfile.write('narration.wav', buf, sr)
+subprocess.run(['ffmpeg', '-y', '-i', 'narration.wav', '-ac', '1', '-ar', '24000',
+                '-c:a', 'libmp3lame', '-b:a', '64k', 'narration.mp3'], check=True)
+b64 = base64.b64encode(open('narration.mp3', 'rb').read()).decode()
+html = open('template.html').read()  # your finished HTML with the placeholder below
+html = html.replace('AUDIO_B64_PLACEHOLDER', b64)  # <audio src="data:audio/mpeg;base64,AUDIO_B64_PLACEHOLDER">
+open('demo.html', 'w').write(html)
+```
+
+  Keep the mono track at the model's native 24000 Hz and ~64 kbps — downsampling or dropping below
+  ~48 kbps makes speech sound crushed (a 30 s track is only ~235 KB). Keep the whole document
+  under the 2 MB cap.
 - Wire `play()`/`pause()`/`seek(t)` to the `<audio>` element too (`audio.currentTime = t` on
-  seek) so the narration never drifts from the visual clock, and start muted-fallback: call
-  `.play()` on load, and on rejection (autoplay-blocked browsers) show a small "tap for sound"
-  button instead of failing silently forever.
+  seek) so narration never drifts from the visual clock; call `.play()` on load and, on rejection
+  (autoplay-blocked), show a small "tap for sound" button instead of failing silently.
 - Never write the literal pattern `function (` or `function(` in the inline `<script>` —
-  `project_demo_video_write`'s safety scanner blocks anything matching `/\bFunction\s*\(/i` to
-  stop dynamic `Function(...)` eval, and it cannot tell your IIFE apart from that. Use arrow
-  functions (`() => { ... }`) throughout instead.
-- If pip/network/piper isn't available in this environment, skip audio entirely and ship the
-  silent video rather than failing the whole run — audio is a nice-to-have, never a blocker.
+  `project_demo_video_write`'s safety scanner blocks anything matching `/\bFunction\s*\(/i`.
+  Use arrow functions (`() => { ... }`) throughout.
+- Save the built file by path (see `<process>` step 6). Never retype the base64 audio into a tool
+  argument — a ~300 KB payload retyped by the model is exactly how a run once shipped silent.
 </audio_policy>
 
 <process>
@@ -109,11 +128,13 @@ never calls out to a network TTS service.
 2. Write the claims list: for every goal or feature you plan to show, note the source you read
    it from. Drop anything without a source.
 3. Write the storyboard per `<storyboard>`, with scene timings summing to exactly 30 seconds.
-4. Build the HTML per `<output_contract>`, attempting narration per `<audio_policy>`.
+4. Build the HTML per `<output_contract>` and the narration track per `<audio_policy>`, ending
+   with the final document written to a file (`demo.html`) that contains the `<audio>` tag.
 5. Self-check before saving: scene durations sum to 30, every caption traces to a claim in your
    list, and the document contains none of the forbidden network APIs.
-6. Call `project_demo_video_write` exactly once with `{ html }`. It validates the document and
-   writes it as the project's Demo Video.
+6. Call `project_demo_video_write` exactly once with `{ htmlPath }` — the absolute path of the
+   built file. Never pass the document in `html` (retyping base64 is how narration got lost). It
+   validates the document and writes it as the project's Demo Video.
 7. Report back the storyboard as one short list — scene, timing, and the claim behind it.
 </process>