@moretea-labs/forge 1.8.0 → 1.8.2

package/scripts/benchmark-work-efficiency.ts

@@ -1,334 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Forge Work efficiency benchmark.
- *
- * Measures end-to-end controller ceremony for a tiny, real repository change
- * against isolated temporary repository/controller state. It compares the
- * streamlined path (verify -> finalize) with the legacy-style ceremony
- * (verify -> continue -> finalize) without mutating the Forge checkout.
- */
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { spawnSync } from 'child_process';
-import { createMcpToolContext } from '../src/cli/mcp/server';
-import type { MultiRepositoryMcpToolContext } from '../src/cli/mcp/multi-repository';
-import { ensureControllerHome } from '../src/cli/repositories/controller-home';
-import { registerRepository } from '../src/cli/repositories/registry';
-import { callRuntimeTool } from '../src/runtime/gateway/mcp/runtime-tools';
-import { getWorkContract } from '../src/runtime/control-plane/facade/work-contract-store';
-import { waitForProcess } from '../src/runtime/execution/process-runtime';
-import { acquireRuntimeOwnership } from '../src/runtime/root/ownership';
-import { forgeRuntimeServicePaths } from '../src/runtime/root/service';
-import { writeRuntimeStatusSnapshot } from '../src/runtime/root/status';
-import { ensureActiveRuntimeRelease } from '../src/runtime/root/release-store';
-import { bindRuntimeWriteClaim, clearRuntimeWriteClaimForTests } from '../src/runtime/root/write-fence';
-
-interface TimedCall {
-  elapsedMs: number;
-  value: Record<string, any>;
-}
-
-interface FlowSample {
-  mode: 'streamlined' | 'legacy_ceremony';
-  sample: number;
-  ok: boolean;
-  controllerCalls: number;
-  processWaits: number;
-  startMs: number;
-  verifySubmitMs: number;
-  verifyWaitMs: number;
-  verifyReattachMs: number;
-  continueMs: number;
-  finalizeMs: number;
-  totalMs: number;
-  verificationNextStep?: string;
-  finalStatus?: string;
-  cleanupComplete: boolean;
-}
-
-function argNumber(name: string, fallback: number): number {
-  const index = process.argv.indexOf(name);
-  if (index < 0) return fallback;
-  const parsed = Number(process.argv[index + 1]);
-  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
-}
-
-function git(root: string, args: string[]): string {
-  const result = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
-  if (result.status !== 0) throw new Error(String(result.stderr || `git ${args.join(' ')} failed`));
-  return String(result.stdout ?? '').trim();
-}
-
-function runtimeManifest(controllerHome: string): string {
-  const path = join(controllerHome, 'benchmark-runtime.manifest.json');
-  writeFileSync(path, JSON.stringify({
-    schemaVersion: 1,
-    releaseId: 'release-work-efficiency-benchmark',
-    artifactIdentity: 'artifact-work-efficiency-benchmark',
-    entrypoint: 'forge-runtime',
-    arguments: [],
-    configurationSchemaVersion: 1,
-    controllerHome,
-    databaseSchemaCompatibility: { minimum: 1, maximum: 1 },
-    workerProtocolVersion: 1,
-    createdAt: new Date().toISOString(),
-  }));
-  return path;
-}
-
-function createFixture(label: string) {
-  const root = mkdtempSync(join(tmpdir(), `forge-work-efficiency-${label}-`));
-  const controllerHome = join(root, 'controller');
-  const repoRoot = join(root, 'repo');
-  ensureControllerHome(controllerHome);
-  mkdirSync(repoRoot, { recursive: true });
-  git(repoRoot, ['init', '-b', 'main']);
-  git(repoRoot, ['config', 'user.name', 'Work Efficiency Benchmark']);
-  git(repoRoot, ['config', 'user.email', 'benchmark@example.test']);
-  writeFileSync(join(repoRoot, 'README.md'), 'fixture\n');
-  writeFileSync(join(repoRoot, 'package.json'), JSON.stringify({
-    name: `work-efficiency-${label}`,
-    private: true,
-    scripts: { 'check:bench': 'node -e "process.exit(0)"' },
-  }, null, 2));
-  git(repoRoot, ['add', '.']);
-  git(repoRoot, ['commit', '-m', 'fixture']);
-
-  const repository = registerRepository({ path: repoRoot, controllerHome, displayName: `work-efficiency-${label}` });
-  const owner = acquireRuntimeOwnership(controllerHome, `runtime-work-efficiency-${label}`);
-  const authority = ensureActiveRuntimeRelease(controllerHome, runtimeManifest(controllerHome));
-  bindRuntimeWriteClaim({ controllerHome, owner: owner.record, authority });
-
-  const runtimeService = forgeRuntimeServicePaths(controllerHome);
-  mkdirSync(runtimeService.serviceRoot, { recursive: true });
-  mkdirSync(join(controllerHome, 'mcp'), { recursive: true });
-  const runtimeTokenPath = join(controllerHome, 'mcp', 'runtime-token');
-  writeFileSync(runtimeTokenPath, `fixture-token-${label}\n`, { mode: 0o600 });
-  writeFileSync(runtimeService.configPath, JSON.stringify({
-    schemaVersion: 1,
-    controllerHome,
-    repositoryRoot: repoRoot,
-    host: '127.0.0.1',
-    port: 9876,
-    authTokenFile: runtimeTokenPath,
-  }));
-  const observedAt = new Date().toISOString();
-  writeRuntimeStatusSnapshot(controllerHome, {
-    schemaVersion: 1,
-    runtimeInstanceId: owner.record.runtimeInstanceId,
-    pid: owner.record.pid,
-    releaseId: authority.active.releaseId,
-    artifactIdentity: authority.active.artifactIdentity,
-    endpoint: 'http://127.0.0.1:9876/mcp',
-    readiness: {
-      ready: true,
-      reasonCodes: [],
-      diagnostics: {
-        database: { outcome: 'pass' },
-        scheduler: { outcome: 'pass' },
-        releaseCoherence: { outcome: 'pass' },
-        mcpEndToEnd: { outcome: 'pass' },
-      },
-      observedAt,
-    },
-    startedAt: observedAt,
-    updatedAt: observedAt,
-  });
-
-  const ctx = createMcpToolContext({
-    controllerHome,
-    profile: 'controller',
-    repo: repoRoot,
-    sessionId: `mcp-work-efficiency-${label}`,
-    principalId: `principal-work-efficiency-${label}`,
-    controllerInstanceId: owner.record.runtimeInstanceId,
-  }) as MultiRepositoryMcpToolContext;
-  return { root, controllerHome, repoRoot, repository, ctx };
-}
-
-async function timedCall(ctx: MultiRepositoryMcpToolContext, args: Record<string, unknown>): Promise<TimedCall> {
-  const startedAt = performance.now();
-  const result = await callRuntimeTool(ctx, 'rh_work', args);
-  const elapsedMs = Math.round((performance.now() - startedAt) * 100) / 100;
-  if (!result) throw new Error('rh_work returned no benchmark result');
-  const value = (result.structuredContent ?? JSON.parse(result.content?.[0]?.text ?? '{}')) as Record<string, any>;
-  return { elapsedMs, value };
-}
-
-async function runFlow(mode: FlowSample['mode'], sample: number): Promise<FlowSample> {
-  const label = `${mode}-${sample}-${Date.now()}`;
-  const fx = createFixture(label);
-  const wallStartedAt = performance.now();
-  let controllerCalls = 0;
-  let processWaits = 0;
-  try {
-    const started = await timedCall(fx.ctx, {
-      repo_id: fx.repository.repoId,
-      operation: 'start',
-      objective: `Benchmark ${mode} work lifecycle`,
-      scope_clear: true,
-      expected_files: 1,
-      expected_changed_lines: 1,
-      requires_recovery: true,
-      allowed_paths: ['README.md'],
-      check_ids: ['package:check:bench'],
-      constraints: { workspaceMode: 'isolated' },
-      request_id: `work-efficiency-start-${label}`,
-    });
-    controllerCalls += 1;
-    const workId = String(started.value.data?.work?.workId ?? '');
-    if (!workId) throw new Error('benchmark Work was not created');
-    const store = { controllerHome: fx.controllerHome, repoId: fx.repository.repoId };
-    const contract = getWorkContract(store, workId);
-    if (!contract?.worktreeRef) throw new Error('benchmark Work has no managed worktree');
-    writeFileSync(join(contract.worktreeRef, 'README.md'), `fixture\n${mode}\n`);
-
-    const verifyArgs = {
-      repo_id: fx.repository.repoId,
-      operation: 'verify',
-      work_id: workId,
-      check_id: 'package:check:bench',
-      request_id: `work-efficiency-verify-${label}`,
-    };
-    const verifySubmit = await timedCall(fx.ctx, verifyArgs);
-    controllerCalls += 1;
-    const processId = String(verifySubmit.value.data?.verification?.processId ?? '');
-    if (!processId) throw new Error('benchmark verification did not return a Process id');
-    const waitStartedAt = performance.now();
-    await waitForProcess(fx.controllerHome, fx.repository.repoId, processId, { timeoutMs: 10_000 });
-    const verifyWaitMs = Math.round((performance.now() - waitStartedAt) * 100) / 100;
-    processWaits += 1;
-
-    const verifyReattach = await timedCall(fx.ctx, verifyArgs);
-    controllerCalls += 1;
-    const verificationOutcome = String(verifyReattach.value.data?.verification?.outcome ?? '');
-    const verificationNextStep = typeof verifyReattach.value.data?.nextStep === 'string'
-      ? verifyReattach.value.data.nextStep
-      : undefined;
-    if (verificationOutcome !== 'valid_pass') throw new Error(`benchmark verification outcome: ${verificationOutcome}`);
-
-    let continueMs = 0;
-    if (mode === 'legacy_ceremony') {
-      const continued = await timedCall(fx.ctx, {
-        repo_id: fx.repository.repoId,
-        operation: 'continue',
-        work_id: workId,
-      });
-      controllerCalls += 1;
-      continueMs = continued.elapsedMs;
-      if (continued.value.data?.nextStep !== 'finalize') throw new Error('legacy ceremony did not reach finalize');
-    }
-
-    const finalized = await timedCall(fx.ctx, {
-      repo_id: fx.repository.repoId,
-      operation: 'finalize',
-      work_id: workId,
-    });
-    controllerCalls += 1;
-    const finalStatus = String(finalized.value.data?.finalStatus ?? '');
-    const cleanupComplete = !existsSync(contract.worktreeRef);
-    const totalMs = Math.round((performance.now() - wallStartedAt) * 100) / 100;
-    return {
-      mode,
-      sample,
-      ok: finalStatus === 'completed' && cleanupComplete,
-      controllerCalls,
-      processWaits,
-      startMs: started.elapsedMs,
-      verifySubmitMs: verifySubmit.elapsedMs,
-      verifyWaitMs,
-      verifyReattachMs: verifyReattach.elapsedMs,
-      continueMs,
-      finalizeMs: finalized.elapsedMs,
-      totalMs,
-      verificationNextStep,
-      finalStatus,
-      cleanupComplete,
-    };
-  } finally {
-    clearRuntimeWriteClaimForTests();
-    rmSync(fx.root, { recursive: true, force: true });
-  }
-}
-
-function percentile(values: number[], p: number): number {
-  if (values.length === 0) return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  const index = Math.min(sorted.length - 1, Math.ceil(sorted.length * p) - 1);
-  return Math.round((sorted[Math.max(0, index)] ?? 0) * 100) / 100;
-}
-
-function summarize(samples: FlowSample[]) {
-  return {
-    count: samples.length,
-    allOk: samples.every((sample) => sample.ok),
-    controllerCalls: samples[0]?.controllerCalls ?? 0,
-    processWaits: samples[0]?.processWaits ?? 0,
-    totalMs: {
-      p50: percentile(samples.map((sample) => sample.totalMs), 0.5),
-      p95: percentile(samples.map((sample) => sample.totalMs), 0.95),
-    },
-    startMs: { p50: percentile(samples.map((sample) => sample.startMs), 0.5), p95: percentile(samples.map((sample) => sample.startMs), 0.95) },
-    verifyWallMs: {
-      p50: percentile(samples.map((sample) => sample.verifySubmitMs + sample.verifyWaitMs + sample.verifyReattachMs), 0.5),
-      p95: percentile(samples.map((sample) => sample.verifySubmitMs + sample.verifyWaitMs + sample.verifyReattachMs), 0.95),
-    },
-    continueMs: { p50: percentile(samples.map((sample) => sample.continueMs), 0.5), p95: percentile(samples.map((sample) => sample.continueMs), 0.95) },
-    finalizeMs: { p50: percentile(samples.map((sample) => sample.finalizeMs), 0.5), p95: percentile(samples.map((sample) => sample.finalizeMs), 0.95) },
-  };
-}
-
-async function main(): Promise<void> {
-  const sampleCount = Math.min(argNumber('--samples', 3), 10);
-  const sourceHeadBefore = git(process.cwd(), ['rev-parse', 'HEAD']);
-  const streamlined: FlowSample[] = [];
-  const legacy: FlowSample[] = [];
-
-  for (let sample = 1; sample <= sampleCount; sample += 1) {
-    if (sample % 2 === 1) {
-      streamlined.push(await runFlow('streamlined', sample));
-      legacy.push(await runFlow('legacy_ceremony', sample));
-    } else {
-      legacy.push(await runFlow('legacy_ceremony', sample));
-      streamlined.push(await runFlow('streamlined', sample));
-    }
-  }
-
-  const sourceHeadAfter = git(process.cwd(), ['rev-parse', 'HEAD']);
-  const streamlinedSummary = summarize(streamlined);
-  const legacySummary = summarize(legacy);
-  const result = {
-    schemaVersion: 1,
-    benchmark: 'work-efficiency',
-    revision: sourceHeadAfter,
-    generatedAt: new Date().toISOString(),
-    sampleCount,
-    methodology: 'Real rh_work start + managed Check Process + authoritative reattach + finalize on isolated temporary repositories. Legacy comparison adds only the mechanical continue call.',
-    streamlined: streamlinedSummary,
-    legacyCeremony: legacySummary,
-    productivity: {
-      controllerCallsSavedPerWork: legacySummary.controllerCalls - streamlinedSummary.controllerCalls,
-      controlRoundTripReductionRatio: legacySummary.controllerCalls > 0
-        ? Math.round(((legacySummary.controllerCalls - streamlinedSummary.controllerCalls) / legacySummary.controllerCalls) * 10_000) / 10_000
-        : 0,
-      measuredContinueCeremonyMsP50: legacySummary.continueMs.p50,
-      totalWallClockDeltaMsP50: Math.round((legacySummary.totalMs.p50 - streamlinedSummary.totalMs.p50) * 100) / 100,
-    },
-    acceptance: {
-      sourceCheckoutHeadStable: sourceHeadBefore === sourceHeadAfter,
-      streamlinedAllOk: streamlinedSummary.allOk,
-      legacyAllOk: legacySummary.allOk,
-      streamlinedDirectsFinalPassToFinalize: streamlined.every((sample) => sample.verificationNextStep === 'finalize'),
-      oneControllerCallSaved: legacySummary.controllerCalls - streamlinedSummary.controllerCalls === 1,
-      cleanupComplete: [...streamlined, ...legacy].every((sample) => sample.cleanupComplete),
-    },
-    samples: { streamlined, legacyCeremony: legacy },
-  };
-  const allAccepted = Object.values(result.acceptance).every(Boolean);
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  if (!allAccepted) process.exitCode = 1;
-}
-
-await main();

