machine-bridge-mcp 0.5.0 → 0.6.2

package/src/local/cli.mjs

@@ -1,13 +1,16 @@
 import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, unlinkSync } from "node:fs";
-import path, { resolve } from "node:path";
+import path, { join, resolve } from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { LocalDaemon } from "./daemon.mjs";
 import { runStdioServer } from "./stdio.mjs";
-import { DEFAULT_POLICY_PROFILE, DEFAULT_POLICY_REVISION, POLICY_PROFILES, normalizePolicy, policyProfile } from "./tools.mjs";
+import { assertCanonicalFullPolicy, DEFAULT_POLICY_PROFILE, DEFAULT_POLICY_REVISION, POLICY_PROFILES, normalizePolicy, policyProfile, toolsForPolicy } from "./tools.mjs";
 import { classifyOperationalError, createLogger, normalizeLogLevel, sanitizeLogText } from "./log.mjs";
+import { activeManagedJobs, inspectResourceFile, loadManagedJobPlan, ManagedJobManager, publicResourceRegistry, validateResourceName } from "./managed-jobs.mjs";
 import { runWrangler } from "./shell.mjs";
+import { generateRegisteredSshKey } from "./resource-operations.mjs";
+import { runFullAccessTest } from "./full-access-test.mjs";
 import {
   acquireDaemonLock,
   acquireStartupLock,
@@ -37,7 +40,7 @@ const BOOLEAN_OPTIONS = new Set([
   "help", "version", "quiet", "json", "verbose", "rotateSecrets", "forceWorker",
   "daemonOnly", "noAutostart", "noPrintCredentials", "printMcpCredentials",
   "printCredentials", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
-  "yes", "keepWorker",
+  "yes", "keepWorker", "allowInsecurePermissions",
 ]);
 const VALUE_OPTIONS = new Set([
   "workspace", "stateDir", "workerName", "profile", "execMode", "client", "logLevel",
@@ -59,10 +62,13 @@ export async function main(argv = process.argv.slice(2)) {
     case "client-config": return clientConfigCommand(args);
     case "status": return statusCommand(args);
     case "doctor": return doctorCommand(args);
+    case "full-test": return fullTestCommand(args);
     case "workspace": return workspaceCommand(args);
     case "service":
     case "autostart": return serviceCommand(args);
     case "rotate-secrets": return rotateSecretsCommand(args);
+    case "resource": return resourceCommand(args);
+    case "job": return jobCommand(args);
     case "uninstall": return uninstallCommand(args);
     default:
       console.error(`Unknown command: ${command}`);
@@ -81,10 +87,13 @@ const COMMAND_OPTIONS = {
   "client-config": new Set(["workspace", "stateDir", "profile", "client", "json"]),
   status: new Set(["workspace", "stateDir"]),
   doctor: new Set(["workspace", "stateDir"]),
+  "full-test": new Set(["workspace", "stateDir", "json"]),
   "rotate-secrets": new Set(["workspace", "stateDir", "workerName", "noPrintCredentials", "printMcpCredentials", "printCredentials", "quiet"]),
   workspace: new Set(["workspace", "stateDir"]),
   service: new Set(["workspace", "stateDir", "quiet"]),
   autostart: new Set(["workspace", "stateDir", "quiet"]),
+  resource: new Set(["workspace", "stateDir", "allowInsecurePermissions", "json"]),
+  job: new Set(["workspace", "stateDir", "json", "yes"]),
   uninstall: new Set(["stateDir", "keepWorker", "yes"]),
 };
 
@@ -118,9 +127,7 @@ function toKebab(value) {
 
 export function validatePositionals(command, args) {
   const count = args._.length;
-  const conflict = Boolean(args.workspace) && count > (command === "workspace" || command === "service" || command === "autostart" ? 1 : 0);
-  if (conflict) throw new Error("workspace path was provided both positionally and with --workspace");
-  if (["start", "stdio", "status", "doctor", "rotate-secrets"].includes(command)) {
+  if (["start", "stdio", "status", "doctor", "full-test", "rotate-secrets"].includes(command)) {
     if (count > 1) throw new Error(`${command} accepts at most one positional workspace path`);
     if (args.workspace && count) throw new Error("workspace path was provided both positionally and with --workspace");
     return;
@@ -143,6 +150,18 @@ export function validatePositionals(command, args) {
     if (count > 1) throw new Error("client-config accepts at most one positional client name");
     return;
   }
+  if (command === "resource") {
+    const action = String(args._[0] || "list");
+    const max = action === "add" || action === "generate-ssh-key" ? 3 : action === "remove" || action === "check" ? 2 : 1;
+    if (count > max) throw new Error(`resource ${action} received too many positional arguments`);
+    return;
+  }
+  if (command === "job") {
+    const action = String(args._[0] || "list");
+    const max = action === "read" || action === "inspect" || action === "cancel" || action === "approve" || action === "submit" ? 2 : 1;
+    if (count > max) throw new Error(`job ${action} received too many positional arguments`);
+    return;
+  }
   if (command === "uninstall" && count) throw new Error("uninstall does not accept positional arguments");
 }
 
@@ -336,6 +355,9 @@ async function startCommand(args) {
         workspace,
         policy: state.policy,
         logger: createLogger({ level: args.json ? "error" : effectiveLogLevel(args), component: "daemon" }),
+        jobRoot: join(state.paths.profileDir, "jobs"),
+        resources: state.resources,
+        resourceStatePath: state.paths.statePath,
         onSuperseded: () => {
           logger.warn("this daemon was replaced by a newer authenticated instance; exiting without reconnecting");
           lock.release();
@@ -439,7 +461,168 @@ async function stdioCommand(args) {
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
   const policy = resolvePolicy(args, state.policy);
-  await runStdioServer({ workspace, policy, logLevel: effectiveLogLevel(args) });
+  await runStdioServer({
+    workspace,
+    policy,
+    logLevel: effectiveLogLevel(args),
+    jobRoot: join(state.paths.profileDir, "jobs"),
+    resources: state.resources,
+    resourceStatePath: state.paths.statePath,
+  });
+}
+
+async function resourceCommand(args) {
+  const action = String(args._[0] || "list").toLowerCase();
+  const workspace = await chooseWorkspace({ ...args, _: [] }, { promptOnFirstRun: false, save: false, allowPositional: false });
+  const state = loadState(workspace, { stateDir: args.stateDir });
+  state.resources ||= {};
+
+  if (action === "list") {
+    const resources = publicResourceRegistry(state.resources);
+    if (args.json) console.log(JSON.stringify({ workspace, resources }, null, 2));
+    else if (!Object.keys(resources).length) console.log("No local resources registered.");
+    else for (const [name, value] of Object.entries(resources)) console.log(`${name}	${value.path}	${value.mode || "n/a"}	${value.size ?? "n/a"} bytes`);
+    return;
+  }
+
+  if (action === "add") {
+    const name = validateResourceName(args._[1]);
+    const inputPath = args._[2];
+    if (!inputPath) throw new Error("resource add requires NAME and FILE_PATH");
+    const lock = acquireStartupLock(state);
+    if (!lock.acquired) throw new Error("another state-changing operation is already running for this workspace");
+    try {
+      const latest = loadState(workspace, { stateDir: args.stateDir });
+      latest.resources ||= {};
+      const inspected = inspectResourceFile(expandHome(inputPath), { allowInsecurePermissions: args.allowInsecurePermissions === true });
+      if (!Object.prototype.hasOwnProperty.call(latest.resources, name) && Object.keys(latest.resources).length >= 64) {
+        throw new Error("local resource registry limit reached (64)");
+      }
+      latest.resources[name] = inspected;
+      saveState(latest);
+      const result = { name, ...inspected, contents_exposed: false, available_to_new_jobs_immediately: true };
+      if (args.json) console.log(JSON.stringify(result, null, 2));
+      else {
+        console.log(`Registered local resource: ${name}`);
+        console.log(`Path: ${inspected.path}`);
+        console.log(`Mode: ${inspected.mode || "n/a"}; size: ${inspected.size} bytes`);
+        console.log("The resource is available to newly submitted managed jobs immediately.");
+      }
+    } finally {
+      lock.release();
+    }
+    return;
+  }
+
+  if (action === "generate-ssh-key") {
+    const name = validateResourceName(args._[1]);
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home) throw new Error("HOME or USERPROFILE is required to choose a default SSH key path");
+    const requestedPath = args._[2] ? expandHome(args._[2]) : join(home, ".ssh", `machine-mcp-${name}-ed25519`);
+    const key = await generateRegisteredSshKey({
+      workspace,
+      stateDir: args.stateDir,
+      name,
+      targetPath: requestedPath,
+      comment: `machine-mcp:${name}`,
+    });
+    const result = {
+      name: key.name,
+      created: key.created,
+      private_key_path: key.privateKeyPath,
+      public_key_path: key.publicKeyPath,
+      fingerprint: key.fingerprint,
+      key_type: key.keyType,
+      private_mode: key.privateMode,
+      public_mode: key.publicMode,
+      private_key_content_exposed: key.privateKeyContentExposed,
+      registered: key.registered,
+      available_to_new_jobs_immediately: key.availableToNewJobsImmediately,
+    };
+    if (args.json) console.log(JSON.stringify(result, null, 2));
+    else {
+      console.log(`${key.created ? "Generated and registered" : "Reused and registered"} SSH key resource: ${name}`);
+      console.log(`Private key: ${key.privateKeyPath}`);
+      console.log(`Public key: ${key.publicKeyPath}`);
+      console.log(`Fingerprint: ${key.fingerprint}`);
+      console.log("Private key content was not printed or sent through MCP.");
+    }
+    return;
+  }
+
+  if (action === "remove") {
+    const name = validateResourceName(args._[1]);
+    const lock = acquireStartupLock(state);
+    if (!lock.acquired) throw new Error("another state-changing operation is already running for this workspace");
+    try {
+      const latest = loadState(workspace, { stateDir: args.stateDir });
+      latest.resources ||= {};
+      const existed = Object.prototype.hasOwnProperty.call(latest.resources, name);
+      delete latest.resources[name];
+      saveState(latest);
+      const result = { name, removed: existed, affects_new_jobs_immediately: true };
+      if (args.json) console.log(JSON.stringify(result, null, 2));
+      else {
+        console.log(existed ? `Removed local resource: ${name}` : `Local resource was not registered: ${name}`);
+        console.log("The change applies to newly submitted managed jobs immediately.");
+      }
+    } finally {
+      lock.release();
+    }
+    return;
+  }
+
+  if (action === "check") {
+    const name = validateResourceName(args._[1]);
+    const resource = state.resources[name];
+    if (!resource) throw new Error(`local resource is not registered: ${name}`);
+    const inspected = inspectResourceFile(resource.path, { allowInsecurePermissions: resource.allowInsecurePermissions === true });
+    const result = { name, ...inspected, contents_exposed: false };
+    if (args.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(`${name}: available (${inspected.mode || "n/a"}, ${inspected.size} bytes)`);
+    return;
+  }
+
+  throw new Error(`Unknown resource action: ${action}`);
+}
+
+async function jobCommand(args) {
+  const action = String(args._[0] || "list").toLowerCase();
+  const workspace = await chooseWorkspace({ ...args, _: [] }, { promptOnFirstRun: false, save: false, allowPositional: false });
+  const state = loadState(workspace, { stateDir: args.stateDir });
+  const manager = new ManagedJobManager({
+    jobRoot: join(state.paths.profileDir, "jobs"),
+    workspace,
+    policy: resolvePolicy({}, state.policy),
+    resources: state.resources,
+    resourceStatePath: state.paths.statePath,
+    logger: createLogger({ level: "warn", component: "job" }),
+  });
+  let result;
+  if (action === "list") result = manager.list({ limit: 50 });
+  else if (action === "read") result = manager.read({ job_id: args._[1] });
+  else if (action === "inspect") result = manager.inspectLocal({ job_id: args._[1] });
+  else if (action === "cancel") result = manager.cancel({ job_id: args._[1] });
+  else if (action === "approve") {
+    if (args.json && !args.yes) throw new Error("job approve --json requires --yes");
+    const inspection = manager.inspectLocal({ job_id: args._[1] });
+    if (!args.yes) {
+      console.log(JSON.stringify(inspection, null, 2));
+      const approved = await confirm(`Approve and execute managed job ${args._[1]}?`, false);
+      if (!approved) {
+        console.log("Managed job approval cancelled. Re-run with --yes after review to skip confirmation.");
+        return;
+      }
+    }
+    result = manager.approve({ job_id: args._[1] }, { localOperator: true });
+  }
+  else if (action === "submit") {
+    const planPath = args._[1];
+    if (!planPath) throw new Error("job submit requires a JSON plan file");
+    const plan = loadManagedJobPlan(expandHome(planPath));
+    result = manager.start(plan);
+  } else throw new Error(`Unknown job action: ${action}`);
+  console.log(JSON.stringify(result, null, 2));
 }
 
 async function clientConfigCommand(args) {
@@ -741,16 +924,56 @@ async function doctorCommand(args) {
   const storedPolicyOrigin = state.policy?.origin;
   state.policy = resolvePolicy({}, state.policy);
   checks.push({ name: "policy", ok: true, detail: formatPolicySummary(state.policy) });
+  if (state.policy.profile === "full") {
+    try {
+      assertCanonicalFullPolicy(state.policy);
+      checks.push({ name: "full-policy-contract", ok: true, detail: `${toolsForPolicy(state.policy).length} tools exposed` });
+    } catch (error) {
+      checks.push({ name: "full-policy-contract", ok: false, detail: sanitizeLines(error?.message || error) });
+    }
+  }
   const health = state.worker?.url ? await workerHealth(state.worker.url) : { ok: false, error: "no worker url" };
   checks.push({ name: "worker-health", ok: health.ok, detail: health.ok ? state.worker.url : health.error });
+  const diagnosticRuntime = new LocalDaemon({
+    workspace,
+    policy: state.policy,
+    logger: createLogger({ level: "error", component: "doctor" }),
+    jobRoot: join(state.paths.profileDir, "jobs"),
+    resources: state.resources,
+    resourceStatePath: state.paths.statePath,
+    recoverJobs: false,
+  });
+  let runtimeDiagnostics;
+  try {
+    runtimeDiagnostics = await diagnosticRuntime.diagnoseRuntime();
+  } finally {
+    diagnosticRuntime.stop();
+  }
+  for (const check of runtimeDiagnostics.checks) {
+    checks.push({
+      name: `runtime:${check.layer}`,
+      ok: check.skipped === true || check.ok === true,
+      detail: check.skipped ? `skipped (${check.error_class || "not applicable"})` : check.ok ? "ok" : check.error_class || "failed",
+    });
+  }
   console.log(JSON.stringify({
     ok: checks.every(check => check.ok),
     checks,
+    runtimeDiagnostics,
     policyMigrationPending: !storedPolicyOrigin && state.policy.origin === "migrated",
     state: redactState(state),
   }, null, 2));
 }
 
+async function fullTestCommand(args) {
+  const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
+  const state = loadState(workspace, { stateDir: args.stateDir });
+  const policy = resolvePolicy({}, state.policy);
+  const result = await runFullAccessTest({ workspace, policy });
+  console.log(JSON.stringify(result, null, 2));
+  if (!result.ok) process.exitCode = 1;
+}
+
 async function rotateSecretsCommand(args) {
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
@@ -847,6 +1070,12 @@ async function uninstallCommand(args) {
     console.log("Uninstall cancelled. Re-run with `machine-mcp uninstall --yes` to skip confirmation.");
     return;
   }
+  const activeJobs = activeStateJobs(stateRoot);
+  if (activeJobs.length) {
+    const detail = activeJobs.slice(0, 5).map((item) => `${item.job_id}:${item.status}`).join(", ");
+    const suffix = activeJobs.length > 5 ? `, and ${activeJobs.length - 5} more` : "";
+    throw new Error(`refusing to uninstall while managed jobs are active (${detail}${suffix}); inspect or cancel them with machine-mcp job list/cancel`);
+  }
   const autostartRemoved = await removeAutostartBestEffort(stateRoot);
   if (!autostartRemoved) throw new Error("autostart removal failed; state and Worker were kept so the uninstall can be retried safely");
   await sleep(500);
@@ -918,6 +1147,19 @@ async function removeAutostartBestEffort(stateRoot) {
   }
 }
 
+function activeStateJobs(stateRoot) {
+  const profiles = resolve(expandHome(stateRoot), "profiles");
+  if (!existsSync(profiles)) return [];
+  const active = [];
+  for (const profile of readdirSync(profiles, { withFileTypes: true })) {
+    if (!profile.isDirectory()) continue;
+    for (const job of activeManagedJobs(resolve(profiles, profile.name, "jobs"))) {
+      active.push({ profile: profile.name, ...job });
+    }
+  }
+  return active;
+}
+
 function activeStateLocks(stateRoot) {
   const profiles = resolve(expandHome(stateRoot), "profiles");
   if (!existsSync(profiles)) return [];
@@ -1003,7 +1245,10 @@ Commands:
   service uninstall Remove only the autostart entry
   status            Print redacted local profile state and Worker health
   doctor            Check Node, Wrangler, Cloudflare login, Worker health
+  full-test         Run real local full-profile capability tests in a temporary sandbox
   rotate-secrets    Rotate MCP password and daemon secret in local state
+  resource generate-ssh-key NAME [PATH]
+                    Generate/reuse an Ed25519 key locally and register its private file by alias
   uninstall         Delete known Worker(s), remove autostart and local state
 
 Start options:
@@ -1027,6 +1272,8 @@ Start options:
   --log-level LEVEL     error, warn, info (default), or debug
   --verbose             Alias for --log-level debug; includes per-tool success/correlation logs
   --quiet               Alias for --log-level error
+  --allow-insecure-permissions
+                        Permit resource registration when a file is group/other-readable
 
 Uninstall options:
   --keep-worker         Do not delete deployed Worker(s) during uninstall

package/src/local/daemon.mjs

@@ -9,8 +9,11 @@ import { applyUpdateHunks, parsePatchEnvelope } from "./patch.mjs";
 import { executionEnv, workspaceShellCommand } from "./shell.mjs";
 import { MAX_COMMAND_BYTES, ProcessSessionManager, terminateProcessTree, validateArgv } from "./process-sessions.mjs";
 export { MAX_COMMAND_BYTES } from "./process-sessions.mjs";
-import { MCP_PROTOCOL_VERSION, MCP_SUPPORTED_PROTOCOL_VERSIONS, normalizePolicy, SERVER_NAME, toolNamesForPolicy } from "./tools.mjs";
+import { allToolNames, assertCanonicalFullPolicy, isCanonicalFullPolicy, MCP_PROTOCOL_VERSION, MCP_SUPPORTED_PROTOCOL_VERSIONS, normalizePolicy, POLICY_PROFILES, SERVER_NAME, toolNamesForPolicy } from "./tools.mjs";
 import { classifyOperationalError } from "./log.mjs";
+import { ManagedJobManager } from "./managed-jobs.mjs";
+import { generateRegisteredSshKey } from "./resource-operations.mjs";
+import { expandHome } from "./state.mjs";
 
 export const MAX_WRITE_BYTES = 5 * 1024 * 1024;
 const MAX_WS_MESSAGE_BYTES = 8 * 1024 * 1024;
@@ -22,7 +25,7 @@ const MAX_IMAGE_BYTES = 4 * 1024 * 1024;
 const SLOW_TOOL_CALL_MS = 30_000;
 
 export class LocalDaemon {
-  constructor({ workerUrl = "", secret = "", workspace, policy, logger = console, onSuperseded = null }) {
+  constructor({ workerUrl = "", secret = "", workspace, policy, logger = console, onSuperseded = null, jobRoot = "", resources = {}, resourceStatePath = "", recoverJobs = true }) {
     this.workerUrl = workerUrl ? normalizeWorkerUrl(workerUrl) : "";
     if (this.workerUrl && (typeof secret !== "string" || secret.length < 16)) throw new Error("daemon secret is missing or too short");
     this.secret = secret || "";
@@ -32,6 +35,7 @@ export class LocalDaemon {
     this.policy = normalizePolicy(policy);
     this.logger = logger;
     this.onSuperseded = typeof onSuperseded === "function" ? onSuperseded : null;
+    this.resourceStatePath = resourceStatePath ? resolve(resourceStatePath) : "";
     this.closed = false;
     this.ws = null;
     this.heartbeat = null;
@@ -46,6 +50,16 @@ export class LocalDaemon {
     this.reconnectAttempt = 0;
     this.mutationQueue = Promise.resolve();
     this.runtimeDir = createRuntimeDir();
+    if (typeof jobRoot !== "string" || !jobRoot.trim()) throw new Error("persistent managed-job root is required");
+    this.managedJobManager = new ManagedJobManager({
+      jobRoot,
+      workspace: this.workspace,
+      policy: this.policy,
+      resources,
+      resourceStatePath,
+      logger: this.logger,
+      recover: recoverJobs,
+    });
     this.processSessionManager = new ProcessSessionManager({
       workspace: this.workspace,
       policy: this.policy,
@@ -74,6 +88,11 @@ export class LocalDaemon {
       workspace: this.displayPath(this.workspace),
       workspace_name: basename(this.workspace),
       policy: this.policy,
+      policy_contract: {
+        named_profile_is_canonical: this.policy.profile === "custom" || policyMatchesNamedProfile(this.policy),
+        full_catalog_complete: this.policy.profile === "full" ? isCanonicalFullPolicy(this.policy) && this.tools().length + 1 === allToolNames().length : null,
+        machine_bridge_internal_denials_under_full: this.policy.profile === "full" && isCanonicalFullPolicy(this.policy) ? false : null,
+      },
       enforcement: {
         filesystem_scope: this.policy.unrestrictedPaths ? "local-user-accessible" : "workspace",
         sensitive_filename_filter: false,
@@ -81,10 +100,17 @@ export class LocalDaemon {
         host_policy_is_independent: true,
       },
       tools: ["server_info", ...this.tools()],
+      observability: {
+        per_tool_events: "debug-only",
+        default_logs_include_tool_failures: false,
+        tool_arguments_or_results_logged: false,
+      },
       runtime: {
         environment: this.policy.minimalEnv ? "isolated-minimal" : "full-parent",
         runtime_dir: this.policy.exposeAbsolutePaths ? this.runtimeDir : "<private-runtime-dir>",
         process_sessions: this.processSessionManager.status(),
+        managed_jobs: this.managedJobManager.status(),
+        local_resources: this.managedJobManager.resourceInfo(),
       },
     };
   }
@@ -238,14 +264,12 @@ export class LocalDaemon {
       if (this.cancelledCalls.has(id)) throw new Error("tool call cancelled");
       this.send({ type: "tool_result", id, ok: true, result });
       const durationMs = Date.now() - started;
-      if (durationMs >= SLOW_TOOL_CALL_MS) this.logger.info?.("slow tool call completed", { tool, duration_ms: durationMs });
-      else this.logger.debug?.("tool call completed", { call_id: shortCallId(id), tool, duration_ms: durationMs });
+      this.logger.debug?.(durationMs >= SLOW_TOOL_CALL_MS ? "slow tool call completed" : "tool call completed", { call_id: shortCallId(id), tool, duration_ms: durationMs });
     } catch (error) {
       const safeError = this.safeErrorMessage(error);
       this.send({ type: "tool_result", id, ok: false, error: { message: safeError } });
       const durationMs = Date.now() - started;
-      this.logger.warn?.("tool call failed", { tool, duration_ms: durationMs, error_class: classifyOperationalError(error) });
-      this.logger.debug?.("tool call failure correlation", { call_id: shortCallId(id) });
+      this.logger.debug?.("tool call failed", { call_id: shortCallId(id), tool, duration_ms: durationMs, error_class: classifyOperationalError(error) });
     } finally {
       clearTimeout(deadline);
       this.activeToolCalls -= 1;
@@ -291,6 +315,14 @@ export class LocalDaemon {
       case "git_diff": return this.gitDiff(args, context);
       case "git_log": return this.gitLog(args, context);
       case "git_show": return this.gitShow(args, context);
+      case "diagnose_runtime": return this.diagnoseRuntime(context);
+      case "list_local_resources": return this.managedJobManager.listResources();
+      case "generate_ssh_key_resource": return this.generateSshKeyResource(args, context);
+      case "stage_job": return this.managedJobManager.stage(args);
+      case "start_job": return this.managedJobManager.start(args);
+      case "list_jobs": return this.managedJobManager.list(args);
+      case "read_job": return this.managedJobManager.read(args);
+      case "cancel_job": return this.managedJobManager.cancel(args);
       case "run_process": return this.runDirectProcess(args, context);
       case "start_process": return this.processSessionManager.start(args, context);
       case "read_process": return this.processSessionManager.read(args, context);
@@ -629,6 +661,117 @@ export class LocalDaemon {
     return { ok: true, target, root, pathspec: repoRelative || "" };
   }
 
+  async diagnoseRuntime(context = {}) {
+    this.throwIfCancelled(context);
+    const checks = [];
+    checks.push({
+      layer: "mcp-host-to-daemon",
+      ok: true,
+      detail: "This diagnostic request reached the local Machine Bridge runtime.",
+    });
+    checks.push({
+      layer: "machine-bridge-policy",
+      ok: this.policy.execMode === "direct" || this.policy.execMode === "shell",
+      detail: `profile=${this.policy.profile}; exec_mode=${this.policy.execMode}; unrestricted_paths=${this.policy.unrestrictedPaths}`,
+    });
+
+    const probe = join(this.runtimeDir, `.diagnostic-${process.pid}-${randomBytes(6).toString("hex")}`);
+    try {
+      await writeFile(probe, "ok\n", { mode: 0o600, flag: "wx" });
+      const { buffer } = await readBoundedFile(probe, 64, "diagnostic file");
+      checks.push({ layer: "local-filesystem", ok: buffer.toString("utf8") === "ok\n", error_class: null });
+    } catch (error) {
+      checks.push({ layer: "local-filesystem", ok: false, error_class: classifyOperationalError(error) });
+    } finally {
+      await rm(probe, { force: true }).catch(() => {});
+    }
+
+    if (this.policy.execMode === "direct" || this.policy.execMode === "shell") {
+      const direct = await this.runProcess(
+        process.execPath,
+        ["-e", "process.stdout.write('ok')"],
+        5000,
+        true,
+        1024,
+        context,
+        this.workspace,
+      ).catch((error) => ({ code: 127, stdout: "", stderr: "", error_class: classifyOperationalError(error) }));
+      checks.push({
+        layer: "local-process-spawn",
+        ok: direct.code === 0 && direct.stdout === "ok",
+        error_class: direct.error_class || (direct.code === 0 ? null : classifyOperationalError(direct.stderr || direct.stdout || "execution failed")),
+      });
+    } else {
+      checks.push({ layer: "local-process-spawn", ok: false, skipped: true, error_class: "policy_denied" });
+    }
+
+    if (this.policy.execMode === "shell") {
+      const shell = workspaceShellCommand(process.platform === "win32" ? "cd" : "pwd");
+      const result = await this.runProcess(shell.cmd, shell.args, 5000, true, 4096, context, this.workspace)
+        .catch((error) => ({ code: 127, error_class: classifyOperationalError(error) }));
+      checks.push({
+        layer: "local-shell",
+        ok: result.code === 0,
+        error_class: result.error_class || (result.code === 0 ? null : classifyOperationalError(result.stderr || result.stdout || "execution failed")),
+      });
+    } else {
+      checks.push({ layer: "local-shell", ok: false, skipped: true, error_class: "policy_denied" });
+    }
+
+    const storage = this.managedJobManager.diagnoseStorage();
+    checks.push({ layer: "managed-job-storage", ...storage });
+    const resources = this.managedJobManager.listResources();
+    checks.push({
+      layer: "local-resource-registry",
+      ok: resources.resources.every((resource) => resource.available),
+      registered: resources.count,
+      unavailable: resources.resources.filter((resource) => !resource.available).map((resource) => ({ name: resource.name, error_class: resource.error_class })),
+    });
+
+    return {
+      request_reached_local_runtime: true,
+      interpretation: {
+        tool_call_blocked_before_response: "host/platform or connector gateway",
+        diagnostic_reached_daemon_but_spawn_failed: "local OS, endpoint security, shell configuration, or Machine Bridge policy",
+        managed_job_accepted_then_later_tools_blocked: "job continues independently; inspect with local CLI or a later read_job call",
+      },
+      policy: this.policy,
+      checks,
+      ok: checks.filter((check) => !check.skipped).every((check) => check.ok),
+    };
+  }
+
+  async generateSshKeyResource(args = {}, context = {}) {
+    this.throwIfCancelled(context);
+    assertCanonicalFullPolicy(this.policy);
+    if (!this.resourceStatePath) throw new Error("local resource state is unavailable in this runtime");
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home) throw new Error("HOME or USERPROFILE is required to choose a default SSH key path");
+    const target = args.path
+      ? resolve(expandHome(String(args.path)))
+      : resolve(home, ".ssh", `machine-mcp-${args.name}-ed25519`);
+    const key = await generateRegisteredSshKey({
+      workspace: this.workspace,
+      stateDir: stateRootFromProfileStatePath(this.resourceStatePath),
+      name: args.name,
+      targetPath: target,
+      comment: args.comment || `machine-mcp:${args.name}`,
+    });
+    return {
+      name: key.name,
+      created: key.created,
+      registered: key.registered,
+      private_key_path: this.displayPath(key.privateKeyPath),
+      public_key_path: this.displayPath(key.publicKeyPath),
+      fingerprint: key.fingerprint,
+      key_type: key.keyType,
+      private_mode: key.privateMode,
+      public_mode: key.publicMode,
+      private_key_content_exposed: key.privateKeyContentExposed,
+      available_to_new_jobs_immediately: key.availableToNewJobsImmediately,
+    };
+  }
+
   async runDirectProcess(args, context = {}) {
     if (this.policy.execMode !== "direct" && this.policy.execMode !== "shell") throw new Error("run_process is disabled by daemon policy");
     const argv = validateArgv(args.argv);
@@ -831,6 +974,25 @@ export class LocalDaemon {
   }
 }
 
+function policyMatchesNamedProfile(policy) {
+  const named = POLICY_PROFILES[policy.profile];
+  if (!named) return false;
+  return policy.allowWrite === named.allowWrite
+    && policy.execMode === named.execMode
+    && policy.unrestrictedPaths === named.unrestrictedPaths
+    && policy.minimalEnv === named.minimalEnv
+    && policy.exposeAbsolutePaths === named.exposeAbsolutePaths;
+}
+
+function stateRootFromProfileStatePath(statePath) {
+  const absolute = resolve(statePath);
+  if (basename(absolute) !== "state.json") throw new Error("local resource state path is invalid");
+  const profileDir = dirname(absolute);
+  const profilesDir = dirname(profileDir);
+  if (basename(profilesDir) !== "profiles") throw new Error("local resource state path is outside the expected profile layout");
+  return dirname(profilesDir);
+}
+
 function normalizeWorkerUrl(value) {
   let url;
   try { url = new URL(String(value || "")); } catch { throw new Error("invalid Worker URL"); }