tines 0.0.195 → 0.0.196

package/dist/index.js

@@ -3124,14 +3124,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
    */
   helpInformation(contextOptions) {
     const helper = this.createHelp();
-    const context = this._getOutputContext(contextOptions);
+    const context2 = this._getOutputContext(contextOptions);
     helper.prepareContext({
-      error: context.error,
-      helpWidth: context.helpWidth,
-      outputHasColors: context.hasColors
+      error: context2.error,
+      helpWidth: context2.helpWidth,
+      outputHasColors: context2.hasColors
     });
     const text4 = helper.formatHelp(this, helper);
-    if (context.hasColors) return text4;
+    if (context2.hasColors) return text4;
     return this._outputConfiguration.stripColor(text4);
   }
   /**
@@ -3299,15 +3299,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
 Expecting one of '${allowedValues.join("', '")}'`);
     }
     const helpEvent = `${position}Help`;
-    this.on(helpEvent, (context) => {
+    this.on(helpEvent, (context2) => {
       let helpStr;
       if (typeof text4 === "function") {
-        helpStr = text4({ error: context.error, command: context.command });
+        helpStr = text4({ error: context2.error, command: context2.command });
       } else {
         helpStr = text4;
       }
       if (helpStr) {
-        context.write(`${helpStr}
+        context2.write(`${helpStr}
 `);
       }
     });
@@ -3401,6 +3401,12 @@ function readBodyValue(value, stdin = processStdin) {
 }
 
 // ../shared/src/types.ts
+var STATE_CATEGORIES = [
+  "backlog",
+  "active",
+  "awaiting_human",
+  "done"
+];
 function runRefLabel(run) {
   return run.issue_ref ? `run on ${run.issue_ref.project_name}/${run.issue_ref.number}` : `run ${run.run_id}`;
 }
@@ -3421,7 +3427,9 @@ var LABEL_COLORS = [
   "violet",
   "pink"
 ];
+var LABEL_NAME_MAX = 50;
 var PROMPT_MAX_BYTES = 32 * 1024;
+var SKILL_MAX_FILES = 20;
 var SKILL_MAX_TOTAL_BYTES = 100 * 1024;
 var AGENT_GUIDELINES_NAME = "agent-guidelines";
 var JOURNAL_NAME = "journal";
@@ -3451,6 +3459,7 @@ function repoDirFromUrl(url) {
     return "repo";
   return base;
 }
+var ARTIFACT_TYPES = ["file", "text", "link", "pr", "folder"];
 var ARTIFACT_FILE_MAX_BYTES = 25 * 1024 * 1024;
 var ARTIFACT_TEXT_MAX_BYTES = 256 * 1024;
 var ARTIFACT_FOLDER_MAX_BYTES = 50 * 1024 * 1024;
@@ -3464,13 +3473,13 @@ function canonicalGitHubRepoUrl(url) {
 function parsePrSpec(spec) {
   const short = spec.trim().match(/^([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)#(\d+)$/);
   if (short) {
-    const repoUrl2 = canonicalGitHubRepoUrl(`https://github.com/${short[1]}`);
-    return repoUrl2 ? { repo_url: repoUrl2, number: Number.parseInt(short[2], 10) } : null;
+    const repoUrl3 = canonicalGitHubRepoUrl(`https://github.com/${short[1]}`);
+    return repoUrl3 ? { repo_url: repoUrl3, number: Number.parseInt(short[2], 10) } : null;
   }
   const url = spec.trim().match(/^(.*?)\/pull\/(\d+)(?:[/?#].*)?$/);
   if (!url) return null;
-  const repoUrl = canonicalGitHubRepoUrl(url[1]);
-  return repoUrl ? { repo_url: repoUrl, number: Number.parseInt(url[2], 10) } : null;
+  const repoUrl2 = canonicalGitHubRepoUrl(url[1]);
+  return repoUrl2 ? { repo_url: repoUrl2, number: Number.parseInt(url[2], 10) } : null;
 }
 var MODEL_TIERS = ["smartest", "balanced", "cheapest"];
 var RUNNER_ONLINE_WINDOW_MS = 2 * 60 * 1e3;
@@ -3840,12 +3849,12 @@ function declaredContentType(reqs, type) {
 // ../shared/src/artifact-site.ts
 var ARTIFACT_SITE_LINK_TTL_MS = 60 * 60 * 1e3;
 var ARTIFACT_SITE_INDEX = "index.html";
-function siteEntry(type, contentType, files = []) {
+function siteEntry(type, contentType, files2 = []) {
   if (type === "file" || type === "text") {
     return (contentType ?? "").toLowerCase().startsWith("text/html") ? "" : null;
   }
   if (type === "folder") {
-    return files.some((f) => f.path === ARTIFACT_SITE_INDEX) ? ARTIFACT_SITE_INDEX : null;
+    return files2.some((f) => f.path === ARTIFACT_SITE_INDEX) ? ARTIFACT_SITE_INDEX : null;
   }
   return null;
 }
@@ -4076,12 +4085,12 @@ function createApiClient(options) {
     /** JSON upsert for text/link/pr: creates the artifact or appends a version. */
     putArtifact: (issueId, name2, body) => request("PUT", artifactPath(issueId, name2), body),
     /** Raw-body upload for `file`: creates the artifact or appends a version. */