package/scripts/build-controller-ui.ts

@@ -1,28 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { build } from 'vite';
-
-const root = resolve(import.meta.dir, '..');
-const configFile = resolve(root, 'src/cli/local-bridge/frontend/vite.config.ts');
-const committedOutdir = resolve(root, 'src/cli/local-bridge/ui-dist');
-const checkOnly = process.argv.includes('--check');
-const outdir = checkOnly ? await mkdtemp(join(tmpdir(), 'forge-controller-ui-')) : committedOutdir;
-
-try {
-  await build({ configFile, build: { outDir: outdir, emptyOutDir: true } });
-  if (checkOnly) {
-    for (const asset of ['app.js', 'app.css']) {
-      const [generated, committed] = await Promise.all([
-        readFile(resolve(outdir, asset), 'utf8'),
-        readFile(resolve(committedOutdir, asset), 'utf8'),
-      ]);
-      if (generated !== committed) throw new Error(`CONTROLLER_UI_BUNDLE_STALE: ${asset}; run bun run build:controller-ui`);
-    }
-    console.log('Controller UI bundle is current.');
-  } else {
-    console.log(`Controller UI built: ${resolve(outdir, 'app.js')}, ${resolve(outdir, 'app.css')}`);
-  }
-} finally {
-  if (checkOnly) await rm(outdir, { recursive: true, force: true });
-}

