forge-workflow 0.1.0-beta.3 → 0.1.0-beta.5

package/lib/memory-recall-events.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+const { spawn } = require('node:child_process');
+
+const { resolveKernelDatabasePath } = require('./kernel/cli-broker-factory');
+const { createBuiltinSQLiteDriver } = require('./kernel/sqlite-driver');
+const projectMemory = require('./project-memory');
+
+const EVENT_TYPE = 'memory.recall.observed';
+const OUTCOMES = new Set(['selected', 'empty', 'filtered', 'unsupported', 'timeout', 'error']);
+const MAX_COUNT = 1_000_000;
+const MAX_SELECTED_IDS = 20;
+const MAX_MIX_KEYS = 10;
+const EVENT_WRITER = "const { recordMemoryRecallPayload } = require(process.argv[1]); recordMemoryRecallPayload(process.argv[2], JSON.parse(process.argv[3])).catch(() => {});";
+
+function boundedInteger(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(MAX_COUNT, Math.max(0, Math.trunc(value)));
+}
+
+function boundedString(value, maxLength) {
+  return String(value ?? '').slice(0, maxLength);
+}
+
+function boundedMix(mix) {
+  if (!mix || typeof mix !== 'object' || Array.isArray(mix)) return {};
+  return Object.fromEntries(
+    Object.entries(mix)
+      .slice(0, MAX_MIX_KEYS)
+      .map(([label, count]) => [boundedString(label, 64), boundedInteger(count)])
+      .filter(([label, count]) => label && count > 0)
+  );
+}
+
+function buildRecallEventPayload(observation = {}) {
+  const selectedIds = Array.isArray(observation.selectedIds)
+    ? observation.selectedIds
+      .slice(0, MAX_SELECTED_IDS)
+      .map(id => boundedString(id, 128))
+      .filter(Boolean)
+    : [];
+  return {
+    outcome: OUTCOMES.has(observation.outcome) ? observation.outcome : 'error',
+    counts: {
+      candidates: boundedInteger(observation.candidateCount),
+      eligible: boundedInteger(observation.eligibleCount),
+      selected: selectedIds.length,
+    },
+    selected_ids: selectedIds,
+    source_mix: boundedMix(observation.sourceMix),
+    trust_mix: boundedMix(observation.trustMix),
+    token_estimate: boundedInteger(observation.tokenEstimate),
+    elapsed_ms: boundedInteger(observation.elapsedMs),
+    harness: boundedString(observation.harness || 'unknown', 32),
+  };
+}
+
+function normalizeRecallEventPayload(payload = {}) {
+  return buildRecallEventPayload({
+    outcome: payload.outcome,
+    candidateCount: payload.counts?.candidates,
+    eligibleCount: payload.counts?.eligible,
+    selectedIds: payload.selected_ids,
+    sourceMix: payload.source_mix,
+    trustMix: payload.trust_mix,
+    tokenEstimate: payload.token_estimate,
+    elapsedMs: payload.elapsed_ms,
+    harness: payload.harness,
+  });
+}
+
+async function recordMemoryRecallEvent(projectRoot, observation = {}, options = {}) {
+  return recordMemoryRecallPayload(projectRoot, buildRecallEventPayload(observation), options);
+}
+
+async function recordMemoryRecallPayload(projectRoot, payload, options = {}) {
+  let store = options.store;
+  let ownsStore = false;
+  try {
+    const safePayload = normalizeRecallEventPayload(payload);
+    const projectId = options.projectId || projectMemory.resolveProjectId(projectRoot, options);
+    if (!store) {
+      store = createBuiltinSQLiteDriver({
+        databasePath: resolveKernelDatabasePath({
+          projectRoot,
+          gitCommonDir: options.gitCommonDir,
+          databasePath: options.databasePath,
+        }),
+      });
+      ownsStore = true;
+    }
+    const id = (options.randomUUID || randomUUID)();
+    const createdAt = options.now || new Date().toISOString();
+    await store.insertKernelEvent({
+      id,
+      entity_type: 'project',
+      entity_id: projectId,
+      event_type: EVENT_TYPE,
+      idempotency_key: id,
+      expected_revision: 0,
+      actor: 'forge',
+      origin: 'hook',
+      payload: safePayload,
+      created_at: createdAt,
+    });
+    return { recorded: true, eventId: id };
+  } catch (error) {
+    return {
+      recorded: false,
+      reason: error && error.message ? error.message : 'telemetry unavailable',
+    };
+  } finally {
+    if (ownsStore && store && typeof store.close === 'function') {
+      try {
+        store.close();
+      } catch {
+        // Best-effort evidence must never block recall.
+      }
+    }
+  }
+}
+
+function launchMemoryRecallEvent(projectRoot, observation = {}, options = {}) {
+  try {
+    const child = (options.spawn || spawn)(
+      process.execPath,
+      ['-e', EVENT_WRITER, __filename, projectRoot, JSON.stringify(buildRecallEventPayload(observation))],
+      { detached: true, stdio: 'ignore', windowsHide: true },
+    );
+    if (child && typeof child.on === 'function') child.on('error', () => {});
+    if (child && typeof child.unref === 'function') child.unref();
+    return { launched: true };
+  } catch {
+    return { launched: false };
+  }
+}
+
+module.exports = {
+  EVENT_TYPE,
+  buildRecallEventPayload,
+  launchMemoryRecallEvent,
+  recordMemoryRecallEvent,
+  recordMemoryRecallPayload,
+};

