@keyou007/agent-bot 0.1.20-alpha.1 → 0.1.21

package/src/runtime/types.ts

@@ -73,6 +73,17 @@ export type AgentEvent =
       turnId: string;
       lastTokens: number;
       cumulativeTokens: number;
+      contextTokens?: number;
+    }
+  | {
+      type: "context_compaction";
+      sessionId: string;
+      turnId: string;
+      phase: "started" | "completed";
+      compactionId?: string;
+      timestampMs?: number;
+      turnCount?: number;
+      storageBytes?: number;
     }
   | {
       type: "progress";
@@ -113,6 +124,11 @@ export interface RemoteCompletedTurnSummary {
   completedAt?: number;
 }
 
+export interface RemoteTurnPage {
+  turns: RemoteCompletedTurnSummary[];
+  nextCursor?: string;
+}
+
 export interface RemoteSessionSummary {
   id: string;
   title?: string;
@@ -151,6 +167,11 @@ export interface RemoteSessionActivity {
   activeTurnId?: string;
 }
 
+export interface RemoteSessionMetrics {
+  turnCount: number;
+  storageBytes?: number;
+}
+
 export interface RuntimeSession {
   localSessionId: string;
   remoteSessionId: string;
@@ -163,6 +184,8 @@ export interface RuntimeSession {
   reasoningEffort?: string;
   permissionMode: PermissionMode;
   activeTurnId?: string;
+  // Returned by reconciliation so status callers can reuse the same observation.
+  remoteSummary?: RemoteSessionSummary;
 }
 
 export interface CreateRuntimeSessionInput {
@@ -229,8 +252,10 @@ export interface AgentRuntime {
   getSession(localSessionId: string): RuntimeSession | undefined;
   readSessionMetadata(remoteSessionId: string): Promise<RuntimeSessionMetadata>;
   listRemoteSessions?(input?: { searchTerm?: string; cursor?: string; limit?: number }): Promise<RemoteSessionPage>;
-  readRemoteSession?(remoteSessionId: string): Promise<RemoteSessionSummary>;
+  readRemoteSession?(remoteSessionId: string, view?: "metadata" | "latest" | "latest-full"): Promise<RemoteSessionSummary>;
+  readRemoteSessionMetrics?(remoteSessionId: string): Promise<RemoteSessionMetrics>;
   readRemoteForkSource?(remoteSessionId: string): Promise<RemoteSessionSummary>;
+  listRemoteTurnSummaries?(remoteSessionId: string, input: { cursor?: string; limit: number }): Promise<RemoteTurnPage>;
   inspectRemoteSessionActivity?(remoteSessionId: string): Promise<RemoteSessionActivity>;
   synchronizeSession(sessionId: string): Promise<RuntimeSession>;
   startTurn(sessionId: string, prompt: RuntimePrompt): Promise<string>;
@@ -246,9 +271,14 @@ export interface AgentRuntime {
   setModel(sessionId: string, model: string): Promise<void>;
   setReasoningEffort(sessionId: string, effort: string): Promise<void>;
   setPermissionMode(sessionId: string, mode: PermissionMode): Promise<void>;
-  setExecutionSettings?(sessionId: string, settings: RuntimeExecutionSettings): Promise<RuntimeSession>;
+  setExecutionSettings?(
+    sessionId: string,
+    settings: RuntimeExecutionSettings,
+    // Called after remote verification, before releasing the task's operation lock.
+    persist?: (session: RuntimeSession) => Promise<void>,
+  ): Promise<RuntimeSession>;
   respondToApproval(sessionId: string, requestId: string, decision: ApprovalDecision): Promise<void>;
-  listModels(): Promise<ModelOption[]>;
+  listModels(modelProvider?: string, fallbackModel?: string): Promise<ModelOption[]>;
   listModelProviders?(): Promise<ModelProviderOption[]>;
   release?(options?: { force?: boolean }): Promise<RuntimeReleaseResult>;
   onEvent(listener: (event: RuntimeEvent) => void): () => void;

package/src/state/StateStore.ts

@@ -95,6 +95,21 @@ export interface CompletedTurnSnapshotRecord {
   updatedAt: string;
 }
 
+export interface CompletedTurnIndexRecord {
+  turnId: string;
+  parentTurnId?: string;
+  timestamp: number;
+  updatedAt: string;
+}
+
+export interface TurnPromptSummary {
+  status?: string;
+  prompt?: string;
+  taskTitle?: string;
+  startedAt?: number;
+  completedAt?: number;
+}
+
 export interface ImportedCompletedTurnRecord {
   turnId: string;
   snapshot: unknown;
@@ -1032,6 +1047,21 @@ export class StateStore {
     return row ? JSON.parse(row.snapshot_json) : undefined;
   }
 
+  getTurnPromptSummary(turnId: string): TurnPromptSummary | undefined {
+    const row = this.db.prepare(`SELECT
+      json_extract(snapshot_json, '$.status') AS status,
+      json_extract(snapshot_json, '$.prompt') AS prompt,
+      json_extract(snapshot_json, '$.taskTitle') AS taskTitle,
+      json_extract(snapshot_json, '$.startedAt') AS startedAt,
+      json_extract(snapshot_json, '$.completedAt') AS completedAt
+      FROM turn_snapshots WHERE turn_id = ?`).get(turnId) as TurnPromptSummary | undefined;
+    return row ? {
+      status: row.status ?? undefined, prompt: row.prompt ?? undefined,
+      taskTitle: row.taskTitle ?? undefined, startedAt: row.startedAt ?? undefined,
+      completedAt: row.completedAt ?? undefined,
+    } : undefined;
+  }
+
   findLatestTurnSnapshotForSession(localSessionId: string): PersistedTurnSnapshotRecord | undefined {
     const row = this.db.prepare(`
       SELECT turn_id, local_session_id, context_key, snapshot_json, updated_at
@@ -1096,16 +1126,16 @@ export class StateStore {
       : undefined;
   }
 
-  saveTurnParent(turnId: string, localSessionId: string, parentTurnId?: string): void {
+  saveTurnParent(turnId: string, localSessionId: string, parentTurnId?: string, replaceExisting = false): void {
     this.db.prepare(`
       INSERT INTO turn_parent_links (
         turn_id, local_session_id, parent_turn_id, created_at
       ) VALUES (?, ?, ?, ?)
       ON CONFLICT(turn_id) DO UPDATE SET
         parent_turn_id = excluded.parent_turn_id
-      WHERE turn_parent_links.parent_turn_id IS NULL
+      WHERE (turn_parent_links.parent_turn_id IS NULL OR ?)
         AND excluded.parent_turn_id IS NOT NULL
-    `).run(turnId, localSessionId, parentTurnId ?? null, new Date().toISOString());
+    `).run(turnId, localSessionId, parentTurnId ?? null, new Date().toISOString(), Number(replaceExisting));
   }
 
   importCompletedTurnHistory(input: {
@@ -1114,6 +1144,7 @@ export class StateStore {
     agentName: string;
     remoteSessionId: string;
     turns: ImportedCompletedTurnRecord[];
+    replaceParents?: boolean;
   }): void {
     const importHistory = this.db.transaction(() => {
       let parentTurnId: string | undefined;
@@ -1140,7 +1171,7 @@ export class StateStore {
           input.remoteSessionId,
           turn.updatedAt,
         );
-        this.saveTurnParent(turn.turnId, input.localSessionId, parentTurnId);
+        this.saveTurnParent(turn.turnId, input.localSessionId, parentTurnId, input.replaceParents);
         parentTurnId = turn.turnId;
       }
     });
@@ -1156,13 +1187,13 @@ export class StateStore {
     return row?.parent_turn_id ?? undefined;
   }
 
-  findLatestCompletedTurnId(localSessionId: string, contextKey: string): string | undefined {
+  findLatestCompletedTurnId(localSessionId: string, contextKey?: string): string | undefined {
     const row = this.db
       .prepare(`
         SELECT turn_id
         FROM turn_snapshots
         WHERE local_session_id = ?
-          AND context_key = ?
+          AND (? IS NULL OR context_key = ?)
           AND json_extract(snapshot_json, '$.status') = 'completed'
         ORDER BY
           coalesce(
@@ -1173,7 +1204,7 @@ export class StateStore {
           updated_at DESC
         LIMIT 1
       `)
-      .get(localSessionId, contextKey) as { turn_id: string } | undefined;
+      .get(localSessionId, contextKey ?? null, contextKey ?? null) as { turn_id: string } | undefined;
     return row?.turn_id;
   }
 
@@ -1296,23 +1327,60 @@ export class StateStore {
   }
 
   listTaskTurnGraph(localSessionId: string): CompletedTurnSnapshotRecord[] {
-    this.backfillTurnParents(localSessionId);
-    const records = new Map(
-      this.listCompletedTurnGraphRows(localSessionId).map((record) => [record.turnId, record]),
-    );
+    return this.listTaskTurnGraphIndex(localSessionId).map((record) => ({
+      ...record, snapshot: this.getTurnSnapshot(record.turnId),
+    }));
+  }
+
+  countTaskTurns(localSessionId: string): number {
+    const turnIds = new Set(this.listTaskTurnGraphIndex(localSessionId).map((turn) => turn.turnId));
+    const own = this.db.prepare(
+      "SELECT turn_id AS turnId FROM turn_snapshots WHERE local_session_id = ?",
+    ).all(localSessionId) as Array<{ turnId: string }>;
+    for (const turn of own) turnIds.add(turn.turnId);
+    return turnIds.size;
+  }
+
+  listTaskTurnGraphIndex(localSessionId: string): CompletedTurnIndexRecord[] {
+    const backfilled = new Set<string>();
+    const backfill = (id: string): void => {
+      if (backfilled.has(id)) return;
+      this.backfillTurnParents(id);
+      backfilled.add(id);
+    };
+    backfill(localSessionId);
+    const projection = `SELECT ts.turn_id AS turnId, tpl.parent_turn_id AS parentTurnId,
+      ts.local_session_id AS localSessionId, ts.updated_at AS updatedAt,
+      coalesce(json_extract(ts.snapshot_json, '$.completedAt'),
+        json_extract(ts.snapshot_json, '$.startedAt'),
+        cast(strftime('%s', ts.updated_at) AS INTEGER) * 1000, 0) AS timestamp
+      FROM turn_snapshots ts LEFT JOIN turn_parent_links tpl ON tpl.turn_id = ts.turn_id
+      WHERE json_extract(ts.snapshot_json, '$.status') = 'completed'`;
+    type Row = CompletedTurnIndexRecord & { localSessionId: string; parentTurnId: string | undefined };
+    const normalize = (row: Row): CompletedTurnIndexRecord => ({
+      turnId: row.turnId, parentTurnId: row.parentTurnId ?? undefined,
+      timestamp: row.timestamp, updatedAt: row.updatedAt,
+    });
+    const own = this.db.prepare(`${projection} AND ts.local_session_id = ?`).all(localSessionId) as Row[];
+    const read = this.db.prepare(`${projection} AND ts.turn_id = ?`);
+    const records = new Map(own.map((row) => [row.turnId, normalize(row)]));
     let ancestorTurnId = this.findForkSourceTurnId(localSessionId)
       ?? this.findCrossSessionParentTurnId(localSessionId);
     const visited = new Set<string>();
 
     while (ancestorTurnId && !visited.has(ancestorTurnId)) {
       visited.add(ancestorTurnId);
-      const ancestor = this.getCompletedTurnGraphRecord(ancestorTurnId);
+      let ancestor = read.get(ancestorTurnId) as Row | undefined;
       if (!ancestor) break;
-      records.set(ancestor.turnId, ancestor);
+      if (!backfilled.has(ancestor.localSessionId)) {
+        backfill(ancestor.localSessionId);
+        ancestor = read.get(ancestorTurnId) as Row;
+      }
+      records.set(ancestor.turnId, normalize(ancestor));
       ancestorTurnId = ancestor.parentTurnId;
     }
 
-    return [...records.values()].sort(compareCompletedTurnSnapshots);
+    return [...records.values()].sort((a, b) => b.timestamp - a.timestamp || b.updatedAt.localeCompare(a.updatedAt));
   }
 
   getForkHistorySource(localSessionId: string): ForkHistorySourceRecord | undefined {
@@ -1340,54 +1408,16 @@ export class StateStore {
     };
   }
 
-  hasImportedForkTurnHistory(localSessionId: string): boolean {
+  hasImportedForkTurnHistory(localSessionId: string, sourceRemoteSessionId?: string, sourceTurnId?: string): boolean {
     return Boolean(this.db.prepare(`
       SELECT 1
       FROM audit_events
       WHERE event_type = 'fork_turn_history_imported'
         AND json_extract(payload_json, '$.forkedLocalSessionId') = ?
+        AND (? IS NULL OR json_extract(payload_json, '$.sourceRemoteSessionId') = ?)
+        AND (? IS NULL OR json_extract(payload_json, '$.sourceTurnId') = ?)
       LIMIT 1
-    `).get(localSessionId));
-  }
-
-  private listCompletedTurnGraphRows(localSessionId: string): CompletedTurnSnapshotRecord[] {
-    const rows = this.db.prepare(`
-      SELECT ts.turn_id, tpl.parent_turn_id, ts.snapshot_json, ts.updated_at
-      FROM turn_snapshots ts
-      LEFT JOIN turn_parent_links tpl ON tpl.turn_id = ts.turn_id
-      WHERE ts.local_session_id = ?
-        AND json_extract(ts.snapshot_json, '$.status') = 'completed'
-    `).all(localSessionId) as Array<{
-      turn_id: string;
-      parent_turn_id: string | null;
-      snapshot_json: string;
-      updated_at: string;
-    }>;
-    return rows.map(mapCompletedTurnSnapshot);
-  }
-
-  private getCompletedTurnGraphRecord(turnId: string): CompletedTurnSnapshotRecord | undefined {
-    const owner = this.db.prepare(`
-      SELECT local_session_id
-      FROM turn_snapshots
-      WHERE turn_id = ?
-        AND json_extract(snapshot_json, '$.status') = 'completed'
-    `).get(turnId) as { local_session_id: string } | undefined;
-    if (!owner) return undefined;
-    this.backfillTurnParents(owner.local_session_id);
-    const row = this.db.prepare(`
-      SELECT ts.turn_id, tpl.parent_turn_id, ts.snapshot_json, ts.updated_at
-      FROM turn_snapshots ts
-      LEFT JOIN turn_parent_links tpl ON tpl.turn_id = ts.turn_id
-      WHERE ts.turn_id = ?
-        AND json_extract(ts.snapshot_json, '$.status') = 'completed'
-    `).get(turnId) as {
-      turn_id: string;
-      parent_turn_id: string | null;
-      snapshot_json: string;
-      updated_at: string;
-    } | undefined;
-    return row ? mapCompletedTurnSnapshot(row) : undefined;
+    `).get(localSessionId, sourceRemoteSessionId ?? null, sourceRemoteSessionId ?? null, sourceTurnId ?? null, sourceTurnId ?? null));
   }
 
   private findForkSourceTurnId(localSessionId: string): string | undefined {
@@ -2289,40 +2319,6 @@ function mapTurnAttempt(row: TurnAttemptRow): TurnAttemptRecord {
   };
 }
 
-function mapCompletedTurnSnapshot(row: {
-  turn_id: string;
-  parent_turn_id: string | null;
-  snapshot_json: string;
-  updated_at: string;
-}): CompletedTurnSnapshotRecord {
-  return {
-    turnId: row.turn_id,
-    parentTurnId: row.parent_turn_id ?? undefined,
-    snapshot: JSON.parse(row.snapshot_json),
-    updatedAt: row.updated_at,
-  };
-}
-
-function compareCompletedTurnSnapshots(
-  left: CompletedTurnSnapshotRecord,
-  right: CompletedTurnSnapshotRecord,
-): number {
-  const timeDifference = completedTurnTimestamp(right) - completedTurnTimestamp(left);
-  return timeDifference || right.updatedAt.localeCompare(left.updatedAt);
-}
-
-function completedTurnTimestamp(record: CompletedTurnSnapshotRecord): number {
-  const snapshot = record.snapshot && typeof record.snapshot === "object"
-    ? record.snapshot as { completedAt?: unknown; startedAt?: unknown }
-    : undefined;
-  const timestamp = typeof snapshot?.completedAt === "number"
-    ? snapshot.completedAt
-    : typeof snapshot?.startedAt === "number"
-      ? snapshot.startedAt
-      : Date.parse(record.updatedAt);
-  return Number.isFinite(timestamp) ? timestamp : 0;
-}
-
 function stringValue(value: unknown): string | undefined {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }

package/src/utils/formatStorageSize.ts

@@ -0,0 +1,13 @@
+export function formatStorageSize(bytes: number): string {
+  const normalized = Math.max(0, Math.round(bytes));
+  if (normalized < 1_024) return `${normalized} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = normalized / 1_024;
+  let unitIndex = 0;
+  while (value >= 1_024 && unitIndex < units.length - 1) {
+    value /= 1_024;
+    unitIndex += 1;
+  }
+  const precision = value >= 100 ? 0 : value >= 10 ? 1 : 2;
+  return `${Number(value.toFixed(precision))} ${units[unitIndex]}`;
+}

package/src/utils/semanticVersion.ts

@@ -0,0 +1,28 @@
+export function compareSemanticVersions(left: string, right: string): number {
+  const parse = (value: string) => /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u.exec(value);
+  const a = parse(left);
+  const b = parse(right);
+  if (!a || !b) return 0;
+  for (let i = 1; i <= 3; i += 1) {
+    const difference = Number(a[i]) - Number(b[i]);
+    if (difference) return difference;
+  }
+  if (!a[4] && !b[4]) return 0;
+  if (!a[4]) return 1;
+  if (!b[4]) return -1;
+  const aParts = a[4].split(".");
+  const bParts = b[4].split(".");
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i += 1) {
+    const x = aParts[i];
+    const y = bParts[i];
+    if (x === undefined) return -1;
+    if (y === undefined) return 1;
+    if (x === y) continue;
+    const nx = /^\d+$/u.test(x);
+    const ny = /^\d+$/u.test(y);
+    if (nx && ny) return Number(x) - Number(y);
+    if (nx !== ny) return nx ? -1 : 1;
+    return x.localeCompare(y);
+  }
+  return 0;
+}