@cassiomc1/forgeloop 0.1.0

package/src/commands/doctor.js

@@ -0,0 +1,165 @@
+import { assertSafePath, fileExists, ensureWithin, readBytes } from "../core/filesystem.js";
+import { readManifest, sha256, writeManifest } from "../core/manifest.js";
+import { readTemplateEntries } from "../core/templates.js";
+import { createEvidence } from "../core/evidence.js";
+
+function finding(code, severity, relativePath, message, remediation = null, evidence = null) {
+  const evidenceRecord = evidence && typeof evidence === "object"
+    ? evidence
+    : createEvidence({
+      kind: "OBSERVED",
+      source: `ForgeLoop doctor:${relativePath}`,
+      result: evidence ?? message,
+    });
+  return {
+    code,
+    severity,
+    path: relativePath,
+    message,
+    remediation: remediation ?? (severity === "info" ? "No action required." : "Review the target path and apply the suggested correction."),
+    evidence: evidenceRecord,
+  };
+}
+
+function readProfileMode(bytes) {
+  const text = bytes.toString("utf8");
+  return text.match(/^profile-mode:\s*([^\s]+)\s*$/m)?.[1] ?? null;
+}
+
+const ADAPTER_PATHS = new Set([
+  "AGENTS.md",
+  "CLAUDE.md",
+  ".cursor/rules/project-loop.mdc",
+  ".github/copilot-instructions.md",
+]);
+
+async function adoptAdapters({ target, manifest, adoptPaths, findings }) {
+  if (!manifest || adoptPaths.length === 0) return manifest;
+
+  const nextManifest = structuredClone(manifest);
+  let changed = false;
+
+  for (const relativePath of adoptPaths) {
+    if (!ADAPTER_PATHS.has(relativePath)) {
+      findings.push(
+        finding(
+          "adopt-invalid-path",
+          "error",
+          relativePath,
+          "Only supported adapter paths can be adopted.",
+        ),
+      );
+      continue;
+    }
+
+    const destination = ensureWithin(target, relativePath);
+    try {
+      await assertSafePath(target, relativePath);
+    } catch (error) {
+      findings.push(finding("unsafe-path", "error", relativePath, error.message));
+      continue;
+    }
+    if (!(await fileExists(destination))) {
+      findings.push(finding("adopt-file-missing", "error", relativePath, "Adapter file is missing."));
+      continue;
+    }
+
+    nextManifest.files[relativePath] = {
+      sha256: sha256(await readBytes(destination)),
+      preserve: true,
+    };
+    findings.push(
+      finding(
+        "file-adopted",
+        "info",
+        relativePath,
+        "Existing adapter is now recorded as preserved by ForgeLoop.",
+      ),
+    );
+    changed = true;
+  }
+
+  if (changed) await writeManifest(target, nextManifest);
+  return nextManifest;
+}
+
+export async function runDoctor({ target, packageRoot, adoptPaths = [], strict = false }) {
+  const findings = [];
+  let manifest = null;
+  try {
+    manifest = await readManifest(target);
+    if (!manifest) {
+      findings.push(finding("manifest-missing", "error", ".forgeloop/manifest.json", "Run forgeloop init first."));
+    }
+  } catch (error) {
+    findings.push(finding("manifest-invalid", "error", ".forgeloop/manifest.json", error.message));
+  }
+
+  manifest = await adoptAdapters({ target, manifest, adoptPaths, findings });
+  const entries = await readTemplateEntries(packageRoot);
+  for (const entry of entries) {
+    const destination = ensureWithin(target, entry.relativePath);
+    try {
+      await assertSafePath(target, entry.relativePath);
+    } catch (error) {
+      findings.push(finding("unsafe-path", "error", entry.relativePath, error.message));
+      continue;
+    }
+    if (!(await fileExists(destination))) {
+      findings.push(finding("file-missing", "error", entry.relativePath, "Managed file is missing."));
+      continue;
+    }
+
+    if (entry.relativePath === "PROJECT_PROFILE.md") {
+      const mode = readProfileMode(await readBytes(destination));
+      if (mode === "template") {
+        findings.push(finding("profile-template", "info", entry.relativePath, "Initialize profile-mode as project after confirming real project facts."));
+      }
+    }
+
+    const record = manifest?.files?.[entry.relativePath];
+    if (!record) {
+      if (ADAPTER_PATHS.has(entry.relativePath)) {
+        findings.push(
+          finding(
+            "unmanaged-file",
+            "error",
+            entry.relativePath,
+            "Existing adapter is not managed by ForgeLoop; merge the loop reference and rerun doctor.",
+          ),
+        );
+      }
+      continue;
+    }
+    const actualHash = sha256(await readBytes(destination));
+    if (actualHash !== record.sha256 && !record.preserve) {
+      findings.push(finding("file-drift", "warning", entry.relativePath, "File differs from the last managed version; update will preserve it."));
+    }
+  }
+
+  const shippedPaths = new Set(entries.map((entry) => entry.relativePath));
+  for (const relativePath of Object.keys(manifest?.files ?? {})) {
+    if (!shippedPaths.has(relativePath)) {
+      findings.push(
+        finding(
+          "manifest-orphan",
+          "warning",
+          relativePath,
+          "Manifest entry no longer corresponds to a shipped template.",
+        ),
+      );
+    }
+  }
+
+  const ok = findings.every((item) => item.severity !== "error")
+    && (!strict || findings.every((item) => item.severity !== "warning"));
+  return {
+    ok,
+    findings,
+    evidence: [createEvidence({
+      kind: "OBSERVED",
+      source: "ForgeLoop doctor",
+      result: `${findings.length} findings; ${ok ? "healthy" : "needs attention"}`,
+    })],
+  };
+}

