@phnx-labs/agents-cli 1.20.92 → 1.21.0

package/dist/lib/hq/floor.d.ts

@@ -1,87 +0,0 @@
-import type { ActiveSession } from '../session/active.js';
-import type { OpenBlock } from '../feed.js';
-import type { AgentStatusDetail, TaskInfo } from '../teams/api.js';
-export type HqRoomKind = 'team' | 'machine' | 'lobby';
-export type HqAgentMood = 'working' | 'waiting' | 'blocked' | 'celebrating' | 'done' | 'idle';
-export type HqAmbientKind = 'needs_input' | 'error' | 'pr' | 'team_active' | 'idle_scene';
-export interface HqAction {
-    id: string;
-    label: string;
-    command: string[];
-    target: {
-        kind: 'agent' | 'room' | 'floor';
-        id: string;
-    };
-    destructive?: boolean;
-    input?: Array<{
-        name: string;
-        label: string;
-        placeholder?: string;
-        required?: boolean;
-    }>;
-}
-export interface HqRoom {
-    id: string;
-    kind: HqRoomKind;
-    name: string;
-    machine?: string;
-    team?: string;
-    counts: {
-        agents: number;
-        needsInput: number;
-        running: number;
-        failed: number;
-    };
-    actions: HqAction[];
-}
-export interface HqAgent {
-    id: string;
-    label: string;
-    agent: string;
-    roomId: string;
-    mood: HqAgentMood;
-    status: string;
-    activity?: string;
-    preview?: string;
-    machine?: string;
-    team?: string;
-    teammate?: string;
-    sessionId?: string;
-    mailboxId?: string;
-    pid?: number;
-    prUrl?: string;
-    ticketId?: string;
-    actions: HqAction[];
-}
-export interface HqAmbientEvent {
-    id: string;
-    kind: HqAmbientKind;
-    roomId: string;
-    agentId?: string;
-    label: string;
-    intensity: 'low' | 'medium' | 'high';
-}
-export interface HqFloorSnapshot {
-    version: 1;
-    generatedAt: string;
-    counters: {
-        rooms: number;
-        agents: number;
-        teams: number;
-        needsInput: number;
-        failed: number;
-        prs: number;
-    };
-    rooms: HqRoom[];
-    agents: HqAgent[];
-    ambientEvents: HqAmbientEvent[];
-    actions: HqAction[];
-}
-export interface BuildHqFloorInput {
-    generatedAt?: Date;
-    sessions: ActiveSession[];
-    teams: TaskInfo[];
-    teammatesByTeam: Map<string, AgentStatusDetail[]>;
-    blocks: OpenBlock[];
-}
-export declare function buildHqFloor(input: BuildHqFloorInput): HqFloorSnapshot;

package/dist/lib/hq/floor.js

