tines 0.0.140 → 0.0.141

package/dist/index.js

@@ -3716,6 +3716,44 @@ function displayActor(ev) {
   return actorLabel(ev.actor);
 }
 
+// ../shared/src/requirements.ts
+function attachFlag(type, slot, contentType) {
+  switch (type) {
+    case "file":
+      return "--file <path>";
+    case "folder":
+      return "--folder <dir>";
+    case "link":
+      return "--link <url>";
+    case "pr":
+      return "--pr <owner/repo#N>";
+    case "text": {
+      const ext = contentType === "text/markdown" ? "md" : contentType === "text/plain" ? "txt" : null;
+      return ext ? `--text @${slot}.${ext}` : "--text <markdown|@file>";
+    }
+  }
+}
+function requirementFix(r, ref) {
+  const attach = (type) => `tines issues artifacts attach ${ref} ${r.artifact} ${attachFlag(type, r.artifact, r.content_type)}`;
+  if (r.status === "missing" || r.current_type === null) {
+    return { kind: "attach", command: attach(r.type ?? "file") };
+  }
+  if (r.status === "satisfied") {
+    return { kind: "attach", command: attach(r.current_type) };
+  }
+  if (r.status === "stale") {
+    return {
+      kind: "reattach_or_reaffirm",
+      command: `${attach(r.current_type)} \u2014 or, if the current content still stands: tines issues artifacts reaffirm ${ref} ${r.artifact}`
+    };
+  }
+  const reattachable = r.type === void 0 ? r.current_type === "file" || r.current_type === "text" : r.current_type === r.type;
+  return reattachable ? { kind: "attach", command: attach(r.current_type) } : {
+    kind: "delete_and_attach",
+    command: `tines issues artifacts delete ${ref} ${r.artifact} && ${attach(r.type ?? "file")}`
+  };
+}
+
 // ../shared/src/client.ts
 var ApiError = class extends Error {
   status;
@@ -4149,6 +4187,29 @@ function artifactSummary(a) {
       return `${prRefLabel(cv)} \u2014 ${cv.pr_repo_url}/pull/${cv.pr_number}`;
   }
 }
+function artifactTypeLabel(a) {
+  const ct = a.current_version.content_type;
+  return (a.artifact_type === "file" || a.artifact_type === "text") && ct ? `${a.artifact_type}, ${ct}` : a.artifact_type;
+}
+function requirementStatus(r) {
+  switch (r.status) {
+    case "satisfied":
+      return `satisfied (v${r.current_version?.version})`;
+    case "missing":
+      return "missing";
+    case "stale":
+      return `stale (v${r.current_version?.version}, attached before the current state)`;
+    case "type_mismatch":
+      return r.type !== void 0 && r.current_type !== null && r.current_type !== r.type ? `type mismatch (holds ${r.current_type})` : `type mismatch (v${r.current_version?.version} is not ${r.content_type ?? r.type})`;
+  }
+}
+function requirementLines(r) {
+  const spec = [r.type, r.content_type].filter(Boolean).join(", ");
+  return [
+    `requires artifact "${r.artifact}"${spec ? ` (${spec})` : ""}: ${requirementStatus(r)}${r.description ? ` \u2014 ${r.description}` : ""}`,
+    ...r.fix ? [`  fix: ${r.fix}`] : []
+  ];
+}
 function scheduleRef(s) {
   return `${s.project_name}/${s.name}`;
 }