package/lib/memory-recall.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const { fenceUntrusted } = require('./untrusted-content');
+
+/**
+ * @module memory-recall
+ *
+ * Pure selection core for the per-turn memory-recall hook (the query-relevant tier-2
+ * that complements the recency digest pushed at SessionStart). Kept free of stdin/fs so
+ * it is fully testable; lib/commands/hooks.js does the I/O wiring around it.
+ *
+ * Design constraints (verified against the Claude Code hooks contract + external memory
+ * research, kernel issue 781f6f65):
+ *   - UserPromptSubmit additionalContext APPENDS to history every prompt, so a per-turn
+ *     injector must stay tiny: a hard token budget, a relevance floor, and cross-turn
+ *     dedupe. Below the bar -> inject NOTHING (silence is safe; a wrong memory at
+ *     authority every turn is not).
+ *   - Anaphora guard: a trivial query ("continue", "fix it") carries no retrieval signal,
+ *     so ranking on it is worse than silence. Require a minimum of distinct content tokens.
+ *   - Scope is a FILTER; relevance is the RANKER (bm25). Never sort by recency here — that
+ *     is the recency digest's job, not tier-2's.
+ */
+
+// A query needs at least this many distinct content tokens to be worth ranking on.
+// Below it we treat the prompt as anaphora and inject nothing.
+const MIN_QUERY_TOKENS = 2;
+
+// Default token budget for the whole tier-2 injection. Deliberately small: it rides on
+// EVERY prompt, and it must never starve the always-on SessionStart digest.
+const DEFAULT_TOKEN_BUDGET = 400;
+
+// Default relevance floor for the live hook path so it never runs floor-less. bm25 is
+// more-negative-is-better, so 0 keeps every token-AND FTS match: the ACTIVE relevance gate
+// today is the token-AND match plus the anaphora guard, and the numeric floor is a knob to
+// be tightened (made negative) once shadow-logging measurement (781f6f65 step 0) shows where
+// the corpus's relevant/irrelevant boundary sits. Named + wired so the default is explicit,
+// not an accidental `undefined`.
+const DEFAULT_SCORE_FLOOR = 0;
+
+// Short/function words that carry no retrieval signal. Not exhaustive — just enough to
+// stop pure anaphora ("do that now", "same for it") from clearing the guard.
+const STOPWORDS = new Set([
+  'the', 'a', 'an', 'and', 'or', 'but', 'for', 'to', 'of', 'in', 'on', 'at', 'by', 'is',
+  'it', 'this', 'that', 'these', 'those', 'do', 'did', 'now', 'then', 'same', 'again',
+  'continue', 'go', 'ok', 'okay', 'yes', 'no', 'fix', 'please', 'thanks', 'with', 'as',
+  'we', 'i', 'you', 'he', 'she', 'they', 'them', 'his', 'her', 'my', 'our', 'your',
+]);
+
+// Rough token estimate: ~4 chars/token, matching lib/memory-digest.js's convention so
+// the two tiers budget on the same scale.
+function estimateTokens(text) {
+  return Math.ceil(String(text || '').length / 4);
+}
+
+function normalizeMemoryType(entry) {
+  const tags = Array.isArray(entry?.tags) ? entry.tags : [];
+  const tagged = tags.find(tag => /^type:[a-z0-9][a-z0-9-]{0,63}$/i.test(tag));
+  if (tagged) return tagged.slice('type:'.length).toLowerCase();
+  const category = entry?.value && typeof entry.value === 'object'
+    ? entry.value.category
+    : null;
+  if (typeof category === 'string' && /^[a-z0-9][a-z0-9-]{0,63}$/i.test(category)) {
+    return category.toLowerCase();
+  }
+  return entry?.value && typeof entry.value === 'object' ? 'machine-record' : 'note';
+}
+
+function memoryTrustStatus(entry) {
+  const tags = Array.isArray(entry?.tags) ? entry.tags : [];
+  const normalizedTags = tags.map(tag => String(tag).toLowerCase());
+  if (normalizedTags.includes('trust:confirmed')) return 'confirmed';
+  if (normalizedTags.some(tag => tag.startsWith('trust:')
+    || tag === 'forge:auto-capture')) return 'suggested';
+  if (entry?.sourceAgent === 'forge remember (imported)') return 'suggested';
+  if (entry?.value && typeof entry.value === 'object') return 'suggested';
+  if (entry?.sourceAgent === 'forge remember' && typeof entry.value === 'string') return 'confirmed';
+  return 'suggested';
+}
+
+function normalizeRecallHit(entry, projectId) {
+  if (!entry) return null;
+  if (entry.memory_id) return entry;
+  const sourceRefs = Array.isArray(entry.beadsRefs) ? entry.beadsRefs : [];
+  return {
+    memory_id: entry.key,
+    type: normalizeMemoryType(entry),
+    content: typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value),
+    scope: !entry.scope || entry.scope === 'project' ? projectId : entry.scope,
+    trust_status: memoryTrustStatus(entry),
+    provenance: {
+      source_agent: entry.sourceAgent || '',
+      source_refs: sourceRefs,
+    },
+    updated_at: entry.timestamp,
+    score: entry.score,
+  };
+}
+
+/**
+ * Parse the JSON payload Claude Code delivers on a UserPromptSubmit hook's stdin. Never
+ * throws — any malformed input yields an empty prompt so the hook fails open.
+ *
+ * @param {string} raw
+ * @returns {{ prompt: string, sessionId: (string|null) }}
+ */
+function parseHookInput(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { prompt: '', sessionId: null };
+    }
+    const prompt = typeof parsed.prompt === 'string' ? parsed.prompt : '';
+    const sessionId = typeof parsed.session_id === 'string' ? parsed.session_id : null;
+    return { prompt, sessionId };
+  } catch {
+    return { prompt: '', sessionId: null };
+  }
+}
+
+/**
+ * Distinct content tokens in a query — lowercased, length >= 3, minus stopwords. The
+ * anaphora guard counts these; the FTS layer does its own tokenization for the actual match.
+ *
+ * @param {string} query
+ * @returns {string[]}
+ */
+function meaningfulTokens(query) {
+  const seen = new Set();
+  // Unicode-aware split, matching the FTS tokenizer (/[\p{L}\p{N}]+/gu in the kernel driver)
+  // so non-Latin prompts (Cyrillic/CJK/accented) aren't silently stripped — otherwise the
+  // anaphora guard would disable recall for every non-Latin-script user.
+  for (const rawToken of String(query || '').toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+    if (!rawToken) continue;
+    if (STOPWORDS.has(rawToken)) continue;
+    // The length>=3 filter suppresses ASCII noise ("it", "do"), but CJK words are 1-2 chars
+    // and any non-ASCII token is inherently content — keep those regardless of length.
+    if (rawToken.length < 3 && /^[a-z0-9]+$/.test(rawToken)) continue;
+    seen.add(rawToken);
+  }
+  return [...seen];
+}
+
+/**
+ * Choose which memories to inject this turn. PURE.
+ *
+ * @param {object} args
+ * @param {string} args.query — the submitted prompt
+ * @param {Array<{memory_id:string, content:string, score:number}>} args.hits — bm25-ordered
+ *   (best/lowest score first), already relevance-only (token-AND matched)
+ * @param {number} [args.scoreFloor] — keep only hits with score <= floor (more negative =
+ *   stronger). Omit/null to rely on the FTS match alone. The VALUE is corpus-dependent and
+ *   should be tuned from shadow-logging measurement, not guessed — this is the knob.
+ * @param {number} [args.tokenBudget]
+ * @param {string[]} [args.excludeKeys] — keys injected on recent turns (cross-turn dedupe)
+ * @returns {{ lines: string[], injectedKeys: string[] }}
+ */
+function selectInjection({ query, hits, scoreFloor = null, tokenBudget = DEFAULT_TOKEN_BUDGET, excludeKeys = [] }) {
+  // Anaphora guard: a query with too little signal ranks garbage — stay silent.
+  if (meaningfulTokens(query).length < MIN_QUERY_TOKENS) {
+    return { lines: [], injectedKeys: [] };
+  }
+
+  const exclude = new Set(excludeKeys || []);
+  const lines = [];
+  const entries = [];
+  const injectedKeys = [];
+  const usedSections = new Set();
+  let spent = 0;
+
+  for (const hit of hits || []) {
+    const memoryId = hit?.memory_id ?? hit?.key;
+    if (typeof memoryId !== 'string') continue;
+    if (exclude.has(memoryId)) continue;
+    // Relevance floor: below the bar contributes nothing. bm25 is more-negative-is-better.
+    if (typeof scoreFloor === 'number' && !(typeof hit.score === 'number' && hit.score <= scoreFloor)) {
+      continue;
+    }
+    const body = String((hit.content ?? hit.value) == null ? '' : (hit.content ?? hit.value));
+    const trust = hit.trust_status === 'confirmed' ? 'confirmed' : 'suggested';
+    const source = String(hit.provenance?.source_agent || hit.sourceAgent || 'unknown').slice(0, 80);
+    const updated = String(hit.updated_at || hit.timestamp || 'unknown').slice(0, 40);
+    const labeled = `[trust=${trust} source=${source} updated=${updated}] ${body}`;
+    const line = fenceUntrusted(labeled, { source: 'memory' });
+    const heading = trust === 'confirmed'
+      ? 'Confirmed memory (project-local; provenance shown)'
+      : 'Suggested memory — verify before relying';
+    const cost = estimateTokens(line) + (usedSections.has(trust) ? 0 : estimateTokens(`${heading}\n`));
+    if (spent + cost > tokenBudget) {
+      continue;
+    }
+    lines.push(line);
+    entries.push({ trust, line });
+    injectedKeys.push(memoryId);
+    usedSections.add(trust);
+    spent += cost;
+  }
+
+  return { lines, entries, injectedKeys };
+}
+
+module.exports = {
+  MIN_QUERY_TOKENS,
+  DEFAULT_TOKEN_BUDGET,
+  DEFAULT_SCORE_FLOOR,
+  estimateTokens,
+  memoryTrustStatus,
+  normalizeMemoryType,
+  normalizeRecallHit,
+  parseHookInput,
+  meaningfulTokens,
+  selectInjection,
+};