@@ -1,243 +0,0 @@
-import { mailboxIdForActiveSession } from '../mailbox-target.js';
-function slug(s) {
-    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'unknown';
-}
-function roomIdForTeam(team) {
-    return `team:${slug(team)}`;
-}
-function roomIdForMachine(machine) {
-    return `machine:${slug(machine)}`;
-}
-function agentDisplayName(session) {
-    return session.name || session.label || session.agentId || session.sessionId?.slice(0, 8) || session.kind;
-}
-function sessionMachine(session) {
-    return session.machine || session.provenance?.host || session.host || 'local';
-}
-function teamForSession(session, teammatesById) {
-    if (session.teamName)
-        return session.teamName;
-    if (session.agentId && teammatesById.has(session.agentId))
-        return teammatesById.get(session.agentId).team;
-    return undefined;
-}
-function teammateName(session, teammatesById) {
-    if (session.agentId && teammatesById.has(session.agentId)) {
-        return teammatesById.get(session.agentId).name || session.agentId.slice(0, 8);
-    }
-    return session.agentId;
-}
-function moodForSession(session, hasOpenBlock) {
-    if (session.status === 'abandoned')
-        return 'blocked';
-    // A crashed session is NOT `done` — it stopped without finishing, and its last
-    // parsed turn often still says `working`, which would otherwise reach the Floor
-    // as a happily-running agent. Both lost-host states need a human.
-    if (session.status === 'crashed')
-        return 'blocked';
-    // An orphaned session that is genuinely mid-question needs an answer; one that
-    // is merely idle-and-unwatched needs someone to reattach or clean it up. Same
-    // distinction `isAwaitingUser` draws — giving both the high-intensity "needs
-    // input" alert would train the operator to ignore it.
-    if (session.status === 'orphaned') {
-        return session.activity === 'waiting_input' ? 'waiting' : 'blocked';
-    }
-    if (session.status === 'closed')
-        return 'done';
-    if (session.status === 'input_required' || session.activity === 'waiting_input' || hasOpenBlock)
-        return 'waiting';
-    if (session.rateLimited)
-        return 'blocked';
-    if (session.pr)
-        return 'celebrating';
-    if (session.status === 'running' || session.activity === 'working')
-        return 'working';
-    return 'idle';
-}
-function action(id, label, command, target, extra = {}) {
-    return { id, label, command, target, ...extra };
-}
-function agentActions(agentId, session, mailboxId, team, teammate) {
-    const actions = [];
-    if (mailboxId) {
-        actions.push(action(`agent:${agentId}:message`, 'Message', ['message', mailboxId, '{message}', '--surface', 'hq'], { kind: 'agent', id: agentId }, { input: [{ name: 'message', label: 'Message', placeholder: 'What should this agent do next?', required: true }] }));
-        actions.push(action(`agent:${agentId}:stop`, 'Stop', ['feed', '--kill', mailboxId], { kind: 'agent', id: agentId }, { destructive: true }));
-    }
-    if (team && teammate) {
-        actions.push(action(`agent:${agentId}:team-stop`, 'Stop teammate', ['teams', 'stop', team, teammate], { kind: 'agent', id: agentId }, { destructive: true }));
-    }
-    if (session.sessionId) {
-        actions.push(action(`agent:${agentId}:transcript`, 'Transcript', ['sessions', session.sessionId, '--markdown'], { kind: 'agent', id: agentId }));
-    }
-    return actions;
-}
-function spawnActionForRoom(roomId, team) {
-    if (team) {
-        return action(`room:${roomId}:spawn-teammate`, 'Spawn teammate', ['teams', 'add', team, '{agent}', '{task}', '--name', '{name}', '--mode', 'edit'], { kind: 'room', id: roomId }, {
-            input: [
-                { name: 'agent', label: 'Agent', placeholder: 'claude', required: true },
-                { name: 'name', label: 'Name', placeholder: 'frontend', required: true },
-                { name: 'task', label: 'Task', placeholder: 'Implement the next scoped task', required: true },
-            ],
-        });
-    }
-    return action(`room:${roomId}:spawn-run`, 'Run agent', ['run', '{agent}', '{task}', '--name', '{name}'], { kind: 'room', id: roomId }, {
-        input: [
-            { name: 'agent', label: 'Agent', placeholder: 'claude', required: true },
-            { name: 'name', label: 'Name', placeholder: 'investigate', required: true },
-            { name: 'task', label: 'Task', placeholder: 'Investigate this room', required: true },
-        ],
-    });
-}
-export function buildHqFloor(input) {
-    const generatedAt = (input.generatedAt ?? new Date()).toISOString();
-    const teammatesById = new Map();
-    for (const [team, teammates] of input.teammatesByTeam) {
-        for (const teammate of teammates)
-            teammatesById.set(teammate.agent_id, { ...teammate, team });
-    }
-    const openBlocksByMailbox = new Map();
-    for (const block of input.blocks) {
-        const blocks = openBlocksByMailbox.get(block.mailboxId) || [];
-        blocks.push(block);
-        openBlocksByMailbox.set(block.mailboxId, blocks);
-    }
-    const rooms = new Map();
-    const ensureRoom = (room) => {
-        const existing = rooms.get(room.id);
-        if (existing)
-            return existing;
-        const created = {
-            ...room,
-            counts: { agents: 0, needsInput: 0, running: 0, failed: 0 },
-            actions: [spawnActionForRoom(room.id, room.team)],
-        };
-        rooms.set(room.id, created);
-        return created;
-    };
-    for (const team of input.teams) {
-        ensureRoom({ id: roomIdForTeam(team.task_name), kind: 'team', name: team.task_name, team: team.task_name });
-    }
-    const agents = [];
-    for (const session of input.sessions) {
-        const team = teamForSession(session, teammatesById);
-        const machine = sessionMachine(session);
-        const room = team
-            ? ensureRoom({ id: roomIdForTeam(team), kind: 'team', name: team, team })
-            : ensureRoom({ id: roomIdForMachine(machine), kind: 'machine', name: machine, machine });
-        const mailboxId = mailboxIdForActiveSession(session);
-        const blocks = mailboxId ? openBlocksByMailbox.get(mailboxId) || [] : [];
-        const id = session.agentId || session.sessionId || `${session.kind}:${agents.length + 1}`;
-        const mood = moodForSession(session, blocks.length > 0);
-        const teammate = teammateName(session, teammatesById);
-        room.counts.agents++;
-        if (mood === 'waiting')
-            room.counts.needsInput++;
-        if (session.status === 'running')
-            room.counts.running++;
-        if (mood === 'blocked')
-            room.counts.failed++;
-        agents.push({
-            id,
-            label: agentDisplayName(session),
-            agent: session.kind,
-            roomId: room.id,
-            mood,
-            status: session.status,
-            activity: session.activity,
-            preview: session.preview || session.question?.text,
-            machine,
-            team,
-            teammate,
-            sessionId: session.sessionId,
-            mailboxId,
-            pid: session.pid,
-            prUrl: session.pr?.url,
-            ticketId: session.ticket?.id,
-            actions: agentActions(id, session, mailboxId, team, teammate),
-        });
-    }
-    const ambientEvents = [];
-    for (const agent of agents) {
-        if (agent.mood === 'waiting') {
-            ambientEvents.push({
-                id: `needs-input:${agent.id}`,
-                kind: 'needs_input',
-                roomId: agent.roomId,
-                agentId: agent.id,
-                label: `${agent.label} needs input`,
-                intensity: 'high',
-            });
-        }
-        else if (agent.mood === 'blocked') {
-            ambientEvents.push({
-                id: `blocked:${agent.id}`,
-                kind: 'error',
-                roomId: agent.roomId,
-                agentId: agent.id,
-                label: `${agent.label} is blocked`,
-                intensity: 'high',
-            });
-        }
-        else if (agent.mood === 'celebrating' && agent.prUrl) {
-            ambientEvents.push({
-                id: `pr:${agent.id}`,
-                kind: 'pr',
-                roomId: agent.roomId,
-                agentId: agent.id,
-                label: `${agent.label} opened a PR`,
-                intensity: 'medium',
-            });
-        }
-    }
-    for (const room of rooms.values()) {
-        const roomAgents = agents.filter((agent) => agent.roomId === room.id);
-        if (room.kind === 'team' && room.counts.running > 0) {
-            ambientEvents.push({
-                id: `team-active:${room.id}`,
-                kind: 'team_active',
-                roomId: room.id,
-                label: `${room.name} has ${room.counts.running} active teammate${room.counts.running === 1 ? '' : 's'}`,
-                intensity: 'low',
-            });
-        }
-        if (roomAgents.length > 0 && roomAgents.every((agent) => agent.mood === 'idle')) {
-            ambientEvents.push({
-                id: `idle:${room.id}`,
-                kind: 'idle_scene',
-                roomId: room.id,
-                label: `${room.name} is calm`,
-                intensity: 'low',
-            });
-        }
-    }
-    const floorActions = [
-        action('floor:create-team', 'Create team room', ['teams', 'create', '{team}', '--description', '{description}'], { kind: 'floor', id: 'floor' }, {
-            input: [
-                { name: 'team', label: 'Team', placeholder: 'release-squad', required: true },
-                { name: 'description', label: 'Description', placeholder: 'What this room owns' },
-            ],
-        }),
-    ];
-    const roomList = [...rooms.values()].sort((a, b) => {
-        if (a.kind !== b.kind)
-            return a.kind === 'team' ? -1 : 1;
-        return a.name.localeCompare(b.name);
-    });
-    return {
-        version: 1,
-        generatedAt,
-        counters: {
-            rooms: roomList.length,
-            agents: agents.length,
-            teams: input.teams.length,
-            needsInput: agents.filter((agent) => agent.mood === 'waiting').length,
-            failed: agents.filter((agent) => agent.mood === 'blocked').length,
-            prs: agents.filter((agent) => agent.prUrl).length,
-        },
-        rooms: roomList,
-        agents,
-        ambientEvents,
-        actions: floorActions,
-    };
-}

