paper-mono 0.62.0

package/bin/chunks/owner-commands-MWXW2KMM.js

@@ -0,0 +1,403 @@
+import {
+  invalidPaperArgument,
+  safeArgumentForDiagnostic
+} from "./chunk-JCO37BXY.js";
+import "./chunk-ZX4GFXSY.js";
+
+// src/owner-commands.ts
+import { writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+var PAPER_MCP_URL = "http://127.0.0.1:29979/mcp";
+var PAPER_MCP_TIMEOUT_MS = 3e4;
+var PAPER_NODE_PLACEHOLDER = "replace-with-node-id";
+var PAPER_NO_SCREENSHOT_SELECTION = "No Paper node is selected. Select exactly one node in Paper or pass --node <node-id>.";
+var PAPER_AMBIGUOUS_SCREENSHOT_SELECTION = "Multiple Paper nodes are selected. Select exactly one node in Paper or pass --node <node-id>.";
+var OWNER_DESKTOP_TOOL_NAMES = Object.freeze({
+  paper_get_basic_info: "get_basic_info",
+  paper_get_selection: "get_selection",
+  paper_get_node_info: "get_node_info",
+  paper_get_children: "get_children",
+  paper_get_tree_summary: "get_tree_summary",
+  paper_get_screenshot: "get_screenshot",
+  paper_get_jsx: "get_jsx"
+});
+var SUPPORTED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp"]);
+var STRICT_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var ownerRequestId = 1;
+var READ_COMMANDS = /* @__PURE__ */ new Set(["show", "info", "selection", "tree", "node", "screenshot"]);
+var READ_COMMAND_HELP = {
+  show: "Usage: paper show [--json]\nShow basic information about the open Paper document.\n",
+  info: "Usage: paper info [--json]\nAlias for `paper show`.\n",
+  selection: "Usage: paper selection [--json]\nShow the current Paper selection.\n",
+  tree: "Usage: paper tree [--json]\nShow a bounded summary of the open document tree.\n",
+  node: "Usage: paper node <nodeId> [--children | --jsx] [--json]\nInspect one Paper node.\n",
+  screenshot: "Usage: paper screenshot --out <file> [--node <nodeId>] [--json]\nSave a node or single-selection screenshot using Paper's returned image format.\n"
+};
+function providerError(result) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return void 0;
+  const record = result;
+  if (record.isError !== true || !Array.isArray(record.content)) return void 0;
+  const text = record.content.filter(
+    (part) => Boolean(part) && typeof part === "object" && part.type === "text" && typeof part.text === "string"
+  ).map((part) => part.text).join("\n");
+  return text || "Paper MCP reported an error.";
+}
+async function callPaperOwnerMcp(toolName, args, signal, timeoutMs = PAPER_MCP_TIMEOUT_MS) {
+  const desktopToolName = OWNER_DESKTOP_TOOL_NAMES[toolName];
+  if (!desktopToolName) {
+    return {
+      ok: false,
+      error: `Unsupported deterministic Paper tool: ${toolName}`,
+      failure: "contract",
+      desktopToolName: toolName
+    };
+  }
+  const id = ownerRequestId++;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const abort = () => controller.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  let endpointReached = false;
+  try {
+    const response = await fetch(PAPER_MCP_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "tools/call",
+        params: { name: desktopToolName, arguments: args },
+        id
+      }),
+      signal: controller.signal
+    });
+    endpointReached = true;
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: `Paper MCP returned ${response.status} ${response.statusText}`,
+        failure: "contract",
+        desktopToolName
+      };
+    }
+    const body = await response.text();
+    const dataMatch = body.match(/^data: (.+)$/m);
+    const rpc = JSON.parse(dataMatch?.[1] ?? body);
+    if (rpc.jsonrpc !== "2.0" || rpc.id !== id) {
+      return {
+        ok: false,
+        error: `Paper MCP returned an invalid JSON-RPC envelope for ${desktopToolName}.`,
+        failure: "contract",
+        desktopToolName
+      };
+    }
+    if (rpc.error) {
+      return {
+        ok: false,
+        error: `Paper MCP error calling ${desktopToolName}: ${rpc.error.message ?? "unknown error"}`,
+        failure: "contract",
+        desktopToolName
+      };
+    }
+    const reportedError = providerError(rpc.result);
+    if (reportedError) {
+      return {
+        ok: false,
+        error: `Paper MCP tool ${desktopToolName} failed: ${reportedError}`,
+        failure: "contract",
+        desktopToolName
+      };
+    }
+    return { ok: true, result: rpc.result, desktopToolName };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return endpointReached ? {
+      ok: false,
+      error: `Paper MCP contract error calling ${desktopToolName}: ${message}`,
+      failure: "contract",
+      desktopToolName
+    } : {
+      ok: false,
+      error: `Paper Desktop is not running. Open a file in Paper Desktop to start the MCP server (${PAPER_MCP_URL}).`,
+      failure: "unreachable",
+      desktopToolName
+    };
+  } finally {
+    clearTimeout(timeout);
+    signal?.removeEventListener("abort", abort);
+  }
+}
+function assertPaperResult(toolName, result) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    throw new TypeError(`Paper ${toolName} returned an invalid result envelope.`);
+  }
+  const record = result;
+  if (!Array.isArray(record.content) || record.content.length === 0) {
+    throw new TypeError(`Paper ${toolName} returned invalid or empty content.`);
+  }
+  for (const item of record.content) {
+    if (!item || typeof item !== "object") {
+      throw new TypeError(`Paper ${toolName} returned a malformed content part.`);
+    }
+    const entry = item;
+    if (entry.type === "text" && typeof entry.text === "string") continue;
+    if (entry.type === "image" && typeof entry.data === "string" && typeof entry.mimeType === "string" && SUPPORTED_IMAGE_MIME_TYPES.has(entry.mimeType)) {
+      continue;
+    }
+    throw new TypeError(`Paper ${toolName} returned an unsupported content part.`);
+  }
+}
+function paperContentParts(result) {
+  if (!result || typeof result !== "object") return [];
+  const content = result.content;
+  if (!Array.isArray(content)) return [];
+  const parts = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") continue;
+    const entry = item;
+    if (entry.type === "text" && typeof entry.text === "string") {
+      parts.push({ type: "text", text: entry.text });
+      continue;
+    }
+    if (entry.type === "image" && typeof entry.data === "string" && typeof entry.mimeType === "string") {
+      parts.push({
+        type: "image",
+        data: entry.data,
+        mimeType: entry.mimeType
+      });
+    }
+  }
+  return parts;
+}
+function paperText(result) {
+  const text = paperContentParts(result).filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  return text || JSON.stringify(result, null, 2);
+}
+function selectedNodeIds(result) {
+  let selection;
+  try {
+    selection = JSON.parse(paperText(result));
+  } catch {
+    throw new TypeError("Paper get_selection returned invalid JSON for screenshot targeting.");
+  }
+  if (!selection || typeof selection !== "object" || Array.isArray(selection)) {
+    throw new TypeError("Paper get_selection returned an invalid screenshot-selection payload.");
+  }
+  const nodes = selection.selectedNodes;
+  if (!Array.isArray(nodes)) {
+    throw new TypeError("Paper get_selection returned no selectedNodes array for screenshot targeting.");
+  }
+  return nodes.map((node) => {
+    const nodeId = typeof node === "string" ? node : node && typeof node === "object" && !Array.isArray(node) ? node.id ?? node.nodeId : void 0;
+    if (typeof nodeId !== "string" || !nodeId.trim()) {
+      throw new TypeError("Paper get_selection returned a selected node without a valid ID.");
+    }
+    return nodeId;
+  });
+}
+function stripJsonFlag(args) {
+  let json = false;
+  const remaining = [];
+  for (const arg of args) {
+    if (arg !== "--json") {
+      remaining.push(arg);
+      continue;
+    }
+    if (json) throw new TypeError("--json may be provided only once.");
+    json = true;
+  }
+  return { args: remaining, json };
+}
+function assertNoArguments(command, args) {
+  if (args.length > 0) {
+    invalidPaperArgument(`${command} does not accept '${safeArgumentForDiagnostic(args[0] ?? "")}'.`);
+  }
+}
+function parseNodeArgs(args) {
+  let nodeId;
+  let children = false;
+  let jsx = false;
+  for (const arg of args) {
+    if (arg === "--children") {
+      if (children) throw new TypeError("--children may be provided only once.");
+      children = true;
+      continue;
+    }
+    if (arg === "--jsx") {
+      if (jsx) throw new TypeError("--jsx may be provided only once.");
+      jsx = true;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      invalidPaperArgument(`node does not accept '${safeArgumentForDiagnostic(arg)}'.`);
+    }
+    if (nodeId) throw new TypeError("node accepts exactly one <nodeId>.");
+    nodeId = arg;
+  }
+  if (!nodeId) throw new TypeError("node requires a <nodeId> (see `paper tree`).");
+  if (nodeId === PAPER_NODE_PLACEHOLDER) {
+    throw new TypeError("Replace 'replace-with-node-id' with a real Paper node ID before running this command.");
+  }
+  if (children && jsx) throw new TypeError("--children and --jsx are mutually exclusive.");
+  return {
+    nodeId,
+    toolName: jsx ? "paper_get_jsx" : children ? "paper_get_children" : "paper_get_node_info"
+  };
+}
+function parseScreenshotArgs(args) {
+  let out;
+  let nodeId;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    const [flag, inlineValue] = arg.includes("=") ? arg.split(/=(.*)/s, 2) : [arg, void 0];
+    if (flag !== "--out" && flag !== "--node") {
+      invalidPaperArgument(`screenshot does not accept '${safeArgumentForDiagnostic(arg)}'.`);
+    }
+    const value = inlineValue ?? args[index + 1];
+    if (!inlineValue) index += 1;
+    if (!value || value.startsWith("--")) throw new TypeError(`${flag} requires a value.`);
+    if (flag === "--out") {
+      if (out) throw new TypeError("--out may be provided only once.");
+      out = value;
+    } else {
+      if (nodeId) throw new TypeError("--node may be provided only once.");
+      nodeId = value;
+    }
+  }
+  if (!out) throw new TypeError("screenshot requires --out <file>.");
+  if (nodeId === PAPER_NODE_PLACEHOLDER) {
+    throw new TypeError("Replace 'replace-with-node-id' with a real Paper node ID before running this command.");
+  }
+  return { out: resolve(out), ...nodeId ? { nodeId } : {} };
+}
+function screenshotOutputPath(requestedOut, mimeType) {
+  const expectedExtension = mimeType === "image/png" ? ".png" : mimeType === "image/jpeg" ? ".jpg" : mimeType === "image/webp" ? ".webp" : void 0;
+  if (!expectedExtension) throw new TypeError(`Paper returned unsupported screenshot type ${mimeType}.`);
+  const providedExtension = extname(requestedOut).toLowerCase();
+  if (!providedExtension) return `${requestedOut}${expectedExtension}`;
+  const acceptedExtensions = expectedExtension === ".jpg" ? /* @__PURE__ */ new Set([".jpg", ".jpeg"]) : /* @__PURE__ */ new Set([expectedExtension]);
+  if (acceptedExtensions.has(providedExtension)) return requestedOut;
+  const suggested = join(dirname(requestedOut), `${basename(requestedOut, providedExtension)}${expectedExtension}`);
+  throw new TypeError(
+    `Paper returned ${mimeType}, but --out uses '${providedExtension}'. No file was written; retry with --out ${suggested}.`
+  );
+}
+function verifiedImageBytes(image) {
+  if (!image.data || image.data.length % 4 !== 0 || !STRICT_BASE64.test(image.data)) {
+    throw new TypeError("Paper returned malformed screenshot base64; no file was written.");
+  }
+  const bytes = Buffer.from(image.data, "base64");
+  if (bytes.toString("base64") !== image.data) {
+    throw new TypeError("Paper returned non-canonical screenshot base64; no file was written.");
+  }
+  const actualMimeType = bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) ? "image/png" : bytes.length >= 5 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 && bytes.at(-2) === 255 && bytes.at(-1) === 217 ? "image/jpeg" : bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP" ? "image/webp" : void 0;
+  if (!actualMimeType)
+    throw new TypeError("Paper returned bytes that are not a supported screenshot image; no file was written.");
+  if (actualMimeType !== image.mimeType) {
+    throw new TypeError(
+      `Paper labeled screenshot bytes as ${image.mimeType}, but they are ${actualMimeType}; no file was written.`
+    );
+  }
+  return bytes;
+}
+async function requirePaperResult(callTool, toolName, args) {
+  const response = await callTool(toolName, args);
+  if (!response.ok) throw new TypeError(response.error);
+  assertPaperResult(toolName, response.result);
+  return response.result;
+}
+function writeReadResult(result, json, writeOutput) {
+  writeOutput(json ? `${JSON.stringify({ result }, null, 2)}
+` : `${paperText(result)}
+`);
+}
+async function handleOwnerReadCommand(argv, io = {}) {
+  const command = argv[0];
+  if (!command || !READ_COMMANDS.has(command)) return false;
+  const callTool = io.callTool ?? callPaperOwnerMcp;
+  const writeOutput = io.writeOutput ?? ((value) => process.stdout.write(value));
+  const writeScreenshot = io.writeScreenshot ?? (async (path, data) => writeFile(path, data, { flag: "wx" }));
+  const helpArgs = argv.slice(1).filter((arg) => arg === "--help" || arg === "-h");
+  if (helpArgs.length > 0) {
+    if (argv.length !== 2 || helpArgs.length !== 1) {
+      throw new TypeError(`${command} help does not accept other arguments.`);
+    }
+    writeOutput(READ_COMMAND_HELP[command] ?? "");
+    return true;
+  }
+  const parsed = stripJsonFlag(argv.slice(1));
+  if (command === "show" || command === "info") {
+    assertNoArguments(command, parsed.args);
+    writeReadResult(await requirePaperResult(callTool, "paper_get_basic_info", {}), parsed.json, writeOutput);
+    return true;
+  }
+  if (command === "selection") {
+    assertNoArguments(command, parsed.args);
+    writeReadResult(await requirePaperResult(callTool, "paper_get_selection", {}), parsed.json, writeOutput);
+    return true;
+  }
+  if (command === "tree") {
+    assertNoArguments(command, parsed.args);
+    const basicInfo = await requirePaperResult(callTool, "paper_get_basic_info", {});
+    let rootNodeId;
+    try {
+      rootNodeId = JSON.parse(paperText(basicInfo)).rootNodeId;
+    } catch {
+      throw new TypeError("Paper get_basic_info returned invalid JSON for the tree summary.");
+    }
+    if (typeof rootNodeId !== "string" || !rootNodeId.trim()) {
+      throw new TypeError("Paper get_basic_info returned no rootNodeId for the tree summary.");
+    }
+    const result2 = await requirePaperResult(callTool, "paper_get_tree_summary", { nodeId: rootNodeId });
+    writeReadResult(result2, parsed.json, writeOutput);
+    return true;
+  }
+  if (command === "node") {
+    const node = parseNodeArgs(parsed.args);
+    const result2 = await requirePaperResult(callTool, node.toolName, { nodeId: node.nodeId });
+    writeReadResult(result2, parsed.json, writeOutput);
+    return true;
+  }
+  const screenshot = parseScreenshotArgs(parsed.args);
+  let screenshotNodeId = screenshot.nodeId;
+  if (!screenshotNodeId) {
+    const selection = await requirePaperResult(callTool, "paper_get_selection", {});
+    const nodeIds = selectedNodeIds(selection);
+    if (nodeIds.length === 0) throw new TypeError(PAPER_NO_SCREENSHOT_SELECTION);
+    if (nodeIds.length !== 1) throw new TypeError(PAPER_AMBIGUOUS_SCREENSHOT_SELECTION);
+    screenshotNodeId = nodeIds[0];
+  }
+  const result = await requirePaperResult(callTool, "paper_get_screenshot", { nodeId: screenshotNodeId });
+  const images = paperContentParts(result).filter(
+    (part) => part.type === "image"
+  );
+  if (images.length === 0) {
+    throw new TypeError(`Paper returned no screenshot image: ${paperText(result).slice(0, 200)}`);
+  }
+  if (images.length !== 1) {
+    throw new TypeError(
+      "Paper returned an ambiguous screenshot response; expected exactly one image and wrote no file."
+    );
+  }
+  const image = images[0];
+  const imageBytes = verifiedImageBytes(image);
+  const outputPath = screenshotOutputPath(screenshot.out, image.mimeType);
+  try {
+    await writeScreenshot(outputPath, imageBytes);
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+    if (code === "EEXIST") {
+      throw new TypeError(`Screenshot output already exists; no file was overwritten: ${outputPath}`);
+    }
+    throw error;
+  }
+  writeOutput(
+    parsed.json ? `${JSON.stringify({ out: outputPath, mimeType: image.mimeType }, null, 2)}
+` : `${image.mimeType} -> ${outputPath}
+`
+  );
+  return true;
+}
+export {
+  handleOwnerReadCommand
+};

