@treeseed/sdk 0.6.16 → 0.6.18

package/dist/operations/services/github-actions-verification.js

@@ -0,0 +1,440 @@
+import { Buffer } from "node:buffer";
+import {
+  createGitHubApiClient,
+  parseGitHubRepositorySlug
+} from "./github-api.js";
+function normalizeWorkflowRun(run) {
+  return {
+    id: Number(run.id ?? 0),
+    status: typeof run.status === "string" ? run.status : null,
+    conclusion: typeof run.conclusion === "string" ? run.conclusion : null,
+    url: typeof run.html_url === "string" ? run.html_url : null,
+    headSha: typeof run.head_sha === "string" ? run.head_sha : null,
+    headBranch: typeof run.head_branch === "string" ? run.head_branch : null,
+    createdAt: typeof run.created_at === "string" ? run.created_at : null,
+    updatedAt: typeof run.updated_at === "string" ? run.updated_at : null
+  };
+}
+function normalizeWorkflowJobStep(step) {
+  return {
+    name: String(step.name ?? ""),
+    number: typeof step.number === "number" ? step.number : null,
+    status: typeof step.status === "string" ? step.status : null,
+    conclusion: typeof step.conclusion === "string" ? step.conclusion : null,
+    startedAt: typeof step.started_at === "string" ? step.started_at : null,
+    completedAt: typeof step.completed_at === "string" ? step.completed_at : null
+  };
+}
+function isSuccessfulConclusion(conclusion) {
+  return conclusion === "success" || conclusion === "skipped" || conclusion === "neutral";
+}
+function isFailedConclusion(conclusion) {
+  return Boolean(conclusion && !isSuccessfulConclusion(conclusion));
+}
+function normalizeWorkflowJob(job) {
+  const steps = Array.isArray(job.steps) ? job.steps.map((step) => normalizeWorkflowJobStep(step)) : [];
+  return {
+    id: Number(job.id ?? 0),
+    name: String(job.name ?? ""),
+    status: typeof job.status === "string" ? job.status : null,
+    conclusion: typeof job.conclusion === "string" ? job.conclusion : null,
+    url: typeof job.html_url === "string" ? job.html_url : null,
+    steps,
+    failedSteps: steps.filter((step) => isFailedConclusion(step.conclusion))
+  };
+}
+function workflowStateForRun(run) {
+  if (!run) return "missing";
+  if (run.status !== "completed") return "pending";
+  return isSuccessfulConclusion(run.conclusion) ? "success" : "failure";
+}
+function aggregateWorkflowState(states) {
+  if (states.includes("error")) return "error";
+  if (states.includes("not_pushed")) return "not_pushed";
+  if (states.includes("failure")) return "failure";
+  if (states.includes("missing")) return "missing";
+  if (states.includes("pending")) return "pending";
+  return "success";
+}
+function cappedLogExcerpt(value, maxLines) {
+  const text = typeof value === "string" ? value : value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : Buffer.isBuffer(value) ? value.toString("utf8") : String(value ?? "");
+  const lines = text.split(/\r?\n/u);
+  return lines.slice(Math.max(0, lines.length - maxLines)).join("\n").trim();
+}
+async function downloadJobLogExcerpt(client, repository, jobId, maxLines) {
+  const { owner, name } = parseGitHubRepositorySlug(repository);
+  const response = await client.request("GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs", {
+    owner,
+    repo: name,
+    job_id: jobId
+  });
+  return cappedLogExcerpt(response.data, maxLines);
+}
+async function loadWorkflowJobs(client, repository, runId, options) {
+  const { owner, name } = parseGitHubRepositorySlug(repository);
+  const jobs = await client.rest.actions.listJobsForWorkflowRun({
+    owner,
+    repo: name,
+    run_id: runId,
+    per_page: 100
+  });
+  const normalized = jobs.data.jobs.map((job) => normalizeWorkflowJob(job));
+  if (!options.includeLogs) {
+    return normalized;
+  }
+  await Promise.all(normalized.filter((job) => isFailedConclusion(job.conclusion) && job.id > 0).map(async (job) => {
+    try {
+      job.logExcerpt = await downloadJobLogExcerpt(client, repository, job.id, options.logLines);
+    } catch (error) {
+      job.logExcerpt = `Unable to fetch job log: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }));
+  return normalized;
+}
+async function resolveRemoteBranchHead(client, repository, branch) {
+  const { owner, name } = parseGitHubRepositorySlug(repository);
+  const remote = await client.rest.repos.getBranch({
+    owner,
+    repo: name,
+    branch
+  });
+  return remote.data.commit.sha;
+}
+async function findWorkflowRun(client, repository, workflow, branch, headSha) {
+  const { owner, name } = parseGitHubRepositorySlug(repository);
+  const listed = await client.rest.actions.listWorkflowRuns({
+    owner,
+    repo: name,
+    workflow_id: workflow,
+    branch: branch ?? void 0,
+    head_sha: headSha ?? void 0,
+    per_page: 20
+  });
+  const runs = listed.data.workflow_runs.map((run) => normalizeWorkflowRun(run)).filter((run) => (!headSha || run.headSha === headSha) && (!branch || run.headBranch === branch));
+  return runs[0] ?? null;
+}
+function inspectCommand(repository, runId) {
+  return repository && runId ? `gh run view ${runId} --repo ${repository} --log-failed` : null;
+}
+function workflowMessage(workflow, state, conclusion) {
+  switch (state) {
+    case "success":
+      return `${workflow} completed successfully.`;
+    case "failure":
+      return `${workflow} completed with conclusion ${conclusion ?? "unknown"}.`;
+    case "pending":
+      return `${workflow} is still running or queued.`;
+    case "missing":
+      return `${workflow} has no run for this branch HEAD.`;
+    case "not_pushed":
+      return `${workflow} cannot be checked because the local HEAD is not the remote branch HEAD.`;
+    case "error":
+      return `${workflow} could not be inspected.`;
+  }
+}
+function isGitHubNotFoundError(error) {
+  const status = typeof error?.status === "number" ? Number(error.status) : null;
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return status === 404 || /not found/iu.test(message);
+}
+async function inspectWorkflow(client, target, workflow, options) {
+  if (!target.repository || !target.branch || !target.headSha) {
+    return {
+      workflow,
+      state: "error",
+      status: null,
+      conclusion: null,
+      runId: null,
+      url: null,
+      headSha: target.headSha,
+      branch: target.branch,
+      createdAt: null,
+      updatedAt: null,
+      jobs: [],
+      failedJobs: [],
+      inspectCommand: null,
+      message: "Repository, branch, or head SHA is unavailable."
+    };
+  }
+  try {
+    const run = await findWorkflowRun(client, target.repository, workflow, target.branch, target.headSha);
+    const state = workflowStateForRun(run);
+    const jobs = run?.id && run.status === "completed" ? await loadWorkflowJobs(client, target.repository, run.id, options) : [];
+    const failedJobs = jobs.filter((job) => isFailedConclusion(job.conclusion));
+    return {
+      workflow,
+      state,
+      status: run?.status ?? null,
+      conclusion: run?.conclusion ?? null,
+      runId: run?.id ?? null,
+      url: run?.url ?? null,
+      headSha: run?.headSha ?? target.headSha,
+      branch: run?.headBranch ?? target.branch,
+      createdAt: run?.createdAt ?? null,
+      updatedAt: run?.updatedAt ?? null,
+      jobs,
+      failedJobs,
+      inspectCommand: inspectCommand(target.repository, run?.id ?? null),
+      message: workflowMessage(workflow, state, run?.conclusion ?? null)
+    };
+  } catch (error) {
+    if (isGitHubNotFoundError(error)) {
+      return {
+        workflow,
+        state: "missing",
+        status: null,
+        conclusion: null,
+        runId: null,
+        url: null,
+        headSha: target.headSha,
+        branch: target.branch,
+        createdAt: null,
+        updatedAt: null,
+        jobs: [],
+        failedJobs: [],
+        inspectCommand: null,
+        message: `${workflow} is missing or has no run for this branch HEAD.`
+      };
+    }
+    return {
+      workflow,
+      state: "error",
+      status: null,
+      conclusion: null,
+      runId: null,
+      url: null,
+      headSha: target.headSha,
+      branch: target.branch,
+      createdAt: null,
+      updatedAt: null,
+      jobs: [],
+      failedJobs: [],
+      inspectCommand: null,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function repositoryFailure(target) {
+  return {
+    type: "repository",
+    repository: target.repository,
+    repoName: target.name,
+    workflow: null,
+    runId: null,
+    jobId: null,
+    jobName: null,
+    state: target.state,
+    conclusion: null,
+    url: null,
+    inspectCommand: null,
+    message: target.message ?? `${target.name} requires attention.`,
+    failedSteps: []
+  };
+}
+function workflowFailure(repo, workflow) {
+  return {
+    type: "workflow",
+    repository: repo.repository,
+    repoName: repo.name,
+    workflow: workflow.workflow,
+    runId: workflow.runId,
+    jobId: null,
+    jobName: null,
+    state: workflow.state,
+    conclusion: workflow.conclusion,
+    url: workflow.url,
+    inspectCommand: workflow.inspectCommand,
+    message: workflow.message ?? `${repo.name} ${workflow.workflow} requires attention.`,
+    failedSteps: []
+  };
+}
+function jobFailure(repo, workflow, job) {
+  return {
+    type: "job",
+    repository: repo.repository,
+    repoName: repo.name,
+    workflow: workflow.workflow,
+    runId: workflow.runId,
+    jobId: job.id,
+    jobName: job.name,
+    state: workflow.state,
+    conclusion: job.conclusion,
+    url: job.url ?? workflow.url,
+    inspectCommand: workflow.inspectCommand,
+    message: `${repo.name} ${workflow.workflow} job ${job.name || job.id} completed with conclusion ${job.conclusion ?? "unknown"}.`,
+    failedSteps: job.failedSteps,
+    logExcerpt: job.logExcerpt ?? null
+  };
+}
+function collectFailures(repositories) {
+  const failures = [];
+  for (const repo of repositories) {
+    if (repo.state === "not_pushed" || repo.state === "error") {
+      failures.push(repositoryFailure(repo));
+      continue;
+    }
+    for (const workflow of repo.workflows) {
+      if (workflow.state === "failure" && workflow.failedJobs.length > 0) {
+        failures.push(...workflow.failedJobs.map((job) => jobFailure(repo, workflow, job)));
+        continue;
+      }
+      if (workflow.state === "failure" || workflow.state === "missing" || workflow.state === "error") {
+        failures.push(workflowFailure(repo, workflow));
+      }
+    }
+  }
+  return failures;
+}
+function summarize(repositories, failures) {
+  const workflows = repositories.flatMap((repo) => repo.workflows);
+  return {
+    repositories: repositories.length,
+    workflows: workflows.length,
+    success: workflows.filter((workflow) => workflow.state === "success").length,
+    failure: workflows.filter((workflow) => workflow.state === "failure").length,
+    pending: workflows.filter((workflow) => workflow.state === "pending").length,
+    missing: workflows.filter((workflow) => workflow.state === "missing").length,
+    notPushed: repositories.filter((repo) => repo.state === "not_pushed").length,
+    error: workflows.filter((workflow) => workflow.state === "error").length + repositories.filter((repo) => repo.state === "error").length,
+    failures: failures.length
+  };
+}
+async function inspectTarget(client, target, options) {
+  if (!target.repository || !target.branch || !target.headSha) {
+    return {
+      name: target.name,
+      repoPath: target.repoPath,
+      repository: target.repository,
+      kind: target.kind ?? "package",
+      branch: target.branch,
+      headSha: target.headSha,
+      remoteHeadSha: null,
+      remoteSynced: false,
+      state: "error",
+      message: "Repository, branch, or head SHA is unavailable.",
+      workflows: []
+    };
+  }
+  try {
+    const remoteHeadSha = await resolveRemoteBranchHead(client, target.repository, target.branch);
+    if (remoteHeadSha !== target.headSha) {
+      return {
+        name: target.name,
+        repoPath: target.repoPath,
+        repository: target.repository,
+        kind: target.kind ?? "package",
+        branch: target.branch,
+        headSha: target.headSha,
+        remoteHeadSha,
+        remoteSynced: false,
+        state: "not_pushed",
+        message: `Local HEAD ${target.headSha.slice(0, 12)} does not match origin/${target.branch} ${remoteHeadSha.slice(0, 12)}.`,
+        workflows: target.workflows.map((workflow) => ({
+          workflow,
+          state: "not_pushed",
+          status: null,
+          conclusion: null,
+          runId: null,
+          url: null,
+          headSha: target.headSha,
+          branch: target.branch,
+          createdAt: null,
+          updatedAt: null,
+          jobs: [],
+          failedJobs: [],
+          inspectCommand: null,
+          message: workflowMessage(workflow, "not_pushed", null)
+        }))
+      };
+    }
+    const workflows = await Promise.all(target.workflows.map((workflow) => inspectWorkflow(client, target, workflow, options)));
+    return {
+      name: target.name,
+      repoPath: target.repoPath,
+      repository: target.repository,
+      kind: target.kind ?? "package",
+      branch: target.branch,
+      headSha: target.headSha,
+      remoteHeadSha,
+      remoteSynced: true,
+      state: aggregateWorkflowState(workflows.map((workflow) => workflow.state)),
+      message: null,
+      workflows
+    };
+  } catch (error) {
+    return {
+      name: target.name,
+      repoPath: target.repoPath,
+      repository: target.repository,
+      kind: target.kind ?? "package",
+      branch: target.branch,
+      headSha: target.headSha,
+      remoteHeadSha: null,
+      remoteSynced: false,
+      state: "error",
+      message: error instanceof Error ? error.message : String(error),
+      workflows: []
+    };
+  }
+}
+async function inspectGitHubActionsVerification(targets, {
+  client = createGitHubApiClient(),
+  includeLogs = false,
+  logLines = 120
+} = {}) {
+  const resolvedLogLines = Math.max(20, Math.min(1e3, Math.floor(logLines)));
+  const repositories = await Promise.all(targets.map((target) => inspectTarget(client, target, {
+    includeLogs,
+    logLines: resolvedLogLines
+  })));
+  const failures = collectFailures(repositories);
+  return {
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repositories,
+    failures,
+    summary: summarize(repositories, failures)
+  };
+}
+function skippedGitHubActionsGate(gate, reason) {
+  return {
+    name: gate.name,
+    repository: gate.repository ?? null,
+    workflow: gate.workflow,
+    branch: gate.branch,
+    headSha: gate.headSha,
+    status: "skipped",
+    reason,
+    conclusion: null,
+    runId: null,
+    url: null
+  };
+}
+function formatGitHubActionsGateFailure(gate, result) {
+  const repository = String(result.repository ?? gate.repository ?? gate.name);
+  const runId = typeof result.runId === "number" || typeof result.runId === "string" ? String(result.runId) : "";
+  const url = typeof result.url === "string" && result.url ? `
+${result.url}` : "";
+  const failedJobs = Array.isArray(result.failedJobs) ? result.failedJobs.map((job) => typeof job?.name === "string" ? String(job.name) : "").filter(Boolean) : [];
+  const jobLine = failedJobs.length > 0 ? `
+Failed jobs: ${failedJobs.join(", ")}` : "";
+  const command = runId ? `
+Inspect with: gh run view ${runId} --repo ${repository} --log-failed` : "";
+  return `${gate.name} ${gate.workflow} completed with conclusion ${String(result.conclusion ?? "unknown")} in ${repository}.${url}${jobLine}${command}`;
+}
+async function waitForGitHubActionsGate(gate, options = {}) {
+  const { waitForGitHubWorkflowCompletion } = await import("./github-automation.js");
+  return await waitForGitHubWorkflowCompletion(gate.repoPath, {
+    repository: gate.repository,
+    workflow: gate.workflow,
+    headSha: gate.headSha,
+    branch: gate.branch,
+    timeoutSeconds: options.timeoutSeconds,
+    pollSeconds: options.pollSeconds
+  });
+}
+export {
+  formatGitHubActionsGateFailure,
+  inspectGitHubActionsVerification,
+  skippedGitHubActionsGate,
+  waitForGitHubActionsGate
+};

package/dist/operations/services/mailpit-runtime.d.ts

@@ -1,3 +1,8 @@
+export type TreeseedMailpitContainer = {
+    name: string;
+    image: string;
+    ports: string;
+};
 export declare function dockerIsAvailable(): boolean;
 export declare function findRunningMailpitContainer(): any;
 export declare function stopKnownMailpitContainers(): boolean;

package/dist/operations/services/mailpit-runtime.js

@@ -35,11 +35,11 @@ function stopKnownMailpitContainers() {
   if (!container) {
     return true;
   }
-  const stopResult = runDocker(["stop", container.name], { stdio: "inherit" });
+  const stopResult = runDocker(["stop", container.name]);
   if (stopResult.status !== 0) {
     return false;
   }
-  const removeResult = runDocker(["rm", "-f", container.name], { stdio: "inherit" });
+  const removeResult = runDocker(["rm", "-f", container.name]);
   return removeResult.status === 0;
 }
 function streamKnownMailpitLogs() {

package/dist/operations/services/repository-save-orchestrator.js

@@ -505,6 +505,9 @@ async function commitMessageFor(node, options, context) {
     provider: options.commitMessageProvider
   });
 }
+function commitSubject(message) {
+  return String(message ?? "").split(/\r?\n/u)[0]?.trim() || null;
+}
 function gitDiffSummary(repoDir) {
   const changedFiles = run("git", ["status", "--porcelain"], { cwd: repoDir, capture: true });
   const diff = run("git", ["diff", "--cached"], { cwd: repoDir, capture: true });
@@ -884,19 +887,68 @@ function ensurePackageTagReady(node, options, tagName, branch, workflowRunId) {
   }
   return message;
 }
-function refreshSubmodulePointers(node, finalizedCommits) {
-  let changed = false;
-  for (const [repoName] of finalizedCommits.entries()) {
+function treeCommitForPath(repoDir, ref, path) {
+  try {
+    const output = run("git", ["ls-tree", ref, "--", path], { cwd: repoDir, capture: true }).trim();
+    const match = output.match(/^\d+\s+commit\s+([0-9a-f]{40})\t/u);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function collectSubmodulePointerChanges(node, finalizedCommits) {
+  const changes = [];
+  for (const [repoName, finalizedCommit] of finalizedCommits.entries()) {
     const childRelativePath = node.id === "." ? repoName : repoName.startsWith(`${node.id}/`) ? repoName.slice(node.id.length + 1) : null;
     if (!childRelativePath) continue;
     const childPath = resolve(node.path, childRelativePath);
     if (!existsSync(childPath) || !isGitRepo(childPath)) continue;
     const status = run("git", ["status", "--porcelain", "--", childRelativePath], { cwd: node.path, capture: true });
-    if (status.trim().length > 0) {
-      changed = true;
+    const oldSha = treeCommitForPath(node.path, "HEAD", childRelativePath);
+    const newSha = finalizedCommit || headCommit(childPath);
+    if (status.trim().length > 0 || oldSha && newSha && oldSha !== newSha) {
+      changes.push({
+        path: childRelativePath,
+        oldSha,
+        newSha
+      });
     }
   }
-  return changed;
+  return changes;
+}
+function commitContextDependencyUpdates(updates) {
+  return updates.map((update) => ({
+    packageName: update.packageName,
+    field: update.field,
+    from: update.from,
+    to: update.to,
+    tagName: update.tagName
+  }));
+}
+function commitContextPackageChanges(node, state, submodulePointers) {
+  const pointersByPath = new Map(submodulePointers.map((pointer) => [pointer.path, pointer]));
+  const changes = [];
+  for (const [relativePath, report] of state.reports.entries()) {
+    if (relativePath === node.id || relativePath === ".") continue;
+    const childRelativePath = node.id === "." ? relativePath : relativePath.startsWith(`${node.id}/`) ? relativePath.slice(node.id.length + 1) : null;
+    if (!childRelativePath) continue;
+    const pointer = pointersByPath.get(childRelativePath);
+    if (!pointer && !report.committed && !report.tagName && !report.dependencySpec) continue;
+    changes.push({
+      name: report.name,
+      path: childRelativePath,
+      oldSha: pointer?.oldSha ?? null,
+      newSha: pointer?.newSha ?? report.commitSha,
+      tagName: report.tagName,
+      version: report.version,
+      dependencySpec: report.dependencySpec,
+      commitSubject: commitSubject(report.commitMessage)
+    });
+    if (pointer) {
+      pointer.packageName = report.name;
+    }
+  }
+  return changes;
 }
 function syncBranchBeforeSave(node, options, branch) {
   checkoutOrCreateBranch(node, options, branch);
@@ -1201,7 +1253,8 @@ async function saveOneRepository(node, options, state) {
   const dependencyUpdates = updateDependencyReferences(node, state.finalizedReferences);
   const dependencyChanged = dependencyUpdates.length > 0;
   const gitDependencyRefreshSpecs = dependencyUpdates.map((update) => state.finalizedReferences.get(update.packageName)).filter((reference) => Boolean(reference) && reference.mode === "dev-git-tag").map((reference) => `${reference.packageName}@${reference.installSpec ?? reference.spec}`);
-  const submodulesChanged = refreshSubmodulePointers(node, state.finalizedCommits);
+  const submodulePointers = collectSubmodulePointerChanges(node, state.finalizedCommits);
+  const submodulesChanged = submodulePointers.length > 0;
   const packageNeedsVersion = node.kind === "package" && (hasMeaningfulChanges(node.path) || dependencyChanged || submodulesChanged);
   let plannedVersion = null;
   if (packageNeedsVersion) {
@@ -1294,7 +1347,10 @@ async function saveOneRepository(node, options, state) {
     changedFiles,
     diff,
     plannedVersion: plannedVersion ?? report.version,
-    plannedTag: node.plannedTag ?? report.tagName
+    plannedTag: node.plannedTag ?? report.tagName,
+    dependencyUpdates: commitContextDependencyUpdates(dependencyUpdates),
+    submodulePointers,
+    packageChanges: commitContextPackageChanges(node, state, submodulePointers)
   });
   report.commitMessage = messageResult.message;
   report.commitMessageProvider = messageResult.provider;

package/dist/operations/services/runtime-tools.d.ts

@@ -109,6 +109,9 @@ export declare function loadCliDeployConfig(tenantRoot: any): {
             rootDir: string | undefined;
             publicBaseUrl: string | undefined;
             localBaseUrl: string | undefined;
+            local: {
+                runtime: string | undefined;
+            } | undefined;
             environments: {
                 local: {
                     baseUrl: string | undefined;
@@ -160,6 +163,9 @@ export declare function loadCliDeployConfig(tenantRoot: any): {
             provider: string | undefined;
             rootDir: string | undefined;
             publicBaseUrl: string | undefined;
+            local: {
+                runtime: string | undefined;
+            } | undefined;
             cloudflare: {
                 workerName: string | undefined;
             };

package/dist/operations/services/runtime-tools.js

@@ -112,6 +112,15 @@ function parseServiceEnvironmentConfig(value) {
     railwayEnvironment: optionalString(record.railwayEnvironment)
   };
 }
+function parseLocalRuntimeConfig(value, label) {
+  const record = optionalRecord(value, label);
+  if (!record) {
+    return void 0;
+  }
+  return {
+    runtime: optionalEnum(record.runtime ?? record.runtime_mode ?? record.runtimeMode, `${label}.runtime`, ["auto", "provider", "local"])
+  };
+}
 function parseManagedServiceConfig(value, label) {
   const record = optionalRecord(value, label);
   if (!record) {
@@ -125,6 +134,7 @@ function parseManagedServiceConfig(value, label) {
     provider: optionalString(record.provider),
     rootDir: optionalString(record.rootDir),
     publicBaseUrl: optionalString(record.publicBaseUrl),
+    local: parseLocalRuntimeConfig(record.local, `${label}.local`),
     cloudflare: {
       workerName: optionalString(cloudflare.workerName)
     },
@@ -212,6 +222,7 @@ function parseSurfaceConfig(value, label) {
     rootDir: optionalString(record.rootDir),
     publicBaseUrl: optionalString(record.publicBaseUrl),
     localBaseUrl: optionalString(record.localBaseUrl),
+    local: parseLocalRuntimeConfig(record.local, `${label}.local`),
     environments: (() => {
       const environments = optionalRecord(record.environments, `${label}.environments`);
       if (!environments) {

package/dist/operations-registry.js

@@ -4,6 +4,7 @@ function operation(spec) {
 const workspaceCommand = (name) => `workspace${":"}${name}`;
 const TRESEED_OPERATION_SPECS = [
   operation({ id: "workspace.status", name: "status", aliases: [], group: "Workflow", summary: "Show Treeseed project health and the current task state.", description: "Report branch/task state, runtime readiness, preview/deploy state, auth readiness, and recommended next operations.", provider: "default", related: ["tasks", "switch", "config"] }),
+  operation({ id: "workspace.ci", name: "ci", aliases: [], group: "Validation", summary: "Inspect remote GitHub Actions status for the active workspace commits.", description: "Check the latest GitHub Actions workflow runs for the current branch heads across market and checked-out package repositories, including failed jobs and inspect commands.", provider: "default", related: ["status", "save", "stage"] }),
   operation({ id: "branch.tasks", name: "tasks", aliases: [], group: "Workflow", summary: "List task branches plus package branch alignment.", description: "List task branches from market and checked-out package repos, including preview metadata and branch/pointer alignment state.", provider: "default", related: ["status", "switch", "close"] }),
   operation({ id: "branch.switch", name: "switch", aliases: [], group: "Workflow", summary: "Create or resume a recursive task branch.", description: "Create or resume the task branch in market and any checked-out package repos, with optional preview provisioning.", provider: "default", related: ["tasks", "dev", "save"] }),
   operation({ id: "branch.save", name: "save", aliases: [], group: "Workflow", summary: "Recursively verify, commit, and push the current task checkpoint.", description: "Save dirty package repos in dependency order, then verify, commit, push, and optionally refresh preview for market.", provider: "default", related: ["switch", "stage", "status"] }),

package/dist/platform/contracts.d.ts

@@ -122,6 +122,7 @@ export interface TreeseedPlatformSurfaceConfig {
     rootDir?: string;
     publicBaseUrl?: string;
     localBaseUrl?: string;
+    local?: TreeseedLocalRuntimeConfig;
     environments?: Partial<Record<'local' | 'staging' | 'prod', TreeseedManagedServiceEnvironmentConfig>>;
     cache?: TreeseedWebSurfaceCacheConfig;
 }
@@ -182,6 +183,10 @@ export interface TreeseedManagedServiceEnvironmentConfig {
     domain?: string;
     railwayEnvironment?: string;
 }
+export type TreeseedLocalRuntimeMode = 'auto' | 'provider' | 'local';
+export interface TreeseedLocalRuntimeConfig {
+    runtime?: TreeseedLocalRuntimeMode;
+}
 export interface TreeseedManagedServiceCloudflareConfig {
     workerName?: string;
 }
@@ -207,6 +212,7 @@ export interface TreeseedManagedServiceConfig {
     publicBaseUrl?: string;
     cloudflare?: TreeseedManagedServiceCloudflareConfig;
     railway?: TreeseedManagedServiceRailwayConfig;
+    local?: TreeseedLocalRuntimeConfig;
     environments?: Partial<Record<'local' | 'staging' | 'prod', TreeseedManagedServiceEnvironmentConfig>>;
 }
 export interface TreeseedManagedServicesConfig {