package/scripts/check-npm-release.sh

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-
-PACKAGE_NAME="$(bun -e 'const pkg = await Bun.file("package.json").json(); console.log(pkg.name)')"
-PACKAGE_VERSION="$(bun -e 'const pkg = await Bun.file("package.json").json(); console.log(pkg.version)')"
-NPM_RELEASE_REGISTRY="${NPM_RELEASE_REGISTRY:-https://registry.npmjs.org/}"
-LOOKUP_STDERR="$(mktemp)"
-trap 'rm -f "$LOOKUP_STDERR"' EXIT
-
-node scripts/check-package-identity.mjs
-node scripts/check-third-party-notices.mjs
-
-echo "[release] package: ${PACKAGE_NAME}@${PACKAGE_VERSION}"
-echo "[release] registry: ${NPM_RELEASE_REGISTRY}"
-if npm view "${PACKAGE_NAME}@${PACKAGE_VERSION}" version --json --registry "$NPM_RELEASE_REGISTRY" >/dev/null 2>"$LOOKUP_STDERR"; then
-  echo "[release] ERROR: ${PACKAGE_NAME}@${PACKAGE_VERSION} already exists on npm." >&2
-  echo "[release] Bump package.json, CLI version, status version, and tests before publishing." >&2
-  exit 1
-fi
-
-if ! grep -Eq 'E404|404 Not Found|No match found|not in this registry' "$LOOKUP_STDERR"; then
-  echo "[release] ERROR: unable to prove ${PACKAGE_NAME}@${PACKAGE_VERSION} is unpublished." >&2
-  cat "$LOOKUP_STDERR" >&2
-  exit 1
-fi
-
-bun run check:release
-
-echo "[release] OK: npm package gate passed."