package/dist/lib/session/sync/crdt.d.ts

@@ -1,44 +0,0 @@
-/**
- * CRDT merge for agent transcripts.
- *
- * A transcript (Claude JSONL, Codex JSONL, …) is an append-only log of
- * immutable events: each line is written once and never rewritten, and Claude
- * already tolerates branches within one file (parentUuid fan-out). That makes a
- * transcript a grow-only set (G-Set) of events, and merging two copies of the
- * same session is a set union — associative, commutative, idempotent. Two
- * machines that each appended to the same session therefore converge to the
- * exact same merged file regardless of sync order or timing, with zero conflict
- * resolution and zero data loss.
- *
- * Events are identified by the SHA-256 of their raw line bytes. We deliberately
- * do NOT key on a per-event `uuid`: Codex lines carry no id, and because an
- * event is written exactly once and then copied verbatim across machines, the
- * raw bytes are a stable, agent-agnostic identity. Multiplicity is preserved
- * (some transcripts contain legitimately identical lines, e.g. paired
- * `queue-operation` entries) by taking the per-hash max count across sources.
- */
-export interface ParsedEvent {
-    /** Original line bytes, exactly as stored (no trailing newline). */
-    raw: string;
-    /** SHA-256 of `raw` — the event's identity. */
-    hash: string;
-    /** Top-level ISO `timestamp`, or '' when absent/unparseable. */
-    ts: string;
-}
-/** Parse a transcript's raw text into events, skipping blank lines. */
-export declare function parseTranscript(content: string): ParsedEvent[];
-/**
- * Merge copies of the same session into one transcript via G-Set union.
- *
- * Returns a source VERBATIM (no reordering, byte-identical) for the common
- * cases — one source, all sources identical, or one source a superset of the
- * rest — so the steady state never rewrites unchanged files. Only a true fork
- * (each side holds events the other lacks) produces a reordered union, sorted
- * by (timestamp, hash) so every machine derives identical bytes.
- */
-export declare function mergeTranscripts(contents: string[]): string;
-/** Count distinct + total events across copies (for logging / manifest stats). */
-export declare function transcriptStats(content: string): {
-    events: number;
-    lastTs: string;
-};

