harborloop 0.3.0 → 0.4.1

package/dist/commands/init.d.ts

@@ -1,36 +0,0 @@
-import type { Endpoints } from '../endpoints.js';
-import { type InstallOutcome } from '../daemon/install.js';
-import { type AgentId } from '../providers/detect.js';
-export interface InitOptions {
-    readonly cwd: string;
-    readonly endpoints: Endpoints;
-    readonly bind?: boolean;
-    readonly noBrowser?: boolean;
-    readonly workspaceId?: string;
-    readonly json?: boolean;
-    readonly daemon?: boolean;
-    readonly codex?: boolean;
-    readonly cursor?: boolean;
-}
-export interface AgentInstall {
-    readonly agent: AgentId;
-    readonly provider: string;
-    readonly connectionId: string;
-    readonly configPath: string;
-    readonly verifiedHooks: number | null;
-    readonly trustSkipped: string | null;
-}
-export interface InitResult {
-    readonly workspaceName: string;
-    readonly settingsPath: string;
-    readonly hooksDir: string;
-    readonly origins: readonly string[];
-    readonly boundRepo: string | null;
-    readonly migratedLegacyState: boolean;
-    readonly installs: readonly AgentInstall[];
-    readonly daemon: InstallOutcome | null;
-    readonly fellBackToClaude: boolean;
-}
-export declare function runInit(opts: InitOptions): Promise<InitResult>;
-export declare function renderInit(result: InitResult): string;
-export declare function runLogout(): Promise<void>;

package/dist/commands/init.js