package/src/commands/init.js

@@ -0,0 +1,42 @@
+import { assertSafePath, fileExists, ensureWithin, writeFileAtomic } from "../core/filesystem.js";
+import {
+  createManifest,
+  readManifest,
+  sha256,
+  writeManifest,
+} from "../core/manifest.js";
+import { readTemplateEntries } from "../core/templates.js";
+
+const PROFILE_PATH = "PROJECT_PROFILE.md";
+
+export async function runInit({ target, dryRun, packageRoot, packageVersion }) {
+  const entries = await readTemplateEntries(packageRoot);
+  const existingManifest = await readManifest(target);
+  if (existingManifest) {
+    throw new Error("Target is already initialized; run forgeloop update instead.");
+  }
+  const manifest = createManifest(packageVersion);
+  const actions = [];
+
+  for (const entry of entries) {
+    const destination = ensureWithin(target, entry.relativePath);
+    await assertSafePath(target, entry.relativePath);
+    if (await fileExists(destination)) {
+      actions.push({ action: "skip", path: entry.relativePath, reason: "exists" });
+      continue;
+    }
+
+    actions.push({
+      action: dryRun ? "would-create" : "created",
+      path: entry.relativePath,
+    });
+    await writeFileAtomic(destination, entry.bytes, { dryRun });
+    manifest.files[entry.relativePath] = {
+      sha256: sha256(entry.bytes),
+      preserve: entry.relativePath === PROFILE_PATH,
+    };
+  }
+
+  await writeManifest(target, manifest, { dryRun });
+  return { actions, manifest };
+}

package/src/commands/inspect.js

