codehere 0.6.0-alpha.1 → 0.6.0

package/dist/infrastructure/orchestration/session-manager.js

@@ -28,6 +28,12 @@ import { mirrorSpawnedToThread, mirrorCompletedToThread } from '../storage/proje
 import { scanPromptBeforeSpawn } from '../hooks/pre-prompt-scan.js';
 import { generateNarration } from '../../application/use-cases/generate-narration.js';
 import { randomUUID } from 'crypto';
+import { classifyFailoverEligibility } from './failover-classifier.js';
+import { resolveFailoverTarget, toAvailability, } from './failover-policy.js';
+import { loadFailoverConfig, resolveChain } from './failover-config.js';
+import { enrichPromptWithPackSync, compileSessionPackSync, persistContextPack } from './graphify-context.js';
+import { buildFailoverHandoff, enrichPromptWithHandoff } from './context-handoff.js';
+import { mirrorFailoverToThread } from '../storage/project-thread-mirror.js';
 // ── Agent registry ─────────────────────────────────────────────────────────────
 // All backends codehere can spawn. Order here drives the default UI dropdown
 // order. Built-in adapters first; user-config-driven ones appended from
@@ -132,6 +138,21 @@ export class SessionManager {
     narrationBySession = new Map();
     narrationTimers = new Map();
     narrationStepsAtLastFire = new Map();
+    /** Stores active failover offers keyed by sessionId+target. API layer
+     *  reads these via getFailoverOffers() for the /api/failover-offers endpoint. */
+    failoverOffers;
+    /** Tracks the failover error code per session so acceptFailover can emit
+      *  the correct reason in the thread event. Populated by handleFailover. */
+    failoverReasonBySession = new Map();
+    /** Session threading — tracks which session continued as which after failover.
+      *  continuedAsBySession: original → new session ID
+      *  continuedFromBySession: new → original session ID */
+    continuedAsBySession = new Map();
+    continuedFromBySession = new Map();
+    /** Final Report failure tracking — when generateFinalReport rejects, we
+      *  record it so the API can return a definitive "failed" state instead
+      *  of leaving the UI showing "Generating report…" forever. */
+    failedReportBySession = new Set();
     spawn(prompt, agentId = 'claude-code', options) {
         const adapter = getAdapter(agentId);
         if (!adapter) {
@@ -158,12 +179,17 @@ export class SessionManager {
         if (!scan.allowed) {
             throw new Error(scan.blockReason || 'pre-prompt scan blocked the spawn');
         }
-        const session = adapter.spawn(prompt, options);
+        // P1 — graphify-ts structural memory: enrich prompt with compact context
+        // pack so the agent starts with a verified knowledge graph of the workspace.
+        // Respects CODEHERE_GRAPHIFY env var (auto|force|off, default=auto).
+        // Synchronous call — degrades to original prompt if graphify fails.
+        const cwd = options?.cwd ?? process.cwd();
+        const enrichedPrompt = enrichPromptWithPackSync(prompt, cwd);
+        const session = adapter.spawn(enrichedPrompt, options);
         this.sessions.set(session.sessionId, session);
         // Persistence: write the spawned record immediately so a daemon crash still
         // leaves an audit trail of what was attempted. Subscribe to exit so we can
         // capture the final status + steps + artifacts when the session settles.
-        const cwd = options?.cwd ?? process.cwd();
         this.cwdBySession.set(session.sessionId, cwd);
         appendSpawned({
             id: session.sessionId,
@@ -182,6 +208,20 @@ export class SessionManager {
             startedAt: session.startedAt,
         });
         const unsubscribe = session.subscribe((event) => {
+            // ── Failover check — intercept rate-limit / quota errors before exit ──
+            // Adapters emit 'codehere:error' (structured: { code, message, recovery })
+            // or 'error' (spawn-level: { message }). Both need classification.
+            if (event.type === 'error' || event.type === 'codehere:error') {
+                const err = event.data;
+                if (err?.code && err?.message) {
+                    const signal = classifyFailoverEligibility(session.agent, err.code, err.message);
+                    if (signal) {
+                        const newSession = this.handleFailover(session, signal);
+                        if (newSession)
+                            return; // auto-spawned — keep listening on new session
+                    }
+                }
+            }
             if (event.type !== 'exit')
                 return;
             const data = event.data;
@@ -248,7 +288,28 @@ export class SessionManager {
                 }
             })
                 .catch(() => {
-                // generateFinalReport never throws by contract; defensive only.
+                // generateFinalReport rejected — record it so the UI can show
+                // "Report unavailable" instead of "Generating report…" forever.
+                this.failedReportBySession.add(session.sessionId);
+            });
+            // P1 — persist context pack at session exit for cross-session handoff (P2).
+            // Fire-and-forget: graphify-ts may not be installed, graph may be empty,
+            // or pack compilation may fail. All degrade silently.
+            void Promise.resolve().then(() => {
+                try {
+                    const stepsStr = session.steps?.map((s) => `${s.label}: ${s.output || s.state}`).filter(Boolean).join('\n') ?? '';
+                    const pack = compileSessionPackSync(cwd, {
+                        prompt: session.prompt,
+                        artifacts: JSON.stringify(session.artifacts, null, 2),
+                        steps: stepsStr,
+                        agent: session.agent,
+                    });
+                    if (pack)
+                        persistContextPack(pack, cwd);
+                }
+                catch {
+                    // Silent degradation — context pack is enrichment, not the primary path.
+                }
             });
             // v0.6 M3 — clean up the narration timer for this session.
             const t = this.narrationTimers.get(session.sessionId);
@@ -267,6 +328,346 @@ export class SessionManager {
         this.startNarrationTimer(session);
         return session;
     }
+    /** Tracks which agents have already been tried for a given prompt during
+     *  a failover chain. Maps sessionId → set of agent ids already attempted. */
+    failoverTriedBySession = new Map();
+    /** v0.6.x failover — emit a failover offer when an adapter hits a
+     *  rate-limit / quota error. The offer is surfaced via the API layer
+     *  (Slice E) and optionally auto-spawned (Slice D). Returns the new
+     *  session if auto-spawn was triggered, undefined otherwise. */
+    handleFailover(session, signal) {
+        const config = loadFailoverConfig();
+        const chain = resolveChain(config?.chain);
+        const tried = this.failoverTriedBySession.get(session.sessionId) ?? new Set();
+        tried.add(signal.fromAgent);
+        this.failoverTriedBySession.set(session.sessionId, tried);
+        const adapters = allAdapters();
+        const available = toAvailability(adapters, (a) => {
+            return a.id !== signal.fromAgent && a.isInstalled();
+        });
+        const target = resolveFailoverTarget({
+            failedAgent: signal.fromAgent,
+            alreadyTried: Array.from(tried),
+            available,
+            preferredChain: config?.chain,
+        });
+        if (!target)
+            return undefined;
+        const targetAdapter = getAdapter(target);
+        if (!targetAdapter || !targetAdapter.isInstalled())
+            return undefined;
+        // Auto-failover: spawn on the next agent in the chain
+        const autoFailover = config?.autoFailover ?? true;
+        if (autoFailover) {
+            // Spawn replacement session on the next agent, preserving prompt + cwd
+            const cwd = this.cwdBySession.get(session.sessionId) ?? process.cwd();
+            // P2 — build handoff context for continuity across agent swap
+            const handoff = buildFailoverHandoff(cwd, {
+                failedAgent: session.agent,
+                failedPrompt: session.prompt,
+            });
+            // Enrich prompt with handoff if available (P2)
+            const promptWithHandoff = handoff
+                ? enrichPromptWithHandoff(session.prompt, {
+                    packId: handoff.packId,
+                    agent: session.agent,
+                    prompt: session.prompt,
+                    status: 'failed',
+                    timestamp: handoff.timestamp,
+                    nodeCount: handoff.nodeCount,
+                    edgeCount: handoff.edgeCount,
+                    task: handoff.task,
+                    payloadPreview: handoff.payloadPreview,
+                })
+                : session.prompt;
+            try {
+                const newSession = targetAdapter.spawn(promptWithHandoff, {
+                    cwd,
+                    env: process.env,
+                    preferSubscription: true,
+                });
+                // Track this new session in the same way
+                this.sessions.set(newSession.sessionId, newSession);
+                this.cwdBySession.set(newSession.sessionId, cwd);
+                appendSpawned({
+                    id: newSession.sessionId,
+                    agent: newSession.agent,
+                    prompt: promptWithHandoff,
+                    cwd,
+                    startedAt: newSession.startedAt,
+                });
+                mirrorSpawnedToThread({
+                    sessionId: newSession.sessionId,
+                    agent: newSession.agent,
+                    prompt: promptWithHandoff,
+                    cwd,
+                    startedAt: newSession.startedAt,
+                });
+                mirrorFailoverToThread({
+                    sessionId: newSession.sessionId,
+                    fromAgent: signal.fromAgent,
+                    toAgent: target,
+                    reason: signal.errorCode,
+                    cwd,
+                });
+                // Subscribe to the new session with the same failover logic
+                const unsubscribe = newSession.subscribe((event) => {
+                    if (event.type !== 'exit')
+                        return;
+                    const data = event.data;
+                    const completedAt = Date.now();
+                    this.completedAtBySession.set(newSession.sessionId, completedAt);
+                    appendCompleted({
+                        id: newSession.sessionId,
+                        status: newSession.status,
+                        durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
+                        completedAt,
+                        steps: newSession.steps ? [...newSession.steps] : undefined,
+                        artifacts: newSession.artifacts,
+                    });
+                    mirrorCompletedToThread({
+                        sessionId: newSession.sessionId,
+                        cwd,
+                        status: newSession.status,
+                        durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
+                        completedAt,
+                        steps: newSession.steps ? [...newSession.steps] : undefined,
+                        artifacts: newSession.artifacts,
+                    });
+                    const reportInput = {
+                        sessionId: newSession.sessionId,
+                        prompt: newSession.prompt,
+                        agent: newSession.agent,
+                        status: newSession.status,
+                        durationMs: completedAt - newSession.startedAt,
+                        steps: newSession.steps ? [...newSession.steps] : [],
+                        artifacts: newSession.artifacts,
+                    };
+                    generateFinalReport(reportInput)
+                        .then((report) => {
+                        if (report) {
+                            this.finalReportBySession.set(newSession.sessionId, report);
+                            appendFinalReport({
+                                id: newSession.sessionId,
+                                summary: report.summary,
+                                generatedAt: report.generatedAt,
+                                durationMs: report.durationMs,
+                            });
+                            try {
+                                printFinalReportToTerminal(reportInput, report);
+                            }
+                            catch { /* defensive */ }
+                        }
+                    })
+                        .catch(() => { });
+                    // P1 — persist context pack at failover-replacement session exit.
+                    void Promise.resolve().then(() => {
+                        try {
+                            const stepsStr = newSession.steps?.map((s) => `${s.label}: ${s.output || s.state}`).filter(Boolean).join('\n') ?? '';
+                            const pack = compileSessionPackSync(cwd, {
+                                prompt: newSession.prompt,
+                                artifacts: JSON.stringify(newSession.artifacts, null, 2),
+                                steps: stepsStr,
+                                agent: newSession.agent,
+                            });
+                            if (pack)
+                                persistContextPack(pack, cwd);
+                        }
+                        catch {
+                            // Silent degradation — context pack is enrichment, not primary path.
+                        }
+                    });
+                    const t = this.narrationTimers.get(newSession.sessionId);
+                    if (t) {
+                        clearInterval(t);
+                        this.narrationTimers.delete(newSession.sessionId);
+                    }
+                    unsubscribe();
+                });
+                this.startNarrationTimer(newSession);
+                return newSession;
+            }
+            catch {
+                // Spawn failed — fall through to offer-only mode
+                return undefined;
+            }
+        }
+        // Offer-only mode: signal the API layer to present a failover banner
+        // (Slice E handles the actual UI surfacing)
+        this.emitFailoverOffer({ session, signal, target });
+        this.failoverReasonBySession.set(session.sessionId, signal.errorCode);
+        return undefined;
+    }
+    /** Emitted when a failover offer is generated. The API layer listens
+     *  to this to surface the banner in the web UI. */
+    emitFailoverOffer(offer) {
+        // Store in a map that the API layer can poll — Slice E wires the
+        // /api/failover-offers endpoint to read from here.
+        if (!this.failoverOffers) {
+            this.failoverOffers = new Map();
+        }
+        const key = `${offer.session.sessionId}-${offer.target}`;
+        this.failoverOffers.set(key, offer);
+        // Auto-expire offers after 60 seconds to keep the map bounded
+        setTimeout(() => {
+            this.failoverOffers?.delete(key);
+        }, 60_000);
+    }
+    /** Get all active failover offers for the API layer. */
+    getFailoverOffers() {
+        if (!this.failoverOffers)
+            return [];
+        const offers = [];
+        for (const [key, offer] of this.failoverOffers) {
+            offers.push({
+                sessionId: offer.session.sessionId,
+                signal: offer.signal,
+                target: offer.target,
+                expiresAt: Date.now() + 60_000,
+            });
+        }
+        return offers;
+    }
+    /** v0.6.x P0 — user-initiated failover accept. Spawns a replacement
+       *  session on the target agent, preserving the original prompt + cwd.
+       *  P2 — injects handoff context for cross-agent continuity.
+       *  Returns the new session or undefined if the target is unavailable. */
+    acceptFailover(sessionId, targetAgent) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return undefined;
+        const targetAdapter = getAdapter(targetAgent);
+        if (!targetAdapter || !targetAdapter.isInstalled())
+            return undefined;
+        const cwd = this.cwdBySession.get(sessionId) ?? process.cwd();
+        // P2 — build handoff context for continuity across agent swap
+        const handoff = buildFailoverHandoff(cwd, {
+            failedAgent: session.agent,
+            failedPrompt: session.prompt,
+        });
+        const promptWithHandoff = handoff
+            ? enrichPromptWithHandoff(session.prompt, {
+                packId: handoff.packId,
+                agent: session.agent,
+                prompt: session.prompt,
+                status: 'failed',
+                timestamp: handoff.timestamp,
+                nodeCount: handoff.nodeCount,
+                edgeCount: handoff.edgeCount,
+                task: handoff.task,
+                payloadPreview: handoff.payloadPreview,
+            })
+            : session.prompt;
+        const newSession = targetAdapter.spawn(promptWithHandoff, {
+            cwd,
+            env: process.env,
+            preferSubscription: true,
+        });
+        // Track the new session
+        this.sessions.set(newSession.sessionId, newSession);
+        this.cwdBySession.set(newSession.sessionId, cwd);
+        // Session threading: record the parent-child relationship
+        this.continuedAsBySession.set(sessionId, newSession.sessionId);
+        this.continuedFromBySession.set(newSession.sessionId, sessionId);
+        appendSpawned({
+            id: newSession.sessionId,
+            agent: newSession.agent,
+            prompt: promptWithHandoff,
+            cwd,
+            startedAt: newSession.startedAt,
+        });
+        mirrorSpawnedToThread({
+            sessionId: newSession.sessionId,
+            agent: newSession.agent,
+            prompt: promptWithHandoff,
+            cwd,
+            startedAt: newSession.startedAt,
+        });
+        mirrorFailoverToThread({
+            sessionId: newSession.sessionId,
+            fromAgent: session.agent,
+            toAgent: targetAgent,
+            reason: this.failoverReasonBySession.get(session.sessionId) ?? 'error',
+            cwd,
+        });
+        // Subscribe to the new session with the same failover logic
+        const unsubscribe = newSession.subscribe((event) => {
+            if (event.type !== 'exit')
+                return;
+            const data = event.data;
+            const completedAt = Date.now();
+            this.completedAtBySession.set(newSession.sessionId, completedAt);
+            appendCompleted({
+                id: newSession.sessionId,
+                status: newSession.status,
+                durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
+                completedAt,
+                steps: newSession.steps ? [...newSession.steps] : undefined,
+                artifacts: newSession.artifacts,
+            });
+            mirrorCompletedToThread({
+                sessionId: newSession.sessionId,
+                cwd,
+                status: newSession.status,
+                durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
+                completedAt,
+                steps: newSession.steps ? [...newSession.steps] : undefined,
+                artifacts: newSession.artifacts,
+            });
+            const reportInput = {
+                sessionId: newSession.sessionId,
+                prompt: newSession.prompt,
+                agent: newSession.agent,
+                status: newSession.status,
+                durationMs: completedAt - newSession.startedAt,
+                steps: newSession.steps ? [...newSession.steps] : [],
+                artifacts: newSession.artifacts,
+            };
+            generateFinalReport(reportInput)
+                .then((report) => {
+                if (report) {
+                    this.finalReportBySession.set(newSession.sessionId, report);
+                    appendFinalReport({
+                        id: newSession.sessionId,
+                        summary: report.summary,
+                        generatedAt: report.generatedAt,
+                        durationMs: report.durationMs,
+                    });
+                    try {
+                        printFinalReportToTerminal(reportInput, report);
+                    }
+                    catch { /* defensive */ }
+                }
+            })
+                .catch(() => { });
+            // P1 — persist context pack at accept-failover replacement session exit.
+            void Promise.resolve().then(() => {
+                try {
+                    const stepsStr = newSession.steps?.map((s) => `${s.label}: ${s.output || s.state}`).filter(Boolean).join('\n') ?? '';
+                    const pack = compileSessionPackSync(cwd, {
+                        prompt: newSession.prompt,
+                        artifacts: JSON.stringify(newSession.artifacts, null, 2),
+                        steps: stepsStr,
+                        agent: newSession.agent,
+                    });
+                    if (pack)
+                        persistContextPack(pack, cwd);
+                }
+                catch {
+                    // Silent degradation — context pack is enrichment, not primary path.
+                }
+            });
+            const t = this.narrationTimers.get(newSession.sessionId);
+            if (t) {
+                clearInterval(t);
+                this.narrationTimers.delete(newSession.sessionId);
+            }
+            this.startNarrationTimer(newSession);
+            unsubscribe();
+        });
+        this.startNarrationTimer(newSession);
+        return newSession;
+    }
     /** v0.6 M3 — periodic narration loop per session. */
     startNarrationTimer(session) {
         if (process.env.CODEHERE_DISABLE_NARRATOR === '1')
@@ -320,13 +721,26 @@ export class SessionManager {
     getCwd(sessionId) {
         return this.cwdBySession.get(sessionId);
     }
+    /** Session threading — which session did this one continue from (after failover)? */
+    getContinuedFrom(sessionId) {
+        return this.continuedFromBySession.get(sessionId);
+    }
+    /** Session threading — which session did this one continue as (after failover)? */
+    getContinuedAs(sessionId) {
+        return this.continuedAsBySession.get(sessionId);
+    }
     /** PM-UX Layer 3 · prose Final Report for an in-memory exited session.
-     *  Returns undefined while generation is in flight OR if the provider chain
-     *  failed (no claude-free, no claude, no credit, etc). The web UI reads this
-     *  through the /api/tasks serializer to render the prose summary inline. */
+      *  Returns undefined while generation is in flight OR if the provider chain
+      *  failed (no claude-free, no claude, no credit, etc). The web UI reads this
+      *  through the /api/tasks serializer to render the prose summary inline. */
     getFinalReport(sessionId) {
         return this.finalReportBySession.get(sessionId);
     }
+    /** Returns true if Final Report generation explicitly failed for this session.
+      *  Lets the API distinguish "not yet" from "never coming". */
+    hasFailedReport(sessionId) {
+        return this.failedReportBySession.has(sessionId);
+    }
     get(sessionId) {
         return this.sessions.get(sessionId);
     }

package/dist/infrastructure/protocols/cloud-sync.js

@@ -0,0 +1,208 @@
+/**
+ * Cloud sync bridge for codehere remote dashboard.
+ *
+ * Pushes session state to codehere.uk/api/sync every 30s.
+ * Pulls task assignments from cloud.
+ *
+ * What leaves the machine:
+ *   - Session metadata (id, title, status, agent, project, tags, duration, tools, files, trustScore)
+ *   - Machine identity (name, token hash)
+ *
+ * What stays local:
+ *   - Code, file contents, API keys, git repos, full conversation threads
+ */
+import { randomUUID } from 'crypto';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir, hostname } from 'os';
+const CLOUD_URL = 'https://codehere.uk/api/sync';
+const TOKEN_PATH = join(homedir(), '.codehere', 'cloud-token');
+const SESSIONS_FILE = join(homedir(), '.codehere', 'sessions.jsonl');
+// Lazy-loaded session manager — imported once to avoid circular deps
+let _sessionManager = null;
+async function getSessionManager() {
+    if (!_sessionManager) {
+        const { SessionManager } = await import('../orchestration/session-manager.js');
+        _sessionManager = SessionManager.getInstance();
+    }
+    return _sessionManager;
+}
+// ── Token management ─────────────────────────────────────────────────────────
+export function getOrCreateToken() {
+    if (existsSync(TOKEN_PATH)) {
+        return readFileSync(TOKEN_PATH, 'utf-8').trim();
+    }
+    const token = randomUUID();
+    const dir = dirname(TOKEN_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(TOKEN_PATH, token);
+    return token;
+}
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+function extractProjectFromCwd(cwd) {
+    // Extract project name from cwd path (last directory component)
+    const parts = cwd.split('/').filter(Boolean);
+    return parts[parts.length - 1] || 'unknown';
+}
+function extractTrustScore(artifacts) {
+    return artifacts?.trustScore;
+}
+export function collectSessionMetadata() {
+    if (!existsSync(SESSIONS_FILE)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(SESSIONS_FILE, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim().length > 0);
+        // Parse records and pair spawned + completed
+        const spawnedMap = new Map();
+        const completedMap = new Map();
+        const finalReportMap = new Map();
+        for (const line of lines) {
+            try {
+                const record = JSON.parse(line);
+                if (record.t === 'spawned') {
+                    spawnedMap.set(record.id, record);
+                }
+                else if (record.t === 'completed') {
+                    completedMap.set(record.id, record);
+                }
+                else if (record.t === 'finalReport') {
+                    finalReportMap.set(record.id, record);
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        const sessions = [];
+        for (const [id, spawned] of spawnedMap.entries()) {
+            const completed = completedMap.get(id);
+            const finalReport = finalReportMap.get(id);
+            const status = completed
+                ? (completed.status === 'completed' ? 'done' : completed.status === 'failed' ? 'failed' : 'done')
+                : 'running';
+            const durationMs = completed?.durationMs ?? (Date.now() - spawned.startedAt);
+            const tools = completed?.steps?.length ?? 0;
+            const files = completed?.artifacts?.filesChanged?.length ?? 0;
+            const trustScore = extractTrustScore(completed?.artifacts);
+            // Extract title from prompt (first line or first 80 chars)
+            const title = spawned.prompt.split('\n')[0].slice(0, 80) || 'Untitled task';
+            sessions.push({
+                id,
+                title,
+                status,
+                agent: spawned.agent || 'Unknown',
+                project: extractProjectFromCwd(spawned.cwd || ''),
+                tags: [], // Tags not yet implemented in session schema
+                duration: formatDuration(durationMs),
+                tools,
+                files,
+                ...(trustScore !== undefined ? { trustScore } : {}),
+            });
+        }
+        return sessions.sort((a, b) => {
+            // Running first, then by duration descending
+            if (a.status === 'running' && b.status !== 'running')
+                return -1;
+            if (a.status !== 'running' && b.status === 'running')
+                return 1;
+            return 0;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// ── Sync loop ────────────────────────────────────────────────────────────────
+let syncInterval = null;
+export function startCloudSync(machineName) {
+    const token = getOrCreateToken();
+    // Use hostname + first 8 chars of token as machine ID — unique per machine
+    const machineId = machineName || `${hostname()}-${token.slice(0, 8)}`;
+    console.log(`  Cloud sync enabled — pushing to codehere.uk/app`);
+    console.log(`  Machine: ${machineId}`);
+    console.log(`  Token: ${TOKEN_PATH}`);
+    const push = async () => {
+        try {
+            const sessions = collectSessionMetadata();
+            const res = await fetch(CLOUD_URL, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    machineId,
+                    name: machineId,
+                    token,
+                    sessions,
+                    timestamp: Date.now(),
+                }),
+            });
+            if (!res.ok) {
+                const body = await res.text();
+                console.error(`  Cloud sync failed: ${res.status} ${body}`);
+            }
+            else {
+                const data = await res.json();
+                if (data.sessionsPushed && data.sessionsPushed > 0) {
+                    console.log(`  Cloud sync: ${data.sessionsPushed} session(s) pushed`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`  Cloud sync error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    const pullTasks = async () => {
+        try {
+            const res = await fetch(`${CLOUD_URL}?action=pull-tasks&machineId=${machineId}`);
+            if (!res.ok)
+                return;
+            const data = await res.json();
+            const tasks = data.tasks || [];
+            for (const task of tasks) {
+                if (task.prompt) {
+                    console.log(`  Cloud task received: ${task.prompt.slice(0, 60)}...`);
+                    try {
+                        const manager = await getSessionManager();
+                        manager.spawn(task.prompt, task.agent || 'claude-code');
+                        // Mark task as claimed
+                        await fetch(`${CLOUD_URL}?action=claim-task&machineId=${machineId}&taskId=${task.id}`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ machineId, token, taskId: task.id }),
+                        });
+                    }
+                    catch (err) {
+                        console.error(`  Failed to spawn cloud task: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Silent fail for task pull — not critical
+        }
+    };
+    // Push immediately, then every 30s
+    push();
+    pullTasks();
+    syncInterval = setInterval(() => {
+        push();
+        pullTasks();
+    }, 30000);
+}
+export function stopCloudSync() {
+    if (syncInterval) {
+        clearInterval(syncInterval);
+        syncInterval = null;
+    }
+}
+//# sourceMappingURL=cloud-sync.js.map