@@ -1,192 +0,0 @@
-import { createRepoBinding, listRepoBindings, mintMcpToken, } from '../api.js';
-import { login } from '../auth/login.js';
-import { readAuth, writeAuth } from '../auth/store.js';
-import { harborDir } from '../paths.js';
-import { daemonProgram, installDaemon, installPlan, } from '../daemon/install.js';
-import { installHookScripts } from '../install-hooks.js';
-import { gitRoot, repoOrigin } from '../origin.js';
-import * as claude from '../providers/claude.js';
-import * as codex from '../providers/codex.js';
-import * as cursor from '../providers/cursor.js';
-import { stampAndVerify } from '../providers/codex-trust.js';
-import { detectAgents, selectAgents, MINT_PROVIDER, } from '../providers/detect.js';
-import { migrateLegacyState, updateSyncedConfig } from '../state.js';
-export async function runInit(opts) {
-    const { endpoints } = opts;
-    const migrated = (await migrateLegacyState()) === 'migrated';
-    const { auth } = await login(endpoints, {
-        noBrowser: opts.noBrowser,
-        workspaceId: opts.workspaceId,
-    });
-    const selection = selectAgents(await detectAgents(), {
-        codex: opts.codex,
-        cursor: opts.cursor,
-    });
-    const minted = new Map();
-    for (const agent of selection.agents) {
-        minted.set(agent, await mintMcpToken(endpoints.apiUrl, auth.runnerToken, auth.workspaceId, MINT_PROVIDER[agent]));
-    }
-    const primary = selection.agents.includes('claude') ? 'claude' : selection.agents[0];
-    await writeAuth({
-        ...auth,
-        mcpMintedAt: new Date().toISOString(),
-        mcpConnectionId: minted.get(primary)?.connectionId,
-    });
-    const origin = repoOrigin(opts.cwd);
-    const repoRoot = gitRoot(opts.cwd);
-    let bound = null;
-    const shouldBind = opts.bind ?? origin !== '';
-    if (shouldBind && origin !== '') {
-        const existing = await listRepoBindings(endpoints.apiUrl, auth.runnerToken, auth.workspaceId);
-        bound =
-            existing.find((b) => b.originUrl === origin) ??
-                (await createRepoBinding(endpoints.apiUrl, auth.runnerToken, auth.workspaceId, {
-                    originUrl: origin,
-                }));
-    }
-    const bindings = await listRepoBindings(endpoints.apiUrl, auth.runnerToken, auth.workspaceId);
-    const config = await updateSyncedConfig((current) => ({
-        ...current,
-        apiBase: endpoints.apiUrl,
-        origins: bindings.map((b) => b.originUrl),
-    }));
-    const install = await installHookScripts();
-    const installs = [];
-    for (const agent of selection.agents) {
-        const token = minted.get(agent);
-        const provider = MINT_PROVIDER[agent];
-        if (agent === 'claude') {
-            const configPath = await claude.installMcpServer({
-                mcpUrl: endpoints.mcpUrl,
-                token: token.token,
-                repoPath: repoRoot ?? undefined,
-                originUrl: origin !== '' ? origin : undefined,
-            });
-            await claude.installHooks(install.paths);
-            installs.push({
-                agent,
-                provider,
-                connectionId: token.connectionId,
-                configPath,
-                verifiedHooks: null,
-                trustSkipped: null,
-            });
-            continue;
-        }
-        if (agent === 'cursor') {
-            const cursorConfigPath = await cursor.installMcpServer({
-                mcpUrl: endpoints.mcpUrl,
-                token: token.token,
-            });
-            await cursor.installHooks(install.paths);
-            installs.push({
-                agent,
-                provider,
-                connectionId: token.connectionId,
-                configPath: cursorConfigPath,
-                verifiedHooks: null,
-                trustSkipped: null,
-            });
-            continue;
-        }
-        const configPath = await codex.installMcpServer({
-            mcpUrl: endpoints.mcpUrl,
-            token: token.token,
-        });
-        await codex.installHooks(install.paths);
-        const trust = await stampAndVerify({ probeCwd: opts.cwd });
-        installs.push({
-            agent,
-            provider,
-            connectionId: token.connectionId,
-            configPath,
-            verifiedHooks: trust.skippedReason === null ? trust.verified : null,
-            trustSkipped: trust.skippedReason,
-        });
-    }
-    const claudeInstall = installs.find((i) => i.agent === 'claude');
-    const daemon = opts.daemon === false ? null : await scheduleDaemon();
-    return {
-        workspaceName: auth.workspaceName,
-        settingsPath: claudeInstall?.configPath ?? installs[0]?.configPath ?? '',
-        hooksDir: install.dir,
-        origins: config.origins,
-        boundRepo: bound?.originUrl ?? null,
-        migratedLegacyState: migrated,
-        installs,
-        fellBackToClaude: selection.fellBack,
-        daemon,
-    };
-}
-async function scheduleDaemon() {
-    try {
-        return await installDaemon({
-            plan: installPlan({ program: daemonProgram(), harborHome: harborDir() }),
-        });
-    }
-    catch (error) {
-        return {
-            kind: 'unsupported',
-            files: [],
-            manual: [],
-            detail: `Could not schedule the daemon automatically (${error instanceof Error ? error.message : 'unknown error'}). Run \`harbor daemon --install\` once, or \`harbor daemon\` in a terminal — until something ticks, nothing you connect will report.`,
-        };
-    }
-}
-function daemonLine(outcome) {
-    if (outcome === null)
-        return 'not scheduled (--no-daemon)';
-    switch (outcome.kind) {
-        case 'installed':
-            return `scheduled (${outcome.files.length} unit${outcome.files.length === 1 ? '' : 's'})`;
-        case 'partial':
-            return 'partly scheduled — see below';
-        case 'removed':
-            return 'removed';
-        case 'unsupported':
-            return 'NOT scheduled — see below';
-    }
-}
-export function renderInit(result) {
-    const lines = [`Connected to workspace "${result.workspaceName}".`, ''];
-    for (const install of result.installs) {
-        const label = install.agent.padEnd(10);
-        lines.push(`  ${label} ${install.configPath}`);
-        if (install.trustSkipped !== null) {
-            lines.push(`             ⚠ hooks written but NOT trusted — ${install.trustSkipped}`, '             Codex will not run them. Re-run `harbor init` once `codex` is available.');
-        }
-        else if (install.verifiedHooks !== null && install.verifiedHooks === 0) {
-            lines.push('             ⚠ Codex registered none of our hooks. `harbor doctor` has the detail.');
-        }
-        else if (install.verifiedHooks !== null) {
-            lines.push(`             ${install.verifiedHooks} hooks trusted`);
-        }
-    }
-    lines.push(`  hooks      ${result.hooksDir}`, `  repos      ${result.origins.length} bound${result.boundRepo ? ` (this one: ${result.boundRepo})` : ''}`, `  daemon     ${daemonLine(result.daemon)}`);
-    const manual = result.daemon?.manual ?? [];
-    if (result.daemon && result.daemon.kind !== 'installed') {
-        lines.push('', result.daemon.detail);
-        for (const command of manual) {
-            lines.push(`  ${command.join(' ')}`);
-        }
-    }
-    if (result.fellBackToClaude) {
-        lines.push('', 'No agent was detected on this machine, so Claude Code was configured as', 'the default. Re-run `harbor init` after installing Claude Code or Codex.');
-    }
-    if (result.migratedLegacyState) {
-        lines.push('', 'Adopted the existing desktop-app setup from ~/.milestone.');
-    }
-    if (!result.boundRepo) {
-        lines.push('', 'This directory is not a bound repo. Run `harbor bind` inside one to', 'give its sessions a project scope.');
-    }
-    const started = result.installs.map((i) => `\`${i.agent}\``).join(' or ');
-    lines.push('', `Start ${started} in a bound repo. Check it with \`harbor doctor\`.`);
-    return lines.join('\n');
-}
-export async function runLogout() {
-    const auth = await readAuth();
-    if (!auth)
-        return;
-    const { clearAuth } = await import('../auth/store.js');
-    await clearAuth();
-}

