@longleash/cli 0.1.0-rc.10 → 0.1.0-rc.11

package/runtime/daemon/bin/longleashd.mjs

@@ -5496,6 +5496,8 @@ var sessionStartedPayload = external_exports.object({
   origin: SessionOrigin.optional(),
   /** Who owns the process now; unlike origin, this changes after a safe handoff. */
   controller: external_exports.enum(["longleash", "external"]).optional(),
+  /** Where the process is controlled now; origin remains its historical birthplace. */
+  surface: SessionOrigin.optional(),
   /** Observation-only means the native surface is visible but has not exposed process control. */
   control: external_exports.enum(["full", "observe"]).optional(),
   /**
@@ -5531,6 +5533,8 @@ var sessionStatusPayload = external_exports.object({
   /** LongLeash's own gate for this session: whether it should page the phone at all. */
   gate: SessionGate.optional(),
   controller: external_exports.enum(["longleash", "external"]).optional(),
+  /** Current UI/process surface after a handoff. */
+  surface: SessionOrigin.optional(),
   /** Observation-only sessions are never presented as remotely stoppable or writable. */
   control: external_exports.enum(["full", "observe"]).optional(),
   /** Current overrides. An empty object explicitly means provider defaults. */
@@ -5547,6 +5551,13 @@ var streamDeltaPayload = external_exports.object({
   kind: external_exports.enum(["text", "tool", "thinking", "user"]),
   text: external_exports.string()
 }).passthrough();
+var transcriptResetPayload = external_exports.object({
+  reason: external_exports.enum(["provider-snapshot", "recovery"]),
+  blocks: external_exports.array(external_exports.object({
+    kind: external_exports.enum(["text", "tool", "thinking", "user"]),
+    text: external_exports.string().max(12e4)
+  }).strict()).max(80).optional()
+}).passthrough();
 var QuestionOption = external_exports.object({
   label: external_exports.string().min(1),
   description: external_exports.string().default(""),
@@ -5606,6 +5617,7 @@ function event(type, payload) {
 var SessionEventSchema = external_exports.discriminatedUnion("type", [
   event("session.started", sessionStartedPayload),
   event("session.status", sessionStatusPayload),
+  event("session.transcript.reset", transcriptResetPayload),
   event("stream.delta", streamDeltaPayload),
   event("approval.requested", approvalRequestedPayload),
   event("approval.decided", approvalDecidedPayload),
@@ -5709,6 +5721,20 @@ var takeOverMessage = external_exports.object({
   sessionId: external_exports.string().min(1),
   text: external_exports.string().min(1)
 }).passthrough();
+var reclaimSessionMessage = external_exports.object({
+  ...clientBase,
+  type: external_exports.literal("reclaimSession"),
+  sessionId: external_exports.string().min(1)
+}).passthrough();
+var renameSessionMessage = external_exports.object({
+  ...clientBase,
+  type: external_exports.literal("renameSession"),
+  sessionId: external_exports.string().min(1),
+  title: external_exports.string().trim().min(1).max(80).refine(
+    (value) => value.replace(/[\u0000-\u001f\u007f]/g, "").trim().length > 0,
+    "A session name needs visible text."
+  )
+}).passthrough();
 var previewDelegationMessage = external_exports.object({
   ...clientBase,
   type: external_exports.literal("previewDelegation"),
@@ -5851,6 +5877,8 @@ var ClientMessageSchema = external_exports.discriminatedUnion("type", [
   pushUnsubscribeMessage,
   pushTestMessage,
   takeOverMessage,
+  reclaimSessionMessage,
+  renameSessionMessage,
   setGateMessage,
   previewDelegationMessage,
   startDelegationMessage,
@@ -5884,7 +5912,12 @@ var EventLog = class {
         type TEXT NOT NULL,
         payload TEXT NOT NULL,
         PRIMARY KEY (session_id, seq)
-      )
+      );
+      CREATE TABLE IF NOT EXISTS session_aliases (
+        session_id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
     `);
     this.now = opts.now ?? Date.now;
     this.insertStmt = this.rawDb.prepare(
@@ -5956,6 +5989,16 @@ var EventLog = class {
   latestTimestamp(sessionId) {
     return this.latestTsStmt.get(sessionId).ts;
   }
+  aliasFor(sessionId) {
+    const row = this.rawDb.prepare("SELECT title FROM session_aliases WHERE session_id = ?").get(sessionId);
+    return row?.title;
+  }
+  setAlias(sessionId, title) {
+    this.rawDb.prepare(
+      `INSERT INTO session_aliases (session_id, title, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT(session_id) DO UPDATE SET title = excluded.title, updated_at = excluded.updated_at`
+    ).run(sessionId, title, this.now());
+  }
   pruneBefore(sessionId, uptoExclusive) {
     this.pruneStmt.run(sessionId, uptoExclusive);
   }
@@ -7109,6 +7152,26 @@ var SessionManager = class {
       };
     });
   }
+  /** Find the stable LongLeash card that already owns this provider conversation id. */
+  sessionIdForAgentSession(agentSessionId) {
+    const row = this.approvals.rawDb.prepare("SELECT session_id FROM sessions WHERE agent_session_id = ? ORDER BY started_at DESC LIMIT 1").get(agentSessionId);
+    return row?.session_id;
+  }
+  /** Persist a human label independently of whatever title a provider derives later. */
+  renameSession(sessionId, title, emit = true) {
+    const changed = this.approvals.rawDb.prepare("UPDATE sessions SET title = ? WHERE session_id = ?").run(title, sessionId).changes;
+    if (changed === 0) return false;
+    const live = this.sessions.get(sessionId);
+    if (live !== void 0) live.title = title;
+    this.eventLog.setAlias(sessionId, title);
+    if (emit) {
+      this.emit(sessionId, {
+        type: "session.status",
+        payload: { status: live?.status ?? "waiting", live: live !== void 0, title }
+      });
+    }
+    return true;
+  }
   /**
    * Adopt a finished TERMINAL session so a phone reply can wake it: the
    * conversation lives in Claude Code's own storage, keyed by its resume id,
@@ -7880,6 +7943,7 @@ var ExternalSessions = class {
   stopTimeoutMs;
   onEnded;
   workspace;
+  resolveSessionId;
   unsubscribeWorkspace;
   constructor(opts) {
     this.eventLog = opts.eventLog;
@@ -7899,6 +7963,7 @@ var ExternalSessions = class {
     this.waitForExit = opts.waitForExit ?? ((pid, timeoutMs) => this.pollForExit(pid, timeoutMs));
     this.onEnded = opts.onEnded;
     this.workspace = opts.workspace;
+    this.resolveSessionId = opts.resolveSessionId;
     this.unsubscribeWorkspace = this.workspace?.subscribe(() => this.reconcileWorkspace());
     for (const orphan of this.approvals.closeOrphans(
       "The daemon restarted; this was answered in the terminal."
@@ -7922,6 +7987,38 @@ var ExternalSessions = class {
   hasLiveSession(sessionId) {
     return [...this.sessions.values()].some((session) => session.sessionId === sessionId);
   }
+  renameSession(sessionId, title) {
+    const entry = [...this.sessions.entries()].find(([, session2]) => session2.sessionId === sessionId);
+    if (entry === void 0) return false;
+    const [agentSessionId, session] = entry;
+    session.title = title;
+    session.named = true;
+    this.eventLog.setAlias(sessionId, title);
+    this.persist(agentSessionId, session);
+    this.emit(sessionId, {
+      type: "session.status",
+      payload: {
+        status: session.status,
+        live: true,
+        title,
+        controller: "external",
+        control: session.observedOnly ? "observe" : "full",
+        surface: session.surface
+      }
+    });
+    return true;
+  }
+  /**
+   * End a native writer so the same conversation can be parked on the phone.
+   * Observation-only sessions have no authenticated PID and are never remotely terminated.
+   */
+  async reclaimToPhone(externalSessionId, decidedBy) {
+    const session = [...this.sessions.values()].find((item) => item.sessionId === externalSessionId);
+    if (session === void 0) return "not-found";
+    if (session.observedOnly) return "observe-only";
+    if (session.pid === null) return "unverified";
+    return await this.stop(externalSessionId, decidedBy) ? "reclaimed" : "unverified";
+  }
   /**
    * Take back the sessions a previous run was watching.
    *
@@ -7950,7 +8047,7 @@ var ExternalSessions = class {
         transcriptPath: row.transcriptPath,
         status: "running",
         startedAt: row.startedAt,
-        title: row.title,
+        title: this.eventLog.aliasFor(row.sessionId) ?? row.title,
         pid: row.pid,
         named: true,
         permissionMode: null,
@@ -7968,7 +8065,13 @@ var ExternalSessions = class {
       session.timer.unref?.();
       this.emit(session.sessionId, {
         type: "session.status",
-        payload: { status: "running", live: true }
+        payload: {
+          status: "running",
+          live: true,
+          controller: "external",
+          control: "full",
+          surface: session.surface
+        }
       });
     }
   }
@@ -7984,22 +8087,35 @@ var ExternalSessions = class {
   /** Adopt a Codex transcript observed after startup, including sessions older than the hooks. */
   observeCodexSession(info) {
     const session = this.ensure(info.sessionId, info.cwd, info.transcriptPath, "codex", info.surface, true);
-    if (info.title !== void 0 && info.title !== session.title) {
+    const alias = this.eventLog.aliasFor(session.sessionId);
+    const nextTitle = alias ?? info.title;
+    if (nextTitle !== void 0 && nextTitle !== session.title) {
       session.named = true;
-      session.title = info.title;
+      session.title = nextTitle;
       this.persist(info.sessionId, session);
     }
+    if (session.observedOnly && session.observedFingerprint === void 0) {
+      session.observedFingerprint = JSON.stringify(info.snapshot);
+      this.emit(session.sessionId, {
+        type: "session.transcript.reset",
+        payload: { reason: "provider-snapshot", blocks: info.snapshot }
+      });
+    }
     this.emit(session.sessionId, {
       type: "session.status",
       payload: {
         status: session.status,
         live: true,
         controller: "external",
-        control: "observe",
-        ...info.title === void 0 ? {} : { title: info.title }
+        control: session.observedOnly ? "observe" : "full",
+        ...nextTitle === void 0 ? {} : { title: nextTitle }
       }
     });
-    this.claimWorkspace(session);
+    if (session.observedOnly) {
+      if (session.workspaceConflict !== void 0) delete session.workspaceConflict;
+    } else {
+      this.claimWorkspace(session);
+    }
   }
   /**
    * Stop a terminal session from the phone — for real. The recorded pid is only
@@ -8415,14 +8531,26 @@ var ExternalSessions = class {
         this.persist(claudeSessionId, existing);
         this.emit(existing.sessionId, {
           type: "session.status",
-          payload: { status: existing.status, live: true, controller: "external", control: "full" }
+          payload: {
+            status: existing.status,
+            live: true,
+            controller: "external",
+            control: "full",
+            surface: existing.surface
+          }
         });
+        if (existing.timer === null) {
+          existing.timer = setInterval(() => this.drain(existing), this.pollMs);
+          existing.timer.unref?.();
+          this.drain(existing);
+        }
       }
       return existing;
     }
-    const sessionId = `ext_${claudeSessionId}`;
+    const sessionId = this.resolveSessionId?.(claudeSessionId) ?? `ext_${claudeSessionId}`;
     const replay = this.eventLog.replay(sessionId, 0);
     const hasHistory = replay.gap === false ? replay.events.length > 0 : true;
+    const alias = this.eventLog.aliasFor(sessionId);
     const session = {
       sessionId,
       agent,
@@ -8431,9 +8559,9 @@ var ExternalSessions = class {
       transcriptPath,
       status: "running",
       startedAt: this.now(),
-      title: `${basename3(cwd)} \u2014 ${surface === "vscode" ? "VS Code" : AGENT_LABEL[agent]}`,
+      title: alias ?? `${basename3(cwd)} \u2014 ${surface === "vscode" ? "VS Code" : AGENT_LABEL[agent]}`,
       pid: null,
-      named: false,
+      named: alias !== void 0,
       permissionMode: null,
       gate: "ask",
       offset: (tailOnly || hasHistory) && existsSync(transcriptPath) ? statSync(transcriptPath).size : 0,
@@ -8454,6 +8582,7 @@ var ExternalSessions = class {
           origin: surface,
           controller: "external",
           control: tailOnly ? "observe" : "full",
+          surface,
           resumeId: claudeSessionId
         }
       });
@@ -8464,7 +8593,8 @@ var ExternalSessions = class {
         status: "running",
         live: true,
         controller: "external",
-        control: tailOnly ? "observe" : "full"
+        control: tailOnly ? "observe" : "full",
+        surface
       }
     });
     session.timer = setInterval(() => this.drain(session), this.pollMs);
@@ -8474,7 +8604,9 @@ var ExternalSessions = class {
   }
   /** Retry claims after startup reconciliation released dead managed-session ownership. */
   reconcileWorkspace() {
-    for (const session of this.sessions.values()) this.claimWorkspace(session);
+    for (const session of this.sessions.values()) {
+      if (!session.observedOnly) this.claimWorkspace(session);
+    }
   }
   claimWorkspace(session) {
     if (this.workspace === void 0 || session.cwd.trim() === "") return;
@@ -10412,6 +10544,9 @@ var LongLeashServer = class {
   }
   /** Tell the client what it may do, so it never has to guess a project path. */
   sendHello(connection) {
+    const bySession = new Map(
+      [...this.sessions?.listSessions() ?? [], ...this.external?.listSessions() ?? []].map((session) => [session.sessionId, session])
+    );
     this.sendTo(connection, {
       v: PROTOCOL_VERSION,
       type: "hello",
@@ -10419,8 +10554,9 @@ var LongLeashServer = class {
       roots: this.sessions?.listAllowedRoots() ?? [],
       // Everything the daemon knows about, so a reloaded phone rebuilds instead of showing
       // nothing — including sessions the human started in a terminal.
-      sessions: [...this.sessions?.listSessions() ?? [], ...this.external?.listSessions() ?? []].map((session) => ({
+      sessions: [...bySession.values()].map((session) => ({
         ...session,
+        title: this.eventLog.aliasFor(session.sessionId) ?? session.title,
         lastActivityAt: this.eventLog.latestTimestamp(session.sessionId) || session.startedAt
       })).sort((left, right) => left.startedAt - right.startedAt || left.sessionId.localeCompare(right.sessionId)),
       capabilities: {
@@ -10794,8 +10930,60 @@ var LongLeashServer = class {
       });
       return;
     }
+    if (message.type === "renameSession") {
+      const title = message.title.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+      const externalRenamed = this.external?.renameSession(message.sessionId, title) === true;
+      const managedRenamed = this.sessions.renameSession(message.sessionId, title, !externalRenamed);
+      const renamed = externalRenamed || managedRenamed;
+      this.log(`rename ${message.sessionId} -> ${renamed ? "renamed" : "unknown"}`);
+      this.sendTo(connection, {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        of: "renameSession",
+        sessionId: message.sessionId,
+        outcome: renamed ? "renamed" : "unknown-session"
+      });
+      if (!renamed) {
+        this.sendTo(connection, {
+          v: PROTOCOL_VERSION,
+          type: "error",
+          code: "unknown-session",
+          message: "This conversation is no longer known to the laptop, so its name was not changed."
+        });
+      }
+      return;
+    }
+    if (message.type === "reclaimSession") {
+      const sessionManager = this.sessions;
+      void (async () => {
+        const outcome = await this.external?.reclaimToPhone(message.sessionId, connection.deviceId) ?? "not-found";
+        let reopened = false;
+        if (outcome === "reclaimed") {
+          reopened = await sessionManager.resumeSession(message.sessionId, connection.deviceId);
+        }
+        const success = outcome === "reclaimed" && reopened;
+        this.log(`reclaim ${message.sessionId} -> ${success ? "phone-ready" : outcome}`);
+        this.sendTo(connection, {
+          v: PROTOCOL_VERSION,
+          type: "ack",
+          of: "reclaimSession",
+          sessionId: message.sessionId,
+          outcome: success ? "phone-ready" : outcome
+        });
+        if (!success) {
+          const detail = outcome === "observe-only" ? "This VS Code conversation is visible, but its lifecycle hook has not provided a verified process handle. Stop it in VS Code; LongLeash will make the same conversation reopenable when SessionEnd arrives." : outcome === "unverified" ? "LongLeash could not verify that the Terminal or VS Code writer exited, so it kept control there. Nothing was started on the phone." : outcome === "reclaimed" ? "The native writer ended, but this provider did not expose a recoverable conversation point. Nothing new was started." : "This native session is no longer connected to the laptop daemon.";
+          this.sendTo(connection, {
+            v: PROTOCOL_VERSION,
+            type: "error",
+            code: "cannot-reclaim",
+            message: detail
+          });
+        }
+      })();
+      return;
+    }
     if (message.type === "setGate") {
-      const applied = this.external !== null && message.sessionId.startsWith("ext_") ? this.external.setGate(message.sessionId, message.gate) : false;
+      const applied = this.external !== null && this.external.hasLiveSession(message.sessionId) ? this.external.setGate(message.sessionId, message.gate) : false;
       this.log(`gate ${message.sessionId} -> ${message.gate}${applied ? "" : " (unknown session)"}`);
       this.sendTo(connection, {
         v: PROTOCOL_VERSION,
@@ -10933,7 +11121,7 @@ var LongLeashServer = class {
       return;
     }
     if (message.type === "stopSession") {
-      if (message.sessionId.startsWith("ext_") && this.external !== null) {
+      if (this.external?.hasLiveSession(message.sessionId) === true) {
         const sessions = this.sessions;
         void this.external.stop(message.sessionId, connection.deviceId).then((stopped) => {
           if (stopped) {
@@ -12325,8 +12513,11 @@ function inside(root, candidate) {
 }
 function inspectCodexTranscript(path, roots2, maxTailBytes = MAX_INITIAL_TAIL) {
   let size;
+  let activityAt;
   try {
-    size = statSync2(path).size;
+    const stats = statSync2(path);
+    size = stats.size;
+    activityAt = stats.mtimeMs;
   } catch {
     return null;
   }
@@ -12345,6 +12536,7 @@ function inspectCodexTranscript(path, roots2, maxTailBytes = MAX_INITIAL_TAIL) {
     const lines = tailText.split("\n");
     if (tailOffset > 0) lines.shift();
     let title;
+    const snapshot = [];
     for (let index = lines.length - 1; index >= 0; index -= 1) {
       const line = lines[index];
       if (!line?.includes('"role":"user"')) continue;
@@ -12359,8 +12551,31 @@ function inspectCodexTranscript(path, roots2, maxTailBytes = MAX_INITIAL_TAIL) {
       } catch {
       }
     }
+    for (const line of lines) {
+      if (line.length === 0 || line.length > 1e6) continue;
+      try {
+        for (const delta of transcriptDeltas(JSON.parse(line))) {
+          if (delta.type !== "stream.delta" || delta.payload.text.trim() === "") continue;
+          snapshot.push({ kind: delta.payload.kind, text: delta.payload.text });
+        }
+      } catch {
+      }
+    }
+    let retained = snapshot.slice(-80);
+    let characters = retained.reduce((sum, block) => sum + block.text.length, 0);
+    while (retained.length > 1 && characters > 12e4) {
+      characters -= retained.shift()?.text.length ?? 0;
+    }
     if (title === void 0) title = titleFrom(latestUserText(tailText) ?? "") ?? void 0;
-    return { sessionId, cwd, transcriptPath: path, surface, ...title === void 0 ? {} : { title } };
+    return {
+      sessionId,
+      cwd,
+      transcriptPath: path,
+      surface,
+      activityAt,
+      snapshot: retained,
+      ...title === void 0 ? {} : { title }
+    };
   } catch {
     return null;
   }
@@ -12593,6 +12808,7 @@ async function startDaemon(options) {
     registry: sessionRegistry,
     onEvent: mirror,
     workspace,
+    resolveSessionId: (agentSessionId) => sessions.sessionIdForAgentSession(agentSessionId),
     // A live socket means the app is open and can answer in seconds. A push REGISTRATION is
     // permanent and proves nothing about whether anyone is looking — treating it as presence
     // is what froze the keyboard for two minutes with the phone in a drawer.
@@ -12617,7 +12833,7 @@ async function startDaemon(options) {
   external.startSweeping();
   const delegationStore = new DelegationStore(approvals.rawDb);
   workspace.reconcile({
-    activeSessionIds: external.listSessions().map((session) => session.sessionId),
+    activeSessionIds: external.listSessions().filter((session) => session.control === "full").map((session) => session.sessionId),
     validReservationIds: delegationStore.list().filter((record) => record.status === "starting").map((record) => record.delegationId)
   });
   external.reconcileWorkspace();