@outerlayer/cli 0.1.0

package/dist/mcp-install-cmd-FDQH6SEN.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { C } from './chunk-YRYMNBGQ.js';
+import { readCloudConfig } from './chunk-TFUIDMOB.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var McpInstallError = class extends Error {
+};
+function defaultMcpUrl(home) {
+  const origin = readCloudConfig(home).url;
+  if (!origin) {
+    throw new McpInstallError(
+      "no gateway URL: pass --url <your gateway>, or run `outerlayer login --url <your gateway>` first."
+    );
+  }
+  return `${origin.replace(/\/+$/, "")}/v1/mcp`;
+}
+var API_KEY_ENV_PLACEHOLDER = "${OUTERLAYER_API_KEY}";
+var DEFAULT_MCP_TRANSPORT = "stdio";
+var DEFAULT_MCP_COMMAND = "outerlayer";
+function buildServerEntry(url, appId) {
+  const headers = { Authorization: `Bearer ${API_KEY_ENV_PLACEHOLDER}` };
+  if (appId) headers["X-Outerlayer-App-Id"] = appId;
+  return { type: "http", url, headers };
+}
+function buildStdioServerEntry(command, url, appId) {
+  const args = ["mcp", "serve"];
+  if (url) args.push("--url", url);
+  if (appId) args.push("--app-id", appId);
+  return { type: "stdio", command, args };
+}
+function runMcpInstall(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (!existsSync(cwd)) throw new McpInstallError(`no such directory: ${cwd}`);
+  const name = opts.name ?? "outerlayer";
+  const transport = opts.transport ?? DEFAULT_MCP_TRANSPORT;
+  const url = transport === "http" ? opts.url ?? defaultMcpUrl(opts.home) : opts.url ?? null;
+  const relPath = ".mcp.json";
+  const absPath = join(cwd, relPath);
+  let doc = {};
+  if (existsSync(absPath)) {
+    try {
+      doc = JSON.parse(readFileSync(absPath, "utf8"));
+    } catch {
+      throw new McpInstallError(`${relPath} exists and is not valid JSON \u2014 fix or remove it before running "mcp install"`);
+    }
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+      throw new McpInstallError(`${relPath} exists and its top level is not a JSON object \u2014 refusing to overwrite`);
+    }
+  }
+  const existingServers = doc.mcpServers && typeof doc.mcpServers === "object" && !Array.isArray(doc.mcpServers) ? doc.mcpServers : {};
+  const entry = transport === "http" ? buildServerEntry(url, opts.appId) : buildStdioServerEntry(opts.command ?? DEFAULT_MCP_COMMAND, url ?? void 0, opts.appId);
+  const changed = JSON.stringify(existingServers[name] ?? null) !== JSON.stringify(entry);
+  const next = { ...doc, mcpServers: { ...existingServers, [name]: entry } };
+  writeFileSync(absPath, `${JSON.stringify(next, null, 2)}
+`);
+  const where = transport === "http" ? `${url}` : `stdio: ${opts.command ?? DEFAULT_MCP_COMMAND} mcp serve`;
+  const keyNote = transport === "http" ? `Set OUTERLAYER_API_KEY in your environment \u2014 the key is referenced as ${API_KEY_ENV_PLACEHOLDER}, never written to this file.` : "The key is read from ~/.outerlayer/config.json (or OUTERLAYER_API_KEY) each time the client connects \u2014 never written to this file.";
+  const output = opts.json ? JSON.stringify({ path: relPath, server: name, transport, url, changed }) : changed ? `${C.green}\u2713${C.reset} Wrote "${name}" MCP server (${where}) to ${relPath}
+${C.dim}  ${keyNote}${C.reset}` : `${C.dim}"${name}" MCP server already configured in ${relPath} (no change)${C.reset}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { path: relPath, server: name, transport, url, changed, output };
+}
+function handleMcpInstallError(err) {
+  if (!(err instanceof McpInstallError)) throw err;
+  process.stderr.write(`${C.red}\u2717${C.reset} ${err.message}
+`);
+  process.exitCode = 1;
+}
+
+export { DEFAULT_MCP_COMMAND, McpInstallError, buildServerEntry, buildStdioServerEntry, defaultMcpUrl, handleMcpInstallError, runMcpInstall };

package/dist/mcp-serve-cmd-57EZZOTL.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { C } from './chunk-YRYMNBGQ.js';
+import { readCloudConfig, cloudConfigPath } from './chunk-TFUIDMOB.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { createInterface } from 'readline';
+
+createRequire(import.meta.url);
+var McpServeConfigError = class extends Error {
+};
+var JSON_RPC_PARSE_ERROR = -32700;
+var JSON_RPC_GATEWAY_ERROR = -32e3;
+function mcpEndpointFromOrigin(origin) {
+  return `${origin.replace(/\/+$/, "")}/v1/mcp`;
+}
+function resolveMcpServeTarget(opts = {}) {
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homeFromEnv(env);
+  const config = readCloudConfig(home);
+  const apiKey = env.OUTERLAYER_API_KEY || config.apiKey;
+  if (!apiKey) {
+    throw new McpServeConfigError(
+      `no API key: set OUTERLAYER_API_KEY or save "apiKey" to ${cloudConfigPath(home)} (run "outerlayer sync" once with --api-key, or mint a key in the dashboard: Settings \u2192 API keys).`
+    );
+  }
+  const origin = env.OUTERLAYER_URL || config.url;
+  if (!opts.url && !origin) {
+    throw new McpServeConfigError(
+      `no gateway URL: set OUTERLAYER_URL or save "url" to ${cloudConfigPath(home)} (run \`outerlayer login --url <your gateway>\`), or pass --url.`
+    );
+  }
+  const url = opts.url ?? mcpEndpointFromOrigin(origin);
+  const appId = opts.appId ?? env.OUTERLAYER_APP_ID ?? config.appId;
+  const headers = { Authorization: `Bearer ${apiKey}` };
+  if (appId) headers["X-Outerlayer-App-Id"] = appId;
+  return { url, headers };
+}
+function errorResponse(id, code, message) {
+  return JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+}
+function isNotification(message) {
+  return typeof message === "object" && message !== null && !Array.isArray(message) && !Object.hasOwn(message, "id");
+}
+function requestId(message) {
+  if (typeof message !== "object" || message === null || Array.isArray(message)) return null;
+  const id = message.id;
+  return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function gatewayErrorMessage(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const error = body.error;
+  if (typeof error === "object" && error !== null && typeof error.message === "string") {
+    return error.message;
+  }
+  return null;
+}
+async function bridgeMessage(line, opts) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return errorResponse(null, JSON_RPC_PARSE_ERROR, "Request body is not valid JSON.");
+  }
+  const notification = isNotification(message);
+  const id = requestId(message);
+  const doFetch = opts.fetch ?? fetch;
+  let status;
+  let text;
+  try {
+    const response = await doFetch(opts.target.url, {
+      method: "POST",
+      headers: { ...opts.target.headers, "Content-Type": "application/json", Accept: "application/json" },
+      // Forward the client's own bytes: re-serializing could reorder keys
+      // or drop values the gateway's schema cares about.
+      body: line
+    });
+    status = response.status;
+    text = await response.text();
+  } catch (err) {
+    if (notification) return null;
+    const reason = err instanceof Error ? err.message : String(err);
+    return errorResponse(id, JSON_RPC_GATEWAY_ERROR, `OuterLayer gateway unreachable at ${opts.target.url}: ${reason}`);
+  }
+  if (notification || status === 202 || text.trim() === "") return null;
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = void 0;
+  }
+  if (typeof body === "object" && body !== null && body.jsonrpc === "2.0") {
+    return JSON.stringify(body);
+  }
+  const detail = gatewayErrorMessage(body) ?? text.slice(0, 200);
+  const hint = status === 401 ? ` \u2014 check the API key in ${cloudConfigPath(opts.home ?? homeFromEnv())} (or OUTERLAYER_API_KEY)` : "";
+  return errorResponse(id, JSON_RPC_GATEWAY_ERROR, `OuterLayer gateway returned HTTP ${status}: ${detail}${hint}`);
+}
+async function runMcpServe(opts = {}) {
+  const target = resolveMcpServeTarget(opts);
+  const stdin = opts.stdin ?? process.stdin;
+  const stdout = opts.stdout ?? process.stdout;
+  const inFlight = /* @__PURE__ */ new Set();
+  const lines = createInterface({ input: stdin, crlfDelay: Infinity });
+  for await (const raw of lines) {
+    const line = raw.trim();
+    if (line === "") continue;
+    const task = bridgeMessage(line, { target, fetch: opts.fetch, home: opts.home }).then((out) => {
+      if (out !== null) stdout.write(out + "\n");
+    });
+    inFlight.add(task);
+    void task.finally(() => inFlight.delete(task));
+  }
+  await Promise.all(inFlight);
+}
+function handleMcpServeError(err) {
+  if (!(err instanceof McpServeConfigError)) throw err;
+  process.stderr.write(`${C.red}\u2717${C.reset} ${err.message}
+`);
+  process.exitCode = 1;
+}
+
+export { McpServeConfigError, bridgeMessage, handleMcpServeError, mcpEndpointFromOrigin, resolveMcpServeTarget, runMcpServe };