package/bin/chunks/tool-contract-ZWFZSYL4.js

@@ -0,0 +1,32 @@
+import {
+  PAPER_DOMAIN_TOOL_NAMES,
+  PAPER_TOOL_CONTRACT_HASH,
+  PAPER_TOOL_CONTRACT_PATH,
+  PAPER_TOOL_SCHEMA_HASHES,
+  assertPaperContractFixturesExist,
+  assertPaperToolContractHandshake,
+  extractPaperPromptToolIds,
+  paperDomainToolIdsFromActive,
+  paperLoadedToolContract,
+  paperToolContract,
+  renderPaperToolInventoryXml,
+  resolvePaperAgentHome,
+  resolvePaperContractRef
+} from "./chunk-UHVY2TIH.js";
+import "./chunk-BGKLQ5Y6.js";
+import "./chunk-ZX4GFXSY.js";
+export {
+  PAPER_DOMAIN_TOOL_NAMES,
+  PAPER_TOOL_CONTRACT_HASH,
+  PAPER_TOOL_CONTRACT_PATH,
+  PAPER_TOOL_SCHEMA_HASHES,
+  assertPaperContractFixturesExist,
+  assertPaperToolContractHandshake,
+  extractPaperPromptToolIds,
+  paperDomainToolIdsFromActive,
+  paperLoadedToolContract,
+  paperToolContract,
+  renderPaperToolInventoryXml,
+  resolvePaperAgentHome,
+  resolvePaperContractRef
+};