package/scripts/check-public-release-surface.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-
-echo "[release-surface] typecheck"
-bun run check:type
-
-echo "[release-surface] focused tests"
-bun test --timeout 60000 \
-  tests/cli/local-bridge.test.ts \
-  tests/install-scripts.test.ts \
-  tests/readme-dx.test.ts
-
-echo "[release-surface] public export"
-bun run check:public-export
-
-echo "[release-surface] OK"

package/scripts/check-release-published.sh

@@ -1,57 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-
-PACKAGE_NAME="$(bun -e 'const pkg = await Bun.file("package.json").json(); console.log(pkg.name)')"
-PACKAGE_VERSION="${1:-$(bun -e 'const pkg = await Bun.file("package.json").json(); console.log(pkg.version)')}"
-PACKAGE_DIST_TAG="${NPM_EXPECTED_DIST_TAG:-$(bun -e 'const pkg = await Bun.file("package.json").json(); console.log(pkg.publishConfig?.tag || (pkg.version.includes("-") ? "next" : "latest"))')}"
-NPM_RELEASE_REGISTRY="${NPM_RELEASE_REGISTRY:-https://registry.npmjs.org/}"
-TMP_DIR="$(mktemp -d)"
-trap 'rm -rf "$TMP_DIR"' EXIT
-
-echo "[release-published] package: ${PACKAGE_NAME}@${PACKAGE_VERSION}"
-echo "[release-published] registry: ${NPM_RELEASE_REGISTRY}"
-echo "[release-published] dist-tag: ${PACKAGE_DIST_TAG}"
-
-VIEW_JSON="$TMP_DIR/npm-view.json"
-TAGS_JSON="$TMP_DIR/npm-tags.json"
-PACK_JSON="$TMP_DIR/npm-pack.json"
-
-npm view "${PACKAGE_NAME}@${PACKAGE_VERSION}" version dist.integrity dist.shasum dist.tarball --json --registry "$NPM_RELEASE_REGISTRY" >"$VIEW_JSON"
-npm view "$PACKAGE_NAME" dist-tags --json --registry "$NPM_RELEASE_REGISTRY" >"$TAGS_JSON"
-npm pack "${PACKAGE_NAME}@${PACKAGE_VERSION}" --json --pack-destination "$TMP_DIR" --registry "$NPM_RELEASE_REGISTRY" >"$PACK_JSON"
-
-bun - "$PACKAGE_NAME" "$PACKAGE_VERSION" "$PACKAGE_DIST_TAG" "$VIEW_JSON" "$TAGS_JSON" "$PACK_JSON" <<'JS_EOF'
-const [, , packageName, version, distTag, viewPath, tagsPath, packPath] = process.argv;
-const view = await Bun.file(viewPath).json();
-const tags = await Bun.file(tagsPath).json();
-const pack = await Bun.file(packPath).json();
-const packed = Array.isArray(pack) ? pack[0] : pack;
-
-function fail(message) {
-  console.error(`[release-published] ERROR: ${message}`);
-  process.exit(1);
-}
-
-function packPrefix(name) {
-  return name.replace(/^@/, "").replace(/\//g, "-");
-}
-
-if (view.version !== version) fail(`npm view returned version ${view.version}`);
-if (tags[distTag] !== version) fail(`${distTag} dist-tag is ${tags[distTag]}, expected ${version}`);
-if (!view["dist.integrity"] || !view["dist.shasum"] || !view["dist.tarball"]) {
-  fail("npm view response is missing dist integrity, shasum, or tarball");
-}
-if (!packed?.filename?.startsWith(`${packPrefix(packageName)}-${version}`)) {
-  fail(`npm pack returned unexpected filename ${packed?.filename}`);
-}
-if (packed.integrity !== view["dist.integrity"]) fail("packed tarball integrity does not match registry metadata");
-if (packed.shasum !== view["dist.shasum"]) fail("packed tarball shasum does not match registry metadata");
-JS_EOF
-
-git rev-parse -q --verify "refs/tags/v${PACKAGE_VERSION}" >/dev/null
-bun scripts/check-skill-version.ts --project . >/dev/null
-
-echo "[release-published] OK: registry, ${PACKAGE_DIST_TAG} dist-tag, tarball, tag, and local version files agree."

package/scripts/check-release-readiness.sh

@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-# Release-only checks. Main/type/focused evidence is owned by check:main.
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-
-echo "[release-readiness] version, identity, and notices"
-node scripts/check-release-version.mjs
-node scripts/check-package-identity.mjs
-node scripts/check-third-party-notices.mjs
-
-echo "[release-readiness] focused release contracts"
-bun scripts/test-governance.ts affected \
-  tests/release/release-version.test.ts \
-  tests/release/package-release.test.ts \
-  tests/skill-version.test.ts
-
-echo "[release-readiness] public/package surfaces"
-bash scripts/check-public-docs.sh
-node scripts/check-platform-support.mjs
-bash scripts/check-open-source-tracked-surface.sh
-bun run check:public-export
-
-ARTIFACT_DIR="${FORGE_RELEASE_ARTIFACT_DIR:-$ROOT/.ai/harness/artifacts/release}"
-mkdir -p "$ARTIFACT_DIR"
-TARBALL="$(node -e 'const p=require("./package.json"); process.stdout.write(`${p.name.replace(/^@/, "").replace(/\//g, "-")}-${p.version}.tgz`)')"
-TARBALL_PATH="$ARTIFACT_DIR/$TARBALL"
-echo "[release-readiness] create one reusable tarball"
-rm -f "$TARBALL_PATH"
-npm pack --pack-destination "$ARTIFACT_DIR" >/dev/null
-[[ -f "$TARBALL_PATH" ]] || { echo "[release-readiness] ERROR: npm pack did not create $TARBALL_PATH" >&2; exit 1; }
-printf '%s\n' "$TARBALL_PATH" >"$ARTIFACT_DIR/latest-tarball.txt"
-
-echo "[release-readiness] smoke the same tarball"
-node scripts/run-bounded-command.mjs --timeout-ms 180000 -- bash scripts/check-tarball-install-smoke.sh "$TARBALL_PATH"
-echo "[release-readiness] OK: $TARBALL_PATH"

package/scripts/check-release-version.mjs

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const scriptDir = dirname(fileURLToPath(import.meta.url));
-const root = resolve(scriptDir, "..");
-const args = process.argv.slice(2);
-
-function fail(message) {
-  console.error(`[release-version] ERROR: ${message}`);
-  process.exit(1);
-}
-
-function valueAfter(flag) {
-  const index = args.indexOf(flag);
-  if (index === -1) return undefined;
-  const value = args[index + 1];
-  if (!value || value.startsWith("--")) fail(`${flag} requires a value`);
-  return value;
-}
-
-function nonEmpty(value) {
-  const normalized = String(value ?? "").trim();
-  return normalized || undefined;
-}
-
-const packageJsonArg = valueAfter("--package-json");
-const packageJsonPath = packageJsonArg
-  ? resolve(process.cwd(), packageJsonArg)
-  : resolve(root, "package.json");
-
-let pkg;
-try {
-  pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-} catch (error) {
-  fail(`cannot read package metadata at ${packageJsonPath}: ${error instanceof Error ? error.message : error}`);
-}
-
-const version = String(pkg.version ?? "");
-const match = version.match(/^(\d+\.\d+\.\d+)(?:-rc\.(\d+))?$/);
-if (!match) fail(`unsupported package version: ${version}`);
-
-if (pkg.publishConfig?.tag !== undefined) {
-  fail("publishConfig.tag must be omitted; release commands select next or latest explicitly");
-}
-
-const prerelease = match[2] !== undefined;
-const inferredChannel = prerelease ? "next" : "latest";
-const requestedChannel = valueAfter("--channel");
-if (requestedChannel && !["next", "latest"].includes(requestedChannel)) {
-  fail(`unsupported release channel: ${requestedChannel}`);
-}
-if (requestedChannel && requestedChannel !== inferredChannel) {
-  fail(`${version} must publish to ${inferredChannel}, not ${requestedChannel}`);
-}
-
-const explicitTag = valueAfter("--tag") ?? nonEmpty(process.env.RELEASE_TAG);
-const githubTag = process.env.GITHUB_REF_TYPE === "tag"
-  ? nonEmpty(process.env.GITHUB_REF_NAME)
-  : undefined;
-const releaseTag = explicitTag ?? githubTag;
-const expectedTag = `v${version}`;
-const requireTag = args.includes("--require-tag");
-
-if (releaseTag && releaseTag !== expectedTag) {
-  fail(`release tag ${releaseTag} does not match package version ${expectedTag}`);
-}
-if (requireTag && !releaseTag) {
-  fail(`set RELEASE_TAG=${expectedTag} or run from Git tag ${expectedTag}`);
-}
-
-console.log(`[release-version] OK: ${version} -> ${inferredChannel}${releaseTag ? ` (${releaseTag})` : ""}`);

package/scripts/check-skill-version.ts

@@ -1,5 +0,0 @@
-#!/usr/bin/env bun
-export * from "../assets/templates/helpers/check-skill-version";
-import { runTrackedForgeHelper } from "./lib/run-forge-helper";
-
-if (import.meta.main) runTrackedForgeHelper("check-skill-version.ts");