package/dist/commands/status.d.ts

@@ -1,5 +0,0 @@
-import type { Check } from '../render.js';
-export interface StatusOptions {
-    readonly cwd: string;
-}
-export declare function runStatus(opts: StatusOptions): Promise<Check[]>;

package/dist/commands/status.js

@@ -1,164 +0,0 @@
-import { readAuth } from '../auth/store.js';
-import { repoOrigin } from '../origin.js';
-import * as claude from '../providers/claude.js';
-import * as codex from '../providers/codex.js';
-import * as cursor from '../providers/cursor.js';
-import { detectAgents } from '../providers/detect.js';
-import { readSyncedConfig, resolveArms } from '../state.js';
-export async function runStatus(opts) {
-    const [auth, config, settings, claudeMcpConfig, present, codexConfig, codexHooksJson, cursorMcpJson, cursorHooksJson,] = await Promise.all([
-        readAuth(),
-        readSyncedConfig(),
-        claude.readClaudeSettings(),
-        claude.readClaudeMcpConfig(),
-        detectAgents(),
-        codex.readCodexConfig(),
-        codex.readCodexHooksJson(),
-        cursor.readCursorMcpJson(),
-        cursor.readCursorHooksJson(),
-    ]);
-    const origin = repoOrigin(opts.cwd);
-    const bound = Boolean(config && origin !== '' && config.origins.includes(origin));
-    const arms = config ? resolveArms(config.pause, origin) : null;
-    const agents = [];
-    appendClaudeCheck(agents, present, settings, claudeMcpConfig);
-    appendCodexCheck(agents, present, codexConfig, codexHooksJson);
-    appendCursorCheck(agents, present, cursorMcpJson, cursorHooksJson);
-    if (agents.length === 0)
-        agents.push(claudeNotInstalled());
-    return [
-        {
-            label: 'Workspace',
-            state: auth ? 'ok' : 'fail',
-            detail: auth ? auth.workspaceName : 'not signed in',
-            ...(auth ? {} : { fix: 'harbor init' }),
-        },
-        {
-            label: 'Repo',
-            state: origin === '' ? 'warn' : bound ? 'ok' : 'fail',
-            detail: origin === ''
-                ? 'no git origin here'
-                : bound
-                    ? origin
-                    : `${origin} — not bound`,
-            ...(origin !== '' && !bound ? { fix: 'harbor bind' } : {}),
-        },
-        ...agents,
-        {
-            label: 'Recording',
-            state: !arms ? 'unknown' : arms.recall && arms.capture ? 'ok' : 'paused',
-            detail: !arms
-                ? 'not configured'
-                : arms.recall && arms.capture
-                    ? 'on'
-                    : arms.recall
-                        ? 'recall on, recording paused on purpose'
-                        : 'paused, on purpose',
-        },
-    ];
-}
-function claudeNotInstalled() {
-    return {
-        label: 'Hooks',
-        state: 'fail',
-        detail: 'not installed',
-        fix: 'harbor init',
-    };
-}
-function appendClaudeCheck(checks, present, settings, mcpConfig) {
-    const hooks = claude.readInstalledHooks(settings);
-    const hasMcp = claude.readInstalledToken(mcpConfig) !== null;
-    if (!present.claude && !hasMcp && !hooks.installed)
-        return;
-    if (!hooks.installed) {
-        checks.push(claudeNotInstalled());
-        return;
-    }
-    checks.push({ label: 'Hooks', state: 'ok', detail: 'installed' });
-}
-function appendCodexCheck(checks, present, config, hooksJson) {
-    const hasMcp = codex.hasMcpServer(config);
-    const hooks = codex.readInstalledHooks(hooksJson);
-    if (!present.codex && !hasMcp && !hooks.installed)
-        return;
-    if (!hasMcp && !hooks.installed) {
-        checks.push({
-            label: 'Codex',
-            state: 'warn',
-            detail: 'installed here, but not configured',
-            fix: 'harbor init',
-        });
-        return;
-    }
-    if (!hooks.installed) {
-        checks.push({
-            label: 'Codex',
-            state: 'fail',
-            detail: 'MCP configured, but no hooks',
-            fix: 'harbor init',
-        });
-        return;
-    }
-    if (!hasMcp) {
-        checks.push({
-            label: 'Codex',
-            state: 'fail',
-            detail: 'hooks registered, but no MCP bearer',
-            fix: 'harbor init',
-        });
-        return;
-    }
-    const stamps = codex.countHookTrustStamps(config, codex.resolveCodexPaths().hooksJsonPath);
-    if (stamps === 0) {
-        checks.push({
-            label: 'Codex',
-            state: 'fail',
-            detail: `${hooks.commands.length} hooks registered and NONE trusted`,
-            fix: 'harbor init  (stamps the trust hashes `codex` reports)',
-        });
-        return;
-    }
-    checks.push({
-        label: 'Codex',
-        state: 'ok',
-        detail: `${hooks.commands.length} installed, ${stamps} trusted`,
-    });
-}
-function appendCursorCheck(checks, present, mcpJson, hooksJson) {
-    const hasMcp = cursor.hasMcpServer(mcpJson);
-    const hooks = cursor.readInstalledHooks(hooksJson);
-    if (!present.cursor && !hasMcp && !hooks.installed)
-        return;
-    if (!hasMcp && !hooks.installed) {
-        checks.push({
-            label: 'Cursor',
-            state: 'warn',
-            detail: 'installed here, but not configured',
-            fix: 'harbor init',
-        });
-        return;
-    }
-    if (!hooks.installed) {
-        checks.push({
-            label: 'Cursor',
-            state: 'fail',
-            detail: 'MCP configured, but no hooks',
-            fix: 'harbor init',
-        });
-        return;
-    }
-    if (!hasMcp) {
-        checks.push({
-            label: 'Cursor',
-            state: 'fail',
-            detail: 'hooks registered, but no MCP bearer',
-            fix: 'harbor init',
-        });
-        return;
-    }
-    checks.push({
-        label: 'Cursor',
-        state: 'ok',
-        detail: `${hooks.commands.length} installed`,
-    });
-}