package/bin/paper.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+import {
+  PAPER_BRIEF_APPROVAL_PREFIX,
+  PAPER_IMPLEMENTATION_BRIEF_SCHEMA_VERSION,
+  PAPER_TOOL_IDS,
+  PAPER_TOOL_SAFETY_CLASSIFICATIONS,
+  STANDARD_TOOL_IDS,
+  printHelp,
+  resolvePaperWorkflowMode
+} from "./chunks/chunk-I4P43IZS.js";
+import {
+  APP_NAME,
+  BUNDLED_PACKAGE_VERSIONS,
+  IDENTITY_DOMAIN,
+  PACKAGE_DISTRIBUTION,
+  VERSION,
+  applyPaperPrivacyDefaults,
+  getAgentDir
+} from "./chunks/chunk-BGKLQ5Y6.js";
+import {
+  invalidPaperArgument,
+  safeArgumentForDiagnostic
+} from "./chunks/chunk-JCO37BXY.js";
+import "./chunks/chunk-ZX4GFXSY.js";
+
+// src/owner-cli.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var STANDARD_LOCKED_TOOL_IDS = /* @__PURE__ */ new Set(["read", "grep", "find", "ls"]);
+var OWNER_READ_COMMANDS = /* @__PURE__ */ new Set(["show", "info", "selection", "tree", "node", "screenshot"]);
+function resolveModulePath(specifier) {
+  return fileURLToPath(import.meta.resolve(specifier));
+}
+function readDependencyVersion(specifier) {
+  let current = dirname(resolveModulePath(specifier));
+  for (let depth = 0; depth < 10; depth += 1) {
+    const manifestPath = join(current, "package.json");
+    if (existsSync(manifestPath)) {
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+      if (manifest.name === specifier) return manifest.version ?? "unknown";
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "unknown";
+}
+function resolveReportedModule(specifier, bundlePath, packageLoadErrors) {
+  if (PACKAGE_DISTRIBUTION === "public-bundle") return bundlePath;
+  try {
+    return resolveModulePath(specifier);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    packageLoadErrors.push(`${specifier}: ${message}`);
+    return "unresolved";
+  }
+}
+function readReportedVersion(specifier, packageLoadErrors) {
+  if (PACKAGE_DISTRIBUTION !== "public-bundle") return readDependencyVersion(specifier);
+  const version = BUNDLED_PACKAGE_VERSIONS[specifier];
+  if (version) return version;
+  packageLoadErrors.push(`${specifier}: missing bundled package version`);
+  return "unknown";
+}
+async function createAboutJson(options = {}) {
+  const {
+    PAPER_TOOL_CONTRACT_HASH,
+    PAPER_TOOL_CONTRACT_PATH,
+    PAPER_TOOL_SCHEMA_HASHES,
+    paperToolContract,
+    resolvePaperAgentHome
+  } = await import("./chunks/tool-contract-ZWFZSYL4.js");
+  const packageLoadErrors = [];
+  const paperEntry = fileURLToPath(import.meta.url);
+  const monoForkRuntime = resolveReportedModule("@creative-int/mono/fork-runtime", paperEntry, packageLoadErrors);
+  const piCodingRuntime = resolveReportedModule("@creative-int/pi-coding-runtime", paperEntry, packageLoadErrors);
+  const registeredToolIds = paperToolContract.tools.map((tool) => tool.id);
+  if (registeredToolIds.join("\n") !== PAPER_TOOL_IDS.join("\n")) {
+    packageLoadErrors.push("workflow contract tool order does not match tools.contract.json");
+  }
+  const approvedCapabilityToolIds = [...STANDARD_TOOL_IDS, ...registeredToolIds];
+  const defaultLockedToolIds = approvedCapabilityToolIds.filter(
+    (toolName) => STANDARD_LOCKED_TOOL_IDS.has(toolName) || PAPER_TOOL_SAFETY_CLASSIFICATIONS[toolName] === "read-only" || PAPER_TOOL_SAFETY_CLASSIFICATIONS[toolName] === "dry-run-or-live-mutation"
+  );
+  const runtimeVersions = {
+    node: process.version,
+    paperMono: VERSION,
+    mono: readReportedVersion("@creative-int/mono", packageLoadErrors),
+    piCodingRuntime: readReportedVersion("@creative-int/pi-coding-runtime", packageLoadErrors)
+  };
+  return {
+    name: APP_NAME,
+    specialist: paperToolContract.specialist,
+    ownerCommand: paperToolContract.ownerCommand,
+    domain: IDENTITY_DOMAIN,
+    version: VERSION,
+    distribution: PACKAGE_DISTRIBUTION,
+    runtime: "@creative-int/mono/fork-runtime",
+    resolvedBinary: process.argv[1] ?? "paper",
+    agentHome: resolvePaperAgentHome(getAgentDir()),
+    contractPath: PAPER_TOOL_CONTRACT_PATH,
+    contractHash: PAPER_TOOL_CONTRACT_HASH,
+    toolSchemaHashes: PAPER_TOOL_SCHEMA_HASHES,
+    registeredToolIds,
+    promptToolIds: registeredToolIds,
+    defaultLockedToolIds,
+    approvedCapabilityToolIds,
+    bundledPackages: BUNDLED_PACKAGE_VERSIONS,
+    packageLoadErrors,
+    loadedModules: { paperEntry, monoForkRuntime, piCodingRuntime },
+    moduleProvenance: {
+      paperEntry: { kind: "resolved", path: paperEntry },
+      monoForkRuntime: {
+        kind: PACKAGE_DISTRIBUTION === "public-bundle" ? "bundled" : "resolved",
+        path: monoForkRuntime
+      },
+      piCodingRuntime: {
+        kind: PACKAGE_DISTRIBUTION === "public-bundle" ? "bundled" : "resolved",
+        path: piCodingRuntime
+      }
+    },
+    runtimeVersions,
+    briefGate: {
+      schemaVersion: PAPER_IMPLEMENTATION_BRIEF_SCHEMA_VERSION,
+      approvalPhrase: `${PAPER_BRIEF_APPROVAL_PREFIX} <brief-id>`,
+      mutationLockedByDefault: true,
+      workflowModes: ["reference-to-code", "audit-only", "copilot"],
+      selectedWorkflow: options.selectedWorkflow ?? "reference-to-code",
+      sessionAction: options.sessionAction ?? "new"
+    },
+    privacy: {
+      productTelemetry: false,
+      automaticVersionChecks: false,
+      productBackend: false
+    }
+  };
+}
+function specialistAboutOptions(args) {
+  let auditOnly = false;
+  let copilot = false;
+  let sessionAction = "new";
+  for (const arg of args) {
+    if (arg === "--about-json") continue;
+    if (arg === "--audit-only") {
+      auditOnly = true;
+      continue;
+    }
+    if (arg === "--copilot") {
+      copilot = true;
+      continue;
+    }
+    if (arg === "--continue" || arg === "-c") {
+      if (sessionAction !== "new") invalidPaperArgument("--continue and --resume are mutually exclusive.");
+      sessionAction = "continue";
+      continue;
+    }
+    if (arg === "--resume" || arg === "-r") {
+      if (sessionAction !== "new") invalidPaperArgument("--continue and --resume are mutually exclusive.");
+      sessionAction = "resume";
+      continue;
+    }
+    invalidPaperArgument(`--about-json does not accept '${safeArgumentForDiagnostic(arg)}'.`);
+  }
+  if (auditOnly && copilot) {
+    invalidPaperArgument("--audit-only and --copilot are mutually exclusive Paper workflow modes.");
+  }
+  return { selectedWorkflow: resolvePaperWorkflowMode(auditOnly, copilot), sessionAction };
+}
+function printDoctorHelp() {
+  process.stdout.write(
+    "Usage: paper doctor [--json]\nCheck the 27-tool contract and live Paper Desktop reachability.\n"
+  );
+}
+function assertOnly(args, accepted, command) {
+  if (args.length !== accepted.length || args.some((arg, index) => arg !== accepted[index])) {
+    const rejected = args.find((arg, index) => arg !== accepted[index]) ?? "extra arguments";
+    invalidPaperArgument(`${command} does not accept '${safeArgumentForDiagnostic(rejected)}'.`);
+  }
+}
+function argumentsBeforeOptionTerminator(args) {
+  const terminator = args.indexOf("--");
+  return terminator < 0 ? args : args.slice(0, terminator);
+}
+async function runSpecialist(args) {
+  const [{ EnvHttpProxyAgent, setGlobalDispatcher }, { main: runSpecialistMain }] = await Promise.all([
+    import("undici"),
+    import("./chunks/main-NQIGPQXK.js")
+  ]);
+  setGlobalDispatcher(new EnvHttpProxyAgent());
+  await runSpecialistMain(args);
+}
+async function main(args) {
+  applyPaperPrivacyDefaults();
+  const isMonoRoute = args[0] === "mono";
+  const normalizedArgs = isMonoRoute ? args.slice(1) : [...args];
+  if (normalizedArgs[0] === "help") normalizedArgs[0] = "--help";
+  const optionArgs = argumentsBeforeOptionTerminator(normalizedArgs);
+  if (normalizedArgs[0] === "--help" || normalizedArgs[0] === "-h") {
+    assertOnly(normalizedArgs, [normalizedArgs[0] ?? "--help"], "help");
+    printHelp();
+    return;
+  }
+  if (optionArgs.includes("--about-json")) {
+    let aboutOptions = {};
+    if (isMonoRoute) aboutOptions = specialistAboutOptions(normalizedArgs);
+    else assertOnly(normalizedArgs, ["--about-json"], "--about-json");
+    process.stdout.write(`${JSON.stringify(await createAboutJson(aboutOptions))}
+`);
+    return;
+  }
+  const versionArgument = optionArgs.find((arg) => arg === "--version" || arg === "-v");
+  if (versionArgument) {
+    assertOnly(normalizedArgs, [versionArgument], "--version");
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  if (normalizedArgs[0] === "doctor") {
+    if (normalizedArgs[1] === "--help" || normalizedArgs[1] === "-h") {
+      assertOnly(normalizedArgs, ["doctor", normalizedArgs[1]], "doctor");
+      printDoctorHelp();
+      return;
+    }
+    if (normalizedArgs.length > 2 || normalizedArgs[1] !== void 0 && normalizedArgs[1] !== "--json") {
+      const rejected = normalizedArgs[1] ?? normalizedArgs[2] ?? "extra arguments";
+      invalidPaperArgument(`doctor does not accept '${safeArgumentForDiagnostic(rejected)}'.`);
+    }
+    const { createPaperToolDoctorReport, paperDoctorExitCode, renderPaperToolDoctorReport } = await import("./chunks/doctor-7DE4ASQO.js");
+    const report = await createPaperToolDoctorReport();
+    process.stdout.write(
+      normalizedArgs[1] === "--json" ? `${JSON.stringify(report, null, 2)}
+` : renderPaperToolDoctorReport(report)
+    );
+    process.exitCode = paperDoctorExitCode(report);
+    return;
+  }
+  if (!isMonoRoute && OWNER_READ_COMMANDS.has(normalizedArgs[0] ?? "")) {
+    const { handleOwnerReadCommand } = await import("./chunks/owner-commands-MWXW2KMM.js");
+    if (await handleOwnerReadCommand(normalizedArgs)) return;
+  }
+  if (normalizedArgs[0] === "page") {
+    throw new TypeError(
+      "Direct page control is disabled. Start `paper mono --copilot`, inspect the target, approve its exact brief, and use the gated Paper page tools."
+    );
+  }
+  await runSpecialist(normalizedArgs);
+}
+
+// src/public-cli.ts
+process.title = "paper";
+process.title = APP_NAME;
+void main(process.argv.slice(2)).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`paper: ${message}
+`);
+  process.exitCode = 1;
+});