package/dist/paths-D2VGWWFI.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { RUNNER_DIR_MODE, RUNNER_FILE_MODE, attemptStamp, jobDir, jobsDir, pidFilePath, runnerDir } from './chunk-JJP7YLMN.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/pidfile-PTW76F56.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { RunnerAlreadyRunningError, claimPidFile, readPidFile, releasePidFile } from './chunk-D77LS3UI.js';
+import './chunk-OZ7C3XUE.js';
+import './chunk-JJP7YLMN.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/status-WGOJTXZF.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { formatDuration, formatClock, relativeToRunner, LEASE_SECONDS, RENEW_INTERVAL_SECONDS } from './chunk-4H56Y7O6.js';
+import './chunk-OZ7C3XUE.js';
+import { runnerDir, jobsDir } from './chunk-JJP7YLMN.js';
+import './chunk-VU34RWDU.js';
+import './chunk-DEDV5V4U.js';
+import './chunk-YRYMNBGQ.js';
+import './chunk-RCQXYLMO.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-A6NNKRJU.js';
+import './chunk-IWIUYLDR.js';
+import './chunk-YMTXR7PJ.js';
+import './chunk-ECSYRPCC.js';
+import './chunk-TFUIDMOB.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var JOB_DIR_WIDTH = 34;
+function truncate(text, width) {
+  return text.length <= width ? text : `${text.slice(0, width - 1)}\u2026`;
+}
+function isUnfinished(job) {
+  return job.outcome === void 0 && job.endedAt === void 0;
+}
+function table(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i]?.length ?? 0)));
+  const render = (cells) => `  ${cells.map((cell, i) => i === cells.length - 1 ? cell : cell.padEnd(widths[i])).join("  ")}`.trimEnd();
+  return [render(headers), ...rows.map(render)];
+}
+function leaseCell(job, now) {
+  const sinceMs = now.getTime() - new Date(job.lastRenewAt ?? job.startedAt).getTime();
+  if (sinceMs >= LEASE_SECONDS * 1e3) return "expired";
+  const untilNext = RENEW_INTERVAL_SECONDS * 1e3 - sinceMs;
+  return untilNext <= 0 ? "renew due" : `renews ${formatDuration(untilNext)}`;
+}
+function renderStatus(input) {
+  const lines = [];
+  const running = input.jobs.filter(({ job }) => isUnfinished(job));
+  const finished = input.jobs.filter(({ job }) => !isUnfinished(job)).sort((a, b) => (b.job.endedAt ?? "").localeCompare(a.job.endedAt ?? "")).slice(0, 20);
+  const header = input.process.state === "running" ? `runner ${input.host} running, pid ${input.process.pid} \xB7 config ${input.configPath} \xB7 ${running.length} of ${input.concurrency} slots in use` : input.process.state === "stale" ? `runner ${input.host} not running (stale pid file for pid ${input.process.pid}) \xB7 config ${input.configPath}` : `runner ${input.host} not running (pid file absent) \xB7 config ${input.configPath}`;
+  lines.push(header, "");
+  if (running.length === 0) {
+    lines.push("No running jobs.");
+  } else {
+    const root = runnerDir(input.configPath);
+    lines.push(
+      ...table(
+        ["ITEM", "QUEUE", "STAGE", "ELAPSED", "STARTED", "LEASE", "JOB DIR"],
+        running.map(({ dirName, job }) => [
+          `#${job.item}`,
+          job.queue,
+          // A job with no outcome under a runner that is not running is not
+          // running either; nothing is watching it.
+          input.process.state === "running" ? job.stage ?? "starting" : "orphaned",
+          formatDuration(input.now.getTime() - new Date(job.startedAt).getTime()),
+          formatClock(new Date(job.startedAt), input.now),
+          input.process.state === "running" ? leaseCell(job, input.now) : "\u2014",
+          truncate(relativeToRunner(root, join(jobsDir(input.configPath), dirName)), JOB_DIR_WIDTH)
+        ])
+      )
+    );
+  }
+  if (!input.recent) {
+    lines.push("", "No finished jobs in the last 24h. Use --recent to list them.");
+    return lines.join("\n");
+  }
+  lines.push("");
+  if (finished.length === 0) {
+    lines.push("No finished jobs.");
+    return lines.join("\n");
+  }
+  lines.push(
+    ...table(
+      ["ITEM", "QUEUE", "OUTCOME", "ENDED", "DURATION"],
+      finished.map(({ job }) => [
+        `#${job.item}`,
+        job.queue,
+        // A lease released with no outcome is an item this host declined
+        // before it ever started; "no outcome" describes the field rather
+        // than what happened. A release that never landed is marked,
+        // because the platform's own record of this attempt is missing.
+        `${job.outcome ?? "not attempted"}${job.releaseFailed === void 0 ? "" : " (release failed)"}`,
+        job.endedAt === void 0 ? "\u2014" : formatClock(new Date(job.endedAt), input.now),
+        job.endedAt === void 0 ? "\u2014" : formatDuration(new Date(job.endedAt).getTime() - new Date(job.startedAt).getTime())
+      ])
+    )
+  );
+  return lines.join("\n");
+}
+
+export { renderStatus };

