@pome-sh/cli 0.21.5 → 0.21.7

package/dist/chunk-XS66ZRBJ.js

@@ -0,0 +1,537 @@
+import { statePath, defineCheck, VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, childStatePath } from './chunk-NY55QTVQ.js';
+
+// ../packages/twin-linear/dist/src/check-params.js
+var issueTitle = {
+  name: "title",
+  pattern: '[^"\\n]+',
+  example: "Orders 500 after deploy",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var teamKey = {
+  name: "team",
+  pattern: "[A-Z][A-Z0-9]*",
+  example: "ENG",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var workflowStateName = {
+  name: "state",
+  pattern: '[^"\\n]+',
+  example: "In Progress",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var labelName = {
+  name: "label",
+  pattern: '[^"\\n]+',
+  example: "Agent",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var estimatePoints = {
+  name: "estimate",
+  pattern: "0|[1-9][0-9]*",
+  example: "2",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var userRef = {
+  name: "user",
+  pattern: "[^`\\n]+",
+  example: "dev@pome-twin.test",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var commentNeedle = {
+  name: "needle",
+  pattern: '[^"\\n]+',
+  example: "triage",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+
+// ../packages/twin-linear/dist/src/check-state.js
+var ISSUES_PATH = statePath("issues");
+var COMMENTS_PATH = statePath("comments");
+var LABELS_PATH = statePath("labels");
+var WORKFLOW_STATES_PATH = statePath("workflowStates");
+var USERS_PATH = statePath("users");
+function fieldPath(base, row, key) {
+  return Object.prototype.hasOwnProperty.call(row, key) ? childStatePath(base, key) : base;
+}
+function unresolved(r) {
+  const outcome = r.skip ? { passed: false, status: "skipped", reason: r.missing } : { passed: false, reason: r.missing };
+  if (r.searched === void 0)
+    return outcome;
+  return { ...outcome, evidenceStatePaths: [r.searched] };
+}
+function isTruncated(state, collection) {
+  return (state.exportBounds?.truncatedCollections ?? []).includes(collection);
+}
+function resolveIssue(state, teamKey2, title) {
+  if (state.teams == null)
+    return { missing: "state_incomplete", skip: true };
+  const team = state.teams.find((t) => t.key === teamKey2);
+  if (team?.id == null) {
+    return {
+      missing: `team \`${teamKey2}\` not found in state_final`,
+      skip: false,
+      searched: statePath("teams")
+    };
+  }
+  if (state.issues == null)
+    return { missing: "state_incomplete", skip: true };
+  const indices = state.issues.map((issue, index) => issue.teamId === team.id && issue.title === title && (issue.archivedAt ?? null) === null ? index : -1).filter((index) => index >= 0);
+  if (indices.length === 1) {
+    const index = indices[0];
+    return { found: state.issues[index], path: childStatePath(ISSUES_PATH, index) };
+  }
+  if (indices.length > 1) {
+    return {
+      missing: `${indices.length} issues in \`${teamKey2}\` share that title`,
+      skip: false,
+      searched: ISSUES_PATH
+    };
+  }
+  if (isTruncated(state, "issues")) {
+    return { missing: "state_truncated", skip: true, searched: ISSUES_PATH };
+  }
+  return {
+    missing: `no issue with that title in \`${teamKey2}\``,
+    skip: false,
+    searched: ISSUES_PATH
+  };
+}
+function resolveWorkflowStateName(state, issue) {
+  if (state.workflowStates == null)
+    return { missing: "state_incomplete", skip: true };
+  const index = state.workflowStates.findIndex((s) => s.id === issue.stateId && s.teamId === issue.teamId);
+  const row = index >= 0 ? state.workflowStates[index] : void 0;
+  if (row?.name == null) {
+    return { missing: "workflow_state_unresolved", skip: true, searched: WORKFLOW_STATES_PATH };
+  }
+  return { found: row.name, path: childStatePath(WORKFLOW_STATES_PATH, index, "name") };
+}
+function resolveLabelNames(state, issue) {
+  if (state.labels == null)
+    return { missing: "state_incomplete", skip: true };
+  const byId = new Map(state.labels.filter((l) => l.id != null).map((l) => [l.id, (l.name ?? "").toLowerCase()]));
+  const names = /* @__PURE__ */ new Set();
+  for (const id of issue.labelIds ?? []) {
+    const name = byId.get(id);
+    if (name === void 0)
+      return { missing: "label_unresolved", skip: true, searched: LABELS_PATH };
+    names.add(name);
+  }
+  return { found: names, path: LABELS_PATH };
+}
+function resolveComments(state, issue) {
+  if (state.comments == null)
+    return { missing: "state_incomplete", skip: true };
+  return { found: state.comments.filter((c) => c.issueId === issue.id), path: COMMENTS_PATH };
+}
+function resolveUserLabels(state, id) {
+  if (id == null || state.users == null)
+    return [];
+  const user = state.users.find((u) => u.id === id);
+  if (user == null)
+    return [];
+  return [user.email, user.name, user.displayName].filter((v) => typeof v === "string" && v.length > 0);
+}
+
+// ../packages/twin-linear/dist/src/check-worlds.js
+var FIXTURE_TEAM_ID = "team_eng";
+var FIXTURE_TEAM_KEY = "ENG";
+function fixtureStateId(name) {
+  return `state_${name.toLowerCase().replace(/[^a-z0-9]+/g, "_")}`;
+}
+function fixtureLabelId(name) {
+  return `label_${name.toLowerCase().replace(/[^a-z0-9]+/g, "_")}`;
+}
+var FIXTURE_STATES = [
+  { name: "Backlog", type: "backlog" },
+  { name: "Todo", type: "unstarted" },
+  { name: "In Progress", type: "started" },
+  { name: "Done", type: "completed" },
+  { name: "Canceled", type: "canceled" }
+];
+function finalWorld(final) {
+  return { seed: null, final, tape: null };
+}
+function deltaWorld(seed, final) {
+  return { seed, final, tape: null };
+}
+function tapeWorld(tape) {
+  return { seed: null, final: { issues: [] }, tape };
+}
+function linearState(issues, comments = [], labelNames = ["Agent"]) {
+  return {
+    teams: [{ id: FIXTURE_TEAM_ID, key: FIXTURE_TEAM_KEY, name: "Engineering" }],
+    workflowStates: FIXTURE_STATES.map((s) => ({
+      id: fixtureStateId(s.name),
+      teamId: FIXTURE_TEAM_ID,
+      name: s.name,
+      type: s.type
+    })),
+    labels: labelNames.map((name) => ({
+      id: fixtureLabelId(name),
+      teamId: FIXTURE_TEAM_ID,
+      name
+    })),
+    issues,
+    comments,
+    users: [
+      { id: "user_dev", email: "dev@pome-twin.test", name: "Developer", displayName: "Dev" }
+    ],
+    exportBounds: { truncatedCollections: [] }
+  };
+}
+function issueRow(title, over = {}) {
+  return {
+    id: over.id ?? "issue_1",
+    identifier: "ENG-1",
+    number: 1,
+    teamId: FIXTURE_TEAM_ID,
+    title,
+    stateId: fixtureStateId(over.stateName ?? "In Progress"),
+    estimate: over.estimate ?? null,
+    ...over.assigneeId === void 0 ? {} : { assigneeId: over.assigneeId },
+    archivedAt: null,
+    labelIds: (over.labelNames ?? []).map(fixtureLabelId)
+  };
+}
+
+// ../packages/twin-linear/dist/src/check-comments.js
+var issueCommentContains = defineCheck({
+  id: "linear.issue-comment-contains",
+  description: 'Resolves the issue and scans the body of every comment on it for this string as a SUBSTRING, case-sensitively. Because the string is hunted inside free prose rather than compared to a field, a redactor that destroys it makes this check unable to fire \u2014 the engine skips it as `subject_redacted` rather than passing it vacuously. Choose the needle every honest phrasing would share, not the whole sentence you imagine the agent writing: a task wanting a GitHub cross-reference is served by "#1", where "GitHub issue #1" fails an agent that wrote "linked from acme/api#1".',
+  template: 'A comment on issue "{title}" in `{team}` contains "{needle}"',
+  params: { title: issueTitle, team: teamKey, needle: commentNeedle },
+  substrate: "final",
+  polarity: () => "positive",
+  // The needle is SCANNED inside prose, so it is the subject — twin-slack's
+  // `messageNeedle` precedent, and the reason a redacted needle becomes an
+  // honest skip rather than a silent failure.
+  subject: ({ needle }) => needle,
+  vacuityMutant: (args) => ({ ...args, needle: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ title, needle }) => ({
+    passing: finalWorld(linearState([issueRow(title)], [{ id: "c1", issueId: "issue_1", parentId: null, body: `see ${needle}` }])),
+    // The issue AND a comment are present in both worlds; only the body
+    // moves. A world with no comments would still fail, but for a reason
+    // closer to the empty world's than to the assertion's.
+    failing: finalWorld(linearState([issueRow(title)], [{ id: "c1", issueId: "issue_1", parentId: null, body: "nothing relevant here" }]))
+  }),
+  evaluate({ title, team, needle }, { final }) {
+    const issue = resolveIssue(final, team, title);
+    if ("missing" in issue)
+      return unresolved(issue);
+    const comments = resolveComments(final, issue.found);
+    if ("missing" in comments)
+      return unresolved(comments);
+    const hit = comments.found.some((c) => (c.body ?? "").includes(needle));
+    return {
+      passed: hit,
+      reason: hit ? `a comment contains "${needle}"` : `no comment contains "${needle}" (${comments.found.length} comment(s) scanned)`,
+      evidenceStatePaths: [comments.path]
+    };
+  }
+});
+var issueThreadedReply = defineCheck({
+  id: "linear.issue-threaded-reply",
+  description: "Asserts a comment exists on this issue whose `parentId` names a comment that was ALREADY THERE IN THE SEED. Needs the seed: it is a delta, not a state assertion, and the delta is what separates replying inside an existing thread from posting a comment and replying to yourself. It asserts nothing about what the reply says, or who wrote it.",
+  template: 'A threaded reply to a seeded comment exists on issue "{title}" in `{team}`',
+  params: { title: issueTitle, team: teamKey },
+  substrate: "seed+final",
+  polarity: () => "positive",
+  // No caller-supplied literal reaches an assertion: title and team only
+  // select, and the predicate compares ids it read out of the two substrates.
+  subject: () => null,
+  // Ledgered. Both slots only SELECT, so there is nothing in the sentence to
+  // falsify — the trigger is a parentId relation between two substrates.
+  vacuityMutant: () => null,
+  discriminatingWorlds: ({ title }) => {
+    const seededRoot = { id: "root", issueId: "issue_1", parentId: null, body: "reply here" };
+    const seed = linearState([issueRow(title)], [seededRoot]);
+    return {
+      passing: deltaWorld(seed, linearState([issueRow(title)], [seededRoot, { id: "reply", issueId: "issue_1", parentId: "root", body: "on it" }])),
+      // The issue and the seeded root are present in both worlds; only the
+      // reply's PARENT moves. This agent commented — just not in the thread.
+      failing: deltaWorld(seed, linearState([issueRow(title)], [seededRoot, { id: "own", issueId: "issue_1", parentId: null, body: "on it" }]))
+    };
+  },
+  evaluate({ title, team }, { seed, final }) {
+    if (seed === null)
+      return { passed: false, reason: "seed_missing", status: "skipped" };
+    const seedIssue = resolveIssue(seed, team, title);
+    if ("missing" in seedIssue)
+      return unresolved({ ...seedIssue, searched: void 0 });
+    const seedComments = resolveComments(seed, seedIssue.found);
+    if ("missing" in seedComments)
+      return unresolved({ ...seedComments, searched: void 0 });
+    const seeded = new Set(seedComments.found.map((c) => c.id).filter((id) => typeof id === "string"));
+    const finalIssue = resolveIssue(final, team, title);
+    if ("missing" in finalIssue)
+      return unresolved(finalIssue);
+    const finalComments = resolveComments(final, finalIssue.found);
+    if ("missing" in finalComments)
+      return unresolved(finalComments);
+    const replies = finalComments.found.filter((c) => typeof c.parentId === "string" && seeded.has(c.parentId));
+    return {
+      passed: replies.length > 0,
+      reason: `${replies.length} repl${replies.length === 1 ? "y" : "ies"} to a seeded comment (${seeded.size} seeded comment(s), ${finalComments.found.length} at finish)`,
+      // The FINAL comment list only. This is a delta over two trees and the
+      // reader has one on screen; a pointer into the seed would send them to the
+      // tree the report does not render (see the sdk's `check-state-path.ts`).
+      // The reason carries the seed side.
+      evidenceStatePaths: [COMMENTS_PATH]
+    };
+  }
+});
+
+// ../packages/twin-linear/dist/src/check-issues.js
+var issueExists = defineCheck({
+  id: "linear.issue-exists",
+  description: "Asserts an unarchived issue with this exact title exists in the named team. Declared and unused by the shipped corpus on purpose: `linear.issue-state` FAILS on a missing issue and therefore subsumes this one, so task 26 carries the state criterion alone \u2014 twin-github ships the same pair for the same reason. A vocabulary is what an author may pick from, not what the corpus happens to exercise. Title matching is EXACT and archived issues do not count, so an examinee that renames or archives the issue fails this.",
+  template: 'An issue titled "{title}" exists in `{team}`',
+  params: { title: issueTitle, team: teamKey },
+  substrate: "final",
+  polarity: () => "positive",
+  // The only check where the title IS the assertion rather than the selector,
+  // which is why it is the only one that declares the title as its subject.
+  subject: ({ title }) => title,
+  vacuityMutant: (args) => ({ ...args, title: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ title }) => ({
+    // The team is present in both worlds; only the issue moves. `linearState`
+    // always fills teams, so the failing world's reason is "no issue with that
+    // title in `ENG`" rather than the empty world's "team not found" — which is
+    // what arm 3 rejects.
+    passing: finalWorld(linearState([issueRow(title)])),
+    failing: finalWorld(linearState([issueRow("a different issue entirely")]))
+  }),
+  evaluate({ title, team }, { final }) {
+    const issue = resolveIssue(final, team, title);
+    if ("missing" in issue)
+      return unresolved(issue);
+    return {
+      passed: true,
+      reason: `an issue titled "${title}" exists in \`${team}\``,
+      evidenceStatePaths: [issue.path]
+    };
+  }
+});
+var issueState = defineCheck({
+  id: "linear.issue-state",
+  description: "Resolves the issue by title within the named team, follows `stateId` to that team's workflow-state row, and compares its NAME to the one given \u2014 case-insensitively, because a workflow state name is prose an author retypes. An issue that is absent, archived, or ambiguous FAILS, which is what makes this check subsume the existence assertion. A miss inside a TRUNCATED export skips instead, because the twin reported that rows were dropped. Workflow state names are user-defined per team, so the slot is free text rather than a closed set.",
+  // "is in state X", not "is X". Two reasons, both of which twin-github's
+  // `issue-state` comment states while crediting this very idiom to the Linear
+  // tasks: one reading habit spans twins, and the longer literal tail keeps
+  // this template from near-missing `... is assigned to \`{user}\``.
+  template: 'Issue "{title}" in `{team}` is in state "{state}"',
+  params: { title: issueTitle, team: teamKey, state: workflowStateName },
+  substrate: "final",
+  // Positive on every shipped use. Unlike `github.issue-state` there is no
+  // canonical "open" member to read a prohibition off, because the state names
+  // belong to the workspace rather than to the API.
+  polarity: () => "positive",
+  // The state name is the value COMPARED against the state; title and team only
+  // select.
+  subject: ({ state }) => state,
+  vacuityMutant: (args) => ({ ...args, state: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ title, state }) => ({
+    passing: finalWorld(linearState([issueRow(title, { stateName: state })])),
+    // The team and the issue are PRESENT in both worlds; only the state moves.
+    failing: finalWorld(linearState([issueRow(title, { stateName: "Backlog" })]))
+  }),
+  evaluate({ title, team, state }, { final }) {
+    const issue = resolveIssue(final, team, title);
+    if ("missing" in issue)
+      return unresolved(issue);
+    const name = resolveWorkflowStateName(final, issue.found);
+    if ("missing" in name)
+      return unresolved(name);
+    return {
+      passed: name.found.toLowerCase() === state.toLowerCase(),
+      reason: `issue state is "${name.found}" (wanted "${state}")`,
+      // BOTH ends of trap 1's join. An issue has no state string — it has a
+      // `stateId` into the team's own workflow catalog — so a reader handed only
+      // the issue row would find an opaque id, and one handed only the catalog
+      // row would not know which issue pointed at it.
+      evidenceStatePaths: [fieldPath(issue.path, issue.found, "stateId"), name.path]
+    };
+  }
+});
+var issueHasLabel = defineCheck({
+  id: "linear.issue-has-label",
+  description: "Resolves the issue, joins its `labelIds` to the workspace label catalog, and asserts the named label is among them \u2014 case-insensitively, as the legacy rule's comparison was. The join is the point: this export carries label IDS where the seed writes names and twin-github writes objects, so one concept has three shapes and only this one is exported. A label id with no catalog row is a partial export and SKIPS rather than failing.",
+  template: 'Issue "{title}" in `{team}` has label "{label}"',
+  params: { title: issueTitle, team: teamKey, label: labelName },
+  substrate: "final",
+  polarity: () => "positive",
+  subject: ({ label }) => label,
+  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ title, label }) => ({
+    passing: finalWorld(linearState([issueRow(title, { labelNames: [label] })], [], [label])),
+    // The issue is present and resolvable in both; only its labels move.
+    failing: finalWorld(linearState([issueRow(title, { labelNames: [] })], [], [label]))
+  }),
+  evaluate({ title, team, label }, { final }) {
+    const issue = resolveIssue(final, team, title);
+    if ("missing" in issue)
+      return unresolved(issue);
+    const names = resolveLabelNames(final, issue.found);
+    if ("missing" in names)
+      return unresolved(names);
+    return {
+      passed: names.found.has(label.toLowerCase()),
+      reason: `issue carries ${names.found.size} label(s) (wanted "${label}")`,
+      // Trap 2's join, both ends: `labelIds` on the row, names in the catalog.
+      evidenceStatePaths: [fieldPath(issue.path, issue.found, "labelIds"), names.path]
+    };
+  }
+});
+var issueEstimate = defineCheck({
+  id: "linear.issue-estimate",
+  description: "Resolves the issue and compares its `estimate` column to the number given. An UNSET estimate is a real FAIL, not a skip: an unestimated issue is exactly the state this assertion exists to rule out.",
+  template: 'Issue "{title}" in `{team}` has estimate {estimate}',
+  params: { title: issueTitle, team: teamKey, estimate: estimatePoints },
+  substrate: "final",
+  polarity: () => "positive",
+  // The single null in the subject column, and for twin-slack's emoji-name
+  // reason rather than an exemption: a bare integer of at most three digits
+  // matches no pattern in `redactSecrets` (key prefixes, 13-19-digit runs) or
+  // in a team's `PII_PATTERNS` (emails, phones). A value no redactor can eat is
+  // not a subject, and declaring one would only narrow the corpus gate's
+  // whole-phrase fallback for nothing.
+  subject: () => null,
+  // D10's second allowlist entry ever, and the argument is stripe's unchanged:
+  // here the number IS the scanned value, and the title is the selector.
+  vacuityMutant: (args) => ({ ...args, estimate: String(VACUITY_SENTINEL_NUMBER) }),
+  discriminatingWorlds: ({ title, estimate }) => ({
+    passing: finalWorld(linearState([issueRow(title, { estimate: Number(estimate) })])),
+    failing: finalWorld(linearState([issueRow(title, { estimate: null })]))
+  }),
+  evaluate({ title, team, estimate }, { final }) {
+    const issue = resolveIssue(final, team, title);
+    if ("missing" in issue)
+      return unresolved(issue);
+    const actual = issue.found.estimate ?? null;
+    return {
+      passed: actual === Number(estimate),
+      reason: `issue estimate is ${actual === null ? "unset" : actual} (wanted ${estimate})`,
+      // `fieldPath`, not a bare `…/estimate`: an UNSET estimate is the verdict
+      // this check exists to deliver, and on an export that omits the column
+      // entirely a pointer at it would resolve to nothing — stripping the
+      // affordance from exactly the row a reader wants to open.
+      evidenceStatePaths: [fieldPath(issue.path, issue.found, "estimate")]
+    };
+  }
+});
+var issueAssignee = defineCheck({
+  id: "linear.issue-assignee",
+  description: "Resolves the issue, then its assignee, and matches the given reference against that user's email, name OR displayName \u2014 every spelling the legacy rule accepted. An UNASSIGNED issue is a real FAIL. Declared with no shipped corpus user, carrying a legacy capability forward. This is the check whose `subject` earns its keep: an email reference is destroyed by a team's `PII_PATTERNS`, which the twin's own redactor has no equivalent of, so without the declaration the criterion would silently be unable to fire.",
+  template: 'Issue "{title}" in `{team}` is assigned to `{user}`',
+  params: { title: issueTitle, team: teamKey, user: userRef },
+  substrate: "final",
+  polarity: () => "positive",
+  subject: ({ user }) => user,
+  vacuityMutant: (args) => ({ ...args, user: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ title }) => ({
+    // The issue resolves in both worlds; only the assignee moves.
+    passing: finalWorld(linearState([issueRow(title, { assigneeId: "user_dev" })])),
+    failing: finalWorld(linearState([issueRow(title)]))
+  }),
+  evaluate({ title, team, user }, { final }) {
+    const issue = resolveIssue(final, team, title);
+    if ("missing" in issue)
+      return unresolved(issue);
+    const labels = resolveUserLabels(final, issue.found.assigneeId);
+    const assignment = [fieldPath(issue.path, issue.found, "assigneeId")];
+    if (labels.length === 0) {
+      return { passed: false, reason: "issue has no assignee", evidenceStatePaths: assignment };
+    }
+    if (final.users != null)
+      assignment.push(USERS_PATH);
+    return {
+      passed: labels.some((l) => l.toLowerCase() === user.toLowerCase()),
+      // Safe to quote: `user` is this check's declared subject.
+      reason: `issue is assigned to \`${labels[0]}\` (wanted \`${user}\`)`,
+      evidenceStatePaths: assignment
+    };
+  }
+});
+
+// ../packages/twin-linear/dist/src/check-tape.js
+var noUnsupportedEndpoint = defineCheck({
+  id: "linear.no-unsupported-endpoint",
+  description: 'Scans the recorded call tape for any request the twin answered with fidelity "unsupported" \u2014 a route it does not implement, answered 501. It asserts nothing about whether the run SUCCEEDED, and nothing about calls that were merely rejected: a 404 or a 422 from a route the twin does implement is a semantic answer and passes. The tape is scoped to this twin by the engine before the check sees it, so an unsupported call to a different twin in a multi-twin session cannot fail it.',
+  template: "No unsupported endpoint was called",
+  params: {},
+  substrate: "tape",
+  // A prohibition. Nothing is required to happen; only the examinee reaching
+  // for an unimplemented route can break it.
+  polarity: () => "negative",
+  // No caller-supplied literal is hunted for in any substrate, so there is
+  // nothing a redactor could silently delete out from under this check.
+  subject: () => null,
+  // Ledgered. No slots, so the sentence carries no literal to falsify — the
+  // trigger is a fidelity stamp on the tape, which no mutation of the criterion
+  // text can reach.
+  vacuityMutant: () => null,
+  discriminatingWorlds: () => ({
+    passing: tapeWorld([
+      {
+        twin: "linear",
+        method: "POST",
+        path: "/graphql",
+        status: 200,
+        fidelity: "semantic",
+        event_id: "evt_ok"
+      }
+    ]),
+    failing: tapeWorld([
+      {
+        twin: "linear",
+        method: "POST",
+        path: "/graphql",
+        status: 501,
+        fidelity: "unsupported",
+        event_id: "evt_bad"
+      }
+    ])
+  }),
+  evaluate(_args, { tape }) {
+    if (tape === null)
+      return { passed: false, reason: "tape_missing", status: "skipped" };
+    const unsupported = tape.filter((event) => event.fidelity === "unsupported");
+    if (unsupported.length === 0) {
+      return {
+        passed: true,
+        reason: `no unsupported endpoint was called (${tape.length} call(s) inspected)`
+      };
+    }
+    const evidenceEventIds = unsupported.map((event) => event.event_id).filter((id) => typeof id === "string" && id !== "");
+    return {
+      passed: false,
+      reason: `${unsupported.length} unsupported call(s): ${unsupported.map((e) => `${e.method ?? "?"} ${e.path ?? "?"}`).join(", ")}`,
+      ...evidenceEventIds.length > 0 ? { evidenceEventIds } : {}
+    };
+  }
+});
+
+// ../packages/twin-linear/dist/src/checks.js
+var LINEAR_CHECKS = [
+  issueExists,
+  issueState,
+  issueHasLabel,
+  issueEstimate,
+  issueAssignee,
+  issueCommentContains,
+  issueThreadedReply,
+  // Last, because the listing order runs from the assertion an author reaches
+  // for first to the ones a specialised task needs — and this is the only one
+  // that reads the run rather than the world it left behind.
+  noUnsupportedEndpoint
+];
+
+export { LINEAR_CHECKS };