@@ -4406,12 +4467,10 @@ allowed actions: ${actions.join(", ")}` : "\nallowed actions: none (terminal sta
     const unmet = err.details?.unmet;
     if (Array.isArray(unmet)) {
       for (const raw of unmet) {
-        const r = raw;
-        const spec = [r.type, r.content_type].filter(Boolean).join(", ");
-        message3 += `
-requires artifact "${r.artifact}"${spec ? ` (${spec})` : ""}: ${r.status ?? "unmet"}${r.description ? ` \u2014 ${r.description}` : ""}`;
-        if (r.fix) message3 += `
-  fix: ${r.fix}`;
+        for (const line of requirementLines(raw)) {
+          message3 += `
+${line}`;
+        }
       }
     }
     die(message3);
@@ -4748,9 +4807,334 @@ function register(program3) {
 }
 
 // src/commands/issues.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { basename, dirname as dirname2, join as join2 } from "node:path";
 
+// src/attach-source.ts
+import { existsSync as existsSync2, statSync } from "node:fs";
+var fsProbe = (path2) => {
+  if (!existsSync2(path2)) return "missing";
+  try {
+    return statSync(path2).isDirectory() ? "dir" : "file";
+  } catch {
+    return "missing";
+  }
+};
+var SOURCE_FLAGS = ["--file", "--folder", "--text", "--link", "--pr"];
+function gatesFor(issue, name2) {
+  const gates = [];
+  for (const t of issue.allowed_transitions) {
+    for (const check of t.requires ?? []) {
+      if (name2 === void 0 || check.artifact === name2) {
+        gates.push({ transition: t.name, check });
+      }
+    }
+  }
+  return gates;
+}
+function flagFor(type) {
+  return type === "file" ? "--file" : `--${type}`;
+}
+function sourceLabel(flags, positional) {
+  if (flags.file !== void 0) return "--file";
+  if (flags.folder !== void 0) return "--folder";
+  if (flags.text !== void 0) return "--text";
+  if (flags.link !== void 0) return "--link";
+  if (flags.pr !== void 0) return "--pr";
+  return positional !== void 0 ? "the positional source" : "the source";
+}
+function assertOneSource(flags, positional) {
+  const values = [flags.file, flags.folder, flags.text, flags.link, flags.pr];
+  const given = SOURCE_FLAGS.filter((_, i) => values[i] !== void 0);
+  const count = given.length + (positional !== void 0 ? 1 : 0);
+  if (count === 0) {
+    throw new CliError(
+      "pass exactly one content source: a positional <source> (a path, a URL, or owner/repo#N), --file <path>, --folder <dir>, --text <md|@file>, --link <url>, or --pr <spec> (a link goes in --link; --url is the API base URL)"
+    );
+  }
+  if (count > 1) {
+    const what = [
+      ...given,
+      ...positional !== void 0 ? [`the positional "${positional}"`] : []
+    ];
+    throw new CliError(`pass the source once: got ${what.join(" and ")}`);
+  }
+}
+function normalizePositional(raw) {
+  if (raw === "-" || raw === "@-") return { value: raw, stdin: true };
+  if (raw.startsWith("@@")) return { value: raw.slice(1), stdin: false };
+  if (raw.startsWith("@")) return { value: raw.slice(1), stdin: false };
+  return { value: raw, stdin: false };
+}
+var isUrl = (v) => /^https?:\/\//.test(v);
+function concreteContentType(ct) {
+  return ct !== void 0 && ct.includes("/") && !ct.endsWith("/") ? ct : void 0;
+}
+function declaredTypes(gates) {
+  return [
+    ...new Set(gates.map((g) => g.check.type).filter((t) => t !== void 0))
+  ];
+}
+function shapeCompatible(types, value, stdin, probe) {
+  if (stdin) return types.filter((t) => t === "text" || t === "file");
+  const what = probe(value);
+  if (what === "dir") return types.filter((t) => t === "folder");
+  if (what === "file") return types.filter((t) => t === "text" || t === "file");
+  if (isUrl(value)) {
+    return types.filter((t) => t === "link" || t === "pr" && parsePrSpec(value) !== null);
+  }
+  return types.filter((t) => t === "pr" && parsePrSpec(value) !== null);
+}
+function gateSpec(check) {
+  const type = check.type ?? "any type";
+  return check.content_type ? `${type} (${check.content_type})` : type;
+}
+function joinTransitions(names) {
+  const unique = [...new Set(names)].map((n) => `"${n}"`);
+  if (unique.length <= 1) return unique.join("");
+  return `${unique.slice(0, -1).join(", ")} and ${unique[unique.length - 1]}`;
+}
+function fixCommand(gate, ref) {
+  return gate.check.fix || requirementFix(gate.check, ref).command;
+}
+function accepts(gate, type, contentType) {
+  const check = gate.check;
+  if (check.type !== void 0 && check.type !== type) return false;
+  if (check.content_type === void 0) return true;
+  if (contentType === void 0) return true;
+  return contentType.startsWith(check.content_type);
+}
+function effectiveContentType(type, source, explicit, sniff) {
+  if (explicit !== void 0) return explicit;
+  if (type === "text") return "text/markdown";
+  if (source.kind === "file-path") return sniff(source.path);
+  if (source.kind === "file-stdin") return "application/octet-stream";
+  return void 0;
+}
+function planAttach(input, sniff) {
+  const { ref, name: name2, positional, flags, probe } = input;
+  assertOneSource(flags, positional);
+  const gates = flags.ignoreGates ? [] : input.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);
+    checkExistingSlot(plan, gates, ref, name2, flags, positional);
+  }
+  return plan;
+}
+function planPositional(name2, raw, gates, probe, flags) {
+  const { value, stdin } = normalizePositional(raw);
+  const types = declaredTypes(gates);
+  let type;
+  if (types.length === 1) {
+    type = types[0];
+  } else if (types.length > 1) {
+    const compatible = shapeCompatible(types, value, stdin, probe);
+    if (compatible.length === 1) {
+      type = compatible[0];
+    } else {
+      const specs = gates.filter((g) => g.check.type !== void 0).map((g) => `as ${g.check.type} by "${g.transition}"`);
+      throw new CliError(
+        `"${name2}" is gated ${specs.join(" and ")}; pass ${types.map(flagFor).join("/")} to choose`
+      );
+    }
+  }
+  const contentType = flags.contentType ?? gateContentType(gates, type);
+  const withCt = (p) => ({
+    ...p,
+    ...contentType !== void 0 ? { contentType } : {},
+    ...flags.filename !== void 0 ? { filename: flags.filename } : {}
+  });
+  if (type === void 0) {
+    if (stdin) {
+      throw new CliError(
+        `"${name2}" is not gated on this issue, so "-" has no type to read stdin as \u2014 use --text - for a document, or --file <path>`
+      );
+    }
+    const what = probe(value);
+    if (what === "dir") return withCt({ type: "folder", source: { kind: "folder", dir: value } });
+    if (what === "file")
+      return withCt({ type: "file", source: { kind: "file-path", path: value } });
+    const pr = parsePrSpec(value);
+    if (pr) return withCt({ type: "pr", source: { kind: "pr", pr } });
+    if (isUrl(value)) {
+      return withCt({
+        type: "link",
+        source: {
+          kind: "link",
+          url: value,
+          ...flags.title !== void 0 ? { title: flags.title } : {}
+        }
+      });
+    }
+    throw new CliError(
+      `no such file "${value}" \u2014 a positional source is a path, a URL or owner/repo#N; inline text goes in --text (text is only inferred under a text gate)`
+    );
+  }
+  switch (type) {
+    case "text": {
+      if (stdin) return withCt({ type: "text", source: { kind: "text-stdin" } });
+      const what = probe(value);
+      if (what === "dir") {
+        throw new CliError(`"${value}" is a directory; "${name2}" is gated as text`);
+      }
+      if (what === "missing") throw new CliError(`cannot read ${value}: no such file`);
+      return withCt({ type: "text", source: { kind: "text-path", path: value } });
+    }
+    case "file": {
+      if (stdin) return withCt({ type: "file", source: { kind: "file-stdin" } });
+      const what = probe(value);
+      if (what === "dir") {
+        throw new CliError(`"${value}" is a directory; "${name2}" is gated as file`);
+      }
+      if (what === "missing") throw new CliError(`cannot read ${value}: no such file`);
+      return withCt({ type: "file", source: { kind: "file-path", path: value } });
+    }
+    case "folder": {
+      if (probe(value) !== "dir") {
+        throw new CliError(`"${name2}" is gated as folder, but "${value}" is not a directory`);
+      }
+      return withCt({ type: "folder", source: { kind: "folder", dir: value } });
+    }
+    case "link": {
+      if (!isUrl(value)) {
+        throw new CliError(`"${name2}" is gated as link, but "${value}" is not an http(s) URL`);
+      }
+      return withCt({
+        type: "link",
+        source: {
+          kind: "link",
+          url: value,
+          ...flags.title !== void 0 ? { title: flags.title } : {}
+        }
+      });
+    }
+    case "pr": {
+      const pr = parsePrSpec(value);
+      if (!pr) {
+        throw new CliError(
+          `"${name2}" is gated as pr, but "${value}" is not owner/repo#N or a GitHub PR URL`
+        );
+      }
+      return withCt({ type: "pr", source: { kind: "pr", pr } });
+    }
+  }
+}
+function gateContentType(gates, type) {
+  if (type !== "text" && type !== "file") return void 0;
+  const declared = [
+    ...new Set(
+      gates.filter((g) => g.check.type === type).map((g) => concreteContentType(g.check.content_type)).filter((ct) => ct !== void 0)
+    )
+  ];
+  return declared.length === 1 ? declared[0] : void 0;
+}
+function planFlags(flags, probe) {
+  const ct = flags.contentType;
+  const filename = flags.filename;
+  const modifiers = {
+    ...ct !== void 0 ? { contentType: ct } : {},
+    ...filename !== void 0 ? { filename } : {}
+  };
+  if (flags.folder !== void 0) {
+    if (probe(flags.folder) !== "dir") {
+      throw new CliError(`--folder needs a directory, got "${flags.folder}"`);
+    }
+    return { type: "folder", source: { kind: "folder", dir: flags.folder }, ...modifiers };
+  }
+  if (flags.file !== void 0) {
+    const what = probe(flags.file);
+    if (what === "missing") throw new CliError(`cannot read ${flags.file}: no such file`);
+    if (what === "dir")
+      throw new CliError(`--file needs a file, got the directory "${flags.file}"`);
+    return { type: "file", source: { kind: "file-path", path: flags.file }, ...modifiers };
+  }
+  if (flags.text !== void 0) {
+    const v = flags.text;
+    const source = v === "-" || v === "@-" ? { kind: "text-stdin" } : v.startsWith("@@") ? { kind: "text-inline", value: v.slice(1) } : v.startsWith("@") ? { kind: "text-path", path: v.slice(1) } : { kind: "text-inline", value: v };
+    return { type: "text", source, ...modifiers };
+  }
+  if (flags.link !== void 0) {
+    return {
+      type: "link",
+      source: {
+        kind: "link",
+        url: flags.link,
+        ...flags.title !== void 0 ? { title: flags.title } : {}
+      },
+      ...modifiers
+    };
+  }
+  const parsed = parsePrSpec(flags.pr);
+  if (!parsed) throw new CliError(`--pr takes owner/repo#N or a GitHub PR URL, got "${flags.pr}"`);
+  return { type: "pr", source: { kind: "pr", pr: parsed }, ...modifiers };
+}
+function checkExistingSlot(plan, gates, ref, name2, flags, positional) {
+  const held = gates.find((g) => g.check.current_type !== null)?.check.current_type;
+  if (held === void 0 || held === null || held === plan.type) return;
+  const rejecting = gates.find((g) => g.check.type !== void 0 && g.check.type !== held);
+  const fix = rejecting ? fixCommand(rejecting, ref) : `tines issues artifacts delete ${ref} ${name2} && tines issues artifacts attach ${ref} ${name2} ${flagFor(plan.type)} <source>`;
+  throw new CliError(
+    `"${name2}" already holds a ${held} artifact and the type is immutable; ${sourceLabel(flags, positional)} would attach ${plan.type}. Use: ${fix} \u2014 or attach it under a different name (--ignore-gates does not bypass this; the server rejects the type change too)`
+  );
+}
+function checkAccepted(plan, gates, ref, name2, flags, positional, sniff) {
+  const effective = effectiveContentType(plan.type, plan.source, plan.contentType, sniff);
+  if (gates.some((g2) => accepts(g2, plan.type, effective))) return;
+  const label = sourceLabel(flags, positional);
+  const typeMatched = gates.filter((g2) => (g2.check.type ?? plan.type) === plan.type);
+  if (typeMatched.length > 0) {
+    const g2 = typeMatched[0];
+    throw new CliError(
+      `"${name2}" is gated by ${joinTransitions(typeMatched.map((x) => x.transition))} as ${gateSpec(g2.check)}; ${label} would attach ${effective ?? plan.type}, which does not satisfy it. Use: ${fixCommand(g2, ref)} with --content-type <mime under ${g2.check.content_type}> (or --ignore-gates to attach it anyway)`
+    );
+  }
+  const g = gates[0];
+  throw new CliError(
+    `"${name2}" is gated by ${joinTransitions(gates.map((x) => x.transition))} as ${gateSpec(g.check)}; ${label} would create a ${plan.type} artifact that can never satisfy it. Use: ${fixCommand(g, ref)} (or --ignore-gates to attach a ${plan.type} anyway)`
+  );
+}
+function satisfiedBy(artifact, gates) {
+  const satisfies = [];
+  const rejects = [];
+  for (const gate of gates) {
+    if (gate.check.artifact !== artifact.name) continue;
+    if (accepts(gate, artifact.artifact_type, artifact.current_version.content_type ?? void 0)) {
+      satisfies.push(gate.transition);
+    } else {
+      rejects.push({ transition: gate.transition, wants: wantsLabel(gate, artifact) });
+    }
+  }
+  return { satisfies, rejects };
+}
+function wantsLabel(gate, artifact) {
+  const check = gate.check;
+  if (check.type !== void 0 && check.type !== artifact.artifact_type)
+    return `wants ${check.type}`;
+  return `wants ${check.content_type ?? check.type ?? "something else"}`;
+}
+function gateLabel(artifact, gates) {
+  const { rejects } = satisfiedBy(artifact, gates);
+  return [...new Set(rejects.map((r) => r.wants))].join("; ");
+}
+var ATTACH_SOURCE_HELP = `
+Source:
+  A positional <source> is typed by the slot's gate when this issue has one:
+  a text gate reads the path as the document (the gate's content type wins over
+  the extension), a file gate uploads its bytes, a folder gate walks it, and a
+  link/pr gate takes a URL or owner/repo#N. "-" reads stdin under a text or
+  file gate.
+
+  With no gate, the shape alone decides: a directory is a folder, an http(s)
+  URL is a link (a GitHub PR URL is a pr), owner/repo#N is a pr, and anything
+  else is a file \u2014 a .md path included. Inline text is never inferred: pass it
+  with --text.
+
+  Flags still override, and are refused before any network write when no
+  available transition's requirement for the slot could ever accept what they
+  would create. --ignore-gates attaches it anyway. Prefix a source starting
+  with "-" with "--".`;
+
 // src/help-guard.ts
 function helpGuard(command, markdown) {
   if (markdown === "--help" || markdown === "-h") {
@@ -4879,6 +5263,13 @@ ${issue.description}`);
     `
 allowed actions: ${allowed.length ? allowed.join(", ") : "none (terminal state)"}`
   );
+  for (const t of issue.allowed_transitions) {
+    for (const check of t.requires ?? []) {
+      const [head, ...rest] = requirementLines(check);
+      console.log(`  "${t.name}" ${head}`);
+      for (const line of rest) console.log(`  ${line}`);
+    }
+  }
   if (issue.comments.length > 0) {
     console.log(`
 comments (${issue.comments.length}):`);
@@ -4887,6 +5278,18 @@ comments (${issue.comments.length}):`);
     }
   }
 }