package/lib/merge-rules.js

@@ -54,7 +54,7 @@
  * (squash | merge | rebase); and post-merge branch deletion.
  */
 
-const SUCCESS_CONCLUSIONS = new Set(['SUCCESS', 'NEUTRAL', 'SKIPPED', 'PASS', 'PASSED']);
+const SUCCESS_CONCLUSIONS = new Set(['SUCCESS']);
 const MS_PER_MIN = 60_000;
 
 /** Coerce an epoch-ms number, a Date, or an ISO string to epoch ms (NaN if unparseable). */
@@ -85,11 +85,15 @@ function toAccountList(arg) {
   return [String(arg).trim().toLowerCase()];
 }
 
-/** A CI check is green if its conclusion is a success-class conclusion. */
+/** A CI check is green only when it is terminal and explicitly successful. */
 function isCheckGreen(check) {
   if (!check || typeof check !== 'object') return false;
-  const conclusion = String(check.conclusion ?? check.state ?? check.status ?? '').toUpperCase();
-  return SUCCESS_CONCLUSIONS.has(conclusion);
+  if (Object.prototype.hasOwnProperty.call(check, 'state')
+    && !Object.prototype.hasOwnProperty.call(check, 'status')) {
+    return String(check.state || '').toUpperCase() === 'SUCCESS';
+  }
+  return String(check.status || '').toUpperCase() === 'COMPLETED'
+    && SUCCESS_CONCLUSIONS.has(String(check.conclusion || '').toUpperCase());
 }
 
 /** The most recent comment by timestamp; ties and unparseable stamps fall back to array order. */

