@h-rig/standard-plugin 0.0.6-alpha.132 → 0.0.6-alpha.134

package/dist/src/drift/plugin.js

@@ -0,0 +1,421 @@
+// @bun
+// packages/standard-plugin/src/drift/plugin.ts
+import { Schema } from "effect";
+import { StageMutation as StageMutationSchema } from "@rig/contracts";
+
+// packages/standard-plugin/src/drift/detect.ts
+import { existsSync } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { basename, extname, relative, resolve } from "path";
+
+// packages/standard-plugin/src/drift/extract-refs.ts
+var INLINE_CODE = /`([^`\n]+)`/g;
+var MARKDOWN_LINK = /\[[^\]]+\]\(([^)\s]+)\)/g;
+var SYMBOL_REF = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$/;
+var PATH_REF = /^(?:\.\.?\/)?(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+$|^[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|mdx|css|scss|html|yml|yaml|toml|rs|go|py|rb|java|kt|swift|c|cc|cpp|h|hpp)$/;
+function stripFenceLines(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  let fenced = false;
+  return lines.map((line) => {
+    if (/^\s*(```|~~~)/.test(line)) {
+      fenced = !fenced;
+      return "";
+    }
+    return fenced ? "" : line;
+  });
+}
+function normalizeToken(raw) {
+  return raw.trim().replace(/^['"]|['"]$/g, "").replace(/[),.;:]+$/g, "").replace(/#L\d+(?:-L\d+)?$/i, "");
+}
+function classifyReference(raw) {
+  if (raw.startsWith("@"))
+    return null;
+  if (PATH_REF.test(raw))
+    return "path";
+  if (SYMBOL_REF.test(raw))
+    return "symbol";
+  return null;
+}
+function pushReference(refs, seen, raw, line) {
+  const value = normalizeToken(raw);
+  if (!value)
+    return;
+  const kind = classifyReference(value);
+  if (!kind)
+    return;
+  const key = `${kind}:${value}:${line}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  refs.push({ kind, value, line });
+}
+function extractDriftReferences(markdown) {
+  const refs = [];
+  const seen = new Set;
+  const lines = stripFenceLines(markdown);
+  for (const [index, line] of lines.entries()) {
+    const lineNumber = index + 1;
+    for (const match of line.matchAll(INLINE_CODE)) {
+      pushReference(refs, seen, match[1] ?? "", lineNumber);
+    }
+    for (const match of line.matchAll(MARKDOWN_LINK)) {
+      pushReference(refs, seen, match[1] ?? "", lineNumber);
+    }
+  }
+  return refs;
+}
+
+// packages/standard-plugin/src/drift/git-adapter.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function processError(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function lineCount(output) {
+  const trimmed = output.trim();
+  return trimmed ? trimmed.split(/\r?\n/).length : 0;
+}
+function makeDriftGit(projectRoot) {
+  async function git(args) {
+    const result = await execFileAsync("git", [...args], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return String(result.stdout);
+  }
+  async function grepCountAt(symbolOrPath, commit) {
+    try {
+      return lineCount(await git(["grep", "-F", "-n", "-e", symbolOrPath, commit, "--"]));
+    } catch (error) {
+      const detail = processError(error);
+      if (detail?.code === 1)
+        return 0;
+      throw error;
+    }
+  }
+  return {
+    async lastCommitTouching(path) {
+      const commit = (await git(["log", "-n", "1", "--format=%H", "--", path])).trim();
+      return commit || "HEAD";
+    },
+    async grepCount(symbolOrPath) {
+      return grepCountAt(symbolOrPath, "HEAD");
+    },
+    async grepCountAtCommit(symbolOrPath, commit) {
+      return grepCountAt(symbolOrPath, commit);
+    },
+    async wasRenamed(symbolOrPath, sinceCommit) {
+      if (!symbolOrPath.includes("/") && !symbolOrPath.includes("."))
+        return false;
+      try {
+        const output = await git(["log", "--name-status", "--format=", `${sinceCommit}..HEAD`]);
+        return output.split(/\r?\n/).some((line) => {
+          const match = line.match(/^R\d*\s+(.+?)\s+(.+)$/);
+          return Boolean(match && (match[1] === symbolOrPath || match[2] === symbolOrPath));
+        });
+      } catch (error) {
+        const detail = processError(error);
+        if (detail?.code === 128)
+          return false;
+        throw error;
+      }
+    }
+  };
+}
+
+// packages/standard-plugin/src/drift/detect.ts
+var DEFAULT_IGNORED_DIRS = {
+  ".git": true,
+  node_modules: true,
+  dist: true,
+  build: true,
+  coverage: true,
+  ".next": true,
+  vendor: true
+};
+var SOURCE_EXTENSIONS = {
+  ".ts": true,
+  ".tsx": true,
+  ".js": true,
+  ".jsx": true,
+  ".mjs": true,
+  ".cjs": true,
+  ".rs": true,
+  ".go": true,
+  ".py": true,
+  ".rb": true,
+  ".java": true,
+  ".kt": true,
+  ".swift": true,
+  ".c": true,
+  ".cc": true,
+  ".cpp": true,
+  ".h": true,
+  ".hpp": true,
+  ".json": true,
+  ".toml": true,
+  ".yml": true,
+  ".yaml": true
+};
+function globLikeMatch(path, pattern) {
+  if (pattern === path)
+    return true;
+  if (pattern.startsWith("**/*"))
+    return path.endsWith(pattern.slice(4));
+  if (pattern.endsWith("/**"))
+    return path.startsWith(pattern.slice(0, -3));
+  if (pattern.includes("*")) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`).test(path);
+  }
+  return path.startsWith(pattern);
+}
+function isDefaultDoc(path) {
+  const lower = basename(path).toLowerCase();
+  return (path.endsWith(".md") || path.endsWith(".mdx")) && !lower.startsWith("changelog") && !lower.includes("generated");
+}
+function isIgnored(path, patterns) {
+  return (patterns ?? []).some((pattern) => globLikeMatch(path, pattern));
+}
+async function collectFiles(root, options) {
+  const files = [];
+  async function visit(dir) {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && DEFAULT_IGNORED_DIRS[entry.name])
+        continue;
+      const absolute = resolve(dir, entry.name);
+      const rel = relative(root, absolute).replace(/\\/g, "/");
+      if (isIgnored(rel, options.ignore))
+        continue;
+      if (entry.isDirectory()) {
+        await visit(absolute);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      if (options.docs) {
+        const matchesConfigured = options.patterns && options.patterns.length > 0 ? options.patterns.some((pattern) => globLikeMatch(rel, pattern)) : isDefaultDoc(rel);
+        if (matchesConfigured)
+          files.push(rel);
+        continue;
+      }
+      if (SOURCE_EXTENSIONS[extname(entry.name)])
+        files.push(rel);
+    }
+  }
+  await visit(root);
+  return files.sort();
+}
+async function sourceReferenceCount(projectRoot, reference, docPath) {
+  if (reference.kind === "path")
+    return existsSync(resolve(projectRoot, reference.value)) ? 1 : 0;
+  let count = 0;
+  const sourceFiles = await collectFiles(projectRoot, { docs: false });
+  for (const sourceFile of sourceFiles) {
+    if (sourceFile === docPath)
+      continue;
+    const text = await readFile(resolve(projectRoot, sourceFile), "utf8").catch(() => "");
+    if (text.includes(reference.value))
+      count += 1;
+  }
+  return count;
+}
+function deletedReferenceFinding(docPath, reference) {
+  return {
+    kind: "deleted-reference",
+    docPath,
+    line: reference.line,
+    reference: reference.value,
+    detail: `Documented reference "${reference.value}" no longer exists in the source tree.`,
+    confidence: "high"
+  };
+}
+function staleAnchorFinding(docPath, reference) {
+  return {
+    kind: "stale-anchor",
+    docPath,
+    line: reference.line,
+    reference: reference.value,
+    detail: `Documented path "${reference.value}" changed after this doc was last updated.`,
+    confidence: "medium"
+  };
+}
+async function detectDeletedReferences(projectRoot, docPath, git = makeDriftGit(projectRoot)) {
+  const markdown = await readFile(resolve(projectRoot, docPath), "utf8");
+  const docCommit = await git.lastCommitTouching(docPath);
+  const findings = [];
+  for (const reference of extractDriftReferences(markdown)) {
+    if (await sourceReferenceCount(projectRoot, reference, docPath) > 0)
+      continue;
+    if (await git.wasRenamed(reference.value, docCommit))
+      continue;
+    findings.push(deletedReferenceFinding(docPath, reference));
+  }
+  return findings;
+}
+async function detectStaleAnchors(projectRoot, docPath, git = makeDriftGit(projectRoot)) {
+  const markdown = await readFile(resolve(projectRoot, docPath), "utf8");
+  const docCommit = await git.lastCommitTouching(docPath);
+  const findings = [];
+  for (const reference of extractDriftReferences(markdown).filter((ref) => ref.kind === "path")) {
+    if (!existsSync(resolve(projectRoot, reference.value)))
+      continue;
+    const sourceStat = await stat(resolve(projectRoot, reference.value)).catch(() => null);
+    if (!sourceStat?.isFile())
+      continue;
+    const sourceCommit = await git.lastCommitTouching(reference.value);
+    if (sourceCommit !== docCommit && !await git.wasRenamed(reference.value, docCommit)) {
+      findings.push(staleAnchorFinding(docPath, reference));
+    }
+  }
+  return findings;
+}
+async function detectDrift(options) {
+  const git = options.git ?? makeDriftGit(options.projectRoot);
+  const docs = await collectFiles(options.projectRoot, {
+    docs: true,
+    ...options.docsGlobs !== undefined ? { patterns: options.docsGlobs } : {},
+    ...options.ignoreGlobs !== undefined ? { ignore: options.ignoreGlobs } : {}
+  });
+  const findings = [];
+  let degraded = false;
+  for (const docPath of docs) {
+    try {
+      findings.push(...await detectDeletedReferences(options.projectRoot, docPath, git));
+      findings.push(...await detectStaleAnchors(options.projectRoot, docPath, git));
+    } catch {
+      degraded = true;
+    }
+  }
+  return {
+    generatedAt: new Date().toISOString(),
+    scanned: docs.length,
+    degraded,
+    findings
+  };
+}
+
+// packages/standard-plugin/src/drift/plugin.ts
+var DOCS_DRIFT_VALIDATOR_ID = "std:docs-drift";
+var DOCS_DRIFT_CLI_ID = "std:drift";
+var DOCS_DRIFT_STAGE_ID = "docs-drift";
+var DOCS_DRIFT_VALIDATOR = {
+  id: DOCS_DRIFT_VALIDATOR_ID,
+  category: "regression",
+  description: "Detect documentation references that drifted from the source tree."
+};
+var DOCS_DRIFT_STAGE_MUTATION = Schema.decodeUnknownSync(StageMutationSchema)({
+  op: "insert",
+  stage: {
+    id: DOCS_DRIFT_STAGE_ID,
+    kind: "gate",
+    before: ["merge-gate"],
+    after: ["verify"]
+  },
+  contributedBy: DOCS_DRIFT_STAGE_ID
+});
+var DOCS_DRIFT_CLI_COMMAND = `bun -e 'import { runDriftCli } from "@rig/standard-plugin/drift"; process.exitCode = await runDriftCli(process.argv.slice(1), { projectRoot: process.cwd() });' --`;
+function highConfidenceDriftFindings(report) {
+  return report.findings.filter((finding) => finding.confidence === "high");
+}
+function driftGateResult(report, mode = "enforce") {
+  const high = highConfidenceDriftFindings(report);
+  if (mode === "enforce" && high.length > 0) {
+    return { kind: "block", reason: `${high.length} high-confidence documentation drift finding(s).` };
+  }
+  return { kind: "allow" };
+}
+async function runDocsDriftValidation(options) {
+  const report = await detectDrift(options);
+  const high = highConfidenceDriftFindings(report);
+  const passed = options.failOnDrift ? high.length === 0 : true;
+  const findingWord = report.findings.length === 1 ? "finding" : "findings";
+  return {
+    id: DOCS_DRIFT_VALIDATOR_ID,
+    passed,
+    summary: `docs drift scanned ${report.scanned} doc(s), ${report.findings.length} ${findingWord}`,
+    details: JSON.stringify(report)
+  };
+}
+function createDocsDriftValidator(options = {}) {
+  return {
+    ...DOCS_DRIFT_VALIDATOR,
+    async run(ctx) {
+      return runDocsDriftValidation({
+        projectRoot: ctx.workspaceRoot,
+        ...options.docsGlobs !== undefined ? { docsGlobs: options.docsGlobs } : {},
+        ...options.ignoreGlobs !== undefined ? { ignoreGlobs: options.ignoreGlobs } : {},
+        ...options.failOnDrift !== undefined ? { failOnDrift: options.failOnDrift } : {}
+      });
+    }
+  };
+}
+function takeOptionValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value)
+    throw new Error(`${flag} requires a value`);
+  return value;
+}
+async function runDriftCli(args, options = {}) {
+  const docsGlobs = [];
+  const ignoreGlobs = [];
+  let json = false;
+  let failOnDrift = false;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--fail-on-drift") {
+      failOnDrift = true;
+      continue;
+    }
+    if (arg === "--docs") {
+      docsGlobs.push(takeOptionValue(args, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg === "--ignore") {
+      ignoreGlobs.push(takeOptionValue(args, index, arg));
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown rig drift argument: ${arg}`);
+  }
+  const report = await detectDrift({
+    projectRoot: options.projectRoot ?? process.cwd(),
+    ...docsGlobs.length > 0 ? { docsGlobs } : {},
+    ...ignoreGlobs.length > 0 ? { ignoreGlobs } : {}
+  });
+  const write = options.write ?? ((message) => console.log(message));
+  if (json) {
+    write(JSON.stringify(report));
+  } else {
+    write(`Scanned ${report.scanned} doc(s); ${report.findings.length} drift finding(s).`);
+    for (const finding of report.findings) {
+      write(`${finding.confidence.toUpperCase()} ${finding.kind} ${finding.docPath}${finding.line ? `:${finding.line}` : ""} ${finding.reference ?? ""} \u2014 ${finding.detail}`);
+    }
+  }
+  const high = highConfidenceDriftFindings(report);
+  if (failOnDrift && high.length > 0) {
+    options.writeError?.(`${high.length} high-confidence drift finding(s).`);
+    return 2;
+  }
+  return 0;
+}
+export {
+  runDriftCli,
+  runDocsDriftValidation,
+  highConfidenceDriftFindings,
+  driftGateResult,
+  createDocsDriftValidator,
+  DOCS_DRIFT_VALIDATOR_ID,
+  DOCS_DRIFT_VALIDATOR,
+  DOCS_DRIFT_STAGE_MUTATION,
+  DOCS_DRIFT_STAGE_ID,
+  DOCS_DRIFT_CLI_ID,
+  DOCS_DRIFT_CLI_COMMAND
+};

package/dist/src/github-issues-source.d.ts

@@ -47,6 +47,8 @@ export interface GitHubIssuesOptions {
     }) => void;
     /** Optional GitHub Projects (v2) status-field sync mapped from Rig task status. */
     projects?: GitHubProjectsOptions;
+    /** Opt into GitHub-native issue dependency reads; body parsing remains the fallback. */
+    useNativeDependencies?: boolean;
 }
 export interface GitHubIssueCreateInput {
     title: string;

package/dist/src/github-issues-source.js

@@ -89,17 +89,42 @@ function statusFor(issue) {
     return "cancelled";
   return "open";
 }
+function parseIssueRefs(raw) {
+  return raw.split(",").map((s) => s.trim()).map((s) => s.replace(/^#/, "").match(/^(\d+)/)?.[1] ?? "").filter((s) => s.length > 0);
+}
+function parseMetadataList(body, key) {
+  const block = body.match(/<!-- rig:metadata:start -->\s*([\s\S]*?)\s*<!-- rig:metadata:end -->/);
+  if (!block)
+    return [];
+  const lines = block[1].split(/\r?\n/);
+  const values = [];
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index];
+    const sameLine = line.match(new RegExp(`^${key}:\\s*(.+)$`, "i"));
+    if (sameLine) {
+      values.push(...parseIssueRefs(sameLine[1]));
+      continue;
+    }
+    if (!new RegExp(`^${key}:\\s*$`, "i").test(line))
+      continue;
+    for (let cursor = index + 1;cursor < lines.length; cursor += 1) {
+      const item = lines[cursor].match(/^\s*-\s*(.+)$/);
+      if (!item)
+        break;
+      values.push(...parseIssueRefs(item[1]));
+    }
+  }
+  return [...new Set(values)];
+}
 function parseDeps(body) {
   const match = body.match(/^depends-on:\s*([^\n]+)/im);
-  if (!match)
-    return [];
-  return match[1].split(",").map((s) => s.trim()).map((s) => s.replace(/^#/, "").match(/^(\d+)/)?.[1] ?? "").filter((s) => s.length > 0);
+  const bodyRefs = match ? parseIssueRefs(match[1]) : [];
+  return [...new Set([...bodyRefs, ...parseMetadataList(body, "depends-on")])];
 }
 function parseParents(body) {
   const match = body.match(/^parents?:\s*([^\n]+)/im);
-  if (!match)
-    return [];
-  return match[1].split(",").map((s) => s.trim()).map((s) => s.replace(/^#/, "").match(/^(\d+)/)?.[1] ?? "").filter((s) => s.length > 0);
+  const bodyRefs = match ? parseIssueRefs(match[1]) : [];
+  return [...new Set([...bodyRefs, ...parseMetadataList(body, "parents")])];
 }
 function issueTypeFor(issue) {
   const labels = labelNamesFor(issue);
@@ -110,7 +135,7 @@ function issueTypeFor(issue) {
     return "epic";
   return "task";
 }
-function issueToTask(issue, repo) {
+function issueToTask(issue, repo, nativeDependencies) {
   const labelNames = labelNamesFor(issue);
   const scope = labelNames.filter((l) => l.startsWith("scope:")).map((l) => l.slice("scope:".length));
   const roleLabel = labelNames.find((l) => l.startsWith("role:"));
@@ -118,10 +143,12 @@ function issueToTask(issue, repo) {
   const validators = labelNames.filter((l) => l.startsWith("validator:")).map((l) => l.slice("validator:".length));
   const body = issue.body ?? "";
   const issueNodeId = issue.id ?? issue.nodeId ?? issue.node_id;
+  const parsedDeps = parseDeps(body);
+  const deps = nativeDependencies?.deps ? [...new Set([...parsedDeps, ...nativeDependencies.deps])] : parsedDeps;
   return {
     id: String(issue.number),
     ...typeof issueNodeId === "string" && issueNodeId.trim() ? { issueNodeId: issueNodeId.trim() } : {},
-    deps: parseDeps(body),
+    deps,
     status: statusFor(issue),
     title: issue.title,
     body,
@@ -133,6 +160,7 @@ function issueToTask(issue, repo) {
     sourceIssueId: `${repo}#${issue.number}`,
     parentChildDeps: parseParents(body),
     labels: labelNames,
+    ...nativeDependencies?.degraded ? { nativeDependenciesDegraded: true, nativeDependenciesError: nativeDependencies.degraded } : {},
     raw: issue
   };
 }
@@ -306,6 +334,86 @@ function ghGraphQLFetch(bin, spawnFn, extraEnv, timeoutMs) {
     return asProjectRecord(response)?.data ?? response;
   };
 }
