@tuned-tensor/cli 0.20.0 → 0.22.0

package/dist/index.js

@@ -1,22 +1,34 @@
 #!/usr/bin/env node
 import {
+  DECISION_MODELS,
   DEFAULT_ARTIFACT_ROOT,
+  DEFAULT_DECISION_RUNS_DIR,
   DEFAULT_FOUNDATION_RUNS_DIR,
   DEFAULT_PROJECT_STORE_ROOT,
   TRAINING_MODELS,
   assertFoundationSettingsMatch,
   assessHardware,
+  auditRun,
+  buildDecisionPythonCommand,
   buildFoundationPythonCommand,
   buildSystemMessage,
   canonicalFoundationPipeline,
   canonicalJson,
   canonicalPipeline,
+  compareEvalReports,
   configForSpec,
   createExecutionPlan,
   createLocalStore,
+  createRunConsoleReporter,
+  decisionLabels,
   defaultLocalHome,
   defaultStoreRoot,
+  deriveSampleSeed,
+  ensureDatasetCached,
+  evalReportSchema,
+  evaluateCapabilities,
   expandUserPath,
+  fileUri,
   formatAgentHostBlock,
   formatHostStatusLine,
   getAgentConfigDir,
@@ -32,24 +44,27 @@ import {
   pipelineForRunInput,
   pipelineFromFoundationHyperparameters,
   readHardwareSnapshot,
+  resolveDecisionModel,
   resolveProjectConfig,
   runGpuProcess,
   runLocalPipeline,
   runLoggedProcess,
   runReportSchema,
   specHash,
+  splitSpecExamples,
   validateBehaviorSpec,
   validateEvalCases,
   validatePipeline,
   warningsFromSnapshot,
+  withDecisionPythonEnvironment,
   withFoundationPythonEnvironment
-} from "./chunk-4Q54NHKR.js";
+} from "./chunk-4SUXBHIY.js";
 
 // src/cli.ts
 import { spawn as spawn4 } from "child_process";
 import { constants as osConstants2 } from "os";
 import { Command } from "commander";
-import chalk10 from "chalk";
+import chalk13 from "chalk";
 
 // src/local-agent-client.ts
 import { randomUUID as randomUUID5 } from "crypto";