package/dist/statusline-fast-Z5U5CEC6.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { STATE_FRESH_MS, WRAP_TIMEOUT_MS, localDateString, parseStatuslineArgs, parseStatuslineStdin, readStatuslineState, renderStatusline, runStatuslineFast, runWrappedStatusline, statuslineStatePath } from './chunk-XN2XZFTK.js';
+import './chunk-ECSYRPCC.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/sync-cmd-C5UGI4SF.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { CHUNK_PART_TARGET_BYTES, RETRYABLE_STATUSES, SyncConfigError, SyncTransportError, detectCi, isLoopbackUrl, resolveTier, runSync } from './chunk-DEDV5V4U.js';
+import './chunk-YRYMNBGQ.js';
+import './chunk-RCQXYLMO.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-A6NNKRJU.js';
+import './chunk-IWIUYLDR.js';
+import './chunk-YMTXR7PJ.js';
+import './chunk-ECSYRPCC.js';
+export { cloudConfigPath, readCloudConfig, writeCloudConfig } from './chunk-TFUIDMOB.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/watch-V3K4PESQ.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { StatuslineAggregator, CaptureDaemon, LiveUploader } from './chunk-DEDV5V4U.js';
+import './chunk-YRYMNBGQ.js';
+import './chunk-RCQXYLMO.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-A6NNKRJU.js';
+import './chunk-IWIUYLDR.js';
+import './chunk-YMTXR7PJ.js';
+import './chunk-ECSYRPCC.js';
+import './chunk-TFUIDMOB.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+function makeWatchLogHandler(statusline, stdout = (s) => process.stdout.write(s), stderr = (s) => process.stderr.write(s), uploader) {
+  return (e) => {
+    if (e.type === "mirrored") {
+      stdout(`mirrored ${e.file}
+`);
+      statusline.notifyChange();
+      uploader?.notify(e.file);
+    }
+    if (e.type === "rescan") statusline.notifyChange();
+    if (e.type === "evicted") stdout(`evicted ${e.file}
+`);
+    if (e.type === "error") stderr(`error ${e.file}: ${e.detail}
+`);
+  };
+}
+async function runWatch(opts = {}) {
+  const home = opts.home ?? homeFromEnv();
+  const stateDir = join(home, ".outerlayer");
+  mkdirSync(stateDir, { recursive: true });
+  const statusline = new StatuslineAggregator({ home });
+  if (opts.once) {
+    const daemon2 = new CaptureDaemon({ onLog: makeWatchLogHandler(statusline) });
+    daemon2.rescanNow();
+    statusline.stop();
+    process.stdout.write("Single sweep complete.\n");
+    return;
+  }
+  const uploader = new LiveUploader({ home });
+  const daemon = new CaptureDaemon({ onLog: makeWatchLogHandler(statusline, void 0, void 0, uploader) });
+  writeFileSync(join(stateDir, "daemon.pid"), String(process.pid));
+  const heartbeat = join(stateDir, "daemon.heartbeat");
+  const beat = () => writeFileSync(heartbeat, (/* @__PURE__ */ new Date()).toISOString());
+  beat();
+  const heartbeatTimer = setInterval(beat, 6e4);
+  await daemon.start();
+  statusline.refresh();
+  process.stdout.write("OuterLayer daemon watching ~/.claude/projects (Ctrl-C to stop)\n");
+  const shutdown = async () => {
+    clearInterval(heartbeatTimer);
+    await daemon.stop();
+    statusline.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`daemon: unhandled error, continuing \u2014 ${String(reason)}
+`);
+  });
+  await new Promise(() => void 0);
+}
+
+export { makeWatchLogHandler, runWatch };

