@h-rig/standard-plugin 0.0.6-alpha.155 → 0.0.6-alpha.156

package/dist/src/drift/plugin.d.ts

@@ -1,53 +0,0 @@
-import type { DriftFinding, DriftReport, StageResult, StageRun } from "@rig/contracts";
-import type { RegisteredValidator, RuntimeCliCommand, RuntimeCliContext, ValidatorResult } from "@rig/core/config";
-import { type DriftDetectOptions } from "./detect";
-export { DOCS_DRIFT_CAPABILITY_ID, DOCS_DRIFT_CLI_COMMAND, DOCS_DRIFT_CLI_ID, DOCS_DRIFT_STAGE_ID, DOCS_DRIFT_STAGE_MUTATION, DOCS_DRIFT_VALIDATOR, DOCS_DRIFT_VALIDATOR_ID, type DocsDriftPluginOptions, } from "./metadata";
-import { type DocsDriftPluginOptions } from "./metadata";
-export declare function highConfidenceDriftFindings(report: DriftReport): readonly DriftFinding[];
-export declare function driftGateResult(report: DriftReport, mode?: "observe" | "enforce"): StageResult;
-/**
- * Executable for the `docs-drift` pre-merge gate stage (inserted by
- * DOCS_DRIFT_STAGE_MUTATION before `merge-gate`). Reads the project root from the
- * stage context metadata, runs deletion-survival drift detection, and blocks the
- * pipeline on high-confidence drift when enforcing (`failOnDrift`), else observes.
- */
-export declare function createDocsDriftGateStage(options?: DocsDriftPluginOptions): StageRun;
-export declare function runDocsDriftValidation(options: DriftDetectOptions & {
-    failOnDrift?: boolean;
-}): Promise<ValidatorResult>;
-export declare function createDocsDriftValidator(options?: DocsDriftPluginOptions): RegisteredValidator;
-export interface RunDriftCliOptions {
-    readonly projectRoot?: string;
-    readonly write?: (message: string) => void;
-    readonly writeError?: (message: string) => void;
-}
-export declare function executeDrift(context: RuntimeCliContext, args: readonly string[], options?: DocsDriftPluginOptions): Promise<{
-    ok: boolean;
-    group: string;
-    command: string;
-    details: {
-        report: {
-            readonly degraded: boolean;
-            readonly generatedAt: string;
-            readonly findings: readonly {
-                readonly kind: "deleted-reference" | "stale-anchor" | "semantic-mismatch" | "issue-mismatch";
-                readonly detail: string;
-                readonly line: number | null;
-                readonly reference: string | null;
-                readonly docPath: string;
-                readonly confidence: "high" | "medium" | "low";
-            }[];
-            readonly scanned: number;
-        };
-        summary: {
-            total: number;
-            highConfidence: number;
-            degraded: boolean;
-        };
-        failOnDrift: boolean;
-        failed: boolean;
-    };
-}>;
-export declare function createDocsDriftRuntimeCliCommand(options?: DocsDriftPluginOptions): RuntimeCliCommand;
-export declare const DOCS_DRIFT_RUNTIME_CLI_COMMAND: RuntimeCliCommand;
-export declare function runDriftCli(args: readonly string[], options?: RunDriftCliOptions): Promise<number>;

package/dist/src/drift/plugin.js