-    uploadArtifactFile: async (issueId, name2, bytes, opts) => {
+    uploadArtifactFile: async (issueId, name2, bytes2, opts) => {
       const res = await raw(
         "PUT",
         artifactPath(issueId, name2, `/file?filename=${encodeURIComponent(opts.filename)}`),
         {
-          body: bytes,
+          body: bytes2,
           headers: { "content-type": opts.contentType }
         }
       );
@@ -4091,9 +4100,9 @@ function createApiClient(options) {
      * Multipart snapshot upload for `folder`: every file of the new version
      * in one request (path as the part filename, MIME as the part type).
      */
-    uploadArtifactFolder: async (issueId, name2, files) => {
+    uploadArtifactFolder: async (issueId, name2, files2) => {
       const form = new FormData();
-      for (const file of files) {
+      for (const file of files2) {
         form.append(
           "file",
           new Blob([file.bytes], { type: file.contentType }),
@@ -4416,10 +4425,10 @@ var INHERIT_RUNNER_ID = "*";
 
 // ../shared/src/issue-transfer.ts
 var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
-function conflictsByKey(context) {
-  const repositories = new Map(context.repos.map((repo) => [repo.item_id, repo]));
+function conflictsByKey(context2) {
+  const repositories = new Map(context2.repos.map((repo) => [repo.item_id, repo]));
   return new Map(
-    context.conflicts.map((conflict) => {
+    context2.conflicts.map((conflict) => {
       const ids = [...new Set(conflict.item_ids)].sort(compare);
       const key = JSON.stringify([conflict.dir, ids]);
       return [
@@ -4460,6 +4469,8 @@ function deriveTransferConflictDeltas(before, after) {
 }
 
 // ../shared/src/library/types.ts
+var LIBRARY_V3_MAX_DEPTH = 64;
+var LIBRARY_V3_MAX_RECORDS = 1e3;
 var LibraryValidationError = class extends Error {
   constructor(diagnostics) {
     super(diagnostics[0]?.message ?? "Invalid library document");
@@ -4508,6 +4519,11 @@ var oneOf = (values) => (v, p) => {
 var nullable = (check) => (v, p) => {
   if (v !== null) check(v, p);
 };
+var array = (check, max = 1e3) => (v, p) => {
+  if (!Array.isArray(v)) invalid(p, "invalid_type", "Expected an array");
+  if (v.length > max) invalid(p, "package_too_large", `Array exceeds ${max} entries`);
+  for (let i = 0; i < v.length; i++) check(v[i], pointer(p, i));
+};
 function object(v, p) {
   if (!v || typeof v !== "object" || Array.isArray(v) || ![null, Object.prototype].includes(Object.getPrototypeOf(v)))
     invalid(p, "invalid_type", "Expected a plain object");
@@ -4539,14 +4555,166 @@ var id = (v, p) => {
   if (!/^[A-Za-z0-9:_-]{1,80}$/.test(v))
     invalid(p, "invalid_local_id", "Invalid document-local ID");
 };
+var labelName = (v, p) => {
+  text2(LABEL_NAME_MAX, true)(v, p);
+  const name2 = v.trim();
+  if (name2.startsWith("-") || /[\u0000-\u001f\u007f]/.test(name2))
+    invalid(
+      p,
+      "invalid_field",
+      "Label names cannot start with a hyphen or contain control characters"
+    );
+};
+var slug = (v, p) => {
+  text2(100, true)(v, p);
+  if (!/^[a-z0-9-]+$/.test(v))
+    invalid(p, "invalid_field", "Expected a slug ([a-z0-9-]+)");
+};
 var bundledState = shape({ kind: oneOf(["bundled_state"]), state_id: id });
 var systemState = shape({
   kind: oneOf(["system_state"]),
   workflow: oneOf(["Standard"]),
   state_name: text2(100, true)
 });
+var stateRef = (library) => discriminated("kind", {
+  bundled_state: bundledState,
+  ...library ? { system_state: systemState } : {}
+});
 var bundledWorkflow = shape({ kind: oneOf(["bundled_workflow"]), workflow_id: id });
 var projectRef = shape({ kind: oneOf(["input_project"]), input_id: id });
+var requirement = (v, p) => {
+  shape(
+    { artifact: slug },
+    { type: oneOf(ARTIFACT_TYPES), content_type: text2(100, true), description: text2(500) }
+  )(v, p);
+  const o = v;
+  if (o.content_type !== void 0 && o.type !== "file" && o.type !== "text")
+    invalid(pointer(p, "content_type"), "invalid_field", "content_type requires type file or text");
+};
+var workflow = (library) => shape({
+  id,
+  name: text2(200, true),
+  description: text2(1e4),
+  initial_state_id: id,
+  states: array(
+    shape({
+      id,
+      name: text2(100, true),
+      category: oneOf(STATE_CATEGORIES),
+      inherits_from: nullable(stateRef(library))
+    })
+  ),
+  transitions: array(
+    shape({
+      id,
+      name: text2(100, true),
+      from_state_id: id,
+      to_state_id: id,
+      requires: array(requirement)
+    })
+  )
+});
+var workspacePath = (v, p) => {
+  text2(500, true)(v, p);
+  const path2 = v;
+  if (path2.includes("\\") || path2.includes("=") || path2.split("/").some((s) => !s || s === "." || s === ".."))
+    invalid(
+      p,
+      "invalid_path",
+      "Expected a relative workspace path without empty, dot or parent segments, backslashes or equals"
+    );
+};
+var bytes = (v) => new TextEncoder().encode(v).byteLength;
+var prompt = (v, p) => {
+  text2(PROMPT_MAX_BYTES)(v, p);
+  if (bytes(v) > PROMPT_MAX_BYTES)
+    invalid(p, "package_too_large", `Prompt exceeds ${PROMPT_MAX_BYTES} UTF-8 bytes`);
+};
+var files = (v, p) => {
+  array(shape({ id, path: workspacePath, content: text2(SKILL_MAX_TOTAL_BYTES) }), SKILL_MAX_FILES)(
+    v,
+    p
+  );
+  const entries = v;
+  const seen = /* @__PURE__ */ new Set();
+  let size = 0;
+  for (const [i, file] of entries.entries()) {
+    if (seen.has(file.path))
+      invalid(pointer(pointer(p, i), "path"), "duplicate_path", "Duplicate skill file path");
+    seen.add(file.path);
+    size += bytes(file.path) + bytes(file.content);
+  }
+  if (size > SKILL_MAX_TOTAL_BYTES)
+    invalid(p, "package_too_large", `Skill exceeds ${SKILL_MAX_TOTAL_BYTES} UTF-8 bytes`);
+};
+var repoUrl = (v, p) => {
+  text2(1e3, true)(v, p);
+  let url;
+  try {
+    url = new URL(v);
+  } catch {
+    invalid(p, "invalid_repo_url", "Expected a GitHub HTTPS repository URL");
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash || !canonicalGitHubRepoUrl(v))
+    invalid(
+      p,
+      "invalid_repo_url",
+      "Expected a GitHub HTTPS repository URL without credentials, query or fragment"
+    );
+};
+var context = (library) => {
+  const scope = library ? {
+    scope: shape({}, { project_id: id, state: stateRef(true), label_id: id }),
+    journal: bool
+  } : { state_id: id };
+  const common = {
+    id,
+    name: text2(100, true),
+    description: text2(1e3),
+    ...scope
+  };
+  return (v, p) => {
+    discriminated("kind", {
+      prompt: shape({ ...common, kind: oneOf(["prompt"]), body: prompt }),
+      skill: shape({ ...common, name: slug, kind: oneOf(["skill"]), files }),
+      repo: shape({
+        ...common,
+        kind: oneOf(["repo"]),
+        // Whole-library transfer preserves ordinary repo declarations, including
+        // local/file URLs. Workflow packages are shareable and stay GitHub-only.
+        repo_url: library ? text2(1e3, true) : repoUrl,
+        repo_branch: nullable(text2(200, true)),
+        repo_dir: nullable(workspacePath)
+      })
+    })(v, p);
+    const o = v;
+    if (library && o.journal && o.kind !== "prompt")
+      invalid(pointer(p, "journal"), "invalid_field", "Only prompts may be journals");
+  };
+};
+var input = (v, p) => {
+  shape(
+    {
+      id,
+      key: text2(64, true),
+      type: oneOf(["text", "workflow", "label", "project"]),
+      label: text2(200, true),
+      description: text2(1e3),
+      required: bool,
+      default: nullable(text2(1e4))
+    },
+    { required_states: array(text2(100, true)) }
+  )(v, p);
+  const o = v;
+  if (!/^[a-z][a-z0-9_]{0,63}$/.test(o.key))
+    invalid(pointer(p, "key"), "invalid_input_key", "Invalid input key");
+  if (o.required_states !== void 0 && o.type !== "workflow")
+    invalid(
+      pointer(p, "required_states"),
+      "invalid_field",
+      "Only workflow inputs may require states"
+    );
+};
 var preset = discriminated("kind", {
   hourly: shape({ kind: oneOf(["hourly"]), every_hours: integer }, { minute: integer }),
   daily: shape({ kind: oneOf(["daily"]), time: text2(5, true) }),
@@ -4585,6 +4753,695 @@ var schedule = shape({
   require_all_closed: bool,
   start_state: nullable(bundledState)
 });
+function validateLibraryV3Shape(value) {
+  const envelope = { format: oneOf(["tines.library"]), version: oneOf([3]), exported_at: integer };
+  const digest = (v, p) => {
+    text2(71)(v, p);
+    if (v !== "" && !/^sha256:[0-9a-f]{64}$/.test(v))
+      invalid(p, "invalid_digest", "Expected sha256 and 64 lowercase hex digits");
+  };
+  discriminated("profile", {
+    workflow: shape(
+      {
+        ...envelope,
+        profile: oneOf(["workflow"]),
+        main_workflow_id: id,
+        workflows: array(workflow(false)),
+        context: array(context(false)),
+        inputs: array(input),
+        text_uses: array(
+          shape({
+            id,
+            target: shape({
+              record_id: id,
+              field: oneOf([
+                "description",
+                "body",
+                "content",
+                "title_template",
+                "description_template"
+              ])
+            }),
+            input_id: id,
+            token: text2(30100, true)
+          })
+        ),
+        schedules: array(schedule),
+        routing: array(
+          shape({
+            id,
+            scope: shape({ state_id: id }, { project: projectRef }),
+            tier: oneOf(MODEL_TIERS)
+          })
+        )
+      },
+      { digest }
+    ),
+    library: shape(
+      {
+        ...envelope,
+        profile: oneOf(["library"]),
+        workflows: array(workflow(true)),
+        context: array(context(true)),
+        projects: array(
+          shape({
+            id,
+            name: text2(200, true),
+            description: text2(1e4),
+            default_workflow: nullable(
+              discriminated("kind", {
+                bundled_workflow: bundledWorkflow,
+                system_workflow: shape({
+                  kind: oneOf(["system_workflow"]),
+                  name: oneOf(["Standard"])
+                })
+              })
+            )
+          })
+        ),
+        labels: array(shape({ id, name: labelName, color: oneOf(LABEL_COLORS) }))
+      },
+      { digest }
+    )
+  })(value, "");
+}
+
+// ../shared/src/library/inputs.ts
+function inputToken(key, defaultValue) {
+  const escaped = (defaultValue ?? "").replaceAll("\\", "\\\\").replaceAll(":", "\\:").replaceAll("}", "\\}");
+  return `{{${key}:${escaped}}}`;
+}
+function renderDeclaredTokens(source, declarations) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const { token } of declarations) {
+    if (!token || tokens.has(token))
+      throw new LibraryValidationError([
+        {
+          path: "/text_uses",
+          code: "duplicate_text_use",
+          message: "Tokens must be non-empty and unique within a field"
+        }
+      ]);
+    tokens.add(token);
+  }
+  const matches = [];
+  declarations.forEach(({ token }, index) => {
+    for (let offset2 = 0; offset2 < source.length; ) {
+      const start = source.indexOf(token, offset2);
+      if (start < 0) break;
+      matches.push({
+        start,
+        end: start + token.length,
+        index,
+        escaped: start > 0 && source[start - 1] === "\\"
+      });
+      offset2 = start + 1;
+    }
+  });
+  matches.sort((a, b) => a.start - b.start || a.end - b.end);
+  for (let i = 1; i < matches.length; i++) {
+    if (matches[i].start < matches[i - 1].end)
+      throw new LibraryValidationError([
+        {
+          path: "/text_uses",
+          code: "overlapping_text_use",
+          message: "Declared token occurrences overlap"
+        }
+      ]);
+  }
+  let value = "";
+  let offset = 0;
+  const counts = declarations.map(() => 0);
+  for (const match of matches) {
+    value += source.slice(offset, match.escaped ? match.start - 1 : match.start);
+    value += match.escaped ? declarations[match.index].token : declarations[match.index].value;
+    if (!match.escaped) counts[match.index]++;
+    offset = match.end;
+  }
+  return { value: value + source.slice(offset), counts };
+}
+
+// ../shared/src/library/references.ts
+function validateLibraryV3References(document) {
+  validateLibraryV3Shape(document);
+  const ids = /* @__PURE__ */ new Map();
+  let count = 0;
+  const add = (id2, path2) => {
+    count++;
+    if (count > LIBRARY_V3_MAX_RECORDS)
+      invalid(path2, "package_too_large", `Package exceeds ${LIBRARY_V3_MAX_RECORDS} records`);
+    if (ids.has(id2)) invalid(path2, "duplicate_local_id", `Local ID already used at ${ids.get(id2)}`);
+    ids.set(id2, path2);
+  };
+  const unique = (values, path2, code) => {
+    if (new Set(values).size !== values.length) invalid(path2, code, "Values must be unique");
+  };
+  const workflows = new Map(document.workflows.map((w) => [w.id, w]));
+  const states = /* @__PURE__ */ new Map();
+  const fields = /* @__PURE__ */ new Map();
+  const requireRef = (exists, path2, message3 = "Reference does not identify the required record kind") => {
+    if (!exists) invalid(path2, "invalid_reference", message3);
+  };
+  const system = (ref, path2) => {
+    requireRef(
+      ["Open", "Human Review", "Closed"].includes(ref.state_name),
+      path2,
+      "Unknown Standard state"
+    );
+  };
+  for (const [wi, w] of document.workflows.entries()) {
+    const p = `/workflows/${wi}`;
+    add(w.id, `${p}/id`);
+    fields.set(w.id, { description: w.description });
+    if (!w.states.length)
+      invalid(`${p}/states`, "no_states", "A workflow needs at least one state");
+    unique(
+      w.states.map((s) => s.name.trim()),
+      `${p}/states`,
+      "duplicate_state_name"
+    );
+    for (const [si, s] of w.states.entries()) {
+      const sp = `${p}/states/${si}`;
+      add(s.id, `${sp}/id`);
+      states.set(s.id, { state: s, workflow: w.id, path: sp });
+    }
+    const local = new Map(w.states.map((s) => [s.id, s]));
+    const initial = local.get(w.initial_state_id);
+    requireRef(!!initial, `${p}/initial_state_id`, "Initial state must belong to its workflow");
+    if (initial && initial.category !== "backlog" && initial.category !== "active")
+      invalid(
+        `${p}/initial_state_id`,
+        "invalid_initial_state",
+        "Initial state must be backlog or active"
+      );
+    unique(
+      w.transitions.map((t) => `${t.from_state_id}\0${t.name.trim().toLowerCase()}`),
+      `${p}/transitions`,
+      "duplicate_action"
+    );
+    for (const [ti, t] of w.transitions.entries()) {
+      const tp = `${p}/transitions/${ti}`;
+      add(t.id, `${tp}/id`);
+      requireRef(local.has(t.from_state_id), `${tp}/from_state_id`);
+      requireRef(local.has(t.to_state_id), `${tp}/to_state_id`);
+      if (t.from_state_id === t.to_state_id)
+        invalid(tp, "self_transition", "Self transitions are not allowed");
+      unique(
+        t.requires.map((r) => r.artifact),
+        `${tp}/requires`,
+        "duplicate_requirement"
+      );
+    }
+  }
+  for (const { state, path: path2 } of states.values()) {
+    const ref = state.inherits_from;
+    if (ref?.kind === "bundled_state")
+      requireRef(states.has(ref.state_id), `${path2}/inherits_from`);
+    else if (ref?.kind === "system_state") system(ref, `${path2}/inherits_from`);
+  }
+  for (const entry of states.values()) {
+    const chain = /* @__PURE__ */ new Set();
+    let current = entry;
+    let length = 0;
+    while (current) {
+      if (chain.has(current.state.id))
+        invalid(
+          `${entry.path}/inherits_from`,
+          "inheritance_cycle",
+          "State inheritance contains a cycle"
+        );
+      chain.add(current.state.id);
+      length++;
+      const ref = current.state.inherits_from;
+      if (ref?.kind === "system_state") length++;
+      if (length > 3)
+        invalid(
+          `${entry.path}/inherits_from`,
+          "inheritance_depth",
+          "Inheritance may contain at most three states"
+        );
+      current = ref?.kind === "bundled_state" ? states.get(ref.state_id) : void 0;
+    }
+  }
+  const contextKeys = /* @__PURE__ */ new Set();
+  for (const [ci, item] of document.context.entries()) {
+    const p = `/context/${ci}`;
+    add(item.id, `${p}/id`);
+    fields.set(item.id, {
+      description: item.description,
+      ...item.kind === "prompt" ? { body: item.body } : {}
+    });
+    let scope;
+    if ("state_id" in item) {
+      requireRef(states.has(item.state_id), `${p}/state_id`);
+      scope = item.state_id;
+    } else {
+      const ref = item.scope.state;
+      if (ref?.kind === "bundled_state") requireRef(states.has(ref.state_id), `${p}/scope/state`);
+      if (ref?.kind === "system_state") system(ref, `${p}/scope/state`);
+      if (document.profile !== "library")
+        invalid(p, "invalid_scope", "Package context must have exact state scope");
+      if (item.scope.project_id)
+        requireRef(
+          document.projects.some((r) => r.id === item.scope.project_id),
+          `${p}/scope/project_id`
+        );
+      if (item.scope.label_id)
+        requireRef(
+          document.labels.some((r) => r.id === item.scope.label_id),
+          `${p}/scope/label_id`
+        );
+      scope = JSON.stringify([
+        item.scope.project_id ?? null,
+        ref?.kind === "bundled_state" ? ["bundled", ref.state_id] : ref ? ["system", ref.state_name] : null,
+        item.scope.label_id ?? null
+      ]);
+    }
+    const key = JSON.stringify([scope, item.kind, item.name.trim()]);
+    if (contextKeys.has(key))
+      invalid(p, "duplicate_context", "Context kind/name must be unique at its exact scope");
+    contextKeys.add(key);
+    if (item.kind === "skill")
+      for (const [fi, file] of item.files.entries()) {
+        add(file.id, `${p}/files/${fi}/id`);
+        fields.set(file.id, { content: file.content });
+      }
+  }
+  if (document.profile === "library") {
+    for (const [i, p] of document.projects.entries()) {
+      add(p.id, `/projects/${i}/id`);
+      if (p.default_workflow?.kind === "bundled_workflow")
+        requireRef(
+          workflows.has(p.default_workflow.workflow_id),
+          `/projects/${i}/default_workflow`
+        );
+    }
+    for (const [i, label] of document.labels.entries()) add(label.id, `/labels/${i}/id`);
+    unique(
+      document.projects.map((p) => p.name.trim()),
+      "/projects",
+      "duplicate_project"
+    );
+    unique(
+      document.labels.map((l) => l.name.trim().toLowerCase()),
+      "/labels",
+      "duplicate_label"
+    );
+    return;
+  }
+  requireRef(
+    workflows.has(document.main_workflow_id),
+    "/main_workflow_id",
+    "Main workflow does not exist"
+  );
+  const reached = /* @__PURE__ */ new Set();
+  const pending = [document.main_workflow_id];
+  while (pending.length) {
+    const id2 = pending.pop();
+    if (reached.has(id2)) continue;
+    reached.add(id2);
+    for (const s of workflows.get(id2).states)
+      if (s.inherits_from?.kind === "bundled_state")
+        pending.push(states.get(s.inherits_from.state_id).workflow);
+  }
+  for (const [i, w] of document.workflows.entries())
+    if (!reached.has(w.id))
+      invalid(
+        `/workflows/${i}`,
+        "disconnected_workflow",
+        "Every dependency workflow must be reachable through inheritance"
+      );
+  const inputs = new Map(document.inputs.map((input2) => [input2.id, input2]));
+  unique(
+    document.inputs.map((input2) => input2.key),
+    "/inputs",
+    "duplicate_input_key"
+  );
+  for (const [i, input2] of document.inputs.entries()) {
+    add(input2.id, `/inputs/${i}/id`);
+    if (input2.required_states)
+      unique(
+        input2.required_states.map((s) => s.trim()),
+        `/inputs/${i}/required_states`,
+        "duplicate_required_state"
+      );
+  }
+  const project = (id2, path2) => requireRef(inputs.get(id2)?.type === "project", path2, "Expected a project input declaration");
+  for (const [i, schedule2] of document.schedules.entries()) {
+    const p = `/schedules/${i}`;
+    add(schedule2.id, `${p}/id`);
+    requireRef(workflows.has(schedule2.workflow.workflow_id), `${p}/workflow`);
+    project(schedule2.project.input_id, `${p}/project`);
+    if (schedule2.start_state)
+      requireRef(
+        states.get(schedule2.start_state.state_id)?.workflow === schedule2.workflow.workflow_id,
+        `${p}/start_state`,
+        "Start state must belong to the scheduled workflow"
+      );
+    fields.set(schedule2.id, {
+      title_template: schedule2.title_template,
+      description_template: schedule2.description_template
+    });
+  }
+  const routingScopes = /* @__PURE__ */ new Set();
+  for (const [i, routing] of document.routing.entries()) {
+    const p = `/routing/${i}`;
+    add(routing.id, `${p}/id`);
+    requireRef(states.has(routing.scope.state_id), `${p}/scope/state_id`);
+    if (routing.scope.project) project(routing.scope.project.input_id, `${p}/scope/project`);
+    const key = JSON.stringify([routing.scope.state_id, routing.scope.project?.input_id ?? null]);
+    if (routingScopes.has(key))
+      invalid(p, "duplicate_routing", "Only one tier preference is allowed per scope");
+    routingScopes.add(key);
+  }
+  const uses = /* @__PURE__ */ new Map();
+  for (const [i, use] of document.text_uses.entries()) {
+    const p = `/text_uses/${i}`;
+    add(use.id, `${p}/id`);
+    const input2 = inputs.get(use.input_id);
+    requireRef(!!input2, `${p}/input_id`);
+    const target = fields.get(use.target.record_id);
+    requireRef(
+      !!target && Object.hasOwn(target, use.target.field),
+      `${p}/target`,
+      "Text use must target an allowed field on this record kind"
+    );
+    if (use.token !== inputToken(input2.key, input2.default))
+      invalid(`${p}/token`, "invalid_token", "Token must match its declared input key and default");
+    const key = JSON.stringify([use.target.record_id, use.target.field]);
+    const group = uses.get(key) ?? {
+      source: target[use.target.field],
+      declarations: [],
+      paths: []
+    };
+    group.declarations.push({ token: use.token, value: "" });
+    group.paths.push(p);
+    uses.set(key, group);
+  }
+  for (const group of uses.values()) {
+    const result = renderDeclaredTokens(group.source, group.declarations);
+    result.counts.forEach((count2, i) => {
+      if (!count2)
+        invalid(
+          pointer(group.paths[i], "token"),
+          "unused_text_use",
+          "Declaration must match at least one unescaped occurrence"
+        );
+    });
+  }
+}
+
+// ../shared/src/library/canonical.ts
+function canonicalValue(value, path2 = "", depth = 0) {
+  if (depth > 64) invalid(path2, "maximum_depth", "JSON nesting exceeds 64");
+  if (typeof value === "string") validateUnicode(value, path2);
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new LibraryValidationError([
+        { path: "", code: "invalid_number", message: "Numbers must be finite" }
+      ]);
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++)
+      if (!Object.hasOwn(value, i))
+        invalid(pointer(path2, i), "invalid_value", "Sparse arrays are not JSON values");
+    return `[${value.map((v, i) => canonicalValue(v, pointer(path2, i), depth + 1)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    if (![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+      invalid(path2, "invalid_value", "Expected a plain JSON object");
+    for (const key of Object.keys(value)) validateUnicode(key, pointer(path2, key));
+    return `{${Object.keys(value).sort().map(
+      (key) => `${JSON.stringify(key)}:${canonicalValue(value[key], pointer(path2, key), depth + 1)}`
+    ).join(",")}}`;
+  }
+  throw new LibraryValidationError([
+    {
+      path: "",
+      code: "invalid_value",
+      message: "Undefined and non-JSON values are not canonicalizable"
+    }
+  ]);
+}
+function canonicalizeLibraryValue(value) {
+  return canonicalValue(value);
+}
+async function libraryDocumentDigest(document) {
+  const { digest: _digest, ...unsigned } = document;
+  validateLibraryV3References(unsigned);
+  const bytes2 = new TextEncoder().encode(canonicalValue(unsigned));
+  if (new TextEncoder().encode(canonicalValue({ ...unsigned, digest: `sha256:${"0".repeat(64)}` })).byteLength > LIBRARY_MAX_BYTES)
+    invalid("", "package_too_large", `Document exceeds ${LIBRARY_MAX_BYTES} bytes`);
+  const hash = await crypto.subtle.digest("SHA-256", bytes2);
+  return `sha256:${Array.from(new Uint8Array(hash), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// ../shared/src/library/parse.ts
+var StrictJsonParser = class {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  offset = 0;
+  parse() {
+    const value = this.value(0, "");
+    this.space();
+    if (this.offset !== this.source.length)
+      this.fail("", "invalid_json", "Unexpected trailing input");
+    return value;
+  }
+  value(depth, path2) {
+    if (depth > LIBRARY_V3_MAX_DEPTH)
+      this.fail(path2, "maximum_depth", `JSON nesting exceeds ${LIBRARY_V3_MAX_DEPTH}`);
+    this.space();
+    const char = this.source[this.offset];
+    if (char === "{") return this.object(depth + 1, path2);
+    if (char === "[") return this.array(depth + 1, path2);
+    if (char === '"') return this.string(path2);
+    if (char === "t" && this.take("true")) return true;
+    if (char === "f" && this.take("false")) return false;
+    if (char === "n" && this.take("null")) return null;
+    if (char === "-" || char >= "0" && char <= "9") return this.number(path2);
+    this.fail(path2, "invalid_json", "Expected a JSON value");
+  }
+  object(depth, path2) {
+    this.offset++;
+    const result = /* @__PURE__ */ Object.create(null);
+    const keys = /* @__PURE__ */ new Set();
+    this.space();
+    if (this.source[this.offset] === "}") {
+      this.offset++;
+      return result;
+    }
+    while (true) {
+      this.space();
+      if (this.source[this.offset] !== '"')
+        this.fail(path2, "invalid_json", "Expected an object key");
+      const key = this.string(path2);
+      const keyPath = `${path2}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+      if (keys.has(key))
+        this.fail(keyPath, "duplicate_key", `Duplicate object key ${JSON.stringify(key)}`);
+      keys.add(key);
+      this.space();
+      if (this.source[this.offset++] !== ":")
+        this.fail(keyPath, "invalid_json", "Expected colon after object key");
+      result[key] = this.value(depth, keyPath);
+      this.space();
+      const separator = this.source[this.offset++];
+      if (separator === "}") return result;
+      if (separator !== ",") this.fail(path2, "invalid_json", "Expected comma or closing brace");
+    }
+  }
+  array(depth, path2) {
+    this.offset++;
+    const result = [];
+    this.space();
+    if (this.source[this.offset] === "]") {
+      this.offset++;
+      return result;
+    }
+    while (true) {
+      result.push(this.value(depth, `${path2}/${result.length}`));
+      this.space();
+      const separator = this.source[this.offset++];
+      if (separator === "]") return result;
+      if (separator !== ",") this.fail(path2, "invalid_json", "Expected comma or closing bracket");
+    }
+  }
+  string(path2) {
+    const start = this.offset++;
+    while (this.offset < this.source.length) {
+      const code = this.source.charCodeAt(this.offset);
+      if (code === 34) {
+        this.offset++;
+        let value;
+        try {
+          value = JSON.parse(this.source.slice(start, this.offset));
+        } catch {
+          this.fail(path2, "invalid_json", "Invalid JSON string escape");
+        }
+        for (let i = 0; i < value.length; i++) {
+          const unit = value.charCodeAt(i);
+          if (unit >= 55296 && unit <= 56319) {
+            const next = value.charCodeAt(++i);
+            if (!(next >= 56320 && next <= 57343))
+              this.fail(path2, "invalid_unicode", "Lone UTF-16 surrogate is not allowed");
+          } else if (unit >= 56320 && unit <= 57343)
+            this.fail(path2, "invalid_unicode", "Lone UTF-16 surrogate is not allowed");
+        }
+        return value;
+      }
+      if (code < 32) this.fail(path2, "invalid_json", "Unescaped control character in string");
+      if (code === 92) this.offset++;
+      this.offset++;
+    }
+    this.fail(path2, "invalid_json", "Unterminated JSON string");
+  }
+  number(path2) {
+    const rest = this.source.slice(this.offset);
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(rest);
+    if (!match) this.fail(path2, "invalid_json", "Invalid number");
+    this.offset += match[0].length;
+    const value = Number(match[0]);
+    if (!Number.isFinite(value)) this.fail(path2, "invalid_number", "Numbers must be finite");
+    return value;
+  }
+  take(word) {
+    if (!this.source.startsWith(word, this.offset)) return false;
+    this.offset += word.length;
+    return true;
+  }
+  space() {
+    while (/[ \t\r\n]/.test(this.source[this.offset] ?? "x")) this.offset++;
+  }
+  fail(path2, code, message3) {
+    throw new LibraryValidationError([{ path: path2, code, message: message3 }]);
+  }
+};
+var TOP_LEVEL = {
+  workflow: [
+    "format",
+    "version",
+    "profile",
+    "exported_at",
+    "digest",
+    "main_workflow_id",
+    "workflows",
+    "context",
+    "inputs",
+    "text_uses",
+    "schedules",
+    "routing"
+  ],
+  library: [
+    "format",
+    "version",
+    "profile",
+    "exported_at",
+    "digest",
+    "projects",
+    "labels",
+    "workflows",
+    "context"
+  ]
+};
+function structuralDocument(value, allowMissingDigest) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new LibraryValidationError([
+      { path: "", code: "invalid_document", message: "Library document must be an object" }
+    ]);
+  const object3 = value;
+  if (object3.format !== "tines.library")
+    throw new LibraryValidationError([
+      { path: "/format", code: "invalid_format", message: "Expected tines.library" }
+    ]);
+  if (object3.version !== 3)
+    throw new LibraryValidationError([
+      {
+        path: "/version",
+        code: "unsupported_version",
+        message: `Unsupported library version ${String(object3.version)}`
+      }
+    ]);
+  if (object3.profile !== "workflow" && object3.profile !== "library")
+    throw new LibraryValidationError([
+      { path: "/profile", code: "invalid_profile", message: "Expected workflow or library profile" }
+    ]);
+  const allowed = TOP_LEVEL[object3.profile];
+  const unknown = Object.keys(object3).find((key) => !allowed.includes(key));
+  if (unknown)
+    throw new LibraryValidationError([
+      { path: `/${unknown}`, code: "unknown_field", message: `Unknown field ${unknown}` }
+    ]);
+  if (!Number.isSafeInteger(object3.exported_at) || object3.exported_at < 0)
+    throw new LibraryValidationError([
+      {
+        path: "/exported_at",
+        code: "invalid_integer",
+        message: "exported_at must be a non-negative safe integer"
+      }
+    ]);
+  if (!(allowMissingDigest && object3.digest === void 0) && (typeof object3.digest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(object3.digest)))
+    throw new LibraryValidationError([
+      {
+        path: "/digest",
+        code: "invalid_digest",
+        message: "digest must be sha256 followed by 64 lowercase hex characters"
+      }
+    ]);
+  for (const key of allowed) {
+    if (key === "digest" && allowMissingDigest) continue;
+    if (!(key in object3))
+      throw new LibraryValidationError([
+        { path: `/${key}`, code: "missing_field", message: `Missing required field ${key}` }
+      ]);
+  }
+  return {
+    ...object3,
+    digest: typeof object3.digest === "string" ? object3.digest : ""
+  };
+}
+async function parseLibraryV3Document(input2, options = {}) {
+  const bytes2 = typeof input2 === "string" ? new TextEncoder().encode(input2) : input2;
+  if (bytes2.byteLength > LIBRARY_MAX_BYTES)
+    throw new LibraryValidationError([
+      {
+        path: "",
+        code: "package_too_large",
+        message: `Document exceeds ${LIBRARY_MAX_BYTES} bytes`
+      }
+    ]);
+  let source;
+  try {
+    source = typeof input2 === "string" ? input2 : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input2);
+  } catch {
+    throw new LibraryValidationError([
+      { path: "", code: "invalid_utf8", message: "Document is not valid UTF-8" }
+    ]);
+  }
+  const document = structuralDocument(
+    new StrictJsonParser(source).parse(),
+    options.allowMissingDigest ?? false
+  );
+  validateLibraryV3References(document);
+  const actual = await libraryDocumentDigest(document);
+  if (document.digest && document.digest !== actual)
+    throw new LibraryValidationError([
+      {
+        path: "/digest",
+        code: "digest_mismatch",
+        message: `Document digest does not match; expected ${actual}`
+      }
+    ]);
+  return { ...document, digest: actual };
+}
+function parseStrictLibraryJson(source) {
+  return new StrictJsonParser(source).parse();
+}
 
 // ../shared/src/library/choices.ts
 var PACKAGE_CHOICES_MAX_BYTES = 512 * 1024;
@@ -4737,48 +5594,48 @@ function commentLines(comment) {
 function sinceLastRunLines(since, now = Date.now()) {
   const prev = since.previous_run;
   const ended = prev.ended_at === null ? "not ended" : `ended ${ageLabel(prev.ended_at, now)} ago`;
-  const lines = [
+  const lines2 = [
     `since the last run (${prev.state_at_start_name ?? "unknown state"}, ${prev.run_id} ${ended}):`
   ];
   const t = since.transition;
   if (t) {
     const via = t.action ? `via "${t.action}"` : "moved directly";
     const stale = since.stale_artifacts.length > 0 ? ` \u2014 now stale: ${since.stale_artifacts.join(", ")}` : "";
-    lines.push(
+    lines2.push(
       `  moved from ${t.from_state.name} ${via} by ${actorLabel(t.actor)} ${ageLabel(t.at, now)} ago${stale}`
     );
   }
-  for (const c of since.comments) lines.push(...commentLines(c));
+  for (const c of since.comments) lines2.push(...commentLines(c));
   if (since.comment_count > since.comments.length) {
     const hidden = since.comment_count - since.comments.length;
-    lines.push(`  \u2026 and ${hidden} earlier comment${hidden === 1 ? "" : "s"}`);
+    lines2.push(`  \u2026 and ${hidden} earlier comment${hidden === 1 ? "" : "s"}`);
   }
-  return lines;
+  return lines2;
 }
 function roundLines(round, now = Date.now()) {
   const b = round.boundary;
   const from = b ? `since ${actorLabel(b.actor)} ${b.action ? `moved "${b.action}"` : "moved it directly"} ${timestamp(b.at)}` : `since created ${timestamp(round.boundary_at)}`;
-  const lines = [`round (${round.run_count} run${round.run_count === 1 ? "" : "s"} ${from}):`];
+  const lines2 = [`round (${round.run_count} run${round.run_count === 1 ? "" : "s"} ${from}):`];
   for (const stage of round.stages) {
     const [latest, ...earlier] = stage.runs;
     if (!latest) continue;
-    lines.push(`  ${stage.state.name ?? stage.state.id} \u2014 ${runHeadline(latest, now)}`);
+    lines2.push(`  ${stage.state.name ?? stage.state.id} \u2014 ${runHeadline(latest, now)}`);
     if (latest.artifacts.length > 0) {
-      lines.push(`    ${latest.artifacts.map(artifactChangeLabel).join(" \xB7 ")}`);
+      lines2.push(`    ${latest.artifacts.map(artifactChangeLabel).join(" \xB7 ")}`);
     }
-    for (const run of earlier) lines.push(`    ${earlierAttemptLine(run, now)}`);
+    for (const run of earlier) lines2.push(`    ${earlierAttemptLine(run, now)}`);
     if (latest.summary_comment) {
-      lines.push(`    summary (${latest.summary_comment.id}):`);
-      for (const line of latest.summary_comment.body.split("\n")) lines.push(`      ${line}`);
+      lines2.push(`    summary (${latest.summary_comment.id}):`);
+      for (const line of latest.summary_comment.body.split("\n")) lines2.push(`      ${line}`);
     }
     const earlierComments = latest.earlier_comment_ids;
     if (earlierComments.length > 0) {
-      lines.push(
+      lines2.push(
         `    ${earlierComments.length} earlier comment${earlierComments.length === 1 ? "" : "s"}: ${earlierComments.join(", ")}`
       );
     }
   }
-  return lines;
+  return lines2;
 }
 function runHeadline(run, now) {
   const cost = runCostLabel(run);
@@ -4824,9 +5681,9 @@ function runRow(run) {
     timestamp(run.created_at)
   ];
 }
-function byteSize(bytes) {
+function byteSize(bytes2) {
   const units = ["B", "KB", "MB", "GB", "TB"];
-  let value = Math.max(0, bytes);
+  let value = Math.max(0, bytes2);
   let unit = 0;
   while (value >= 1024 && unit < units.length - 1) {
     value /= 1024;
@@ -5144,15 +6001,15 @@ async function resolveStateFlag(api, ref) {
   if (sep2 < 1 || sep2 === ref.length - 1) {
     die(`--state must look like <workflow>/<state>, got "${ref}"`);
   }
-  const workflow = await resolveWorkflow(api, ref.slice(0, sep2));
-  const stateRef = ref.slice(sep2 + 1);
-  const state = workflow.states.find((s) => s.name === stateRef) ?? workflow.states.find((s) => s.id === stateRef);
+  const workflow2 = await resolveWorkflow(api, ref.slice(0, sep2));
+  const stateRef2 = ref.slice(sep2 + 1);
+  const state = workflow2.states.find((s) => s.name === stateRef2) ?? workflow2.states.find((s) => s.id === stateRef2);
   if (!state) {
     die(
-      `workflow "${workflow.name}" has no state "${stateRef}" (have: ${workflow.states.map((s) => s.name).join(", ")})`
+      `workflow "${workflow2.name}" has no state "${stateRef2}" (have: ${workflow2.states.map((s) => s.name).join(", ")})`
     );
   }
-  return { workflow, state };
+  return { workflow: workflow2, state };
 }
 var collect = (value, previous) => [...previous, value];
 async function resolveRunner(api, ref) {
@@ -5216,12 +6073,12 @@ function withScopeFlags(cmd) {
   return cmd.option("-p, --project <name>", "scope: project name or id").option("-s, --state <workflow/state>", "scope: workflow-qualified state").option("-i, --issue <ref>", "scope: issue (<project>/<number>)").option("-l, --label <name>", "scope: issue label name or id").addHelpText("after", SCOPE_FLAGS_HELP);
 }
 function register(program3) {
-  const context = program3.command("context").description(
+  const context2 = program3.command("context").description(
     "Manage context items (prompts, skills, repo pointers) scoped to projects, states, and issues"
   );
   withList(
     withScopeFlags(
-      context.command("list").description(
+      context2.command("list").description(
         "List context items (scope filters match every item whose scope includes the element)"
       ).option("-k, --kind <kind>", "filter by kind: prompt, skill, or repo").option("--exact", "only items whose scope sets exactly the given dimensions").option("-q, --search <text>", "search names and descriptions")
     )
@@ -5259,7 +6116,7 @@ function register(program3) {
     }
   );
   withCommon(
-    context.command("show <id>").description("Show a context item (skills include their files)")
+    context2.command("show <id>").description("Show a context item (skills include their files)")
   ).action(async (id2, opts) => {
     const item = await client(opts).getContextItem(id2);
     if (opts.json) return printJson(item);
@@ -5267,7 +6124,7 @@ function register(program3) {
   });
   withCommon(
     withScopeFlags(
-      context.command("create").description("Create a context item scoped to a project, state, and/or issue").requiredOption("-k, --kind <kind>", "prompt, skill, or repo").requiredOption(
+      context2.command("create").description("Create a context item scoped to a project, state, and/or issue").requiredOption("-k, --kind <kind>", "prompt, skill, or repo").requiredOption(
         "-n, --name <name>",
         "item name (slug-like for skills; the dedup/override key)"
       ).option("-d, --description <text>", "one-liner shown in lists").option("--body <md>", "prompt body: inline Markdown or @file (escape a literal @ as @@)").option(
@@ -5303,7 +6160,7 @@ function register(program3) {
   );
   withCommon(
     withScopeFlags(
-      context.command("edit <id>").description("Edit a context item: payload, name, description, or scope").option("-n, --name <name>", "rename the item").option("-d, --description <text>", "set the description").option("--body <md>", "prompt body: inline Markdown or @file (escape a literal @ as @@)").option("--file <path>=@<local>", "add or replace a skill file (repeatable)", collect, []).option("--remove-file <path>", "remove a skill file (repeatable)", collect, []).option("--repo-url <url>", "repo: clone URL").option("--branch <branch>", "repo: branch (empty string clears it)").option("--dir <dir>", "repo: checkout directory (empty string restores the URL default)").option(
+      context2.command("edit <id>").description("Edit a context item: payload, name, description, or scope").option("-n, --name <name>", "rename the item").option("-d, --description <text>", "set the description").option("--body <md>", "prompt body: inline Markdown or @file (escape a literal @ as @@)").option("--file <path>=@<local>", "add or replace a skill file (repeatable)", collect, []).option("--remove-file <path>", "remove a skill file (repeatable)", collect, []).option("--repo-url <url>", "repo: clone URL").option("--branch <branch>", "repo: branch (empty string clears it)").option("--dir <dir>", "repo: checkout directory (empty string restores the URL default)").option(
         "--unset <dimension>",
         "drop a scope dimension: project, state, issue, or label (repeatable)",
         collect,
@@ -5336,19 +6193,19 @@ function register(program3) {
         if (current.kind !== "skill")
           die(`--file/--remove-file only apply to skills (this is a ${current.kind})`);
         if (body.expected_version === void 0) body.expected_version = current.version;
-        const files = new Map((current.files ?? []).map((f) => [f.path, f.content]));
+        const files2 = new Map((current.files ?? []).map((f) => [f.path, f.content]));
         for (const path2 of opts.removeFile) {
-          if (!files.delete(path2)) {
+          if (!files2.delete(path2)) {
             die(
-              `no file "${path2}" in skill "${current.name}" (have: ${[...files.keys()].join(", ") || "none"})`
+              `no file "${path2}" in skill "${current.name}" (have: ${[...files2.keys()].join(", ") || "none"})`
             );
           }
         }
         for (const spec of opts.file) {
           const f = parseFileSpec(spec);
-          files.set(f.path, f.content);
+          files2.set(f.path, f.content);
         }
-        body.files = [...files.entries()].map(([path2, content]) => ({ path: path2, content }));
+        body.files = [...files2.entries()].map(([path2, content]) => ({ path: path2, content }));
       }
       if (opts.repoUrl !== void 0) body.repo_url = opts.repoUrl;
       if (opts.branch !== void 0) body.repo_branch = opts.branch === "" ? null : opts.branch;
@@ -5363,7 +6220,7 @@ function register(program3) {
       console.log(`updated ${item.kind} "${item.name}" (${item.id}) \u2014 scope: ${item.scope.label}`);
     }
   );
-  withCommon(context.command("delete <id>").description("Delete a context item")).action(
+  withCommon(context2.command("delete <id>").description("Delete a context item")).action(
     async (id2, opts) => {
       const api = client(opts);
       const item = await api.getContextItem(id2);
@@ -5372,7 +6229,7 @@ function register(program3) {
     }
   );
   withCommon(
-    context.command("init").description('Seed the global "agent-guidelines" prompt (a no-op if it already exists)')
+    context2.command("init").description('Seed the global "agent-guidelines" prompt (a no-op if it already exists)')
   ).action(async (opts) => {
     const api = client(opts);
     const items = await listAll(
@@ -5424,98 +6281,98 @@ function repoLine(change) {
   return `      checkout: ${show(before)} => ${show(after)}`;
 }
 function routingLines(preview) {
-  const lines = ["", "Routing:"];
+  const lines2 = ["", "Routing:"];
   for (const [label, explainer] of [
     ["  before", preview.routing.before],
     ["  after ", preview.routing.after]
   ]) {
     if (!explainer) {
-      lines.push(`${label}: no explanation available`);
+      lines2.push(`${label}: no explanation available`);
       continue;
     }
-    lines.push(`${label}: ${explainer.verdict}`);
+    lines2.push(`${label}: ${explainer.verdict}`);
     if (explainer.pin) {
-      lines.push(
+      lines2.push(
         `           pin: runner ${explainer.pin.runner_name ?? explainer.pin.runner_id}, tier ${explainer.pin.tier ?? "default"}`
       );
     }
     for (const check of explainer.checks) {
-      lines.push(
+      lines2.push(
         `           ${check.ok ? "pass" : "FAIL"} ${check.name}: ${check.detail}${check.action?.label ? ` (${check.action.label})` : ""}`
       );
-      if (check.action?.cli) lines.push(`             fix: ${check.action.cli}`);
+      if (check.action?.cli) lines2.push(`             fix: ${check.action.cli}`);
     }
     if (explainer.matched_rule)
-      lines.push(`           matched rule ${explainer.matched_rule.scope_label}`);
+      lines2.push(`           matched rule ${explainer.matched_rule.scope_label}`);
     for (const tie of explainer.ambiguous_rules) {
-      lines.push(`           tied rule ${tie.scope_label}`);
+      lines2.push(`           tied rule ${tie.scope_label}`);
     }
     if (explainer.runner_rule)
-      lines.push(`           runner source rule ${explainer.runner_rule.scope_label}`);
-    if (explainer.tier_override) lines.push(`           tier override ${explainer.tier_override}`);
+      lines2.push(`           runner source rule ${explainer.runner_rule.scope_label}`);
+    if (explainer.tier_override) lines2.push(`           tier override ${explainer.tier_override}`);
     for (const target of explainer.targets) {
-      lines.push(
+      lines2.push(
         `           target ${target.runner_name} \u2014 ${target.tier}${target.model ? ` / ${target.model}` : ""}: ${target.verdict} \u2014 ${target.detail}`
       );
     }
     if (explainer.active_run)
-      lines.push(
+      lines2.push(
         `           active run ${explainer.active_run.id} (${explainer.active_run.status})`
       );
     if (explainer.queue_position !== null)
-      lines.push(`           queue position ${explainer.queue_position}`);
-    lines.push(
+      lines2.push(`           queue position ${explainer.queue_position}`);
+    lines2.push(
       `           attempts ${explainer.attempt_count}/${explainer.attempt_limit}; parked ${explainer.parked ? "yes" : "no"}`
     );
   }
-  lines.push("  Capacity, heartbeats and spending are advisory and may change at any moment.");
-  return lines;
+  lines2.push("  Capacity, heartbeats and spending are advisory and may change at any moment.");
+  return lines2;
 }
 function repoDetail(repo) {
   return `${repo.url}; branch ${repo.branch ?? "repository default branch"}; directory ${repo.dir}`;
 }
 function effectiveRepositoryLines(preview) {
-  const lines = ["", "Effective repositories:"];
-  for (const [label, context] of [
+  const lines2 = ["", "Effective repositories:"];
+  for (const [label, context2] of [
     ["  before", preview.context.before],
     ["  after ", preview.context.after]
   ]) {
-    lines.push(`${label}:`);
-    if (!context.repos.length) lines.push("    none");
-    for (const repo of context.repos) {
-      lines.push(`    ${repo.name} \u2014 effective (${repo.scope.label})`);
-      lines.push(`      ${repoDetail(repo)}`);
-      for (const loser of context.overridden.filter(
+    lines2.push(`${label}:`);
+    if (!context2.repos.length) lines2.push("    none");
+    for (const repo of context2.repos) {
+      lines2.push(`    ${repo.name} \u2014 effective (${repo.scope.label})`);
+      lines2.push(`      ${repoDetail(repo)}`);
+      for (const loser of context2.overridden.filter(
         (item) => item.kind === "repo" && item.name === repo.name
       )) {
-        lines.push(
+        lines2.push(
           `      overridden candidate ${loser.name} (${loser.scope.label}) \u2014 overridden by ${loser.overridden_by}`
         );
-        lines.push(
+        lines2.push(
           `        ${loser.repo ? repoDetail(loser.repo) : "checkout details unavailable from this server"}`
         );
       }
     }
   }
-  return lines;
+  return lines2;
 }
 function conflictLines(preview) {
-  const lines = ["", "Repository checkout conflicts:"];
+  const lines2 = ["", "Repository checkout conflicts:"];
   const deltas = deriveTransferConflictDeltas(preview.context.before, preview.context.after);
-  if (!deltas.length) return [...lines, "  none"];
+  if (!deltas.length) return [...lines2, "  none"];
   const participants = (items) => items.map(
     (item) => item.name && item.scope_label ? `${item.name} (${item.scope_label})` : item.item_id
   ).join(", ");
   for (const delta of deltas) {
-    lines.push(`  ${delta.change[0].toUpperCase()}${delta.change.slice(1)} \u2014 ${delta.dir}`);
-    if (delta.before.length) lines.push(`    Before: ${participants(delta.before)}`);
-    if (delta.after.length) lines.push(`    After: ${participants(delta.after)}`);
+    lines2.push(`  ${delta.change[0].toUpperCase()}${delta.change.slice(1)} \u2014 ${delta.dir}`);
+    if (delta.before.length) lines2.push(`    Before: ${participants(delta.before)}`);
+    if (delta.after.length) lines2.push(`    After: ${participants(delta.after)}`);
   }
-  return lines;
+  return lines2;
 }
 function formatTransferPreview(preview) {
   const p = preview.preserved;
-  const lines = [
+  const lines2 = [
     `Move ${preview.old_ref.ref} from ${preview.source.name} to ${preview.destination.name}`,
     `  ${preview.number_notice} The issue keeps its stable ID (${preview.issue_id}) and every old ref keeps working.`,
     "",
@@ -5526,37 +6383,37 @@ function formatTransferPreview(preview) {
     `  pins: ${p.pinned_runner_id ?? "none"}${p.pinned_tier ? ` (${p.pinned_tier})` : ""}; attempts ${p.attempt_count}${p.parked ? "; parked" : ""}`
   ];
   const changes = inspectableChanges(preview);
-  lines.push("", changes.length ? "Guidance:" : "Guidance: none.");
+  lines2.push("", changes.length ? "Guidance:" : "Guidance: none.");
   changes.forEach((change, index) => {
-    lines.push(`  [${index}] ${change.kind} "${change.name}" \u2014 ${CHANGE_LABEL[change.change]}`);
+    lines2.push(`  [${index}] ${change.kind} "${change.name}" \u2014 ${CHANGE_LABEL[change.change]}`);
     const scopeBefore = change.scope_before?.label ?? "\u2014";
     const scopeAfter = change.scope_after?.label ?? "\u2014";
-    lines.push(`      scope: ${scopeBefore} => ${scopeAfter}`);
-    lines.push(
+    lines2.push(`      scope: ${scopeBefore} => ${scopeAfter}`);
+    lines2.push(
       `      before: ${effectiveness(Boolean(change.scope_before), change.effective_before)}; after: ${effectiveness(Boolean(change.scope_after), change.effective_after)}`
     );
     const repo = repoLine(change);
-    if (repo) lines.push(repo);
+    if (repo) lines2.push(repo);
   });
-  lines.push(...effectiveRepositoryLines(preview), ...conflictLines(preview));
-  lines.push(...routingLines(preview));
+  lines2.push(...effectiveRepositoryLines(preview), ...conflictLines(preview));
+  lines2.push(...routingLines(preview));
   if (preview.schedule) {
-    lines.push(
+    lines2.push(
       "",
       `Schedule: ${preview.schedule.name} (${preview.schedule.project_name}) \u2014 ${preview.schedule.notice}`
     );
   }
   if (preview.blockers.length) {
-    lines.push("", "Cannot move yet:");
+    lines2.push("", "Cannot move yet:");
     for (const blocker of preview.blockers) {
-      lines.push(
+      lines2.push(
         `  ${blocker.code}: ${blocker.message}${blocker.remedy ? ` (${blocker.remedy})` : ""}`
       );
     }
   }
   if (preview.noop)
-    lines.push("", "This issue is already in that project; moving would change nothing.");
-  return lines.join("\n");
+    lines2.push("", "This issue is already in that project; moving would change nothing.");
+  return lines2.join("\n");
 }
 function formatTransferItem(preview, index) {
   const change = inspectableChanges(preview)[index];
@@ -5722,10 +6579,10 @@ function effectiveContentType(type, source, explicit, sniff) {
   if (source.kind === "file-stdin") return "application/octet-stream";
   return void 0;
 }
-function planAttach(input, sniff) {
-  const { ref, name: name2, positional, flags, probe } = input;
+function planAttach(input2, sniff) {
+  const { ref, name: name2, positional, flags, probe } = input2;
   assertOneSource(flags, positional);
-  const gates = flags.ignoreGates ? [] : input.gates;
+  const gates = flags.ignoreGates ? [] : input2.gates;
   const plan = positional !== void 0 ? planPositional(name2, positional, gates, probe, flags) : planFlags(flags, probe);
   if (gates.length > 0) {
     checkAccepted(plan, gates, ref, name2, flags, positional, sniff);
@@ -6119,14 +6976,14 @@ function readTextSource(source) {
   throw new Error(`not a text source: ${source.kind}`);
 }
 function walkFolder(dir) {
-  const files = [];
+  const files2 = [];
   const walk = (abs, rel) => {
     for (const entry of readdirSync(abs, { withFileTypes: true })) {
       const nextAbs = join2(abs, entry.name);
       const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
       if (entry.isDirectory()) walk(nextAbs, nextRel);
       else if (entry.isFile()) {
-        files.push({
+        files2.push({
           path: nextRel,
           contentType: sniffContentType(entry.name),
           bytes: readFileSync4(nextAbs)
@@ -6135,7 +6992,7 @@ function walkFolder(dir) {
     }
   };
   walk(dir, "");
-  return files;
+  return files2;
 }
 function printExplainer(issue, ex) {
   console.log(`${issue.project_name}/#${issue.number}  ${issue.title}`);
@@ -6576,34 +7433,34 @@ function register2(program3) {
   ).action(async (ref, opts) => {
     const api = client(opts);
     const issue = await resolveIssue(api, ref);
-    const context = await api.getIssueContext(issue.id);
-    if (opts.json && !opts.out) return printJson(context);
+    const context2 = await api.getIssueContext(issue.id);
+    if (opts.json && !opts.out) return printJson(context2);
     if (opts.out === void 0) {
-      if (context.prompt.text) console.log(context.prompt.text);
-      if (context.skills.length > 0) {
+      if (context2.prompt.text) console.log(context2.prompt.text);
+      if (context2.skills.length > 0) {
         console.log(`
-skills: ${context.skills.map((s) => s.name).join(", ")}`);
+skills: ${context2.skills.map((s) => s.name).join(", ")}`);
       }
-      for (const repo of context.repos) {
+      for (const repo of context2.repos) {
         console.log(
           `repo: ${repo.name} ${repo.url}${repo.branch ? `#${repo.branch}` : ""} \u2192 ${repo.dir}/`
         );
       }
-      for (const o of context.overridden) {
+      for (const o of context2.overridden) {
         console.log(
           `overridden: ${o.kind} "${o.name}" [${o.scope.label}] (overridden by ${o.overridden_by})`
         );
       }
-      for (const c of context.conflicts) {
+      for (const c of context2.conflicts) {
         console.log(
           `conflict: repos ${c.item_ids.join(", ")} all resolve to checkout dir "${c.dir}"`
         );
       }
       return;
     }
-    if (context.conflicts.length > 0) {
+    if (context2.conflicts.length > 0) {
       die(
-        `refusing to write: checkout-directory conflict${context.conflicts.length === 1 ? "" : "s"} among the effective repos (${context.conflicts.map((c) => `"${c.dir}": ${c.item_ids.join(", ")}`).join("; ")}); rename or re-dir the items first`
+        `refusing to write: checkout-directory conflict${context2.conflicts.length === 1 ? "" : "s"} among the effective repos (${context2.conflicts.map((c) => `"${c.dir}": ${c.item_ids.join(", ")}`).join("; ")}); rename or re-dir the items first`
       );
     }
     if (existsSync3(opts.out) && readdirSync(opts.out).length > 0 && !opts.force) {
@@ -6612,20 +7469,20 @@ skills: ${context.skills.map((s) => s.name).join(", ")}`);
     mkdirSync2(opts.out, { recursive: true });
     writeFileSync2(
       join2(opts.out, "prompt.md"),
-      context.prompt.text ? `${context.prompt.text}
+      context2.prompt.text ? `${context2.prompt.text}
 ` : ""
     );
-    for (const skill of context.skills) {
+    for (const skill of context2.skills) {
       for (const file of skill.files) {
         const target = join2(opts.out, "skills", skill.name, file.path);
         mkdirSync2(dirname2(target), { recursive: true });
         writeFileSync2(target, file.content);
       }
     }
-    writeFileSync2(join2(opts.out, "repos.json"), `${JSON.stringify(context.repos, null, 2)}
+    writeFileSync2(join2(opts.out, "repos.json"), `${JSON.stringify(context2.repos, null, 2)}
 `);
     console.log(
-      `wrote ${opts.out}/prompt.md, ${context.skills.length} skill${context.skills.length === 1 ? "" : "s"}, repos.json (${context.repos.length} repo${context.repos.length === 1 ? "" : "s"})`
+      `wrote ${opts.out}/prompt.md, ${context2.skills.length} skill${context2.skills.length === 1 ? "" : "s"}, repos.json (${context2.repos.length} repo${context2.repos.length === 1 ? "" : "s"})`
     );
   });
   withCommon(
@@ -6646,9 +7503,9 @@ skills: ${context.skills.map((s) => s.name).join(", ")}`);
   ).action(async (ref, opts) => {
     const api = client(opts);
     const issue = await resolveIssue(api, ref);
-    const prompt = await api.getIssuePrompt(issue.id);
-    if (opts.json) return printJson(prompt);
-    console.log(prompt.text);
+    const prompt2 = await api.getIssuePrompt(issue.id);
+    if (opts.json) return printJson(prompt2);
+    console.log(prompt2.text);
   });
   const artifactsCmd = issues.command("artifacts").description(
     "Typed, versioned attachments on an issue \u2014 the work products transition requirements gate on"
@@ -6711,11 +7568,11 @@ skills: ${context.skills.map((s) => s.name).join(", ")}`);
         v.reaffirmed_from !== null ? `reaffirmed v${v.reaffirmed_from}` : v.file_count !== null ? `${v.file_count} file${v.file_count === 1 ? "" : "s"}` : v.filename ?? v.url ?? (v.pr_repo_url ? prRefLabel(v) : "")
       ])
     );
-    const files = artifact.current_version.files;
-    if (files && files.length > 0) {
+    const files2 = artifact.current_version.files;
+    if (files2 && files2.length > 0) {
       console.log(`
 files (v${artifact.current_version.version}):`);
-      table(files.map((f) => [`  ${f.path}`, f.content_type, `${f.size_bytes} bytes`]));
+      table(files2.map((f) => [`  ${f.path}`, f.content_type, `${f.size_bytes} bytes`]));
     }
   });
   withCommon(
@@ -6754,30 +7611,30 @@ files (v${artifact.current_version.version}):`);
       let siteHtml = null;
       if (plan.type === "folder") {
         const dir = plan.source.dir;
-        const files = walkFolder(dir);
-        if (files.length === 0) die(`${dir} contains no files to snapshot`);
-        const index = files.find((f) => f.path === ARTIFACT_SITE_INDEX);
+        const files2 = walkFolder(dir);
+        if (files2.length === 0) die(`${dir} contains no files to snapshot`);
+        const index = files2.find((f) => f.path === ARTIFACT_SITE_INDEX);
         if (index) siteHtml = index.bytes.toString("utf8");
-        artifact = await api.uploadArtifactFolder(issue.id, name2, files);
+        artifact = await api.uploadArtifactFolder(issue.id, name2, files2);
         if (opts.description !== void 0) {
           artifact = await api.putArtifact(issue.id, name2, { description: opts.description });
         }
       } else if (plan.type === "file") {
         const fromPath = plan.source.kind === "file-path" ? plan.source.path : null;
-        let bytes;
+        let bytes2;
         if (fromPath === null) {
           if (process.stdin.isTTY) die('"-" reads the file from stdin, but stdin is a terminal');
-          bytes = readFileSync4(0);
+          bytes2 = readFileSync4(0);
         } else {
           try {
-            bytes = readFileSync4(fromPath);
+            bytes2 = readFileSync4(fromPath);
           } catch (err) {
             die(`cannot read ${fromPath}: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
         const contentType = plan.contentType ?? (fromPath === null ? "application/octet-stream" : sniffContentType(fromPath));
-        if (siteEntry("file", contentType) !== null) siteHtml = bytes.toString("utf8");
-        artifact = await api.uploadArtifactFile(issue.id, name2, bytes, {
+        if (siteEntry("file", contentType) !== null) siteHtml = bytes2.toString("utf8");
+        artifact = await api.uploadArtifactFile(issue.id, name2, bytes2, {
           filename: plan.filename ?? (fromPath === null ? name2 : basename(fromPath)),
           contentType
         });
@@ -6901,9 +7758,9 @@ files (v${artifact.current_version.version}):`);
             `refusing to write folder artifact into non-empty directory "${opts.out}"; choose a new or empty directory`
           );
         }
-        const files = version.files ?? [];
+        const files2 = version.files ?? [];
         let total = 0;
-        for (const file of files) {
+        for (const file of files2) {
           const content2 = await api.getArtifactContent(issue.id, name2, {
             version: opts.version,
             path: file.path
@@ -6914,26 +7771,26 @@ files (v${artifact.current_version.version}):`);
           total += content2.bytes.byteLength;
         }
         return console.log(
-          `wrote ${files.length} file${files.length === 1 ? "" : "s"} (${total} bytes) from "${name2}" v${version.version} into ${opts.out}/`
+          `wrote ${files2.length} file${files2.length === 1 ? "" : "s"} (${total} bytes) from "${name2}" v${version.version} into ${opts.out}/`
         );
       }
       const content = await api.getArtifactContent(issue.id, name2, { version: opts.version });
-      const bytes = Buffer.from(content.bytes);
+      const bytes2 = Buffer.from(content.bytes);
       if (opts.out !== void 0) {
         let target2 = opts.out;
         if (existsSync3(target2) && statSync2(target2).isDirectory()) {
           target2 = join2(target2, version.filename ?? name2);
         }
-        writeFileSync2(target2, bytes);
-        return console.log(`wrote ${target2} (${bytes.byteLength} bytes, ${content.content_type})`);
+        writeFileSync2(target2, bytes2);
+        return console.log(`wrote ${target2} (${bytes2.byteLength} bytes, ${content.content_type})`);
       }
       if ((content.content_type ?? "").startsWith("text/")) {
-        process.stdout.write(bytes);
+        process.stdout.write(bytes2);
         return;
       }
       const target = version.filename ?? name2;
-      writeFileSync2(target, bytes);
-      console.log(`wrote ${target} (${bytes.byteLength} bytes, ${content.content_type})`);
+      writeFileSync2(target, bytes2);
+      console.log(`wrote ${target} (${bytes2.byteLength} bytes, ${content.content_type})`);
     }
   );
   withCommon(
@@ -7016,14 +7873,14 @@ async function journalItemAt(api, scope) {
   );
   return items.find((i) => i.name === JOURNAL_NAME) ?? null;
 }
-function stateScope(issue, state, workflow) {
+function stateScope(issue, state, workflow2) {
   return {
     project_id: issue.project_id,
     project_name: issue.project_name,
     workflow_state_id: state.id,
     workflow_state_name: state.name,
-    workflow_id: workflow.id,
-    workflow_name: workflow.name,
+    workflow_id: workflow2.id,
+    workflow_name: workflow2.name,
     issue_id: null,
     issue_ref: null,
     label_id: null,
@@ -7032,11 +7889,11 @@ function stateScope(issue, state, workflow) {
     label: `project ${issue.project_name} \xB7 state ${state.name}`
   };
 }
-async function resolveJournal(api, ref, stateRef) {
+async function resolveJournal(api, ref, stateRef2) {
   const issue = await resolveIssue(api, ref);
-  if (stateRef !== void 0) {
-    const { workflow, state } = await resolveStateFlag(api, stateRef);
-    const scope = stateScope(issue, state, workflow);
+  if (stateRef2 !== void 0) {
+    const { workflow: workflow2, state } = await resolveStateFlag(api, stateRef2);
+    const scope = stateScope(issue, state, workflow2);
     return { issue, scope, note: null, item: await journalItemAt(api, scope) };
   }
   try {
@@ -7336,14 +8193,14 @@ function register6(program3) {
     for (const starter of response.items) {
       console.log(`${starter.id} \u2014 ${starter.name}`);
       console.log(`  ${starter.description}`);
-      for (const input of starter.inputs) {
+      for (const input2 of starter.inputs) {
         console.log(
-          `  --${inputFlag(input)}${input.required ? " (required)" : " (optional)"} \u2014 ${input.description ?? input.label}`
+          `  --${inputFlag(input2)}${input2.required ? " (required)" : " (optional)"} \u2014 ${input2.description ?? input2.label}`
         );
       }
-      for (const workflow of starter.creates.workflows) {
+      for (const workflow2 of starter.creates.workflows) {
         console.log(
-          `  workflow: ${workflow.name}${workflow.default ? " (default)" : ""} \u2014 ${workflow.states.join(" \u2192 ")}`
+          `  workflow: ${workflow2.name}${workflow2.default ? " (default)" : ""} \u2014 ${workflow2.states.join(" \u2192 ")}`
         );
       }
       for (const item of starter.creates.context) console.log(`  ${item.kind}: ${item.name}`);
@@ -7391,7 +8248,7 @@ function register6(program3) {
     )
   ).action(
     async (name2, opts) => {
-      const prompt = typeof opts.prompt === "string" ? readBodyValue(opts.prompt) : void 0;
+      const prompt2 = typeof opts.prompt === "string" ? readBodyValue(opts.prompt) : void 0;
       const suppliedInputs = [
         ["repo_url", "--repo", opts.repo],
         ["repo_branch", "--branch", opts.branch],
@@ -7413,7 +8270,7 @@ function register6(program3) {
             `unknown starter "${opts.starter}"; choose ${response.items.map((item) => item.id).join(", ")} (see \`tines projects starters\`)`
           );
         }
-        const declared = new Map(starter.inputs.map((input) => [input.key, input]));
+        const declared = new Map(starter.inputs.map((input2) => [input2.key, input2]));
         for (const [key, flag, value] of suppliedInputs) {
           if (value !== void 0 && !declared.has(key))
             die(`${flag} is not used by starter "${starter.id}"`);
@@ -7422,14 +8279,14 @@ function register6(program3) {
         for (const [key, , value] of suppliedInputs) {
           if (value !== void 0 && declared.has(key)) inputs[key] = value.trim();
         }
-        for (const input of starter.inputs) {
-          const value = inputs[input.key] ?? "";
-          if (input.required && !value)
-            die(`starter "${starter.id}" requires --${inputFlag(input)}`);
-          const max = input.max ?? 1e4;
-          if (value.length > max) die(`--${inputFlag(input)} is longer than ${max} characters`);
+        for (const input2 of starter.inputs) {
+          const value = inputs[input2.key] ?? "";
+          if (input2.required && !value)
+            die(`starter "${starter.id}" requires --${inputFlag(input2)}`);
+          const max = input2.max ?? 1e4;
+          if (value.length > max) die(`--${inputFlag(input2)} is longer than ${max} characters`);
         }
-        if (starter.creates.workflows.some((workflow) => workflow.default) && opts.defaultWorkflow) {
+        if (starter.creates.workflows.some((workflow2) => workflow2.default) && opts.defaultWorkflow) {
           die(`starter "${starter.id}" sets the default workflow; do not pass --default-workflow`);
         }
         starterRequest = { id: starter.id, inputs };
@@ -7444,7 +8301,7 @@ function register6(program3) {
         name: name2,
         description: opts.description,
         default_workflow_id: workflowId,
-        ...typeof opts.prompt === "string" ? { initial_prompt: prompt } : opts.prompt === false ? { initial_prompt: "" } : {},
+        ...typeof opts.prompt === "string" ? { initial_prompt: prompt2 } : opts.prompt === false ? { initial_prompt: "" } : {},
         ...starterRequest ? { starter: starterRequest } : {}
       };
       const project = await api.createProject(body);
@@ -7453,9 +8310,9 @@ function register6(program3) {
         `created project "${project.name}" (${project.id})${typeof opts.prompt === "string" ? ' with its "conventions" prompt' : ""}`
       );
       if (project.starter) {
-        for (const workflow of project.starter.workflows) {
+        for (const workflow2 of project.starter.workflows) {
           console.log(
-            `workflow: ${workflow.name} (${workflow.id})${workflow.reused ? " \u2014 reused" : ""}`
+            `workflow: ${workflow2.name} (${workflow2.id})${workflow2.reused ? " \u2014 reused" : ""}`
           );
         }
         for (const item of project.starter.context)
@@ -7540,10 +8397,10 @@ default workflow: ${defaultWorkflow}`);
     console.log(`deleted project "${project.name}" (${project.id})`);
   });
 }
-function inputFlag(input) {
-  if (input.key === "repo_url") return "repo";
-  if (input.key === "repo_branch") return "branch";
-  return input.key.replaceAll("_", "-");
+function inputFlag(input2) {
+  if (input2.key === "repo_url") return "repo";
+  if (input2.key === "repo_branch") return "branch";
+  return input2.key.replaceAll("_", "-");
 }
 function isBlank(starter) {
   return starter.creates.workflows.length === 0 && starter.creates.context.length === 0 && starter.creates.first_issue === null;
@@ -7703,25 +8560,25 @@ function renderStreamEvent(event) {
       }
       return [];
     case "assistant": {
-      const lines = [];
+      const lines2 = [];
       for (const block of event.message?.content ?? []) {
         if (block.type === "text" && block.text?.trim()) {
-          lines.push(`[agent] ${clip(block.text.trim(), 2e3)}`);
+          lines2.push(`[agent] ${clip(block.text.trim(), 2e3)}`);
         } else if (block.type === "tool_use") {
           const args = block.input === void 0 ? "" : JSON.stringify(block.input);
-          lines.push(`[tool] ${block.name ?? "tool"} ${clip(args, 300)}`.trimEnd());
+          lines2.push(`[tool] ${block.name ?? "tool"} ${clip(args, 300)}`.trimEnd());
         }
       }
-      return lines;
+      return lines2;
     }
     case "user": {
-      const lines = [];
+      const lines2 = [];
       for (const block of event.message?.content ?? []) {
         if (block.type === "tool_result" && block.is_error) {
-          lines.push(`[tool] error: ${clip(resultText(block.content), 300)}`);
+          lines2.push(`[tool] error: ${clip(resultText(block.content), 300)}`);
         }
       }
-      return lines;
+      return lines2;
     }
     case "result": {
       const parts = [];
@@ -7729,9 +8586,9 @@ function renderStreamEvent(event) {
       if (typeof event.total_cost_usd === "number")
         parts.push(`$${event.total_cost_usd.toFixed(2)}`);
       const detail = parts.length > 0 ? ` (${parts.join(", ")})` : "";
-      const lines = [`[session] result: ${event.subtype ?? "done"}${detail}`];
-      if (event.is_error && event.result) lines.push(`[error] ${clip(event.result, 2e3)}`);
-      return lines;
+      const lines2 = [`[session] result: ${event.subtype ?? "done"}${detail}`];
+      if (event.is_error && event.result) lines2.push(`[error] ${clip(event.result, 2e3)}`);
+      return lines2;
     }
     case "rate_limit_event": {
       const info = event.rate_limit_info;
@@ -7975,16 +8832,16 @@ var CodexStreamRenderer = class {
     ).length : 0;
     const complete = supplied === 4 && Object.keys(rawUsage).length === 4 && rawCached + rawWrite <= totalInput;
     const previousInput = previous ? metric(previous.input_tokens) !== void 0 && metric(previous.cached_input_tokens) !== void 0 && metric(previous.cache_write_input_tokens) !== void 0 ? previous.input_tokens - previous.cached_input_tokens - previous.cache_write_input_tokens : void 0 : void 0;
-    const input = complete ? totalInput - rawCached - rawWrite : void 0;
+    const input2 = complete ? totalInput - rawCached - rawWrite : void 0;
     let status = complete ? "complete" : supplied < 4 ? "missing" : "invalid";
     if (complete && previous && ["input_tokens", "cached_input_tokens", "cache_write_input_tokens", "output_tokens"].some(
       (key) => rawUsage[key] < previous[key]
-    ) || input !== void 0 && previousInput !== void 0 && input < previousInput) {
+    ) || input2 !== void 0 && previousInput !== void 0 && input2 < previousInput) {
       this.stickyStatus = "nonmonotonic";
     }
     status = this.stickyStatus ?? status;
     const usage = {};
-    if (complete) usage.input_tokens = input;
+    if (complete) usage.input_tokens = input2;
     if (rawCached !== void 0) usage.cache_read_tokens = rawCached;
     if (rawWrite !== void 0) usage.cache_write_tokens = rawWrite;
     if (output !== void 0) usage.output_tokens = output;
@@ -8211,17 +9068,17 @@ function keepWorkspace(mode, outcome) {
 function shellQuote(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
-function expandCommandTemplate(template, input) {
-  return template.replaceAll("{prompt_file}", shellQuote(input.promptFile)).replaceAll("{workspace}", shellQuote(input.workspace)).replaceAll("{model}", input.model ? shellQuote(input.model) : "''");
+function expandCommandTemplate(template, input2) {
+  return template.replaceAll("{prompt_file}", shellQuote(input2.promptFile)).replaceAll("{workspace}", shellQuote(input2.workspace)).replaceAll("{model}", input2.model ? shellQuote(input2.model) : "''");
 }
-function buildHarnessInvocation(spec, input) {
+function buildHarnessInvocation(spec, input2) {
   switch (spec.harness) {
     case "claude_code":
       return {
         file: "sh",
         args: [
           "-c",
-          `claude -p${input.resumeSessionId ? ` --resume ${shellQuote(input.resumeSessionId)}` : ""} --output-format stream-json --verbose${input.model ? ` --model ${shellQuote(input.model)}` : ""} < ${shellQuote(input.promptFile)}`
+          `claude -p${input2.resumeSessionId ? ` --resume ${shellQuote(input2.resumeSessionId)}` : ""} --output-format stream-json --verbose${input2.model ? ` --model ${shellQuote(input2.model)}` : ""} < ${shellQuote(input2.promptFile)}`
         ]
       };
     case "codex":
@@ -8231,13 +9088,13 @@ function buildHarnessInvocation(spec, input) {
           "exec",
           "--json",
           "--skip-git-repo-check",
-          ...input.model ? ["--model", input.model] : [],
-          input.prompt
+          ...input2.model ? ["--model", input2.model] : [],
+          input2.prompt
         ]
       };
     case "custom": {
       if (!spec.command) throw new Error("the custom harness needs a --command template");
-      return { file: "sh", args: ["-c", expandCommandTemplate(spec.command, input)] };
+      return { file: "sh", args: ["-c", expandCommandTemplate(spec.command, input2)] };
     }
   }
 }
@@ -8253,16 +9110,16 @@ function formatLaunchCommand(invocation) {
     return invocation.args[1];
   return [invocation.file, ...invocation.args].map(launchWord).join(" ");
 }
-function formatLaunchBanner(invocation, input, meta) {
+function formatLaunchBanner(invocation, input2, meta) {
   const fields = [
     `harness=${meta.harness}`,
-    `model=${input.model ?? "(fixed)"}`,
+    `model=${input2.model ?? "(fixed)"}`,
     `timeout=${meta.timeoutMinutes}m`,
     `cli=${meta.cliVersion}`,
-    `workspace=${input.workspace}`,
+    `workspace=${input2.workspace}`,
     // The one line that says a send-back reused a session rather than
     // re-exploring the repository from zero.
-    ...input.resumeSessionId ? [`resumed=${meta.resumedFromRunId ?? input.resumeSessionId}`] : []
+    ...input2.resumeSessionId ? [`resumed=${meta.resumedFromRunId ?? input2.resumeSessionId}`] : []
   ];
   return `$ ${formatLaunchCommand(invocation)}
 # tines runner: ${fields.join(" ")}
@@ -8445,9 +9302,9 @@ var LogBatcher = class {
     let lost = 0;
     while (this.pending.length > 1 && held > cap) {
       const dropped = this.pending.shift();
-      const bytes = Buffer.byteLength(dropped.chunk, "utf8");
-      held -= bytes;
-      lost += bytes;
+      const bytes2 = Buffer.byteLength(dropped.chunk, "utf8");
+      held -= bytes2;
+      lost += bytes2;
     }
     const head = this.pending[0];
     head.chunk = `[log] ${lost} bytes lost (supervisor unreachable)
@@ -8602,8 +9459,8 @@ async function installAgentCli(opts) {
   return { binDir: binDirOf(prefix), version, source: "fresh" };
 }
 function tail(output) {
-  const lines = output.trim().split("\n").filter(Boolean).slice(-3);
-  return lines.length > 0 ? `: ${lines.join(" / ")}` : "";
+  const lines2 = output.trim().split("\n").filter(Boolean).slice(-3);
+  return lines2.length > 0 ? `: ${lines2.join(" / ")}` : "";
 }
 function message(err) {
   return err instanceof Error ? err.message : String(err);
@@ -10269,7 +11126,352 @@ function register10(program3) {
 }
 
 // src/commands/workflows.ts
+import { readFileSync as readFileSync11 } from "node:fs";
+
+// src/workflow-packages.ts
+import { createInterface as createInterface4 } from "node:readline/promises";
+import { createHash } from "node:crypto";
 import { readFileSync as readFileSync10 } from "node:fs";
+var PACKAGE_STDIN = "-";
+var MAX_LOCAL_JSON_BYTES = 32 * 1024 * 1024;
+function readPackageSource(path2) {
+  try {
+    const bytes2 = readFileSync10(path2 === PACKAGE_STDIN ? 0 : path2);
+    if (bytes2.byteLength > MAX_LOCAL_JSON_BYTES)
+      throw new Error(`input exceeds ${MAX_LOCAL_JSON_BYTES} bytes`);
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes2);
+  } catch (error) {
+    throw new Error(
+      `cannot read ${path2 === PACKAGE_STDIN ? "stdin" : path2}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function readStrictObject(path2, label) {
+  const value = parseStrictLibraryJson(readPackageSource(path2));
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must contain a JSON object`);
+  }
+  return value;
+}
+function normalizeApiBase(value) {
+  return new URL(value).toString().replace(/\/$/, "");
+}
+function saveWorkflowPackagePlan(path2, apiBase, plan) {
+  const saved = {
+    format: "tines.workflow-install-plan",
+    version: 1,
+    api_base: normalizeApiBase(apiBase),
+    document_digest: plan.document_digest,
+    plan
+  };
+  writeJsonFile(path2, saved, { secret: true });
+  return saved;
+}
+function readWorkflowPackagePlan(path2) {
+  const saved = readStrictObject(path2, "plan file");
+  const outerKeys = ["format", "version", "api_base", "document_digest", "plan"];
+  const planKeys = [
+    "operations",
+    "document",
+    "resolved",
+    "allocation",
+    "plan_id",
+    "plan_digest",
+    "document_digest",
+    "issued_at",
+    "expires_at",
+    "actor_key",
+    "compiler_version",
+    "plan_token",
+    "budget"
+  ];
+  if (Object.keys(saved).length !== outerKeys.length || !Object.keys(saved).every((key) => outerKeys.includes(key)) || saved.format !== "tines.workflow-install-plan" || saved.version !== 1 || typeof saved.api_base !== "string" || typeof saved.document_digest !== "string" || !saved.plan || typeof saved.plan !== "object" || typeof saved.plan.plan_token !== "string" || typeof saved.plan.plan_digest !== "string" || Object.keys(saved.plan).length !== planKeys.length || !Object.keys(saved.plan).every((key) => planKeys.includes(key))) {
+    throw new Error("invalid workflow package plan file");
+  }
+  const result = saved;
+  assertPlanBinding(result.plan);
+  return result;
+}
+function tokenPayload(token) {
+  const parts = token.split(".");
+  if (token.length > 7e5 || parts.length !== 3 || parts[0] !== "wip1" || !parts.slice(1).every((part) => /^[A-Za-z0-9_-]+$/.test(part)))
+    throw new Error("invalid workflow package plan token");
+  try {
+    const bytes2 = Buffer.from(parts[1], "base64url");
+    if (bytes2.toString("base64url") !== parts[1]) throw new Error();
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes2));
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+    return value;
+  } catch {
+    throw new Error("invalid workflow package plan token");
+  }
+}
+function expectedWorkflowPackageOperations(plan) {
+  const operations = [];
+  for (const workflow2 of plan.resolved.workflows) {
+    const workflowId = plan.allocation.records[workflow2.id]?.id;
+    const href = `/workflows/${workflowId}`;
+    operations.push({
+      action: "create",
+      kind: "workflow",
+      local_id: workflow2.id,
+      id: workflowId,
+      name: workflow2.name,
+      href,
+      relationship: workflow2.id === plan.document.main_workflow_id ? "main" : "dependency"
+    });
+    for (const state of workflow2.states)
+      operations.push({
+        action: "create",
+        kind: "state",
+        local_id: state.id,
+        id: plan.allocation.records[state.id]?.id,
+        name: state.name,
+        href: `${href}#state-${plan.allocation.records[state.id]?.id}`
+      });
+    for (const transition of workflow2.transitions)
+      operations.push({
+        action: "create",
+        kind: "transition",
+        local_id: transition.id,
+        id: plan.allocation.records[transition.id]?.id,
+        name: transition.name,
+        href
+      });
+  }
+  for (const item of plan.resolved.context) {
+    const workflow2 = plan.resolved.workflows.find(
+      (candidate) => candidate.states.some((state) => state.id === item.state_id)
+    );
+    const href = `/context?workflow=${plan.allocation.records[workflow2?.id ?? ""]?.id}&q=${encodeURIComponent(item.name)}`;
+    operations.push({
+      action: "create",
+      kind: item.kind,
+      local_id: item.id,
+      id: plan.allocation.records[item.id]?.id,
+      name: item.name,
+      href
+    });
+    if (item.kind === "skill")
+      for (const file of item.files)
+        operations.push({
+          action: "create",
+          kind: "file",
+          local_id: file.id,
+          id: plan.allocation.records[file.id]?.id,
+          name: file.path,
+          href
+        });
+  }
+  for (const input2 of plan.resolved.inputs) {
+    if (input2.mode === "create")
+      operations.push({
+        action: "create",
+        kind: "label",
+        local_id: input2.input_id,
+        id: input2.id,
+        name: input2.value,
+        href: "/labels"
+      });
+    if (input2.mode === "reuse")
+      operations.push({
+        action: "reuse",
+        kind: input2.type,
+        local_id: input2.input_id,
+        id: input2.id,
+        name: input2.value,
+        href: input2.type === "workflow" ? `/workflows/${input2.id}` : input2.type === "project" ? `/projects/${input2.id}` : "/labels"
+      });
+  }
+  for (const skip of plan.resolved.skipped)
+    operations.push({
+      action: "skip",
+      kind: skip.kind,
+      local_id: skip.local_id,
+      id: null,
+      name: skip.kind === "schedule" ? plan.document.schedules.find((item) => item.id === skip.local_id)?.name : plan.document.routing.find((item) => item.id === skip.local_id)?.tier,
+      href: null
+    });
+  return operations;
+}
+function assertPlanBinding(plan) {
+  const payload = tokenPayload(plan.plan_token);
+  const { plan_digest: signedDigest, ...unsigned } = payload;
+  const digest = `sha256:${createHash("sha256").update(canonicalizeLibraryValue({ plan: unsigned, resolved: plan.resolved })).digest("hex")}`;
+  const mirrors = {
+    id: plan.plan_id,
+    plan_digest: plan.plan_digest,
+    document_digest: plan.document_digest,
+    issued_at: plan.issued_at,
+    expires_at: plan.expires_at,
+    actor_key: plan.actor_key,
+    compiler_version: plan.compiler_version,
+    allocation: plan.allocation,
+    budget: plan.budget
+  };
+  for (const [field, value] of Object.entries(mirrors)) {
+    const signedField = field === "id" ? "id" : field;
+    if (canonicalizeLibraryValue(payload[signedField]) !== canonicalizeLibraryValue(value))
+      throw new Error(`saved workflow package plan has modified ${field}`);
+  }
+  if (signedDigest !== digest || plan.plan_digest !== digest)
+    throw new Error("saved workflow package plan digest does not bind its review");
+  if (canonicalizeLibraryValue(plan.operations) !== canonicalizeLibraryValue(expectedWorkflowPackageOperations(plan)))
+    throw new Error("saved workflow package plan has modified operations");
+}
+var lines = (heading, values) => values.length ? [heading, ...values.map((value) => `  ${value}`)] : [heading, "  none"];
+function formatWorkflowPackageReview(plan) {
+  const { document, resolved } = plan;
+  const output = [
+    `Workflow package plan ${plan.plan_digest}`,
+    `  file: ${plan.document_digest}`,
+    `  valid until: ${new Date(plan.expires_at).toISOString()}`,
+    `  budget: ${plan.budget.statements} statements, ${plan.budget.max_parameters} parameters, ${plan.budget.max_sql_bytes} SQL bytes, ${plan.budget.max_value_bytes} value bytes`,
+    "",
+    ...lines(
+      "Operations:",
+      plan.operations.map(
+        (operation) => `${operation.action} ${operation.kind} ${operation.local_id}: ${operation.name}${operation.relationship ? ` (${operation.relationship})` : ""}${operation.id ? ` [${operation.id}]` : ""}`
+      )
+    ),
+    "",
+    ...lines(
+      "Workflows and gates:",
+      document.workflows.flatMap((workflow2) => [
+        `${workflow2.id}: ${resolved.names[workflow2.id] ?? workflow2.name} \u2014 ${workflow2.description}`,
+        ...workflow2.states.map(
+          (state) => `  state ${state.id}: ${state.name} (${state.category})${state.inherits_from ? ` inherits ${state.inherits_from.state_id}` : ""}`
+        ),
+        ...workflow2.transitions.map(
+          (transition) => `  transition ${transition.id}: ${transition.name} ${transition.from_state_id} -> ${transition.to_state_id}; gates ${transition.requires.length ? transition.requires.map((gate) => `${gate.artifact}${gate.type ? `:${gate.type}` : ""}${gate.content_type ? `:${gate.content_type}` : ""}`).join(", ") : "none"}`
+        )
+      ])
+    ),
+    "",
+    ...lines(
+      "Inputs:",
+      document.inputs.map((declaration) => {
+        const input2 = resolved.inputs.find((candidate) => candidate.input_id === declaration.id);
+        return `${declaration.id} ${declaration.key}: ${declaration.label} \u2014 ${declaration.description}
+    type: ${declaration.type}; required: ${declaration.required ? "yes" : "no"}; default: ${declaration.default ?? "none"}; required states: ${declaration.required_states?.join(", ") || "none"}
+    resolution: ${input2?.mode ?? "missing"}; value: ${input2?.value ?? "missing"}${input2?.id ? ` [${input2.id}]` : ""}`;
+      })
+    ),
+    "",
+    ...lines(
+      "Original and rendered text:",
+      resolved.patches.map(
+        (patch) => `${patch.record_id}.${patch.field}
+    original: ${patch.original}
+    rendered: ${patch.rendered}
+    uses: ${patch.uses.length ? patch.uses.map((use) => `${use.id} -> ${use.input_id} (${use.count} occurrence${use.count === 1 ? "" : "s"})`).join(", ") : "none"}`
+      )
+    ),
+    "",
+    ...lines(
+      "Context:",
+      document.context.flatMap((item) => {
+        const header = `${item.kind} ${item.id} in ${item.state_id}: ${item.name} \u2014 ${item.description}`;
+        if (item.kind === "prompt") return [header, `  body: ${item.body}`];
+        if (item.kind === "repo")
+          return [
+            header,
+            `  repository: ${item.repo_url}; branch ${item.repo_branch ?? "default"}; directory ${item.repo_dir ?? "default"}`
+          ];
+        return [
+          header,
+          ...item.files.map((file) => `  file ${file.id} ${file.path}:
+${file.content}`)
+        ];
+      })
+    ),
+    "",
+    ...lines(
+      "Schedules:",
+      resolved.schedules.map(
+        (schedule2) => `${schedule2.local_id}: ${resolved.names[schedule2.local_id] ?? schedule2.definition.name}; project ${schedule2.project_id}; ${JSON.stringify(schedule2.definition)}`
+      )
+    ),
+    "",
+    ...lines(
+      "Routing capabilities:",
+      resolved.routing.flatMap((routing) => [
+        `${routing.local_id}: ${routing.tier}; winning rule ${routing.winning_rule_id}`,
+        ...routing.targets.map(
+          (target) => `  ${target.name} (${target.status}) ${target.model ?? "default model"} / ${target.config}; supported ${target.supported ? "yes" : "no"}`
+        ),
+        ...routing.warnings.map((warning) => `  warning: ${warning}`)
+      ])
+    ),
+    "",
+    ...lines(
+      "Skipped:",
+      resolved.skipped.map((item) => `${item.kind} ${item.local_id}`)
+    )
+  ];
+  return output.join("\n");
+}
+function formatValidation(result) {
+  const output = [result.valid ? "valid workflow package" : "invalid workflow package"];
+  if (result.digest) output.push(`digest: ${result.digest}`);
+  for (const diagnostic of result.diagnostics) {
+    output.push(`${diagnostic.path || "/"}: ${diagnostic.code}: ${diagnostic.message}`);
+  }
+  output.push(
+    `limits: ${result.limits.max_document_bytes} bytes, ${result.limits.max_records} records, depth ${result.limits.max_depth}`
+  );
+  return output.join("\n");
+}
+async function localDocument(path2) {
+  const raw = readPackageSource(path2);
+  const document = await parseLibraryV3Document(raw);
+  if (document.profile !== "workflow") throw new Error("expected a workflow-profile package");
+  return { raw, document };
+}
+function canonicalWorkflowPackage(document) {
+  return canonicalizeLibraryValue(document);
+}
+async function askToInstall(plan) {
+  const rl = createInterface4({ input: process.stdin, output: process.stderr });
+  try {
+    process.stderr.write(`${formatWorkflowPackageReview(plan)}
+`);
+    const answer = await rl.question(`Install exactly plan ${plan.plan_digest}? [y/N] `).catch(() => "");
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function recoverOrInstall(api, raw, plan) {
+  const checked = (receipt) => {
+    if (receipt.id !== plan.plan_id || receipt.document_digest !== plan.document_digest || receipt.plan_digest !== plan.plan_digest)
+      throw new Error("recovered workflow package receipt does not match the saved plan");
+    return receipt;
+  };
+  try {
+    return checked(await api.getWorkflowPackageReceipt(plan.plan_id));
+  } catch (error) {
+    if (!(error instanceof ApiError) || error.status !== 404) throw error;
+  }
+  const request = {
+    document_json: raw,
+    plan_token: plan.plan_token,
+    confirmation: { plan_digest: plan.plan_digest }
+  };
+  try {
+    return checked(await api.installWorkflowPackage(request));
+  } catch (first) {
+    if (!(first instanceof ApiNetworkError)) throw first;
+    try {
+      return checked(await api.getWorkflowPackageReceipt(plan.plan_id));
+    } catch (recovery) {
+      if (!(recovery instanceof ApiError) || recovery.status !== 404) throw first;
+    }
+    return checked(await api.installWorkflowPackage(request));
+  }
+}
+
+// src/commands/workflows.ts
 function readJsonBody(inline, file) {
   if (inline !== void 0 && file !== void 0) {
     die("pass the JSON inline or with --file, not both");
@@ -10278,14 +11480,14 @@ function readJsonBody(inline, file) {
   if (file !== void 0 && file !== "-") {
     let raw;
     try {
-      raw = readFileSync10(file, "utf8");
+      raw = readFileSync11(file, "utf8");
     } catch (err) {
       die(`cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
     }
     return parseJsonObject(raw, file);
   }
   if (file === "-" || !process.stdin.isTTY) {
-    const raw = readFileSync10(0, "utf8");
+    const raw = readFileSync11(0, "utf8");
     if (raw.trim() === "") {
       if (file === "-") die("no JSON on stdin");
       return void 0;
@@ -10351,8 +11553,8 @@ name issues must carry (see: tines issues artifacts --help).
 async function loadLibrary(api) {
   const workflows = await listAll((page) => api.listWorkflows(page));
   const states = /* @__PURE__ */ new Map();
-  for (const workflow of workflows) {
-    for (const state of workflow.states) states.set(state.id, { workflow, state });
+  for (const workflow2 of workflows) {
+    for (const state of workflow2.states) states.set(state.id, { workflow: workflow2, state });
   }
   const children = /* @__PURE__ */ new Map();
   for (const entry of states.values()) {
@@ -10370,13 +11572,13 @@ function stateLabel(lib, id2) {
   return entry ? qualify(entry) : id2;
 }
 function inheritanceLines(lib, state) {
-  const lines = [];
+  const lines2 = [];
   if (state.inherits_from !== null) {
-    lines.push(`    inherits from: ${stateLabel(lib, state.inherits_from)}`);
+    lines2.push(`    inherits from: ${stateLabel(lib, state.inherits_from)}`);
   }
   const kids = lib.children.get(state.id) ?? [];
-  if (kids.length > 0) lines.push(`    inherited by: ${kids.map(qualify).join(", ")}`);
-  return lines;
+  if (kids.length > 0) lines2.push(`    inherited by: ${kids.map(qualify).join(", ")}`);
+  return lines2;
 }
 async function resolveStateBases(states, library) {
   if (!Array.isArray(states)) return;
@@ -10396,24 +11598,24 @@ async function resolveStateBases(states, library) {
 function resolveBasePair(lib, pair, stateName) {
   const sep2 = pair.indexOf("/");
   const workflowRef = pair.slice(0, sep2).trim();
-  const stateRef = pair.slice(sep2 + 1).trim();
+  const stateRef2 = pair.slice(sep2 + 1).trim();
   const where = `state "${stateName}" inherits from "${pair}"`;
-  if (!workflowRef || !stateRef) {
+  if (!workflowRef || !stateRef2) {
     die(`${where}, which is not a <workflow>/<state> pair`);
   }
   const byName = lib.workflows.filter((w) => w.name === workflowRef);
   if (byName.length > 1)
     die(`${where}, but workflow name "${workflowRef}" is ambiguous; use an id`);
-  const workflow = lib.workflows.find((w) => w.id === workflowRef) ?? byName[0];
-  if (!workflow) {
+  const workflow2 = lib.workflows.find((w) => w.id === workflowRef) ?? byName[0];
+  if (!workflow2) {
     die(
       `${where}, but there is no workflow "${workflowRef}" (have: ${lib.workflows.map((w) => w.name).join(", ")})`
     );
   }
-  const state = workflow.states.find((s) => s.name === stateRef) ?? workflow.states.find((s) => s.id === stateRef);
+  const state = workflow2.states.find((s) => s.name === stateRef2) ?? workflow2.states.find((s) => s.id === stateRef2);
   if (!state) {
     die(
-      `${where}, but workflow "${workflow.name}" has no state "${stateRef}" (have: ${workflow.states.map((s) => s.name).join(", ")})`
+      `${where}, but workflow "${workflow2.name}" has no state "${stateRef2}" (have: ${workflow2.states.map((s) => s.name).join(", ")})`
     );
   }
   return state.id;
@@ -10451,6 +11653,7 @@ warning: ${w}`);
 }
 function register11(program3) {
   const workflows = program3.command("workflows").description("Manage the workflow library");
+  registerPackageCommands(workflows);
   withList(workflows.command("list").description("List the workflow library")).action(
     async (opts) => {
       const api = client(opts);
@@ -10561,6 +11764,147 @@ see \`tines workflows create --help\` for the expected shape`
     console.log(`deleted workflow "${wf.name}" (${wf.id})`);
   });
 }
+var collect2 = (value, previous) => [...previous, value];
+async function resolveExportState(api, ref) {
+  const all = await listAll((page) => api.listWorkflows(page));
+  const exact = all.flatMap((workflow2) => workflow2.states).find((state) => state.id === ref);
+  if (exact) return exact.id;
+  if (ref.includes("/")) {
+    const separator = ref.indexOf("/");
+    const workflow2 = pickWorkflow(all, ref.slice(0, separator).trim());
+    const states = workflow2.states.filter(
+      (state) => state.name === ref.slice(separator + 1).trim()
+    );
+    if (states.length === 1) return states[0].id;
+  }
+  const named = all.flatMap((workflow2) => workflow2.states).filter((state) => state.name === ref);
+  if (named.length === 1) return named[0].id;
+  if (named.length > 1) die(`state name "${ref}" is ambiguous; use an id`);
+  die(`no state named "${ref}"; use a state id or <workflow>/<state>`);
+}
+function registerPackageCommands(workflows) {
+  withCommon(
+    workflows.command("export <workflow-id-or-unambiguous-name>").description("Export a canonical workflow package JSON document").option("--project <id-or-name>", "source project for selected project-bound configuration").option("--schedule <id>", "include this source schedule ID (repeatable)", collect2, []).option(
+      "--tier <state-ref=tier>",
+      "include a state tier preference (repeatable)",
+      collect2,
+      []
+    ).option("--project-routing", "make every --tier selector project scoped").option("--inputs <file>", "JSON object containing input declarations and text uses")
+  ).action(
+    async (ref, opts) => {
+      const api = client(opts);
+      const all = await listAll((page) => api.listWorkflows(page));
+      const workflow2 = pickWorkflow(all, ref);
+      const sourceProject = opts.project ? await resolveProject(api, opts.project) : void 0;
+      if ((opts.schedule.length || opts.projectRouting) && !sourceProject)
+        die("--project is required with --schedule or --project-routing");
+      const tiers = [];
+      for (const selector of opts.tier) {
+        const separator = selector.lastIndexOf("=");
+        if (separator < 1) die(`invalid --tier "${selector}"; expected <state-ref>=<tier>`);
+        const tier = selector.slice(separator + 1);
+        if (!["smartest", "balanced", "cheapest"].includes(tier))
+          die(`invalid tier "${tier}"; expected smartest, balanced, or cheapest`);
+        tiers.push({
+          state_id: await resolveExportState(api, selector.slice(0, separator)),
+          tier,
+          project_scoped: Boolean(opts.projectRouting)
+        });
+      }
+      const authoring = opts.inputs ? readStrictObject(opts.inputs, "inputs file") : void 0;
+      const document = await api.exportWorkflowPackage(workflow2.id, {
+        source_project_id: sourceProject?.id,
+        schedule_ids: opts.schedule,
+        tiers,
+        authoring
+      });
+      process.stdout.write(`${canonicalWorkflowPackage(document)}
+`);
+    }
+  );
+  withCommon(
+    workflows.command("validate <file>").description("Validate a workflow package file (use - for stdin)")
+  ).action(async (path2, opts) => {
+    const result = await client(opts).validateLibrary({ document_json: readPackageSource(path2) });
+    if (opts.json) printJson(result);
+    else console.log(formatValidation(result));
+    if (!result.valid) process.exitCode = 1;
+  });
+  withCommon(
+    workflows.command("preview <file>").description("Prepare and fully review a destination workflow package plan").option("--choices <file>", "destination choices JSON file").option("--plan-out <file>", "atomically save the signed plan for a later install")
+  ).action(async (path2, opts) => {
+    const raw = readPackageSource(path2);
+    const choices = opts.choices ? readStrictObject(opts.choices, "choices file") : void 0;
+    const plan = await client(opts).prepareWorkflowPackage({ document_json: raw, choices });
+    if (opts.planOut) saveWorkflowPackagePlan(opts.planOut, resolveUrl(opts), plan);
+    if (opts.json) printJson(plan);
+    else console.log(formatWorkflowPackageReview(plan));
+  });
+  withCommon(
+    workflows.command("install <file>").description("Install one exactly reviewed workflow package plan").option("--choices <file>", "destination choices JSON file (interactive preparation only)").option("--plan <file>", "signed plan saved by workflows preview").option("--confirm <plan-digest>", "exact reviewed plan digest (required outside a TTY)")
+  ).action(
+    async (path2, opts) => {
+      if (path2 === "-" && process.stdin.isTTY)
+        die('"-" reads the package from stdin, but stdin is a terminal');
+      if (!opts.plan && !process.stdin.isTTY)
+        die(
+          "non-interactive install requires a separate prior preview with --plan-out, then --plan and --confirm"
+        );
+      if (opts.plan && opts.choices)
+        die("--choices cannot be used with --plan; the saved choices are authoritative");
+      if (path2 === "-" && !opts.plan)
+        die(
+          "stdin package input cannot also provide interactive confirmation; use preview --plan-out first"
+        );
+      const { raw, document } = await localDocument(path2);
+      const apiBase = normalizeUrl(resolveUrl(opts));
+      const api = client(opts);
+      let plan;
+      let planPath = opts.plan;
+      if (planPath) {
+        const saved = readWorkflowPackagePlan(planPath);
+        if (normalizeUrl(saved.api_base) !== apiBase)
+          die(`plan belongs to ${saved.api_base}, not ${apiBase}`);
+        if (saved.document_digest !== document.digest || saved.plan.document_digest !== document.digest || canonicalWorkflowPackage(saved.plan.document) !== canonicalWorkflowPackage(document))
+          die(
+            `package digest ${document.digest} does not match saved plan ${saved.document_digest}`
+          );
+        plan = saved.plan;
+      } else {
+        const choices = opts.choices ? readStrictObject(opts.choices, "choices file") : void 0;
+        plan = await api.prepareWorkflowPackage({ document_json: raw, choices });
+        planPath = `${path2}.plan.json`;
+        saveWorkflowPackagePlan(planPath, apiBase, plan);
+        console.error(`saved retryable signed plan to ${planPath}`);
+      }
+      if (opts.confirm !== void 0 && opts.confirm !== plan.plan_digest)
+        die(`confirmation digest does not match reviewed plan ${plan.plan_digest}`);
+      if (!process.stdin.isTTY && opts.confirm !== plan.plan_digest)
+        die(`non-interactive install requires --confirm ${plan.plan_digest}`);
+      if (process.stdin.isTTY && opts.confirm === void 0) {
+        if (!await askToInstall(plan)) die("installation declined");
+      } else {
+        process.stderr.write(`${formatWorkflowPackageReview(plan)}
+`);
+      }
+      const receipt = await recoverOrInstall(api, raw, plan);
+      if (opts.json) printJson(receipt);
+      else {
+        console.log(`installed workflow package (${receipt.id})`);
+        console.log(`plan: ${receipt.plan_digest}`);
+        for (const object3 of receipt.objects)
+          console.log(`  ${object3.kind}: ${object3.name} \u2014 ${object3.href}`);
+      }
+    }
+  );
+}
+function normalizeUrl(value) {
+  try {
+    return new URL(value).toString().replace(/\/$/, "");
+  } catch {
+    die(`invalid API base URL: ${value}`);
+  }
+}
 
 // src/commands/usage.ts
 var money = (value) => usageCostLabel(value);
@@ -10647,14 +11991,14 @@ function register12(program3) {
     if (opts.state && !opts.workflow) throw new Error("--state requires --workflow");
     const api = client(opts);
     const project = opts.project && opts.project !== "unknown" ? (await resolveProject(api, opts.project)).id : opts.project;
-    const workflow = opts.workflow && opts.workflow !== "unknown" ? (await resolveWorkflow(api, opts.workflow)).id : opts.workflow;
+    const workflow2 = opts.workflow && opts.workflow !== "unknown" ? (await resolveWorkflow(api, opts.workflow)).id : opts.workflow;
     const runner = opts.runner && opts.runner !== "unknown" ? (await resolveRunner(api, opts.runner)).id : opts.runner;
     const report = await api.getUsage({
       window: opts.window,
       from: opts.from,
       to: opts.to,
       project,
-      workflow,
+      workflow: workflow2,
       state: opts.state,
       runner,
       tier: opts.tier,