+function issueNodeIdFor(issue) {
+  const id = issue.id ?? issue.nodeId ?? issue.node_id;
+  return typeof id === "string" && id.trim().length > 0 ? id.trim() : null;
+}
+function nativeIssueDependencyRef(value, currentRepo) {
+  const record = asProjectRecord(value);
+  const number = typeof record?.number === "number" ? String(record.number) : projectString(record?.number);
+  if (!number)
+    return null;
+  const repository = asProjectRecord(record?.repository);
+  const owner = projectString(asProjectRecord(repository?.owner)?.login);
+  const name = projectString(repository?.name);
+  if (!owner || !name || `${owner}/${name}` === currentRepo)
+    return number;
+  return `${owner}/${name}#${number}`;
+}
+function nativeDependencyRefsFrom(data, currentRepo) {
+  const issue = asProjectRecord(asProjectRecord(data)?.node);
+  const blockedBy = asProjectRecord(issue?.blockedBy);
+  const nodes = Array.isArray(blockedBy?.nodes) ? blockedBy.nodes : [];
+  return [...new Set(nodes.flatMap((node) => {
+    const ref = nativeIssueDependencyRef(node, currentRepo);
+    return ref ? [ref] : [];
+  }))];
+}
+async function readNativeDependenciesForIssue(input) {
+  const issueId = issueNodeIdFor(input.issue);
+  if (!issueId)
+    return { deps: [], degraded: "GitHub issue node id is unavailable." };
+  const query = `
+    query RigIssueNativeDependencies($issueId: ID!) {
+      node(id: $issueId) {
+        ... on Issue {
+          blockedBy(first: 100) {
+            nodes {
+              number
+              repository { name owner { login } }
+            }
+          }
+        }
+      }
+    }
+  `;
+  try {
+    return {
+      deps: nativeDependencyRefsFrom(await input.fetchGraphQL(query, { issueId }, "gh-cli"), input.repo)
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { deps: [], degraded: detail };
+  }
+}
+function formatIssueReference(ref) {
+  const clean = ref.trim().replace(/^#/, "");
+  return /^\d+$/.test(clean) ? `#${clean}` : clean;
+}
+function appendReferenceLines(body, deps, parents) {
+  const lines = [];
+  const cleanDeps = (deps ?? []).map(formatIssueReference).filter((ref) => ref.length > 0);
+  const cleanParents = (parents ?? []).map(formatIssueReference).filter((ref) => ref.length > 0);
+  if (cleanDeps.length > 0)
+    lines.push(`depends-on: ${cleanDeps.join(", ")}`);
+  if (cleanParents.length > 0)
+    lines.push(`parents: ${cleanParents.join(", ")}`);
+  if (lines.length === 0)
+    return body;
+  return body.trim().length > 0 ? `${body.trimEnd()}
+
+${lines.join(`
+`)}` : lines.join(`
+`);
+}
+function bodyForCreatedTask(input) {
+  const metadata = { ...input.metadata ?? {} };
+  if (input.deps && input.deps.length > 0)
+    metadata["depends-on"] = input.deps.map(formatIssueReference);
+  if (input.parents && input.parents.length > 0)
+    metadata.parents = input.parents.map(formatIssueReference);
+  return updateRigOwnedMetadataBlock(appendReferenceLines(input.body, input.deps, input.parents), metadata);
+}
 function projectStatusFieldFrom(data, projectId) {
   const fields = asProjectRecord(asProjectRecord(asProjectRecord(data)?.node)?.fields)?.nodes;
   for (const node of Array.isArray(fields) ? fields : []) {
@@ -641,6 +749,16 @@ function createGitHubIssuesTaskSource(opts) {
   const timeoutMs = Math.max(1000, Math.trunc(opts.timeoutMs ?? DEFAULT_GH_TIMEOUT_MS));
   const listLimit = Math.max(1, Math.trunc(opts.listLimit ?? DEFAULT_GITHUB_ISSUE_LIST_LIMIT));
   const issueUpdates = issueUpdatesMode(opts.issueUpdates);
+  async function issueToTaskWithOptionalNativeDependencies(issue, env) {
+    if (!opts.useNativeDependencies)
+      return issueToTask(issue, repo);
+    const nativeDependencies = await readNativeDependenciesForIssue({
+      issue,
+      repo,
+      fetchGraphQL: ghGraphQLFetch(bin, spawnFn, env, timeoutMs)
+    });
+    return issueToTask(issue, repo, nativeDependencies);
+  }
   return {
     id: "std:github-issues",
     kind: "github-issues",
@@ -667,7 +785,7 @@ function createGitHubIssuesTaskSource(opts) {
         throw new Error(`GitHub issue list for ${repo} reached the configured limit (${listLimit}); refusing to silently truncate matching issues. Increase taskSource.options.listLimit or narrow labels/state/assignee.`);
       }
       const issues = rawIssues.filter((issue) => !issue.pull_request);
-      return issues.map((i) => issueToTask(i, repo));
+      return Promise.all(issues.map((issue) => issueToTaskWithOptionalNativeDependencies(issue, env)));
     },
     async get(id) {
       const env = await resolveCredentialEnv(opts, "selected-repo");
@@ -684,12 +802,12 @@ function createGitHubIssuesTaskSource(opts) {
         ], spawnFn, env, timeoutMs);
       } catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
-        if (/could not resolve to (an? )?(issue|pullrequest)|no issues? (found|matched)|404 not found|gh: not found/i.test(detail)) {
+        if (/could not resolve to (an? )?(issue|pullrequest)|no issues? (found|matched)|404 not found|gh: not found|gh issue view\b[\s\S]*failed \(exit \d+\): not found\b/i.test(detail)) {
           return;
         }
         throw new Error(`Failed to read task ${id} from GitHub repo ${repo}: ${detail}`);
       }
-      return issueToTask(issue, repo);
+      return issueToTaskWithOptionalNativeDependencies(issue, env);
     },
     async updateStatus(id, status) {
       const env = await resolveCredentialEnv(opts, "selected-repo");
@@ -713,6 +831,7 @@ function createGitHubIssuesTaskSource(opts) {
     },
     async createIssue(input) {
       const env = await resolveCredentialEnv(opts, "selected-repo");
+      const body = input.body ?? "";
       const args = [
         "api",
         "-X",
@@ -721,12 +840,31 @@ function createGitHubIssuesTaskSource(opts) {
         "-f",
         `title=${input.title}`,
         "-f",
-        `body=${input.body ?? ""}`,
+        `body=${body}`,
         ...(input.labels ?? []).flatMap((label) => ["-f", `labels[]=${label}`])
       ];
       const issue = runGh(bin, args, spawnFn, env, timeoutMs);
       notifyTaskChanged(opts.onTaskChanged, repo, String(issue.number));
-      return issueToTask(issue, repo);
+      return issueToTask({ ...issue, body: issue.body ?? body }, repo);
+    },
+    async create(input) {
+      const env = await resolveCredentialEnv(opts, "selected-repo");
+      const body = bodyForCreatedTask(input);
+      const args = [
+        "api",
+        "-X",
+        "POST",
+        `repos/${repo}/issues`,
+        "-f",
+        `title=${input.title}`,
+        "-f",
+        `body=${body}`,
+        "-f",
+        "labels[]=rig:generated"
+      ];
+      const issue = runGh(bin, args, spawnFn, env, timeoutMs);
+      notifyTaskChanged(opts.onTaskChanged, repo, String(issue.number));
+      return issueToTask({ ...issue, body: issue.body ?? body }, repo);
     },
     async getIssueBody(id) {
       const env = await resolveCredentialEnv(opts, "selected-repo");