+function readTextSource(source) {
+  if (source.kind === "text-inline") return source.value;
+  if (source.kind === "text-stdin") return readBodyValue("-");
+  if (source.kind === "text-path") {
+    try {
+      return readFileSync4(source.path, "utf8");
+    } catch (err) {
+      die(`cannot read ${source.path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  throw new Error(`not a text source: ${source.kind}`);
+}
 function walkFolder(dir) {
   const files = [];
   const walk = (abs, rel) => {
@@ -5259,7 +5662,7 @@ skills: ${context.skills.map((s) => s.name).join(", ")}`);
         `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`
       );
     }
-    if (existsSync2(opts.out) && readdirSync(opts.out).length > 0 && !opts.force) {
+    if (existsSync3(opts.out) && readdirSync(opts.out).length > 0 && !opts.force) {
       die(`refusing to write into non-empty directory ${opts.out} (pass --force to override)`);
     }
     mkdirSync2(opts.out, { recursive: true });
@@ -5314,13 +5717,17 @@ skills: ${context.skills.map((s) => s.name).join(", ")}`);
     const res = await api.listArtifacts(issue.id);
     if (opts.json) return printJson(res);
     if (res.items.length === 0) return console.log("no artifacts attached");
+    const gates = gatesFor(issue);
+    const labels = res.items.map((a) => gateLabel(a, gates));
+    const gated = labels.some((l) => l !== "");
     table([
-      ["NAME", "TYPE", "VERSION", "FRESH", "SUMMARY", "ATTACHED"],
-      ...res.items.map((a) => [
+      ["NAME", "TYPE", "VERSION", "FRESH", ...gated ? ["GATE"] : [], "SUMMARY", "ATTACHED"],
+      ...res.items.map((a, i) => [
         a.name,
         a.artifact_type,
         `v${a.current_version.version}`,
         a.fresh ? "yes" : "no",
+        ...gated ? [labels[i] || "ok"] : [],
         artifactSummary(a),
         timestamp(a.current_version.created_at)
       ])
@@ -5358,79 +5765,97 @@ files (v${artifact.current_version.version}):`);
     }
   });
   withCommon(
-    artifactsCmd.command("attach <ref> <name>").description(
+    artifactsCmd.command("attach <ref> <name> [source]").description(
       "Attach content to a named artifact slot (creates it, or appends the next version)"
     ).option("-f, --file <path>", "upload a file (MIME sniffed from the extension)").option(
       "--folder <dir>",
       "snapshot a directory tree as one version (collect locally, attach once; MIME per file sniffed)"
-    ).option("-t, --text <md|@file>", "inline text document: inline Markdown or @file").option("--link <url>", "link: the URL to attach").option("--pr <spec>", "PR reference: owner/repo#N or a GitHub PR URL").option("--content-type <mime>", "declared MIME type (with --file or --text)").option("--filename <name>", "display filename (with --text; defaults to <name>.md)").option("--title <title>", "display title (with --link)").option("-d, --description <text>", "artifact description, shown in lists and launch prompts")
+    ).option("-t, --text <md|@file>", "inline text document: inline Markdown or @file").option("--link <url>", "link: the URL to attach").option("--pr <spec>", "PR reference: owner/repo#N or a GitHub PR URL").option("--content-type <mime>", "declared MIME type (with --file or --text)").option("--filename <name>", "display filename (with --text; defaults to <name>.md)").option("--title <title>", "display title (with --link)").option("-d, --description <text>", "artifact description, shown in lists and launch prompts").option(
+      "--ignore-gates",
+      "attach this type even when a transition requirement rejects it (skips inference and the pre-flight checks)"
+    ).addHelpText("after", ATTACH_SOURCE_HELP)
   ).action(
-    async (ref, name2, opts) => {
+    async (ref, name2, source, opts) => {
       const api = client(opts);
-      const sources = [opts.file, opts.folder, opts.text, opts.link, opts.pr].filter(
-        (v) => v !== void 0
-      );
-      if (sources.length !== 1) {
-        die(
-          "pass exactly one content source: --file <path>, --folder <dir>, --text <md|@file>, --link <url>, or --pr <spec> (a link goes in --link; --url is the API base URL)"
-        );
+      try {
+        assertOneSource(opts, source);
+      } catch (err) {
+        die(err instanceof Error ? err.message : String(err));
       }
       const issue = await resolveIssue(api, ref);
+      const gates = gatesFor(issue, name2);
+      const plan = planAttach(
+        {
+          ref: `${issue.project_name}/${issue.number}`,
+          name: name2,
+          positional: source,
+          flags: opts,
+          gates,
+          probe: fsProbe
+        },
+        sniffContentType
+      );
+      const withDescription = opts.description !== void 0 ? { description: opts.description } : {};
       let artifact;
-      if (opts.folder !== void 0) {
-        if (!existsSync2(opts.folder) || !statSync(opts.folder).isDirectory()) {
-          die(`--folder needs a directory, got "${opts.folder}"`);
-        }
-        const files = walkFolder(opts.folder);
-        if (files.length === 0) die(`${opts.folder} contains no files to snapshot`);
+      if (plan.type === "folder") {
+        const dir = plan.source.dir;
+        const files = walkFolder(dir);
+        if (files.length === 0) die(`${dir} contains no files to snapshot`);
         artifact = await api.uploadArtifactFolder(issue.id, name2, files);
         if (opts.description !== void 0) {
           artifact = await api.putArtifact(issue.id, name2, { description: opts.description });
         }
-      } else if (opts.file !== void 0) {
+      } else if (plan.type === "file") {
+        const fromPath = plan.source.kind === "file-path" ? plan.source.path : null;
         let bytes;
-        try {
-          bytes = readFileSync4(opts.file);
-        } catch (err) {
-          die(`cannot read ${opts.file}: ${err instanceof Error ? err.message : String(err)}`);
+        if (fromPath === null) {
+          if (process.stdin.isTTY) die('"-" reads the file from stdin, but stdin is a terminal');
+          bytes = readFileSync4(0);
+        } else {
+          try {
+            bytes = readFileSync4(fromPath);
+          } catch (err) {
+            die(`cannot read ${fromPath}: ${err instanceof Error ? err.message : String(err)}`);
+          }
         }
         artifact = await api.uploadArtifactFile(issue.id, name2, bytes, {
-          filename: opts.filename ?? basename(opts.file),
-          contentType: opts.contentType ?? sniffContentType(opts.file)
+          filename: plan.filename ?? (fromPath === null ? name2 : basename(fromPath)),
+          contentType: plan.contentType ?? (fromPath === null ? "application/octet-stream" : sniffContentType(fromPath))
         });
         if (opts.description !== void 0) {
           artifact = await api.putArtifact(issue.id, name2, { description: opts.description });
         }
-      } else if (opts.text !== void 0) {
+      } else if (plan.type === "text") {
+        const content = readTextSource(plan.source);
         artifact = await api.putArtifact(issue.id, name2, {
           type: "text",
-          content: readBodyValue(opts.text),
-          ...opts.filename !== void 0 ? { filename: opts.filename } : {},
-          ...opts.contentType !== void 0 ? { content_type: opts.contentType } : {},
-          ...opts.description !== void 0 ? { description: opts.description } : {}
+          content,
+          ...plan.filename !== void 0 ? { filename: plan.filename } : {},
+          ...plan.contentType !== void 0 ? { content_type: plan.contentType } : {},
+          ...withDescription
         });
-      } else if (opts.link !== void 0) {
+      } else if (plan.type === "link") {
+        const link = plan.source;
         artifact = await api.putArtifact(issue.id, name2, {
           type: "link",
-          url: opts.link,
-          ...opts.title !== void 0 ? { title: opts.title } : {},
-          ...opts.description !== void 0 ? { description: opts.description } : {}
+          url: link.url,
+          ...link.title !== void 0 ? { title: link.title } : {},
+          ...withDescription
         });
       } else {
-        const parsed = parsePrSpec(opts.pr);
-        if (!parsed) {
-          die(`--pr takes owner/repo#N or a GitHub PR URL, got "${opts.pr}"`);
-        }
+        const { pr } = plan.source;
         artifact = await api.putArtifact(issue.id, name2, {
           type: "pr",
-          pr_repo_url: parsed.repo_url,
-          pr_number: parsed.number,
-          ...opts.description !== void 0 ? { description: opts.description } : {}
+          pr_repo_url: pr.repo_url,
+          pr_number: pr.number,
+          ...withDescription
         });
       }
       if (opts.json) return printJson(artifact);
+      const { satisfies, rejects } = satisfiedBy(artifact, gates);
+      const gateNote = satisfies.length > 0 ? `; satisfies ${satisfies.map((t) => `"${t}"`).join(", ")}` : rejects.length > 0 ? `, but does not satisfy ${rejects.map((r) => `"${r.transition}" (${r.wants})`).join(", ")}` : "";
       console.log(
-        `attached "${artifact.name}" v${artifact.current_version.version} (${artifactSummary(artifact)}) to ${issue.project_name}/${issue.number} \u2014 fresh`
+        `attached "${artifact.name}" v${artifact.current_version.version} (${artifactTypeLabel(artifact)}) to ${issue.project_name}/${issue.number} \u2014 fresh${gateNote}`
       );
     }
   );
@@ -5476,7 +5901,7 @@ files (v${artifact.current_version.version}):`);
         if (opts.out === void 0) {
           die(`artifact "${name2}" is a folder \u2014 pass --out <dir> to write its tree`);
         }
-        if (existsSync2(opts.out) && !statSync(opts.out).isDirectory()) {
+        if (existsSync3(opts.out) && !statSync2(opts.out).isDirectory()) {
           die(`--out for a folder must be a directory, and "${opts.out}" is a file`);
         }
         const files = version.files ?? [];
@@ -5499,7 +5924,7 @@ files (v${artifact.current_version.version}):`);
       const bytes = Buffer.from(content.bytes);
       if (opts.out !== void 0) {
         let target2 = opts.out;
-        if (existsSync2(target2) && statSync(target2).isDirectory()) {
+        if (existsSync3(target2) && statSync2(target2).isDirectory()) {
           target2 = join2(target2, version.filename ?? name2);
         }
         writeFileSync2(target2, bytes);
@@ -6103,12 +6528,12 @@ import { hostname as hostname2 } from "node:os";
 import { spawn as spawn2 } from "node:child_process";
 import {
   createWriteStream,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync9,
   realpathSync,
   rmSync as rmSync2,
-  statSync as statSync3,
+  statSync as statSync4,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "node:fs";
@@ -6224,7 +6649,7 @@ var ClaudeStreamRenderer = class {
 
 // src/daemon/cli-refresh.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "node:fs";
 import { dirname as dirname3, join as join3 } from "node:path";
 
 // src/daemon/support.ts
@@ -6550,7 +6975,7 @@ function installedVersion(prefix) {
 }
 function lastGood(prefix) {
   const binDir = binDirOf(prefix);
-  if (!existsSync3(join3(binDir, PACKAGE))) return AMBIENT_CLI;
+  if (!existsSync4(join3(binDir, PACKAGE))) return AMBIENT_CLI;
   return { binDir, version: installedVersion(prefix), source: "stale" };
 }
 function runNpm(file, args, cwd, timeoutMs) {
@@ -6596,7 +7021,7 @@ async function installAgentCli(opts) {
   let result = await runNpm("npm", args, prefix, timeoutMs);
   if (result.spawnError?.code === "ENOENT") {
     const sibling = join3(dirname3(process.execPath), "npm");
-    if (existsSync3(sibling)) result = await runNpm(sibling, args, prefix, timeoutMs);
+    if (existsSync4(sibling)) result = await runNpm(sibling, args, prefix, timeoutMs);
   }
   if (result.code !== 0) {
     const fallback = lastGood(prefix);
@@ -6618,7 +7043,7 @@ function message(err) {
 }
 
 // src/daemon/store.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync, statSync as statSync2 } from "node:fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync, statSync as statSync3 } from "node:fs";
 import { join as join4 } from "node:path";
 function credentialsKey(url, name2) {
   return `${url.replace(/\/+$/, "")}#${name2}`;
@@ -6739,7 +7164,7 @@ function directorySizeBytes(path2) {
     if (entry.isDirectory()) total += directorySizeBytes(child);
     else if (entry.isFile()) {
       try {
-        total += statSync2(child).size;
+        total += statSync3(child).size;
       } catch {
       }
     }
@@ -6756,7 +7181,7 @@ async function uploadRawLog(run) {
   run.rawSpoolPath = void 0;
   try {
     await new Promise((resolve) => run.rawSpool?.end(resolve) ?? resolve());
-    const size = statSync3(path2).size;
+    const size = statSync4(path2).size;
     if (size > 0) {
       let body = readFileSync9(path2);
       if (body.byteLength > RUN_LOG_RAW_MAX_BYTES) {
@@ -6819,7 +7244,7 @@ async function runDaemon(opts) {
       rmSync2(workspace, { recursive: true, force: true });
       return;
     }
-    if (!existsSync4(workspace)) return;
+    if (!existsSync5(workspace)) return;
     try {
       writeKeptMarker(workspace, { ...marker, kept_at: (/* @__PURE__ */ new Date()).toISOString() });
       log(`run ${marker.run_id}: workspace kept at ${workspace}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.140",
+  "version": "0.0.141",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",