@@ -1,509 +0,0 @@
-// @bun
-// 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/metadata.ts
-import { Schema } from "effect";
-import { StageMutation as StageMutationSchema } from "@rig/contracts";
-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_CAPABILITY_ID = "std:docs-drift-capability";
-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: ["open-pr"],
-    priority: 0,
-    protected: false
-  },
-  contributedBy: DOCS_DRIFT_STAGE_ID
-});
-var DOCS_DRIFT_CLI_COMMAND = "rig drift [--docs <csv>] [--ignore <csv>] [--fail-on-drift] [--json]";
-// packages/standard-plugin/src/drift/plugin.ts
-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" };
-}
-function createDocsDriftGateStage(options = {}) {
-  return async (ctx) => {
-    const projectRoot = typeof ctx.metadata?.projectRoot === "string" ? ctx.metadata.projectRoot : process.cwd();
-    const report = await detectDrift({
-      projectRoot,
-      ...options.docsGlobs !== undefined ? { docsGlobs: options.docsGlobs } : {},
-      ...options.ignoreGlobs !== undefined ? { ignoreGlobs: options.ignoreGlobs } : {}
-    });
-    return driftGateResult(report, options.failOnDrift ? "enforce" : "observe");
-  };
-}
-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;
-}
-function takeFlag(args, flag) {
-  const rest = [...args];
-  const index = rest.indexOf(flag);
-  if (index < 0)
-    return { value: false, rest };
-  rest.splice(index, 1);
-  return { value: true, rest };
-}
-function takeOption(args, flag) {
-  const rest = [...args];
-  const index = rest.indexOf(flag);
-  if (index < 0)
-    return { rest };
-  const value = rest[index + 1];
-  if (!value || value.startsWith("-"))
-    throw new Error(`${flag} requires a value.`);
-  rest.splice(index, 2);
-  return { value, rest };
-}
-function requireNoExtraArgs(args, usage) {
-  if (args.length > 0)
-    throw new Error(`Unexpected argument: ${args[0]}
-Usage: ${usage}`);
-}
-function parseCsv(value) {
-  return value?.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0) ?? [];
-}
-function driftSummary(report) {
-  const highConfidence = highConfidenceDriftFindings(report).length;
-  return { total: report.findings.length, highConfidence, degraded: report.degraded };
-}
-async function executeDrift(context, args, options = {}) {
-  const json = takeFlag(args, "--json");
-  const docs = takeOption(json.rest, "--docs");
-  const ignore = takeOption(docs.rest, "--ignore");
-  const failOnDrift = takeFlag(ignore.rest, "--fail-on-drift");
-  requireNoExtraArgs(failOnDrift.rest, "rig drift [--docs <csv>] [--ignore <csv>] [--fail-on-drift] [--json]");
-  const docsGlobs = parseCsv(docs.value);
-  const ignoreGlobs = parseCsv(ignore.value);
-  const effectiveDocsGlobs = docsGlobs.length > 0 ? docsGlobs : options.docsGlobs;
-  const effectiveIgnoreGlobs = ignoreGlobs.length > 0 ? ignoreGlobs : options.ignoreGlobs;
-  const effectiveFailOnDrift = failOnDrift.value || options.failOnDrift === true;
-  const report = await detectDrift({
-    projectRoot: context.projectRoot,
-    ...effectiveDocsGlobs !== undefined ? { docsGlobs: effectiveDocsGlobs } : {},
-    ...effectiveIgnoreGlobs !== undefined ? { ignoreGlobs: effectiveIgnoreGlobs } : {}
-  });
-  const failed = effectiveFailOnDrift && highConfidenceDriftFindings(report).length > 0;
-  const details = { report, summary: driftSummary(report), failOnDrift: effectiveFailOnDrift, failed };
-  if (context.outputMode === "text") {
-    if (json.value)
-      console.log(JSON.stringify(details, null, 2));
-    else
-      console.log(report.findings.length === 0 ? `No drift findings across ${report.scanned} documents.` : report.findings.map((finding) => `${finding.docPath}:${finding.line ?? "?"}	${finding.kind}	${finding.confidence}	${finding.detail}`).join(`
-`));
-  }
-  return { ok: !failed, group: "drift", command: "scan", details };
-}
-function createDocsDriftRuntimeCliCommand(options = {}) {
-  return {
-    id: DOCS_DRIFT_CLI_ID,
-    family: "drift",
-    command: DOCS_DRIFT_CLI_COMMAND,
-    description: "Scan documentation for stale code references.",
-    usage: DOCS_DRIFT_CLI_COMMAND,
-    projectRequired: true,
-    run: (context, args) => executeDrift(context, args, options)
-  };
-}
-var DOCS_DRIFT_RUNTIME_CLI_COMMAND = createDocsDriftRuntimeCliCommand();
-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,
-  executeDrift,
-  driftGateResult,
-  createDocsDriftValidator,
-  createDocsDriftRuntimeCliCommand,
-  createDocsDriftGateStage,
-  DOCS_DRIFT_VALIDATOR_ID,
-  DOCS_DRIFT_VALIDATOR,
-  DOCS_DRIFT_STAGE_MUTATION,
-  DOCS_DRIFT_STAGE_ID,
-  DOCS_DRIFT_RUNTIME_CLI_COMMAND,
-  DOCS_DRIFT_CLI_ID,
-  DOCS_DRIFT_CLI_COMMAND,
-  DOCS_DRIFT_CAPABILITY_ID
-};

package/dist/src/files-source.d.ts

