opencode-feature-factory 0.2.0 → 0.2.1

package/README.md

@@ -98,9 +98,9 @@ The published package supports Node `>=20`. Repository tooling selects Node `24.
 
 ### Release workflow
 
-Publication is tag-driven only. Pushing `v<package.json version>` (for package version `0.2.0`, `v0.2.0`) triggers the workflow, which checks out that pushed tag, selects Node 24, runs `npm ci`, enforces exact equality between the tag and `v${package.json.version}`, runs `npm run check`, and then runs `npm publish`. The publish job uses the `npm` environment and `id-token: write` for trusted publication.
+Publication is tag-driven only. Pushing `v<package.json version>` (for package version `0.2.1`, `v0.2.1`) triggers the workflow, which checks out that pushed tag, selects Node 24, runs `npm ci`, enforces exact equality between the tag and `v${package.json.version}`, runs `npm run check`, and then runs `npm publish`. The publish job uses the `npm` environment and `id-token: write` for trusted publication.
 
-The workflow does not publish from a branch or manual dispatch, and it does not bump the version, create or push the tag, generate a changelog, push commits, or create a GitHub Release. Operators own those preparatory actions. See [RELEASING.md](https://github.com/jasoncarreira/opencode-feature-factory/blob/main/RELEASING.md) for the repository release guide and [CHANGELOG.md](https://github.com/jasoncarreira/opencode-feature-factory/blob/main/CHANGELOG.md) for the verified 0.2.0 surface record.
+The workflow does not publish from a branch or manual dispatch, and it does not bump the version, create or push the tag, generate a changelog, push commits, or create a GitHub Release. Operators own those preparatory actions. See [RELEASING.md](https://github.com/jasoncarreira/opencode-feature-factory/blob/main/RELEASING.md) for the repository release guide and [CHANGELOG.md](https://github.com/jasoncarreira/opencode-feature-factory/blob/main/CHANGELOG.md) for the verified release records.
 
 ## Local Diagnostics
 
@@ -553,7 +553,7 @@ The preview emits a repository- and evidence-bound digest plus an exact confirma
 feature-factory factory cleanup --all --digest ff-cleanup-v1.<repository-sha256>.<envelope-sha256> [--repo PATH] [--json]
 ```
 
-The sweep never accepts a positional run id, `--force`, or unrelated options. It deletes only runs whose status is exactly `completed` and whose current evidence positively proves all cleanup conditions: canonical PR metadata resolves to the exact merged or closed PR; every recorded local branch is contained in a freshly fetched trustworthy PR base; every recorded worktree and branch has safe containment and exact identity; and no active factory ownership, fresh heartbeat, identity-matching live process, run-state lock, shared target, or contradictory evidence remains. Open or unavailable PRs, unmerged or unprovable branches, malformed state, pre-manifest entries, unsafe paths, and any filesystem, Git, GitHub, lock, heartbeat, process, or sidecar uncertainty are skipped rather than deleted.
+The sweep never accepts a positional run id, `--force`, or unrelated options. It deletes only runs whose status is exactly `completed` and whose current evidence positively proves all cleanup conditions: canonical PR metadata resolves to the exact merged or closed PR; every recorded local branch is contained in a freshly fetched trustworthy PR base at the current head of the canonical base branch; every recorded worktree and branch has safe containment and exact identity; and no active factory ownership, fresh heartbeat, identity-matching live process, run-state lock, shared target, or contradictory evidence remains. Open or unavailable PRs, unmerged or unprovable branches, malformed state, pre-manifest entries, unsafe paths, and any filesystem, Git, GitHub, lock, heartbeat, process, or sidecar uncertainty are skipped rather than deleted.
 
 Execution first recomputes the complete digest and refuses a foreign or stale digest before attempting any candidate. It then acquires each candidate's run-state lock without reclaiming a contested lock and repeats the complete eligibility check while holding that lock. Evidence that changed during lock-held revalidation is skipped. The sweep never takes over a lock, force-deletes a branch, repairs a run, or broadens the recorded cleanup targets.
 
@@ -582,7 +582,7 @@ feature-factory factory cleanup --all --digest ff-cleanup-v1.<repository-sha256>
 
 Sweep flags may appear in any order, but `--all` must appear exactly once and must select exactly one mode: `--dry-run` once for preview or `--digest VALUE` once for execution. `--repo PATH` and `--json` are each optional once. Sweep cleanup accepts no run ID, `--force`, repeated flag, unrelated option, short option, `--flag=value`, or `--` separator. A digest has exactly two 64-character lowercase hexadecimal components. Grammar errors produce one terminal-safe `error:` line on stderr, no report on stdout, and perform no repository inspection.
 