package/dist/work-claim-cmd-FQDWQVT2.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { resolveCredentials, WorkCommandError, parsePositiveInt, postJson, resolveRepository, findLiveItem } from './chunk-VU34RWDU.js';
+export { WorkCommandError } from './chunk-VU34RWDU.js';
+import './chunk-DEDV5V4U.js';
+import './chunk-YRYMNBGQ.js';
+import './chunk-RCQXYLMO.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-A6NNKRJU.js';
+import './chunk-IWIUYLDR.js';
+import './chunk-YMTXR7PJ.js';
+import './chunk-ECSYRPCC.js';
+import './chunk-TFUIDMOB.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { hostname } from 'os';
+
+createRequire(import.meta.url);
+var DEFAULT_LEASE_SECONDS = 900;
+var CLAIM_OUTCOMES = ["ok", "failed", "timed_out", "idle", "lease_lost", "interrupted", "stopped"];
+async function resolveItemIdentifier(opts, creds, cwd, fetchImpl) {
+  const itemNumber = parsePositiveInt(opts.item, "--item");
+  if (itemNumber !== void 0) return itemNumber;
+  const issue = parsePositiveInt(opts.issue, "--issue");
+  if (issue === void 0) {
+    throw new WorkCommandError("pass --item <number> or --issue <number>");
+  }
+  const repository = resolveRepository(opts.repo, cwd);
+  const found = await findLiveItem(creds, repository, { issue }, fetchImpl);
+  if (!found) {
+    throw new WorkCommandError(`no live item for ${repository}#${issue}`);
+  }
+  return found.id;
+}
+async function runWorkClaim(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const creds = resolveCredentials(opts);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  if (opts.kind !== "implement" && opts.kind !== "amend") {
+    throw new WorkCommandError('--kind is required \u2014 pass "implement" or "amend"');
+  }
+  const host = opts.host ?? hostname();
+  const seconds = parsePositiveInt(opts.seconds, "--seconds") ?? DEFAULT_LEASE_SECONDS;
+  const itemId = await resolveItemIdentifier(opts, creds, cwd, fetchImpl);
+  const { data } = await postJson(
+    creds.url,
+    `/v1/work-items/${itemId}/claim`,
+    creds.apiKey,
+    creds.appId,
+    { host, kind: opts.kind, seconds },
+    fetchImpl
+  );
+  const output = opts.json ? JSON.stringify(data) : `claimed until ${String(data.expiresAt)}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+async function runWorkRenew(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const creds = resolveCredentials(opts);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const host = opts.host ?? hostname();
+  const seconds = parsePositiveInt(opts.seconds, "--seconds") ?? DEFAULT_LEASE_SECONDS;
+  const itemId = await resolveItemIdentifier(opts, creds, cwd, fetchImpl);
+  const { data } = await postJson(
+    creds.url,
+    `/v1/work-items/${itemId}/claim/renew`,
+    creds.apiKey,
+    creds.appId,
+    { host, seconds },
+    fetchImpl
+  );
+  const output = opts.json ? JSON.stringify(data) : `claimed until ${String(data.expiresAt)}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+async function runWorkRelease(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const creds = resolveCredentials(opts);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  if (opts.outcome !== void 0 && !CLAIM_OUTCOMES.includes(opts.outcome)) {
+    throw new WorkCommandError(`--outcome must be one of: ${CLAIM_OUTCOMES.join(", ")}`);
+  }
+  const host = opts.host ?? hostname();
+  const itemId = await resolveItemIdentifier(opts, creds, cwd, fetchImpl);
+  const { data } = await postJson(
+    creds.url,
+    `/v1/work-items/${itemId}/claim/release`,
+    creds.apiKey,
+    creds.appId,
+    opts.outcome === void 0 ? { host } : { host, outcome: opts.outcome },
+    fetchImpl
+  );
+  const output = opts.json ? JSON.stringify(data) : `released at ${String(data.releasedAt)}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+
+export { runWorkClaim, runWorkRelease, runWorkRenew };

package/dist/work-cmd-CW26EZZO.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { WorkCommandError, findLiveItem, getJson, parsePositiveInt, postJson, resolveCredentials, resolveRepository, runWorkAdd, runWorkLinkSession, runWorkList, runWorkRemove, runWorkStatus } from './chunk-VU34RWDU.js';
+import './chunk-DEDV5V4U.js';
+import './chunk-YRYMNBGQ.js';
+import './chunk-RCQXYLMO.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-A6NNKRJU.js';
+import './chunk-IWIUYLDR.js';
+import './chunk-YMTXR7PJ.js';
+import './chunk-ECSYRPCC.js';
+import './chunk-TFUIDMOB.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/work-launch-YNNCKIH3.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { appendLaunchRecord, launchStatusIsDecisive, launchedItemForSession, launchesPath, parseWorkItemEnv, readLaunchSpoolState } from './chunk-RCQXYLMO.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/work-pr-cmd-W2QNMWXP.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { resolveRepoIdentity, detectActiveSession } from './chunk-DEDV5V4U.js';
+import './chunk-YRYMNBGQ.js';
+import { parseTrackerNumber, trackerNumberError } from './chunk-RCQXYLMO.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-A6NNKRJU.js';
+import './chunk-IWIUYLDR.js';
+import './chunk-YMTXR7PJ.js';
+import './chunk-ECSYRPCC.js';
+import { readCloudConfig } from './chunk-TFUIDMOB.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);
+
+// src/work-pr-cmd.ts
+var GREEN = "\x1B[32m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var WorkPrCommandError = class extends Error {
+};
+function resolveCredentials(opts) {
+  const home = opts.home ?? homeFromEnv();
+  const env = opts.env ?? process.env;
+  const fileConfig = readCloudConfig(home);
+  const url = opts.url ?? env.OUTERLAYER_URL ?? fileConfig.url;
+  const apiKey = opts.apiKey ?? env.OUTERLAYER_API_KEY ?? fileConfig.apiKey;
+  const appId = opts.appId ?? env.OUTERLAYER_APP_ID ?? fileConfig.appId;
+  if (!url || !apiKey || !appId) {
+    const missing = [!url && "--url", !apiKey && "--api-key", !appId && "--app-id"].filter(Boolean).join(", ");
+    throw new WorkPrCommandError(
+      `missing ${missing}. Run \`outerlayer login --url <your gateway>\` and paste the key at the prompt, or set OUTERLAYER_URL / OUTERLAYER_API_KEY / OUTERLAYER_APP_ID. Mint a key in the dashboard: Settings \u2192 API keys.`
+    );
+  }
+  return { url, apiKey, appId };
+}
+function resolveRepository(repoFlag, cwd) {
+  if (repoFlag) return repoFlag;
+  const identity = resolveRepoIdentity(cwd);
+  if (identity.gitRepo) return identity.gitRepo;
+  throw new WorkPrCommandError(
+    "no repository. Pass --repo <owner/name>, or run from a git checkout with a remote."
+  );
+}
+function resolvePrNumber(raw) {
+  const n = parseTrackerNumber(raw);
+  if (n === void 0) throw new WorkPrCommandError(trackerNumberError("<n>", raw ?? ""));
+  return n;
+}
+async function runWorkPr(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homeFromEnv(env);
+  const creds = resolveCredentials(opts);
+  const prNumber = resolvePrNumber(opts.number);
+  const repository = resolveRepository(opts.repo, cwd);
+  const identity = resolveRepoIdentity(cwd);
+  const sessionId = opts.sessionId ?? detectActiveSession({
+    env,
+    home,
+    cwds: identity.repoRoot !== void 0 ? [identity.repoRoot, cwd] : [cwd],
+    nowMs: Date.now()
+  });
+  if (sessionId === void 0) {
+    throw new WorkPrCommandError(
+      "no active session detected. `work pr` declares a pull request from inside the session that opened it."
+    );
+  }
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const endpoint = new URL("/v1/work-items/pull-requests", creds.url).toString();
+  let response;
+  try {
+    response = await fetchImpl(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${creds.apiKey}`,
+        "x-outerlayer-app-id": creds.appId
+      },
+      body: JSON.stringify({ sessionId, pullRequest: { repository, number: prNumber } })
+    });
+  } catch (err) {
+    throw new WorkPrCommandError(`network error reaching ${endpoint}: ${String(err)}`);
+  }
+  if (response.status === 401) {
+    throw new WorkPrCommandError(
+      "not authorized \u2014 the API key is unknown, expired, or bound to a different app. Mint a fresh key: dashboard \u2192 Settings \u2192 API keys."
+    );
+  }
+  let json;
+  try {
+    json = await response.json();
+  } catch {
+    throw new WorkPrCommandError(
+      `${endpoint} answered ${response.status} with a body that is not JSON \u2014 the request may not have reached the gateway`
+    );
+  }
+  if (!response.ok || !json.data) {
+    if (json.error?.code === "session_not_on_item") {
+      throw new WorkPrCommandError("this session is not launched on a work item.");
+    }
+    if (json.error?.code === "repository_not_connected") {
+      throw new WorkPrCommandError(`${repository} is not a workpiece of this factory.`);
+    }
+    throw new WorkPrCommandError(json.error?.message ?? `request failed (${response.status})`);
+  }
+  const data = json.data;
+  const verb = data.created ? "declared" : "already declared";
+  const output = opts.json ? JSON.stringify(data) : `${GREEN}\u2713${RESET} ${verb} ${DIM}\xB7${RESET} ${data.repository}#${data.prNumber} ${DIM}\u2192${RESET} ${data.workItemId}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+
+export { WorkPrCommandError, runWorkPr };