@geminixiang/mikan 1.0.0-beta.83 → 1.0.0-beta.85

package/dist/office/index.js

@@ -1,10 +1,6 @@
 import { createHash, randomBytes } from "node:crypto";
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
-import * as log from "../log.js";
-import { legacyConversationCredentialKey } from "../sandbox/identity.js";
-import { guestWorkspacePath } from "../sandbox/layout.js";
-import { migrateConversationVaultKeys } from "../vault/index.js";
+import { lstatSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { atomicWritePrivateFile, readTextFileIfExists } from "../file-guards.js";
 import { isRecord } from "../unknown-values.js";
 export const OFFICE_LOG_FILENAME = "log.jsonl";
@@ -193,13 +189,6 @@ function ensureRegularOfficeDirectory(dir) {
 }
 const REGISTRY_VERSION = 1;
 const REGISTRY_FILENAME = "office-registry.json";
-const MIGRATION_STATUSES = new Set([
-    "needs-owner",
-    "prepared",
-    "moving",
-    "committed",
-    "failed",
-]);
 const REGISTRY_LOCK_FILENAME = ".office-registry.lock";
 const REGISTRY_LOCK_RETRY_MS = 25;
 const REGISTRY_LOCK_TIMEOUT_MS = 5_000;
@@ -222,20 +211,6 @@ export class OfficeRegistry {
     getState() {
         return this.state;
     }
-    getMigration(rawConversationId) {
-        assertConversationId(rawConversationId);
-        return this.state.migrations.find((record) => record.rawConversationId === rawConversationId);
-    }
-    enablePlatform(platform) {
-        const validPlatform = assertPlatformName(platform);
-        return this.withExclusiveLease(() => {
-            if (this.state.enabledPlatforms.includes(validPlatform))
-                return this.state;
-            const enabledPlatforms = [...this.state.enabledPlatforms, validPlatform].toSorted();
-            this.replaceState(enabledPlatforms, this.state.offices, this.state.migrations);
-            return this.state;
-        });
-    }
     recordOffice(address) {
         const normalized = validateOfficeAddress(address);
         const existing = this.findOffice(normalized);
@@ -250,7 +225,7 @@ export class OfficeRegistry {
                 conversationId: normalized.conversationId,
                 recordedAt: new Date().toISOString(),
             });
-            this.replaceState(this.state.enabledPlatforms, [...this.state.offices, record], this.state.migrations);
+            this.replaceState([...this.state.offices, record]);
             return record;
         });
     }