package/lib/npm-publish-workflow.js

@@ -0,0 +1,272 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+	createProtectedStateAuditRecord,
+	recordProtectedStateAuditEvent,
+	writeProtectedFile,
+} = require('./protected-state-surfaces');
+const {
+	issueNpmPublishWorkflowAuthorization,
+} = require('./protected-state-authority');
+
+const NPM_PUBLISH_WORKFLOW_PATH = '.github/workflows/npm-publish.yml';
+
+function snapshotWorkflow(projectRoot) {
+	const fullPath = path.resolve(projectRoot, NPM_PUBLISH_WORKFLOW_PATH);
+	try {
+		const stat = fs.lstatSync(fullPath);
+		return {
+			fullPath,
+			existed: true,
+			content: stat.isFile() ? fs.readFileSync(fullPath) : null,
+		};
+	} catch (error) {
+		if (error.code === 'ENOENT') return { fullPath, existed: false, content: null };
+		throw error;
+	}
+}
+
+function rollbackWorkflow(snapshot, projectRoot, protectedWriter, writeOptions) {
+	if (!snapshot.existed) {
+		fs.rmSync(snapshot.fullPath, { force: true });
+		return;
+	}
+	if (!Buffer.isBuffer(snapshot.content)) {
+		throw new Error('Previous workflow was not a regular file');
+	}
+	const restored = protectedWriter(
+		projectRoot,
+		NPM_PUBLISH_WORKFLOW_PATH,
+		snapshot.content,
+		writeOptions,
+	);
+	if (!restored.allowed) throw new Error(restored.reason || 'Protected workflow restore was denied');
+}
+
+function renderNpmPublishWorkflow() {
+	return `# Generated by \`forge release generate-npm-workflow\`. Do not edit directly.
+name: Bun Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  resolve-release:
+    name: Resolve immutable release SHA
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      commitSha: \${{ steps.resolve.outputs.commitSha }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: \${{ github.event.release.tag_name }}
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Resolve release tag
+        id: resolve
+        shell: bash
+        env:
+          RELEASE_TAG: \${{ github.event.release.tag_name }}
+        run: |
+          set -euo pipefail
+          COMMIT_SHA="$(git rev-parse "\${RELEASE_TAG}^{commit}")"
+          if [ -z "$COMMIT_SHA" ] || [ "$COMMIT_SHA" != "$(git rev-parse HEAD)" ]; then
+            echo "::error::Release tag did not resolve to the checked out commit"
+            exit 1
+          fi
+          echo "commitSha=$COMMIT_SHA" >> "$GITHUB_OUTPUT"
+
+  build:
+    needs: resolve-release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      commitSha: \${{ steps.evidence.outputs.commitSha }}
+      receipt: \${{ steps.evidence.outputs.receipt }}
+      receiptSubject: \${{ steps.evidence.outputs.receiptSubject }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: \${{ needs.resolve-release.outputs.commitSha }}
+          fetch-depth: 1
+          persist-credentials: false
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 22
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.3.12
+      - run: bun install --frozen-lockfile
+      - name: Setup test fixtures
+        shell: bash
+        run: bash test-env/automation/setup-fixtures.sh --force
+      - name: Run complete release suite
+        shell: bash
+        run: |
+          set -euo pipefail
+          node scripts/test-full-suite.js --label-prefix release-full
+      - name: Emit attributable release suite receipt
+        id: evidence
+        env:
+          EXPECTED_SHA: \${{ needs.resolve-release.outputs.commitSha }}
+        run: node scripts/npm-release-receipt.js emit
+
+  publish-npm:
+    needs: [resolve-release, build]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: \${{ needs.resolve-release.outputs.commitSha }}
+          fetch-depth: 1
+          persist-credentials: false
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org/
+      - name: Verify exact release suite receipt
+        env:
+          EXPECTED_SHA: \${{ needs.resolve-release.outputs.commitSha }}
+          VERIFIED_SHA: \${{ needs.build.outputs.commitSha }}
+          RECEIPT: \${{ needs.build.outputs.receipt }}
+          RECEIPT_SUBJECT: \${{ needs.build.outputs.receiptSubject }}
+        run: node scripts/npm-release-receipt.js verify
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.3.12
+      - run: bun install --frozen-lockfile
+      - name: Release tag matches package.json version
+        shell: bash
+        run: |
+          set -euo pipefail
+          PKG="$(node -p "require('./package.json').version")"
+          TAG="\${GITHUB_REF_NAME#v}"
+          if [ "$PKG" != "$TAG" ]; then
+            echo "::error::Release tag ($TAG) != package.json version ($PKG). Bump package.json before releasing."
+            exit 1
+          fi
+      - name: Release-readiness gate
+        run: node bin/forge.js release check --target "$(node -p "require('./package.json').version.split('-')[0]")"
+      - name: Verify package contents
+        run: npm pack --dry-run
+      - name: Ensure OIDC-capable npm
+        run: npm install --global npm@11.5.1 && npm --version
+      - name: Publish to npm
+        shell: bash
+        run: |
+          set -euo pipefail
+          VERSION="$(node -p "require('./package.json').version")"
+          if echo "$VERSION" | grep -q '-'; then
+            echo "Prerelease $VERSION -> publishing under the beta dist-tag"
+            npm publish --provenance --tag beta
+          else
+            npm publish --provenance
+          fi
+`;
+}
+
+async function generateNpmPublishWorkflow(projectRoot, options = {}) {
+	const content = renderNpmPublishWorkflow();
+	const actor = options.actor || options.env?.FORGE_ACTOR || process.env.FORGE_ACTOR || process.env.USER || process.env.USERNAME || 'unknown';
+	const protectedWriter = options.writeProtectedFile || writeProtectedFile;
+	const auditWriter = options.recordProtectedStateAuditEvent || recordProtectedStateAuditEvent;
+	const authorizationWriter = options.issueNpmPublishWorkflowAuthorization || issueNpmPublishWorkflowAuthorization;
+	const snapshot = snapshotWorkflow(projectRoot);
+	const writeOptions = {
+		actor,
+		operation: 'generate_npm_workflow',
+		viaForgeApi: true,
+		surface: 'workflows',
+	};
+	let write;
+	try {
+		write = protectedWriter(projectRoot, NPM_PUBLISH_WORKFLOW_PATH, content, writeOptions);
+	} catch (error) {
+		return { success: false, error: error.message };
+	}
+	if (!write.allowed) {
+		return { success: false, error: write.reason, write };
+	}
+
+	const auditRecord = createProtectedStateAuditRecord({
+		actor,
+		surface: 'workflows',
+		path: NPM_PUBLISH_WORKFLOW_PATH,
+		content,
+		operation: 'generate_npm_workflow',
+	});
+	let audit;
+	try {
+		audit = auditWriter(auditRecord, { cwd: projectRoot });
+	} catch (error) {
+		audit = { success: false, error: error.message };
+	}
+	if (!audit.success) {
+		let rollbackError;
+		try {
+			rollbackWorkflow(snapshot, projectRoot, protectedWriter, writeOptions);
+		} catch (error) {
+			rollbackError = error.message;
+		}
+		return {
+			success: false,
+			error: `Could not record protected-state authorization: ${audit.error}`,
+			audit,
+			rollbackError,
+		};
+	}
+
+	let trustedAuthorization;
+	try {
+		trustedAuthorization = await authorizationWriter(
+			projectRoot,
+			{ actor },
+			{ deps: options.kernelDeps },
+		);
+	} catch (error) {
+		trustedAuthorization = { success: false, error: error.message };
+	}
+	if (!trustedAuthorization.success) {
+		let rollbackError;
+		try {
+			rollbackWorkflow(snapshot, projectRoot, protectedWriter, writeOptions);
+		} catch (error) {
+			rollbackError = error.message;
+		}
+		return {
+			success: false,
+			error: `Could not record trusted protected-state authorization: ${trustedAuthorization.error}`,
+			audit,
+			trustedAuthorization,
+			rollbackError,
+		};
+	}
+
+	return {
+		success: true,
+		path: NPM_PUBLISH_WORKFLOW_PATH,
+		contentHash: write.contentHash,
+		write,
+		audit,
+		trustedAuthorization,
+	};
+}
+
+module.exports = {
+	NPM_PUBLISH_WORKFLOW_PATH,
+	renderNpmPublishWorkflow,
+	generateNpmPublishWorkflow,
+};