-Sweep cleanup is deliberately stricter than single-run cleanup. A run is eligible only when its status is exactly `completed`, its canonical recorded GitHub PR is currently merged or closed, every recorded branch is proven contained in a freshly fetched PR base, every worktree and branch passes containment and identity checks, and no active ownership, fresh heartbeat, live identity-matching process, run lock, shared target, or contradictory evidence remains. Missing, malformed, inaccessible, stale, foreign, or otherwise unprovable evidence skips deletion; `--force` is not supported with `--all`.
+Sweep cleanup is deliberately stricter than single-run cleanup. A run is eligible only when its status is exactly `completed`, its canonical recorded GitHub PR is currently merged or closed, every recorded branch is proven contained in a freshly fetched PR base at the current head of the canonical base branch, every worktree and branch passes containment and identity checks, and no active ownership, fresh heartbeat, live identity-matching process, run lock, shared target, or contradictory evidence remains. Missing, malformed, inaccessible, stale, foreign, or otherwise unprovable evidence skips deletion; `--force` is not supported with `--all`.
 
 Execution first resolves `--repo` to its physical identity and recomputes the complete digest. The exact physical root, device/inode identity, Git common-directory identity, and object format bind authorization; display text never does. A digest from another repository is refused as `DIGEST_FOREIGN`; changed candidate evidence is refused as `DIGEST_STALE`. Both refusals preserve the recomputed unattempted candidates and counts, provide no confirmation action, and require a fresh preview. After a matching digest, each eligible candidate is locked without lock takeover and fully revalidated immediately before mutation. Changed or contested candidates are skipped. Deletion delegates to the existing identity-checked single-run target semantics, uses no branch force deletion, retains the run directory after a partial target failure, and continues processing independent candidates.
 

package/dist/tui.js

@@ -1846,6 +1846,19 @@ var TOKEN_SHAPED_VALUE_PATTERNS = Object.freeze([
   /(?:^|[^A-Za-z0-9-])(?:[A-Fa-f0-9]{32,})(?=$|[^A-Za-z0-9-])/u,
   /(?:https?|ssh|git|ftp):\/\/[^/\s:@]+:[^/\s@]+@/iu
 ]);
