chore(hygiene): scrub the private product name from the public repo

The private/commercial product name was leaking into this public repo:
- @metaobjectsdev/sdk exported MetaForge* symbols (MetaForgeNode,
  MetaForgeRecordNotFoundError, MetaForgeAlreadyPromotedError,
  MetaForgeRecordParseError). Renamed MetaForge* → Forge*, aligning with the
  existing public @metaobjectsdev/forge package + ForgeType/ForgeAttr naming.
  No other workspace package imports them; the generic "forge" concept stays.
  (Breaking change to @metaobjectsdev/sdk's public API.)
- spec/design-docs/2026-05-14-polyglot-monorepo-design.md was a historical
  private→public migration doc that documented the private project's structure
  + commercial roadmap; referenced by nothing. Removed.
- Genericized a "superseded by <private> (private)" banner in one plan doc.

SDK storage/forge-types tests green (23/0); zero references to the private name
remain in tracked files. The name is now on the public-repo commit-guard denylist.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

docs/superpowers/plans/2026-05-19-java-conformance-harness.md

@@ -1,4 +1,4 @@
-> **Superseded by `metaforge/docs/superpowers/plans/2026-05-19-java-h3b2-conformance-harness.md` (private). This file is the original draft and is no longer the source of truth.**
+> **Superseded — this file is the original draft and is no longer the source of truth.**
 
 # Java Conformance Harness Implementation Plan
 

server/typescript/packages/sdk/src/forge-types.ts

@@ -114,7 +114,7 @@ import {
 } from "@metaobjectsdev/metadata";
 
 /** Minimal concrete MetaData subclass used for all forge descriptive nodes. */
-class MetaForgeNode extends MetaData {}
+class ForgeNode extends MetaData {}
 
 function wildcardOf(childType: string): ChildRule {
   return {
@@ -133,7 +133,7 @@ function def(
   return {
     typeId: new TypeId(type, subType),
     description,
-    factory: (typeId, name) => new MetaForgeNode(typeId, name),
+    factory: (typeId, name) => new ForgeNode(typeId, name),
     childRules,
     attributes: [],
   };

server/typescript/packages/sdk/src/index.ts

@@ -16,9 +16,9 @@ export {
   listRecords,
   promoteRecord,
   supersede,
-  MetaForgeRecordNotFoundError,
-  MetaForgeAlreadyPromotedError,
-  MetaForgeRecordParseError,
+  ForgeRecordNotFoundError,
+  ForgeAlreadyPromotedError,
+  ForgeRecordParseError,
 } from "./storage/index.js";
 export type { ListOptions } from "./storage/index.js";
 

server/typescript/packages/sdk/src/storage/errors.ts

@@ -1,23 +1,23 @@
-export class MetaForgeRecordNotFoundError extends Error {
+export class ForgeRecordNotFoundError extends Error {
   constructor(public readonly path: string) {
     super(`Record not found: ${path}`);
-    this.name = "MetaForgeRecordNotFoundError";
+    this.name = "ForgeRecordNotFoundError";
   }
 }
 
-export class MetaForgeAlreadyPromotedError extends Error {
+export class ForgeAlreadyPromotedError extends Error {
   constructor(public readonly path: string) {
     super(`A canonical record already exists at: ${path}`);
-    this.name = "MetaForgeAlreadyPromotedError";
+    this.name = "ForgeAlreadyPromotedError";
   }
 }
 
-export class MetaForgeRecordParseError extends Error {
+export class ForgeRecordParseError extends Error {
   constructor(
     public readonly path: string,
     public override readonly cause: unknown,
   ) {
     super(`Failed to parse record at ${path}: ${cause instanceof Error ? cause.message : String(cause)}`);
-    this.name = "MetaForgeRecordParseError";
+    this.name = "ForgeRecordParseError";
   }
 }

server/typescript/packages/sdk/src/storage/index.ts

@@ -4,7 +4,7 @@ export { listRecords } from "./list.js";
 export type { ListOptions } from "./list.js";
 export { promoteRecord, supersede } from "./lifecycle.js";
 export {
-  MetaForgeRecordNotFoundError,
-  MetaForgeAlreadyPromotedError,
-  MetaForgeRecordParseError,
+  ForgeRecordNotFoundError,
+  ForgeAlreadyPromotedError,
+  ForgeRecordParseError,
 } from "./errors.js";

server/typescript/packages/sdk/src/storage/lifecycle.ts

@@ -2,7 +2,7 @@ import type { AnyRecord } from "../records/any.js";
 import type { RecordType } from "../records/core.js";
 import { readRecord, recordExists } from "./read.js";
 import { writeRecord, removeRecord } from "./write.js";
-import { MetaForgeAlreadyPromotedError, MetaForgeRecordNotFoundError } from "./errors.js";
+import { ForgeAlreadyPromotedError, ForgeRecordNotFoundError } from "./errors.js";
 import { recordPath } from "../paths.js";
 
 export async function promoteRecord(
@@ -11,10 +11,10 @@ export async function promoteRecord(
   id: string,
 ): Promise<void> {
   if (!(await recordExists(metaRoot, type, id, { pending: true }))) {
-    throw new MetaForgeRecordNotFoundError(recordPath(metaRoot, type, id, { pending: true }));
+    throw new ForgeRecordNotFoundError(recordPath(metaRoot, type, id, { pending: true }));
   }
   if (await recordExists(metaRoot, type, id)) {
-    throw new MetaForgeAlreadyPromotedError(recordPath(metaRoot, type, id));
+    throw new ForgeAlreadyPromotedError(recordPath(metaRoot, type, id));
   }
   const record = await readRecord(metaRoot, type, id, { pending: true });
   await writeRecord(metaRoot, record);
@@ -27,7 +27,7 @@ export async function supersede(
   newRecord: AnyRecord,
 ): Promise<void> {
   if (!(await recordExists(metaRoot, newRecord.type, oldId))) {
-    throw new MetaForgeRecordNotFoundError(recordPath(metaRoot, newRecord.type, oldId));
+    throw new ForgeRecordNotFoundError(recordPath(metaRoot, newRecord.type, oldId));
   }
   // Write the new record first, so a failure leaves the old record intact.
   await writeRecord(metaRoot, newRecord);

server/typescript/packages/sdk/src/storage/read.ts

@@ -3,7 +3,7 @@ import type { AnyRecord } from "../records/any.js";
 import { AnyRecord as AnyRecordSchema } from "../records/any.js";
 import type { RecordType } from "../records/core.js";
 import { recordPath } from "../paths.js";
-import { MetaForgeRecordNotFoundError, MetaForgeRecordParseError } from "./errors.js";
+import { ForgeRecordNotFoundError, ForgeRecordParseError } from "./errors.js";
 
 export async function readRecord(
   metaRoot: string,
@@ -16,17 +16,17 @@ export async function readRecord(
   try {
     raw = await readFile(path, "utf8");
   } catch (err) {
-    if (isNoEntError(err)) throw new MetaForgeRecordNotFoundError(path);
+    if (isNoEntError(err)) throw new ForgeRecordNotFoundError(path);
     throw err;
   }
   let parsedJson: unknown;
   try {
     parsedJson = JSON.parse(raw);
   } catch (err) {
-    throw new MetaForgeRecordParseError(path, err);
+    throw new ForgeRecordParseError(path, err);
   }
   const result = AnyRecordSchema.safeParse(parsedJson);
-  if (!result.success) throw new MetaForgeRecordParseError(path, result.error);
+  if (!result.success) throw new ForgeRecordParseError(path, result.error);
   return result.data;
 }
 

server/typescript/packages/sdk/src/storage/write.ts

@@ -3,7 +3,7 @@ import { dirname } from "node:path";
 import type { AnyRecord } from "../records/any.js";
 import { AnyRecord as AnyRecordSchema } from "../records/any.js";
 import { recordPath } from "../paths.js";
-import { MetaForgeRecordNotFoundError } from "./errors.js";
+import { ForgeRecordNotFoundError } from "./errors.js";
 import { recordExists } from "./read.js";
 
 export async function writeRecord(
@@ -26,7 +26,7 @@ export async function removeRecord(
   opts: { pending?: boolean } = {},
 ): Promise<void> {
   if (!(await recordExists(metaRoot, type, id, opts))) {
-    throw new MetaForgeRecordNotFoundError(recordPath(metaRoot, type, id, opts));
+    throw new ForgeRecordNotFoundError(recordPath(metaRoot, type, id, opts));
   }
   await unlink(recordPath(metaRoot, type, id, opts));
 }

server/typescript/packages/sdk/test/storage.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { writeRecord } from "../src/storage/write.js";
 import { readRecord, recordExists } from "../src/storage/read.js";
-import { MetaForgeRecordNotFoundError } from "../src/storage/errors.js";
+import { ForgeRecordNotFoundError } from "../src/storage/errors.js";
 
 let metaRoot: string;
 beforeEach(() => {
@@ -48,9 +48,9 @@ describe("writeRecord", () => {
 });
 
 describe("readRecord", () => {
-  test("throws MetaForgeRecordNotFoundError when missing", async () => {
+  test("throws ForgeRecordNotFoundError when missing", async () => {
     await expect(readRecord(metaRoot, "decision", "missing")).rejects.toBeInstanceOf(
-      MetaForgeRecordNotFoundError,
+      ForgeRecordNotFoundError,
     );
   });
   test("round-trips a record losslessly", async () => {
@@ -99,7 +99,7 @@ describe("listRecords", () => {
   });
 });
 import { promoteRecord, supersede } from "../src/storage/lifecycle.js";
-import { MetaForgeAlreadyPromotedError, MetaForgeRecordNotFoundError as NotFoundError } from "../src/storage/errors.js";
+import { ForgeAlreadyPromotedError, ForgeRecordNotFoundError as NotFoundError } from "../src/storage/errors.js";
 
 describe("promoteRecord", () => {
   test("moves a pending record to canonical", async () => {
@@ -115,7 +115,7 @@ describe("promoteRecord", () => {
     await writeRecord(metaRoot, aDecision);
     await writeRecord(metaRoot, aDecision, { pending: true });
     await expect(promoteRecord(metaRoot, "decision", "decision-tanstack")).rejects.toBeInstanceOf(
-      MetaForgeAlreadyPromotedError,
+      ForgeAlreadyPromotedError,
     );
   });
 });