@hasna/machines 0.0.20 → 0.0.22

package/README.md

@@ -111,6 +111,23 @@ workspace inference second; consumers can still pass manual overrides.
 
 ```bash
 machines workspace resolve --machine spark01 --project open-knowledge --repo open-knowledge --json
+machines workspace doctor --machine spark01 --project open-knowledge --repo open-knowledge --json
+```
+
+`workspace resolve` and `workspace doctor` include JSON-friendly
+`diagnostics` and `repair_hints`. Diagnostics classify missing manifests,
+unresolved roots, inferred roots, local stale paths, untrusted machines, and
+unknown auth. Repair hints include the dry-run command plus the matching
+`--apply` command so downstream apps can surface the next step without
+depending on open-machines internals.
+
+If a resolver result reports inferred or unresolved project/open-files roots,
+repair the manifest metadata explicitly. The command previews changes by
+default and only writes when `--apply` is passed:
+
+```bash
+machines workspace repair --machine spark01 --project open-knowledge --repo open-knowledge --json
+machines workspace repair --machine spark01 --project open-knowledge --repo open-knowledge --apply --json
 ```
 
 ## Compatibility SDK

package/dist/cli/index.js

@@ -7633,7 +7633,8 @@ var MACHINES_CONSUMER_CAPABILITIES = {
   compatibility: true,
   route_resolution: true,
   cli_json_fallback: true,
-  workspace_path_mapping: true
+  workspace_path_mapping: true,
+  workspace_diagnostics: true
 };
 function getMachinesConsumerCapabilities() {
   return { ...MACHINES_CONSUMER_CAPABILITIES };
@@ -8024,6 +8025,170 @@ function inferRepoRoot(workspaceRoot, repoName) {
   }
   return joinPath(root, repoName);
 }
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function shellCommand(command) {
+  return command.map(shellQuote).join(" ");
+}
+function canCheckPathForMachine(machine, localMachineId) {
+  if (!machine)
+    return false;
+  if (machine.machine_id === localMachineId)
+    return true;
+  return machine.route_hints.some((hint) => hint.kind === "local");
+}
+function checkedPathExists(path, check) {
+  if (!path || !check)
+    return null;
+  return existsSync5(path);
+}
+function repairHint(input) {
+  const command = [
+    "machines",
+    "workspace",
+    "repair",
+    "--machine",
+    input.machineId,
+    "--project",
+    input.projectId
+  ];
+  if (input.repoName)
+    command.push("--repo", input.repoName);
+  if (input.openFilesRepoName)
+    command.push("--open-files-repo", input.openFilesRepoName);
+  command.push("--json");
+  const applyCommand = [...command.slice(0, -1), "--apply", "--json"];
+  return {
+    id: `repair:${input.machineId}:${input.projectId}`,
+    reason: input.reason,
+    command,
+    shell_command: shellCommand(command),
+    apply_command: applyCommand,
+    apply_shell_command: shellCommand(applyCommand)
+  };
+}
+function pathDiagnostic(input) {
+  if (!input.path.path) {
+    return {
+      id: input.id,
+      status: "missing",
+      severity: input.required ? "fail" : "warn",
+      message: `${input.label} is unresolved.`,
+      path: null,
+      source: input.path.source,
+      path_exists: null
+    };
+  }
+  if (input.pathExists === false) {
+    return {
+      id: input.id,
+      status: "stale",
+      severity: "fail",
+      message: `${input.label} points to a path that does not exist on this machine.`,
+      path: input.path.path,
+      source: input.path.source,
+      path_exists: false
+    };
+  }
+  if (input.path.source === "inferred") {
+    return {
+      id: input.id,
+      status: "inferred",
+      severity: "warn",
+      message: `${input.label} was inferred from the workspace root; write an explicit manifest mapping for repeatable downstream sync.`,
+      path: input.path.path,
+      source: input.path.source,
+      path_exists: input.pathExists
+    };
+  }
+  return {
+    id: input.id,
+    status: "ok",
+    severity: "ok",
+    message: `${input.label} is explicit enough for downstream sync.`,
+    path: input.path.path,
+    source: input.path.source,
+    path_exists: input.pathExists
+  };
+}
+function workspaceDiagnostics(input) {
+  const checkPaths = canCheckPathForMachine(input.machine, input.localMachineId);
+  const diagnostics = [];
+  if (!input.machine) {
+    diagnostics.push({
+      id: "manifest",
+      status: "missing_manifest",
+      severity: "fail",
+      message: "Machine is not present in topology or manifest.",
+      path: null,
+      source: "manifest",
+      path_exists: null
+    });
+  } else if (!input.resolution.evidence.manifest_declared) {
+    diagnostics.push({
+      id: "manifest",
+      status: "missing_manifest",
+      severity: "warn",
+      message: "Machine came from live topology but is not declared in the manifest.",
+      path: null,
+      source: "manifest",
+      path_exists: null
+    });
+  }
+  diagnostics.push(pathDiagnostic({
+    id: "workspace_root",
+    label: "Workspace root",
+    path: input.resolution.paths.workspace_root,
+    pathExists: checkedPathExists(input.resolution.paths.workspace_root.path, checkPaths),
+    required: false
+  }));
+  diagnostics.push(pathDiagnostic({
+    id: "project_root",
+    label: "Project root",
+    path: input.resolution.paths.project_root,
+    pathExists: checkedPathExists(input.resolution.paths.project_root.path, checkPaths),
+    required: true
+  }));
+  diagnostics.push(pathDiagnostic({
+    id: "open_files_root",
+    label: "Open-files root",
+    path: input.resolution.paths.open_files_root,
+    pathExists: checkedPathExists(input.resolution.paths.open_files_root.path, checkPaths),
+    required: false
+  }));
+  if (input.resolution.machine.trust_status !== "trusted") {
+    diagnostics.push({
+      id: "trust",
+      status: "untrusted",
+      severity: "warn",
+      message: `Machine trust status is ${input.resolution.machine.trust_status}; manifest repair apply requires trust or --allow-untrusted.`,
+      path: null,
+      source: "trust",
+      path_exists: null
+    });
+  }
+  if (input.resolution.machine.auth_status !== "authenticated") {
+    diagnostics.push({
+      id: "auth",
+      status: "unknown_auth",
+      severity: "warn",
+      message: `Machine auth status is ${input.resolution.machine.auth_status}; remote sync may still fail if SSH is unavailable.`,
+      path: null,
+      source: "auth",
+      path_exists: null
+    });
+  }
+  const needsRepair = diagnostics.some((entry) => (entry.id === "project_root" || entry.id === "open_files_root") && (entry.status === "missing" || entry.status === "inferred" || entry.status === "stale"));
+  const repairHints = needsRepair ? [repairHint({
+    machineId: input.resolution.machine_id ?? input.resolution.requested_machine_id,
+    projectId: input.resolution.project.project_id,
+    repoName: input.resolution.project.repo_name,
+    openFilesRepoName: input.openFilesRepoName,
+    reason: "Write explicit workspace_paths and open_files_roots manifest metadata."
+  })] : [];
+  return { diagnostics, repairHints };
+}
 function projectPathFromMetadata(metadata, projectId, repoName) {
   const keys = [projectId, repoName].filter((value) => Boolean(value));
   return readMappedPath({
@@ -8099,7 +8264,7 @@ function resolveMachineWorkspace(options) {
   const openFilesRepoName = options.openFilesRepoName ?? "open-files";
   if (!machine) {
     warnings.push(`machine_not_found:${options.machineId}`);
-    return {
+    const resolution2 = {
       schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
       package: topology.package,
       ok: false,
@@ -8113,6 +8278,8 @@ function resolveMachineWorkspace(options) {
         project_root: { path: null, source: "unresolved" },
         open_files_root: { path: null, source: "unresolved" }
       },
+      diagnostics: [],
+      repair_hints: [],
       evidence: {
         topology: true,
         matched_by: matchedBy,
@@ -8121,6 +8288,17 @@ function resolveMachineWorkspace(options) {
       },
       warnings
     };
+    const diagnostics2 = workspaceDiagnostics({
+      machine,
+      localMachineId: topology.local_machine_id,
+      resolution: resolution2,
+      openFilesRepoName
+    });
+    return {
+      ...resolution2,
+      diagnostics: diagnostics2.diagnostics,
+      repair_hints: diagnostics2.repairHints
+    };
   }
   const metadata = machine.metadata;
   const workspaceRootPath = options.workspaceRoot ?? machine.workspace_path;
@@ -8139,7 +8317,7 @@ function resolveMachineWorkspace(options) {
     warnings.push(`open_files_root_inferred:${options.projectId}`);
   if (!projectRootPath)
     warnings.push(`project_root_unresolved:${options.projectId}`);
-  return {
+  const resolution = {
     schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
     package: topology.package,
     ok: Boolean(projectRootPath),
@@ -8162,6 +8340,8 @@ function resolveMachineWorkspace(options) {
       project_root: { path: projectRootPath, source: projectRootSource },
       open_files_root: { path: openFilesRootPath, source: openFilesRootSource }
     },
+    diagnostics: [],
+    repair_hints: [],
     evidence: {
       topology: true,
       matched_by: matchedBy,
@@ -8170,10 +8350,21 @@ function resolveMachineWorkspace(options) {
     },
     warnings
   };
+  const diagnostics = workspaceDiagnostics({
+    machine,
+    localMachineId: topology.local_machine_id,
+    resolution,
+    openFilesRepoName
+  });
+  return {
+    ...resolution,
+    diagnostics: diagnostics.diagnostics,
+    repair_hints: diagnostics.repairHints
+  };
 }
 
 // src/commands/ssh.ts
-function shellQuote(value) {
+function shellQuote2(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function resolveSshTarget(machineId, options = {}) {
@@ -8194,11 +8385,11 @@ function resolveSshTarget(machineId, options = {}) {
 }
 function buildSshCommand(machineId, remoteCommand, options = {}) {
   const resolved = resolveSshTarget(machineId, options);
-  return remoteCommand ? `ssh ${resolved.target} ${shellQuote(remoteCommand)}` : `ssh ${resolved.target}`;
+  return remoteCommand ? `ssh ${resolved.target} ${shellQuote2(remoteCommand)}` : `ssh ${resolved.target}`;
 }
 
 // src/remote.ts
-function shellQuote2(value) {
+function shellQuote3(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function machineIsLocal(machineId, localMachineId) {
@@ -8216,7 +8407,7 @@ function resolveMachineCommand(machineId, command, localMachineId = getLocalMach
   } catch (error) {
     const message = String(error.message ?? error);
     if (message.includes("Machine route not found") || message.includes("Machine not found in manifest")) {
-      return { source: "ssh", shellCommand: `ssh ${shellQuote2(machineId)} ${shellQuote2(command)}` };
+      return { source: "ssh", shellCommand: `ssh ${shellQuote3(machineId)} ${shellQuote3(command)}` };
     }
     throw error;
   }
@@ -8249,7 +8440,7 @@ function getAppManager(machine, app) {
     return "winget";
   return "apt";
 }
-function shellQuote3(value) {
+function shellQuote4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function buildAppCommand(machine, app) {
@@ -8270,7 +8461,7 @@ function buildAppCommand(machine, app) {
   return `sudo apt-get install -y ${packageName}`;
 }
 function buildAppProbeCommand(machine, app) {
-  const packageName = shellQuote3(getPackageName(app));
+  const packageName = shellQuote4(getPackageName(app));
   const manager = getAppManager(machine, app);
   if (manager === "custom") {
     return `if command -v ${packageName} >/dev/null 2>&1; then printf 'installed=1\\nversion=custom\\n'; else printf 'installed=0\\n'; fi`;
@@ -8565,7 +8756,7 @@ var notificationConfigSchema = exports_external.object({
 function sortChannels(channels) {
   return [...channels].sort((left, right) => left.id.localeCompare(right.id));
 }
-function shellQuote4(value) {
+function shellQuote5(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function hasCommand2(binary) {
@@ -8612,7 +8803,7 @@ ${message}
     };
   }
   if (hasCommand2("mail")) {
-    const command = `printf %s ${shellQuote4(message)} | mail -s ${shellQuote4(subject)} ${shellQuote4(channel.target)}`;
+    const command = `printf %s ${shellQuote5(message)} | mail -s ${shellQuote5(subject)} ${shellQuote5(channel.target)}`;
     const result = Bun.spawnSync(["bash", "-lc", command], {
       stdout: "pipe",
       stderr: "pipe",
@@ -9038,6 +9229,156 @@ function getStatus() {
   };
 }
 
+// src/commands/workspace.ts
+init_paths();
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function cloneMetadata(metadata) {
+  return isRecord2(metadata) ? { ...metadata } : {};
+}
+function mappedPath(metadata, field, key) {
+  const container = metadata[field];
+  if (!isRecord2(container))
+    return null;
+  const value = container[key];
+  if (typeof value === "string" && value.trim())
+    return value.trim();
+  if (isRecord2(value)) {
+    const nested = value["path"] ?? value["root"] ?? value["workspacePath"] ?? value["workspace_path"];
+    if (typeof nested === "string" && nested.trim())
+      return nested.trim();
+  }
+  return null;
+}
+function writeMappedPath(metadata, field, key, path) {
+  const existing = metadata[field];
+  const container = isRecord2(existing) ? { ...existing } : {};
+  container[key] = path;
+  metadata[field] = container;
+}
+function buildPatch(input) {
+  const previous = mappedPath(input.metadata, input.field, input.key);
+  if (!input.path) {
+    return {
+      field: input.field,
+      key: input.key,
+      path: null,
+      previous_path: previous,
+      status: "unresolved"
+    };
+  }
+  const status = previous === input.path ? "unchanged" : input.apply ? "written" : "would_write";
+  return {
+    field: input.field,
+    key: input.key,
+    path: input.path,
+    previous_path: previous,
+    status
+  };
+}
+function upsertMachineMetadata(manifest, machineId, metadata) {
+  return {
+    ...manifest,
+    machines: manifest.machines.map((machine) => machine.id === machineId ? { ...machine, metadata } : machine)
+  };
+}
+function repairWorkspaceManifestMappings(options) {
+  const projectId = options.projectId;
+  const repoName = options.repoName ?? projectId;
+  const openFilesRepoName = options.openFilesRepoName ?? "open-files";
+  const apply = options.apply === true;
+  const resolution = resolveMachineWorkspace({
+    machineId: options.machineId,
+    projectId,
+    repoName,
+    openFilesRepoName,
+    projectRoot: options.projectRoot,
+    openFilesRoot: options.openFilesRoot,
+    workspaceRoot: options.workspaceRoot,
+    includeTailscale: options.includeTailscale,
+    now: options.now
+  });
+  const warnings = [...resolution.warnings];
+  const manifest = readManifest();
+  const manifestMachineId = resolution.machine_id ?? options.machineId;
+  const machine = manifest.machines.find((entry) => entry.id === manifestMachineId) ?? null;
+  const trusted = resolution.machine.trust_status === "trusted" || options.allowUntrusted === true;
+  if (!machine) {
+    warnings.push(`manifest_machine_missing:${manifestMachineId}`);
+    return {
+      ok: false,
+      applied: false,
+      manifest_path: getManifestPath(),
+      machine_id: resolution.machine_id,
+      project_id: projectId,
+      repo_name: repoName,
+      open_files_repo_name: openFilesRepoName,
+      trusted,
+      resolution,
+      patches: [],
+      warnings
+    };
+  }
+  const metadata = cloneMetadata(machine.metadata);
+  const patches = [
+    buildPatch({
+      metadata,
+      field: "workspace_paths",
+      key: projectId,
+      path: options.projectRoot ?? resolution.paths.project_root.path,
+      apply
+    }),
+    buildPatch({
+      metadata,
+      field: "open_files_roots",
+      key: projectId,
+      path: options.openFilesRoot ?? resolution.paths.open_files_root.path,
+      apply
+    })
+  ];
+  const hasUnresolved = patches.some((patch) => patch.status === "unresolved");
+  const hasWrites = patches.some((patch) => patch.status === "would_write" || patch.status === "written");
+  if (apply && hasWrites && !trusted) {
+    warnings.push(`manifest_repair_requires_trusted_machine:${manifestMachineId}`);
+    return {
+      ok: false,
+      applied: false,
+      manifest_path: getManifestPath(),
+      machine_id: manifestMachineId,
+      project_id: projectId,
+      repo_name: repoName,
+      open_files_repo_name: openFilesRepoName,
+      trusted,
+      resolution,
+      patches: patches.map((patch) => patch.status === "written" ? { ...patch, status: "would_write" } : patch),
+      warnings
+    };
+  }
+  let applied = false;
+  if (apply && !hasUnresolved && hasWrites) {
+    for (const patch of patches) {
+      if (patch.path && patch.status === "written")
+        writeMappedPath(metadata, patch.field, patch.key, patch.path);
+    }
+    writeManifest(upsertMachineMetadata(manifest, manifestMachineId, metadata));
+    applied = true;
+  }
+  return {
+    ok: resolution.ok && !hasUnresolved && (!apply || applied || !hasWrites),
+    applied,
+    manifest_path: getManifestPath(),
+    machine_id: manifestMachineId,
+    project_id: projectId,
+    repo_name: repoName,
+    open_files_repo_name: openFilesRepoName,
+    trusted,
+    resolution,
+    patches,
+    warnings
+  };
+}
+
 // src/compatibility.ts
 init_db();
 var DEFAULT_COMMANDS = [
@@ -9047,7 +9388,7 @@ var DEFAULT_COMMANDS = [
 function defaultPackages() {
   return [{ name: "@hasna/machines", command: "machines", expectedVersion: getPackageVersion(), required: true }];
 }
-function shellQuote5(value) {
+function shellQuote6(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function commandId(value) {
@@ -9098,7 +9439,7 @@ function defaultRunner2(machineId, command) {
   return runMachineCommand(machineId, command);
 }
 function inspectCommand(machineId, spec, runner) {
-  const command = shellQuote5(spec.command);
+  const command = shellQuote6(spec.command);
   const versionArgs = spec.versionArgs ?? "--version";
   const script = [
     `cmd=${command}`,
@@ -9127,7 +9468,7 @@ function fieldCommand(field) {
 }
 function inspectWorkspace(machineId, spec, runner) {
   const script = [
-    `path=${shellQuote5(spec.path)}`,
+    `path=${shellQuote6(spec.path)}`,
     'printf "exists=%s\\n" "$(test -d "$path" && printf yes || printf no)"',
     'pkg="$path/package.json"',
     'printf "package_json=%s\\n" "$(test -f "$pkg" && printf yes || printf no)"',
@@ -10769,6 +11110,12 @@ function renderCompatibilityResult(result) {
 `);
 }
 function renderWorkspaceResolution(result) {
+  const diagnosticSummary = result.diagnostics.reduce((summary, entry) => {
+    summary[entry.severity] += 1;
+    return summary;
+  }, { ok: 0, warn: 0, fail: 0 });
+  const diagnosticLines = result.diagnostics.filter((entry) => entry.severity !== "ok").map((entry) => `${entry.id}: ${entry.status} ${entry.message}`);
+  const repairLines = result.repair_hints.map((hint) => `${hint.reason}: ${hint.shell_command}`);
   return renderKeyValueTable([
     ["machine", result.machine_id ?? result.requested_machine_id],
     ["ok", String(result.ok)],
@@ -10781,8 +11128,30 @@ function renderWorkspaceResolution(result) {
     ["workspace root", `${result.paths.workspace_root.path ?? "unresolved"} (${result.paths.workspace_root.source})`],
     ["project root", `${result.paths.project_root.path ?? "unresolved"} (${result.paths.project_root.source})`],
     ["open-files root", `${result.paths.open_files_root.path ?? "unresolved"} (${result.paths.open_files_root.source})`],
+    ["diagnostics", `${diagnosticSummary.ok} ok, ${diagnosticSummary.warn} warn, ${diagnosticSummary.fail} fail`],
     ["warnings", result.warnings.join(", ") || "none"]
-  ]);
+  ]) + `
+` + renderList("issues", diagnosticLines) + `
+` + renderList("repair hints", repairLines);
+}
+function renderWorkspaceRepairResult(result) {
+  const patchLines = result.patches.map((patch) => {
+    const path = patch.path ?? "unresolved";
+    const previous = patch.previous_path ? ` previous=${patch.previous_path}` : "";
+    return `${patch.field}.${patch.key}: ${patch.status} ${path}${previous}`;
+  });
+  return [
+    renderKeyValueTable([
+      ["machine", result.machine_id ?? "unresolved"],
+      ["project", result.project_id],
+      ["trusted", String(result.trusted)],
+      ["applied", String(result.applied)],
+      ["manifest", result.manifest_path],
+      ["warnings", result.warnings.join(", ") || "none"]
+    ]),
+    renderList("patches", patchLines)
+  ].join(`
+`);
 }
 function renderFleetStatus(status) {
   return [
@@ -10951,6 +11320,39 @@ workspaceCommand.command("resolve").description("Resolve repo and open-files roo
   if (!result.ok && !options.json)
     process.exitCode = 1;
 });
+workspaceCommand.command("doctor").description("Diagnose repo and open-files workspace mappings and print repair hints").requiredOption("--machine <id>", "Machine identifier").requiredOption("--project <id>", "Canonical project id").option("--repo <name>", "Repository name; defaults to project id").option("--open-files-repo <name>", "Open-files repository name", "open-files").option("--primary-machine <id>", "Primary machine id for the project").option("--workspace-root <path>", "Override the machine workspace root").option("--project-root <path>", "Override the resolved project root").option("--open-files-root <path>", "Override the resolved open-files root").option("--no-tailscale", "Skip tailscale status probing").option("-j, --json", "Print JSON output", false).action((options) => {
+  const result = resolveMachineWorkspace({
+    machineId: options.machine,
+    projectId: options.project,
+    repoName: options.repo,
+    openFilesRepoName: options.openFilesRepo,
+    primaryMachineId: options.primaryMachine,
+    workspaceRoot: options.workspaceRoot,
+    projectRoot: options.projectRoot,
+    openFilesRoot: options.openFilesRoot,
+    includeTailscale: options.tailscale !== false
+  });
+  printJsonOrText(result, renderWorkspaceResolution(result), options.json);
+  if (result.diagnostics.some((entry) => entry.severity === "fail") && !options.json)
+    process.exitCode = 1;
+});
+workspaceCommand.command("repair").description("Preview or write explicit manifest path mappings for inferred workspace roots").requiredOption("--machine <id>", "Machine identifier").requiredOption("--project <id>", "Canonical project id").option("--repo <name>", "Repository name; defaults to project id").option("--open-files-repo <name>", "Open-files repository name", "open-files").option("--workspace-root <path>", "Override the machine workspace root for resolution").option("--project-root <path>", "Explicit project root to write").option("--open-files-root <path>", "Explicit open-files root to write").option("--apply", "Write the mappings into the manifest", false).option("--allow-untrusted", "Allow writing mappings for machines not marked trusted", false).option("--no-tailscale", "Skip tailscale status probing").option("-j, --json", "Print JSON output", false).action((options) => {
+  const result = repairWorkspaceManifestMappings({
+    machineId: options.machine,
+    projectId: options.project,
+    repoName: options.repo,
+    openFilesRepoName: options.openFilesRepo,
+    workspaceRoot: options.workspaceRoot,
+    projectRoot: options.projectRoot,
+    openFilesRoot: options.openFilesRoot,
+    apply: options.apply,
+    allowUntrusted: options.allowUntrusted,
+    includeTailscale: options.tailscale !== false
+  });
+  printJsonOrText(result, renderWorkspaceRepairResult(result), options.json);
+  if (!result.ok && !options.json)
+    process.exitCode = 1;
+});
 program2.command("diff").description("Show manifest differences between two machines").requiredOption("--left <id>", "Left machine identifier").option("--right <id>", "Right machine identifier (defaults to current machine)").option("-j, --json", "Print JSON output", false).action((options) => {
   const result = diffMachines(options.left, options.right);
   console.log(JSON.stringify(result, null, 2));

package/dist/commands/workspace.d.ts

@@ -0,0 +1,37 @@
+import { type MachineWorkspaceResolution } from "../topology.js";
+export interface WorkspaceManifestRepairOptions {
+    machineId: string;
+    projectId: string;
+    repoName?: string;
+    openFilesRepoName?: string;
+    projectRoot?: string;
+    openFilesRoot?: string;
+    workspaceRoot?: string;
+    includeTailscale?: boolean;
+    apply?: boolean;
+    allowUntrusted?: boolean;
+    now?: Date;
+}
+export type WorkspaceManifestRepairStatus = "unchanged" | "would_write" | "written" | "unresolved";
+export interface WorkspaceManifestRepairPatch {
+    field: "workspace_paths" | "open_files_roots";
+    key: string;
+    path: string | null;
+    previous_path: string | null;
+    status: WorkspaceManifestRepairStatus;
+}
+export interface WorkspaceManifestRepairResult {
+    ok: boolean;
+    applied: boolean;
+    manifest_path: string;
+    machine_id: string | null;
+    project_id: string;
+    repo_name: string;
+    open_files_repo_name: string;
+    trusted: boolean;
+    resolution: MachineWorkspaceResolution;
+    patches: WorkspaceManifestRepairPatch[];
+    warnings: string[];
+}
+export declare function repairWorkspaceManifestMappings(options: WorkspaceManifestRepairOptions): WorkspaceManifestRepairResult;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/commands/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/commands/workspace.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2B,KAAK,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAG1F,MAAM,WAAW,8BAA8B;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,MAAM,6BAA6B,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;AAEnG,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,iBAAiB,GAAG,kBAAkB,CAAC;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,6BAA6B,CAAC;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC5C,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,0BAA0B,CAAC;IACvC,OAAO,EAAE,4BAA4B,EAAE,CAAC;IACxC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAqED,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,8BAA8B,GAAG,6BAA6B,CAkGtH"}

package/dist/consumer.d.ts

@@ -1,5 +1,5 @@
 export { MACHINES_CONSUMER_CAPABILITIES, MACHINES_CONSUMER_CONTRACT, MACHINES_CONSUMER_ENTRYPOINT, MACHINES_CONSUMER_CONTRACT_VERSION, MACHINES_PACKAGE_NAME, discoverMachineTopology, getMachinesConsumerCapabilities, getLocalMachineTopology, resolveMachineRoute, resolveMachineWorkspace, } from "./topology.js";
-export type { MachineRouteConfidence, MachineRouteHint, MachineRouteKind, MachineRouteOptions, MachineRouteResolution, MachineTopology, MachineTopologyEntry, MachineTopologyOptions, MachineWorkspaceAuthStatus, MachineWorkspaceOptions, MachineWorkspacePath, MachineWorkspacePathSource, MachineWorkspaceProject, MachineWorkspaceResolution, MachineWorkspaceTrustStatus, MachinesConsumerContract, MachinesConsumerEnvelope, MachinesConsumerCapabilities, MachinesContractPackage, TopologyCommandResult, TopologyCommandRunner, } from "./topology.js";
+export type { MachineRouteConfidence, MachineRouteHint, MachineRouteKind, MachineRouteOptions, MachineRouteResolution, MachineTopology, MachineTopologyEntry, MachineTopologyOptions, MachineWorkspaceAuthStatus, MachineWorkspaceDiagnostic, MachineWorkspaceDiagnosticStatus, MachineWorkspaceOptions, MachineWorkspacePath, MachineWorkspacePathSource, MachineWorkspaceProject, MachineWorkspaceRepairHint, MachineWorkspaceResolution, MachineWorkspaceTrustStatus, MachinesConsumerContract, MachinesConsumerEnvelope, MachinesConsumerCapabilities, MachinesContractPackage, TopologyCommandResult, TopologyCommandRunner, } from "./topology.js";
 export { checkMachineCompatibility, } from "./compatibility.js";
 export type { CompatibilityCheck, CompatibilityCommandRunner, CompatibilityCommandSpec, CompatibilityPackageSpec, CompatibilitySource, CompatibilityStatus, CompatibilityWorkspaceSpec, MachineCompatibilityOptions, MachineCompatibilityReport, } from "./compatibility.js";
 export { resolveMachineCommand, runMachineCommand, } from "./remote.js";

package/dist/consumer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consumer.d.ts","sourceRoot":"","sources":["../src/consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,kCAAkC,EAClC,qBAAqB,EACrB,uBAAuB,EACvB,+BAA+B,EAC/B,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACvB,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,4BAA4B,EAC5B,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,yBAAyB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,eAAe,EACf,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,iBAAiB,GAClB,MAAM,cAAc,CAAC"}
+{"version":3,"file":"consumer.d.ts","sourceRoot":"","sources":["../src/consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,kCAAkC,EAClC,qBAAqB,EACrB,uBAAuB,EACvB,+BAA+B,EAC/B,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,0BAA0B,EAC1B,0BAA0B,EAC1B,gCAAgC,EAChC,uBAAuB,EACvB,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,4BAA4B,EAC5B,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,yBAAyB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,eAAe,EACf,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,iBAAiB,GAClB,MAAM,cAAc,CAAC"}