@treeseed/cli 0.6.7 → 0.6.8

package/dist/cli/handlers/close.js

@@ -4,6 +4,7 @@ const handleClose = async (invocation, context) => {
   try {
     const result = await createWorkflowSdk(context).close({
       message: invocation.positionals.join(" ").trim(),
+      workspaceLinks: typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0,
       plan: invocation.args.plan === true || invocation.args.dryRun === true,
       dryRun: invocation.args.dryRun === true
     });

package/dist/cli/handlers/config.js

@@ -4,7 +4,9 @@ import {
   collectTreeseedConfigContext,
   ensureTreeseedActVerificationTooling,
   ensureTreeseedSecretSessionForConfig,
-  findNearestTreeseedRoot
+  findNearestTreeseedRoot,
+  formatTreeseedDependencyFailureDetails,
+  installTreeseedDependencies
 } from "@treeseed/sdk/workflow-support";
 import { fail, guidedResult } from "./utils.js";
 import { buildCliConfigPages, runCliConfigEditor } from "./config-ui.js";
@@ -192,6 +194,16 @@ const handleConfig = async (invocation, context) => {
       if (!tenantRoot) {
         return fail("Treeseed config requires a Treeseed project. Run the command from inside a tenant or initialize one first.");
       }
+      const dependencyInstall = await installTreeseedDependencies({
+        tenantRoot,
+        force: invocation.args.installMissingTooling === true,
+        env: context.env,
+        write: context.write
+      });
+      if (!dependencyInstall.ok) {
+        return fail(`Treeseed dependency initialization failed:
+- ${formatTreeseedDependencyFailureDetails(dependencyInstall)}`);
+      }
       applyTreeseedSafeRepairs(tenantRoot);
       const toolAvailability = ensureTreeseedActVerificationTooling({
         tenantRoot,

package/dist/cli/handlers/dev.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
-import { resolveTreeseedLaunchEnvironment } from "@treeseed/sdk/workflow-support";
+import { ensureLocalWorkspaceLinks, findNearestTreeseedWorkspaceRoot, resolveTreeseedLaunchEnvironment } from "@treeseed/sdk/workflow-support";
 import { workflowErrorResult } from "./workflow.js";
 const require2 = createRequire(import.meta.url);
 function resolveCoreDevEntrypoint(cwd) {
@@ -43,6 +43,12 @@ function resolveCoreDevEntrypoint(cwd) {
 const handleDev = async (invocation, context) => {
   try {
     const watch = invocation.commandName === "dev:watch" || invocation.args.watch === true;
+    const workspaceRoot = findNearestTreeseedWorkspaceRoot(context.cwd);
+    const workspaceLinksMode = typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0;
+    const workspaceLinks = workspaceRoot ? ensureLocalWorkspaceLinks(workspaceRoot, { env: context.env, mode: workspaceLinksMode }) : null;
+    if (workspaceLinks?.created.length) {
+      context.write(`[workspace][link] Linked ${workspaceLinks.created.length} local workspace package paths.`, "stdout");
+    }
     const resolved = resolveCoreDevEntrypoint(context.cwd);
     const args = watch ? [...resolved.args, "--watch"] : resolved.args;
     const result = context.spawn(resolved.command, args, {
@@ -61,7 +67,8 @@ const handleDev = async (invocation, context) => {
         ok: (result.status ?? 1) === 0,
         watch,
         executable: resolved.command,
-        args
+        args,
+        workspaceLinks
       }
     };
   } catch (error) {

package/dist/cli/handlers/release.js

@@ -1,15 +1,72 @@
 import { guidedResult } from "./utils.js";
 import { createWorkflowSdk, renderWorkflowNextSteps, workflowErrorResult } from "./workflow.js";
+function formatReleasePlanSections(payload) {
+  const sections = [];
+  const selection = payload.packageSelection ?? {};
+  const selected = selection.selected ?? [];
+  if (selected.length > 0 || (selection.changed ?? []).length > 0 || (selection.dependents ?? []).length > 0) {
+    sections.push({
+      title: "Package selection",
+      lines: [
+        `Changed: ${(selection.changed ?? []).join(", ") || "none"}`,
+        `Dependents: ${(selection.dependents ?? []).join(", ") || "none"}`,
+        `Selected: ${selected.join(", ") || "none"}`
+      ]
+    });
+  }
+  const versions = Object.entries(payload.plannedVersions ?? {});
+  if (versions.length > 0) {
+    sections.push({
+      title: "Planned versions",
+      lines: versions.map(([name, version]) => `- ${name}: ${version}`)
+    });
+  }
+  const rewrites = payload.plannedDevReferenceRewrites ?? [];
+  if (rewrites.length > 0) {
+    sections.push({
+      title: "Dependency rewrites",
+      lines: rewrites.map((rewrite) => {
+        const target = rewrite.dependencyName ? `${rewrite.field ?? "dependencies"}.${rewrite.dependencyName}` : rewrite.filePath ?? "lockfile";
+        return `- ${rewrite.repoName ?? "repo"} ${target}: ${rewrite.reason ?? "dev-ref"} ${rewrite.spec ?? ""}`.trim();
+      })
+    });
+  }
+  const waits = payload.plannedPublishWaits ?? [];
+  if (waits.length > 0) {
+    sections.push({
+      title: "Publish waits",
+      lines: waits.map((wait) => `- ${wait.name ?? "package"}: ${wait.workflow ?? "publish.yml"} on ${wait.branch ?? "main"} (${wait.status ?? "planned"})`)
+    });
+  }
+  const steps = payload.plannedSteps ?? [];
+  if (steps.length > 0) {
+    sections.push({
+      title: "Execution order",
+      lines: steps.map((step, index) => `${index + 1}. ${step.description ?? step.id ?? "step"}`)
+    });
+  }
+  if ((payload.blockers ?? []).length > 0) {
+    sections.push({
+      title: "Blockers",
+      lines: (payload.blockers ?? []).map((blocker) => `- ${blocker}`)
+    });
+  }
+  return sections;
+}
 const handleRelease = async (invocation, context) => {
   try {
     const bump = ["major", "minor", "patch"].find((candidate) => invocation.args[candidate] === true) ?? "patch";
     const result = await createWorkflowSdk(context).release({
       bump,
+      workspaceLinks: typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0,
       plan: invocation.args.plan === true || invocation.args.dryRun === true,
       dryRun: invocation.args.dryRun === true
     });
     const payload = result.payload;
-    const completedPublishes = payload.publishWait.filter((entry) => entry.status === "completed").length;
+    const publishWait = payload.publishWait ?? [];
+    const completedPublishes = publishWait.filter((entry) => entry.status === "completed").length;
+    const plannedPublishes = payload.plannedPublishWaits?.length ?? 0;
+    const releasedCommit = typeof payload.releasedCommit === "string" && payload.releasedCommit.length > 0 ? payload.releasedCommit.slice(0, 12) : result.executionMode === "plan" ? "planned" : "not available";
     return guidedResult({
       command: invocation.commandName || "release",
       summary: result.executionMode === "plan" ? "Treeseed release plan ready." : "Treeseed release completed successfully.",
@@ -19,15 +76,16 @@ const handleRelease = async (invocation, context) => {
         { label: "Production branch", value: payload.productionBranch },
         { label: "Merge strategy", value: payload.mergeStrategy },
         { label: "Release level", value: payload.level },
-        { label: "Root version", value: payload.rootVersion },
-        { label: "Release tag", value: payload.releaseTag },
-        { label: "Released commit", value: payload.releasedCommit.slice(0, 12) },
+        { label: "Root version", value: payload.rootVersion ?? payload.plannedVersions?.["@treeseed/market"] ?? "(planned)" },
+        { label: "Release tag", value: payload.releaseTag ?? payload.rootVersion ?? payload.plannedVersions?.["@treeseed/market"] ?? "(planned)" },
+        { label: "Released commit", value: releasedCommit },
         { label: "Changed packages", value: String(payload.packageSelection.changed.length) },
         { label: "Dependent packages", value: String(payload.packageSelection.dependents.length) },
-        { label: "Released packages", value: String(payload.touchedPackages.length) },
-        { label: "Publish waits", value: String(completedPublishes) },
-        { label: "Final branch", value: payload.finalBranch }
+        { label: result.executionMode === "plan" ? "Packages planned" : "Released packages", value: String((payload.touchedPackages ?? payload.packageSelection.selected).length) },
+        { label: "Publish waits", value: result.executionMode === "plan" ? String(plannedPublishes) : String(completedPublishes) },
+        { label: "Final branch", value: payload.finalBranch ?? (result.executionMode === "plan" ? payload.stagingBranch : "(unknown)") }
       ],
+      sections: result.executionMode === "plan" ? formatReleasePlanSections(payload) : [],
       nextSteps: renderWorkflowNextSteps(result),
       report: result
     });

package/dist/cli/handlers/save.js

@@ -1,16 +1,64 @@
 import { guidedResult } from "./utils.js";
 import { createWorkflowSdk, renderWorkflowNextSteps, workflowErrorResult } from "./workflow.js";
+function formatRepoPlanSummary(repo) {
+  const branch = repo.currentBranch && repo.targetBranch && repo.currentBranch !== repo.targetBranch ? `${repo.currentBranch} -> ${repo.targetBranch}` : repo.targetBranch ?? repo.currentBranch ?? "unknown";
+  const version = repo.plannedVersion ? `, version ${repo.currentVersion ?? "?"} -> ${repo.plannedVersion}` : repo.currentVersion ? `, version ${repo.currentVersion}` : "";
+  return `${repo.name} (${repo.kind ?? "repo"}, ${repo.branchMode ?? "unknown"}, ${repo.dirty ? "dirty" : "clean"}, branch ${branch}${version})`;
+}
+function formatSavePlanSections(repositoryPlan) {
+  if (!repositoryPlan) return [];
+  const reposByName = new Map([
+    ...repositoryPlan.repos ?? [],
+    ...repositoryPlan.rootRepo ? [repositoryPlan.rootRepo] : []
+  ].map((repo) => [repo.name, repo]));
+  const sections = [];
+  const repoLines = [
+    ...(repositoryPlan.repos ?? []).map((repo) => `- ${formatRepoPlanSummary(repo)}`),
+    ...repositoryPlan.rootRepo ? [`- ${formatRepoPlanSummary(repositoryPlan.rootRepo)}`] : []
+  ];
+  if (repoLines.length > 0) {
+    sections.push({ title: "Repositories", lines: repoLines });
+  }
+  const versionEntries = Object.entries(repositoryPlan.plannedVersions ?? {});
+  if (versionEntries.length > 0) {
+    sections.push({
+      title: "Planned package versions",
+      lines: versionEntries.map(([name, version]) => `- ${name}: ${version}`)
+    });
+  }
+  const waveLines = [];
+  for (const wave of repositoryPlan.waves ?? []) {
+    waveLines.push(`Wave ${wave.index}${wave.parallel ? " (parallel, concurrency 3)" : ""}: ${wave.repos.join(", ")}`);
+    for (const entry of wave.commands) {
+      const repo = reposByName.get(entry.repo);
+      waveLines.push(`  ${entry.repo}${repo?.plannedDependencySpec ? ` -> ${repo.plannedDependencySpec}` : ""}`);
+      entry.commands.forEach((command, index) => {
+        waveLines.push(`    ${index + 1}. ${command}`);
+      });
+    }
+  }
+  if (waveLines.length > 0) {
+    sections.push({ title: "Execution order", lines: waveLines });
+  }
+  return sections;
+}
 const handleSave = async (invocation, context) => {
   try {
-    const result = await createWorkflowSdk(context).save({
+    const result = await createWorkflowSdk(context, {
+      write: context.outputFormat === "json" ? (() => {
+      }) : context.write
+    }).save({
       message: invocation.positionals.join(" ").trim(),
       hotfix: invocation.args.hotfix === true,
       preview: invocation.args.preview === true,
+      workspaceLinks: typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0,
       plan: invocation.args.plan === true || invocation.args.dryRun === true,
       dryRun: invocation.args.dryRun === true
     });
     const payload = result.payload;
+    const commitSha = typeof payload.commitSha === "string" && payload.commitSha.length > 0 ? payload.commitSha.slice(0, 12) : "not applicable";
     const savedRepos = (payload.repos ?? []).filter((repo) => repo.committed || repo.pushed).map((repo) => `${repo.name}@${String(repo.commitSha ?? "").slice(0, 12)}`).join(", ");
+    const plannedRepos = result.executionMode === "plan" ? (payload.repositoryPlan?.repos ?? payload.repos ?? []).map((repo) => repo.name).join(", ") : "";
     return guidedResult({
       command: invocation.commandName || "save",
       summary: result.executionMode === "plan" ? "Treeseed save plan ready." : payload.noChanges ? "Treeseed save found no new changes and confirmed branch sync." : "Treeseed save completed successfully.",
@@ -19,12 +67,23 @@ const handleSave = async (invocation, context) => {
         { label: "Branch", value: payload.branch },
         { label: "Environment scope", value: payload.scope },
         { label: "Hotfix", value: payload.hotfix ? "yes" : "no" },
-        { label: "Commit", value: payload.commitSha.slice(0, 12) },
+        {
+          label: result.executionMode === "plan" ? "Interrupted save" : "Resumed run",
+          value: result.executionMode === "plan" ? payload.autoResumeCandidate?.runId ? `will resume ${payload.autoResumeCandidate.runId}` : "none" : payload.resumedRunId ?? "none"
+        },
+        { label: "Commit", value: commitSha },
         { label: "Commit created", value: payload.commitCreated ? "yes" : "no" },
-        { label: "Workspace repos", value: savedRepos || ((payload.repos ?? []).length > 0 ? "none saved" : "not applicable") },
+        {
+          label: result.executionMode === "plan" ? "Workspace repos planned" : "Workspace repos",
+          value: result.executionMode === "plan" ? plannedRepos || "not applicable" : savedRepos || ((payload.repos ?? []).length > 0 ? "none saved" : "not applicable")
+        },
         { label: "Market pushed", value: payload.rootRepo?.pushed ? "yes" : "no" },
         { label: "Preview action", value: payload.previewAction?.status ?? "skipped" }
       ],
+      sections: result.executionMode === "plan" ? [
+        ...payload.plannedSteps?.length ? [{ title: "Dependency mode transitions", lines: payload.plannedSteps.filter((step) => /workspace-(?:link|unlink)/u.test(String(step.id ?? ""))).map((step) => `- ${step.description ?? step.id}`) }] : [],
+        ...formatSavePlanSections(payload.repositoryPlan)
+      ] : [],
       nextSteps: renderWorkflowNextSteps(result),
       report: result
     });

package/dist/cli/handlers/stage.js

@@ -4,6 +4,7 @@ const handleStage = async (invocation, context) => {
   try {
     const result = await createWorkflowSdk(context).stage({
       message: invocation.positionals.join(" ").trim(),
+      workspaceLinks: typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0,
       plan: invocation.args.plan === true || invocation.args.dryRun === true,
       dryRun: invocation.args.dryRun === true
     });

package/dist/cli/handlers/status-ui.d.ts

@@ -0,0 +1,4 @@
+import type { TreeseedCommandContext } from '../types.js';
+type StatusState = Record<string, any>;
+export declare function renderTreeseedStatusInk(state: StatusState, context?: Pick<TreeseedCommandContext, 'outputFormat' | 'interactiveUi'>): Promise<boolean>;
+export {};

package/dist/cli/handlers/status-ui.js

@@ -0,0 +1,162 @@
+import { Box, render, Text, useApp, useWindowSize } from "ink";
+import React from "react";
+import { truncateLine, wrapText } from "../ui/framework.js";
+const SCOPES = [
+  { id: "local", label: "Local" },
+  { id: "staging", label: "Staging" },
+  { id: "prod", label: "Production" }
+];
+function statusTone(ok, warnings = 0) {
+  if (!ok) return "red";
+  if (warnings > 0) return "yellow";
+  return "green";
+}
+function yesNo(value) {
+  return value ? "yes" : "no";
+}
+function providerText(provider) {
+  if (!provider) return "unknown";
+  if (provider.applicable === false) return provider.detail ?? "not applicable";
+  const base = provider.configured ? "configured" : "missing";
+  if (!provider.live) return base;
+  if (provider.live.skipped) return `${base} / ${provider.live.detail}`;
+  return `${base} / ${provider.live.ready ? "live ok" : "live failed"}`;
+}
+function providerColor(provider) {
+  if (provider?.applicable === false) return "gray";
+  if (!provider?.configured) return "red";
+  if (provider.live && !provider.live.ready && !provider.live.skipped) return "red";
+  if (provider.live?.skipped) return "yellow";
+  return "green";
+}
+function envRows(state, scope, width) {
+  const env = state.environmentStatus?.[scope] ?? state.persistentEnvironments?.[scope] ?? {};
+  const readiness = state.readiness?.[scope] ?? {};
+  const provider = state.providerStatus?.[scope] ?? {};
+  const blockers = Array.isArray(env.blockers) ? env.blockers : readiness.blockers ?? [];
+  const warnings = Array.isArray(env.warnings) ? env.warnings : readiness.warnings ?? [];
+  const providerRows = [
+    { label: "GitHub", value: providerText(provider.github), color: providerColor(provider.github) },
+    { label: "Cloudflare", value: providerText(provider.cloudflare), color: providerColor(provider.cloudflare) },
+    { label: "Railway", value: providerText(provider.railway), color: providerColor(provider.railway) }
+  ];
+  if (scope === "local") {
+    providerRows.push({ label: "Local dev", value: providerText(provider.localDevelopment), color: providerColor(provider.localDevelopment) });
+  }
+  const rows = [
+    { label: "Phase", value: env.phase ?? "pending", color: statusTone(Boolean(env.ready), warnings.length) },
+    { label: "Ready", value: yesNo(Boolean(env.ready)), color: statusTone(Boolean(env.ready), warnings.length) },
+    { label: "Configured", value: yesNo(Boolean(env.configured)), color: env.configured ? "green" : "yellow" },
+    { label: "Initialized", value: yesNo(Boolean(env.initialized)), color: env.initialized ? "green" : "yellow" },
+    { label: "Provisioned", value: yesNo(Boolean(env.provisioned)), color: scope === "local" || env.provisioned ? "green" : "yellow" },
+    { label: "Deployable", value: yesNo(Boolean(env.deployable)), color: env.deployable ? "green" : "yellow" },
+    ...providerRows,
+    { label: "Last deploy", value: env.lastDeploymentTimestamp ?? "(none)", color: env.lastDeploymentTimestamp ? "white" : "gray" },
+    { label: "URL", value: env.lastDeployedUrl ?? "(none)", color: env.lastDeployedUrl ? "cyan" : "gray" }
+  ];
+  const issueRows = [
+    ...blockers.slice(0, 4).map((value) => ({ label: "Blocker", value, color: "red" })),
+    ...warnings.slice(0, 3).map((value) => ({ label: "Warning", value, color: "yellow" }))
+  ];
+  return [...rows, ...issueRows].flatMap((row) => {
+    const prefix = `${row.label}: `;
+    const wrapped = wrapText(String(row.value), Math.max(1, width - prefix.length));
+    return wrapped.map((line, index) => ({
+      text: index === 0 ? `${prefix}${line}` : `${" ".repeat(prefix.length)}${line}`,
+      color: row.color
+    }));
+  });
+}
+function SummaryPanel(props) {
+  const state = props.state;
+  const packageBlockers = state.packageSync?.blockers ?? [];
+  const workflowBlockers = state.workflowControl?.blockers ?? [];
+  const rows = [
+    { label: "Workspace", value: state.workspaceRoot ? state.cwd : "(not a workspace)", color: state.workspaceRoot ? "green" : "red" },
+    { label: "Branch", value: `${state.branchName ?? "(none)"} (${state.branchRole})`, color: state.dirtyWorktree ? "yellow" : "green" },
+    { label: "Environment", value: state.environment, color: state.environment === "none" ? "yellow" : "cyan" },
+    { label: "Worktree", value: state.dirtyWorktree ? "dirty" : "clean", color: state.dirtyWorktree ? "yellow" : "green" },
+    { label: "Packages", value: `${state.packageSync?.mode ?? "unknown"} / ${state.packageSync?.dependencyMode ?? "unknown"}`, color: packageBlockers.length > 0 ? "red" : "green" },
+    { label: "Workflow", value: workflowBlockers.length > 0 ? workflowBlockers.join(" | ") : "no active blockers", color: workflowBlockers.length > 0 ? "red" : "green" },
+    { label: "Secrets", value: state.secrets?.keyAgentRunning ? state.secrets.keyAgentUnlocked ? "agent unlocked" : "agent locked" : "agent stopped", color: state.secrets?.keyAgentUnlocked ? "green" : "yellow" },
+    { label: "Market", value: state.marketConnection?.projectSlug ?? state.marketConnection?.projectId ?? "(not paired)", color: state.marketConnection?.configured ? "green" : "gray" }
+  ];
+  return React.createElement(
+    Box,
+    { flexDirection: "column", borderStyle: "round", borderColor: "cyan", width: props.width, paddingX: 1 },
+    React.createElement(Text, { color: "cyan", bold: true }, truncateLine("Project Status", props.width - 4)),
+    ...rows.map((row) => React.createElement(
+      Text,
+      { key: row.label, color: row.color },
+      truncateLine(`${row.label}: ${row.value}`, props.width - 4)
+    ))
+  );
+}
+function EnvironmentPanel(props) {
+  const env = props.state.environmentStatus?.[props.scope] ?? {};
+  const blockers = env.blockers ?? [];
+  const warnings = env.warnings ?? [];
+  const rows = envRows(props.state, props.scope, props.width - 4);
+  return React.createElement(
+    Box,
+    { flexDirection: "column", borderStyle: "round", borderColor: statusTone(Boolean(env.ready), warnings.length), width: props.width, paddingX: 1 },
+    React.createElement(Text, { color: statusTone(Boolean(env.ready), warnings.length), bold: true }, truncateLine(`${props.label}  ${blockers.length ? "blocked" : warnings.length ? "warning" : "ready"}`, props.width - 4)),
+    ...rows.slice(0, 18).map((row, index) => React.createElement(
+      Text,
+      { key: `${props.scope}-${index}`, color: row.color ?? "white" },
+      truncateLine(row.text, props.width - 4)
+    ))
+  );
+}
+function ServicesPanel(props) {
+  const services = Object.entries(props.state.managedServices ?? {});
+  const nextSteps = Array.isArray(props.state.recommendations) ? props.state.recommendations : [];
+  const serviceRows = services.length > 0 ? services.map(([key, service]) => `${key}: ${service.enabled ? service.initialized ? "deployed" : "not deployed" : "disabled"}${service.lastDeployedUrl ? ` (${service.lastDeployedUrl})` : ""}`) : ["(none)"];
+  const nextRows = nextSteps.length > 0 ? nextSteps.map((step) => `${step.operation}: ${step.reason ?? ""}`) : ["No next steps."];
+  return React.createElement(
+    Box,
+    { flexDirection: "column", borderStyle: "round", borderColor: "gray", width: props.width, paddingX: 1 },
+    React.createElement(Text, { color: "yellow", bold: true }, truncateLine("Services and Next Steps", props.width - 4)),
+    ...serviceRows.slice(0, 6).map((line, index) => React.createElement(Text, { key: `svc-${index}`, color: line.includes("not deployed") ? "yellow" : line.includes("disabled") ? "gray" : "green" }, truncateLine(line, props.width - 4))),
+    ...nextRows.slice(0, 4).map((line, index) => React.createElement(Text, { key: `next-${index}`, color: "cyan" }, truncateLine(`Next: ${line}`, props.width - 4)))
+  );
+}
+function StatusDashboard(props) {
+  const { exit } = useApp();
+  const windowSize = useWindowSize();
+  const width = Math.max(72, windowSize?.columns ?? 100);
+  const stacked = width < 118;
+  const columnWidth = stacked ? width : Math.max(28, Math.floor((width - 2) / 3));
+  React.useEffect(() => {
+    const timer = setTimeout(() => exit(), 20);
+    return () => clearTimeout(timer);
+  }, [exit]);
+  return React.createElement(
+    Box,
+    { flexDirection: "column", width },
+    React.createElement(SummaryPanel, { state: props.state, width }),
+    React.createElement(
+      Box,
+      { flexDirection: stacked ? "column" : "row", width },
+      ...SCOPES.map((scope) => React.createElement(EnvironmentPanel, {
+        key: scope.id,
+        state: props.state,
+        scope: scope.id,
+        label: scope.label,
+        width: columnWidth
+      }))
+    ),
+    React.createElement(ServicesPanel, { state: props.state, width })
+  );
+}
+async function renderTreeseedStatusInk(state, context = {}) {
+  if (context.outputFormat === "json" || context.interactiveUi === false || !process.stdout.isTTY) {
+    return false;
+  }
+  const instance = render(React.createElement(StatusDashboard, { state }), { exitOnCtrlC: false });
+  await instance.waitUntilExit();
+  return true;
+}
+export {
+  renderTreeseedStatusInk
+};

package/dist/cli/handlers/status.js

@@ -1,67 +1,116 @@
 import { guidedResult } from "./utils.js";
 import { createWorkflowSdk, renderWorkflowNextSteps, workflowErrorResult } from "./workflow.js";
-const handleStatus = async (_invocation, context) => {
+import { renderTreeseedStatusInk } from "./status-ui.js";
+const SCOPES = [
+  { id: "local", label: "Local" },
+  { id: "staging", label: "Staging" },
+  { id: "prod", label: "Production" }
+];
+function yesNo(value) {
+  return value ? "yes" : "no";
+}
+function providerSummary(provider) {
+  if (!provider) return "unknown";
+  if (provider.applicable === false) return provider.detail ?? "not applicable";
+  const configured = provider.configured ? "configured" : "missing";
+  if (!provider.live) return configured;
+  if (provider.live.skipped) return `${configured}, skipped: ${provider.live.detail}`;
+  return `${configured}, ${provider.live.ready ? "live ok" : `live failed: ${provider.live.detail}`}`;
+}
+function environmentLines(state, scope) {
+  const env = state.environmentStatus?.[scope] ?? state.persistentEnvironments?.[scope] ?? {};
+  const providers = state.providerStatus?.[scope] ?? {};
+  const blockers = Array.isArray(env.blockers) ? env.blockers : [];
+  const warnings = Array.isArray(env.warnings) ? env.warnings : [];
+  const providerLines = [
+    `GitHub: ${providerSummary(providers.github)}`,
+    `Cloudflare: ${providerSummary(providers.cloudflare)}`,
+    `Railway: ${providerSummary(providers.railway)}`
+  ];
+  if (scope === "local") {
+    providerLines.push(`Local development: ${providerSummary(providers.localDevelopment)}`);
+  }
+  return [
+    `Phase: ${env.phase ?? "pending"}`,
+    `Ready: ${yesNo(Boolean(env.ready))}`,
+    `Configured: ${yesNo(Boolean(env.configured))}`,
+    `Initialized: ${yesNo(Boolean(env.initialized))}`,
+    `Provisioned: ${yesNo(Boolean(env.provisioned))}`,
+    `Deployable: ${yesNo(Boolean(env.deployable))}`,
+    ...providerLines,
+    `Last deploy: ${env.lastDeploymentTimestamp ?? "(none)"}`,
+    `URL: ${env.lastDeployedUrl ?? "(none)"}`,
+    ...blockers.length > 0 ? blockers.map((blocker) => `BLOCKER: ${blocker}`) : ["Blockers: none"],
+    ...warnings.length > 0 ? warnings.map((warning) => `WARNING: ${warning}`) : ["Warnings: none"]
+  ];
+}
+function statusFacts(state, live) {
+  return [
+    { label: "Mode", value: live ? "saved state + live provider checks" : "saved state" },
+    { label: "Workspace root", value: state.workspaceRoot ? "yes" : "no" },
+    { label: "Tenant config present", value: state.deployConfigPresent ? "yes" : "no" },
+    { label: "Branch", value: state.branchName ?? "(none)" },
+    { label: "Branch role", value: state.branchRole },
+    { label: "Mapped environment", value: state.environment },
+    { label: "Dirty worktree", value: state.dirtyWorktree ? "yes" : "no" },
+    { label: "Package mode", value: state.packageSync.mode },
+    { label: "Dependency mode", value: state.packageSync.dependencyMode ?? "(unknown)" },
+    { label: "Full package checkout", value: state.packageSync.completeCheckout ? "yes" : "no" },
+    { label: "Package branch aligned", value: state.packageSync.aligned ? "yes" : "no" },
+    { label: "Dirty package repos", value: state.packageSync.dirty ? "yes" : "no" },
+    { label: "Package blockers", value: state.packageSync.blockers.length > 0 ? state.packageSync.blockers.join(" | ") : "(none)" },
+    { label: "Preview enabled", value: state.preview.enabled ? "yes" : "no" },
+    { label: "Preview URL", value: state.preview.url ?? "(none)" },
+    { label: "Remote API auth", value: state.auth.remoteApi ? "ready" : "not ready" },
+    { label: "Wrapped machine key", value: state.secrets.wrappedKeyPresent ? "present" : "missing" },
+    { label: "Key migration", value: state.secrets.migrationRequired ? "required" : "not needed" },
+    { label: "Key agent", value: state.secrets.keyAgentRunning ? state.secrets.keyAgentUnlocked ? "running/unlocked" : "running/locked" : "stopped" },
+    { label: "Startup passphrase env", value: state.secrets.startupPassphraseConfigured ? "configured" : "unset" },
+    { label: "Market project", value: state.marketConnection.projectSlug ?? state.marketConnection.projectId ?? "(not paired)" },
+    { label: "Market team", value: state.marketConnection.teamSlug ?? state.marketConnection.teamId ?? "(not paired)" },
+    { label: "Market mode", value: state.marketConnection.connectionMode ?? "(not paired)" },
+    { label: "Hub mode", value: state.marketConnection.hubMode ?? "(unknown)" },
+    { label: "Runtime mode", value: state.marketConnection.runtimeMode ?? "(unknown)" },
+    { label: "Runtime registration", value: state.marketConnection.runtimeRegistration ?? "(none)" },
+    { label: "Runtime ready", value: state.marketConnection.runtimeReady ? "yes" : "no" },
+    { label: "Current workstream", value: state.marketConnection.currentWorkstreamId ?? "(none)" },
+    { label: "Approval blockers", value: state.marketConnection.approvalBlockers.length > 0 ? state.marketConnection.approvalBlockers.join(" | ") : "(none)" }
+  ];
+}
+const handleStatus = async (invocation, context) => {
   try {
-    const result = await createWorkflowSdk(context).status();
+    const live = invocation.args.live === true;
+    const result = await createWorkflowSdk(context).status({ live });
     const state = result.payload;
+    const nextSteps = renderWorkflowNextSteps(result);
+    const report = {
+      ...result,
+      state,
+      live
+    };
+    if (await renderTreeseedStatusInk(state, context)) {
+      return {
+        exitCode: 0,
+        stdout: [],
+        report
+      };
+    }
     return guidedResult({
       command: "status",
       summary: "Treeseed workflow status",
-      facts: [
-        { label: "Workspace root", value: state.workspaceRoot ? "yes" : "no" },
-        { label: "Tenant config present", value: state.deployConfigPresent ? "yes" : "no" },
-        { label: "Branch", value: state.branchName ?? "(none)" },
-        { label: "Branch role", value: state.branchRole },
-        { label: "Mapped environment", value: state.environment },
-        { label: "Dirty worktree", value: state.dirtyWorktree ? "yes" : "no" },
-        { label: "Package mode", value: state.packageSync.mode },
-        { label: "Full package checkout", value: state.packageSync.completeCheckout ? "yes" : "no" },
-        { label: "Package branch aligned", value: state.packageSync.aligned ? "yes" : "no" },
-        { label: "Dirty package repos", value: state.packageSync.dirty ? "yes" : "no" },
-        { label: "Package blockers", value: state.packageSync.blockers.length > 0 ? state.packageSync.blockers.join(" | ") : "(none)" },
-        { label: "Local state", value: state.persistentEnvironments.local.phase },
-        { label: "Staging state", value: state.persistentEnvironments.staging.phase },
-        { label: "Prod state", value: state.persistentEnvironments.prod.phase },
-        { label: "Local initialized", value: state.persistentEnvironments.local.initialized ? "yes" : "no" },
-        { label: "Staging initialized", value: state.persistentEnvironments.staging.initialized ? "yes" : "no" },
-        { label: "Prod initialized", value: state.persistentEnvironments.prod.initialized ? "yes" : "no" },
-        { label: "Staging blockers", value: state.persistentEnvironments.staging.blockers.length > 0 ? state.persistentEnvironments.staging.blockers.join(" | ") : "(none)" },
-        { label: "Prod blockers", value: state.persistentEnvironments.prod.blockers.length > 0 ? state.persistentEnvironments.prod.blockers.join(" | ") : "(none)" },
-        { label: "Preview enabled", value: state.preview.enabled ? "yes" : "no" },
-        { label: "Preview URL", value: state.preview.url ?? "(none)" },
-        { label: "GitHub token/config", value: state.auth.gh ? "configured" : "missing" },
-        { label: "Cloudflare token/config", value: state.auth.wrangler ? "configured" : "missing" },
-        { label: "Railway token/config", value: state.auth.railway ? "configured" : "missing" },
-        { label: "Remote API auth", value: state.auth.remoteApi ? "ready" : "not ready" },
-        { label: "Wrapped machine key", value: state.secrets.wrappedKeyPresent ? "present" : "missing" },
-        { label: "Key migration", value: state.secrets.migrationRequired ? "required" : "not needed" },
-        { label: "Key agent", value: state.secrets.keyAgentRunning ? state.secrets.keyAgentUnlocked ? "running/unlocked" : "running/locked" : "stopped" },
-        { label: "Startup passphrase env", value: state.secrets.startupPassphraseConfigured ? "configured" : "unset" },
-        { label: "Market project", value: state.marketConnection.projectSlug ?? state.marketConnection.projectId ?? "(not paired)" },
-        { label: "Market team", value: state.marketConnection.teamSlug ?? state.marketConnection.teamId ?? "(not paired)" },
-        { label: "Market mode", value: state.marketConnection.connectionMode ?? "(not paired)" },
-        { label: "Hub mode", value: state.marketConnection.hubMode ?? "(unknown)" },
-        { label: "Runtime mode", value: state.marketConnection.runtimeMode ?? "(unknown)" },
-        { label: "Runtime registration", value: state.marketConnection.runtimeRegistration ?? "(none)" },
-        { label: "Runtime ready", value: state.marketConnection.runtimeReady ? "yes" : "no" },
-        { label: "Web cache host", value: state.webCache.webHost ?? "(none)" },
-        { label: "Content cache host", value: state.webCache.contentHost ?? "(none)" },
-        { label: "Source page cache", value: state.webCache.sourcePagePolicy ?? "(none)" },
-        { label: "Content page cache", value: state.webCache.contentPagePolicy ?? "(none)" },
-        { label: "R2 object cache", value: state.webCache.r2ObjectPolicy ?? "(none)" },
-        { label: "Cloudflare cache rules", value: state.webCache.cloudflareRulesManaged ? "managed" : "not managed" },
-        { label: "Last deploy purge", value: state.webCache.lastDeployPurgeAt ? `${state.webCache.lastDeployPurgeAt} (${state.webCache.lastDeployPurgeCount ?? 0} urls)` : "(none)" },
-        { label: "Last content purge", value: state.webCache.lastContentPurgeAt ? `${state.webCache.lastContentPurgeAt} (${state.webCache.lastContentPurgeCount ?? 0} urls)` : "(none)" },
-        { label: "Current workstream", value: state.marketConnection.currentWorkstreamId ?? "(none)" },
-        { label: "Approval blockers", value: state.marketConnection.approvalBlockers.length > 0 ? state.marketConnection.approvalBlockers.join(" | ") : "(none)" },
-        { label: "API service", value: state.managedServices.api.enabled ? `${state.managedServices.api.initialized ? "deployed" : "not deployed"}${state.managedServices.api.lastDeployedUrl ? ` (${state.managedServices.api.lastDeployedUrl})` : ""}` : "disabled" },
-        { label: "Worker service", value: state.managedServices.worker.enabled ? `${state.managedServices.worker.initialized ? "deployed" : "not deployed"}${state.managedServices.worker.lastDeployedUrl ? ` (${state.managedServices.worker.lastDeployedUrl})` : ""}` : "disabled" }
+      facts: statusFacts(state, live),
+      sections: [
+        ...SCOPES.map((scope) => ({
+          title: scope.label,
+          lines: environmentLines(state, scope.id)
+        })),
+        {
+          title: "Managed services",
+          lines: Object.entries(state.managedServices ?? {}).map(([name, service]) => `${name}: ${service.enabled ? service.initialized ? "deployed" : "not deployed" : "disabled"}${service.lastDeployedUrl ? ` (${service.lastDeployedUrl})` : ""}`)
+        }
       ],
-      nextSteps: renderWorkflowNextSteps(result),
-      report: {
-        ...result,
-        state
-      }
+      nextSteps,
+      report
     });
   } catch (error) {
     return workflowErrorResult(error);

package/dist/cli/handlers/switch.js

@@ -6,6 +6,7 @@ const handleSwitch = async (invocation, context) => {
     const result = await createWorkflowSdk(context).switchTask({
       branch,
       preview: invocation.args.preview === true,
+      workspaceLinks: typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0,
       plan: invocation.args.plan === true || invocation.args.dryRun === true,
       dryRun: invocation.args.dryRun === true
     });

package/dist/cli/handlers/utils.d.ts

@@ -8,6 +8,10 @@ type GuidedResultOptions = {
         label: string;
         value: string | number | boolean | null | undefined;
     }>;
+    sections?: Array<{
+        title: string;
+        lines: string[];
+    }>;
     nextSteps?: string[];
     report?: Record<string, unknown> | null;
     exitCode?: number;

package/dist/cli/handlers/utils.js

@@ -13,6 +13,11 @@ function guidedResult(options) {
       lines.push(`${fact.label}: ${fact.value}`);
     }
   }
+  for (const section of options.sections ?? []) {
+    const sectionLines = section.lines.filter((line) => line.length > 0);
+    if (sectionLines.length === 0) continue;
+    lines.push("", `${section.title}:`, ...sectionLines);
+  }
   if ((options.nextSteps ?? []).length > 0) {
     lines.push("", "Next steps:");
     for (const step of options.nextSteps ?? []) {
@@ -25,12 +30,14 @@ function guidedResult(options) {
     ok: (options.exitCode ?? 0) === 0,
     summary: options.summary,
     facts: facts.map((fact) => ({ label: fact.label, value: fact.value })),
+    sections: options.sections ?? [],
     nextSteps: options.nextSteps ?? []
   } : {
     command: options.command,
     ok: (options.exitCode ?? 0) === 0,
     summary: options.summary,
     facts: facts.map((fact) => ({ label: fact.label, value: fact.value })),
+    sections: options.sections ?? [],
     nextSteps: options.nextSteps ?? []
   };
   return {

package/dist/cli/handlers/workflow.js

@@ -104,8 +104,10 @@ function renderWorkflowNextStep(step) {
   switch (step.operation) {
     case "switch":
       return `treeseed switch ${String(input.branch ?? "feature/my-change")}${input.preview ? " --preview" : ""}`;
-    case "save":
-      return `treeseed save "${String(input.message ?? "describe your change")}"${input.hotfix ? " --hotfix" : ""}`;
+    case "save": {
+      const message = String(input.message ?? "").trim();
+      return `treeseed save${message ? ` "${message}"` : ""}${input.hotfix ? " --hotfix" : ""}`;
+    }
     case "close":
       return `treeseed close "${String(input.message ?? "reason")}"`;
     case "stage":

package/dist/cli/handlers/workspace.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleWorkspace: TreeseedCommandHandler;

package/dist/cli/handlers/workspace.js

@@ -0,0 +1,51 @@
+import {
+  ensureLocalWorkspaceLinks,
+  findNearestTreeseedWorkspaceRoot,
+  inspectWorkspaceDependencyMode,
+  unlinkLocalWorkspaceLinks
+} from "@treeseed/sdk/workflow-support";
+import { guidedResult } from "./utils.js";
+import { workflowErrorResult } from "./workflow.js";
+const workspaceCommand = (name) => `workspace${":"}${name}`;
+function workspaceRootOrThrow(cwd) {
+  const root = findNearestTreeseedWorkspaceRoot(cwd);
+  if (!root) {
+    throw new Error("Treeseed workspace commands must run inside a workspace with checked-out packages.");
+  }
+  return root;
+}
+function facts(report) {
+  return [
+    { label: "Dependency mode", value: report.mode },
+    { label: "Workspace links enabled", value: report.enabled ? "yes" : "no" },
+    { label: "Links", value: String(report.links.length) },
+    { label: "Linked", value: String(report.links.filter((link) => link.linked && link.targetMatches).length) },
+    { label: "Created", value: String(report.created.length) },
+    { label: "Removed", value: String(report.removed.length) },
+    { label: "Issues", value: report.issues.length > 0 ? report.issues.join(" | ") : "(none)" }
+  ];
+}
+const handleWorkspace = async (invocation, context) => {
+  try {
+    const root = workspaceRootOrThrow(context.cwd);
+    const linkCommand = workspaceCommand("link");
+    const unlinkCommand = workspaceCommand("unlink");
+    const statusCommand = workspaceCommand("status");
+    const report = invocation.commandName === linkCommand ? ensureLocalWorkspaceLinks(root, { env: context.env }) : invocation.commandName === unlinkCommand ? unlinkLocalWorkspaceLinks(root, { env: context.env }) : inspectWorkspaceDependencyMode(root, { env: context.env });
+    return guidedResult({
+      command: invocation.commandName || statusCommand,
+      summary: invocation.commandName === linkCommand ? "Treeseed local workspace links are ready." : invocation.commandName === unlinkCommand ? "Treeseed local workspace links were removed." : "Treeseed workspace dependency mode",
+      facts: facts(report),
+      report: {
+        ok: true,
+        command: invocation.commandName || statusCommand,
+        payload: report
+      }
+    });
+  } catch (error) {
+    return workflowErrorResult(error);
+  }
+};
+export {
+  handleWorkspace
+};

package/dist/cli/operations-registry.js

@@ -5,6 +5,7 @@ import {
 function command(overlay) {
   return overlay;
 }
+const workspaceCommand = (name) => `workspace${":"}${name}`;
 function example(commandLine, title, description, extras = {}) {
   return {
     command: commandLine,
@@ -133,8 +134,11 @@ function mergeHelpSpec(metadata, overlay, spec) {
 const PASS_THROUGH_ARGS = (invocation) => ({ args: invocation.rawArgs });
 const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
   ["status", command({
-    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
-    examples: ["treeseed status", "treeseed status --json"],
+    options: [
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" },
+      { name: "live", flags: "--live", description: "Run read-only provider connectivity checks and include the results in status.", kind: "boolean" }
+    ],
+    examples: ["treeseed status", "treeseed status --json", "treeseed status --live"],
     help: {
       workflowPosition: "inspect",
       longSummary: [
@@ -147,6 +151,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
       ],
       beforeYouRun: [
         "Run from the workspace you want to inspect.",
+        "Use `--live` only when you want read-only provider connectivity checks in addition to saved state.",
         "Choose `--json` when another tool or agent needs to read the status programmatically."
       ],
       outcomes: [
@@ -156,6 +161,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
       examples: [
         example("treeseed status", "Check the current task state", "Show the current branch role and project health in human-readable form."),
         example("treeseed status --json", "Feed an agent or script", "Emit structured status data for automation and external tooling."),
+        example("treeseed status --live", "Check provider connectivity", "Include read-only GitHub, Cloudflare, and Railway identity checks in the status report."),
         example("trsd status", "Use the short alias", "Run the same status inspection path through the shorter CLI entrypoint.")
       ],
       automationNotes: [
@@ -202,6 +208,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     arguments: [{ name: "branch-name", description: "Task branch to create or resume.", required: true }],
     options: [
       { name: "preview", flags: "--preview", description: "Provision or refresh a branch-scoped Cloudflare preview environment.", kind: "boolean" },
+      { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] },
       { name: "plan", flags: "--plan", description: "Compute the recursive branch switch plan without mutating any repo.", kind: "boolean" },
       { name: "dryRun", flags: "--dry-run", description: "Alias for --plan.", kind: "boolean" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
@@ -250,15 +257,16 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     handlerName: "switch"
   })],
   ["save", command({
-    arguments: [{ name: "message", description: "Git commit message for the save operation.", required: true, kind: "message_tail" }],
+    arguments: [{ name: "message", description: "Optional hint for generated save commit messages.", required: false, kind: "message_tail" }],
     options: [
       { name: "hotfix", flags: "--hotfix", description: "Allow save on main for an explicit hotfix.", kind: "boolean" },
       { name: "preview", flags: "--preview", description: "Create or refresh the branch preview during save.", kind: "boolean" },
+      { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] },
       { name: "plan", flags: "--plan", description: "Compute the recursive save plan without mutating any repo.", kind: "boolean" },
       { name: "dryRun", flags: "--dry-run", description: "Alias for --plan.", kind: "boolean" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
     ],
-    examples: ['treeseed save "feat: add search filters"', 'treeseed save --preview "feat: add search filters"', 'treeseed save --plan "feat: add search filters"', 'treeseed save --hotfix "fix: unblock production form submit"'],
+    examples: ["treeseed save", 'treeseed save "add search filters"', "treeseed save --preview", "treeseed save --plan", 'treeseed save --hotfix "fix production form submit"'],
     help: {
       workflowPosition: "checkpoint work",
       longSummary: [
@@ -272,17 +280,18 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
       ],
       beforeYouRun: [
         "Run from a task branch unless you intentionally mean to use the hotfix path.",
-        "Provide a commit message that captures the checkpoint clearly because Treeseed will use it for the save commit."
+        "Optionally provide a short hint; Treeseed generates the final commit message from the diff and hint."
       ],
       outcomes: [
-        "Verifies and commits current work using the provided message.",
+        "Verifies and commits current work using a generated commit message.",
         "Syncs and pushes branch state.",
         "Optionally refreshes preview infrastructure if requested."
       ],
       examples: [
-        example('treeseed save "feat: add search filters"', "Standard task checkpoint", "Verify, commit, and push the current task branch with a descriptive message."),
-        example('treeseed save --preview "feat: add search filters"', "Checkpoint plus preview refresh", "Include preview refresh when the save should update the branch environment."),
-        example('treeseed save --hotfix "fix: unblock production form submit"', "Explicit hotfix save", "Allow a save from main when the work is a deliberate hotfix path.", { why: "Use sparingly and only when the workflow intentionally bypasses the usual task-branch rule." })
+        example("treeseed save", "Generated checkpoint", "Verify, commit, and push the current task branch with a generated message."),
+        example('treeseed save "add search filters"', "Checkpoint with a hint", "Feed a short hint into commit-message generation without replacing the generated message."),
+        example("treeseed save --preview", "Checkpoint plus preview refresh", "Include preview refresh when the save should update the branch environment."),
+        example('treeseed save --hotfix "fix production form submit"', "Explicit hotfix save", "Allow a save from main when the work is a deliberate hotfix path.", { why: "Use sparingly and only when the workflow intentionally bypasses the usual task-branch rule." })
       ],
       warnings: [
         "`--hotfix` deliberately loosens the normal task-branch safety model. Keep it exceptional."
@@ -300,6 +309,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     arguments: [{ name: "message", description: "Reason for closing the task without staging it.", required: true, kind: "message_tail" }],
     options: [
       { name: "plan", flags: "--plan", description: "Compute the recursive close plan without mutating any repo.", kind: "boolean" },
+      { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] },
       { name: "dryRun", flags: "--dry-run", description: "Alias for --plan.", kind: "boolean" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
     ],
@@ -338,6 +348,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     arguments: [{ name: "message", description: "Resolution message for the staged task.", required: true, kind: "message_tail" }],
     options: [
       { name: "plan", flags: "--plan", description: "Compute the recursive staging plan without mutating any repo.", kind: "boolean" },
+      { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] },
       { name: "dryRun", flags: "--dry-run", description: "Alias for --plan.", kind: "boolean" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
     ],
@@ -420,6 +431,24 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     executionMode: "handler",
     handlerName: "recover"
   })],
+  [workspaceCommand("status"), command({
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ["treeseed workspace:status"],
+    executionMode: "handler",
+    handlerName: workspaceCommand("status")
+  })],
+  [workspaceCommand("link"), command({
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ["treeseed workspace:link"],
+    executionMode: "handler",
+    handlerName: workspaceCommand("link")
+  })],
+  [workspaceCommand("unlink"), command({
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ["treeseed workspace:unlink"],
+    executionMode: "handler",
+    handlerName: workspaceCommand("unlink")
+  })],
   ["rollback", command({
     arguments: [{ name: "environment", description: "The persistent environment to roll back.", required: true }],
     options: [
@@ -492,6 +521,40 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     executionMode: "handler",
     handlerName: "doctor"
   })],
+  ["install", command({
+    options: [
+      { name: "force", flags: "--force", description: "Repair or reinstall managed tools even when they are already present.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed install", "trsd install --json", "treeseed install --force"],
+    help: {
+      workflowPosition: "setup",
+      longSummary: [
+        "Install prepares the local Treeseed toolchain by installing or verifying Treeseed-managed dependencies. It is safe to rerun and uses the same dependency initializer that config runs during bootstrap."
+      ],
+      whenToUse: [
+        "Use this on a new machine before running config, dev, or deployment workflows.",
+        "Use `--force` when a managed tool cache looks stale or corrupted."
+      ],
+      outcomes: [
+        "Installs the managed GitHub CLI, verifies npm-backed Treeseed tool dependencies, and installs gh-act when Docker is available.",
+        "Reports any missing host prerequisites such as Git without modifying the operating system."
+      ],
+      examples: [
+        example("treeseed install", "Install managed dependencies", "Prepare the local Treeseed dependency toolchain."),
+        example("trsd install --json", "Inspect setup from automation", "Emit a structured dependency report for scripts or agents."),
+        example("treeseed install --force", "Repair the managed cache", "Reinstall managed downloaded tools and extensions.")
+      ],
+      relatedDetails: [
+        related("config", "Use `config` after install to configure project and provider values."),
+        related("doctor", "Use `doctor` when install succeeds but workflow readiness still looks wrong.")
+      ]
+    },
+    executionMode: "adapter",
+    buildAdapterInput: (invocation) => ({
+      force: invocation.args.force === true
+    })
+  })],
   ["auth:login", command({
     options: [
       { name: "host", flags: "--host <id>", description: "Override the configured remote host id for this login.", kind: "string" },
@@ -842,6 +905,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
       { name: "major", flags: "--major", description: "Bump to the next major version.", kind: "boolean" },
       { name: "minor", flags: "--minor", description: "Bump to the next minor version.", kind: "boolean" },
       { name: "patch", flags: "--patch", description: "Bump to the next patch version.", kind: "boolean" },
+      { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] },
       { name: "plan", flags: "--plan", description: "Compute the recursive release plan without mutating any repo.", kind: "boolean" },
       { name: "dryRun", flags: "--dry-run", description: "Alias for --plan.", kind: "boolean" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
@@ -931,6 +995,9 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     handlerName: "destroy"
   })],
   ["dev", command({
+    options: [
+      { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] }
+    ],
     examples: ["treeseed dev"],
     help: {
       longSummary: ["Dev starts the unified local Treeseed runtime so you can work against the integrated web, API, and supporting local surfaces."],
@@ -944,6 +1011,9 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     handlerName: "dev"
   })],
   ["dev:watch", command({
+    options: [
+      { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] }
+    ],
     examples: ["treeseed dev:watch"],
     help: {
       longSummary: ["Dev:watch starts local development with rebuild and watch semantics so code changes are reflected continuously during active development."],

package/dist/cli/registry.d.ts

@@ -1,5 +1,6 @@
 import type { TreeseedCommandSpec } from './operations-types.js';
 export declare const COMMAND_HANDLERS: {
+    readonly [x: string]: import("./operations-types.js").TreeseedCommandHandler;
     readonly init: import("./operations-types.js").TreeseedCommandHandler;
     readonly config: import("./operations-types.js").TreeseedCommandHandler;
     readonly close: import("./operations-types.js").TreeseedCommandHandler;

package/dist/cli/registry.js

@@ -32,6 +32,8 @@ import { handleStage } from "./handlers/stage.js";
 import { handleExport } from "./handlers/export.js";
 import { handleResume } from "./handlers/resume.js";
 import { handleRecover } from "./handlers/recover.js";
+import { handleWorkspace } from "./handlers/workspace.js";
+const workspaceCommand = (name) => `workspace${":"}${name}`;
 const COMMAND_HANDLERS = {
   init: handleInit,
   config: handleConfig,
@@ -51,6 +53,9 @@ const COMMAND_HANDLERS = {
   stage: handleStage,
   resume: handleResume,
   recover: handleRecover,
+  [workspaceCommand("status")]: handleWorkspace,
+  [workspaceCommand("link")]: handleWorkspace,
+  [workspaceCommand("unlink")]: handleWorkspace,
   export: handleExport,
   "auth:login": handleAuthLogin,
   "auth:logout": handleAuthLogout,

package/dist/cli/runtime.js

@@ -54,8 +54,13 @@ function colorizeTreeseedCliOutput(output, colorEnabled = true) {
   if (!colorEnabled) {
     return output;
   }
-  return output.replace(/^((?:\[[^\]]+\]){3,4})(\s|$)/u, (match, prefix, suffix) => {
+  return output.replace(/^((?:\[[^\]]+\]){2,4})(\s|$)/u, (match, prefix, suffix) => {
     const segments = [...prefix.matchAll(/\[([^\]]+)\]/gu)].map((entry) => entry[1]);
+    if (segments.length === 2) {
+      const stage2 = segments[1] ?? "";
+      const code2 = /fail|error/iu.test(stage2) ? "31;1" : /skip/iu.test(stage2) ? "90;1" : "32;1";
+      return `\x1B[${code2}m${prefix}\x1B[0m${suffix}`;
+    }
     const system = segments[1] ?? "";
     const stage = segments[segments.length - 1] ?? "";
     const code = /fail|error/iu.test(stage) ? "31;1" : /skip/iu.test(stage) ? "90;1" : colorCodeForBootstrapSystem(system);
@@ -226,20 +231,24 @@ class TreeseedOperationsSdk {
       rawArgs: argv
     };
     const input = spec.buildAdapterInput?.(invocation, context) ?? {};
+    const adapterContext = {
+      ...context,
+      outputFormat: invocation.args.json === true ? "json" : context.outputFormat ?? "human"
+    };
     return sdkOperationsRuntime.execute(
       { operationName: spec.name, input },
       {
-        cwd: context.cwd,
-        env: context.env,
-        write: context.write,
-        spawn: context.spawn,
-        outputFormat: context.outputFormat,
+        cwd: adapterContext.cwd,
+        env: adapterContext.env,
+        write: adapterContext.write,
+        spawn: adapterContext.spawn,
+        outputFormat: adapterContext.outputFormat,
         transport: "cli"
       }
-    ).then((result) => writeTreeseedResult(result, context)).catch((error) => writeTreeseedResult({
+    ).then((result) => writeTreeseedResult(result, adapterContext)).catch((error) => writeTreeseedResult({
       exitCode: 1,
       stderr: [error instanceof Error ? error.message : String(error)]
-    }, context));
+    }, adapterContext));
   }
   async executeAgents(argv, context) {
     try {
@@ -321,7 +330,7 @@ function formatProjectError(spec) {
   ].join("\n");
 }
 function commandNeedsProjectRoot(spec) {
-  return spec.name !== "init" && spec.name !== "export";
+  return spec.name !== "init" && spec.name !== "export" && spec.name !== "install";
 }
 function resolveTreeseedCommandCwd(spec, cwd) {
   if (!commandNeedsProjectRoot(spec)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/cli",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Operator-facing Treeseed CLI package.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -33,6 +33,7 @@
     "lint": "npm run build:dist",
     "test": "npm run build:dist && node --test --test-concurrency=1 ./scripts/treeseed-help.test.mjs ./scripts/wrapper-package.test.mjs",
     "build:dist": "node ./scripts/run-ts.mjs ./scripts/build-dist.ts",
+    "prepare": "node ./scripts/prepare.mjs",
     "prepack": "npm run build:dist",
     "verify:direct": "npm run release:verify",
     "verify:local": "node --input-type=module -e \"process.env.TREESEED_VERIFY_DRIVER='direct'; await import('./scripts/verify-driver.mjs')\"",
@@ -44,7 +45,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "^0.6.7",
+    "@treeseed/sdk": "0.6.8",
     "ink": "^7.0.0",
     "react": "^19.2.5"
   },