@@ -75,15 +90,18 @@ var FolderName = Type.String({
   description: "One new folder name directly beneath the current workspace"
 });
 var LocalBaseModel = Type.String({
-  type: "string",
-  enum: TRAINING_MODELS.map((model) => model.id)
+  minLength: 3,
+  maxLength: 193,
+  pattern: "^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$",
+  description: `Hugging Face repo id. Certified adapter models: ${TRAINING_MODELS.map((model) => model.id).join(", ")}. Decision models: ${DECISION_MODELS.map((model) => model.id).join(", ")}. Other adapter repos require hyperparameters.base_model_revision (40-character commit SHA).`
 });
 var NonEmptyText = Type.String({ minLength: 1, maxLength: 1e3 });
 var LocalProjectSpecSchema = Type.Object({
   name: Type.String({ minLength: 1, maxLength: 255 }),
   description: Type.Optional(Type.String({ maxLength: 5e3 })),
   base_model: Type.Optional(LocalBaseModel),
-  engine: Type.Optional(Type.Union([Type.Literal("adapter"), Type.Literal("foundation")])),
+  engine: Type.Optional(Type.Union([Type.Literal("adapter"), Type.Literal("foundation"), Type.Literal("decision")])),
+  decision: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
   hyperparameters: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
   foundation: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
   dataset_prebuilt: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
@@ -335,6 +353,7 @@ var EDIT_KEYS = /* @__PURE__ */ new Set([
   "base_model",
   "hyperparameters",
   "foundation",
+  "decision",
   "dataset_prebuilt",
   "runtime",
   "evaluation",
@@ -774,7 +793,7 @@ async function prepareLocalPipelineAction(args2) {
     specPath: spec.displayPath,
     specSha256: createHash2("sha256").update(spec.source).digest("hex"),
     dryRun,
-    engine: input.kind === "foundation-spec" ? "foundation" : "adapter",
+    engine: input.kind === "foundation-spec" ? "foundation" : input.kind === "decision-spec" ? "decision" : "adapter",
     resolvedSpec: input.spec,
     resolvedConfig,
     ...config ? {
@@ -1534,9 +1553,16 @@ function canonicalizeHostedBaseModel(model) {
   }
   return canonical;
 }
+var HUGGING_FACE_REPO_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,95}\/[A-Za-z0-9][A-Za-z0-9._-]{0,95}$/;
+function canonicalizeLocalBaseModel(model) {
+  if (typeof model === "string" && HUGGING_FACE_REPO_ID.test(model.trim())) {
+    return BASE_MODEL_ALIASES.get(model.trim().toLowerCase()) ?? model.trim();
+  }
+  return canonicalizeBaseModel(model);
+}
 function canonicalizeSpecBaseModel(body) {
   if ("base_model" in body && body.base_model !== void 0) {
-    return { ...body, base_model: canonicalizeBaseModel(body.base_model) };
+    return { ...body, base_model: canonicalizeLocalBaseModel(body.base_model) };
   }
   return body;
 }
@@ -1958,8 +1984,8 @@ function createTunedTensorTools(api, options = {}) {
         });
       }
     ),
-    define("describe_pipeline", "Describe pipeline", "Describe the built-in adapter or foundation workflow and exact TT commands. This never executes anything.", Type2.Object({
-      engine: Type2.Optional(Type2.Union([Type2.Literal("adapter"), Type2.Literal("foundation")])),
+    define("describe_pipeline", "Describe pipeline", "Describe the built-in adapter, foundation or decision workflow and exact TT commands. A decision spec fine-tunes a small typed decision model (e.g. convaiinnovations/laya) that returns a calibrated probability per label instead of generated text; use it for classification, routing, triage and yes/no or score gates. This never executes anything.", Type2.Object({
+      engine: Type2.Optional(Type2.Union([Type2.Literal("adapter"), Type2.Literal("foundation"), Type2.Literal("decision")])),
       target: Type2.Optional(Type2.Union([Type2.Literal("local"), Type2.Literal("cloud")]))
     }, { additionalProperties: false }), async (p) => {
       const engine = p.engine ?? "adapter";
@@ -1980,6 +2006,24 @@ function createTunedTensorTools(api, options = {}) {
         },
         note: "Configure runtime.gpu in tunedtensor.json with provider aws, instanceId, SSH user and optional AWS profile/region/identityFile. The instance must already be running and reachable with a verified SSH host key. AWS profile lookup and SSH access are separate; no TT token is required. GPU processes use it automatically; orchestration, scoring and artifacts stay local. Hardware tools inspect only the laptop; doctor checks the configured instance. The user manages AWS quota, costs and shutdown. Keep the laptop running until outputs return. Hosted training is retired."
       } : void 0;
+      if (engine === "decision") {
+        return {
+          version: 1,
+          engine,
+          scope: { execution: "local", devices: ["cpu", "mps", "cuda"] },
+          canonical: canonicalPipeline("local"),
+          models: DECISION_MODELS.map((model) => ({ id: model.id, revision: model.revision, parameters: model.parameters, license: model.license })),
+          spec: 'engine "decision", base_model, decision {type: choice|noul|score, criteria}; example outputs are labels (choice keys, true/false, or score level indices). system_prompt, guidelines and constraints become the question instructions.',
+          commands: {
+            init: "tt init --engine decision",
+            validate: "tt validate",
+            dry_run: "tt pipeline run --dry-run --spec tunedtensor.json",
+            run: "tt pipeline run --spec tunedtensor.json"
+          },
+          note: "Runs locally on CPU, Apple MPS or CUDA; runtime.gpu (AWS) is not used. The tuned model directory loads in Python with laya.load(<model_dir>).",
+          ...host ? { host } : {}
+        };
+      }
       if (engine === "foundation") {
         const foundation = {
           version: 1,
@@ -2097,7 +2141,7 @@ function createTunedTensorTools(api, options = {}) {
     define(
       "prepare_update_local_spec",
       "Prepare behavior spec edit",
-      "Prepare a reviewed edit of the existing local spec using the SHA-256 from get_local_spec. Use add_examples to append examples without resending existing ones. Other arrays and pipeline replace whole fields; hyperparameters and foundation settings merge by key. Runtime and evaluation objects merge recursively; null removes optional settings. Preserve unrelated fields. No write until /approve.",
+      "Prepare a reviewed edit of the existing local spec using the SHA-256 from get_local_spec. Use add_examples to append examples without resending existing ones. Other arrays, the decision question and pipeline replace whole fields; hyperparameters and foundation settings merge by key. Runtime and evaluation objects merge recursively; null removes optional settings. Preserve unrelated fields. No write until /approve.",
       Type2.Object({
         spec_path: Type2.Optional(Type2.String({ maxLength: 1e3 })),
         expected_sha256: Type2.String({ pattern: "^[a-f0-9]{64}$" }),
@@ -2118,10 +2162,13 @@ function createTunedTensorTools(api, options = {}) {
           }, { additionalProperties: false }), { minItems: 1 })),
           hyperparameters: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown())),
           foundation: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown())),
+          decision: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown())),
           runtime: Type2.Optional(Type2.Union([Type2.Record(Type2.String(), Type2.Unknown()), Type2.Null()])),
           evaluation: Type2.Optional(Type2.Union([Type2.Record(Type2.String(), Type2.Unknown()), Type2.Null()])),
           pipeline: Type2.Optional(Type2.Union([Type2.Record(Type2.String(), Type2.Unknown()), Type2.Null()])),
-          dataset_prebuilt: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown()))
+          dataset_prebuilt: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown(), {
+            description: "Local chat JSONL files ({training, validation|test}), or a Hugging Face dataset: {huggingface: {repo, revision?: 40-char commit, columns?: {input, output}}, training: 'repo/path.jsonl', test|validation: ...}. The user downloads it with `tt datasets prefetch tunedtensor.json`."
+          }))
         }, { additionalProperties: false })
       }, { additionalProperties: false }),
       async (p) => {
@@ -2246,11 +2293,13 @@ function createTunedTensorTools(api, options = {}) {
 // src/local-agent-client.ts
 var MAX_TOOL_CALLS_PER_TURN = 12;
 var SYSTEM_PROMPT = `You are the local Tuned Tensor assistant running on the user's laptop.
-The workspace tunedtensor.json behavior spec is the source of truth for model behavior, training, evaluation policy, runtime placement and optional pipeline settings. For requests to change the model's behavior, inspect it with get_local_spec first, then prepare_update_local_spec with the returned SHA-256 and only the requested field changes; use add_examples to append examples. Preserve unrelated examples, instructions, engine and training settings. Explain the proposed diff and validation; never claim an edit was saved before approval. Read-only questions about the current spec use get_local_spec without proposing an edit. If no spec exists, help prepare a new project. Malformed JSON must be repaired in an editor before prepare_update_local_spec can operate; never offer that tool as a way to reconstruct a truncated file. Use /spec, /spec diff, /spec validate and /spec history for direct review. General educational or inspection questions do not require a spec mutation.
+The workspace tunedtensor.json behavior spec is the source of truth for model behavior, training, evaluation policy, runtime placement and optional pipeline settings. For requests to change the model's behavior, inspect it with get_local_spec first, then prepare_update_local_spec with the returned SHA-256 and only the requested field changes; use add_examples to append examples. Preserve unrelated examples, instructions, engine and training settings. Explain the proposed diff and validation; never claim an edit was saved before approval. Read-only questions about the current spec use get_local_spec without proposing an edit. If no spec exists, help prepare a new project. Malformed JSON must be repaired in an editor before prepare_update_local_spec can operate; never offer that tool as a way to reconstruct a truncated file. For direct review, point users to /spec (a readable overview), /spec <section> such as /spec examples, /spec show for the JSON, and /spec diff, /spec validate and /spec history. General educational or inspection questions do not require a spec mutation.
 Local workflow commands need no TT access token. For local inspection commands such as runs, models, or doctor, tell the user to run the matching TT command in this shell (for example \`runs list\` or \`doctor\`); those commands execute outside the agent. User-owned AWS GPU training uses \`tt pipeline run\` with runtime.gpu configuration in tunedtensor.json, without a TT token. \`tt cloud\` is for TT account records, not GPU execution; hosted training start/estimate are retired. AWS credentials authorize instance lookup; separate SSH access is required. The instance must already be running, and the user manages quota, capacity, costs and shutdown. Keep the laptop running until outputs return. Model-provider choice is independent of GPU placement.
 When the user requests commands to inspect a run or serve a result, provide the direct CLI handoff: \`tt runs list\` to find a run, \`tt runs get <run-id>\` for its details, \`tt runs report <run-id>\` for its evaluation report, \`tt models list\` to find the resulting model ID, and \`tt serve <model-id>\` to serve that model. Replace placeholders with actual IDs from those commands; never invent results or IDs. Until the user supplies command output, keep literal <run-id> and <model-id> placeholders; do not fabricate example IDs or prefixes. Local run IDs are UUIDs and adapter model IDs are local-<run-id>. Do not refresh hardware or propose spec edits merely to supply those commands; perform those actions only when requested.
-For accurate adapter and foundation workflow stages and commands, call \`describe_pipeline\` with the matching engine instead of relying on prior knowledge.
+For accurate adapter, foundation and decision workflow stages and commands, call \`describe_pipeline\` with the matching engine instead of relying on prior knowledge.
 When the user asks to train, fine-tune, dry-run, or execute a workflow, call \`prepare_pipeline_run\`. Omit its pipeline argument to use the saved recipe or derive its default from the workspace spec. To change workflow stages, propose an edit to the spec pipeline section first; runtime and evaluation settings also belong in the core spec. This prepares a sealed local pipeline dry-run; approved pipeline actions are dry-runs only and may be stopped with Ctrl-C. Never claim training started. Real training requires an explicit direct \`tt pipeline run --spec tunedtensor.json\` command in the shell; preview uses the same command with \`--dry-run\`. The spec path is a --spec option, not a positional argument. No pipeline file or pipeline init is required for this default spec-driven workflow.
+Adapter base models: TT certifies ${TRAINING_MODELS.map((model) => model.id).join(", ")} (reviewed revision, architecture and memory profile). For adapter training, when the user asks for a model that is not certified, do not silently substitute a certified one. Confirm the repo exists with \`search_hugging_face\`, then explain the trade-off: an uncertified model trains as a text causal LM with generic LoRA defaults, safetensors weights and no remote code, but TT has not verified its architecture, chat template or hardware fit. If the user accepts, propose setting base_model to the exact repo id and hyperparameters.base_model_revision to a 40-character commit SHA the user copies from its Hugging Face commits page; never invent a SHA. Suggest the closest certified model as the lower-risk option, and point out that models needing remote code, vision inputs or gated access the user lacks will fail.
+Decision models use engine "decision" and their own certified registry. Call \`describe_pipeline\` with engine "decision" for supported models and typed question settings; do not apply adapter revision requirements to decision specs.
 When the user asks to discover public models or datasets, call \`search_hugging_face\`; it searches Hugging Face metadata for foundation and fine-tuning workflows. The query is sent to huggingface.co, so never include secrets or private data.
 For educational questions about how or why training works, call \`inspect_training_source\` before answering. Ground the explanation in the returned code and distinguish observed behavior from inferred rationale; do not invent author intent.
 When the user wants to examine this host, GPU, VRAM, CUDA, or decide what this machine can train, fine-tune, or infer, call \`examine_hardware\` before recommending a base model, engine, or pipeline. For local execution, recommend only workloads marked ready (mention tight as a caution). This tool inspects only the laptop: do not use a missing local GPU to reject AWS training or infer remote capacity. For AWS, direct the user to \`tt doctor tunedtensor.json\` to check the configured instance. Never invent generic 7B/70B sizing. Never start or cancel training from the model tool loop.
@@ -2778,16 +2827,79 @@ function del(path, opts) {
 }
 
 // src/agent.ts
-import chalk5 from "chalk";
+import chalk8 from "chalk";
+
+// src/mascot.ts
+import chalk from "chalk";
+var MASCOT_NAME = "tt";
+var MASCOT_WIDTH = 11;
+var PALETTE = {
+  a: "#B39DFB",
+  // diagonal, top-left
+  b: "#9B72F8",
+  // diagonal, center
+  c: "#7C3AED",
+  // diagonal, bottom-right
+  d: "#2B323D"
+  // slate tiles
+};
+var MARK = [
+  "aa.dd...",
+  "aa.dd...",
+  "........",
+  "dd.bb.dd",
+  "dd.bb.dd",
+  "........",
+  "...dd.cc",
+  "...dd.cc"
+];
+function pixelRow(upper, lower) {
+  let line = "";
+  for (let column = 0; column < upper.length; column += 1) {
+    const up = upper[column];
+    const down = lower[column];
+    if (up === "." && down === ".") line += " ";
+    else if (up === ".") line += chalk.hex(PALETTE[down])("\u2584");
+    else if (down === ".") line += chalk.hex(PALETTE[up])("\u2580");
+    else if (up === down) line += chalk.hex(PALETTE[up])("\u2588");
+    else line += chalk.hex(PALETTE[up]).bgHex(PALETTE[down])("\u2580");
+  }
+  return line;
+}
+function renderMascot() {
+  if (chalk.level === 0) {
+    return ["", " \u25A0 \u25A1", " \u25A1 \u25A0 \u25A1", "   \u25A1 \u25A0"].map((row) => row.padEnd(MASCOT_WIDTH));
+  }
+  const rows2 = [];
+  for (let row = 0; row < MARK.length; row += 2) {
+    rows2.push(` ${pixelRow(MARK[row], MARK[row + 1])}  `);
+  }
+  return rows2;
+}
+function mascotMark() {
+  if (chalk.level === 0) return "\u259A";
+  return `${chalk.hex(PALETTE.a)("\u2580")}${chalk.hex(PALETTE.c)("\u2584")}`;
+}
+function mascotSays(message) {
+  return `${mascotMark()} ${chalk.hex(PALETTE.b).bold(MASCOT_NAME)} ${chalk.dim("\u203A")} ${message}`;
+}
+var FAREWELLS = [
+  "See you next epoch.",
+  "Bye! Your checkpoints are safe with me.",
+  "Run tt to pick up where you left off."
+];
+function mascotFarewell(seed = Date.now()) {
+  return mascotSays(FAREWELLS[Math.abs(seed) % FAREWELLS.length]);
+}
 
 // src/shell.ts
-import chalk4 from "chalk";
+import chalk7 from "chalk";
 
 // src/terminal-markdown.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 import { stripVTControlCharacters } from "util";
-var accent = chalk.hex("#8B5CF6");
-var code = chalk.hex("#A78BFA");
+var accent = chalk2.hex("#8B5CF6");
+var code = chalk2.hex("#A78BFA");
 function sanitizeTerminalText(text2) {
   return stripVTControlCharacters(text2).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "");
 }
@@ -2806,7 +2918,7 @@ function renderInlineMarkdown(text2) {
     if (text2[index] === "[") {
       const link = text2.slice(index).match(/^\[([^\]]+)]\(([^)]+)\)/);
       if (link) {
-        rendered += `${chalk.underline(renderInlineMarkdown(link[1]))}${chalk.dim(` (${link[2]})`)}`;
+        rendered += `${chalk2.underline(renderInlineMarkdown(link[1]))}${chalk2.dim(` (${link[2]})`)}`;
         index += link[0].length;
         continue;
       }
@@ -2815,7 +2927,7 @@ function renderInlineMarkdown(text2) {
     if (strong) {
       const close = closingDelimiter(text2, strong, index);
       if (close > index + strong.length) {
-        rendered += chalk.bold(
+        rendered += chalk2.bold(
           renderInlineMarkdown(text2.slice(index + strong.length, close))
         );
         index = close + strong.length;
@@ -2834,7 +2946,7 @@ function renderInlineMarkdown(text2) {
     if (emphasis) {
       const close = closingDelimiter(text2, emphasis, index);
       if (close > index + 1) {
-        rendered += chalk.italic(
+        rendered += chalk2.italic(
           renderInlineMarkdown(text2.slice(index + 1, close))
         );
         index = close + 1;
@@ -2849,7 +2961,7 @@ function renderInlineMarkdown(text2) {
 function renderMarkdownLine(line, inCodeBlock) {
   if (inCodeBlock) return code(`  ${line}`);
   const heading = line.match(/^\s{0,3}#{1,6}\s+(.+)$/);
-  if (heading) return chalk.bold(renderInlineMarkdown(heading[1]));
+  if (heading) return chalk2.bold(renderInlineMarkdown(heading[1]));
   const bullet = line.match(/^(\s*)[-+*]\s+(.+)$/);
   if (bullet) {
     return `${bullet[1]}${accent("\u2022")} ${renderInlineMarkdown(bullet[2])}`;
@@ -2859,9 +2971,9 @@ function renderMarkdownLine(line, inCodeBlock) {
     return `${numbered[1]}${accent(`${numbered[2]}.`)} ${renderInlineMarkdown(numbered[3])}`;
   }
   const quote = line.match(/^\s*>\s?(.*)$/);
-  if (quote) return `${chalk.dim("\u2502")} ${chalk.italic(renderInlineMarkdown(quote[1]))}`;
+  if (quote) return `${chalk2.dim("\u2502")} ${chalk2.italic(renderInlineMarkdown(quote[1]))}`;
   if (/^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/.test(line)) {
-    return chalk.dim("\u2500".repeat(32));
+    return chalk2.dim("\u2500".repeat(32));
   }
   return renderInlineMarkdown(line);
 }
@@ -2937,9 +3049,9 @@ function wrapTerminalLine(line, width) {
 }
 
 // src/output.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import Table from "cli-table3";
-var labelStyle = chalk2.bold.hex("#A78BFA");
+var labelStyle = chalk3.bold.hex("#A78BFA");
 var jsonMode = false;
 function setJsonMode(enabled) {
   jsonMode = enabled;
@@ -2962,7 +3074,7 @@ function printTable(headers, rows2, meta) {
   if (meta) {
     const totalPages = Math.ceil(meta.total / meta.per_page);
     console.log(
-      chalk2.dim(
+      chalk3.dim(
         `
 Page ${meta.page}/${totalPages} (${meta.total} total)`
       )
@@ -2973,17 +3085,17 @@ function printDetail(fields) {
   const maxLabel = Math.max(...fields.map(([l]) => l.length));
   for (const [label, value] of fields) {
     const paddedLabel = label.padEnd(maxLabel);
-    console.log(`${labelStyle(paddedLabel)}  ${value ?? chalk2.dim("\u2014")}`);
+    console.log(`${labelStyle(paddedLabel)}  ${value ?? chalk3.dim("\u2014")}`);
   }
 }
 function printSuccess(message) {
-  console.log(chalk2.green("\u2713") + " " + message);
+  console.log(chalk3.green("\u2713") + " " + message);
 }
 function printWarning(message) {
-  console.log(chalk2.yellow("!") + " " + message);
+  console.log(chalk3.yellow("!") + " " + message);
 }
 function printError(message) {
-  console.error(chalk2.red("\u2717") + " " + message);
+  console.error(chalk3.red("\u2717") + " " + message);
 }
 function reportError(err) {
   const isApi = err instanceof ApiError;
@@ -3008,19 +3120,19 @@ function formatDate(iso) {
 }
 function formatStatus(status2) {
   const map = {
-    completed: chalk2.green,
-    running: chalk2.hex("#A78BFA"),
-    training: chalk2.hex("#A78BFA"),
-    evaluating: chalk2.hex("#A78BFA"),
-    preparing: chalk2.yellow,
-    pending: chalk2.yellow,
-    uploading: chalk2.yellow,
-    failed: chalk2.red,
-    cancelled: chalk2.dim,
-    validated: chalk2.green,
-    invalid: chalk2.red
+    completed: chalk3.green,
+    running: chalk3.hex("#A78BFA"),
+    training: chalk3.hex("#A78BFA"),
+    evaluating: chalk3.hex("#A78BFA"),
+    preparing: chalk3.yellow,
+    pending: chalk3.yellow,
+    uploading: chalk3.yellow,
+    failed: chalk3.red,
+    cancelled: chalk3.dim,
+    validated: chalk3.green,
+    invalid: chalk3.red
   };
-  const colorFn = map[status2] || chalk2.white;
+  const colorFn = map[status2] || chalk3.white;
   return colorFn(status2);
 }
 function truncate(str, max) {
@@ -3031,6 +3143,400 @@ function shortId(id) {
   return id.slice(0, 8);
 }
 
+// src/spec-view.ts
+import chalk4 from "chalk";
+var accent2 = chalk4.hex("#8B5CF6");
+var soft = chalk4.hex("#A78BFA");
+var keyColor = chalk4.hex("#C4B5FD");
+var stringColor = chalk4.hex("#86EFAC");
+var numberColor = chalk4.hex("#FCD34D");
+var literalColor = chalk4.hex("#F9A8D4");
+var SPEC_SECTIONS = [
+  "identity",
+  "behavior",
+  "examples",
+  "training",
+  "evaluation",
+  "runtime",
+  "pipeline"
+];
+var SECTION_ALIASES = {
+  id: "identity",
+  about: "identity",
+  prompt: "behavior",
+  system: "behavior",
+  guidelines: "behavior",
+  constraints: "behavior",
+  example: "examples",
+  data: "examples",
+  hyperparameters: "training",
+  hparams: "training",
+  foundation: "training",
+  train: "training",
+  eval: "evaluation",
+  gpu: "runtime"
+};
+function resolveSpecSection(name) {
+  const normalized = name.trim().toLowerCase();
+  if (SPEC_SECTIONS.includes(normalized)) return normalized;
+  return SECTION_ALIASES[normalized];
+}
+var SECTION_BLURBS = {
+  identity: "what this model is",
+  behavior: "what the model should do",
+  examples: "teaches by demonstration",
+  training: "how it is trained",
+  evaluation: "how results are scored",
+  runtime: "where it runs",
+  pipeline: "custom step recipe"
+};
+var SECTION_KEYS = {
+  identity: ["name", "description", "engine", "base_model", "id", "dataset_prebuilt"],
+  behavior: ["system_prompt", "guidelines", "constraints", "decision"],
+  examples: ["examples"],
+  training: ["hyperparameters", "foundation"],
+  evaluation: ["evaluation"],
+  runtime: ["runtime"],
+  pipeline: ["pipeline"]
+};
+var KNOWN_KEYS = new Set(Object.values(SECTION_KEYS).flat());
+function isObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function clean(value) {
+  return sanitizeTerminalText(value);
+}
+function truncateText(value, width) {
+  const flat = clean(value).replace(/\s+/g, " ").trim();
+  if (terminalWidth(flat) <= width) return flat;
+  let out = "";
+  for (const char of flat) {
+    if (terminalWidth(out + char) > width - 1) break;
+    out += char;
+  }
+  return `${out}\u2026`;
+}
+function hintLines(items, width) {
+  return joinFitting(items, width).map((line) => chalk4.dim(line));
+}
+function joinFitting(items, width) {
+  const lines = [];
+  let current = "";
+  for (const item of items) {
+    const next = current ? `${current} \xB7 ${item}` : item;
+    if (current && terminalWidth(next) > width) {
+      lines.push(current);
+      current = item;
+    } else {
+      current = next;
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+}
+function formatScalar(value) {
+  if (typeof value === "string") return stringColor(clean(value));
+  if (typeof value === "number") return numberColor(String(value));
+  if (typeof value === "boolean" || value === null) return literalColor(String(value));
+  return highlightJson(JSON.stringify(value));
+}
+function flattenSettings(value, prefix = "") {
+  if (!isObject2(value)) return [[prefix || "value", value]];
+  const rows2 = [];
+  for (const [key, child] of Object.entries(value)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (isObject2(child) && Object.keys(child).length > 0) rows2.push(...flattenSettings(child, path));
+    else rows2.push([path, child]);
+  }
+  return rows2;
+}
+function highlightJson(source) {
+  const token = /("(?:[^"\\]|\\.)*")(\s*:)?|(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)|\b(true|false|null)\b|([{}[\],])/g;
+  return clean(source).replace(token, (match, string, colon, number2, literal, punctuation) => {
+    if (string !== void 0) {
+      return colon !== void 0 ? `${keyColor(string)}${chalk4.dim(colon)}` : stringColor(string);
+    }
+    if (number2 !== void 0) return numberColor(number2);
+    if (literal !== void 0) return literalColor(literal);
+    if (punctuation !== void 0) return chalk4.dim(punctuation);
+    return match;
+  });
+}
+function highlightSpecDiff(diff) {
+  return diff.split("\n").map((line) => {
+    if (line.startsWith("@@")) return accent2.bold(line);
+    if (line.startsWith("+")) return chalk4.green(line);
+    if (line.startsWith("-")) return chalk4.red(line);
+    return line;
+  }).join("\n");
+}
+var ViewBuilder = class {
+  constructor(width) {
+    this.width = width;
+  }
+  lines = [];
+  push(line = "") {
+    this.lines.push(line);
+  }
+  /** Wrap text under a fixed indent and optional gutter marker. */
+  paragraph(text2, indent, style = (value) => value, maxLines) {
+    const body = this.width - terminalWidth(indent);
+    const wrapped = clean(text2).split(/\r?\n/).flatMap((line) => line.trim() ? wrapTerminalLine(line, Math.max(20, body)) : [""]);
+    const shown = maxLines && wrapped.length > maxLines ? wrapped.slice(0, maxLines) : wrapped;
+    for (const line of shown) this.push(`${indent}${style(line)}`);
+    if (shown.length < wrapped.length) {
+      this.push(`${indent}${chalk4.dim(`\u2026 ${wrapped.length - shown.length} more lines`)}`);
+    }
+  }
+  heading(section, detail) {
+    const title = section.toUpperCase();
+    const room = this.width - title.length - 3;
+    const extra = detail && room >= 8 ? `  ${chalk4.dim(truncateText(detail, room))}` : "";
+    this.push("");
+    this.push(`${accent2("\u258D")}${accent2.bold(title)}${extra}`);
+  }
+  settingsGrid(entries, indent = "  ") {
+    if (entries.length === 0) return;
+    const rows2 = entries.map(([key, value]) => [clean(key), value]);
+    const compact = rows2.every(([, value]) => value === null || ["number", "boolean"].includes(typeof value) || typeof value === "string" && value.length <= 16);
+    if (compact && rows2.length > 4) {
+      const keyWidth2 = Math.max(...rows2.map(([key]) => key.length));
+      const valueWidth = Math.max(...rows2.map(([, value]) => String(value).length));
+      const cell = keyWidth2 + 2 + valueWidth;
+      const columns = Math.min(3, Math.floor((this.width - indent.length + 4) / (cell + 4)));
+      if (columns >= 2) {
+        const height = Math.ceil(rows2.length / columns);
+        for (let row = 0; row < height; row += 1) {
+          const cells = [];
+          for (let column = 0; column < columns; column += 1) {
+            const entry = rows2[column * height + row];
+            if (!entry) continue;
+            const [key, value] = entry;
+            const text2 = String(value);
+            cells.push(`${keyColor(key.padEnd(keyWidth2))}  ${formatScalar(typeof value === "string" ? clean(value) : value)}${" ".repeat(valueWidth - text2.length)}`);
+          }
+          this.push(`${indent}${cells.join("    ").trimEnd()}`);
+        }
+        return;
+      }
+    }
+    const keyWidth = Math.min(28, Math.max(...rows2.map(([key]) => key.length)));
+    for (const [key, value] of rows2) {
+      const label = key.length > keyWidth ? truncateText(key, keyWidth) : key.padEnd(keyWidth);
+      const rendered = typeof value === "string" ? stringColor(truncateText(value, Math.max(20, this.width - keyWidth - indent.length - 2))) : formatScalar(value);
+      this.push(`${indent}${keyColor(label)}  ${rendered}`);
+    }
+  }
+};
+function stringList(value) {
+  return Array.isArray(value) ? value.map((item) => typeof item === "string" ? item : JSON.stringify(item)) : [];
+}
+function exampleText(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "";
+  return JSON.stringify(value);
+}
+function renderIdentity(view, spec, full) {
+  if (!full) return;
+  view.heading("identity", SECTION_BLURBS.identity);
+  view.settingsGrid(SECTION_KEYS.identity.filter((key) => spec[key] !== void 0).map((key) => [key, spec[key]]));
+  if (spec.engine === void 0) view.push(`  ${chalk4.dim("engine defaults to adapter (LoRA on base_model)")}`);
+}
+function renderBehavior(view, spec, full) {
+  const guidelines = stringList(spec.guidelines);
+  const constraints = stringList(spec.constraints);
+  view.heading("behavior", SECTION_BLURBS.behavior);
+  view.push(`  ${chalk4.bold("System prompt")}`);
+  if (typeof spec.system_prompt === "string" && spec.system_prompt.trim()) {
+    view.paragraph(spec.system_prompt, `  ${soft("\u2502")} `, chalk4.italic, full ? void 0 : 6);
+  } else {
+    view.push(`  ${soft("\u2502")} ${chalk4.dim("(none)")}`);
+  }
+  const renderList = (label, items, mark) => {
+    view.push(`  ${chalk4.bold(label)} ${chalk4.dim(String(items.length))}`);
+    if (items.length === 0) {
+      view.push(`    ${chalk4.dim("(none)")}`);
+      return;
+    }
+    const limit = full ? items.length : 5;
+    for (const item of items.slice(0, limit)) {
+      const before = view.lines.length;
+      view.paragraph(item, "      ", void 0, full ? void 0 : 2);
+      view.lines[before] = `    ${mark} ${view.lines[before].slice(6)}`;
+    }
+    if (items.length > limit) view.push(`    ${chalk4.dim(`\u2026 ${items.length - limit} more \xB7 /spec behavior`)}`);
+  };
+  if (isObject2(spec.decision)) {
+    view.push(`  ${chalk4.bold("Decision question")}`);
+    view.settingsGrid(flattenSettings(spec.decision));
+  }
+  renderList("Guidelines", guidelines, chalk4.green("\u2713"));
+  renderList("Constraints", constraints, chalk4.red("\u2717"));
+}
+function renderExamples(view, spec, full) {
+  const examples = Array.isArray(spec.examples) ? spec.examples : [];
+  const count = examples.length;
+  const size = count === 0 ? "none yet" : `${count} example${count === 1 ? "" : "s"}`;
+  view.heading("examples", `${size} \xB7 ${SECTION_BLURBS.examples}`);
+  if (count === 0) {
+    view.push(`  ${chalk4.dim("Ask TT to draft examples, or add input/output pairs to tunedtensor.json.")}`);
+    return;
+  }
+  const limit = full ? count : 3;
+  const number2 = String(Math.min(count, limit)).length;
+  const textWidth = Math.max(20, view.width - number2 - 10);
+  examples.slice(0, limit).forEach((example, index) => {
+    const record4 = isObject2(example) ? example : { input: example };
+    const label = chalk4.dim(String(index + 1).padStart(number2));
+    const pad = " ".repeat(number2);
+    if (full) {
+      const before = view.lines.length;
+      view.paragraph(exampleText(record4.input), `  ${pad}  ${chalk4.cyan("in ")} `);
+      view.lines[before] = view.lines[before].replace(`  ${pad}`, `  ${label}`);
+      view.paragraph(exampleText(record4.output), `  ${pad}  ${chalk4.green("out")} `, stringColor);
+      view.push("");
+    } else {
+      view.push(`  ${label}  ${chalk4.cyan("in ")} ${truncateText(exampleText(record4.input), textWidth)}`);
+      view.push(`  ${pad}  ${chalk4.green("out")} ${stringColor(truncateText(exampleText(record4.output), textWidth))}`);
+    }
+  });
+  if (full && view.lines.at(-1) === "") view.lines.pop();
+  if (count > limit) view.push(`  ${chalk4.dim(`\u2026 ${count - limit} more \xB7 /spec examples shows all`)}`);
+}
+function renderTraining(view, spec) {
+  const foundation = spec.engine === "foundation";
+  const settings = foundation ? spec.foundation : spec.hyperparameters;
+  view.heading("training", foundation ? "foundation \xB7 tokenizer, pretrain, SFT" : spec.engine === "decision" ? "decision \xB7 typed classification" : `adapter \xB7 LoRA on ${typeof spec.base_model === "string" ? clean(spec.base_model) : "base_model"}`);
+  const rows2 = isObject2(settings) ? flattenSettings(settings) : [];
+  if (rows2.length === 0) {
+    view.push(`  ${chalk4.dim("Defaults \u2014 no overrides set.")}`);
+    return;
+  }
+  view.settingsGrid(rows2);
+  const other = foundation ? spec.hyperparameters : spec.foundation;
+  if (isObject2(other)) view.push(`  ${chalk4.yellow("!")} ${chalk4.dim(`${foundation ? "hyperparameters" : "foundation"} is set but unused by this engine`)}`);
+}
+function renderSettingsSection(view, spec, section, full) {
+  const value = spec[section];
+  if (value === void 0) {
+    if (full) {
+      view.heading(section, SECTION_BLURBS[section]);
+      view.push(`  ${chalk4.dim(section === "runtime" ? "Not set \u2014 runs on this machine with default paths." : section === "pipeline" ? "Not set \u2014 TT derives the default pipeline from this spec." : "Not set \u2014 default scoring.")}`);
+    }
+    return;
+  }
+  if (section === "pipeline" && !full) {
+    const steps = isObject2(value) && Array.isArray(value.steps) ? value.steps.length : void 0;
+    view.heading(section, SECTION_BLURBS[section]);
+    view.push(`  ${steps === void 0 ? "custom recipe" : `${steps} custom step${steps === 1 ? "" : "s"}`} ${chalk4.dim("\xB7 /spec pipeline")}`);
+    return;
+  }
+  view.heading(section, SECTION_BLURBS[section]);
+  if (section === "pipeline") {
+    for (const line of JSON.stringify(value, null, 2).split("\n")) view.push(`  ${highlightJson(line)}`);
+    return;
+  }
+  view.settingsGrid(flattenSettings(value));
+}
+function renderOther(view, spec) {
+  const rows2 = Object.entries(spec).filter(([key]) => !KNOWN_KEYS.has(key));
+  if (rows2.length === 0) return;
+  view.push("");
+  view.push(`${accent2("\u258D")}${accent2.bold("OTHER")}`);
+  view.settingsGrid(rows2);
+}
+function renderHeader(view, input, spec) {
+  const name = typeof spec.name === "string" && spec.name.trim() ? clean(spec.name) : "Unnamed spec";
+  const status2 = input.validation.valid ? chalk4.green("\u2713 valid") : chalk4.red(`\u2717 ${input.validation.errors.length} issue${input.validation.errors.length === 1 ? "" : "s"}`);
+  const gap = Math.max(2, view.width - terminalWidth(name) - terminalWidth(status2));
+  view.push(`${chalk4.bold(name)}${" ".repeat(gap)}${status2}`);
+  if (typeof spec.description === "string" && spec.description.trim()) {
+    view.paragraph(spec.description, "", chalk4.dim, 3);
+  }
+  const examples = Array.isArray(spec.examples) ? spec.examples.length : 0;
+  const facts = [
+    spec.engine === "foundation" ? "foundation" : spec.engine === "decision" ? "decision" : "adapter",
+    typeof spec.base_model === "string" ? truncateText(spec.base_model, view.width) : void 0,
+    `${examples} example${examples === 1 ? "" : "s"}`,
+    isObject2(spec.runtime) && isObject2(spec.runtime.gpu) ? "remote GPU" : void 0
+  ].filter((fact) => Boolean(fact));
+  view.lines.push(...joinFitting(facts, view.width));
+  view.lines.push(...hintLines([truncateText(input.displayPath, view.width), `sha256 ${input.sha256.slice(0, 12)}`], view.width));
+}
+function renderDiagnostics(view, input) {
+  const { errors, warnings, valid } = input.validation;
+  if (valid && warnings.length === 0) return;
+  view.push("");
+  const marked = (text2, mark, style) => {
+    const before = view.lines.length;
+    view.paragraph(text2, "  ", style);
+    view.lines[before] = `${mark} ${view.lines[before].slice(2)}`;
+  };
+  for (const error of errors) marked(error, chalk4.red("\u2717"), chalk4.red);
+  for (const warning of warnings) marked(warning, chalk4.yellow("!"), chalk4.yellow);
+}
+function renderInvalid(view, input) {
+  view.push(`${chalk4.red("\u2717")} ${chalk4.bold(clean(input.displayPath))} ${chalk4.dim("could not be parsed")}`);
+  for (const error of input.validation.errors) view.paragraph(error, "  ", chalk4.red);
+  view.push("");
+  for (const line of clean(input.source).split("\n")) view.push(`  ${chalk4.dim(line)}`);
+  return `${view.lines.join("\n")}
+`;
+}
+function renderSpecView(input, options = {}) {
+  const width = Math.max(40, Math.min(options.columns ?? 88, 88));
+  const view = new ViewBuilder(width);
+  if (!isObject2(input.document)) return renderInvalid(view, input);
+  const spec = input.document;
+  const section = options.section;
+  if (!section) {
+    renderHeader(view, input, spec);
+    renderBehavior(view, spec, false);
+    renderExamples(view, spec, false);
+    renderTraining(view, spec);
+    renderSettingsSection(view, spec, "evaluation", false);
+    renderSettingsSection(view, spec, "runtime", false);
+    renderSettingsSection(view, spec, "pipeline", false);
+    renderOther(view, spec);
+    renderDiagnostics(view, input);
+    view.push("");
+    view.lines.push(...hintLines(["/spec <section> for detail", "/spec show for JSON", "/spec diff", "/spec history"], width));
+    view.lines.push(...wrapTerminalLine(`sections: ${SPEC_SECTIONS.join(", ")}`, width).map((line) => chalk4.dim(line)));
+    return `${view.lines.join("\n")}
+`;
+  }
+  switch (section) {
+    case "identity":
+      renderIdentity(view, spec, true);
+      break;
+    case "behavior":
+      renderBehavior(view, spec, true);
+      break;
+    case "examples":
+      renderExamples(view, spec, true);
+      break;
+    case "training":
+      renderTraining(view, spec);
+      break;
+    default:
+      renderSettingsSection(view, spec, section, true);
+  }
+  view.lines.shift();
+  return `${view.lines.join("\n")}
+`;
+}
+function renderSpecSource(input) {
+  const status2 = input.validation.valid ? chalk4.green("\u2713 valid") : chalk4.red("\u2717 invalid");
+  const lines = [
+    `${chalk4.bold(clean(input.displayPath))} ${chalk4.dim(`\xB7 sha256 ${input.sha256.slice(0, 12)}`)}  ${status2}`,
+    highlightJson(input.source.replace(/\s+$/, "")),
+    ...input.validation.errors.map((error) => chalk4.red(`\u2717 ${clean(error)}`)),
+    ...input.validation.warnings.map((warning) => chalk4.yellow(`! ${clean(warning)}`))
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
 // src/commands/spec.ts
 async function reviewSpec(workspaceRoot, operation = "show", specPath = "tunedtensor.json") {
   if (!["show", "validate", "diff", "history"].includes(operation)) {
@@ -3083,8 +3589,14 @@ ${label}
 ${diff}` };
 }
 function registerSpecCommands(program, cwd) {
-  program.command("spec").description("Review the local behavior spec, validation, changes and history").argument("[operation]", "show, validate, diff, or history", "show").argument("[path]", "Workspace-relative tunedtensor.json", "tunedtensor.json").action(async (operation, path) => {
-    const result2 = await reviewSpec(cwd, operation, path);
+  program.command("spec").description("Review the local behavior spec, validation, changes and history").argument("[operation]", `show, view, validate, diff, history, or a section (${SPEC_SECTIONS.join(", ")})`, "show").argument("[path]", "Workspace-relative tunedtensor.json", "tunedtensor.json").action(async (operation, path) => {
+    const section = resolveSpecSection(operation);
+    if ((section || operation === "view") && !isJsonMode()) {
+      const spec = await inspectLocalSpec(cwd, path);
+      process.stdout.write(renderSpecView(spec, { section, columns: process.stdout.columns }));
+      return;
+    }
+    const result2 = await reviewSpec(cwd, section || operation === "view" ? "show" : operation, path);
     if (isJsonMode()) {
       const { text: _text, ...data3 } = result2;
       printJson(data3);
@@ -3097,10 +3609,487 @@ function registerSpecCommands(program, cwd) {
   });
 }
 
+// src/shell-view.ts
+import chalk5 from "chalk";
+var accent3 = chalk5.hex("#8B5CF6");
+var GIB = 1024 ** 3;
+var BAR_WIDTH = 10;
+var MAX_PANEL_WIDTH = 88;
+function panelWidth(columns) {
+  return Math.max(40, Math.min(columns ?? 80, MAX_PANEL_WIDTH));
+}
+function formatGiB(bytes) {
+  const amount = bytes / GIB;
+  return amount >= 100 ? amount.toFixed(0) : amount.toFixed(1);
+}
+function loadColor(percent2) {
+  if (percent2 >= 85) return chalk5.red;
+  if (percent2 >= 60) return chalk5.yellow;
+  return chalk5.green;
+}
+function usageBar(percent2, width = BAR_WIDTH) {
+  if (percent2 === void 0) return chalk5.dim("\xB7".repeat(width));
+  const clamped = Math.max(0, Math.min(100, percent2));
+  const filled = Math.round(clamped / 100 * width);
+  return `${loadColor(clamped)("\u2588".repeat(filled))}${chalk5.dim("\u2591".repeat(width - filled))}`;
+}
+function percentLabel(percent2) {
+  if (percent2 === void 0) return chalk5.dim("  n/a");
+  return loadColor(percent2)(`${String(Math.round(percent2)).padStart(3)}%`).padStart(4);
+}
+function sectionRule(title, width, detail) {
+  const label = `${accent3.bold(title)}${detail ? ` ${chalk5.dim(detail)}` : ""}`;
+  const rule = Math.max(3, width - terminalWidth(label) - 1);
+  return `${label} ${chalk5.dim("\u2500".repeat(rule))}`;
+}
+function inventoryFromUsage(usage) {
+  const nvidia = usage.gpus.filter((gpu) => gpu.vendor === "nvidia");
+  return {
+    collected_at: usage.sampled_at,
+    quick: true,
+    node: { version: process.versions.node, major: Number(process.versions.node.split(".")[0]), ok: true },
+    os: {
+      platform: process.platform,
+      arch: process.arch,
+      type: process.platform,
+      cpu_count: usage.cpu.cores,
+      total_memory_bytes: usage.memory.total_bytes,
+      free_memory_bytes: usage.memory.total_bytes - usage.memory.used_bytes
+    },
+    gpus: nvidia.map((gpu) => ({
+      index: gpu.index,
+      name: gpu.name,
+      memory_total_bytes: gpu.memory_total_bytes,
+      memory_free_bytes: gpu.memory_total_bytes !== void 0 && gpu.memory_used_bytes !== void 0 ? gpu.memory_total_bytes - gpu.memory_used_bytes : void 0,
+      unified_memory: gpu.unified_memory
+    })),
+    nvidia_smi: { ok: nvidia.length > 0, message: usage.gpu_note ?? "" },
+    disks: []
+  };
+}
+function shortModel(id, width = 24) {
+  return truncateText(id.split("/").at(-1) ?? id, width);
+}
+var STATUS_WORD = {
+  ready: "ready",
+  tight: "tight",
+  not_possible: "not possible"
+};
+function describeFineTuneFit(usage, context) {
+  const spec = context.spec;
+  if (spec?.remoteGpu) {
+    return {
+      status: "remote",
+      text: `training runs on AWS ${spec.remoteGpu} (runtime.gpu)`,
+      source: "tt doctor checks it"
+    };
+  }
+  const snapshot = context.host && !context.host.stale ? context.host.capabilities : void 0;
+  let report = snapshot;
+  const source = snapshot ? "from tt hardware" : "quick check \xB7 tt hardware for a full probe";
+  if (!report && usage) report = evaluateCapabilities(inventoryFromUsage(usage));
+  if (!report) return { status: "unknown", text: "not checked yet", source: "run tt hardware" };
+  if (spec?.engine === "decision") {
+    return {
+      status: "unknown",
+      text: "decision training runs locally on CPU, MPS or CUDA",
+      source: "device selected by hyperparameters.device"
+    };
+  }
+  const noCuda = !report.cuda_available;
+  if (spec?.engine === "foundation") {
+    const verdict = report.foundation.train;
+    return {
+      status: verdict.status,
+      text: verdict.status === "not_possible" ? `foundation training ${STATUS_WORD[verdict.status]} \u2014 ${verdict.reason}` : `foundation training ${STATUS_WORD[verdict.status]} \xB7 suggested max depth ${report.foundation.suggested_max_depth}`,
+      source: noCuda ? "set runtime.gpu to train on your AWS GPU" : source
+    };
+  }
+  if (spec?.baseModel) {
+    const adapter = report.adapters.find((item) => item.id.toLowerCase() === spec.baseModel.toLowerCase());
+    if (!adapter) {
+      return {
+        status: "unknown",
+        text: `no certified memory profile for ${shortModel(spec.baseModel, 32)}`,
+        source: "tt hardware lists supported base models"
+      };
+    }
+    const verdict = adapter.finetune;
+    return {
+      status: verdict.status,
+      text: `LoRA ${shortModel(adapter.id)} ${STATUS_WORD[verdict.status]} \u2014 ${verdict.reason}`,
+      source: noCuda ? "set runtime.gpu to train on your AWS GPU" : source
+    };
+  }
+  const ready = report.adapters.filter((item) => item.finetune.status !== "not_possible");
+  if (ready.length === 0) {
+    return {
+      status: "not_possible",
+      text: noCuda ? "no local CUDA GPU for LoRA training" : "no certified base model fits this GPU",
+      source: noCuda ? "runtime.gpu can use your AWS GPU" : source
+    };
+  }
+  const best = ready.some((item) => item.finetune.status === "ready") ? "ready" : "tight";
+  return {
+    status: best,
+    text: `LoRA ${best} for ${ready.map((item) => shortModel(item.id, 20)).join(", ")}`,
+    source
+  };
+}
+function fitMark(status2) {
+  switch (status2) {
+    case "ready":
+      return chalk5.green("\u2713");
+    case "tight":
+      return chalk5.yellow("!");
+    case "not_possible":
+      return chalk5.red("\u2717");
+    case "remote":
+      return accent3("\u2197");
+    default:
+      return chalk5.dim("?");
+  }
+}
+function gpuDetail(gpu) {
+  const parts = [];
+  if (gpu.vendor === "apple") {
+    parts.push(`${formatGiB(gpu.memory_total_bytes ?? 0)} GiB unified \xB7 Metal`);
+  } else if (gpu.memory_total_bytes !== void 0) {
+    const used = gpu.memory_used_bytes;
+    parts.push(used === void 0 ? `${formatGiB(gpu.memory_total_bytes)} GiB VRAM` : `VRAM ${formatGiB(used)}/${formatGiB(gpu.memory_total_bytes)} GiB`);
+  } else if (gpu.unified_memory) {
+    parts.push("unified with system RAM");
+  }
+  if (gpu.temperature_c !== void 0) parts.push(`${Math.round(gpu.temperature_c)}\xB0C`);
+  return parts.join("  ");
+}
+function renderMeterRows(rows2, width) {
+  const detailWidth = Math.max(0, ...rows2.map((row) => terminalWidth(row.detail)));
+  const fixed = 6 + 1 + 1 + BAR_WIDTH + 1 + 4 + 2;
+  const nameWidth = Math.max(6, Math.min(28, width - fixed - detailWidth));
+  const detailRoom = Math.max(8, width - fixed - nameWidth);
+  return rows2.map((row) => {
+    const nameCell = truncateText(row.name, nameWidth).padEnd(nameWidth);
+    return `${chalk5.bold(row.label.padEnd(6))} ${nameCell} ${usageBar(row.percent)} ${percentLabel(row.percent)}  ${chalk5.dim(truncateText(row.detail, detailRoom))}`;
+  });
+}
+function renderMachinePanel(usage, context, options = {}) {
+  const width = panelWidth(options.columns);
+  const lines = [sectionRule("MACHINE", width)];
+  if (usage.gpus.length === 0) {
+    const reason = usage.gpu_note ? ` (${usage.gpu_note})` : "";
+    lines.push(`${chalk5.bold("GPU".padEnd(6))} ${chalk5.dim(truncateText(`no NVIDIA GPU detected${reason}`, width - 7))}`);
+  }
+  const meters = usage.gpus.map((gpu) => ({
+    label: usage.gpus.length > 1 ? `GPU ${gpu.index}` : "GPU",
+    // "NVIDIA GeForce RTX 4090" reads better as "GeForce RTX 4090" in a narrow column.
+    name: sanitizeTerminalText(gpu.name).replace(/^NVIDIA\s+(?=\S)/, ""),
+    percent: gpu.utilization_percent,
+    detail: gpuDetail(gpu)
+  }));
+  meters.push({
+    label: "CPU",
+    name: `${usage.cpu.cores}\xD7 ${sanitizeTerminalText(usage.cpu.model)}`,
+    percent: usage.cpu.utilization_percent,
+    detail: `load ${usage.cpu.load_average[0].toFixed(2)}`
+  });
+  meters.push({
+    label: "RAM",
+    name: "system memory",
+    percent: usage.memory.total_bytes > 0 ? usage.memory.used_bytes / usage.memory.total_bytes * 100 : void 0,
+    detail: `${formatGiB(usage.memory.used_bytes)}/${formatGiB(usage.memory.total_bytes)} GiB`
+  });
+  if (usage.disk && usage.disk.total_bytes > 0) {
+    meters.push({
+      label: "Disk",
+      name: "model cache",
+      percent: (usage.disk.total_bytes - usage.disk.free_bytes) / usage.disk.total_bytes * 100,
+      detail: `${formatGiB(usage.disk.free_bytes)} GiB free`
+    });
+  }
+  lines.push(...renderMeterRows(meters, width));
+  const fit = describeFineTuneFit(usage, context);
+  lines.push(`${chalk5.bold("Tune".padEnd(6))} ${fitMark(fit.status)} ${truncateText(fit.text, width - 9)}`);
+  if (fit.source) lines.push(`${" ".repeat(9)}${chalk5.dim(truncateText(fit.source, width - 9))}`);
+  if (options.detailed) {
+    const report = context.host && !context.host.stale ? context.host.capabilities : evaluateCapabilities(inventoryFromUsage(usage));
+    if (report) {
+      lines.push("", sectionRule("CERTIFIED BASE MODELS", width, "LoRA fine-tune"));
+      const idWidth = Math.min(44, Math.floor(width * 0.55));
+      const reasonWidth = Math.max(10, width - idWidth - 3);
+      const row = (status2, label, reason) => `${fitMark(status2)} ${truncateText(label, idWidth).padEnd(idWidth)} ${chalk5.dim(truncateText(reason, reasonWidth))}`;
+      for (const adapter of report.adapters) {
+        lines.push(row(adapter.finetune.status, adapter.id, adapter.finetune.reason));
+      }
+      const foundation = report.foundation.train;
+      lines.push(row(
+        foundation.status,
+        "foundation engine (from scratch)",
+        foundation.status === "not_possible" ? foundation.reason : `max depth ${report.foundation.suggested_max_depth}`
+      ));
+    }
+    lines.push("");
+    const note = context.host ? `Full probe ${context.host.stale ? "is stale" : "cached"} from ${context.host.collectedAt.slice(0, 16).replace("T", " ")} \xB7 tt hardware refreshes it` : "No full probe yet \xB7 tt hardware checks CUDA, torch and disk space";
+    lines.push(...wrapTerminalLine(note, width).map((line) => chalk5.dim(line)));
+  }
+  return lines;
+}
+function agentLabel(context) {
+  const agent = context.agent;
+  if (!agent?.provider || !agent.model) return void 0;
+  return `${agent.provider}/${agent.model}`;
+}
+function bannerTip(input) {
+  const { context, usage } = input;
+  const agent = agentLabel(context);
+  if (!agent) {
+    return "Use /login tunedtensor for managed inference, or /model for your own provider. Workflow commands work now.";
+  }
+  if (!context.spec) {
+    return "No tunedtensor.json here yet. Describe the model you want and I'll draft a spec, or run init.";
+  }
+  if (context.spec.parseError) {
+    return "tunedtensor.json doesn't parse. /spec show points at the problem.";
+  }
+  const busy = usage?.gpus.find((gpu) => (gpu.utilization_percent ?? 0) >= 85);
+  if (busy) {
+    return `${sanitizeTerminalText(busy.name)} is ${busy.utilization_percent}% busy; training now may be slow.`;
+  }
+  const examples = context.spec.exampleCount ?? 0;
+  if (examples < 20) {
+    return `${examples} example${examples === 1 ? "" : "s"} is a small set. Ask me to draft more, or /spec examples to review them.`;
+  }
+  return "Ask TT anything. Known commands run directly.";
+}
+function specLine(context) {
+  const spec = context.spec;
+  if (!spec) return `${chalk5.dim("spec")} ${chalk5.yellow("none here")} ${chalk5.dim("\xB7 init creates one")}`;
+  if (spec.parseError) return `${chalk5.dim("spec")} ${chalk5.red("tunedtensor.json is invalid JSON")}`;
+  const name = sanitizeTerminalText(spec.name ?? "unnamed");
+  const facts = [
+    spec.engine === "foundation" ? "foundation" : spec.baseModel ? sanitizeTerminalText(spec.baseModel) : void 0,
+    spec.exampleCount === void 0 ? void 0 : `${spec.exampleCount} examples`
+  ].filter(Boolean).join(" \xB7 ");
+  return `${chalk5.dim("spec")} ${chalk5.bold(name)}${facts ? chalk5.dim(` \xB7 ${facts}`) : ""}`;
+}
+function renderBanner(input) {
+  const width = panelWidth(input.columns);
+  const { context } = input;
+  const tip = bannerTip(input);
+  const heading = [
+    `${accent3.bold("tt")}${input.version ? ` ${chalk5.dim(`v${input.version}`)}` : ""}  ${chalk5.dim("Tuned Tensor")}`,
+    specLine(context),
+    chalk5.dim(`agent ${agentLabel(context) ?? "not configured"} \xB7 workflow model ${input.activeModel}`)
+  ];
+  const mascot = renderMascot();
+  const textWidth = width - MASCOT_WIDTH - 1;
+  const offset = mascot.length - heading.length;
+  const lines = mascot.map((row, index) => {
+    const text2 = heading[index - offset] ?? "";
+    return `${row} ${terminalWidth(text2) > textWidth ? truncateText(text2, textWidth) : text2}`;
+  });
+  if (input.usage) {
+    lines.push("", ...renderMachinePanel(input.usage, context, { columns: input.columns }));
+  }
+  const prefix = mascotSays("");
+  const hang = terminalWidth(prefix);
+  const wrapped = wrapTerminalLine(tip, Math.max(20, width - hang));
+  lines.push("", `${prefix}${wrapped[0]}`, ...wrapped.slice(1).map((line) => `${" ".repeat(hang)}${line}`));
+  lines.push(...hintLines([
+    "/spec review",
+    "/system machine",
+    "/help commands",
+    "tab complete",
+    "ctrl+c stop/clear",
+    "ctrl+d exit"
+  ], width));
+  return `${lines.join("\n")}
+
+`;
+}
+
+// src/local-runtime/live-usage.ts
+import { execFile } from "child_process";
+import { readFileSync as readFileSync5 } from "fs";
+import { statfs } from "fs/promises";
+import { cpus, freemem, homedir, loadavg, totalmem } from "os";
+import { dirname as dirname3, join as join7, resolve as resolve2 } from "path";
+function cpuTimes() {
+  let idle = 0;
+  let total = 0;
+  for (const cpu of cpus()) {
+    const times = cpu.times;
+    idle += times.idle;
+    total += times.user + times.nice + times.sys + times.irq + times.idle;
+  }
+  return { idle, total };
+}
+function cpuUtilization(before, after) {
+  const total = after.total - before.total;
+  if (!(total > 0)) return void 0;
+  const busy = total - (after.idle - before.idle);
+  return Math.min(100, Math.max(0, Math.round(busy / total * 100)));
+}
+function optionalNumber(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed || /^\[?n\/a\]?$/i.test(trimmed) || /not supported/i.test(trimmed)) return void 0;
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+var MIB = 1024 * 1024;
+var NVIDIA_USAGE_QUERY = [
+  "--query-gpu=index,name,utilization.gpu,memory.used,memory.total,temperature.gpu",
+  "--format=csv,noheader,nounits"
+];
+function parseNvidiaUsage(stdout3) {
+  const gpus = [];
+  for (const line of stdout3.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+    const parts = line.split(",").map((part) => part.trim());
+    if (parts.length < 2 || !/^\d+$/.test(parts[0] ?? "")) continue;
+    const name = parts[1] || "NVIDIA GPU";
+    const used = optionalNumber(parts[3]);
+    const total = optionalNumber(parts[4]);
+    gpus.push({
+      index: Number(parts[0]),
+      name,
+      utilization_percent: optionalNumber(parts[2]),
+      memory_used_bytes: used === void 0 ? void 0 : Math.round(used * MIB),
+      memory_total_bytes: total === void 0 || total <= 0 ? void 0 : Math.round(total * MIB),
+      temperature_c: optionalNumber(parts[5]),
+      unified_memory: /spark|gb10/i.test(name),
+      vendor: "nvidia"
+    });
+  }
+  return gpus;
+}
+function queryNvidia(env, timeoutMs) {
+  return new Promise((resolve13) => {
+    execFile("nvidia-smi", NVIDIA_USAGE_QUERY, { env, timeout: timeoutMs, windowsHide: true }, (error, stdout3) => {
+      if (error) {
+        const code2 = error.code;
+        resolve13({
+          gpus: [],
+          note: code2 === "ENOENT" ? "nvidia-smi not found" : error.killed ? "nvidia-smi timed out" : "nvidia-smi failed"
+        });
+        return;
+      }
+      const gpus = parseNvidiaUsage(String(stdout3));
+      resolve13(gpus.length > 0 ? { gpus } : { gpus, note: "nvidia-smi listed no GPUs" });
+    });
+  });
+}
+function tidyCpuModel(model) {
+  return model.replace(/\((?:R|TM|tm|r)\)/g, "").replace(/\s+(?:CPU|Processor)\b/gi, "").replace(/\s*@\s*[\d.]+\s*[GM]Hz/i, "").replace(/\s+\d+-Core$/i, "").replace(/\s+/g, " ").trim() || "CPU";
+}
+var ARM_CORES = {
+  "0xd03": "Cortex-A53",
+  "0xd05": "Cortex-A55",
+  "0xd08": "Cortex-A72",
+  "0xd0b": "Cortex-A76",
+  "0xd0c": "Neoverse-N1",
+  "0xd40": "Neoverse-V1",
+  "0xd41": "Cortex-A78",
+  "0xd44": "Cortex-X1",
+  "0xd47": "Cortex-A710",
+  "0xd48": "Cortex-X2",
+  "0xd49": "Neoverse-N2",
+  "0xd4d": "Cortex-A715",
+  "0xd4e": "Cortex-X3",
+  "0xd4f": "Neoverse-V2",
+  "0xd80": "Cortex-A520",
+  "0xd81": "Cortex-A720",
+  "0xd82": "Cortex-X4",
+  "0xd84": "Neoverse-V3",
+  "0xd85": "Cortex-X925",
+  "0xd87": "Cortex-A725",
+  "0xd8e": "Neoverse-N3"
+};
+function armCpuModel(cpuinfo) {
+  const names = [];
+  let implementer;
+  for (const line of cpuinfo.split(/\r?\n/)) {
+    const [key, value] = line.split(":").map((item) => item.trim().toLowerCase());
+    if (key === "cpu implementer") implementer = value;
+    if (key !== "cpu part" || !value) continue;
+    const name = implementer === "0x41" ? ARM_CORES[value] : void 0;
+    if (name && !names.includes(name)) names.push(name);
+  }
+  return names.length > 0 ? names.join(" + ") : void 0;
+}
+function cpuModel(reported, platform, arch) {
+  const model = tidyCpuModel(reported ?? "");
+  if (platform !== "linux" || !/^(?:unknown|CPU)$/i.test(model)) return model;
+  try {
+    return armCpuModel(readFileSync5("/proc/cpuinfo", "utf8")) ?? (arch === "arm64" ? "Arm CPU" : model);
+  } catch {
+    return arch === "arm64" ? "Arm CPU" : model;
+  }
+}
+async function modelCacheDisk(env) {
+  const path = resolve2(env.HF_HOME?.trim() || join7(homedir(), ".cache", "huggingface"));
+  for (let probe = path, depth = 0; depth < 8; depth += 1) {
+    try {
+      const fs = await statfs(probe);
+      return {
+        path,
+        free_bytes: Number(fs.bavail) * Number(fs.bsize),
+        total_bytes: Number(fs.blocks) * Number(fs.bsize)
+      };
+    } catch {
+      const parent = dirname3(probe);
+      if (parent === probe) break;
+      probe = parent;
+    }
+  }
+  return void 0;
+}
+function appleGpu(cpuModel2, platform, arch) {
+  if (platform !== "darwin" || arch !== "arm64") return void 0;
+  const chip = /apple/i.test(cpuModel2) ? cpuModel2.trim() : "Apple Silicon";
+  return {
+    index: 0,
+    name: `${chip} GPU`,
+    memory_total_bytes: totalmem(),
+    unified_memory: true,
+    vendor: "apple"
+  };
+}
+async function sampleLiveUsage(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const before = cpuTimes();
+  const [nvidia, disk] = await Promise.all([
+    queryNvidia(env, options.gpuTimeoutMs ?? 2e3),
+    modelCacheDisk(env).catch(() => void 0),
+    new Promise((resolve13) => setTimeout(resolve13, options.cpuSampleMs ?? 200))
+  ]);
+  const after = cpuTimes();
+  const list = cpus();
+  const model = cpuModel(list[0]?.model, platform, arch);
+  const total = totalmem();
+  const apple = nvidia.gpus.length === 0 ? appleGpu(model, platform, arch) : void 0;
+  const [one, five, fifteen] = loadavg();
+  return {
+    sampled_at: (/* @__PURE__ */ new Date()).toISOString(),
+    cpu: {
+      model,
+      cores: list.length,
+      utilization_percent: cpuUtilization(before, after),
+      load_average: [one ?? 0, five ?? 0, fifteen ?? 0]
+    },
+    memory: { used_bytes: Math.max(0, total - freemem()), total_bytes: total },
+    disk,
+    gpus: apple ? [apple] : nvidia.gpus,
+    gpu_note: apple ? void 0 : nvidia.note
+  };
+}
+
 // src/shell.ts
 import { stat as stat3 } from "fs/promises";
-import { homedir } from "os";
-import { isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
+import { homedir as homedir2 } from "os";
+import { isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
 
@@ -3108,6 +4097,7 @@ import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
 var LOCAL = ["local"];
 var COMMAND_CATALOG = [
   { path: "spec", description: "Review the current behavior spec.", group: "Workflow", modes: LOCAL },
+  { path: "spec view", description: "Readable, highlighted behavior spec; add a section name for detail.", group: "Workflow", modes: LOCAL },
   ...["show", "diff", "validate", "history"].map((operation) => ({ path: `spec ${operation}`, description: `Review behavior spec ${operation}.`, group: "Workflow", modes: LOCAL })),
   { path: "init", description: "Create a local behaviour-spec project.", group: "Workflow", modes: LOCAL },
   { path: "validate", description: "Validate a local fine-tuning project.", group: "Workflow", modes: LOCAL },
@@ -3123,12 +4113,15 @@ var COMMAND_CATALOG = [
   { path: "runs report", description: "Show a local run report.", group: "Inspect", modes: LOCAL },
   { path: "runs compare", description: "Compare two local run reports.", group: "Inspect", modes: LOCAL },
   { path: "runs events", description: "Show local run progress events.", group: "Inspect", modes: LOCAL },
+  { path: "runs audit", description: "Verify a run's event log and report, with timeline and provenance.", group: "Inspect", modes: LOCAL },
   { path: "models list", description: "List local models.", group: "Inspect", modes: LOCAL },
   { path: "models get", description: "Show a local model.", group: "Inspect", modes: LOCAL },
   { path: "models serve", description: "Serve a model through an OpenAI-compatible API.", group: "Serving", modes: LOCAL },
   { path: "models verify", description: "Verify a local model artifact.", group: "Serving", modes: LOCAL },
   { path: "models prefetch", description: "Download the local base-model snapshot.", group: "Serving", modes: LOCAL },
   { path: "models verify-base", description: "Verify the local base-model snapshot.", group: "Serving", modes: LOCAL },
+  { path: "datasets prefetch", description: "Download the spec's Hugging Face dataset files.", group: "Workflow", modes: LOCAL },
+  { path: "datasets verify", description: "Verify the cached Hugging Face dataset files.", group: "Workflow", modes: LOCAL },
   { path: "models active", description: "Show the active local model.", group: "Serving", modes: LOCAL },
   { path: "models activate", description: "Activate a verified local model.", group: "Serving", modes: LOCAL },
   { path: "models rollback", description: "Roll back the active local model.", group: "Serving", modes: LOCAL },
@@ -3184,7 +4177,8 @@ var COMMAND_CATALOG = [
   { path: "agent status", description: "Show the laptop-local TT agent selection.", group: "Inspect", modes: LOCAL }
 ];
 var SLASH_COMMANDS = [
-  { path: "/spec", description: "Review the behavior spec; add diff, validate or history." },
+  { path: "/spec", description: "Readable behavior spec; add a section, show, diff, validate or history." },
+  { path: "/system", description: "Live GPU, CPU and memory use, and what this machine can fine-tune." },
   { path: "/help", description: "Show commands; add a word to filter." },
   { path: "/status", description: "Show lightweight workflow status." },
   { path: "/context", description: "Show the current project context." },
@@ -3246,7 +4240,7 @@ function createCommandCompleter(getMode = () => "local") {
 
 // src/shell-context.ts
 import { readFile as readFile3, readdir as readdir3, stat as stat2 } from "fs/promises";
-import { basename as basename2, dirname as dirname3, join as join7, resolve as resolve2 } from "path";
+import { basename as basename2, dirname as dirname4, join as join8, resolve as resolve3 } from "path";
 async function readJsonObject(path) {
   try {
     const parsed = JSON.parse(await readFile3(path, "utf8"));
@@ -3273,7 +4267,7 @@ function expandPath(value, baseDirectory, env) {
   return expandUserPath(value, env, baseDirectory);
 }
 function configPath(env) {
-  return join7(getConfigDir(env), "config.json");
+  return join8(getConfigDir(env), "config.json");
 }
 function agentSelectionFrom(env, configAgent, hasToken) {
   const stored = configAgent && typeof configAgent === "object" && !Array.isArray(configAgent) ? configAgent : {};
@@ -3291,14 +4285,14 @@ async function adjacentFile(path) {
   }
 }
 async function readActiveModelId(storeRoot) {
-  const result2 = await readJsonObject(join7(storeRoot, "active-model.json"));
+  const result2 = await readJsonObject(join8(storeRoot, "active-model.json"));
   if (!result2.found || result2.invalid) return void 0;
   const modelId = result2.value?.model_id;
   if (modelId === null) return "base";
   return typeof modelId === "string" && modelId ? modelId : void 0;
 }
 async function readLatestRun(storeRoot) {
-  const runsRoot = join7(storeRoot, "runs");
+  const runsRoot = join8(storeRoot, "runs");
   let names;
   try {
     names = (await readdir3(runsRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -3306,7 +4300,7 @@ async function readLatestRun(storeRoot) {
     return void 0;
   }
   const states = await Promise.all(names.map(async (name) => {
-    const result2 = await readJsonObject(join7(runsRoot, name, "state.json"));
+    const result2 = await readJsonObject(join8(runsRoot, name, "state.json"));
     if (!result2.found || result2.invalid || !result2.value) return void 0;
     const id = stringField(result2.value, "id") ?? name;
     const state = {
@@ -3334,14 +4328,15 @@ function hostFromSnapshot(snapshot) {
     summary: snapshot.summary,
     line: formatHostStatusLine(snapshot),
     cuda: snapshot.capabilities.cuda_available,
-    gpuName: snapshot.capabilities.gpu?.name
+    gpuName: snapshot.capabilities.gpu?.name,
+    capabilities: snapshot.capabilities
   };
 }
 async function discoverShellContext(options = {}) {
   const env = options.env ?? process.env;
-  const cwd = resolve2(options.cwd ?? process.cwd());
+  const cwd = resolve3(options.cwd ?? process.cwd());
   const warnings = [];
-  const specPath = join7(cwd, "tunedtensor.json");
+  const specPath = join8(cwd, "tunedtensor.json");
   const specJson = await readJsonObject(specPath);
   let spec;
   if (specJson.found) {
@@ -3350,31 +4345,35 @@ async function discoverShellContext(options = {}) {
       warnings.push("tunedtensor.json could not be parsed.");
     } else {
       const examples = specJson.value.examples;
+      const runtime2 = specJson.value.runtime;
+      const gpu = runtime2 && typeof runtime2 === "object" && !Array.isArray(runtime2) ? runtime2.gpu : void 0;
       spec = {
         path: specPath,
         id: stringField(specJson.value, "id"),
         name: stringField(specJson.value, "name"),
         baseModel: stringField(specJson.value, "base_model"),
+        engine: stringField(specJson.value, "engine"),
         exampleCount: Array.isArray(examples) ? examples.length : void 0,
+        remoteGpu: gpu && typeof gpu === "object" && !Array.isArray(gpu) ? stringField(gpu, "instanceId") : void 0,
         parseError: false
       };
     }
   }
-  const localConfigPath = join7(cwd, "local-runner.json");
+  const localConfigPath = join8(cwd, "local-runner.json");
   const hasAdjacentLocalConfig = await adjacentFile(localConfigPath);
   const localConfigJson = hasAdjacentLocalConfig ? await readJsonObject(localConfigPath) : { found: false, invalid: false };
   if (localConfigJson.invalid) {
     warnings.push("local-runner.json could not be parsed.");
   }
-  const localConfigDirectory = hasAdjacentLocalConfig ? dirname3(localConfigPath) : cwd;
+  const localConfigDirectory = hasAdjacentLocalConfig ? dirname4(localConfigPath) : cwd;
   const runtime = specJson.value?.runtime;
   const projectRuntime = runtime && typeof runtime === "object" && !Array.isArray(runtime) ? runtime : void 0;
   if (hasAdjacentLocalConfig && (projectRuntime || specJson.value?.evaluation)) warnings.push("Conflicting configuration sources; run tt pipeline migrate after reconciling the spec and local-runner.json.");
   const config = projectRuntime ?? localConfigJson.value;
   const configuredArtifactRoot = stringField(config, "artifactRoot");
   const configuredStoreRoot = stringField(config, "storeRoot");
-  const artifactRoot = configuredArtifactRoot ? expandPath(configuredArtifactRoot, localConfigDirectory, env) : resolve2(cwd, DEFAULT_ARTIFACT_ROOT);
-  const storeRoot = configuredStoreRoot ? expandPath(configuredStoreRoot, localConfigDirectory, env) : specJson.value && !hasAdjacentLocalConfig && !env.TT_LOCAL_HOME?.trim() ? resolve2(cwd, DEFAULT_PROJECT_STORE_ROOT) : defaultStoreRoot(env);
+  const artifactRoot = configuredArtifactRoot ? expandPath(configuredArtifactRoot, localConfigDirectory, env) : resolve3(cwd, DEFAULT_ARTIFACT_ROOT);
+  const storeRoot = configuredStoreRoot ? expandPath(configuredStoreRoot, localConfigDirectory, env) : specJson.value && !hasAdjacentLocalConfig && !env.TT_LOCAL_HOME?.trim() ? resolve3(cwd, DEFAULT_PROJECT_STORE_ROOT) : defaultStoreRoot(env);
   const storedConfigPath = configPath(env);
   const storedConfigJson = await readJsonObject(storedConfigPath);
   if (storedConfigJson.invalid) {
@@ -3408,7 +4407,7 @@ async function discoverShellContext(options = {}) {
 function valueOrDash(value) {
   return value === void 0 || value === "" ? "\u2014" : String(value);
 }
-function agentLabel(context) {
+function agentLabel2(context) {
   const agent = context.agent;
   if (!agent?.provider && !agent?.model) return "not configured";
   const id = [agent.provider, agent.model].filter(Boolean).join("/");
@@ -3423,7 +4422,7 @@ function formatShellContext(context) {
     `Spec ID        ${valueOrDash(context.spec?.id)}`,
     `Base model     ${valueOrDash(context.spec?.baseModel)}`,
     `Examples       ${valueOrDash(context.spec?.exampleCount)}`,
-    `Agent model    ${agentLabel(context)}`,
+    `Agent model    ${agentLabel2(context)}`,
     `Local config   ${context.local.configPath ?? "not found"}`,
     `Artifact root  ${context.local.artifactRoot}`,
     `Store root     ${context.local.storeRoot}`,
@@ -3435,7 +4434,7 @@ function formatShellContext(context) {
 function formatShellStatus(context) {
   return [
     `Spec           ${context.spec?.name ?? (context.spec ? "unnamed" : "not found")}`,
-    `Agent model    ${agentLabel(context)}`,
+    `Agent model    ${agentLabel2(context)}`,
     `Local config   ${context.local.configPath ?? "not found"}`,
     `Active model   ${context.local.activeModelId ?? "base"}`,
     `Latest run     ${context.local.latestRun ? `${context.local.latestRun.id} (${context.local.latestRun.status ?? "unknown"})` : "none"}`,
@@ -3612,7 +4611,7 @@ function setAgentModel(runtime, env, provider, model, options = {}) {
 }
 
 // src/secret-prompt.ts
-import chalk3 from "chalk";
+import chalk6 from "chalk";
 import { emitKeypressEvents } from "readline";
 import { createInterface } from "readline/promises";
 import { stdin, stdout } from "process";
@@ -3690,16 +4689,16 @@ async function promptKeyChoice(message, input = stdin, output = stdout) {
   emitKeypressEvents(input);
   return await withDetachedKeypress(input, async () => {
     const wasRaw = terminal.isRaw === true;
-    terminal.setRawMode(true);
-    input.resume();
-    output.write(`${message} ${hint()}`);
     try {
-      const choice = await new Promise((resolve11) => {
+      terminal.setRawMode(true);
+      input.resume();
+      output.write(`${message} ${hint()}`);
+      const choice = await new Promise((resolve13) => {
         const finish = (decision) => {
           input.removeListener("keypress", onKeypress);
           input.removeListener("end", onEnd);
           input.removeListener("close", onEnd);
-          resolve11(decision);
+          resolve13(decision);
         };
         const onKeypress = (text2, key) => {
           const decided = keyChoiceFor(key, text2);
@@ -3719,7 +4718,7 @@ async function promptKeyChoice(message, input = stdin, output = stdout) {
   });
 }
 function hint() {
-  return chalk3.dim("y yes \xB7 n no \xB7 esc decide later ");
+  return chalk6.dim("y yes \xB7 n no \xB7 esc decide later ");
 }
 
 // src/shell.ts
@@ -3880,6 +4879,7 @@ var SLASH_NAMES = /* @__PURE__ */ new Set([
   "help",
   "status",
   "context",
+  "system",
   "model",
   "login",
   "clear",
@@ -3949,9 +4949,9 @@ function parseSlashCommand(input) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-var successMark = () => chalk4.green("\u2713");
-var errorMark = () => chalk4.red("\u2717");
-var accent2 = chalk4.hex("#8B5CF6");
+var successMark = () => chalk7.green("\u2713");
+var errorMark = () => chalk7.red("\u2717");
+var accent4 = chalk7.hex("#8B5CF6");
 var ANSI_BOLD = "\x1B[1m";
 var ANSI_BOLD_OFF = "\x1B[22m";
 var ANSI_CLEAR_LINE = "\x1B[2K";
@@ -3960,15 +4960,15 @@ var ANSI_CLEAR_DOWN = "\x1B[J";
 var ANSI_CURSOR_UP = "\x1B[1A";
 var ANSI_RESET = "\x1B[0m";
 function inputColorCodes() {
-  if (chalk4.level === 0) return null;
-  if (chalk4.level === 1) {
+  if (chalk7.level === 0) return null;
+  if (chalk7.level === 1) {
     return {
       background: "\x1B[100m",
       accent: "\x1B[95m",
       text: "\x1B[97m"
     };
   }
-  if (chalk4.level === 2) {
+  if (chalk7.level === 2) {
     return {
       background: "\x1B[48;5;238m",
       accent: "\x1B[38;5;183m",
@@ -3981,13 +4981,14 @@ function inputColorCodes() {
     text: "\x1B[38;2;245;243;255m"
   };
 }
+var SPEC_USAGE = `Usage: /spec [${SPEC_SECTIONS.join("|")}|show|diff|validate|history] [path/to/tunedtensor.json]`;
 var DETAIL_LABEL_WIDTH = 15;
 function styleDetailLines(lines) {
   return lines.map((line) => {
     if (line.length <= DETAIL_LABEL_WIDTH) return line;
     const label = line.slice(0, DETAIL_LABEL_WIDTH);
     if (!label.trim()) return line;
-    const color = label.startsWith("Warning") ? chalk4.yellow : accent2.bold;
+    const color = label.startsWith("Warning") ? chalk7.yellow : accent4.bold;
     return `${color(label)}${line.slice(DETAIL_LABEL_WIDTH)}`;
   });
 }
@@ -4000,42 +5001,47 @@ function assertNoArgs(command, args2) {
   }
 }
 function expandDirectory(value, cwd, env) {
-  const home = env.HOME ? resolve3(env.HOME) : homedir();
+  const home = env.HOME ? resolve4(env.HOME) : homedir2();
   if (value === "~") return home;
-  if (value.startsWith("~/")) return resolve3(home, value.slice(2));
-  return isAbsolute3(value) ? resolve3(value) : resolve3(cwd, value);
+  if (value.startsWith("~/")) return resolve4(home, value.slice(2));
+  return isAbsolute3(value) ? resolve4(value) : resolve4(cwd, value);
 }
 function helpText(mode, query, palette = false) {
   const groups = groupedCatalog(mode, query);
   const lines = [];
-  lines.push(accent2.bold(palette ? "Commands \u2014 type a command, or prefix with : to make the intent explicit" : `TT commands${query ? ` matching ${JSON.stringify(query)}` : ""}`));
+  lines.push(accent4.bold(palette ? "Commands \u2014 type a command, or prefix with : to make the intent explicit" : `TT commands${query ? ` matching ${JSON.stringify(query)}` : ""}`));
   if (groups.size === 0) {
-    lines.push(chalk4.dim("  No matching commands."));
+    lines.push(chalk7.dim("  No matching commands."));
   } else {
     for (const [group, commands] of groups) {
       lines.push("");
-      lines.push(chalk4.bold(group));
+      lines.push(chalk7.bold(group));
       for (const command of commands) {
-        lines.push(`  ${accent2(command.path.padEnd(22))} ${command.description}`);
+        lines.push(`  ${accent4(command.path.padEnd(22))} ${command.description}`);
       }
     }
   }
   if (!query) {
     lines.push("");
-    lines.push(chalk4.bold("Conversation"));
-    lines.push(`  ${accent2("plain text".padEnd(22))} Ask the Tuned Tensor agent anything.`);
-    lines.push(`  ${accent2("/new".padEnd(22))} Start a new agent conversation.`);
-    lines.push(`  ${accent2("/threads".padEnd(22))} List recent conversations.`);
-    lines.push(`  ${accent2("/resume <id>".padEnd(22))} Resume a conversation.`);
-    lines.push(`  ${accent2("/approve [id]".padEnd(22))} Approve an action left pending.`);
-    lines.push(`  ${accent2("/reject [id]".padEnd(22))} Reject an action left pending.`);
+    lines.push(chalk7.bold("Conversation"));
+    lines.push(`  ${accent4("plain text".padEnd(22))} Ask the Tuned Tensor agent anything.`);
+    lines.push(`  ${accent4("/new".padEnd(22))} Start a new agent conversation.`);
+    lines.push(`  ${accent4("/threads".padEnd(22))} List recent conversations.`);
+    lines.push(`  ${accent4("/resume <id>".padEnd(22))} Resume a conversation.`);
+    lines.push(`  ${accent4("/approve [id]".padEnd(22))} Approve an action left pending.`);
+    lines.push(`  ${accent4("/reject [id]".padEnd(22))} Reject an action left pending.`);
     lines.push("");
-    lines.push(chalk4.bold("Session"));
+    lines.push(chalk7.bold("Session"));
     for (const command of SLASH_COMMANDS) {
-      lines.push(`  ${accent2(command.path.padEnd(22))} ${command.description}`);
+      lines.push(`  ${accent4(command.path.padEnd(22))} ${command.description}`);
     }
-    lines.push(`  ${accent2("?".padEnd(22))} Alias for /help.`);
-    lines.push(chalk4.dim(
+    lines.push(`  ${accent4("?".padEnd(22))} Alias for /help.`);
+    lines.push("");
+    lines.push(chalk7.bold("Behavior spec"));
+    lines.push(`  ${accent4("/spec".padEnd(22))} Readable overview of tunedtensor.json.`);
+    lines.push(`  ${accent4("/spec <section>".padEnd(22))} One section in full: ${SPEC_SECTIONS.join(", ")}.`);
+    lines.push(`  ${accent4("/spec show".padEnd(22))} The raw JSON, highlighted.`);
+    lines.push(chalk7.dim(
       "\nKnown TT commands execute directly; other text goes to the agent. Prefix a command with : to make the intent explicit."
     ));
   }
@@ -4045,33 +5051,17 @@ function helpText(mode, query, palette = false) {
 function activeModelLabel(snapshot) {
   return snapshot.context.local.activeModelId ?? "base";
 }
-function agentModelLabel(context) {
-  const agent = context.agent;
-  if (!agent?.provider && !agent?.model) return "not configured";
-  return [agent.provider, agent.model].filter(Boolean).join("/") || "not configured";
-}
-function renderShellBanner(snapshot) {
-  const heading = snapshot.version ? `${accent2.bold("tt")} ${chalk4.dim(`v${snapshot.version}`)}` : accent2.bold("tt");
-  const configured = Boolean(
-    snapshot.context.agent?.provider && snapshot.context.agent?.model
-  );
-  const lines = [
-    heading,
-    chalk4.dim(
-      `agent ${agentModelLabel(snapshot.context)} \xB7 workflow model ${activeModelLabel(snapshot)}`
-    ),
-    chalk4.dim("/spec review \xB7 ctrl+c stop/clear \xB7 ctrl+d exit \xB7 /help commands \xB7 tab complete"),
-    "",
-    chalk4.dim(
-      configured ? "Ask TT anything. Known commands run directly." : "Use /login tunedtensor for managed inference, or /model for your own provider. Workflow commands work now."
-    )
-  ];
-  return `${lines.join("\n")}
-
-`;
+function renderShellBanner(snapshot, columns) {
+  return renderBanner({
+    version: snapshot.version,
+    context: snapshot.context,
+    activeModel: activeModelLabel(snapshot),
+    usage: snapshot.usage,
+    columns
+  });
 }
 function renderShellPrompt() {
-  return `${accent2.bold("\u203A")} `;
+  return `${accent4.bold("\u203A")} `;
 }
 function renderSubmittedShellInput(input, columns) {
   const colors = inputColorCodes();
@@ -4104,7 +5094,7 @@ function resetShellPromptStyle() {
   return "";
 }
 var TunedTensorShellSession = class _TunedTensorShellSession {
-  constructor(runner, io, agent, env, contextProvider, version, agentModelRuntime, initialContext) {
+  constructor(runner, io, agent, env, contextProvider, version, agentModelRuntime, systemProbe, columns, initialContext) {
     this.runner = runner;
     this.io = io;
     this.agent = agent;
@@ -4112,6 +5102,8 @@ var TunedTensorShellSession = class _TunedTensorShellSession {
     this.contextProvider = contextProvider;
     this.version = version;
     this.agentModelRuntime = agentModelRuntime;
+    this.systemProbe = systemProbe;
+    this.columns = columns;
     this.cwd = initialContext.cwd;
     this.context = initialContext;
   }
@@ -4119,12 +5111,13 @@ var TunedTensorShellSession = class _TunedTensorShellSession {
   modeSource = "default-local";
   cwd;
   context;
+  usage;
   static async create(options) {
     const env = options.env ?? process.env;
-    const cwd = resolve3(options.cwd ?? process.cwd());
+    const cwd = resolve4(options.cwd ?? process.cwd());
     const contextProvider = options.contextProvider ?? ((input) => discoverShellContext(input));
     const initialContext = await contextProvider({ cwd, env });
-    return new _TunedTensorShellSession(
+    const session = new _TunedTensorShellSession(
       options.runner,
       options.io,
       options.agent,
@@ -4132,8 +5125,22 @@ var TunedTensorShellSession = class _TunedTensorShellSession {
       contextProvider,
       options.version,
       options.agentModelRuntime,
+      options.systemProbe,
+      options.columns ?? (() => void 0),
       initialContext
     );
+    await session.sampleSystem();
+    return session;
+  }
+  /** Refresh live machine usage; a failed probe only hides the panel. */
+  async sampleSystem() {
+    if (!this.systemProbe) return void 0;
+    try {
+      this.usage = await this.systemProbe();
+    } catch {
+      this.usage = void 0;
+    }
+    return this.usage;
   }
   interruptAgent() {
     return this.agent?.interrupt() ?? false;
@@ -4144,14 +5151,25 @@ var TunedTensorShellSession = class _TunedTensorShellSession {
       modeSource: this.modeSource,
       cwd: this.cwd,
       context: this.context,
-      version: this.version
+      version: this.version,
+      usage: this.usage
     };
   }
   prompt() {
     return renderShellPrompt();
   }
   banner() {
-    return renderShellBanner(this.snapshot());
+    return renderShellBanner(this.snapshot(), this.columns());
+  }
+  async inspectSpecForView(path) {
+    try {
+      return await inspectLocalSpec(this.cwd, path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new ShellParseError(`No ${path} in ${this.cwd}. Run init, or ask TT to draft a behavior spec.`);
+      }
+      throw error;
+    }
   }
   async refreshContext() {
     this.context = await this.contextProvider({ cwd: this.cwd, env: this.env });
@@ -4187,42 +5205,42 @@ var TunedTensorShellSession = class _TunedTensorShellSession {
     const provider = query ? findAgentProvider(runtime, query) : void 0;
     if (provider) {
       const matches = listAgentModels(runtime, { ...catalog, provider: provider.id });
-      lines.push("", chalk4.bold(`Models from ${provider.id}`));
+      lines.push("", chalk7.bold(`Models from ${provider.id}`));
       this.appendAgentModelChoices(lines, matches, summary, 20, "/model <query> to search");
       if (matches.length === 0) {
-        lines.push(chalk4.dim("  no models"));
+        lines.push(chalk7.dim("  no models"));
       }
       return lines;
     }
     if (query) {
       const matches = listAgentModels(runtime, { ...catalog, query });
-      lines.push("", chalk4.bold(`Models matching ${JSON.stringify(query)}`));
+      lines.push("", chalk7.bold(`Models matching ${JSON.stringify(query)}`));
       this.appendAgentModelChoices(lines, matches, summary, 10, "refine the query");
       if (matches.length === 0) {
-        lines.push(chalk4.dim("  no matches"));
+        lines.push(chalk7.dim("  no matches"));
       }
       return lines;
     }
     const providers = listAgentProviders(runtime, { featuredOnly: true });
-    lines.push("", chalk4.bold("Providers"));
+    lines.push("", chalk7.bold("Providers"));
     if (providers.length === 0) {
-      lines.push(chalk4.dim("  no providers in the catalog"));
+      lines.push(chalk7.dim("  no providers in the catalog"));
     } else {
       for (const choice of providers) {
         lines.push(this.formatAgentProviderChoice(choice));
       }
-      lines.push(chalk4.dim("  Other providers: /login <id> or /model <id>"));
+      lines.push(chalk7.dim("  Other providers: /login <id> or /model <id>"));
       if (providers.some((choice) => !choice.authenticated)) {
-        lines.push(chalk4.dim("  Use /login tunedtensor for your TT token, or /login <provider> for a BYO key."));
+        lines.push(chalk7.dim("  Use /login tunedtensor for your TT token, or /login <provider> for a BYO key."));
       }
     }
     const suggestions = recommendAgentModels(runtime, featuredCatalog);
-    lines.push("", chalk4.bold("Suggestions"));
+    lines.push("", chalk7.bold("Suggestions"));
     this.appendAgentModelChoices(lines, suggestions, summary);
     if (suggestions.length === 0) {
-      lines.push(chalk4.dim("  no models in the catalog"));
+      lines.push(chalk7.dim("  no models in the catalog"));
     } else {
-      lines.push(chalk4.dim("  Use /model <provider> to list models, /model <query> to search"));
+      lines.push(chalk7.dim("  Use /model <provider> to list models, /model <query> to search"));
     }
     return lines;
   }
@@ -4233,25 +5251,35 @@ var TunedTensorShellSession = class _TunedTensorShellSession {
     }
     if (limit && models.length > shown.length) {
       const hint2 = moreHint ? ` \u2014 ${moreHint}` : "";
-      lines.push(chalk4.dim(`  \u2026 ${models.length - shown.length} more${hint2}`));
+      lines.push(chalk7.dim(`  \u2026 ${models.length - shown.length} more${hint2}`));
     }
   }
   formatAgentProviderChoice(provider) {
     const displayName = provider.name !== provider.id ? `  ${provider.name}` : "";
-    const auth = provider.authenticated ? "" : chalk4.dim("  auth required");
-    return `  ${accent2(provider.id)}${displayName}${auth}`;
+    const auth = provider.authenticated ? "" : chalk7.dim("  auth required");
+    return `  ${accent4(provider.id)}${displayName}${auth}`;
   }
   formatAgentModelChoice(model, summary) {
     const active = summary?.provider === model.provider && summary?.model === model.id;
     const displayName = model.name !== model.id ? `  ${model.name}` : "";
-    const auth = model.authenticated ? "" : chalk4.dim("  auth required");
-    return `  ${accent2(`${model.provider}/${model.id}`)}${displayName}${active ? chalk4.dim(" (active)") : ""}${auth}`;
+    const auth = model.authenticated ? "" : chalk7.dim("  auth required");
+    return `  ${accent4(`${model.provider}/${model.id}`)}${displayName}${active ? chalk7.dim(" (active)") : ""}${auth}`;
   }
   async handleSlash(command) {
     switch (command.name) {
       case "spec": {
-        if (command.args.length > 2) throw new ShellParseError("Usage: /spec [show|diff|validate|history] [path/to/tunedtensor.json]");
-        const [operation = "show", path = "tunedtensor.json"] = command.args;
+        if (command.args.length > 2) throw new ShellParseError(SPEC_USAGE);
+        let [operation = "view", path = "tunedtensor.json"] = command.args;
+        if (command.args.length === 1 && /(^|\/)tunedtensor\.json$/.test(operation)) {
+          [operation, path] = ["view", operation];
+        }
+        const section = resolveSpecSection(operation);
+        if (section || operation === "view" || operation === "show") {
+          const spec = await this.inspectSpecForView(path);
+          this.io.write(operation === "show" ? renderSpecSource(spec) : renderSpecView(spec, { section, columns: this.columns() }));
+          return "continue";
+        }
+        if (!["diff", "validate", "history"].includes(operation)) throw new ShellParseError(SPEC_USAGE);
         if (operation === "diff") {
           const current = await inspectLocalSpec(this.cwd, path);
           const pending = this.agent?.snapshot?.().pendingActions.filter((action) => {
@@ -4262,18 +5290,27 @@ var TunedTensorShellSession = class _TunedTensorShellSession {
             for (const action of pending) {
               const preview = action.preview;
               const input = action.arguments;
-              const text2 = `Pending edit ${action.id.slice(0, 8)}${input.expected_sha256 !== current.sha256 ? " (stale; prepare again)" : ""}
+              const text3 = `Pending edit ${action.id.slice(0, 8)}${input.expected_sha256 !== current.sha256 ? " (stale; prepare again)" : ""}
 ${preview.diff}
 `;
-              this.io.write(sanitizeTerminalText(text2));
+              this.io.write(highlightSpecDiff(sanitizeTerminalText(text3)));
             }
             return "continue";
           }
         }
-        this.io.write(`${sanitizeTerminalText((await reviewSpec(this.cwd, operation, path)).text)}
+        const text2 = sanitizeTerminalText((await reviewSpec(this.cwd, operation, path)).text);
+        this.io.write(`${operation === "diff" ? highlightSpecDiff(text2) : text2}
 `);
         return "continue";
       }
+      case "system": {
+        assertNoArgs("system", command.args);
+        const usage = await this.sampleSystem();
+        if (!usage) throw new ShellParseError("Live machine usage is unavailable in this session.");
+        await this.refreshContext();
+        this.writeLines(renderMachinePanel(usage, this.context, { columns: this.columns(), detailed: true }));
+        return "continue";
+      }
       case "palette":
         this.io.write(helpText(this.mode, void 0, true));
         return "continue";
@@ -4336,9 +5373,9 @@ ${preview.diff}
           }
           this.writeLines([
             "",
-            chalk4.bold("Providers"),
+            chalk7.bold("Providers"),
             ...providers.map((choice) => this.formatAgentProviderChoice(choice)),
-            chalk4.dim("  Other providers: /login <id>")
+            chalk7.dim("  Other providers: /login <id>")
           ]);
           if (!this.io.promptLine) {
             throw new ShellParseError("Usage: /login <provider>");
@@ -4526,7 +5563,9 @@ async function startInteractiveShell(options) {
     cwd: options.cwd,
     env: options.env,
     version: options.version,
-    agentModelRuntime: options.agentModelRuntime
+    agentModelRuntime: options.agentModelRuntime,
+    systemProbe: options.systemProbe ?? (() => sampleLiveUsage({ env: { ...process.env, ...options.env } })),
+    columns: () => output.columns
   });
   const completer = createCommandCompleter(() => session.snapshot().mode);
   readline = createInterface2({
@@ -4577,6 +5616,9 @@ async function startInteractiveShell(options) {
   } finally {
     output.write(resetShellPromptStyle());
     readline.close();
+    output.write(`
+${mascotFarewell()}
+`);
   }
 }
 function ciEnabled(value) {
@@ -4589,9 +5631,9 @@ function shouldStartInteractiveShell(options) {
 }
 
 // src/agent.ts
-var accent3 = chalk5.hex("#8B5CF6");
-var successMark2 = () => chalk5.green("\u2713");
-var errorMark2 = () => chalk5.red("\u2717");
+var accent5 = chalk8.hex("#8B5CF6");
+var successMark2 = () => chalk8.green("\u2713");
+var errorMark2 = () => chalk8.red("\u2717");
 var ANSI_CLEAR_LINE2 = "\r\x1B[2K";
 var GUTTER = "  ";
 function isRecord3(value) {
@@ -4602,25 +5644,25 @@ function stringValue(value) {
 }
 function helpText2() {
   return [
-    accent3.bold("Agent commands"),
+    accent5.bold("Agent commands"),
     "",
-    `  ${accent3("/new".padEnd(22))} Start a new conversation.`,
-    `  ${accent3("/threads".padEnd(22))} List recent conversations.`,
-    `  ${accent3("/resume <id>".padEnd(22))} Resume a conversation by ID or prefix.`,
-    `  ${accent3("/approve [id]".padEnd(22))} Approve an action left pending.`,
-    `  ${accent3("/reject [id]".padEnd(22))} Reject an action left pending.`,
-    `  ${accent3("/status".padEnd(22))} Show the active conversation.`,
-    `  ${accent3("/clear".padEnd(22))} Clear the terminal.`,
-    `  ${accent3("/exit".padEnd(22))} Exit the agent.`,
+    `  ${accent5("/new".padEnd(22))} Start a new conversation.`,
+    `  ${accent5("/threads".padEnd(22))} List recent conversations.`,
+    `  ${accent5("/resume <id>".padEnd(22))} Resume a conversation by ID or prefix.`,
+    `  ${accent5("/approve [id]".padEnd(22))} Approve an action left pending.`,
+    `  ${accent5("/reject [id]".padEnd(22))} Reject an action left pending.`,
+    `  ${accent5("/status".padEnd(22))} Show the active conversation.`,
+    `  ${accent5("/clear".padEnd(22))} Clear the terminal.`,
+    `  ${accent5("/exit".padEnd(22))} Exit the agent.`,
     "",
-    chalk5.dim(
+    chalk8.dim(
       "Everything else is sent to the laptop-local Tuned Tensor assistant; known TT commands still run directly in the shell. Proposed changes ask for approval right after the answer."
     ),
     ""
   ].join("\n");
 }
 function formatThread(thread, activeId) {
-  const active = thread.id === activeId ? accent3("\u25CF") : chalk5.dim("\u25CB");
+  const active = thread.id === activeId ? accent5("\u25CF") : chalk8.dim("\u25CB");
   const time = thread.last_message_at ?? thread.updated_at ?? thread.created_at;
   const date = new Date(time);
   const dateLabel = Number.isNaN(date.getTime()) ? "" : date.toLocaleString([], {
@@ -4629,7 +5671,7 @@ function formatThread(thread, activeId) {
     hour: "2-digit",
     minute: "2-digit"
   });
-  return `${active} ${chalk5.dim(thread.id.slice(0, 8))}  ${sanitizeTerminalText(thread.title)}  ${chalk5.dim(dateLabel)}`;
+  return `${active} ${chalk8.dim(thread.id.slice(0, 8))}  ${sanitizeTerminalText(thread.title)}  ${chalk8.dim(dateLabel)}`;
 }
 function actionFromPayload(payload) {
   const value = isRecord3(payload.action) ? payload.action : isRecord3(payload.approval) ? payload.approval : payload;
@@ -4660,14 +5702,14 @@ function formatJson(value) {
 }
 function riskLabel(risk) {
   const safe = sanitizeTerminalText(risk);
-  const color = safe === "low" ? chalk5.green : safe === "high" ? chalk5.red : chalk5.yellow;
+  const color = safe === "low" ? chalk8.green : safe === "high" ? chalk8.red : chalk8.yellow;
   return color(`${safe} risk`);
 }
 function diffStyle(line) {
-  if (line.startsWith("+++") || line.startsWith("---")) return chalk5.dim;
-  if (line.startsWith("+")) return chalk5.green;
-  if (line.startsWith("-")) return chalk5.red;
-  if (line.startsWith("@@")) return chalk5.cyan;
+  if (line.startsWith("+++") || line.startsWith("---")) return chalk8.dim;
+  if (line.startsWith("+")) return chalk8.green;
+  if (line.startsWith("-")) return chalk8.red;
+  if (line.startsWith("@@")) return chalk8.cyan;
   return (text2) => text2;
 }
 function approvalQuestion(action) {
@@ -4805,7 +5847,7 @@ var TunedTensorAgentSession = class {
       wrapped.forEach((part, partIndex) => {
         if (partIndex > 0) this.io.write("\n");
         if (!this.lineOpen || partIndex > 0) {
-          const marker = this.blockStart ? `${accent3("\u25CF")} ` : GUTTER;
+          const marker = this.blockStart ? `${accent5("\u25CF")} ` : GUTTER;
           if (this.blockStart && this.wroteInTurn) this.io.write("\n");
           this.blockStart = false;
           this.wroteInTurn = true;
@@ -4822,11 +5864,11 @@ var TunedTensorAgentSession = class {
   renderAction(action) {
     this.flushResponse();
     this.endOpenLine();
-    const bar = chalk5.yellow("\u2502");
+    const bar = chalk8.yellow("\u2502");
     const out = [
       "",
-      `${GUTTER}${chalk5.yellow.bold("\u25C6 Approval needed")}  ${chalk5.dim(action.id.slice(0, 8))}`,
-      `${GUTTER}${bar} ${chalk5.bold(sanitizeTerminalText(action.title))} ${chalk5.dim("\xB7")} ${riskLabel(action.risk)}`
+      `${GUTTER}${chalk8.yellow.bold("\u25C6 Approval needed")}  ${chalk8.dim(action.id.slice(0, 8))}`,
+      `${GUTTER}${bar} ${chalk8.bold(sanitizeTerminalText(action.title))} ${chalk8.dim("\xB7")} ${riskLabel(action.risk)}`
     ];
     const width = this.wrapWidth();
     const push = (text2, style = (line) => line) => {
@@ -4835,7 +5877,7 @@ var TunedTensorAgentSession = class {
         for (const part of parts) out.push(`${GUTTER}${bar} ${style(part)}`);
       }
     };
-    if (action.summary) push(action.summary, chalk5.dim);
+    if (action.summary) push(action.summary, chalk8.dim);
     if (action.operation === "update_local_spec") {
       const preview = action.preview;
       out.push(`${GUTTER}${bar}`);
@@ -4846,7 +5888,7 @@ var TunedTensorAgentSession = class {
           out.push(`${GUTTER}${bar} ${style(index === 0 ? part : `  ${part}`)}`);
         });
       }
-      for (const warning of preview?.validation?.warnings ?? []) push(`! ${warning}`, chalk5.yellow);
+      for (const warning of preview?.validation?.warnings ?? []) push(`! ${warning}`, chalk8.yellow);
     } else {
       const request2 = [action.method, action.path].filter(Boolean).join(" ");
       const technical = {
@@ -4856,14 +5898,14 @@ var TunedTensorAgentSession = class {
         preview: action.preview ?? null
       };
       out.push(`${GUTTER}${bar}`);
-      push(formatJson(technical), chalk5.dim);
+      push(formatJson(technical), chalk8.dim);
     }
     this.io.write(`${out.join("\n")}
 `);
   }
   writePendingHint() {
     this.io.write(
-      chalk5.dim(`${GUTTER}Nothing changes until you decide: /approve applies it, /reject discards it.
+      chalk8.dim(`${GUTTER}Nothing changes until you decide: /approve applies it, /reject discards it.
 `)
     );
   }
@@ -4880,14 +5922,14 @@ var TunedTensorAgentSession = class {
       const delta = stringValue(payload.delta) ?? stringValue(payload.text) ?? stringValue(payload.content);
       if (!delta) return;
       if (this.reasoningActive) return;
-      this.writeStatus(chalk5.dim("\u25CB Thinking\u2026"), { transient: true });
+      this.writeStatus(`${mascotMark()} ${chalk8.dim("Thinking\u2026")}`, { transient: true });
       this.reasoningActive = true;
       return;
     }
     if (event.type === "tool_call") {
       this.reasoningActive = false;
       const label = toolLabel(payload);
-      this.writeStatus(chalk5.dim(`\u25CB ${label}\u2026`), { transient: true });
+      this.writeStatus(chalk8.dim(`\u25CB ${label}\u2026`), { transient: true });
       const id = stringValue(payload.toolUseId);
       if (id) this.pendingToolLabels.set(id, label);
       else this.pendingUnkeyedToolLabel = label;
@@ -4900,7 +5942,7 @@ var TunedTensorAgentSession = class {
       if (id) this.pendingToolLabels.delete(id);
       else this.pendingUnkeyedToolLabel = null;
       this.writeStatus(
-        `${failed ? errorMark2() : successMark2()} ${chalk5.dim(failed ? `${label} failed` : label)}`
+        `${failed ? errorMark2() : successMark2()} ${chalk8.dim(failed ? `${label} failed` : label)}`
       );
       return;
     }
@@ -4912,7 +5954,7 @@ var TunedTensorAgentSession = class {
       return;
     }
     if (event.type === "action_started") {
-      this.writeStatus(chalk5.dim("\u25CB Running approved action\u2026"));
+      this.writeStatus(chalk8.dim("\u25CB Running approved action\u2026"));
       return;
     }
     if (event.type === "action_result") {
@@ -4959,7 +6001,7 @@ var TunedTensorAgentSession = class {
         }
       }
       if (controller.signal.aborted || result2.status === "cancelled") {
-        this.io.write(chalk5.dim(`${GUTTER}Response stopped.
+        this.io.write(chalk8.dim(`${GUTTER}Response stopped.
 `));
         return null;
       }
@@ -4968,7 +6010,7 @@ var TunedTensorAgentSession = class {
       this.flushResponse();
       this.endOpenLine();
       if (controller.signal.aborted) {
-        this.io.write(chalk5.dim(`${GUTTER}Response stopped.
+        this.io.write(chalk8.dim(`${GUTTER}Response stopped.
 `));
         return null;
       }
@@ -5041,13 +6083,13 @@ var TunedTensorAgentSession = class {
     }
     for (const action of actions) {
       if (!this.pendingActions.has(action.id)) continue;
-      const label = actions.length > 1 ? `${approvalQuestion(action)} ${chalk5.dim(`(${action.title})`)}` : approvalQuestion(action);
-      const decision = await this.prompter(`${GUTTER}${chalk5.yellow("?")} ${chalk5.bold(label)}`);
+      const label = actions.length > 1 ? `${approvalQuestion(action)} ${chalk8.dim(`(${action.title})`)}` : approvalQuestion(action);
+      const decision = await this.prompter(`${GUTTER}${chalk8.yellow("?")} ${chalk8.bold(label)}`);
       try {
         if (decision === "approve") await this.approve(action.id, context);
         else if (decision === "reject") await this.reject(action.id);
         else {
-          this.io.write(chalk5.dim(`${GUTTER}Left pending. Use /approve or /reject when you're ready.
+          this.io.write(chalk8.dim(`${GUTTER}Left pending. Use /approve or /reject when you're ready.
 `));
         }
       } catch (error) {
@@ -5120,7 +6162,7 @@ var TunedTensorAgentSession = class {
         if (args2.length > 0) throw new Error("/threads does not accept arguments.");
         const threads = await this.options.client.listThreads();
         if (threads.length === 0) {
-          this.options.io.write(chalk5.dim("No conversations yet.\n"));
+          this.options.io.write(chalk8.dim("No conversations yet.\n"));
           return "continue";
         }
         this.options.io.write(
@@ -5158,10 +6200,10 @@ var TunedTensorAgentSession = class {
         if (args2.length > 0) throw new Error("/status does not accept arguments.");
         this.options.io.write(
           this.thread ? `${formatThread(this.thread, this.thread.id)}
-` : chalk5.dim("New conversation; send a message to create it.\n")
+` : chalk8.dim("New conversation; send a message to create it.\n")
         );
         this.options.io.write(
-          chalk5.dim(`${this.pendingActions.size} pending approval(s).
+          chalk8.dim(`${this.pendingActions.size} pending approval(s).
 `)
         );
         return "continue";
@@ -5205,10 +6247,10 @@ import {
 } from "fs/promises";
 import {
   basename as basename3,
-  dirname as dirname4,
+  dirname as dirname5,
   isAbsolute as isAbsolute4,
-  join as join8,
-  resolve as resolve4
+  join as join9,
+  resolve as resolve5
 } from "path";
 
 // src/project-spec.ts
@@ -5227,6 +6269,7 @@ var LOCAL_ONLY_SPEC_KEYS = [
   "dataset_prebuilt",
   "engine",
   "foundation",
+  "decision",
   "evaluation",
   "runtime",
   "pipeline"
@@ -5268,7 +6311,7 @@ function projectCloudSpec(raw) {
   return projectSpec(raw, CLOUD_SPEC_KEY_SET, canonicalizeHostedSpecBaseModel);
 }
 function projectLocalSpec(raw) {
-  return projectSpec(raw, LOCAL_SPEC_KEY_SET, canonicalizeSpecBaseModel);
+  return projectSpec(raw, LOCAL_SPEC_KEY_SET, raw.engine === "decision" ? (body) => body : canonicalizeSpecBaseModel);
 }
 function hasLocalOnlySpecFields(raw) {
   return Object.keys(raw).some((key) => LOCAL_ONLY_SPEC_KEY_SET.has(key));
@@ -5383,6 +6426,7 @@ function renderInit(value) {
     ["Path", text(value.path)],
     ["Name", text(value.name)],
     ["ID", text(value.id)],
+    ["Engine", text(value.engine)],
     ["Base model", text(value.base_model)],
     ["Config", text(value.config_path)]
   ]);
@@ -5391,14 +6435,27 @@ function renderValidate(value) {
   printSuccess("Local behavior spec is valid");
   printDetail([
     ["Input", text(value.input_path)],
+    ["Engine", text(value.engine)],
     ["Config", text(value.config_path)],
     ["Spec", text(value.behavior_spec_id)],
     ["Base model", text(value.base_model)],
     ["Dataset", text(value.dataset_format)],
+    ["Hugging Face", huggingFaceDatasetLabel(value)],
     ["Artifacts", text(value.artifact_root)],
     ["Store", text(value.store_root)],
     ["Dry run", text(value.dry_run)]
   ]);
+  if (value.dataset_status === "not_downloaded") {
+    printWarning(`Dataset files are not downloaded yet; dataset contents were not checked. Run \`${text(value.next_step) ?? "tt datasets prefetch"}\`.`);
+  }
+}
+function huggingFaceDatasetLabel(value) {
+  const source = record3(value.dataset_source) ?? record3(value.dataset_huggingface);
+  const repo = text(source?.repo);
+  if (!repo) return void 0;
+  const revision = text(source?.revision) ?? "main";
+  const status2 = value.dataset_status === "not_downloaded" ? "not downloaded" : "cached";
+  return `${repo}@${revision} (${status2}${source?.pinned === false || !text(source?.revision) ? ", unpinned" : ""})`;
 }
 function renderRun(value) {
   const runStatus = text(value.status) ?? "unknown";
@@ -5453,6 +6510,68 @@ function renderRunEvents(value) {
     ])
   );
 }
+function formatSeconds(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return "running";
+  const seconds = Math.round(value);
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const rest = seconds % 60;
+  if (hours) return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  if (minutes) return `${minutes}m ${String(rest).padStart(2, "0")}s`;
+  return `${rest}s`;
+}
+function shortHash(value) {
+  const hash = text(value);
+  return hash ? hash.slice(0, 12) : void 0;
+}
+function renderRunAudit(value) {
+  const verdict = text(value.verdict);
+  const chain = record3(value.chain);
+  const reportInfo = record3(value.report);
+  const findings = Array.isArray(value.findings) ? value.findings.map(String) : [];
+  if (verdict === "verified") printSuccess("Run evidence verified: event log intact and report unchanged since completion");
+  else if (verdict === "tampered") printError("Run evidence does not verify");
+  else printWarning("Run evidence is incomplete");
+  for (const finding of findings) console.log(`  - ${finding}`);
+  printDetail([
+    ["Run", text(value.run_id)],
+    ["Status", status(value.status)],
+    ["Event chain", `${text(chain?.status) ?? "\u2014"} (${text(chain?.chained_events) ?? 0}/${text(chain?.events) ?? 0} chained, head ${shortHash(chain?.head_hash) ?? "\u2014"})`],
+    ["Report sha256", shortHash(reportInfo?.recorded_sha256) ?? "not recorded"]
+  ]);
+  const timeline = rows(value.timeline);
+  if (timeline.length > 0) {
+    console.log("");
+    printTable(
+      ["Started", "Stage", "Duration", "Status"],
+      timeline.map((entry) => [
+        formatDate(text(entry.started_at)),
+        text(entry.stage) ?? "\u2014",
+        formatSeconds(entry.duration_seconds),
+        status(entry.status)
+      ])
+    );
+  }
+  const provenance = record3(value.provenance);
+  if (provenance) {
+    const software = record3(provenance.software);
+    const execution = record3(provenance.execution);
+    const spec = record3(provenance.spec);
+    const baseModel = record3(provenance.base_model);
+    const data3 = record3(provenance.data);
+    const files = record3(data3?.file_sha256) ?? {};
+    console.log("");
+    printDetail([
+      ["TT", `${text(software?.tt_version) ?? "\u2014"} (node ${text(software?.node_version) ?? "\u2014"}, ${text(software?.platform) ?? "\u2014"}/${text(software?.arch) ?? "\u2014"})`],
+      ["Execution", `${text(execution?.target) ?? "\u2014"}${text(execution?.instance_id) ? ` ${text(execution?.instance_id)}` : ""} via ${text(execution?.training_backend) ?? "\u2014"}`],
+      ["Spec", `${text(spec?.file_path) ?? text(spec?.behavior_spec_id) ?? "\u2014"} (sha256 ${shortHash(spec?.file_sha256) ?? shortHash(spec?.snapshot_sha256) ?? "\u2014"})`],
+      ["Base model", `${text(baseModel?.id) ?? "\u2014"}@${shortHash(baseModel?.revision) ?? "unpinned"}`],
+      ...Object.entries(files).map(([split, hash]) => [`Data ${split}`, `sha256 ${shortHash(hash)}`]),
+      ["Training data", `sha256 ${shortHash(data3?.compiled_training_sha256) ?? "\u2014"} (${text(data3?.training_examples) ?? "\u2014"} examples)`],
+      ["Evaluation", `${text(data3?.eval_examples_used) ?? "\u2014"}/${text(data3?.eval_examples_total) ?? "\u2014"} ${text(data3?.eval_split) ?? ""} (seed ${text(data3?.eval_sample_seed) ?? "\u2014"})`]
+    ]);
+  }
+}
 function renderRunRecord(value) {
   printDetail([
     ["Run", text(value.id) ?? text(value.run_id)],
@@ -5558,6 +6677,22 @@ function renderModelPrefetch(value) {
     ["Cache", text(value.model_cache) ?? text(value.hf_home)]
   ]);
 }
+function renderDatasetPrefetch(value) {
+  printSuccess(
+    value.local_files_only === true ? "Verified the cached Hugging Face dataset" : "Dataset is ready locally"
+  );
+  const files = record3(value.files) ?? {};
+  printDetail([
+    ["Dataset", text(value.repo)],
+    ["Revision", `${text(value.revision) ?? "\u2014"}${value.pinned === false ? " (unpinned: set dataset_prebuilt.huggingface.revision to pin it)" : ""}`],
+    ...Object.entries(files).map(([split, file]) => {
+      const entry = record3(file);
+      return [split[0].toUpperCase() + split.slice(1), `${text(entry?.path) ?? "\u2014"} (${displayBytes(entry?.size_bytes) ?? "\u2014"}, sha256 ${String(text(entry?.sha256) ?? "").slice(0, 12)})`];
+    }),
+    ["Snapshot", text(value.snapshot_path)],
+    ["Cache", text(value.hub_cache)]
+  ]);
+}
 function renderActiveModel(value) {
   const active = text(value.active) ?? "base";
   const pointer = record3(value.pointer);
@@ -5659,6 +6794,10 @@ function renderKnownJson(args2, value) {
       renderRunEvents(value);
       return true;
     }
+    if (subcommand === "audit" && isRecord4(value)) {
+      renderRunAudit(value);
+      return true;
+    }
     if (subcommand === "get" && isRecord4(value)) {
       renderRunRecord(value);
       return true;
@@ -5695,6 +6834,10 @@ function renderKnownJson(args2, value) {
       return true;
     }
   }
+  if (command === "datasets" && isRecord4(value)) {
+    renderDatasetPrefetch(value);
+    return true;
+  }
   if (command === "serve" && isRecord4(value)) {
     renderServePlan(value);
     return true;
@@ -5867,10 +7010,18 @@ function positionalSpecArgument(args2, start, defaultPath) {
 function selectedSpecArgument(args2, cwd) {
   const command = args2[0];
   if (["doctor", "validate", "run"].includes(command ?? "")) {
-    return positionalSpecArgument(args2, 1, join8(cwd, DEFAULT_SPEC_NAME));
+    return positionalSpecArgument(args2, 1, join9(cwd, DEFAULT_SPEC_NAME));
   }
   if (command === "models" && ["prefetch", "verify-base"].includes(args2[1] ?? "")) {
-    return positionalSpecArgument(args2, 2, join8(cwd, DEFAULT_SPEC_NAME));
+    return positionalSpecArgument(args2, 2, join9(cwd, DEFAULT_SPEC_NAME));
+  }
+  if (command === "datasets") {
+    if (args2[1] === void 0 || args2[1].startsWith("-") || args2[1].endsWith(".json")) {
+      args2.splice(1, 0, "prefetch");
+    }
+    if (["prefetch", "verify"].includes(args2[1] ?? "")) {
+      return positionalSpecArgument(args2, 2, join9(cwd, DEFAULT_SPEC_NAME));
+    }
   }
   const serves = command === "serve" || command === "models" && args2[1] === "serve";
   if (!serves) return null;
@@ -5883,7 +7034,7 @@ async function pathIsFile(path) {
 }
 function resolveFromCwd(path, cwd) {
   if (isAbsolute4(path)) return path;
-  return resolve4(cwd, path);
+  return resolve5(cwd, path);
 }
 async function projectSpecArguments(originalArgs, cwd) {
   const args2 = [...originalArgs];
@@ -5946,8 +7097,8 @@ async function projectSpecArguments(originalArgs, cwd) {
       }
     };
   }
-  const temporaryPath = join8(
-    dirname4(sourcePath),
+  const temporaryPath = join9(
+    dirname5(sourcePath),
     `.${basename3(sourcePath)}.tt-local-${process.pid}-${randomUUID7()}.json`
   );
   await writeFile4(
@@ -6012,6 +7163,8 @@ function normalizeProjectedPaths(value, replacements) {
 async function spawnLocalCli(args2) {
   const output = args2.stdout ?? process.stdout;
   const errors = args2.stderr ?? process.stderr;
+  const errorTerminal = errors;
+  const childEnv = errorTerminal.isTTY && !args2.jsonMode && args2.env.TT_PROGRESS_TTY === void 0 ? { ...args2.env, TT_PROGRESS_TTY: "1", TT_PROGRESS_COLUMNS: String(errorTerminal.columns ?? 100) } : args2.env;
   const pipeInput = Boolean(args2.stdin && args2.stdin !== process.stdin);
   const pipeStreamingOutput = args2.streamingStdout && Boolean(args2.stdout && args2.stdout !== process.stdout);
   const child = spawn(
@@ -6019,7 +7172,7 @@ async function spawnLocalCli(args2) {
     [args2.entrypoint, ...args2.commandArgs],
     {
       cwd: args2.cwd,
-      env: args2.env,
+      env: childEnv,
       stdio: [
         pipeInput ? "pipe" : "inherit",
         args2.streamingStdout && !pipeStreamingOutput ? "inherit" : "pipe",
@@ -6109,7 +7262,7 @@ function setupFailure(originalArgs, error) {
   };
 }
 async function runLocalCommand(args2, options = {}) {
-  const cwd = resolve4(options.cwd ?? process.cwd());
+  const cwd = resolve5(options.cwd ?? process.cwd());
   let projected;
   try {
     const entrypoint = options.entrypoint ?? resolveLocalCliEntrypoint();
@@ -6155,7 +7308,7 @@ async function executeLocalCommand(args2, options = {}) {
 }
 
 // src/commands/local.ts
-import chalk6 from "chalk";
+import chalk9 from "chalk";
 
 // src/passthrough.ts
 function extractPassthroughOptions(args2, root) {
@@ -6183,7 +7336,8 @@ var LOCAL_COMMANDS = [
   "validate",
   "serve",
   "runs",
-  "models"
+  "models",
+  "datasets"
 ];
 var LOCAL_COMMAND_DESCRIPTIONS = {
   info: "Show the installed local runtime version and runner status",
@@ -6193,7 +7347,8 @@ var LOCAL_COMMAND_DESCRIPTIONS = {
   validate: "Validate a local behavior spec without executing it",
   serve: "Serve a verified adapter, the active model, or the protected base",
   runs: "Inspect locally stored runs",
-  models: "Inspect, verify, prefetch, or serve local models"
+  models: "Inspect, verify, prefetch, or serve local models",
+  datasets: "Download or verify the Hugging Face dataset a spec trains on"
 };
 function applyExitCode(result2) {
   if (result2?.exitCode !== null && result2?.exitCode !== void 0) {
@@ -6210,7 +7365,7 @@ function registerLocalCommands(program, runtime) {
   const runPassthrough = async (forwarded) => {
     const root = program.opts();
     const passthrough = extractPassthroughOptions(forwarded, root);
-    if (!passthrough.color) chalk6.level = 0;
+    if (!passthrough.color) chalk9.level = 0;
     const result2 = await runtime.invokeLocal(
       passthrough.args.length > 0 ? passthrough.args : ["--help"],
       {
@@ -6308,12 +7463,12 @@ function registerAgentCommands(parent, options) {
 }
 
 // src/commands/pipeline.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname7, join as join11, resolve as resolve6 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname9, join as join13, resolve as resolve8 } from "path";
 
 // src/local-runtime/project-migration.ts
 import { lstat as lstat5, readFile as readFile5, rename as rename3, writeFile as writeFile5, unlink as unlink3 } from "fs/promises";
-import { dirname as dirname5, join as join9 } from "path";
+import { dirname as dirname6, join as join10 } from "path";
 async function migrateProjectWorkflow(specPath) {
   const info = await lstat5(specPath);
   if (!info.isFile() || info.isSymbolicLink()) throw new Error("Migration requires a regular spec file.");
@@ -6324,7 +7479,7 @@ async function migrateProjectWorkflow(specPath) {
   const files = [];
   const sources = /* @__PURE__ */ new Map([[specPath, original]]);
   for (const name of ["tunedtensor.pipeline.json", "local-runner.json"]) {
-    const path = join9(dirname5(specPath), name);
+    const path = join10(dirname6(specPath), name);
     const entry = await lstat5(path).catch((error) => {
       if (error.code === "ENOENT") return void 0;
       throw error;
@@ -6392,7 +7547,7 @@ async function migrateProjectWorkflow(specPath) {
 import { createHash as createHash5, randomUUID as randomUUID8 } from "crypto";
 import { createReadStream } from "fs";
 import { chmod as chmod2, lstat as lstat6, mkdir as mkdir4, open as open3, readdir as readdir4, readFile as readFile6, rename as rename4, rm as rm3 } from "fs/promises";
-import { basename as basename4, dirname as dirname6, join as join10, resolve as resolve5 } from "path";
+import { basename as basename4, dirname as dirname7, join as join11, resolve as resolve6 } from "path";
 var INSTRUCTION_CORPUS_VERSION = 1;
 function isRef(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value) && typeof value.from === "string";
@@ -6421,7 +7576,7 @@ async function hashPath(path) {
   if (info.isDirectory()) {
     for (const name of (await readdir4(path)).sort()) {
       hash.update(name);
-      hash.update(await hashPath(join10(path, name)));
+      hash.update(await hashPath(join11(path, name)));
     }
     return hash.digest("hex");
   }
@@ -6444,7 +7599,7 @@ async function makePrivateTree(path) {
   if (info.isDirectory()) {
     await chmod2(path, 448);
     for (const name of await readdir4(path)) {
-      await makePrivateTree(join10(path, name));
+      await makePrivateTree(join11(path, name));
     }
     return;
   }
@@ -6473,7 +7628,7 @@ async function readRequiredJsonObject(path, description) {
   return parsed;
 }
 async function writePrivateTextAtomic(path, content) {
-  const temporary = join10(dirname6(path), `.${basename4(path)}.${randomUUID8()}.tmp`);
+  const temporary = join11(dirname7(path), `.${basename4(path)}.${randomUUID8()}.tmp`);
   const file = await open3(temporary, "wx", 384);
   let closed = false;
   try {
@@ -6588,8 +7743,8 @@ ${result2.stderr}` : ""}`
 async function runFoundationPipeline(args2) {
   assertFoundationPlanSupported(args2.spec, args2.plan);
   assertFoundationSettingsMatch(args2.spec.foundation, args2.plan);
-  const outputDir = resolve5(
-    args2.outputDir ?? (args2.spec.runtime?.artifactRoot ? join10(resolve5(dirname6(args2.specPath), args2.spec.runtime.artifactRoot), "foundation-runs", randomUUID8()) : join10(dirname6(resolve5(args2.specPath)), DEFAULT_FOUNDATION_RUNS_DIR, randomUUID8()))
+  const outputDir = resolve6(
+    args2.outputDir ?? (args2.spec.runtime?.artifactRoot ? join11(resolve6(dirname7(args2.specPath), args2.spec.runtime.artifactRoot), "foundation-runs", randomUUID8()) : join11(dirname7(resolve6(args2.specPath)), DEFAULT_FOUNDATION_RUNS_DIR, randomUUID8()))
   );
   if (args2.gpu && args2.spec.foundation.checkpoint_backup_dir && localPathsOverlap(outputDir, args2.spec.foundation.checkpoint_backup_dir)) {
     throw new Error("AWS checkpoint_backup_dir must be separate from the foundation run directory; overlapping backups can overwrite returned checkpoints.");
@@ -6614,7 +7769,7 @@ async function runFoundationPipeline(args2) {
     await mkdir4(outputDir, { recursive: true, mode: 448 });
   }
   await makePrivateTree(outputDir);
-  const workflowPath = join10(outputDir, "resolved-workflow.json");
+  const workflowPath = join11(outputDir, "resolved-workflow.json");
   const workflow = { spec: args2.spec, plan: args2.plan };
   if (outputExists) {
     const previous = await readFile6(workflowPath, "utf8").catch((error) => {
@@ -6647,16 +7802,16 @@ async function runFoundationPipeline(args2) {
     throw new Error(`Missing ${kind} artifact.`);
   };
   for (const step of args2.plan.steps) {
-    const stepDir = join10(outputDir, step.id);
-    const output = join10(stepDir, "output");
+    const stepDir = join11(outputDir, step.id);
+    const output = join11(stepDir, "output");
     await mkdir4(stepDir, { recursive: true, mode: 448 });
     await chmod2(stepDir, 448);
     await mkdir4(output, { recursive: true, mode: 448 });
     await chmod2(output, 448);
-    const configPath2 = join10(stepDir, "config.json");
-    const logPath = join10(stepDir, "step.log");
-    const metricsPath = join10(output, "metrics.json");
-    const completionPath = join10(stepDir, "completion.json");
+    const configPath2 = join11(stepDir, "config.json");
+    const logPath = join11(stepDir, "step.log");
+    const metricsPath = join11(output, "metrics.json");
+    const completionPath = join11(stepDir, "completion.json");
     const fields = stepConfig(step);
     let entrypoint;
     let config;
@@ -6677,7 +7832,7 @@ async function runFoundationPipeline(args2) {
       config = {
         tokenizer_dir: tokenizerDir,
         output_dir: output,
-        work_dir: join10(stepDir, "recovery"),
+        work_dir: join11(stepDir, "recovery"),
         depth: fields.depth ?? hp.depth,
         steps: fields.steps ?? hp.pretrain_steps,
         batch_size: fields.batchSize ?? hp.batch_size,
@@ -6782,15 +7937,15 @@ async function runFoundationPipeline(args2) {
     const artifacts = {};
     const record4 = {};
     if (step.uses === "tokenize") {
-      const tokenizerPath = join10(output, "tokenizer.json");
+      const tokenizerPath = join11(output, "tokenizer.json");
       await requireRegularNonemptyFile(tokenizerPath, `Foundation step "${step.id}" tokenizer.json`);
       await readRequiredJsonObject(tokenizerPath, `Foundation step "${step.id}" tokenizer.json`);
       record4.tokenizer = output;
       tokenizerDir = output;
       artifacts.tokenizer = await artifactFor(output);
     } else if (step.uses === "pretrain" || step.uses === "finetune" || step.uses === "rl") {
-      const modelPath = join10(output, "model.safetensors");
-      const modelConfigPath = join10(output, "config.json");
+      const modelPath = join11(output, "model.safetensors");
+      const modelConfigPath = join11(output, "config.json");
       await requireRegularNonemptyFile(modelPath, `Foundation step "${step.id}" model.safetensors`);
       const modelConfig = await readRequiredJsonObject(
         modelConfigPath,
@@ -6805,7 +7960,7 @@ async function runFoundationPipeline(args2) {
       modelDir = output;
       artifacts.model = await artifactFor(output);
     } else if (step.uses === "evaluate") {
-      const reportPath2 = join10(output, "report.json");
+      const reportPath2 = join11(output, "report.json");
       const stepReport = await readRequiredJsonObject(
         reportPath2,
         `Foundation step "${step.id}" report.json`
@@ -6845,7 +8000,7 @@ async function runFoundationPipeline(args2) {
     spec: args2.specPath,
     steps
   };
-  const reportPath = join10(outputDir, "report.json");
+  const reportPath = join11(outputDir, "report.json");
   await writePrivateTextAtomic(reportPath, `${JSON.stringify(report, null, 2)}
 `);
   return {
@@ -6856,6 +8011,334 @@ async function runFoundationPipeline(args2) {
   };
 }
 
+// src/local-runtime/decision-runner.ts
+import { randomUUID as randomUUID9 } from "crypto";
+import { lstat as lstat7, mkdir as mkdir5, readFile as readFile7, rename as rename5, rm as rm4, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname8, join as join12, resolve as resolve7 } from "path";
+var PROBABILITY_FLOOR = 1e-6;
+function assertDecisionPlanSupported(plan) {
+  for (const step of plan.steps) {
+    if (step.uses === "evaluate" && step.with.evaluator !== "behavior") {
+      throw new Error(`Decision runner evaluates with the behavior evaluator; step ${step.id} uses ${step.with.evaluator}.`);
+    }
+    if (!["train", "evaluate", "compare"].includes(step.uses)) {
+      throw new Error(`Decision runner does not implement ${step.uses} (step ${step.id}).`);
+    }
+  }
+}
+function decisionQuestion(spec) {
+  return { ...spec.decision, instructions: buildSystemMessage(spec) };
+}
+function canonicalLabel(labels, output) {
+  const normalized = output.trim().toLowerCase();
+  const label = labels.find((candidate) => candidate.trim().toLowerCase() === normalized);
+  if (!label) throw new Error(`Example output ${JSON.stringify(output)} is not a decision label (${labels.join(", ")}).`);
+  return label;
+}
+async function readPredictions(path, ids, labels) {
+  const rows2 = (await readFile7(path, "utf8")).split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  if (rows2.length !== ids.length || new Set(rows2.map((row) => row.id)).size !== rows2.length) {
+    throw new Error(`Decision predictions must contain exactly one row per evaluation ID: ${path}`);
+  }
+  for (const row of rows2) validatePrediction(row, labels);
+  const byId = new Map(rows2.map((row) => [row.id, row]));
+  return ids.map((id) => {
+    const row = byId.get(id);
+    if (!row) throw new Error(`Decision predictions are missing row ${id}: ${path}`);
+    if (!labels.includes(row.prediction)) throw new Error(`Decision prediction for ${id} is not a label: ${row.prediction}`);
+    return row;
+  });
+}
+function validatePrediction(row, labels) {
+  const values = row?.probabilities;
+  if (!values || Object.keys(values).length !== labels.length || labels.some((label) => !Object.hasOwn(values, label) || !Number.isFinite(values[label]) || values[label] < 0 || values[label] > 1)) {
+    throw new Error("Decision probabilities must contain a finite probability for every label.");
+  }
+  const sum = labels.reduce((total, label) => total + values[label], 0);
+  const maximum = Math.max(...labels.map((label) => values[label]));
+  const sumTolerance = labels.length * 5e-5 + 1e-8;
+  const tolerance = 2e-5;
+  if (Math.abs(sum - 1) > sumTolerance || !labels.includes(row.prediction) || Math.abs(values[row.prediction] - maximum) > tolerance || !Number.isFinite(row.confidence) || Math.abs(row.confidence - maximum) > tolerance || !Number.isFinite(row.latency_ms) || row.latency_ms < 0) {
+    throw new Error("Decision prediction must have normalized probabilities, an argmax label, matching confidence and nonnegative latency.");
+  }
+}
+function scoreDecisionPredictions(args2) {
+  if (args2.predictions.length !== args2.examples.length) {
+    throw new Error("Decision prediction count must match the evaluation examples.");
+  }
+  for (const prediction of args2.predictions) validatePrediction(prediction, args2.labels);
+  const perLabel = Object.fromEntries(
+    args2.labels.map((label) => [label, { support: 0, correct: 0, recall: 0 }])
+  );
+  let logLoss = 0;
+  let brier = 0;
+  let confidence = 0;
+  const results = args2.examples.map((example, index) => {
+    const prediction = args2.predictions[index];
+    const passed = prediction.prediction === example.output;
+    const expectedProbability = prediction.probabilities[example.output] ?? 0;
+    logLoss -= Math.log(Math.max(expectedProbability, PROBABILITY_FLOOR));
+    brier += args2.labels.reduce((sum, label) => {
+      const target = label === example.output ? 1 : 0;
+      return sum + ((prediction.probabilities[label] ?? 0) - target) ** 2;
+    }, 0);
+    confidence += prediction.confidence;
+    const entry = perLabel[example.output];
+    entry.support += 1;
+    if (passed) entry.correct += 1;
+    return {
+      prompt: example.input,
+      expected: example.output,
+      actual: prediction.prediction,
+      passed,
+      score: passed ? 1 : 0,
+      reasoning: `p(expected)=${expectedProbability.toFixed(4)}; confidence=${prediction.confidence.toFixed(4)}`,
+      latency_ms: Math.max(0, Math.round(prediction.latency_ms)),
+      scored_by: "exact_match"
+    };
+  });
+  for (const entry of Object.values(perLabel)) entry.recall = entry.support ? entry.correct / entry.support : 0;
+  const total = results.length;
+  const mean = (value) => total ? value / total : 0;
+  const accuracy = mean(results.filter((result2) => result2.passed).length);
+  const report = evalReportSchema.parse({
+    kind: args2.kind,
+    model_id: args2.modelId,
+    total,
+    eval_examples_total: total,
+    eval_examples_used: total,
+    eval_truncated: false,
+    eval_split: "spec_holdout",
+    eval_sample_seed: args2.sampleSeed,
+    avg_score: accuracy,
+    pass_rate: accuracy,
+    exact_match_rate: accuracy,
+    avg_latency_ms: Math.round(mean(results.reduce((sum, result2) => sum + result2.latency_ms, 0))),
+    results,
+    artifact_uri: fileUri(args2.outputPath),
+    scoring_method: "exact_match",
+    scoring_mode: "exact_match"
+  });
+  return {
+    report,
+    metrics: {
+      accuracy,
+      log_loss: mean(logLoss),
+      brier: mean(brier),
+      mean_confidence: mean(confidence),
+      per_label: perLabel
+    }
+  };
+}
+async function defaultDecisionSpawn(args2) {
+  const launched = buildDecisionPythonCommand(args2.entrypoint, ["--config", args2.configPath]);
+  const result2 = await runLoggedProcess({
+    command: launched.command,
+    commandArgs: launched.commandArgs,
+    env: withDecisionPythonEnvironment(process.env),
+    logPath: args2.logPath,
+    stage: args2.stepId,
+    appendLog: true,
+    onLine: (line, stream) => {
+      if (stream !== "stdout" || !args2.onProgress) return;
+      try {
+        const event = JSON.parse(line);
+        if (event.event === "step") {
+          args2.onProgress(`${args2.stepId}: step ${event.step}/${event.total_steps} (epoch ${event.epoch}) loss ${event.loss}`);
+        }
+      } catch {
+      }
+    }
+  });
+  if (result2.exitCode !== 0) {
+    throw new Error(
+      `Decision step "${args2.stepId}" failed (exit ${result2.exitCode}). Log: ${args2.logPath}${result2.stderr ? `
+${result2.stderr}` : ""}`
+    );
+  }
+}
+async function requireRegularNonemptyFile2(path, description) {
+  const info = await lstat7(path).catch(() => null);
+  if (!info || info.isSymbolicLink() || !info.isFile() || info.size === 0) {
+    throw new Error(`${description} must be a non-empty regular file: ${path}`);
+  }
+}
+async function readJsonObject2(path, description) {
+  const parsed = JSON.parse(await readFile7(path, "utf8").catch((error) => {
+    throw new Error(`${description} is missing or unreadable: ${path}`, { cause: error });
+  }));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${description} must be a JSON object: ${path}`);
+  }
+  return parsed;
+}
+async function writePrivateAtomic(path, content) {
+  await mkdir5(dirname8(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${process.pid}.${randomUUID9()}.tmp`;
+  try {
+    await writeFile6(temporary, content, { encoding: "utf8", mode: 384, flag: "wx" });
+    await rename5(temporary, path);
+  } finally {
+    await rm4(temporary, { force: true });
+  }
+}
+async function writePrivateJson2(path, value) {
+  await writePrivateAtomic(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function producer(reference) {
+  return reference.slice(0, reference.lastIndexOf("."));
+}
+function jsonl(rows2) {
+  return rows2.map((row) => JSON.stringify(row)).join("\n") + "\n";
+}
+async function runDecisionPipeline(args2) {
+  assertDecisionPlanSupported(args2.plan);
+  const model = resolveDecisionModel(args2.spec.base_model);
+  const specDir = dirname8(resolve7(args2.specPath));
+  const outputDir = resolve7(args2.outputDir ?? (args2.spec.runtime?.artifactRoot ? join12(resolve7(specDir, args2.spec.runtime.artifactRoot), "decision-runs", randomUUID9()) : join12(specDir, DEFAULT_DECISION_RUNS_DIR, randomUUID9())));
+  if (await lstat7(outputDir).catch(() => null)) {
+    throw new Error(`Decision output directory already exists: ${outputDir}`);
+  }
+  await mkdir5(outputDir, { recursive: true, mode: 448 });
+  const labels = decisionLabels(args2.spec.decision);
+  const question = decisionQuestion(args2.spec);
+  const examples = args2.spec.examples.map((example) => ({
+    input: example.input,
+    output: canonicalLabel(labels, example.output)
+  }));
+  const seed = deriveSampleSeed(args2.spec.id ?? args2.spec.name);
+  const split = splitSpecExamples(examples, seed);
+  if (!split.train.length || !split.holdout.length) {
+    throw new Error("Decision runs need at least one training and one held-out example.");
+  }
+  const hp = args2.spec.hyperparameters ?? {};
+  const device = hp.device ?? "auto";
+  const evalIds = split.holdout.map((_, index) => `eval-${index}`);
+  const dataDir = join12(outputDir, "data");
+  await mkdir5(dataDir, { recursive: true, mode: 448 });
+  const trainPath = join12(dataDir, "train.jsonl");
+  const evalInputsPath = join12(dataDir, "eval-inputs.jsonl");
+  await writePrivateAtomic(trainPath, jsonl(split.train));
+  await writePrivateAtomic(evalInputsPath, jsonl(split.holdout.map((example, index) => ({ id: evalIds[index], input: example.input }))));
+  await writePrivateJson2(join12(outputDir, "resolved-workflow.json"), {
+    spec: args2.spec,
+    plan: args2.plan,
+    model: { id: model.id, revision: model.revision },
+    question,
+    split: { seed, train: split.train.length, eval: split.holdout.length }
+  });
+  const spawnStep = args2.spawnStep ?? defaultDecisionSpawn;
+  const producedModels = /* @__PURE__ */ new Map();
+  const reports = /* @__PURE__ */ new Map();
+  const steps = [];
+  let tunedModelDir;
+  for (const step of args2.plan.steps) {
+    const stepDir = join12(outputDir, step.id);
+    await mkdir5(stepDir, { recursive: true, mode: 448 });
+    const configPath2 = join12(stepDir, "config.json");
+    const logPath = join12(stepDir, "step.log");
+    const metricsPath = join12(stepDir, "metrics.json");
+    if (step.uses === "train") {
+      const modelDir = join12(stepDir, "model");
+      args2.onProgress?.(`${step.id}: fine-tuning ${model.id} on ${split.train.length} examples (log: ${logPath})`);
+      await writePrivateJson2(configPath2, {
+        model: model.id,
+        revision: model.revision,
+        question,
+        train_path: trainPath,
+        output_dir: modelDir,
+        metrics_path: metricsPath,
+        epochs: hp.n_epochs ?? model.defaultEpochs,
+        learning_rate: hp.learning_rate ?? model.defaultLearningRate,
+        batch_size: hp.batch_size ?? model.defaultBatchSize,
+        freeze_encoder: hp.freeze_encoder ?? false,
+        shuffle_options: hp.shuffle_options ?? true,
+        seed: hp.seed ?? 0,
+        device
+      });
+      await spawnStep({ entrypoint: "train.py", configPath: configPath2, logPath, stepId: step.id, onProgress: args2.onProgress });
+      const metrics = await readJsonObject2(metricsPath, `Decision step "${step.id}" metrics`);
+      if (metrics.ok !== true) throw new Error(`Decision step "${step.id}" metrics must report ok: true.`);
+      await requireRegularNonemptyFile2(join12(modelDir, "model.safetensors"), `Decision step "${step.id}" model.safetensors`);
+      await readJsonObject2(join12(modelDir, "rl_agent_config.json"), `Decision step "${step.id}" rl_agent_config.json`);
+      producedModels.set(step.id, modelDir);
+      tunedModelDir = modelDir;
+      steps.push({ id: step.id, uses: step.uses, model: modelDir, training: metrics });
+      continue;
+    }
+    if (step.uses === "evaluate") {
+      const source = step.with.model;
+      const tuned = source !== "base";
+      const modelDir = tuned ? producedModels.get(producer(source.from)) : void 0;
+      if (tuned && !modelDir) throw new Error(`Step ${step.id} needs a model from ${source.from}.`);
+      const predictionsPath = join12(stepDir, "predictions.jsonl");
+      args2.onProgress?.(`${step.id}: evaluating ${tuned ? "tuned" : "base"} model on ${split.holdout.length} held-out examples`);
+      await writePrivateJson2(configPath2, {
+        model: modelDir ?? model.id,
+        ...tuned ? {} : { revision: model.revision },
+        question,
+        inputs_path: evalInputsPath,
+        output_path: predictionsPath,
+        metrics_path: metricsPath,
+        device
+      });
+      await spawnStep({ entrypoint: "evaluate.py", configPath: configPath2, logPath, stepId: step.id, onProgress: args2.onProgress });
+      const metrics = await readJsonObject2(metricsPath, `Decision step "${step.id}" metrics`);
+      if (metrics.ok !== true) throw new Error(`Decision step "${step.id}" metrics must report ok: true.`);
+      const reportPath2 = join12(stepDir, "report.json");
+      const scored = scoreDecisionPredictions({
+        kind: tuned ? "candidate" : "baseline",
+        modelId: modelDir ? fileUri(modelDir) : model.id,
+        labels,
+        examples: split.holdout,
+        predictions: await readPredictions(predictionsPath, evalIds, labels),
+        outputPath: reportPath2,
+        sampleSeed: seed
+      });
+      await writePrivateJson2(reportPath2, { ...scored.report, decision_metrics: scored.metrics });
+      reports.set(step.id, scored);
+      steps.push({ id: step.id, uses: step.uses, model: modelDir ?? model.id, report: scored.report, decision_metrics: scored.metrics });
+      continue;
+    }
+    if (step.uses !== "compare") throw new Error(`Decision runner does not implement ${step.uses} (step ${step.id}).`);
+    const before = reports.get(producer(step.with.before.from));
+    const after = reports.get(producer(step.with.after.from));
+    if (!before || !after) throw new Error(`Step ${step.id} needs both evaluation reports.`);
+    const comparison = {
+      ...compareEvalReports(before.report, after.report),
+      log_loss_delta: after.metrics.log_loss - before.metrics.log_loss,
+      brier_delta: after.metrics.brier - before.metrics.brier
+    };
+    await writePrivateJson2(join12(stepDir, "comparison.json"), comparison);
+    steps.push({ id: step.id, uses: step.uses, comparison });
+  }
+  const reportPath = join12(outputDir, "report.json");
+  const report = {
+    status: "succeeded",
+    engine: "decision",
+    ...args2.plan.name ? { name: args2.plan.name } : {},
+    spec: resolve7(args2.specPath),
+    base_model: model.id,
+    base_model_revision: model.revision,
+    question: { type: question.type, labels },
+    split: { seed, train: split.train.length, eval: split.holdout.length, eval_split: "spec_holdout" },
+    ...tunedModelDir ? { model_dir: tunedModelDir } : {},
+    steps,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writePrivateJson2(reportPath, report);
+  return {
+    status: "succeeded",
+    engine: "decision",
+    ...args2.plan.name ? { name: args2.plan.name } : {},
+    run_dir: outputDir,
+    report_path: reportPath,
+    ...tunedModelDir ? { model_dir: tunedModelDir } : {},
+    steps
+  };
+}
+
 // src/commands/pipeline.ts
 var DEFAULT_SPEC_FILE = "tunedtensor.json";
 function parseList(value) {
@@ -6865,10 +8348,10 @@ function parseList(value) {
   return ids;
 }
 function loadPipelineFile(path) {
-  const resolved = resolve6(path);
+  const resolved = resolve8(path);
   if (!existsSync4(resolved)) throw new Error(`Pipeline file not found: ${path}. Run \`tt pipeline init\` to create one.`);
   try {
-    return JSON.parse(readFileSync5(resolved, "utf8"));
+    return JSON.parse(readFileSync6(resolved, "utf8"));
   } catch (error) {
     throw new Error(`Pipeline file must be JSON: ${error.message}`);
   }
@@ -6877,23 +8360,27 @@ function pipelineFromSpec(input) {
   return pipelineFromFoundationHyperparameters(input.spec.name, input.spec.foundation);
 }
 function resolvePipelineDocument(options, specRequired) {
-  const specPath = resolve6(options.spec);
+  const specPath = resolve8(options.spec);
   const requested = options.file ? loadPipelineFile(options.file) : void 0;
   if (!existsSync4(specPath)) {
     if (specRequired) throw new Error(`Behavior spec not found: ${options.spec}.`);
     if (requested !== void 0) return { document: parsePipeline(requested) };
     throw new Error(`Behavior spec not found: ${options.spec}. Create tunedtensor.json or pass an explicit --file for a recipe-only preview.`);
   }
-  const source = readFileSync5(specPath, "utf8");
+  const source = readFileSync6(specPath, "utf8");
   const input = parseLocalRunInput(JSON.parse(source), specPath);
   const document = pipelineForRunInput(input, requested);
   const spec = {
     path: specPath,
     sha256: specHash(source),
-    engine: input.kind === "foundation-spec" ? "foundation" : "adapter"
+    engine: specEngine(input)
   };
   return { document, input, spec };
 }
+function specEngine(input) {
+  if (input.kind === "foundation-spec") return "foundation";
+  return input.kind === "decision-spec" ? "decision" : "adapter";
+}
 function outputPlan(plan, hostWarnings = []) {
   if (isJsonMode()) {
     return printJson(hostWarnings.length ? { ...plan, host_warnings: hostWarnings } : plan);
@@ -6910,16 +8397,35 @@ function outputPlan(plan, hostWarnings = []) {
 async function hostWarningsForPipeline(document, input) {
   const snapshot = await readHardwareSnapshot();
   if (!snapshot) return [];
+  if (input?.kind === "decision-spec") return warningsFromSnapshot(snapshot.capabilities, { engine: "decision" });
   const engine = isFoundationPipeline(parsePipeline(document)) ? "foundation" : "adapter";
   const baseModel = input && input.kind !== "foundation-spec" ? input.request.spec_snapshot.base_model : void 0;
   return warningsFromSnapshot(snapshot.capabilities, { engine, baseModel });
 }
+function percent(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function printDecisionSummary(result2) {
+  for (const step of result2.steps) {
+    if (step.decision_metrics) {
+      const metrics = step.decision_metrics;
+      console.log(`${step.id.padEnd(12)} accuracy ${percent(metrics.accuracy)}  log-loss ${metrics.log_loss.toFixed(3)}  brier ${metrics.brier.toFixed(3)}  (${step.report?.total ?? 0} held-out)`);
+    }
+    if (step.comparison) {
+      const comparison = step.comparison;
+      const sign = (value) => value >= 0 ? "+" : "";
+      console.log(`${step.id.padEnd(12)} accuracy ${sign(comparison.pass_rate_delta)}${percent(comparison.pass_rate_delta)}  log-loss ${sign(comparison.log_loss_delta)}${comparison.log_loss_delta.toFixed(3)}  improved ${comparison.improvements}, regressed ${comparison.regressions}`);
+    }
+  }
+  if (result2.model_dir) console.log(`Tuned decision model: ${result2.model_dir}`);
+  printSuccess(`Decision pipeline completed. Report: ${result2.report_path}`);
+}
 function registerPipelineCommands(parent) {
   const pipeline2 = parent.command("pipeline").description("Create, validate, inspect, and safely dry-run ordered pipeline recipes");
   pipeline2.command("init").description("Write a canonical v1 pipeline recipe").option("-f, --file <path>", "Legacy standalone recipe output (default: embed in tunedtensor.json)").option("--engine <engine>", "adapter (default) or foundation").option("--spec <path>", "Foundation spec whose hyperparameters stamp the DAG").action(async (options) => {
     if (!options.file) {
-      const path2 = resolve6(options.spec ?? DEFAULT_SPEC_FILE);
-      const raw = JSON.parse(readFileSync5(path2, "utf8"));
+      const path2 = resolve8(options.spec ?? DEFAULT_SPEC_FILE);
+      const raw = JSON.parse(readFileSync6(path2, "utf8"));
       const input = parseLocalRunInput(raw, path2);
       if (input.kind === "request") throw new Error("Pipeline init requires a behavior spec.");
       if (options.engine && options.engine !== (input.spec.engine ?? "adapter")) throw new Error("--engine must match the spec.");
@@ -6937,12 +8443,12 @@ function registerPipelineCommands(parent) {
     if (engine !== "foundation" && options.spec) {
       throw new Error("--spec is only valid with --engine foundation.");
     }
-    const path = resolve6(options.file);
+    const path = resolve8(options.file);
     if (existsSync4(path)) throw new Error(`Pipeline file already exists: ${options.file}.`);
     let recipe;
     if (engine === "foundation") {
       if (options.spec) {
-        const input = await loadLocalRunInput(resolve6(options.spec));
+        const input = await loadLocalRunInput(resolve8(options.spec));
         if (input.kind !== "foundation-spec") {
           throw new Error("--spec must be a foundation tunedtensor.json.");
         }
@@ -6959,7 +8465,7 @@ function registerPipelineCommands(parent) {
     printSuccess(`Created ${options.file}`);
   });
   pipeline2.command("migrate").description("Move legacy configuration into tunedtensor.json, retaining .bak copies").option("--spec <path>", "Local behavior spec", DEFAULT_SPEC_FILE).action(async (options) => {
-    const result2 = await migrateProjectWorkflow(resolve6(options.spec));
+    const result2 = await migrateProjectWorkflow(resolve8(options.spec));
     if (isJsonMode()) return printJson(result2);
     printSuccess(result2.migrated ? `Migrated ${result2.path}; originals retained as .bak files.` : "No legacy configuration found.");
   });
@@ -6983,7 +8489,7 @@ function registerPipelineCommands(parent) {
     const plan = createExecutionPlan(document, { only: parseList(options.only), skip: parseList(options.skip) });
     outputPlan({ ...plan, ...spec ? { spec } : {} }, await hostWarningsForPipeline(document, input));
   });
-  pipeline2.command("run").description("Run an ordered local pipeline, or safely preview any pipeline").option("--dry-run", "Resolve and display only; never execute, transfer, or reserve credits").option("-f, --file <path>", "Explicit pipeline recipe (default: derive from behavior spec)").option("--spec <path>", "Local behavior spec", DEFAULT_SPEC_FILE).option("--config <path>", "Local runtime config").option("--output <path>", "Foundation run directory (must not already exist)").option("--resume <path>", "Resume a foundation run directory").option("--only <ids>", "Comma-separated step IDs to include").option("--skip <ids>", "Comma-separated step IDs to omit").action(async (options, command) => {
+  pipeline2.command("run").description("Run an ordered local pipeline, or safely preview any pipeline").option("--dry-run", "Resolve and display only; never execute, transfer, or reserve credits").option("-f, --file <path>", "Explicit pipeline recipe (default: derive from behavior spec)").option("--spec <path>", "Local behavior spec", DEFAULT_SPEC_FILE).option("--config <path>", "Local runtime config").option("--output <path>", "Foundation or decision run directory (must not already exist)").option("--resume <path>", "Resume a foundation run directory").option("--only <ids>", "Comma-separated step IDs to include").option("--skip <ids>", "Comma-separated step IDs to omit").option("--verbose", "Also stream training and evaluation process logs").option("--quiet", "Do not print live stage progress").action(async (options, command) => {
     if (options.output && options.resume) {
       throw new Error("--output and --resume are mutually exclusive.");
     }
@@ -7016,8 +8522,8 @@ function registerPipelineCommands(parent) {
       const result3 = await runFoundationPipeline({
         spec: input.spec,
         plan,
-        specPath: resolve6(options.spec),
-        ...options.output || options.resume ? { outputDir: resolve6(options.resume ?? options.output) } : {},
+        specPath: resolve8(options.spec),
+        ...options.output || options.resume ? { outputDir: resolve8(options.resume ?? options.output) } : {},
         resume: Boolean(options.resume),
         gpu: config.gpu
       });
@@ -7025,15 +8531,40 @@ function registerPipelineCommands(parent) {
       printSuccess(`Foundation pipeline completed. Report: ${result3.report_path}`);
       return;
     }
+    if (input.kind === "decision-spec") {
+      if (options.resume) throw new Error("--resume is only valid for foundation pipelines.");
+      const result3 = await runDecisionPipeline({
+        spec: input.spec,
+        plan,
+        specPath: resolve8(options.spec),
+        ...options.output ? { outputDir: resolve8(options.output) } : {},
+        onProgress: isJsonMode() ? void 0 : (message) => console.error(message)
+      });
+      if (isJsonMode()) return printJson({ ...result3, spec });
+      printDecisionSummary(result3);
+      return;
+    }
     if (options.output || options.resume) {
-      throw new Error("--output and --resume are only valid for foundation pipelines.");
+      throw new Error("--output is only valid for foundation and decision pipelines; --resume only for foundation.");
     }
     const localPipeline = {
       version: 1,
       ...plan.name ? { name: plan.name } : {},
       steps: plan.steps.map(({ transfers: _transfers, ...step }) => step)
     };
-    const result2 = await runLocalPipeline({ request: input.request, config, pipeline: localPipeline, ...input.kind === "spec" ? { projectSpec: input.spec } : {} });
+    const reporter = options.quiet ? void 0 : createRunConsoleReporter({ verbose: options.verbose });
+    const { request: request2 } = await ensureDatasetCached({ request: input.request, config, reporter });
+    const result2 = await runLocalPipeline({
+      request: request2,
+      config,
+      pipeline: localPipeline,
+      ...input.kind === "spec" ? { projectSpec: input.spec } : {},
+      ...spec ? { specFile: { path: spec.path, sha256: spec.sha256 } } : {},
+      ...reporter ? { reporter } : {}
+    });
+    if (!isJsonMode()) {
+      console.error(`Run ${result2.request.run_id}: \`tt runs audit ${result2.request.run_id}\` verifies its record and shows timing and provenance.`);
+    }
     if (isJsonMode()) return printJson({ ...result2, spec });
     printSuccess(`Pipeline completed with status ${result2.status}.`);
   });
@@ -7043,7 +8574,7 @@ function registerPipelineCommands(parent) {
 import { createInterface as createInterface3 } from "readline/promises";
 import { stdin as stdin2, stdout as stdout2 } from "process";
 import { Writable as Writable2 } from "stream";
-import chalk7 from "chalk";
+import chalk10 from "chalk";
 async function promptForApiKey(input = stdin2, output = stdout2) {
   if (input.isTTY !== true || output.isTTY !== true) {
     throw new Error(
@@ -7085,9 +8616,9 @@ function registerAuthCommands(parent) {
       const settingsUrl = `${getBaseUrl(parent.optsWithGlobals()).replace(/\/$/, "")}/dashboard/settings`;
       console.log();
       console.log(
-        `  To get your TT access token, go to ${chalk7.bold("Settings \u2192 API Keys")} in the Tuned Tensor dashboard:`
+        `  To get your TT access token, go to ${chalk10.bold("Settings \u2192 API Keys")} in the Tuned Tensor dashboard:`
       );
-      console.log(`  ${chalk7.hex("#A78BFA").underline(settingsUrl)}`);
+      console.log(`  ${chalk10.hex("#A78BFA").underline(settingsUrl)}`);
       console.log();
       apiKey = await promptForApiKey();
     }
@@ -7143,7 +8674,7 @@ function registerAuthCommands(parent) {
 }
 
 // src/commands/balance.ts
-import chalk8 from "chalk";
+import chalk11 from "chalk";
 var KIND_LABELS = {
   signup_bonus: "Signup bonus",
   topup: "Top-up",
@@ -7158,8 +8689,8 @@ function formatCents(cents) {
   return `${sign}$${(abs / 100).toFixed(2)}`;
 }
 function formatSigned(cents) {
-  if (cents > 0) return chalk8.green(`+${formatCents(cents)}`);
-  if (cents < 0) return chalk8.red(formatCents(cents));
+  if (cents > 0) return chalk11.green(`+${formatCents(cents)}`);
+  if (cents < 0) return chalk11.red(formatCents(cents));
   return formatCents(cents);
 }
 function registerBalanceCommands(parent) {
@@ -7174,7 +8705,7 @@ function registerBalanceCommands(parent) {
       return printJson({ balance, transactions });
     }
     const lowBalance = balance.balance_cents < 100;
-    const balanceLine = lowBalance ? chalk8.red(formatCents(balance.balance_cents)) + chalk8.dim(" (low)") : chalk8.bold.green(formatCents(balance.balance_cents));
+    const balanceLine = lowBalance ? chalk11.red(formatCents(balance.balance_cents)) + chalk11.dim(" (low)") : chalk11.bold.green(formatCents(balance.balance_cents));
     printDetail([
       ["Credits", balanceLine],
       [
@@ -7189,7 +8720,7 @@ function registerBalanceCommands(parent) {
     ]);
     if (transactions && transactions.length > 0) {
       console.log(`
-${chalk8.bold("Recent transactions")}`);
+${chalk11.bold("Recent transactions")}`);
       printTable(
         ["Date", "Type", "Amount", "Balance", "Reference"],
         transactions.map((row) => [
@@ -7197,19 +8728,19 @@ ${chalk8.bold("Recent transactions")}`);
           KIND_LABELS[row.kind] ?? row.kind,
           formatSigned(row.amount_cents),
           formatCents(row.balance_after_cents),
-          row.reference_id ? shortId(row.reference_id) : chalk8.dim("\u2014")
+          row.reference_id ? shortId(row.reference_id) : chalk11.dim("\u2014")
         ])
       );
     } else {
       console.log(
         `
-${chalk8.dim("No transactions yet \u2014 run `tt topup` to add credits.")}`
+${chalk11.dim("No transactions yet \u2014 run `tt topup` to add credits.")}`
       );
     }
     if (lowBalance) {
       console.log(
         `
-${formatStatus("preparing")} ${chalk8.yellow(
+${formatStatus("preparing")} ${chalk11.yellow(
           "Run `tt topup` to add more credits before starting a run."
         )}`
       );
@@ -7218,7 +8749,7 @@ ${formatStatus("preparing")} ${chalk8.yellow(
 }
 
 // src/commands/topup.ts
-import chalk9 from "chalk";
+import chalk12 from "chalk";
 import open4 from "open";
 var PRESETS_USD = [10, 25, 50, 100];
 var MIN_USD = 5;
@@ -7257,9 +8788,9 @@ function registerTopupCommands(parent) {
           "amount is required in --json mode (use --amount <usd>)"
         );
       }
-      console.log(chalk9.bold("Add credits via Stripe Checkout"));
+      console.log(chalk12.bold("Add credits via Stripe Checkout"));
       console.log(
-        chalk9.dim(
+        chalk12.dim(
           `Quick picks: ${PRESETS_USD.map((n) => `$${n}`).join(", ")}`
         )
       );
@@ -7286,8 +8817,8 @@ function registerTopupCommands(parent) {
     }
     const url = data3.checkout_url;
     console.log(
-      `${chalk9.bold("Checkout URL:")} ${chalk9.hex("#A78BFA")(url)}
-` + chalk9.dim("Complete the payment to credit your account.")
+      `${chalk12.bold("Checkout URL:")} ${chalk12.hex("#A78BFA")(url)}
+` + chalk12.dim("Complete the payment to credit your account.")
     );
     if (options.open !== false) {
       try {
@@ -7295,7 +8826,7 @@ function registerTopupCommands(parent) {
         printSuccess("Opened Stripe Checkout in your browser.");
       } catch {
         console.log(
-          chalk9.yellow(
+          chalk12.yellow(
             "Could not open browser automatically \u2014 copy the URL above."
           )
         );
@@ -7306,30 +8837,30 @@ function registerTopupCommands(parent) {
 
 // src/commands/publish.ts
 import { createInterface as createInterface4 } from "readline/promises";
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { homedir as homedir2 } from "os";
-import { isAbsolute as isAbsolute5, join as join12, resolve as resolve7 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { homedir as homedir3 } from "os";
+import { isAbsolute as isAbsolute5, join as join14, resolve as resolve9 } from "path";
 import { stdin as defaultStdin, stdout as defaultStdout } from "process";
 var MAX_PUBLISH_BYTES = 2 * 1024 * 1024;
 function expandPath2(value, baseDirectory, homeDirectory) {
   if (value === "~") return homeDirectory;
-  if (value.startsWith("~/")) return resolve7(homeDirectory, value.slice(2));
-  return isAbsolute5(value) ? resolve7(value) : resolve7(baseDirectory, value);
+  if (value.startsWith("~/")) return resolve9(homeDirectory, value.slice(2));
+  return isAbsolute5(value) ? resolve9(value) : resolve9(baseDirectory, value);
 }
 function resolvePublishStoreRoot(options) {
   const cwd = options?.cwd ?? process.cwd();
   const env = options?.env ?? process.env;
-  const homeDirectory = options?.homeDirectory ?? (env.HOME ? resolve7(env.HOME) : homedir2());
-  const localConfigPath = join12(cwd, "local-runner.json");
-  const projectPath = join12(cwd, "tunedtensor.json");
+  const homeDirectory = options?.homeDirectory ?? (env.HOME ? resolve9(env.HOME) : homedir3());
+  const localConfigPath = join14(cwd, "local-runner.json");
+  const projectPath = join14(cwd, "tunedtensor.json");
   if (existsSync5(projectPath)) {
-    const spec = localBehaviorSpecFileSchema.parse(JSON.parse(readFileSync6(projectPath, "utf8")));
+    const spec = localBehaviorSpecFileSchema.parse(JSON.parse(readFileSync7(projectPath, "utf8")));
     if (existsSync5(localConfigPath) && (spec.runtime || spec.evaluation)) throw new Error("Conflicting configuration sources; migrate local-runner.json first.");
     if (!existsSync5(localConfigPath)) return expandPath2(spec.runtime?.storeRoot ?? (env.TT_LOCAL_HOME?.trim() || DEFAULT_PROJECT_STORE_ROOT), cwd, homeDirectory);
   }
   if (existsSync5(localConfigPath)) {
     try {
-      const raw = JSON.parse(readFileSync6(localConfigPath, "utf-8"));
+      const raw = JSON.parse(readFileSync7(localConfigPath, "utf-8"));
       if (typeof raw.storeRoot === "string" && raw.storeRoot.trim()) {
         return expandPath2(raw.storeRoot, cwd, homeDirectory);
       }
@@ -7393,7 +8924,7 @@ function assertPublishPayloadSize(payload) {
   }
 }
 function registerPublishCommand(parent) {
-  parent.command("publish").description("Publish local run evidence to the Tuned Tensor dashboard").argument("[runId]", "Local run id or prefix (defaults to latest completed/failed run)").option("-k, --api-key <key>", "API key (tt_...)").option("-u, --base-url <url>", "API base URL").option("-y, --yes", "Skip confirmation prompt").option("--dry-run", "Show what would be published without uploading").action(async (runId, cmdOpts) => {
+  parent.command("publish").description("Publish local run evidence to the Tuned Tensor dashboard").argument("[runId]", "Local run id or prefix (defaults to latest completed/failed run)").option("-k, --api-key <key>", "API key (tt_...)").option("-u, --base-url <url>", "API base URL").option("-y, --yes", "Skip confirmation prompt").option("--dry-run", "Show what would be published without uploading").option("--allow-unverified", "Publish evidence that cannot be fully verified (older TT versions, unreadable events)").action(async (runId, cmdOpts) => {
     const inherited = parent.optsWithGlobals();
     const opts = {
       apiKey: cmdOpts.apiKey ?? inherited.apiKey,
@@ -7412,12 +8943,27 @@ function registerPublishCommand(parent) {
     const report = runReportSchema.parse(rawReport);
     const specRecord = await store.getSpec(run.behavior_spec_id);
     const exampleCount = report.candidate.results.length || report.baseline.results.length;
+    const audit = await auditRun(store, run.id);
+    if (audit.verdict === "tampered") {
+      throw new Error(
+        `Run ${run.id} evidence does not verify: ${audit.findings.join(" ")} Inspect it with \`tt runs audit ${run.id}\`; tampered runs are not published.`
+      );
+    }
     const payload = {
       spec: {
         id: specRecord.id,
         ...specRecord.spec
       },
-      report
+      report: {
+        ...report,
+        audit: {
+          verdict: audit.verdict,
+          findings: audit.findings,
+          event_chain: { status: audit.chain.status, events: audit.chain.events, head_hash: audit.chain.head_hash },
+          report_sha256: audit.report.recorded_sha256,
+          timeline: audit.timeline
+        }
+      }
     };
     assertPublishPayloadSize(payload);
     if (isJsonMode() && cmdOpts.dryRun) {
@@ -7445,6 +8991,14 @@ function registerPublishCommand(parent) {
       printWarning(
         "Prompts and model outputs from the run report will be uploaded to your Tuned Tensor account."
       );
+      if (audit.verdict !== "verified") {
+        printWarning(`Run evidence is unverified: ${audit.findings.join(" ")}`);
+      }
+    }
+    if (audit.verdict !== "verified" && !cmdOpts.allowUnverified && !cmdOpts.dryRun) {
+      throw new Error(
+        `Run ${run.id} evidence cannot be fully verified: ${audit.findings.join(" ")} Review it with \`tt runs audit\`, then pass --allow-unverified to publish it anyway; the dashboard will show it as unverified.`
+      );
     }
     if (cmdOpts.dryRun) {
       if (isJsonMode()) {
@@ -7489,7 +9043,7 @@ function registerPublishCommand(parent) {
 }
 
 // src/commands/specs.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 
 // src/resolve.ts
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -7593,7 +9147,7 @@ var SpecBodyError = class extends Error {
 function loadSpecBody(filePath, mode) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync7(filePath, "utf-8"));
+    parsed = JSON.parse(readFileSync8(filePath, "utf-8"));
   } catch (e) {
     throw new SpecBodyError(
       `Could not parse ${filePath}: ${e.message}`
@@ -7722,7 +9276,7 @@ function registerSpecsCommands(parent) {
 }
 
 // src/commands/datasets.ts
-import { existsSync as existsSync6, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
 var DOCUMENT_OCR_MIME_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp"]);
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -7852,7 +9406,7 @@ function parseDatasetFormat(value) {
   throw new Error("--format must be one of: jsonl, document_ocr_jsonl");
 }
 function validateDatasetFile(file, requestedFormat) {
-  const lines = readFileSync8(file, "utf8").split(/\r?\n/);
+  const lines = readFileSync9(file, "utf8").split(/\r?\n/);
   const errors = [];
   let rowCount = 0;
   let detectedFormat = null;
@@ -7984,7 +9538,7 @@ function registerDatasetsCommands(parent) {
     }
     const format = validateDatasetFile(file, parseDatasetFormat(cmdOpts.format));
     const name = cmdOpts.name || file.split("/").pop().replace(/\.jsonl?$/, "");
-    const fileBytes = readFileSync8(file);
+    const fileBytes = readFileSync9(file);
     const uploadUrl = await post(
       "/datasets/upload-url",
       {
@@ -8029,12 +9583,12 @@ function registerDatasetsCommands(parent) {
 }
 
 // src/commands/label.ts
-import { existsSync as existsSync7, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
 function formatCents2(cents) {
   return `$${(cents / 100).toFixed(2)}`;
 }
 function sleep(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 function parseCsvHeader(line) {
   const fields = [];
@@ -8073,7 +9627,7 @@ function validateUnlabeledFile(file, inputColumn) {
         "CSV uploads need --input-column <name> to say which column holds the input text."
       );
     }
-    const firstLine = readFileSync9(file, "utf8").split(/\r?\n/, 1)[0] ?? "";
+    const firstLine = readFileSync10(file, "utf8").split(/\r?\n/, 1)[0] ?? "";
     const columns = parseCsvHeader(firstLine);
     if (!columns.includes(inputColumn)) {
       throw new Error(
@@ -8085,7 +9639,7 @@ function validateUnlabeledFile(file, inputColumn) {
   if (!lower.endsWith(".jsonl") && !lower.endsWith(".json")) {
     throw new Error("Labeling source file must be .jsonl or .csv");
   }
-  const lines = readFileSync9(file, "utf8").split(/\r?\n/);
+  const lines = readFileSync10(file, "utf8").split(/\r?\n/);
   const errors = [];
   let rowCount = 0;
   for (const [index, rawLine] of lines.entries()) {
@@ -8208,7 +9762,7 @@ function registerLabelCommands(parent) {
     const { format } = validateUnlabeledFile(file, cmdOpts.inputColumn);
     const specId = await resolveSpecId(cmdOpts.spec, opts);
     const name = cmdOpts.name || file.split("/").pop().replace(/\.(jsonl|json|csv)$/, "");
-    const fileBytes = readFileSync9(file);
+    const fileBytes = readFileSync10(file);
     const contentType = format === "csv" ? "text/csv" : "application/jsonl";
     const { data: uploadUrl } = await post(
       "/labeling-jobs/upload-url",
@@ -8381,7 +9935,7 @@ function registerLabelCommands(parent) {
       printError("Provide --output <text> or --file <path>.");
       process.exit(1);
     }
-    const output = cmdOpts.output ?? readFileSync9(cmdOpts.file, "utf8");
+    const output = cmdOpts.output ?? readFileSync10(cmdOpts.file, "utf8");
     const jobId = await resolveLabelingJobId(id, opts);
     const indexes = parseIndexList(cmdOpts.row);
     const rowIds = await resolveRowIds(jobId, indexes, opts);
@@ -8871,22 +10425,22 @@ import {
   statSync as statSync4,
   createWriteStream,
   unlinkSync,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   writeFileSync as writeFileSync5,
   readdirSync,
   rmSync
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname9, join as join13, resolve as resolve9, basename as basename5, normalize, isAbsolute as isAbsolute6 } from "path";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname11, join as join15, resolve as resolve11, basename as basename5, normalize, isAbsolute as isAbsolute6 } from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 
 // src/commands/init.ts
-import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve10 } from "path";
 var DEFAULT_SPEC_FILE2 = "tunedtensor.json";
 function loadSpec(filePath) {
-  const resolved = resolve8(filePath || DEFAULT_SPEC_FILE2);
+  const resolved = resolve10(filePath || DEFAULT_SPEC_FILE2);
   if (!existsSync8(resolved)) {
     printError(
       `Spec file not found: ${filePath || DEFAULT_SPEC_FILE2}
@@ -8894,29 +10448,29 @@ Run \`tt init\` to create one.`
     );
     process.exit(1);
   }
-  const raw = JSON.parse(readFileSync10(resolved, "utf-8"));
+  const raw = JSON.parse(readFileSync11(resolved, "utf-8"));
   return raw;
 }
 
 // src/serve-manager.ts
 import { spawn as spawn2 } from "child_process";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
 import { createServer } from "http";
 import { createServer as createNetServer } from "net";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname10 } from "path";
 var COMPLETION_ROUTES = /* @__PURE__ */ new Set(["/v1/chat/completions", "/chat/completions"]);
 function parsePositiveInteger(value, fallback) {
   return Number.isInteger(value) && value >= 0 ? value : fallback;
 }
 function sleep2(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 function readRequestBody(req) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-    req.on("end", () => resolve11(Buffer.concat(chunks)));
+    req.on("end", () => resolve13(Buffer.concat(chunks)));
     req.on("error", reject);
   });
 }
@@ -8984,7 +10538,7 @@ function errorSummary(response, fallback) {
   return typeof message === "string" ? message : fallback;
 }
 async function allocatePort(host) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const server = createNetServer();
     server.on("error", reject);
     server.listen(0, host, () => {
@@ -8994,7 +10548,7 @@ async function allocatePort(host) {
         return;
       }
       const port = address.port;
-      server.close(() => resolve11(port));
+      server.close(() => resolve13(port));
     });
   });
 }
@@ -9034,11 +10588,11 @@ var ManagedModelServer = class {
         sendJson(res, 500, { error: { message: err instanceof Error ? err.message : String(err) } });
       });
     });
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve13, reject) => {
       this.server?.once("error", reject);
       this.server?.listen(this.options.publicPort, this.options.publicHost, () => {
         this.server?.off("error", reject);
-        resolve11();
+        resolve13();
       });
     });
   }
@@ -9048,15 +10602,15 @@ var ManagedModelServer = class {
     if (!this.server) return;
     const server = this.server;
     this.server = null;
-    await new Promise((resolve11, reject) => {
-      server.close((err) => err ? reject(err) : resolve11());
+    await new Promise((resolve13, reject) => {
+      server.close((err) => err ? reject(err) : resolve13());
     });
   }
   async run() {
     await this.start();
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve13, reject) => {
       this.server?.once("error", reject);
-      this.server?.once("close", resolve11);
+      this.server?.once("close", resolve13);
     });
   }
   async handle(req, res) {
@@ -9124,7 +10678,7 @@ var ManagedModelServer = class {
     });
   }
   async processGeneration(route, body, res, receivedAt) {
-    const requestId = `ttreq-${randomUUID9()}`;
+    const requestId = `ttreq-${randomUUID10()}`;
     const startedAt = Date.now();
     const queuedMs = startedAt - receivedAt;
     this.activeRequests += 1;
@@ -9230,7 +10784,7 @@ var ManagedModelServer = class {
     try {
       child.kill("SIGTERM");
       await Promise.race([
-        new Promise((resolve11) => child.once("exit", () => resolve11())),
+        new Promise((resolve13) => child.once("exit", () => resolve13())),
         sleep2(5e3).then(() => {
           if (child.exitCode == null && child.signalCode == null) child.kill("SIGKILL");
         })
@@ -9308,7 +10862,7 @@ var ManagedModelServer = class {
     const line = `${JSON.stringify(record4)}
 `;
     if (this.options.logFile) {
-      mkdirSync3(dirname8(this.options.logFile), { recursive: true });
+      mkdirSync3(dirname10(this.options.logFile), { recursive: true });
       appendFileSync(this.options.logFile, line, "utf8");
       return;
     }
@@ -9856,7 +11410,7 @@ if __name__ == "__main__":
 function resolveOutputPath(output, filename) {
   if (!output) return filename;
   if (existsSync9(output) && statSync4(output).isDirectory()) {
-    return join13(output, filename);
+    return join15(output, filename);
   }
   return output;
 }
@@ -9932,7 +11486,7 @@ async function downloadUrlToFile(url, outputPath) {
   if (!res.body) {
     throw new Error("Download failed: response body was empty");
   }
-  mkdirSync4(dirname9(outputPath), { recursive: true });
+  mkdirSync4(dirname11(outputPath), { recursive: true });
   const file = createWriteStream(outputPath);
   const contentLength = parseContentLength(res.headers.get("content-length"));
   const progress = createDownloadProgress(
@@ -9963,15 +11517,15 @@ async function downloadUrlToFile(url, outputPath) {
   return contentLength;
 }
 function defaultCacheDir() {
-  const root = process.env.XDG_CACHE_HOME || join13(homedir3(), ".cache");
-  return join13(root, "tuned-tensor", "models");
+  const root = process.env.XDG_CACHE_HOME || join15(homedir4(), ".cache");
+  return join15(root, "tuned-tensor", "models");
 }
 function runtimeDir(cacheDir) {
-  return join13(cacheDir, "_runtime");
+  return join15(cacheDir, "_runtime");
 }
 function runtimePythonPath(cacheDir) {
   const dir = runtimeDir(cacheDir);
-  return process.platform === "win32" ? join13(dir, "Scripts", "python.exe") : join13(dir, "bin", "python");
+  return process.platform === "win32" ? join15(dir, "Scripts", "python.exe") : join15(dir, "bin", "python");
 }
 function resolveServePython(cacheDir, explicitPython) {
   if (explicitPython) return explicitPython;
@@ -10044,7 +11598,7 @@ print(json.dumps({"missing": missing}))
   }
 }
 function setupRuntimeCommands(python, venvDir, deps) {
-  const venvPython = process.platform === "win32" ? join13(venvDir, "Scripts", "python.exe") : join13(venvDir, "bin", "python");
+  const venvPython = process.platform === "win32" ? join15(venvDir, "Scripts", "python.exe") : join15(venvDir, "bin", "python");
   return [
     [python, "-m", "venv", venvDir],
     [venvPython, "-m", "pip", "install", "--upgrade", "pip"],
@@ -10082,9 +11636,9 @@ function extractArchive(archivePath, targetDir, force) {
   return targetDir;
 }
 function localArchiveCacheDir(archivePath, cacheDir) {
-  const resolved = resolve9(archivePath);
+  const resolved = resolve11(archivePath);
   const digest = createHash6("sha256").update(resolved).digest("hex").slice(0, 12);
-  return join13(cacheDir, `local-${safeSegment(basename5(archivePath))}-${digest}`);
+  return join15(cacheDir, `local-${safeSegment(basename5(archivePath))}-${digest}`);
 }
 function buildSystemPrompt(spec) {
   const parts = [];
@@ -10100,39 +11654,39 @@ ${spec.constraints.map((c) => `- ${c}`).join("\n")}`);
   return parts.join("\n\n");
 }
 function findSpecPath(explicitPath, modelPath) {
-  const candidates = explicitPath ? [explicitPath] : [join13(process.cwd(), DEFAULT_SPEC_FILE2), join13(modelPath, DEFAULT_SPEC_FILE2)];
+  const candidates = explicitPath ? [explicitPath] : [join15(process.cwd(), DEFAULT_SPEC_FILE2), join15(modelPath, DEFAULT_SPEC_FILE2)];
   for (const candidate of candidates) {
-    const resolved = resolve9(candidate);
+    const resolved = resolve11(candidate);
     if (existsSync9(resolved) && statSync4(resolved).isFile()) return resolved;
   }
   return null;
 }
 function loadSystemPromptFromSpec(specPath) {
-  const spec = JSON.parse(readFileSync11(specPath, "utf8"));
+  const spec = JSON.parse(readFileSync12(specPath, "utf8"));
   return buildSystemPrompt(spec);
 }
 function loadJsonSchemaForServe(schemaPath) {
-  const resolved = resolve9(schemaPath);
+  const resolved = resolve11(schemaPath);
   if (!existsSync9(resolved) || !statSync4(resolved).isFile()) {
     throw new Error(`JSON schema file not found: ${schemaPath}`);
   }
   try {
-    const schema = JSON.parse(readFileSync11(resolved, "utf8"));
+    const schema = JSON.parse(readFileSync12(resolved, "utf8"));
     return JSON.stringify(schema);
   } catch (err) {
     throw new Error(`JSON schema file is not valid JSON: ${schemaPath}`);
   }
 }
 function writeReferenceServerScript(cacheDir) {
-  const scriptDir = join13(cacheDir, "_server");
+  const scriptDir = join15(cacheDir, "_server");
   mkdirSync4(scriptDir, { recursive: true });
-  const scriptPath = join13(scriptDir, "openai_reference_server.py");
+  const scriptPath = join15(scriptDir, "openai_reference_server.py");
   writeFileSync5(scriptPath, REFERENCE_SERVER_SCRIPT, "utf8");
   return scriptPath;
 }
 async function resolveServeTarget(target, opts, cacheDir, forceDownload) {
   if (existsSync9(target)) {
-    const resolved = resolve9(target);
+    const resolved = resolve11(target);
     const stats = statSync4(resolved);
     if (stats.isDirectory()) {
       return {
@@ -10142,7 +11696,7 @@ async function resolveServeTarget(target, opts, cacheDir, forceDownload) {
       };
     }
     if (stats.isFile() && (resolved.endsWith(".tar.gz") || resolved.endsWith(".tgz"))) {
-      const extractDir2 = join13(localArchiveCacheDir(resolved, cacheDir), "model");
+      const extractDir2 = join15(localArchiveCacheDir(resolved, cacheDir), "model");
       return {
         modelPath: extractArchive(resolved, extractDir2, forceDownload),
         modelName: basename5(resolved).replace(/\.t(ar\.)?gz$/, ""),
@@ -10154,9 +11708,9 @@ async function resolveServeTarget(target, opts, cacheDir, forceDownload) {
   const fullId = await resolveModelId(target, opts);
   const { data: model } = await get(`/models/${fullId}`, void 0, opts);
   const { data: data3 } = await get(`/models/${fullId}/download`, void 0, opts);
-  const modelCacheDir = join13(cacheDir, fullId);
-  const archivePath = join13(modelCacheDir, data3.filename);
-  const extractDir = join13(modelCacheDir, "model");
+  const modelCacheDir = join15(cacheDir, fullId);
+  const archivePath = join15(modelCacheDir, data3.filename);
+  const extractDir = join15(modelCacheDir, "model");
   if (!existsSync9(archivePath) || forceDownload) {
     await downloadUrlToFile(data3.url, archivePath);
   }
@@ -10262,7 +11816,7 @@ function ollamaSlug(name) {
 function firstExisting(candidates) {
   for (const candidate of candidates) {
     if (candidate && existsSync9(candidate) && statSync4(candidate).isFile()) {
-      return resolve9(candidate);
+      return resolve11(candidate);
     }
   }
   return null;
@@ -10272,14 +11826,14 @@ function llamaCppDir(explicit) {
 }
 function resolveConvertScript(opts, required) {
   if (opts.convertScript) {
-    const resolved = resolve9(opts.convertScript);
+    const resolved = resolve11(opts.convertScript);
     if (required && !existsSync9(resolved)) {
       throw new Error(`Conversion script not found: ${opts.convertScript}`);
     }
     return resolved;
   }
   const dir = llamaCppDir(opts.llamaCpp);
-  const candidates = dir ? [join13(dir, "convert_hf_to_gguf.py"), join13(dir, "convert-hf-to-gguf.py")] : [];
+  const candidates = dir ? [join15(dir, "convert_hf_to_gguf.py"), join15(dir, "convert-hf-to-gguf.py")] : [];
   const found = firstExisting(candidates);
   if (found) return found;
   if (required) {
@@ -10287,11 +11841,11 @@ function resolveConvertScript(opts, required) {
       "Could not find convert_hf_to_gguf.py. Pass --llama-cpp <dir> (a llama.cpp checkout) or --convert-script <path>. Get it from https://github.com/ggml-org/llama.cpp."
     );
   }
-  return dir ? join13(dir, "convert_hf_to_gguf.py") : "convert_hf_to_gguf.py";
+  return dir ? join15(dir, "convert_hf_to_gguf.py") : "convert_hf_to_gguf.py";
 }
 function resolveQuantizeBin(opts, required) {
   if (opts.quantizeBin) {
-    const resolved = resolve9(opts.quantizeBin);
+    const resolved = resolve11(opts.quantizeBin);
     if (required && !existsSync9(resolved)) {
       throw new Error(`llama-quantize binary not found: ${opts.quantizeBin}`);
     }
@@ -10300,10 +11854,10 @@ function resolveQuantizeBin(opts, required) {
   const dir = llamaCppDir(opts.llamaCpp);
   if (dir) {
     const candidates = [
-      join13(dir, "build", "bin", "llama-quantize"),
-      join13(dir, "build", "bin", "quantize"),
-      join13(dir, "llama-quantize"),
-      join13(dir, "quantize")
+      join15(dir, "build", "bin", "llama-quantize"),
+      join15(dir, "build", "bin", "quantize"),
+      join15(dir, "llama-quantize"),
+      join15(dir, "quantize")
     ];
     const found = firstExisting(candidates);
     if (found) return found;
@@ -10451,7 +12005,7 @@ function registerModelsCommands(parent) {
     }
     const quantPlan = planQuant(String(cmdOpts.quant));
     const printOnly = Boolean(cmdOpts.printCommand);
-    const cacheDir = resolve9(cmdOpts.cacheDir || defaultCacheDir());
+    const cacheDir = resolve11(cmdOpts.cacheDir || defaultCacheDir());
     mkdirSync4(cacheDir, { recursive: true });
     const serveTarget = await resolveServeTarget(
       target,
@@ -10460,9 +12014,9 @@ function registerModelsCommands(parent) {
       Boolean(cmdOpts.forceDownload)
     );
     const slug = ollamaSlug(serveTarget.modelName);
-    const outputDir = resolve9(cmdOpts.output || join13(process.cwd(), `${slug}-gguf`));
-    const finalPath = join13(outputDir, `${slug}.${quantPlan.quant}.gguf`);
-    const intermediatePath = quantPlan.requiresQuantize ? join13(outputDir, `${slug}.f16.gguf`) : void 0;
+    const outputDir = resolve11(cmdOpts.output || join15(process.cwd(), `${slug}-gguf`));
+    const finalPath = join15(outputDir, `${slug}.${quantPlan.quant}.gguf`);
+    const intermediatePath = quantPlan.requiresQuantize ? join15(outputDir, `${slug}.f16.gguf`) : void 0;
     const convertScript = resolveConvertScript(cmdOpts, !printOnly);
     const convertOutfile = intermediatePath ?? finalPath;
     const steps = [
@@ -10500,7 +12054,7 @@ function registerModelsCommands(parent) {
         }
         if (specPath) systemPrompt2 = loadSystemPromptFromSpec(specPath);
       }
-      modelfilePath = join13(outputDir, "Modelfile");
+      modelfilePath = join15(outputDir, "Modelfile");
       modelfileContent = buildModelfile(basename5(finalPath), systemPrompt2);
       const createModel = cmdOpts.ollamaCreate !== false;
       if (createModel) {
@@ -10587,7 +12141,7 @@ function registerModelsCommands(parent) {
     }
   });
   models.command("setup-runtime").description("Install an isolated Python runtime for local model serving").option("--python <path>", "Python 3.10-3.12 executable to create the runtime").option("--cache-dir <path>", "Cache directory for the managed runtime").option("-f, --force", "Recreate the runtime if it already exists").option("--print-command", "Print the setup commands without running them").action(async (cmdOpts) => {
-    const cacheDir = resolve9(cmdOpts.cacheDir || defaultCacheDir());
+    const cacheDir = resolve11(cmdOpts.cacheDir || defaultCacheDir());
     const venvDir = runtimeDir(cacheDir);
     const venvPython = runtimePythonPath(cacheDir);
     const python = pickRuntimePython(cmdOpts.python);
@@ -10633,7 +12187,7 @@ function registerModelsCommands(parent) {
   });
   models.command("serve").description("Serve a downloaded model with an OpenAI-compatible local API").argument("<target>", "Model ID/prefix, model directory, or .tar.gz artifact").option("--spec <path>", "Behavior spec JSON to apply as the default system prompt").option("--no-spec-prompt", "Do not auto-apply a behavior spec system prompt").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind", "8000").option("--python <path>", "Python executable").option("--cache-dir <path>", "Cache directory for downloaded/extracted models").option("--device <device>", "Inference device: auto, cpu, cuda, or mps", "auto").option("--force-download", "Re-download and re-extract model artifacts").option("--max-tokens <n>", "Default max completion tokens", "512").option("--temperature <n>", "Default sampling temperature", "0.7").option("--json-schema <path>", "JSON Schema file to enforce by default for chat completions").option("--json-repair-attempts <n>", "Number of JSON/schema repair retries", "1").option("--trust-remote-code", "Pass trust_remote_code=True to transformers").option("--managed", "Run a local lifecycle manager in front of the model server").option("--idle-timeout <seconds>", "Managed mode idle timeout before stopping the model", "300").option("--restart-after-requests <n>", "Managed mode restart threshold; 0 disables request-count restarts", "100").option("--gate-field <field>", "Response JSON field to log as the managed serving gate result", "should_process").option("--log-file <path>", "Write managed serving JSONL request logs to a file").option("--print-command", "Print the underlying Python command without starting it").action(async (target, cmdOpts) => {
     const opts = parent.optsWithGlobals();
-    const cacheDir = resolve9(cmdOpts.cacheDir || defaultCacheDir());
+    const cacheDir = resolve11(cmdOpts.cacheDir || defaultCacheDir());
     mkdirSync4(cacheDir, { recursive: true });
     const python = resolveServePython(cacheDir, cmdOpts.python);
     if (!cmdOpts.printCommand) ensureServingRuntime(python, cacheDir);
@@ -10682,7 +12236,7 @@ function registerModelsCommands(parent) {
       idle_timeout_seconds: idleTimeoutSeconds,
       restart_after_requests: restartAfterRequests,
       gate_field: String(cmdOpts.gateField),
-      log_file: cmdOpts.logFile ? resolve9(cmdOpts.logFile) : void 0
+      log_file: cmdOpts.logFile ? resolve11(cmdOpts.logFile) : void 0
     } : void 0;
     if (cmdOpts.printCommand) return printServeCommand(python, args2, env, managedConfig);
     if (!isJsonMode()) {
@@ -10719,7 +12273,7 @@ function registerModelsCommands(parent) {
         idleTimeoutSeconds,
         restartAfterRequests,
         gateField: String(cmdOpts.gateField),
-        logFile: cmdOpts.logFile ? resolve9(cmdOpts.logFile) : void 0
+        logFile: cmdOpts.logFile ? resolve11(cmdOpts.logFile) : void 0
       });
       return;
     }
@@ -10745,17 +12299,17 @@ function registerModelsCommands(parent) {
 }
 
 // src/commands/push.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve10 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve12 } from "path";
 function persistRemoteId(filePath, id) {
-  const raw = JSON.parse(readFileSync12(filePath, "utf-8"));
+  const raw = JSON.parse(readFileSync13(filePath, "utf-8"));
   raw.id = id;
   writeFileSync6(filePath, JSON.stringify(raw, null, 2) + "\n");
 }
 function registerPushCommand(parent) {
   parent.command("push").description("Push local spec to the Tuned Tensor API").option("-f, --file <path>", "Spec file path", DEFAULT_SPEC_FILE2).action(async (cmdOpts) => {
     const opts = parent.optsWithGlobals();
-    const filePath = resolve10(cmdOpts.file);
+    const filePath = resolve12(cmdOpts.file);
     const spec = loadSpec(cmdOpts.file);
     const evalCaseErrors = validateEvalCases(spec);
     if (evalCaseErrors.length > 0) {
@@ -10901,10 +12455,10 @@ async function checkForCliUpdate(currentVersion, options = {}) {
       return null;
     }
   })();
-  const deadline = new Promise((resolve11) => {
+  const deadline = new Promise((resolve13) => {
     timeout = setTimeout(() => {
       controller.abort();
-      resolve11(null);
+      resolve13(null);
     }, timeoutMs);
   });
   try {
@@ -11029,7 +12583,7 @@ async function runSelfCommand(args2, options = {}) {
   if (!entrypoint) {
     throw new Error("Cannot locate the tt CLI entrypoint.");
   }
-  return await new Promise((resolve11, reject) => {
+  return await new Promise((resolve13, reject) => {
     const child = spawn4(process.execPath, [entrypoint, ...args2], {
       cwd: options.cwd,
       env: options.env ?? process.env,
@@ -11069,7 +12623,7 @@ async function runSelfCommand(args2, options = {}) {
     child.once("close", (exitCode, signal) => {
       cleanup();
       const signalNumber = signal ? osConstants2.signals[signal] : void 0;
-      resolve11({
+      resolve13({
         exitCode: exitCode ?? (typeof signalNumber === "number" ? 128 + signalNumber : 1),
         signal
       });
@@ -11132,7 +12686,7 @@ function createProgram(version, runtime = {}) {
     if (root.json) setJsonMode(true);
     if (root.color === false) {
       process.env.FORCE_COLOR = "0";
-      chalk10.level = 0;
+      chalk13.level = 0;
     }
   });
   registerLocalCommands(program, {
@@ -11170,12 +12724,12 @@ function createProgram(version, runtime = {}) {
 `);
       return;
     }
-    output.write(`${chalk10.bold.hex("#8B5CF6")("Tuned Tensor status")}
+    output.write(`${chalk13.bold.hex("#8B5CF6")("Tuned Tensor status")}
 `);
     output.write(`${formatShellStatus(context).join("\n")}
 
 `);
-    output.write(`${chalk10.bold("Context")}
+    output.write(`${chalk13.bold("Context")}
 `);
     output.write(`${formatShellContext(context).join("\n")}
 `);
@@ -11276,7 +12830,7 @@ async function runCli(version, runtime = {}) {
 }
 
 // src/index.ts
-runCli("0.20.0").catch((err) => {
+runCli("0.22.0").catch((err) => {
   reportError(err);
   process.exit(1);
 });