package/dist/lib/session/sync/crdt.js

@@ -1,119 +0,0 @@
-/**
- * CRDT merge for agent transcripts.
- *
- * A transcript (Claude JSONL, Codex JSONL, …) is an append-only log of
- * immutable events: each line is written once and never rewritten, and Claude
- * already tolerates branches within one file (parentUuid fan-out). That makes a
- * transcript a grow-only set (G-Set) of events, and merging two copies of the
- * same session is a set union — associative, commutative, idempotent. Two
- * machines that each appended to the same session therefore converge to the
- * exact same merged file regardless of sync order or timing, with zero conflict
- * resolution and zero data loss.
- *
- * Events are identified by the SHA-256 of their raw line bytes. We deliberately
- * do NOT key on a per-event `uuid`: Codex lines carry no id, and because an
- * event is written exactly once and then copied verbatim across machines, the
- * raw bytes are a stable, agent-agnostic identity. Multiplicity is preserved
- * (some transcripts contain legitimately identical lines, e.g. paired
- * `queue-operation` entries) by taking the per-hash max count across sources.
- */
-import * as crypto from 'crypto';
-/** Extract the top-level `timestamp` field both Claude and Codex stamp per line. */
-function lineTimestamp(raw) {
-    try {
-        const obj = JSON.parse(raw);
-        const ts = obj?.timestamp;
-        return typeof ts === 'string' ? ts : '';
-    }
-    catch {
-        return '';
-    }
-}
-/** Parse a transcript's raw text into events, skipping blank lines. */
-export function parseTranscript(content) {
-    const out = [];
-    for (const line of content.split('\n')) {
-        if (line.trim() === '')
-            continue;
-        out.push({
-            raw: line,
-            hash: crypto.createHash('sha256').update(line).digest('hex'),
-            ts: lineTimestamp(line),
-        });
-    }
-    return out;
-}
-/** Order events deterministically across machines: by timestamp, then hash. */
-function compareEvents(a, b) {
-    if (a.ts !== b.ts)
-        return a.ts < b.ts ? -1 : 1;
-    if (a.hash !== b.hash)
-        return a.hash < b.hash ? -1 : 1;
-    return 0;
-}
-/**
- * Merge copies of the same session into one transcript via G-Set union.
- *
- * Returns a source VERBATIM (no reordering, byte-identical) for the common
- * cases — one source, all sources identical, or one source a superset of the
- * rest — so the steady state never rewrites unchanged files. Only a true fork
- * (each side holds events the other lacks) produces a reordered union, sorted
- * by (timestamp, hash) so every machine derives identical bytes.
- */
-export function mergeTranscripts(contents) {
-    const sources = contents.filter(c => c.length > 0);
-    if (sources.length === 0)
-        return '';
-    if (sources.length === 1)
-        return sources[0];
-    const parsed = sources.map(parseTranscript);
-    // Per-source multiset of event hashes.
-    const counts = parsed.map(events => {
-        const m = new Map();
-        for (const e of events)
-            m.set(e.hash, (m.get(e.hash) ?? 0) + 1);
-        return m;
-    });
-    // Global max count per hash + a representative event for raw bytes / ts.
-    const maxCount = new Map();
-    const rep = new Map();
-    for (let i = 0; i < parsed.length; i++) {
-        for (const e of parsed[i])
-            if (!rep.has(e.hash))
-                rep.set(e.hash, e);
-        for (const [h, c] of counts[i])
-            maxCount.set(h, Math.max(maxCount.get(h) ?? 0, c));
-    }
-    // Superset fast path: a source whose multiset already equals the global max
-    // is the union — return it byte-for-byte (covers identical/subset/prefix).
-    for (let i = 0; i < sources.length; i++) {
-        let isSuperset = true;
-        for (const [h, c] of maxCount) {
-            if ((counts[i].get(h) ?? 0) !== c) {
-                isSuperset = false;
-                break;
-            }
-        }
-        if (isSuperset)
-            return sources[i];
-    }
-    // True fork: emit each distinct event maxCount times, deterministically ordered.
-    const distinct = [...rep.values()].sort(compareEvents);
-    const lines = [];
-    for (const e of distinct) {
-        const n = maxCount.get(e.hash) ?? 1;
-        for (let k = 0; k < n; k++)
-            lines.push(e.raw);
-    }
-    const trailing = sources.some(s => s.endsWith('\n')) ? '\n' : '';
-    return lines.join('\n') + trailing;
-}
-/** Count distinct + total events across copies (for logging / manifest stats). */
-export function transcriptStats(content) {
-    const parsed = parseTranscript(content);
-    let lastTs = '';
-    for (const e of parsed)
-        if (e.ts > lastTs)
-            lastTs = e.ts;
-    return { events: parsed.length, lastTs };
-}