package/dist/commands/sync.d.ts

@@ -1,40 +0,0 @@
-import type { AgentPresence } from '../providers/detect.js';
-import type { ApplyDocumentsOutcome } from '../documents/apply.js';
-import type { Endpoints } from '../endpoints.js';
-import { type EnvDocumentOutcome, type EnvSkillOutcome } from '../env-sync.js';
-import type { MemorySyncSummary } from '../memories.js';
-import type { SkillSyncSummary } from '../skills.js';
-import { type PostSyncReportResult } from '../sync-report.js';
-export interface SyncOptions {
-    readonly cwd: string;
-    readonly endpoints: Endpoints;
-    readonly fetchImpl?: typeof fetch;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}
-export type { EnvDocumentOutcome, EnvSkillOutcome };
-export interface SyncedPayloads {
-    readonly kind: 'synced';
-    readonly documents: ApplyDocumentsOutcome;
-    readonly skills: SkillSyncSummary;
-    readonly envSkills: EnvSkillOutcome;
-    readonly envDocuments: EnvDocumentOutcome;
-    readonly memories: MemorySyncSummary;
-    readonly report: PostSyncReportResult;
-}
-export interface SyncResult {
-    readonly originUrl: string;
-    readonly repoPath: string;
-    readonly credentialSource: 'env' | 'file';
-    readonly outcome: SyncedPayloads | {
-        readonly kind: 'sync_disabled';
-        readonly reason: 'workspace' | 'admin';
-    } | {
-        readonly kind: 'error';
-        readonly message: string;
-    };
-}
-export declare function runSync(opts: SyncOptions): Promise<SyncResult>;
-export declare function renderSync(result: SyncResult): string;
-export declare function exitCodeForSync(result: SyncResult): number;