+var TOKEN_SHAPED_FRAGMENT_PATTERNS = Object.freeze([
+  /gh[pousr]_[A-Za-z0-9_]{20,}/iu,
+  /github_pat_[A-Za-z0-9_]{20,}/iu,
+  /hc_[A-Za-z0-9][A-Za-z0-9_-]{10,}/iu,
+  /sk-proj[-_][A-Za-z0-9_-]{20,}/iu,
+  /sk-[A-Za-z0-9_-]{20,}/iu,
+  /xox[abp][_-][A-Za-z0-9-]{10,}(?:-[A-Za-z0-9-]{10,})*/iu,
+  /glpat-[A-Za-z0-9_-]{20,}/iu,
+  /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/iu,
+  /eyJ[A-Za-z0-9_-]{7,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/iu,
+  /(?:AKIA|ASIA)[A-Z0-9]{16}/u,
+  /[A-Fa-f0-9]{32,}/u
+]);
 var ENDPOINT_PROVIDER_PREFIX_PATTERN = /(?:hc[a-z0-9_-]*|gh[pousr]|github_pat|sk(?:-proj)?|xox[abp]|glpat)[_-][A-Za-z0-9_-]{10,}/iu;
 var ENDPOINT_BARE_HEX_PATTERN = /^[A-Fa-f0-9]{32,}$/u;
 var ENDPOINT_SECRET_ASSIGNMENT_PATTERN = /(?:(?:key|token|secret|password|authorization|credential|access|team|api[_-]?key)\s*[=:]|[=:]\s*(?:key|token|secret|password|authorization|credential|access|team|api[_-]?key))/iu;
@@ -1876,11 +1889,23 @@ function isSecretShapedKey(value, { mode = "baseline" } = {}) {
   return tokenShapedValue(trimmed) || credentialBearingUrl2(trimmed) || highEntropySingleToken2(trimmed) || mode === "endpoint" && endpointValueLooksSensitive(trimmed);
 }
 function isSensitiveValue(value, { mode = "baseline" } = {}) {
+  return isRecognizedSensitiveValue(value, { mode }) || highEntropyValue(value);
+}
+function isRecognizedSensitiveValue(value, { mode = "baseline" } = {}) {
   assertMode(mode);
   if (typeof value !== "string") return false;
   const trimmed = value.trim();
   if (!trimmed) return false;
-  return FLATTENED_BASIC_HEADER_PATTERN.test(value) || BASELINE_SENSITIVE_VALUE_PATTERN.test(trimmed) || tokenShapedValue(trimmed) || credentialBearingUrl2(trimmed) || highEntropySingleToken2(trimmed) || mode === "endpoint" && endpointValueLooksSensitive(trimmed);
+  return FLATTENED_BASIC_HEADER_PATTERN.test(value) || BASELINE_SENSITIVE_VALUE_PATTERN.test(trimmed) || tokenShapedValue(trimmed) || credentialBearingUrl2(trimmed) || mode === "endpoint" && endpointValueLooksSensitive(trimmed);
+}
+function containsRecognizedSensitiveFragment(value) {
+  if (typeof value !== "string") return false;
+  return TOKEN_SHAPED_FRAGMENT_PATTERNS.some((pattern) => pattern.test(value));
+}
+function highEntropyValue(value) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  return Boolean(trimmed && highEntropySingleToken2(trimmed));
 }
 function scrubSensitiveString(value, { mode = "baseline" } = {}) {
   assertMode(mode);
@@ -2307,6 +2332,9 @@ var DIAGNOSTIC_FREEFORM_FIELDS = Object.freeze([
   "action"
 ]);
 var OUTPUT_POLICY_ERROR_CODE = "ERR_OUTPUT_POLICY";
+var SAFE_RUN_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/u;
+var DESCRIPTIVE_RUN_ID_PATTERN = /^[a-z]{1,32}(?:-[a-z]{1,32})+(?:-[0-9]{1,6})?$/u;
+var UUID_PATTERN = /[A-Fa-f0-9]{8}(?:-[A-Fa-f0-9]{4}){3}-[A-Fa-f0-9]{12}/u;
 var segmentBrand = /* @__PURE__ */ new WeakSet();
 var TRUSTED_FRAMING_TEXT = Object.freeze({
   EMPTY: "",
@@ -2365,6 +2393,12 @@ function projectFreeformData(value) {
     fail2("projection");
   }
 }
+function isDisplaySafeRunId(value) {
+  if (typeof value !== "string" || !SAFE_RUN_ID_PATTERN.test(value) || value.includes("..") || value.endsWith(".lock") || UUID_PATTERN.test(value)) return false;
+  if (isRecognizedSensitiveValue(value, { mode: "baseline" }) || containsRecognizedSensitiveFragment(value)) return false;
+  if (!isSensitiveValue(value, { mode: "baseline" })) return true;
+  return DESCRIPTIVE_RUN_ID_PATTERN.test(value) && value.split("-").every((segment) => /^\d+$/u.test(segment) || !isSensitiveValue(segment, { mode: "baseline" }));
+}
 function projectDiagnosticData(value, options = void 0) {
   try {
     const policy = readDiagnosticPolicy(options);
@@ -3104,7 +3138,7 @@ function parseErrorDiagnostics(file, error) {
 }
 function summarize(run, fallbackID, file, diagnostics = healthyDiagnostics()) {
   return {
-    run_id: projectFreeformText(run.run_id || fallbackID),
+    run_id: run.run_id === fallbackID && isDisplaySafeRunId(run.run_id) ? run.run_id : REDACTED_VALUE,
     status: projectFreeformText(run.status || "unknown"),
     mode: projectOptionalFreeformText(run.mode),
     gate: projectOptionalFreeformText(pendingGate(run)),
@@ -3126,7 +3160,7 @@ function summarize(run, fallbackID, file, diagnostics = healthyDiagnostics()) {
 }
 function fallbackRun(fallbackID, file, diagnostics) {
   return {
-    run_id: projectFreeformText(fallbackID),
+    run_id: isDisplaySafeRunId(fallbackID) ? fallbackID : REDACTED_VALUE,
     status: "invalid",
     mode: null,
     gate: null,
@@ -3424,7 +3458,7 @@ function renderRunTextFields(run) {
   const slices = renderSliceLine(run?.slices);
   const diagnostic = renderDiagnosticLine(run);
   return {
-    run_id: renderFreeformText(run?.run_id, 31),
+    run_id: renderRunId(run?.run_id),
     status_line: mode ? `${status} | ${mode}` : status,
     gate_line: run?.gate ? `gate: ${renderFreeformText(run.gate)}` : null,
     current_line: run?.current ? `current: ${renderFreeformText(run.current, 34)}` : null,
@@ -3438,6 +3472,10 @@ function renderRunTextFields(run) {
     branch_line: run?.branch ? `branch: ${renderFreeformText(run.branch, 30)}` : null
   };
 }
+function renderRunId(value) {
+  const segment = isDisplaySafeRunId(value) ? identitySegment(value) : freeformSegment(REDACTED_VALUE);
+  return truncate(renderTerminalSegmentsOrFallback([segment]), 31);
+}
 function renderHiddenRunsLine(value) {
   const count = Number.isSafeInteger(value) && value >= 0 ? value : 0;
   return `+ ${renderTerminalSegmentsOrFallback([identitySegment(count)])} more runs`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-feature-factory",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Hybrid opencode plugin and scriptable feature factory workflow.",
   "type": "module",
   "main": "src/plugin.js",

package/src/cleanup-sweep-eligibility.js

@@ -44,7 +44,10 @@ export function discoverCleanupSweepCandidates(repo, options = {}) {
     try {
       const result = classifyEntry(repositoryRoot, entry, collisions.get(entry.entryName) ?? false, {
         ...options,
-        registerTemporaryRef: (temporaryRef) => temporaryRefs.push(temporaryRef),
+        registerTemporaryRef: (temporaryRef, expectedOid) => {
+          temporaryRefs.push(temporaryRef);
+          options.registerTemporaryRef?.(temporaryRef, expectedOid);
+        },
       });
       return result.candidate;
     } catch {
@@ -136,6 +139,7 @@ function worktreeClaimKeys(logical, options) {
 
 function classifyEntry(repo, entry, sharedClaim, options) {
   const evidence = createEmptyEvidence(entry.entryName, entry.logicalPath);
+  let fetchedBaseOid = null;
   evidence.entry = {
     kind: entry.kind,
     logical_path: entry.logicalPath,
@@ -149,6 +153,7 @@ function classifyEntry(repo, entry, sharedClaim, options) {
   const finish = (classification, reasonCodes, runId = evidence.run.run_id, temporaryRef = null) => ({
     candidate: createCandidate({ entry_name: entry.entryName, run_id: runId, classification, reason_codes: sharedClaim ? [...reasonCodes, "SHARED_TARGET_CLAIM"] : reasonCodes, evidence }),
     temporary_ref: temporaryRef,
+    base_oid: fetchedBaseOid,
   });
 
   if (entry.kind !== "directory" || entry.physicalPath !== entry.logicalPath || !SAFE_ENTRY.test(entry.entryName)) return finish("skipped", ["SKIPPED_UNSAFE_ENTRY"], null);
@@ -187,9 +192,9 @@ function classifyEntry(repo, entry, sharedClaim, options) {
   if (pr.state === "OPEN") return finish("skipped", ["SKIPPED_PR_OPEN"]);
 
   const temporaryRef = temporaryRefFor(entry.entryName, options.invocationId ?? randomUUID());
-  options.registerTemporaryRef?.(temporaryRef);
-  if (!verifyFetchedBase(repo, pr, temporaryRef, options.gitRunner ?? git)) return finish("skipped", ["SKIPPED_BASE_UNPROVABLE"], run.run_id, temporaryRef);
-  const targetResult = inspectTargets(repo, run, temporaryRef, pr.base_sha, evidence, options.gitRunner ?? git, options);
+  fetchedBaseOid = fetchVerifiedBase(repo, pr, temporaryRef, options.gitRunner ?? git, options.registerTemporaryRef);
+  if (!fetchedBaseOid) return finish("skipped", ["SKIPPED_BASE_UNPROVABLE"], run.run_id, temporaryRef);
+  const targetResult = inspectTargets(repo, run, temporaryRef, fetchedBaseOid, evidence, options.gitRunner ?? git, options);
   if (targetResult.reason) return finish("skipped", [targetResult.reason], run.run_id, temporaryRef);
   return finish("eligible", ["ELIGIBLE"], run.run_id, temporaryRef);
 }
@@ -479,13 +484,27 @@ function inspectWorktree(repo, target, registered, branches, worktreeRoot, optio
   return { record, reason: null };
 }
 
-function verifyFetchedBase(repo, pr, temporaryRef, gitRunner) {
-  if (!validBranch(repo, pr.base_ref, gitRunner) || !oid(pr.base_sha)) return false;
-  if (gitRunner(repo, ["check-ref-format", temporaryRef])?.ok !== true) return false;
-  const fetch = gitRunner(repo, ["fetch", "--no-tags", "--no-recurse-submodules", "--no-write-fetch-head", "--force", `https://github.com/${pr.repository}.git`, `+refs/heads/${pr.base_ref}:${temporaryRef}`]);
-  if (!fetch?.ok) return false;
+function fetchVerifiedBase(repo, pr, temporaryRef, gitRunner, registerTemporaryRef) {
+  if (!validBranch(repo, pr.base_ref, gitRunner)) return null;
+  const remoteUrl = `https://github.com/${pr.repository}.git`;
+  const remoteRef = `refs/heads/${pr.base_ref}`;
+  const advertised = gitRunner(repo, ["ls-remote", "--exit-code", "--refs", remoteUrl, remoteRef]);
+  const baseOid = advertised?.ok ? exactRemoteOid(advertised.stdout, remoteRef) : null;
+  if (!baseOid) return null;
+  registerTemporaryRef?.(temporaryRef, baseOid);
+  if (gitRunner(repo, ["check-ref-format", temporaryRef])?.ok !== true) return null;
+  const fetch = gitRunner(repo, ["fetch", "--no-tags", "--no-recurse-submodules", "--no-write-fetch-head", "--force", remoteUrl, `+${baseOid}:${temporaryRef}`]);
+  if (!fetch?.ok) return null;
   const resolved = gitRunner(repo, ["rev-parse", "--verify", `${temporaryRef}^{commit}`]);
-  return Boolean(resolved?.ok && resolved.stdout.trim() === pr.base_sha);
+  return resolved?.ok && resolved.stdout.trim() === baseOid ? baseOid : null;
+}
+
+function exactRemoteOid(stdout, expectedRef) {
+  if (typeof stdout !== "string") return null;
+  const lines = stdout.trimEnd().split("\n");
+  if (lines.length !== 1) return null;
+  const match = /^([0-9a-f]{40}|[0-9a-f]{64})\t([^\t\r\n]+)$/u.exec(lines[0]);
+  return match?.[2] === expectedRef && oid(match[1]) ? match[1] : null;
 }
 
 function validBranch(repo, branch, gitRunner) {

package/src/cleanup-sweep-output.js

@@ -6,10 +6,12 @@ import {
 import {
   freeformSegment,
   identitySegment,
+  isDisplaySafeRunId,
   projectFreeformData,
   renderTerminalSegments,
   TRUSTED_SEGMENTS,
 } from "./hardening/output-policy.js";
+import { REDACTED_VALUE } from "./hardening/sensitive-data.js";
 import { serializeTerminalJson } from "./hardening/terminal-encoding.js";
 
 const CONFIRMATION_PREFIX = Object.freeze(["feature-factory", "factory", "cleanup", "--all", "--digest"]);
@@ -100,9 +102,12 @@ function exactReportConfirmation(report) {
 }
 
 function candidateLine(candidate) {
+  const entrySegment = candidate.entry_name === candidate.run_id && isDisplaySafeRunId(candidate.run_id)
+    ? identitySegment(candidate.run_id)
+    : freeformSegment(REDACTED_VALUE);
   return renderTerminalSegments([
     identitySegment(candidate.classification), TRUSTED_SEGMENTS.TAB,
-    freeformSegment(candidate.entry_name), TRUSTED_SEGMENTS.TAB,
+    entrySegment, TRUSTED_SEGMENTS.TAB,
     identitySegment(candidate.reason_codes.join(",")), TRUSTED_SEGMENTS.TAB,
     freeformSegment(candidate.reasons.map((reason) => reason.message).join(" | ")),
   ]);

package/src/cleanup-sweep.js

@@ -1,4 +1,4 @@
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { readFileSync, realpathSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { cleanupRunLocked, CleanupRunChangedError, CleanupRunUnexpectedError } from "./factory.js";
@@ -19,7 +19,6 @@ import {
 } from "./cleanup-sweep-report.js";
 import { RunJsonLockContendedError, withRunJsonLock } from "./run-state.js";
 import { acquireLaunchFence, releaseLaunchFence } from "./process-evidence.js";
-import { canonicalizeGithubPrUrl } from "./refs.js";
 import { validateRun } from "./validate.js";
 
 const utf8 = (left, right) => Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
@@ -37,7 +36,6 @@ export async function previewCleanupSweep(options = {}) {
     const discovery = discoverCleanupSweepCandidates(repository.root_path, tracked.options);
     discoveryComplete = true;
     candidates = discovery.candidates;
-    temporaryRefs.push(...temporaryRefRecords(discovery.temporary_refs, candidates, repository, tracked.prBaseOids));
     const digest = createCleanupSweepDigest(repository, candidates);
     report = createCleanupSweepReport({
       mode: "preview",
@@ -74,7 +72,6 @@ export async function executeCleanupSweep(options = {}) {
     const discovery = discoverCleanupSweepCandidates(repository.root_path, tracked.options);
     discoveryComplete = true;
     candidates = discovery.candidates;
-    temporaryRefs.push(...temporaryRefRecords(discovery.temporary_refs, candidates, repository, tracked.prBaseOids));
     const comparison = compareCleanupSweepDigest(options.digest, repository, candidates);
     await phase(options, "after-digest-recompute", { repository, candidates });
     if (!comparison.matched) {
@@ -187,7 +184,7 @@ async function executeCandidate(repository, authorized, options, invocationId, t
         if (authorizationRecord(normalized) !== authorizationRecord(authorized)) return changedCandidate(normalized);
 
         const baseRef = reclassified.temporary_ref;
-        const baseOid = authorized.evidence.pr.base_sha;
+        const baseOid = reclassified.base_oid;
         const baseState = inspectAuthorizedTemporaryRef(repository.root_path, baseRef, baseOid, mutationGitRunner);
         if (baseState === "changed") return changedCandidate(normalized);
         if (baseState !== "matching") return inspectionFailureCandidate(normalized);
@@ -214,7 +211,7 @@ async function executeCandidate(repository, authorized, options, invocationId, t
             fetchedBaseRef: baseOid,
             fetchedBase: { ref: baseRef, oid: baseOid },
             gitRunner: guardedCleanupGitRunner(repository.root_path, baseRef, baseOid, mutationGitRunner),
-            assertMutationAuthorized: () => assertCandidateMutationAuthorized(repository, authorized, guardedOptions, invocationId, temporaryRefs),
+            assertMutationAuthorized: () => assertCandidateMutationAuthorized(repository, authorized, baseOid, guardedOptions, invocationId, temporaryRefs),
             removeRunDir: options.removeRunDir,
             checkWorktreeIdentity: options.checkWorktreeIdentity,
             physicalPath: options.physicalPath,
@@ -337,67 +334,21 @@ function discoveryOptions(options, invocationId) {
     processOptions: { ...options, ...options.processOptions },
     clock: options.clock,
     invocationId,
+    registerTemporaryRef: options.registerTemporaryRef,
   };
 }
 
-function temporaryRefRecords(refs, candidates, repository, prBaseOids) {
-  return refs.map((ref) => {
-    const candidate = candidates.find((item) => ref.endsWith(sha256RunId(item.entry_name)));
-    const expectedOid = candidate?.evidence?.pr?.base_sha ?? recordedRunBaseOid(repository.root_path, candidate?.entry_name, prBaseOids);
-    return { ref, expected_oid: expectedOid ?? null };
-  });
-}
-
 function trackedDiscoveryOptions(options, invocationId, temporaryRefs) {
-  const githubRunner = options.githubRunner ?? github;
-  const gitRunner = options.gitRunner ?? git;
-  const prBaseOids = new Map();
-  let currentBaseOid = null;
-  const trackedGithubRunner = (...args) => {
-    currentBaseOid = null;
-    const result = githubRunner(...args);
-    try {
-      const body = result?.ok ? JSON.parse(result.stdout) : null;
-      if (typeof body?.html_url === "string" && typeof body?.base?.sha === "string") {
-        currentBaseOid = body.base.sha;
-        prBaseOids.set(canonicalizeGithubPrUrl(body.html_url), currentBaseOid);
-      }
-    } catch {
-      // Invalid responses cannot authorize temporary-ref deletion.
-    }
-    return result;
-  };
-  const trackedGitRunner = (cwd, args, commandOptions) => {
-    if (args[0] === "check-ref-format" && typeof args[1] === "string" && args[1].startsWith("refs/feature-factory/cleanup-sweep/")) {
-      temporaryRefs.push({ ref: args[1], expected_oid: currentBaseOid });
-    }
-    return gitRunner(cwd, args, commandOptions);
-  };
   return {
-    options: discoveryOptions({ ...options, githubRunner: trackedGithubRunner, gitRunner: trackedGitRunner }, invocationId),
-    prBaseOids,
+    options: discoveryOptions({
+      ...options,
+      githubRunner: options.githubRunner ?? github,
+      gitRunner: options.gitRunner ?? git,
+      registerTemporaryRef: (ref, expectedOid) => temporaryRefs.push({ ref, expected_oid: expectedOid }),
+    }, invocationId),
   };
 }
 
-function recordedRunBaseOid(repo, entryName, prBaseOids) {
-  if (!entryName) return null;
-  try {
-    const run = JSON.parse(readFileSync(join(repo, ".opencode", "factory", entryName, "run.json"), "utf8"));
-    const urls = [run?.pr_url, run?.terminal_result?.pr_url].filter((value) => typeof value === "string");
-    for (const url of urls) {
-      const canonical = canonicalizeGithubPrUrl(url);
-      if (prBaseOids.has(canonical)) return prBaseOids.get(canonical);
-    }
-  } catch {
-    // Missing authorization is handled as FAILED_TEMP_REF_CLEANUP if the ref exists.
-  }
-  return null;
-}
-
-function sha256RunId(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-
 async function finalizeAfterTemporaryRefs(report, context) {
   try {
     await cleanupTemporaryRefs(context.temporaryRefs, context);
@@ -453,7 +404,7 @@ async function cleanupTemporaryRefs(records, options) {
 }
 
 function reclassifyHeldCandidate(repository, authorized, options, invocationId, temporaryRefs) {
-  const registerTemporaryRef = (ref) => temporaryRefs.push({ ref, expected_oid: authorized.evidence.pr.base_sha });
+  const registerTemporaryRef = (ref, expectedOid) => temporaryRefs.push({ ref, expected_oid: expectedOid });
   const result = classifyCleanupSweepCandidate(repository.root_path, authorized.entry_name, {
     ...discoveryOptions(options, invocationId),
     heldRunId: authorized.run_id,
@@ -483,13 +434,14 @@ function guardedCleanupGitRunner(repo, baseRef, baseOid, gitRunner) {
   };
 }
 
-function assertCandidateMutationAuthorized(repository, authorized, options, invocationId, temporaryRefs) {
+function assertCandidateMutationAuthorized(repository, authorized, authorizedBaseOid, options, invocationId, temporaryRefs) {
   const reclassified = reclassifyHeldCandidate(repository, authorized, options, invocationId, temporaryRefs);
   const normalized = normalizeHeldLockEvidence(reclassified.candidate);
-  if (sidecarAuthorizationRecord(normalized) !== sidecarAuthorizationRecord(authorized)) throw new CleanupRunChangedError();
+  if (reclassified.base_oid !== authorizedBaseOid
+    || progressiveAuthorizationRecord(normalized) !== progressiveAuthorizationRecord(authorized)) throw new CleanupRunChangedError();
 }
 
-function sidecarAuthorizationRecord(candidate) {
+function progressiveAuthorizationRecord(candidate) {
   return canonicalJson({
     entry_name: candidate.entry_name,
     run_id: candidate.run_id,
@@ -499,6 +451,7 @@ function sidecarAuthorizationRecord(candidate) {
     heartbeat: candidate.evidence.heartbeat,
     process: candidate.evidence.process,
     launch_claim: candidate.evidence.launch_claim,
+    pr: candidate.evidence.pr,
   });
 }
 

package/src/cli-output.js

@@ -1,6 +1,7 @@
 import {
   freeformSegment,
   identitySegment,
+  isDisplaySafeRunId,
   projectFreeformData,
   renderTerminalSegments,
   TRUSTED_SEGMENTS,
@@ -14,7 +15,6 @@ const VALIDATED_STATUS_VALUES = new Set([
   "ok", "partial", "pending", "ready", "rejected", "review", "running", "stopped",
   "unavailable", "warn", "warning",
 ]);
-const SAFE_RUN_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/u;
 const SAFE_UUID_PATTERN = /^[A-Fa-f0-9]{8}(?:-[A-Fa-f0-9]{4}){3}-[A-Fa-f0-9]{12}$/u;
 const SAFE_HASH_PATTERN = /^(?:sha256:)?[A-Fa-f0-9]{32,128}$/u;
 const SAFE_REF_CHARACTERS = /^[A-Za-z0-9._/-]+$/u;
@@ -141,7 +141,7 @@ function projectedValueSegment(key, value) {
 function validatedIdentity(key, value) {
   if (typeof value !== "string") return false;
   if (key === "status" || key === "level") return VALIDATED_STATUS_VALUES.has(value);
-  if (key === "run_id") return !isSensitiveValue(value, { mode: "baseline" }) && SAFE_RUN_ID_PATTERN.test(value);
+  if (key === "run_id") return isDisplaySafeRunId(value);
   if (key === "token" || key === "boundary_token" || key === "action_token" || key === "fence_token") {
     // Factory-issued tokens have exactly one shape: the UUID minted at
     // boundary/action/fence creation (run-state.js randomUUID()); operators only

package/src/hardening/output-policy.js

@@ -1,7 +1,10 @@
 import {
   REDACTED_VALUE,
   SCRUB_MARKERS,
+  containsRecognizedSensitiveFragment,
   isSensitiveKey,
+  isRecognizedSensitiveValue,
+  isSensitiveValue,
   scrubSensitiveData,
   scrubSensitiveString,
 } from "./sensitive-data.js";
@@ -14,6 +17,9 @@ export const DIAGNOSTIC_FREEFORM_FIELDS = Object.freeze([
 ]);
 
 const OUTPUT_POLICY_ERROR_CODE = "ERR_OUTPUT_POLICY";
+const SAFE_RUN_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/u;
+const DESCRIPTIVE_RUN_ID_PATTERN = /^[a-z]{1,32}(?:-[a-z]{1,32})+(?:-[0-9]{1,6})?$/u;
+const UUID_PATTERN = /[A-Fa-f0-9]{8}(?:-[A-Fa-f0-9]{4}){3}-[A-Fa-f0-9]{12}/u;
 const segmentBrand = new WeakSet();
 const structuredErrorBrand = new WeakSet();
 const structuredErrorSegments = new WeakMap();
@@ -92,6 +98,14 @@ export function projectFreeformData(value) {
   try { return scrubSensitiveData(value, { mode: "baseline" }); } catch { fail("projection"); }
 }
 
+export function isDisplaySafeRunId(value) {
+  if (typeof value !== "string" || !SAFE_RUN_ID_PATTERN.test(value) || value.includes("..") || value.endsWith(".lock") || UUID_PATTERN.test(value)) return false;
+  if (isRecognizedSensitiveValue(value, { mode: "baseline" }) || containsRecognizedSensitiveFragment(value)) return false;
+  if (!isSensitiveValue(value, { mode: "baseline" })) return true;
+  return DESCRIPTIVE_RUN_ID_PATTERN.test(value)
+    && value.split("-").every((segment) => /^\d+$/u.test(segment) || !isSensitiveValue(segment, { mode: "baseline" }));
+}
+
 export function projectDiagnosticData(value, options = undefined) {
   try {
     const policy = readDiagnosticPolicy(options);

package/src/hardening/sensitive-data.js

@@ -16,6 +16,19 @@ const TOKEN_SHAPED_VALUE_PATTERNS = Object.freeze([
   /(?:^|[^A-Za-z0-9-])(?:[A-Fa-f0-9]{32,})(?=$|[^A-Za-z0-9-])/u,
   /(?:https?|ssh|git|ftp):\/\/[^/\s:@]+:[^/\s@]+@/iu,
 ]);
+const TOKEN_SHAPED_FRAGMENT_PATTERNS = Object.freeze([
+  /gh[pousr]_[A-Za-z0-9_]{20,}/iu,
+  /github_pat_[A-Za-z0-9_]{20,}/iu,
+  /hc_[A-Za-z0-9][A-Za-z0-9_-]{10,}/iu,
+  /sk-proj[-_][A-Za-z0-9_-]{20,}/iu,
+  /sk-[A-Za-z0-9_-]{20,}/iu,
+  /xox[abp][_-][A-Za-z0-9-]{10,}(?:-[A-Za-z0-9-]{10,})*/iu,
+  /glpat-[A-Za-z0-9_-]{20,}/iu,
+  /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/iu,
+  /eyJ[A-Za-z0-9_-]{7,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/iu,
+  /(?:AKIA|ASIA)[A-Z0-9]{16}/u,
+  /[A-Fa-f0-9]{32,}/u,
+]);
 const ENDPOINT_PROVIDER_PREFIX_PATTERN = /(?:hc[a-z0-9_-]*|gh[pousr]|github_pat|sk(?:-proj)?|xox[abp]|glpat)[_-][A-Za-z0-9_-]{10,}/iu;
 const ENDPOINT_BARE_HEX_PATTERN = /^[A-Fa-f0-9]{32,}$/u;
 const ENDPOINT_SECRET_ASSIGNMENT_PATTERN = /(?:(?:key|token|secret|password|authorization|credential|access|team|api[_-]?key)\s*[=:]|[=:]\s*(?:key|token|secret|password|authorization|credential|access|team|api[_-]?key))/iu;
@@ -53,6 +66,10 @@ export function isSecretShapedKey(value, { mode = "baseline" } = {}) {
 }
 
 export function isSensitiveValue(value, { mode = "baseline" } = {}) {
+  return isRecognizedSensitiveValue(value, { mode }) || highEntropyValue(value);
+}
+
+export function isRecognizedSensitiveValue(value, { mode = "baseline" } = {}) {
   assertMode(mode);
   if (typeof value !== "string") return false;
   const trimmed = value.trim();
@@ -61,10 +78,20 @@ export function isSensitiveValue(value, { mode = "baseline" } = {}) {
     || BASELINE_SENSITIVE_VALUE_PATTERN.test(trimmed)
     || tokenShapedValue(trimmed)
     || credentialBearingUrl(trimmed)
-    || highEntropySingleToken(trimmed)
     || (mode === "endpoint" && endpointValueLooksSensitive(trimmed));
 }
 
+export function containsRecognizedSensitiveFragment(value) {
+  if (typeof value !== "string") return false;
+  return TOKEN_SHAPED_FRAGMENT_PATTERNS.some((pattern) => pattern.test(value));
+}
+
+function highEntropyValue(value) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  return Boolean(trimmed && highEntropySingleToken(trimmed));
+}
+
 export function scrubSensitiveString(value, { mode = "baseline" } = {}) {
   assertMode(mode);
   if (typeof value !== "string") return SCRUB_MARKERS.unsupported;

package/src/tui-data.js

@@ -13,10 +13,12 @@ import {
 } from "./factory-diagnostics.js";
 import {
   freeformSegment,
+  isDisplaySafeRunId,
   projectDiagnosticData,
   projectFreeformData,
   renderTerminalSegmentsOrFallback,
 } from "./hardening/output-policy.js";
+import { REDACTED_VALUE } from "./hardening/sensitive-data.js";
 
 const SKIP_DIRS = new Set([".git", "node_modules", "dist", "coverage", ".cache", ".next"]);
 const MAX_SCAN_DIRS = 2000;
@@ -177,7 +179,7 @@ function parseErrorDiagnostics(file, error) {
 
 function summarize(run, fallbackID, file, diagnostics = healthyDiagnostics()) {
   return {
-    run_id: projectFreeformText(run.run_id || fallbackID),
+    run_id: run.run_id === fallbackID && isDisplaySafeRunId(run.run_id) ? run.run_id : REDACTED_VALUE,
     status: projectFreeformText(run.status || "unknown"),
     mode: projectOptionalFreeformText(run.mode),
     gate: projectOptionalFreeformText(pendingGate(run)),
@@ -200,7 +202,7 @@ function summarize(run, fallbackID, file, diagnostics = healthyDiagnostics()) {
 
 function fallbackRun(fallbackID, file, diagnostics) {
   return {
-    run_id: projectFreeformText(fallbackID),
+    run_id: isDisplaySafeRunId(fallbackID) ? fallbackID : REDACTED_VALUE,
     status: "invalid",
     mode: null,
     gate: null,

package/src/tui-rendering.js

@@ -5,9 +5,11 @@ import {
 import {
   freeformSegment,
   identitySegment,
+  isDisplaySafeRunId,
   renderTerminalSegmentsOrFallback,
   TRUSTED_SEGMENTS,
 } from "./hardening/output-policy.js";
+import { REDACTED_VALUE } from "./hardening/sensitive-data.js";
 
 const RUN_STATUSES = new Set(["running", "completed", "blocked", "partial", "needs-human", "invalid"]);
 const RUN_MODES = new Set(["interactive", "headless", "autonomous"]);
@@ -49,7 +51,7 @@ export function renderRunTextFields(run) {
   const slices = renderSliceLine(run?.slices);
   const diagnostic = renderDiagnosticLine(run);
   return {
-    run_id: renderFreeformText(run?.run_id, 31),
+    run_id: renderRunId(run?.run_id),
     status_line: mode ? `${status} | ${mode}` : status,
     gate_line: run?.gate ? `gate: ${renderFreeformText(run.gate)}` : null,
     current_line: run?.current ? `current: ${renderFreeformText(run.current, 34)}` : null,
@@ -64,6 +66,11 @@ export function renderRunTextFields(run) {
   };
 }
 
+function renderRunId(value) {
+  const segment = isDisplaySafeRunId(value) ? identitySegment(value) : freeformSegment(REDACTED_VALUE);
+  return truncate(renderTerminalSegmentsOrFallback([segment]), 31);
+}
+
 export function renderHiddenRunsLine(value) {
   const count = Number.isSafeInteger(value) && value >= 0 ? value : 0;
   return `+ ${renderTerminalSegmentsOrFallback([identitySegment(count)])} more runs`;