package/dist/lib/session/sync/manifest.d.ts

@@ -1,62 +0,0 @@
-/**
- * Manifests and the local upload ledger.
- *
- * Each machine publishes one manifest object (sessions/<machine>/manifest.json)
- * listing every session it holds, keyed by session id, with content hash + size
- * + last event timestamp. Pulling machines diff manifests to fetch only changed
- * objects — no per-tick LIST of thousands of keys.
- *
- * The local upload ledger (cache, per machine) records (size, mtime, hash) of
- * files already pushed, so a tick re-uploads only files that actually grew.
- */
-export interface ManifestEntry {
-    /** Storage-relative key, preserved into the mirror layout on the puller. */
-    relKey: string;
-    size: number;
-    /** SHA-256 of the full transcript file. */
-    hash: string;
-    /** Latest event timestamp in the transcript. */
-    lastTs: string;
-}
-/**
- * sessionId -> the session's file entries.
- *  - file-shaped agents (claude/codex/droid) store a single `ManifestEntry`,
- *    byte-identical to the pre-multi-file format, so a machine on an older CLI
- *    reads them unchanged.
- *  - dir-shaped agents (kimi) store a `ManifestEntry[]`, one per constituent file.
- *    A machine that predates multi-file support skips these (an unknown agent is
- *    skipped whole; a kimi-aware-but-file-shaped reader fails to find the flat
- *    object key and simply retries — it never crashes or corrupts).
- */
-export type AgentManifest = Record<string, ManifestEntry | ManifestEntry[]>;
-/** Normalize a manifest value to its file-entry list (single entry -> length-1). */
-export declare function manifestEntries(value: ManifestEntry | ManifestEntry[]): ManifestEntry[];
-export interface Manifest {
-    machine: string;
-    updatedAt: string;
-    /** agentId -> (sessionId -> entry | entry[]) */
-    agents: Record<string, AgentManifest>;
-}
-export declare function emptyManifest(machine: string, updatedAt: string): Manifest;
-export declare function parseManifest(text: string): Manifest | null;
-export declare function hashContent(content: string | Uint8Array): string;
-export declare function loadLocalManifest(): Manifest | null;
-export declare function saveLocalManifest(m: Manifest): void;
-/** key `${agent}/${sessionId}` -> signature of applied source hashes */
-export type PullState = Record<string, string>;
-export declare function loadPullState(): PullState;
-export declare function savePullState(s: PullState): void;
-/** Order-independent signature of the source hashes feeding one mirrored session. */
-export declare function sourceSignature(hashes: string[]): string;
-interface LedgerRow {
-    size: number;
-    mtimeMs: number;
-    hash: string;
-}
-type Ledger = Record<string, LedgerRow>;
-export declare function loadLedger(): Ledger;
-export declare function saveLedger(ledger: Ledger): void;
-/** True if the file at absPath is unchanged since we last uploaded it. */
-export declare function ledgerUnchanged(ledger: Ledger, absPath: string, size: number, mtimeMs: number): boolean;
-export declare function ledgerRecord(ledger: Ledger, absPath: string, size: number, mtimeMs: number, hash: string): void;
-export {};