package/dist/commands/sync.js

@@ -1,242 +0,0 @@
-import { readAuth, resolveCredentials } from '../auth/store.js';
-import { syncEnvPlane, } from '../env-sync.js';
-import { gitRoot, repoOrigin } from '../origin.js';
-import { syncRepoPlane } from '../repo-sync.js';
-import { noteCheckout } from '../repos.js';
-import { buildSyncReport, postSyncReport, } from '../sync-report.js';
-import { NotARepoError, NotSignedInError } from './bind.js';
-export async function runSync(opts) {
-    const credentials = await resolveCredentials(opts.env);
-    if (!credentials)
-        throw new NotSignedInError();
-    const repoPath = gitRoot(opts.cwd);
-    const originUrl = repoOrigin(opts.cwd);
-    if (repoPath === null || originUrl === '')
-        throw new NotARepoError(opts.cwd);
-    const stored = credentials.source === 'file' ? await readAuth() : null;
-    const apiBase = stored?.apiUrl ?? opts.endpoints.apiUrl;
-    const base = {
-        originUrl,
-        repoPath,
-        credentialSource: credentials.source,
-    };
-    const repo = await syncRepoPlane({
-        apiBase,
-        workspaceId: credentials.workspaceId,
-        bearerToken: credentials.runnerToken,
-        repoPath,
-        originUrl,
-        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-        ...(opts.agents === undefined ? {} : { agents: opts.agents }),
-    });
-    if (repo.kind === 'sync_disabled') {
-        return { ...base, outcome: { kind: 'sync_disabled', reason: repo.reason } };
-    }
-    if (repo.kind === 'error') {
-        return { ...base, outcome: { kind: 'error', message: repo.message } };
-    }
-    const env = await syncEnvPlane({
-        apiBase,
-        workspaceId: credentials.workspaceId,
-        bearerToken: credentials.runnerToken,
-        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-    });
-    const report = await reportThisMachine({
-        apiBase,
-        workspaceId: credentials.workspaceId,
-        bearerToken: credentials.runnerToken,
-        ...(env.bundleHash === undefined ? {} : { bundleHash: env.bundleHash }),
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-    });
-    await noteCheckout(originUrl, repoPath);
-    return {
-        ...base,
-        outcome: {
-            kind: 'synced',
-            documents: repo.documents,
-            skills: repo.skills,
-            envSkills: env.skills,
-            envDocuments: env.documents,
-            memories: repo.memories,
-            report,
-        },
-    };
-}
-async function reportThisMachine(input) {
-    try {
-        const report = await buildSyncReport({
-            ...(input.home === undefined ? {} : { home: input.home }),
-            ...(input.bundleHash === undefined ? {} : { bundleHash: input.bundleHash }),
-        });
-        return await postSyncReport({
-            apiBase: input.apiBase,
-            workspaceId: input.workspaceId,
-            bearerToken: input.bearerToken,
-            report,
-            ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}),
-        });
-    }
-    catch (err) {
-        return {
-            kind: 'error',
-            status: 'network',
-            message: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-export function renderSync(result) {
-    const lines = [];
-    const { outcome } = result;
-    if (outcome.kind === 'sync_disabled') {
-        lines.push(outcome.reason === 'workspace'
-            ? 'Sync is switched off for this workspace. Nothing was written.'
-            : 'Sync is switched off for this repository. Nothing was written.');
-        lines.push('Turn it back on in the webapp, then run `harbor sync` again.');
-        return lines.join('\n');
-    }
-    if (outcome.kind === 'error') {
-        return `Could not fetch this repo's context: ${outcome.message}`;
-    }
-    const count = (n, one, many) => `${n} ${n === 1 ? one : many}`;
-    const skillsSynced = outcome.skills.results.filter((r) => r.status === 'synced');
-    if (skillsSynced.length > 0) {
-        lines.push(`${count(skillsSynced.length, 'skill', 'skills')} in ${outcome.skills.dir}`);
-    }
-    for (const result of outcome.skills.results) {
-        if (result.status === 'removed') {
-            lines.push(`  ${result.dir ?? result.file} — removed (no longer connected)`);
-        }
-        if (result.status === 'forked') {
-            lines.push(`  ${result.dir ?? result.file} — you edited this one; left alone, not updated`);
-        }
-        if (result.status === 'skipped_theirs') {
-            lines.push(`  ${result.dir ?? result.file} — a skill you wrote already has this name; not overwritten`);
-        }
-    }
-    const env = outcome.envSkills;
-    if (env.kind === 'unsupported') {
-        lines.push('This backend does not serve env skills yet — none were written.');
-    }
-    else if (env.kind === 'error') {
-        lines.push('Could not fetch your env skills — nothing in your home was touched.');
-    }
-    else {
-        for (const root of env.summary.roots) {
-            const synced = root.results.filter((r) => r.status === 'synced');
-            if (synced.length > 0) {
-                lines.push(`${count(synced.length, 'skill', 'skills')} in ${root.dir} (yours, every repo)`);
-            }
-            for (const result of root.results) {
-                const name = result.dir ?? result.file;
-                if (result.status === 'removed') {
-                    lines.push(`  ${name} — removed from your env (no longer connected)`);
-                }
-                if (result.status === 'forked') {
-                    lines.push(`  ${name} — you edited this one; left alone, not updated`);
-                }
-                if (result.status === 'skipped_theirs') {
-                    lines.push(`  ${name} — a skill you wrote already has this name; not overwritten`);
-                }
-            }
-        }
-    }
-    const memoriesSynced = outcome.memories.results.filter((r) => r.status === 'synced');
-    if (memoriesSynced.length > 0) {
-        lines.push(`${count(memoriesSynced.length, 'memory', 'memories')} in ${outcome.memories.dir}`);
-    }
-    const documents = outcome.documents;
-    if (documents.kind === 'unsupported') {
-        lines.push('This backend does not serve documents yet — none were written.');
-    }
-    else if (documents.reclaimed) {
-        const removed = documents.documents.filter((r) => r.status === 'removed').length;
-        lines.push(`No documents are connected to this repo any more — removed ${count(removed, 'file', 'files')} from ${documents.dir}.`);
-        for (const pointer of documents.pointer) {
-            lines.push(`  ${pointer.file} — pointer line ${pointer.status}`);
-        }
-    }
-    else {
-        const synced = documents.documents.filter((r) => r.status === 'synced');
-        if (synced.length > 0) {
-            lines.push(`${count(synced.length, 'document', 'documents')} in ${documents.dir}`);
-        }
-        for (const entry of documents.documents) {
-            if (entry.status === 'synced')
-                continue;
-            if (entry.status === 'skipped_theirs') {
-                lines.push(`  ${entry.file} — skipped: that name is a file we never wrote.`);
-                continue;
-            }
-            if (entry.status === 'forked') {
-                lines.push(`  ${entry.file} — has local edits, so it was left alone and stops updating.`);
-                continue;
-            }
-            lines.push(`  ${entry.file} — removed (no longer connected)`);
-        }
-        for (const pointer of documents.pointer) {
-            if (pointer.status === 'present')
-                continue;
-            lines.push(`  ${pointer.file} — pointer line ${pointer.status}`);
-        }
-    }
-    const envDocs = outcome.envDocuments;
-    if (envDocs.kind === 'unsupported') {
-        lines.push('This backend does not serve env documents yet — none were written.');
-    }
-    else if (envDocs.kind === 'error') {
-        lines.push('Could not fetch your env documents — nothing in your home was touched.');
-    }
-    else if (envDocs.outcome.kind === 'unsupported') {
-        lines.push('This backend does not serve env documents yet — none were written.');
-    }
-    else if (envDocs.outcome.reclaimed) {
-        const removed = envDocs.outcome.documents.filter((r) => r.status === 'removed').length;
-        lines.push(`No documents reach you any more — removed ${count(removed, 'file', 'files')} from ${envDocs.outcome.dir}.`);
-        for (const pointer of envDocs.outcome.pointer) {
-            lines.push(`  ${pointer.file} — pointer line ${pointer.status}`);
-        }
-    }
-    else {
-        const synced = envDocs.outcome.documents.filter((r) => r.status === 'synced');
-        if (synced.length > 0) {
-            lines.push(`${count(synced.length, 'document', 'documents')} in ${envDocs.outcome.dir} (yours, every repo)`);
-        }
-        for (const entry of envDocs.outcome.documents) {
-            if (entry.status === 'synced')
-                continue;
-            if (entry.status === 'skipped_theirs') {
-                lines.push(`  ${entry.file} — skipped: that name is a file we never wrote.`);
-                continue;
-            }
-            if (entry.status === 'forked') {
-                lines.push(`  ${entry.file} — has local edits, so it was left alone and stops updating.`);
-                continue;
-            }
-            lines.push(`  ${entry.file} — removed from your env (no longer connected)`);
-        }
-        for (const pointer of envDocs.outcome.pointer) {
-            if (pointer.status === 'present')
-                continue;
-            lines.push(`  ${pointer.file} — pointer line ${pointer.status}`);
-        }
-    }
-    const receipt = outcome.report.kind === 'error'
-        ? [
-            `⚠️  The files landed, but this machine could not report them: ${outcome.report.message}`,
-            "  Your team's map will show this machine as stale until the next sync.",
-        ]
-        : [];
-    if (lines.length === 0) {
-        return [
-            'Nothing is connected to this repo yet — no skills, memories or documents.',
-            ...receipt,
-        ].join('\n');
-    }
-    return [...lines, ...receipt].join('\n');
-}
-export function exitCodeForSync(result) {
-    return result.outcome.kind === 'error' ? 1 : 0;
-}