@@ -0,0 +1,17 @@
+import { inspectTarget } from "../core/inspect.js";
+
+export { inspectTarget };
+
+export function formatInspectResult(report) {
+  const lines = [
+    `Target: ${report.target.path}`,
+    `Manifest: ${report.manifest.status}`,
+    `Profile: ${report.profile.mode ?? "unknown"}/${report.profile.status ?? "unknown"}`,
+    `Protocol: v${report.protocol.version}`,
+    `State: ${report.state.status}`,
+    `Adapters: ${report.adapters.detected.length} detected`,
+    `Findings: ${report.findings.length}`,
+    report.ok ? "healthy: ForgeLoop target is ready" : "unhealthy: ForgeLoop target needs attention",
+  ];
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/route.js

@@ -0,0 +1,32 @@
+import { evaluateRoute } from "../core/router.js";
+
+export function runRoute({ workType, surfaces, risks, platforms, behaviorChange, executableChange }) {
+  return evaluateRoute({
+    workType,
+    surfaces,
+    risks,
+    platforms,
+    behaviorChange,
+    executableChange,
+  });
+}
+
+export function formatRouteResult(result) {
+  const lines = ["Selected:"];
+  if (result.guides.length === 0) {
+    lines.push("- none (use the relevant domain guide for this documentation task)");
+  } else {
+    for (const guide of result.guides) {
+      lines.push(`- ${guide}: ${result.reasons[guide].join(", ")}`);
+    }
+  }
+
+  const excludedEntries = Object.entries(result.excluded);
+  if (excludedEntries.length > 0) {
+    lines.push("Excluded:");
+    for (const [guide, reasons] of excludedEntries) {
+      lines.push(`- ${guide}: ${reasons.join(", ")}`);
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/status.js

@@ -0,0 +1,29 @@
+import { readAndClassifyWorkState } from "../core/work-state.js";
+import { inspectSchemaHealth } from "../core/schema-validation.js";
+
+export async function runStatus({ target, packageRoot, contractFile = null }) {
+  const state = await readAndClassifyWorkState({ target, packageRoot, contractFile });
+  const protocol = await inspectSchemaHealth(target);
+  return {
+    ...state,
+    protocol,
+    evidence: [...(state.evidence ?? []), ...(protocol.evidence ?? [])],
+  };
+}
+
+export function formatStatusResult(result) {
+  const lines = [
+    `State: ${result.path}`,
+    `Status: ${result.status}`,
+    `Phase: ${result.phase ?? "none"}`,
+    `Completed: ${result.completed.join(", ") || "none"}`,
+    `Pending: ${result.pending.join(", ") || "none"}`,
+  ];
+  if (result.reasons.length > 0) lines.push(`Reasons: ${result.reasons.join(", ")}`);
+  if (result.warnings?.length > 0) lines.push(`Warnings: ${result.warnings.join(", ")}`);
+  if (result.contractComparison) lines.push(`Contract: ${result.contractComparison}`);
+  if (result.artifactComparison) lines.push(`Artifacts: ${result.artifactComparison}`);
+  if (result.protocol) lines.push(`Schemas: ${result.protocol.status}`);
+  if (result.error) lines.push(`Error: ${result.error}`);
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/update.js

@@ -0,0 +1,109 @@
+import { assertSafePath, fileExists, ensureWithin, readBytes, writeFileAtomic } from "../core/filesystem.js";
+import {
+  PACKAGE_NAME,
+  readManifest,
+  sha256,
+  writeManifest,
+} from "../core/manifest.js";
+import { readTemplateEntries } from "../core/templates.js";
+
+const PROFILE_PATH = "PROJECT_PROFILE.md";
+
+export async function runUpdate({ target, dryRun, packageRoot, packageVersion }) {
+  const currentManifest = await readManifest(target);
+  if (!currentManifest) {
+    throw new Error("No .forgeloop/manifest.json found; run forgeloop init first.");
+  }
+
+  const entries = await readTemplateEntries(packageRoot);
+  const nextManifest = structuredClone(currentManifest);
+  const actions = [];
+  const conflicts = [];
+  const plans = [];
+  const pruneActions = [];
+  const shippedPaths = new Set(entries.map((entry) => entry.relativePath));
+
+  for (const relativePath of Object.keys(nextManifest.files)) {
+    if (!shippedPaths.has(relativePath)) {
+      pruneActions.push({
+        action: dryRun ? "would-prune" : "pruned",
+        path: relativePath,
+        reason: "template-removed",
+      });
+    }
+  }
+
+  for (const entry of entries) {
+    const destination = ensureWithin(target, entry.relativePath);
+    await assertSafePath(target, entry.relativePath);
+    const sourceHash = sha256(entry.bytes);
+    const record = currentManifest.files[entry.relativePath];
+    const exists = await fileExists(destination);
+
+    if (!exists) {
+      plans.push({
+        action: dryRun ? "would-create" : "created",
+        destination,
+        entry,
+        record: {
+          sha256: sourceHash,
+          preserve: entry.relativePath === PROFILE_PATH,
+        },
+      });
+      continue;
+    }
+
+    if (!record) {
+      actions.push({ action: "skip", path: entry.relativePath, reason: "unmanaged" });
+      continue;
+    }
+
+    if (record.preserve || entry.relativePath === PROFILE_PATH) {
+      actions.push({ action: "skip", path: entry.relativePath, reason: "preserved" });
+      continue;
+    }
+
+    const currentBytes = await readBytes(destination);
+    const currentHash = sha256(currentBytes);
+    if (currentHash !== record.sha256) {
+      conflicts.push({
+        path: entry.relativePath,
+        message: "Local changes detected; file was not overwritten.",
+      });
+      actions.push({ action: "conflict", path: entry.relativePath });
+      continue;
+    }
+
+    if (currentHash === sourceHash) {
+      actions.push({ action: "skip", path: entry.relativePath, reason: "current" });
+      continue;
+    }
+
+    plans.push({
+      action: dryRun ? "would-update" : "updated",
+      destination,
+      entry,
+      record: { ...record, sha256: sourceHash },
+    });
+  }
+
+  if (conflicts.length > 0) {
+    return { actions, conflicts, manifest: currentManifest };
+  }
+
+  for (const relativePath of Object.keys(nextManifest.files)) {
+    if (!shippedPaths.has(relativePath)) delete nextManifest.files[relativePath];
+  }
+  actions.push(...pruneActions);
+
+  for (const plan of plans) {
+    actions.push({ action: plan.action, path: plan.entry.relativePath });
+    await writeFileAtomic(plan.destination, plan.entry.bytes, { dryRun });
+    nextManifest.files[plan.entry.relativePath] = plan.record;
+  }
+
+  nextManifest.packageName = PACKAGE_NAME;
+  nextManifest.packageVersion = packageVersion;
+  await writeManifest(target, nextManifest, { dryRun });
+  return { actions, conflicts, manifest: nextManifest };
+}

package/src/commands/validate-protocol.js

@@ -0,0 +1,133 @@
+import { assertSafePath, ensureWithin, fileExists, readBytes } from "../core/filesystem.js";
+import { assertJsonBytes, assertJsonLimits } from "../core/json-safety.js";
+import { validateTaskArtifactSet } from "../core/conformance.js";
+import { assertSchema, readSchema } from "../core/schema-validation.js";
+import { assertRouteInvariants } from "../core/router.js";
+import { assertWorkStateSemantics, classifyLoadedWorkState } from "../core/work-state.js";
+import { validateReceipt } from "../core/receipt.js";
+import { validateTaskBrief, validateDelegatedResult } from "../core/delegation.js";
+
+async function readArtifact(target, relativePath, label) {
+  if (!relativePath) return null;
+  await assertSafePath(target, relativePath);
+  const artifactPath = ensureWithin(target, relativePath);
+  if (!(await fileExists(artifactPath))) {
+    return {
+      error: {
+        code: "ARTIFACT_MISSING",
+        message: `${label} is missing: ${relativePath}`,
+        artifacts: [relativePath],
+      },
+    };
+  }
+  const bytes = await readBytes(artifactPath);
+  try {
+    assertJsonBytes(bytes, label);
+    const value = JSON.parse(bytes.toString("utf8"));
+    assertJsonLimits(value, label);
+    return { value };
+  } catch (error) {
+    return {
+      error: {
+        code: error.code === "JSON_LIMIT_EXCEEDED" ? error.code : "ARTIFACT_INVALID_JSON",
+        message: `${label} is invalid: ${error.message}`,
+        artifacts: [relativePath],
+      },
+    };
+  }
+}
+
+export async function runValidateProtocol({
+  target,
+  packageRoot,
+  routeFile = null,
+  stateFile = null,
+  receiptFile = null,
+  contractFile = null,
+  taskBriefFiles = [],
+  delegatedResultFiles = [],
+}) {
+  const descriptors = [
+    ["route", routeFile],
+    ["state", stateFile],
+    ["receipt", receiptFile],
+    ...taskBriefFiles.map((file) => [`task brief:${file}`, file]),
+    ...delegatedResultFiles.map((file) => [`delegated result:${file}`, file]),
+  ];
+  const loaded = [];
+  for (const [label, relativePath] of descriptors) {
+    const artifact = await readArtifact(target, relativePath, label);
+    loaded.push({ label, relativePath, ...artifact });
+  }
+
+  const readErrors = loaded.filter((item) => item.error).map((item) => item.error);
+  const route = loaded.find((item) => item.label === "route")?.value ?? null;
+  const state = loaded.find((item) => item.label === "state")?.value ?? null;
+  const receipt = loaded.find((item) => item.label === "receipt")?.value ?? null;
+  const taskBriefs = loaded.filter((item) => item.label.startsWith("task brief:") && item.value).map((item) => item.value);
+  const delegatedResults = loaded.filter((item) => item.label.startsWith("delegated result:") && item.value).map((item) => item.value);
+  const schemaErrors = [];
+  const validateLoaded = async (item, schemaName, semanticValidator = null) => {
+    if (!item.value) return;
+    try {
+      const schema = await readSchema(schemaName, packageRoot);
+      assertSchema(item.value, schema, item.label);
+      if (semanticValidator) await semanticValidator(item.value);
+    } catch (error) {
+      schemaErrors.push({
+        code: "ARTIFACT_SCHEMA_INVALID",
+        message: `${item.label} failed schema or semantic validation: ${error.message}`,
+        artifacts: [item.relativePath],
+      });
+    }
+  };
+  await validateLoaded(loaded.find((item) => item.label === "route"), "routing-result", async (value) => assertRouteInvariants(value));
+  await validateLoaded(loaded.find((item) => item.label === "state"), "work-state", async (value) => assertWorkStateSemantics(value));
+  await validateLoaded(loaded.find((item) => item.label === "receipt"), "execution-receipt", async (value) => validateReceipt(value, packageRoot));
+  for (const item of loaded.filter((candidate) => candidate.label.startsWith("task brief:"))) {
+    await validateLoaded(item, "task-brief", async (value) => validateTaskBrief(value, packageRoot));
+  }
+  for (const item of loaded.filter((candidate) => candidate.label.startsWith("delegated result:"))) {
+    await validateLoaded(item, "delegated-result", async (value) => validateDelegatedResult(value, packageRoot));
+  }
+  const stateValidationError = schemaErrors.some((error) => error.artifacts.includes(stateFile));
+  const stateClassification = state && readErrors.length === 0 && !stateValidationError
+    ? await classifyLoadedWorkState({ target, state, contractFile })
+    : null;
+  const result = validateTaskArtifactSet({
+    route,
+    state,
+    stateClassification,
+    receipt,
+    taskBriefs,
+    delegatedResults,
+  });
+  if (readErrors.length > 0 || schemaErrors.length > 0) {
+    return {
+      ...result,
+      status: "INVALID",
+      errors: [...result.errors, ...readErrors, ...schemaErrors].sort((left, right) => left.code.localeCompare(right.code) || left.message.localeCompare(right.message)),
+    };
+  }
+  return result;
+}
+
+export function formatValidateProtocolResult(result) {
+  const lines = [`Protocol: ${result.status}`];
+  if (result.stale) {
+    lines.push(`Repository: ${result.stale.repositoryComparison}`);
+    lines.push(`Contract: ${result.stale.contractComparison}`);
+    lines.push(`Required artifacts: ${result.stale.artifactComparison}`);
+    if (result.stale.reasons.length > 0) {
+      lines.push("Reasons:");
+      for (const reason of result.stale.reasons) lines.push(`- ${reason}`);
+    }
+    if (result.stale.warnings.length > 0) {
+      lines.push("Warnings:");
+      for (const warning of result.stale.warnings) lines.push(`- ${warning}`);
+    }
+  }
+  for (const item of result.errors) lines.push(`- ${item.code}: ${item.message}`);
+  for (const item of result.incomplete) lines.push(`- INCOMPLETE: ${item}`);
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/validate-receipt.js

@@ -0,0 +1,19 @@
+import { assertSafePath, ensureWithin, readBytes } from "../core/filesystem.js";
+import { validateReceipt } from "../core/receipt.js";
+import { assertJsonBytes, assertJsonLimits } from "../core/json-safety.js";
+
+export async function runValidateReceipt({ target, packageRoot, file }) {
+  if (!file) throw new Error("--file is required for validate-receipt");
+  await assertSafePath(target, file);
+  const receiptPath = ensureWithin(target, file);
+  let receipt;
+  try {
+    const bytes = await readBytes(receiptPath);
+    assertJsonBytes(bytes, file);
+    receipt = JSON.parse(bytes.toString("utf8"));
+    assertJsonLimits(receipt, file);
+  } catch (error) {
+    throw new Error(`Unable to parse receipt ${file}: ${error.message}`);
+  }
+  return validateReceipt(receipt, packageRoot);
+}

package/src/commands/validate-state.js

@@ -0,0 +1,30 @@
+import { readWorkState, WORK_STATE_PATH } from "../core/work-state.js";
+
+export async function runValidateState({ target, packageRoot }) {
+  try {
+    const state = await readWorkState(target, packageRoot);
+    if (!state) {
+      return {
+        ok: true,
+        path: WORK_STATE_PATH,
+        state: null,
+        errors: [],
+        warnings: ["No work-state checkpoint is present."],
+      };
+    }
+    return { ok: true, path: WORK_STATE_PATH, state, errors: [], warnings: [] };
+  } catch (error) {
+    return {
+      ok: false,
+      path: WORK_STATE_PATH,
+      state: null,
+      errors: [error.message],
+      warnings: [],
+    };
+  }
+}
+
+export function formatValidateStateResult(result) {
+  if (result.ok) return `valid: ${result.path}\n`;
+  return `invalid: ${result.path}\n${result.errors.map((error) => `- ${error}`).join("\n")}\n`;
+}

package/src/core/agent-support.js

@@ -0,0 +1,89 @@
+function agent(record) {
+  return Object.freeze({
+    ...record,
+    instructionFiles: Object.freeze([...record.instructionFiles]),
+  });
+}
+
+export const AGENT_SUPPORT = Object.freeze([
+  agent({
+    id: "codex",
+    name: "Codex",
+    support: "direct",
+    instructionFiles: ["AGENTS.md"],
+    officialDocs: "https://developers.openai.com/codex/guides/agents-md",
+    notes: "Reads AGENTS.md files from the global scope down to the working directory.",
+  }),
+  agent({
+    id: "claude-code",
+    name: "Claude Code",
+    support: "direct",
+    instructionFiles: ["CLAUDE.md"],
+    officialDocs: "https://code.claude.com/docs/en/memory",
+    notes: "Reads CLAUDE.md; it does not read AGENTS.md unless CLAUDE.md imports it.",
+  }),
+  agent({
+    id: "cursor",
+    name: "Cursor",
+    support: "direct",
+    instructionFiles: ["AGENTS.md", ".cursor/rules/project-loop.mdc"],
+    officialDocs: "https://cursor.com/docs/rules",
+    notes: "Uses the always-applicable MDC rule and also supports a root AGENTS.md.",
+  }),
+  agent({
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    support: "direct",
+    instructionFiles: [".github/copilot-instructions.md"],
+    officialDocs: "https://docs.github.com/en/copilot/how-tos/configure-custom-instructions-in-your-ide/add-repository-instructions-in-your-ide",
+    notes: "Uses repository-wide Copilot instructions; supported agent instruction files vary by Copilot surface.",
+  }),
+  agent({
+    id: "antigravity",
+    name: "Antigravity",
+    support: "agents-md",
+    instructionFiles: ["AGENTS.md"],
+    officialDocs: "https://antigravity.google/docs/cli/best-practices",
+    notes: "Parses a workspace-root AGENTS.md; workspace rules can additionally live in .agents/rules/.",
+  }),
+  agent({
+    id: "opencode",
+    name: "OpenCode",
+    support: "agents-md",
+    instructionFiles: ["AGENTS.md"],
+    officialDocs: "https://opencode.ai/docs/rules/",
+    notes: "Uses project AGENTS.md; opencode.json can add other instruction files when needed.",
+  }),
+  agent({
+    id: "hermes",
+    name: "Hermes",
+    support: "agents-md",
+    instructionFiles: ["AGENTS.md"],
+    officialDocs: "https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/context-files.md",
+    notes: "AGENTS.md is supported, but .hermes.md or HERMES.md has higher project priority.",
+  }),
+  agent({
+    id: "pi",
+    name: "Pi",
+    support: "agents-md",
+    instructionFiles: ["AGENTS.md"],
+    officialDocs: "https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/sdk.md",
+    notes: "Discovers AGENTS.md from the project root through the current working directory.",
+  }),
+  agent({
+    id: "command-code",
+    name: "Command Code",
+    support: "agents-md",
+    instructionFiles: ["AGENTS.md"],
+    officialDocs: "https://commandcode.ai/docs/core-concepts/memory",
+    notes: "Reads project AGENTS.md; .commandcode/AGENTS.md is an optional project-specific location.",
+  }),
+  agent({
+    id: "freebuff",
+    name: "Freebuff",
+    support: "agents-md",
+    instructionFiles: ["AGENTS.md"],
+    officialDocs: "https://github.com/CodebuffAI/freebuff/blob/main/common/src/constants/knowledge.ts",
+    notes: "Recognizes AGENTS.md as a project knowledge file alongside knowledge.md and CLAUDE.md.",
+  }),
+]);