@@ -1,18 +0,0 @@
-import type { RegisteredTaskSource } from "@rig/contracts";
-export interface FilesTaskSourceOptions {
-    /**
-     * Directory containing one JSON file per task. Use either `path` (matches
-     * the `taskSource.path` field in rig.config.ts) or `dir` (back-compat).
-     */
-    path?: string;
-    dir?: string;
-    pattern?: RegExp;
-    /**
-     * Root a relative `path`/`dir` resolves against. The serving process's cwd
-     * is NOT the project (workspace-spawned servers run from the engine
-     * checkout), so without this a relative path silently reads the WRONG
-     * repo's tasks. Defaults to cwd for direct programmatic use.
-     */
-    projectRoot?: string;
-}
-export declare function createFilesTaskSource(opts: FilesTaskSourceOptions): RegisteredTaskSource;

package/dist/src/files-source.js

@@ -1,107 +0,0 @@
-// @bun
-// packages/standard-plugin/src/files-source.ts
-import { readFileSync, readdirSync, existsSync, statSync, writeFileSync } from "fs";
-import { join, basename, isAbsolute, resolve } from "path";
-var DEFAULT_PATTERN = /\.(task\.)?json$/;
-function readTaskFile(file, pattern) {
-  const raw = JSON.parse(readFileSync(file, "utf-8"));
-  const inferredId = basename(file).replace(pattern, "");
-  const labels = Array.isArray(raw.labels) ? raw.labels.filter((label) => typeof label === "string") : [];
-  const scope = labels.filter((label) => label.startsWith("scope:")).map((label) => label.slice("scope:".length));
-  const validators = labels.filter((label) => label.startsWith("validator:")).map((label) => label.slice("validator:".length));
-  const roleLabel = labels.find((label) => label.startsWith("role:"));
-  return {
-    id: raw["id"] ?? inferredId,
-    deps: raw["deps"] ?? raw["depends_on"] ?? [],
-    status: raw["status"] ?? "ready",
-    ...scope.length > 0 ? { scope } : {},
-    ...roleLabel ? { role: roleLabel.slice("role:".length) } : {},
-    ...validators.length > 0 ? { validators, validation: validators } : {},
-    ...raw
-  };
-}
-function createFilesTaskSource(opts) {
-  const pattern = opts.pattern ?? DEFAULT_PATTERN;
-  const configured = opts.path ?? opts.dir;
-  if (!configured) {
-    throw new Error("createFilesTaskSource: either `path` or `dir` must be provided");
-  }
-  const directory = isAbsolute(configured) ? configured : resolve(opts.projectRoot ?? process.cwd(), configured);
-  const findTaskFile = (id) => {
-    if (!existsSync(directory))
-      return;
-    for (const name of readdirSync(directory)) {
-      if (!pattern.test(name))
-        continue;
-      const p = join(directory, name);
-      try {
-        if (!statSync(p).isFile())
-          continue;
-        if (readTaskFile(p, pattern).id === id)
-          return p;
-      } catch {}
-    }
-    return;
-  };
-  const applyUpdate = (id, update) => {
-    const file = findTaskFile(id);
-    if (!file) {
-      throw new Error(`files task not found: ${id}`);
-    }
-    const raw = JSON.parse(readFileSync(file, "utf-8"));
-    if (update.status)
-      raw.status = update.status;
-    if (update.title !== undefined)
-      raw.title = update.title;
-    if (update.body !== undefined)
-      raw.body = update.body;
-    if (update.comment?.trim()) {
-      const existing = Array.isArray(raw.comments) ? raw.comments : [];
-      raw.comments = [
-        ...existing,
-        {
-          body: update.comment,
-          createdAt: new Date().toISOString(),
-          source: "rig"
-        }
-      ];
-    }
-    writeFileSync(file, `${JSON.stringify(raw, null, 2)}
-`, "utf-8");
-  };
-  return {
-    id: "std:files",
-    kind: "files",
-    async list() {
-      if (!existsSync(directory))
-        return [];
-      const out = [];
-      for (const name of readdirSync(directory)) {
-        if (!pattern.test(name))
-          continue;
-        const p = join(directory, name);
-        try {
-          if (!statSync(p).isFile())
-            continue;
-          out.push(readTaskFile(p, pattern));
-        } catch (err) {
-          console.warn(`[files-source] skipped ${name}: ${err.message}`);
-        }
-      }
-      return out;
-    },
-    async get(id) {
-      const all = await this.list();
-      return all.find((t) => t.id === id);
-    },
-    async updateStatus(id, status) {
-      applyUpdate(id, { status });
-    },
-    async updateTask(id, update) {
-      applyUpdate(id, update);
-    }
-  };
-}
-export {
-  createFilesTaskSource
-};