package/dist/lib/session/sync/manifest.js

@@ -1,100 +0,0 @@
-/**
- * Manifests and the local upload ledger.
- *
- * Each machine publishes one manifest object (sessions/<machine>/manifest.json)
- * listing every session it holds, keyed by session id, with content hash + size
- * + last event timestamp. Pulling machines diff manifests to fetch only changed
- * objects — no per-tick LIST of thousands of keys.
- *
- * The local upload ledger (cache, per machine) records (size, mtime, hash) of
- * files already pushed, so a tick re-uploads only files that actually grew.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import { getCacheDir } from '../../state.js';
-/** Normalize a manifest value to its file-entry list (single entry -> length-1). */
-export function manifestEntries(value) {
-    return Array.isArray(value) ? value : [value];
-}
-export function emptyManifest(machine, updatedAt) {
-    return { machine, updatedAt, agents: {} };
-}
-export function parseManifest(text) {
-    try {
-        const m = JSON.parse(text);
-        if (m && typeof m.machine === 'string' && m.agents && typeof m.agents === 'object')
-            return m;
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export function hashContent(content) {
-    return crypto.createHash('sha256').update(content).digest('hex');
-}
-function stateDir() {
-    return path.join(getCacheDir(), 'state', 'sessions-sync');
-}
-// --- local cached copy of our published manifest ---------------------------
-function localManifestPath() {
-    return path.join(stateDir(), 'manifest.json');
-}
-export function loadLocalManifest() {
-    try {
-        return parseManifest(fs.readFileSync(localManifestPath(), 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-export function saveLocalManifest(m) {
-    const p = localManifestPath();
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    fs.writeFileSync(p, JSON.stringify(m), 'utf-8');
-}
-function pullStatePath() {
-    return path.join(stateDir(), 'pull-state.json');
-}
-export function loadPullState() {
-    try {
-        return JSON.parse(fs.readFileSync(pullStatePath(), 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-export function savePullState(s) {
-    const p = pullStatePath();
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    fs.writeFileSync(p, JSON.stringify(s), 'utf-8');
-}
-/** Order-independent signature of the source hashes feeding one mirrored session. */
-export function sourceSignature(hashes) {
-    return [...hashes].sort().join(',');
-}
-function ledgerPath() {
-    return path.join(getCacheDir(), 'state', 'sessions-sync', 'upload-ledger.json');
-}
-export function loadLedger() {
-    try {
-        return JSON.parse(fs.readFileSync(ledgerPath(), 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-export function saveLedger(ledger) {
-    const p = ledgerPath();
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    fs.writeFileSync(p, JSON.stringify(ledger), 'utf-8');
-}
-/** True if the file at absPath is unchanged since we last uploaded it. */
-export function ledgerUnchanged(ledger, absPath, size, mtimeMs) {
-    const row = ledger[absPath];
-    return !!row && row.size === size && row.mtimeMs === Math.floor(mtimeMs);
-}
-export function ledgerRecord(ledger, absPath, size, mtimeMs, hash) {
-    ledger[absPath] = { size, mtimeMs: Math.floor(mtimeMs), hash };
-}