@@ -260,151 +235,8 @@ export class OfficeRegistry {
     findOffice(address) {
         return this.state.offices.find((record) => record.platform === address.platform && record.conversationId === address.conversationId);
     }
-    prepareLegacyMigration(options) {
-        const rawConversationId = assertConversationId(options.rawConversationId);
-        const sourceDir = resolve(options.sourceDir);
-        const workspaceRoot = resolve(options.workspaceRoot);
-        return this.withExclusiveLease(() => {
-            const existing = this.getMigration(rawConversationId);
-            assertCanonicalSource(sourceDir, workspaceRoot, rawConversationId);
-            if (existing) {
-                assertSameMigrationInputs(existing, sourceDir, workspaceRoot);
-                if (existing.status !== "needs-owner")
-                    return existing;
-            }
-            assertRegularDirectory(sourceDir, "Legacy office source");
-            const ownerPlatform = this.resolveOwner(options.ownerPlatform, rawConversationId);
-            if (!ownerPlatform) {
-                const record = makeRecord({
-                    rawConversationId,
-                    sourceDir,
-                    workspaceRoot,
-                    status: "needs-owner",
-                });
-                this.replaceMigration(existing, record);
-                return record;
-            }
-            const targetDir = officeDir(workspaceRoot, {
-                platform: ownerPlatform,
-                conversationId: rawConversationId,
-            });
-            if (pathExists(targetDir)) {
-                const failed = makeRecord({
-                    rawConversationId,
-                    sourceDir,
-                    workspaceRoot,
-                    ownerPlatform,
-                    targetDir,
-                    status: "failed",
-                    error: "Target office directory already exists",
-                });
-                this.replaceMigration(existing, failed);
-                throw new Error(`${failed.error}: ${targetDir}`);
-            }
-            const prepared = makeRecord({
-                rawConversationId,
-                sourceDir,
-                workspaceRoot,
-                ownerPlatform,
-                targetDir,
-                status: "prepared",
-            });
-            this.replaceMigration(existing, prepared);
-            return prepared;
-        });
-    }
-    markMoving(rawConversationId) {
-        return this.withExclusiveLease(() => {
-            const record = this.requireMigration(rawConversationId);
-            if (record.status === "moving" ||
-                record.status === "committed" ||
-                record.status === "failed") {
-                return record;
-            }
-            if (record.status === "needs-owner") {
-                throw new Error(`Legacy office ${JSON.stringify(rawConversationId)} still needs an owner`);
-            }
-            assertRegularDirectory(record.sourceDir, "Legacy office source");
-            const targetDir = migrationTarget(record);
-            if (!targetDir)
-                throw new Error("Prepared office migration has no target directory");
-            if (pathExists(targetDir)) {
-                const failed = this.failRecord(record, "Target office directory appeared before moving");
-                throw new Error(`${failed.error}: ${targetDir}`);
-            }
-            const moving = transitionRecord(record, "moving");
-            this.replaceMigration(record, moving);
-            return moving;
-        });
-    }
-    markCommitted(rawConversationId) {
-        return this.withExclusiveLease(() => {
-            const record = this.requireMigration(rawConversationId);
-            if (record.status === "committed" || record.status === "failed")
-                return record;
-            if (record.status !== "moving") {
-                throw new Error(`Cannot commit office migration from ${record.status}`);
-            }
-            const targetDir = migrationTarget(record);
-            if (!targetDir)
-                throw new Error("Moving office migration has no target directory");
-            assertRegularDirectory(targetDir, "Migrated office target");
-            assertPathAbsent(record.sourceDir, "Legacy office source");
-            const committed = transitionRecord(record, "committed");
-            this.replaceMigration(record, committed);
-            return committed;
-        });
-    }
-    markFailed(rawConversationId, error) {
-        return this.withExclusiveLease(() => {
-            const record = this.requireMigration(rawConversationId);
-            if (record.status === "committed") {
-                throw new Error("A committed office migration cannot be marked failed");
-            }
-            if (record.status === "failed")
-                return record;
-            return this.failRecord(record, error);
-        });
-    }
-    resolveOwner(ownerPlatform, rawConversationId) {
-        if (ownerPlatform !== undefined) {
-            const validPlatform = assertPlatformName(ownerPlatform);
-            if (!this.state.enabledPlatforms.includes(validPlatform)) {
-                throw new Error(`Owner platform ${validPlatform} is not enabled`);
-            }
-            return validPlatform;
-        }
-        const candidates = platformsMatchingConversationIdFormat(rawConversationId, this.state.enabledPlatforms);
-        return candidates.length === 1 ? candidates[0] : undefined;
-    }
-    requireMigration(rawConversationId) {
-        assertConversationId(rawConversationId);
-        const record = this.getMigration(rawConversationId);
-        if (!record)
-            throw new Error(`No office migration registered for ${rawConversationId}`);
-        return record;
-    }
-    failRecord(record, error) {
-        const message = error.trim();
-        if (!message)
-            throw new Error("Office migration failure reason must not be empty");
-        const failed = transitionRecord(record, "failed", message);
-        this.replaceMigration(record, failed);
-        return failed;
-    }
-    replaceMigration(previous, next) {
-        const migrations = [...this.state.migrations];
-        const index = previous
-            ? migrations.findIndex((record) => record.rawConversationId === previous.rawConversationId)
-            : -1;
-        if (index === -1)
-            migrations.push(next);
-        else
-            migrations[index] = next;
-        this.replaceState(this.state.enabledPlatforms, this.state.offices, migrations);
-    }
-    replaceState(enabledPlatforms, offices, migrations) {
-        const candidate = freezeState({ enabledPlatforms, offices, migrations });
+    replaceState(offices) {
+        const candidate = freezeState(offices);
         this.writeState(this.registryPath, `${JSON.stringify(candidate, null, 2)}\n`);
         this.state = candidate;
     }
@@ -422,7 +254,7 @@ export class OfficeRegistry {
         assertRegistryFileSafe(this.registryPath);
         const raw = readTextFileIfExists(this.registryPath);
         if (raw === undefined) {
-            return freezeState({ enabledPlatforms: [], offices: [], migrations: [] });
+            return freezeState([]);
         }
         let value;
         try {
@@ -434,71 +266,21 @@ export class OfficeRegistry {
         return parseState(value, this.registryPath);
     }
 }
-function makeRecord(fields) {
-    const record = {
-        rawConversationId: fields.rawConversationId,
-        sourceDir: fields.sourceDir,
-        workspaceRoot: fields.workspaceRoot,
-        ownerPlatform: fields.ownerPlatform ? fields.ownerPlatform : undefined,
-        targetDir: fields.targetDir ? fields.targetDir : undefined,
-        status: fields.status,
-        error: fields.error ? fields.error : undefined,
-        updatedAt: fields.updatedAt ?? new Date().toISOString(),
-    };
-    return Object.freeze(record);
-}
-function transitionRecord(record, status, error) {
-    const targetDir = migrationTarget(record);
-    return makeRecord({
-        rawConversationId: record.rawConversationId,
-        sourceDir: record.sourceDir,
-        workspaceRoot: record.workspaceRoot,
-        ownerPlatform: record.ownerPlatform,
-        targetDir,
-        status,
-        error,
-    });
-}
-function migrationTarget(record) {
-    return record.ownerPlatform
-        ? officeDir(record.workspaceRoot, {
-            platform: record.ownerPlatform,
-            conversationId: record.rawConversationId,
-        })
-        : undefined;
-}
-function freezeState(input) {
+function freezeState(offices) {
     return Object.freeze({
         version: REGISTRY_VERSION,
-        enabledPlatforms: Object.freeze([...input.enabledPlatforms]),
-        offices: Object.freeze(input.offices.map((record) => Object.freeze({ ...record }))),
-        migrations: Object.freeze(input.migrations.map((record) => Object.freeze({ ...record }))),
+        offices: Object.freeze(offices.map((record) => Object.freeze({ ...record }))),
     });
 }
 function parseState(value, path) {
-    if (!isRecord(value) || value.version !== REGISTRY_VERSION) {
-        throw new Error(`Invalid office registry version at ${path}`);
-    }
-    if (!Array.isArray(value.enabledPlatforms) || !Array.isArray(value.migrations)) {
-        throw new Error(`Invalid office registry shape at ${path}`);
-    }
-    const enabledPlatforms = value.enabledPlatforms.map((platform) => {
-        if (typeof platform !== "string")
-            throw new Error(`Invalid enabled platform in ${path}`);
-        return assertPlatformName(platform);
-    });
-    if (new Set(enabledPlatforms).size !== enabledPlatforms.length) {
-        throw new Error(`Duplicate enabled platform in ${path}`);
+    if (!isRecord(value) || value.version !== REGISTRY_VERSION || !Array.isArray(value.offices)) {
+        throw new Error(`Invalid office registry at ${path}`);
     }
-    const offices = (Array.isArray(value.offices) ? value.offices : []).map((entry) => parseOfficeRecord(entry, path));
+    const offices = value.offices.map((entry) => parseOfficeRecord(entry, path));
     if (new Set(offices.map((record) => officeKey(record))).size !== offices.length) {
         throw new Error(`Duplicate office record in ${path}`);
     }
-    const migrations = value.migrations.map((entry) => parseRecord(entry, path, enabledPlatforms));
-    if (new Set(migrations.map((record) => record.rawConversationId)).size !== migrations.length) {
-        throw new Error(`Duplicate office migration in ${path}`);
-    }
-    return freezeState({ enabledPlatforms, offices, migrations });
+    return freezeState(offices);
 }
 function parseOfficeRecord(value, path) {
     if (!isRecord(value))
@@ -514,113 +296,6 @@ function parseOfficeRecord(value, path) {
         recordedAt: value.recordedAt,
     });
 }
-function hasMigrationStrings(value) {
-    return (typeof value.rawConversationId === "string" &&
-        typeof value.sourceDir === "string" &&
-        typeof value.workspaceRoot === "string" &&
-        typeof value.status === "string" &&
-        typeof value.updatedAt === "string");
-}
-function parseMigrationFields(value, path) {
-    if (!hasMigrationStrings(value)) {
-        throw new Error(`Invalid office migration fields in ${path}`);
-    }
-    assertConversationId(value.rawConversationId);
-    if (!isAbsolute(value.sourceDir) || !isAbsolute(value.workspaceRoot)) {
-        throw new Error(`Office migration paths must be absolute in ${path}`);
-    }
-    assertCanonicalSource(value.sourceDir, value.workspaceRoot, value.rawConversationId);
-    if (!MIGRATION_STATUSES.has(value.status)) {
-        throw new Error(`Invalid office migration status in ${path}`);
-    }
-    return {
-        rawConversationId: value.rawConversationId,
-        sourceDir: value.sourceDir,
-        workspaceRoot: value.workspaceRoot,
-        status: value.status,
-        updatedAt: value.updatedAt,
-    };
-}
-function assertOwnershipMatchesStatus(status, ownerPlatform, targetDir, path) {
-    const owned = ownerPlatform !== undefined;
-    const targeted = targetDir !== undefined;
-    if (status === "needs-owner" && (owned || targeted)) {
-        throw new Error(`Needs-owner migration cannot have an owner or target in ${path}`);
-    }
-    if (status !== "needs-owner" && status !== "failed" && !(owned && targeted)) {
-        throw new Error(`Prepared office migration is missing ownership in ${path}`);
-    }
-    if (!owned && targeted) {
-        throw new Error(`Office migration target has no owner in ${path}`);
-    }
-}
-function parseRecord(value, path, enabledPlatforms) {
-    if (!isRecord(value))
-        throw new Error(`Invalid office migration record in ${path}`);
-    const fields = parseMigrationFields(value, path);
-    const ownerPlatform = optionalPlatform(value.ownerPlatform);
-    const targetDir = optionalString(value.targetDir);
-    const error = optionalString(value.error);
-    if (ownerPlatform !== undefined && !enabledPlatforms.includes(ownerPlatform)) {
-        throw new Error(`Office migration owner is not enabled in ${path}`);
-    }
-    assertOwnershipMatchesStatus(fields.status, ownerPlatform, targetDir, path);
-    const expectedTargetDir = ownerPlatform
-        ? officeDir(fields.workspaceRoot, {
-            platform: ownerPlatform,
-            conversationId: fields.rawConversationId,
-        })
-        : undefined;
-    if (targetDir !== expectedTargetDir) {
-        throw new Error(`Office migration target does not match its office address in ${path}`);
-    }
-    if (fields.status === "failed" && !error) {
-        throw new Error(`Failed office migration is missing an error in ${path}`);
-    }
-    return buildMigrationRecord(fields, ownerPlatform, expectedTargetDir, error);
-}
-function buildMigrationRecord(fields, ownerPlatform, targetDir, error) {
-    return makeRecord({
-        rawConversationId: fields.rawConversationId,
-        sourceDir: fields.sourceDir,
-        workspaceRoot: fields.workspaceRoot,
-        ownerPlatform,
-        targetDir,
-        status: fields.status,
-        error,
-        updatedAt: fields.updatedAt,
-    });
-}
-function optionalPlatform(value) {
-    return value === undefined
-        ? undefined
-        : typeof value === "string"
-            ? assertPlatformName(value)
-            : failOptional("platform");
-}
-function optionalString(value) {
-    return value === undefined
-        ? undefined
-        : typeof value === "string"
-            ? value
-            : failOptional("string");
-}
-function failOptional(label) {
-    throw new Error(`Invalid optional ${label} in office registry`);
-}
-function assertSameMigrationInputs(existing, sourceDir, workspaceRoot) {
-    if (existing.sourceDir !== sourceDir || existing.workspaceRoot !== workspaceRoot) {
-        throw new Error(`Legacy office migration inputs changed for ${existing.rawConversationId}`);
-    }
-}
-function assertCanonicalSource(sourceDir, workspaceRoot, rawConversationId) {
-    const expectedSourceDir = resolve(workspaceRoot, rawConversationId);
-    if (sourceDir !== expectedSourceDir) {
-        throw new Error(`Legacy office source must be ${expectedSourceDir}`);
-    }
-    assertRegularDirectory(workspaceRoot, "Workspace root");
-    assertPathIfPresent(sourceDir, "Legacy office source");
-}
 function assertRegularDirectory(path, label) {
     let stat;
     try {
@@ -649,19 +324,6 @@ function assertRegistryFileSafe(path) {
         throw new Error(`Office registry must be a regular file: ${path}`);
     }
 }
-function assertPathIfPresent(path, label) {
-    const stat = lstatIfExists(path);
-    if (stat && (stat.isSymbolicLink() || !stat.isDirectory())) {
-        throw new Error(`${label} must be a regular directory: ${path}`);
-    }
-}
-function assertPathAbsent(path, label) {
-    if (lstatIfExists(path))
-        throw new Error(`${label} must be absent: ${path}`);
-}
-function pathExists(path) {
-    return lstatIfExists(path) !== undefined;
-}
 function claimRegistryLock(lockPath, token) {
     mkdirSync(lockPath, { mode: 0o700 });
     try {
@@ -741,231 +403,7 @@ function sleepSync(milliseconds) {
 export function listRegisteredOffices(stateDir) {
     return new OfficeRegistry(stateDir).getOffices();
 }
-function platformsMatchingConversationIdFormat(rawConversationId, enabledPlatforms) {
-    return enabledPlatforms.filter((platform) => {
-        switch (platform) {
-            case "github":
-                return isGithubConversationId(rawConversationId);
-            case "telegram":
-                return /^-?\d+$/.test(rawConversationId);
-            case "discord":
-                return /^\d+$/.test(rawConversationId);
-            case "slack":
-                return /^[A-Z][A-Z0-9]*$/.test(rawConversationId);
-        }
-    });
-}
-function isGithubConversationId(rawConversationId) {
-    try {
-        parseGithubConversationId(rawConversationId);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function isErrno(error, code) {
     return error instanceof Error && "code" in error && error.code === code;
 }
-export function migrateLegacyOffices(options) {
-    const registry = new OfficeRegistry(options.stateDir);
-    for (const platform of options.enabledPlatforms)
-        registry.enablePlatform(platform);
-    const summary = {
-        migrated: [],
-        recovered: [],
-        unowned: [],
-        failed: [],
-        vaultKeysMigrated: [],
-        vaultConflicts: [],
-        stateDirsMigrated: [],
-        stateDirConflicts: [],
-    };
-    recoverInterruptedMoves(registry, summary);
-    claimAndMoveLegacyDirs(registry, options.workspaceRoot, summary);
-    const vaults = migrateConversationVaultKeys({
-        stateDir: options.stateDir,
-        offices: registry.getOffices(),
-    });
-    summary.vaultKeysMigrated = vaults.migrated;
-    summary.vaultConflicts = vaults.conflicts;
-    for (const rawConversationId of vaults.migrated) {
-        log.logInfo(`[office] Migrated vault key to office key: ${rawConversationId}`);
-    }
-    migrateConversationStateDirs(registry, options.stateDir, summary);
-    for (const record of registry.getState().migrations) {
-        if (record.status === "needs-owner")
-            summary.unowned.push(record.rawConversationId);
-        else if (record.status === "failed")
-            summary.failed.push(record.rawConversationId);
-    }
-    return summary;
-}
-function recoverInterruptedMoves(registry, summary) {
-    for (const record of registry.getState().migrations) {
-        if (record.status !== "moving")
-            continue;
-        const failure = finishInterruptedMove(record);
-        if (failure) {
-            registry.markFailed(record.rawConversationId, failure);
-            continue;
-        }
-        registry.markCommitted(record.rawConversationId);
-        recordMigratedOffice(registry, record);
-        summary.recovered.push(record.rawConversationId);
-        log.logInfo(`[office] Recovered interrupted migration: ${record.rawConversationId}`);
-    }
-}
-function finishInterruptedMove(record) {
-    const targetDir = record.targetDir;
-    if (!targetDir)
-        return "Moving record has no target directory";
-    const sourceExists = pathExists(record.sourceDir);
-    const targetExists = pathExists(targetDir);
-    if (sourceExists && targetExists) {
-        return "Both legacy source and office target exist; merge them manually";
-    }
-    if (!sourceExists && !targetExists)
-        return "Neither legacy source nor office target exists";
-    if (sourceExists)
-        renameSync(record.sourceDir, targetDir);
-    return undefined;
-}
-function isClaimableLegacyDir(registry, workspaceRoot, rawConversationId) {
-    const existing = registry.getMigration(rawConversationId);
-    if (existing?.status === "committed") {
-        throw new Error(`Legacy office directory reappeared after migration: ${join(workspaceRoot, rawConversationId)}`);
-    }
-    return existing?.status !== "failed";
-}
-function claimAndMoveLegacyDirs(registry, workspaceRoot, summary) {
-    for (const rawConversationId of listLegacyOfficeDirs(workspaceRoot)) {
-        if (!isClaimableLegacyDir(registry, workspaceRoot, rawConversationId))
-            continue;
-        const record = registry.prepareLegacyMigration({
-            rawConversationId,
-            sourceDir: join(workspaceRoot, rawConversationId),
-            workspaceRoot,
-        });
-        if (record.status === "needs-owner")
-            continue;
-        const moving = registry.markMoving(rawConversationId);
-        const targetDir = moving.targetDir;
-        if (!targetDir)
-            throw new Error("Moving office migration has no target directory");
-        renameSync(moving.sourceDir, targetDir);
-        registry.markCommitted(rawConversationId);
-        recordMigratedOffice(registry, moving);
-        summary.migrated.push(rawConversationId);
-        log.logInfo(`[office] Migrated office directory: ${rawConversationId} -> ${targetDir}`);
-    }
-}
-function migrateConversationStateDirs(registry, stateDir, summary) {
-    for (const office of registry.getOffices()) {
-        const legacyDir = join(stateDir, "conversations", office.conversationId);
-        if (!existsSync(legacyDir))
-            continue;
-        const targetDir = officeStateDir(stateDir, office);
-        if (existsSync(targetDir)) {
-            summary.stateDirConflicts.push(office.conversationId);
-            continue;
-        }
-        renameSync(legacyDir, targetDir);
-        summary.stateDirsMigrated.push(office.conversationId);
-        log.logInfo(`[office] Migrated host state dir to office key: ${office.conversationId}`);
-    }
-}
-function recordMigratedOffice(registry, record) {
-    if (!record.ownerPlatform)
-        return;
-    registry.recordOffice({
-        platform: record.ownerPlatform,
-        conversationId: record.rawConversationId,
-    });
-}
-function listLegacyOfficeDirs(workspaceRoot) {
-    return readdirSync(workspaceRoot, { withFileTypes: true })
-        .filter((entry) => isLegacyOfficeDir(workspaceRoot, entry))
-        .map((entry) => entry.name)
-        .toSorted();
-}
-function isLegacyOfficeDir(workspaceRoot, entry) {
-    if (entry.name.startsWith("."))
-        return false;
-    if (RESERVED_WORKSPACE_NAMES.has(entry.name))
-        return false;
-    if (isOfficeKey(entry.name))
-        return false;
-    if (entry.isSymbolicLink()) {
-        throw new Error(`Workspace entry must not be a symlink: ${join(workspaceRoot, entry.name)}`);
-    }
-    if (!entry.isDirectory())
-        return false;
-    if (looksLikeConversationOffice(join(workspaceRoot, entry.name)))
-        return true;
-    log.logInfo(`[office] Skipping non-office workspace directory (no ${OFFICE_LOG_FILENAME} or sessions/): ${entry.name}`);
-    return false;
-}
-function looksLikeConversationOffice(dir) {
-    return existsSync(join(dir, OFFICE_LOG_FILENAME)) || existsSync(join(dir, "sessions"));
-}
-export function formatUnmigratedOfficesError(summary) {
-    const lines = ["Conversation office migration cannot complete:"];
-    if (summary.unowned.length > 0) {
-        lines.push("", "These legacy conversation directories have no owning platform (several", "platforms are enabled, so ownership cannot be inferred):", ...summary.unowned.map((id) => `  - ${id}`), "", "Assign each one with:", "  mikan office claim <conversationId> <platform>");
-    }
-    lines.push(...conflictSection(summary.failed, [
-        "These migrations previously failed and need manual repair (see",
-        "office-registry.json in the state dir for each error):",
-    ]), ...conflictSection(summary.vaultConflicts, [
-        "These conversations have credentials under both the legacy and the",
-        "office-key vault directory; merge them manually under <state-dir>/vaults:",
-    ]), ...conflictSection(summary.stateDirConflicts, [
-        "These conversations have host state under both the legacy and the",
-        "office-key directory; merge them manually under <state-dir>/conversations:",
-    ]));
-    return lines.join("\n");
-}
-function conflictSection(ids, explanation) {
-    if (ids.length === 0)
-        return [];
-    return ["", ...explanation, ...ids.map((id) => `  - ${id}`)];
-}
-function replacePrefix(path, pairs) {
-    for (const [oldPrefix, newPrefix] of pairs) {
-        if (path === oldPrefix)
-            return newPrefix;
-        if (path.startsWith(`${oldPrefix}/`))
-            return newPrefix + path.slice(oldPrefix.length);
-    }
-    return path;
-}
-export function buildContainerBindTranslator(options) {
-    const hostPairs = [];
-    const guestPairs = [];
-    for (const office of options.offices) {
-        const key = officeKey(office);
-        const rawId = office.conversationId;
-        hostPairs.push([join(options.workspaceRoot, rawId), join(options.workspaceRoot, key)]);
-        hostPairs.push([
-            join(options.stateDir, "conversations", rawId),
-            officeStateDir(options.stateDir, office),
-        ]);
-        hostPairs.push([
-            join(options.stateDir, "vaults", legacyConversationCredentialKey(rawId)),
-            join(options.stateDir, "vaults", key),
-        ]);
-        guestPairs.push([guestWorkspacePath(rawId), guestWorkspacePath(key)]);
-    }
-    return (bindSpec) => {
-        const readOnly = bindSpec.endsWith(":ro");
-        const spec = readOnly ? bindSpec.slice(0, -3) : bindSpec;
-        const separator = spec.indexOf(":");
-        if (separator === -1)
-            return bindSpec;
-        const source = replacePrefix(spec.slice(0, separator), hostPairs);
-        const target = replacePrefix(spec.slice(separator + 1), guestPairs);
-        return `${source}:${target}${readOnly ? ":ro" : ""}`;
-    };
-}
 //# sourceMappingURL=index.js.map