Skip to content

Commit 26889fd

Browse files
donjor-agent[bot]rsi-pr-agent
authored andcommitted
feat(fork): refuse a fixup! commit that does not fold into its owner (#1619)
> 🤖 claude/anthropic claude-opus-5-5 (high) ## Problem Pull-request CI never checks that a `fixup!` commit folds into the commit it names. The sync folds each fixup during its rebase, so a fixup that only applies at the tip lands green and blocks the next sync. ## Change New `vp run fork:fixup-fold --base <upstream base> --head <head>`: 1. Skips a stack with no `fixup!` 2. Resolves owners with the sync's `resolveFixups` 3. Replays with autosquash in a temp worktree 4. Keeps rerere off during the replay 5. Requires no stops and a tip-equal tree 6. Names each failing fixup and owner Owner lookup handles a squash `(#N)` suffix. It runs as step 4 of `fork:ci` and as a Check job step in `hyprws-ci.yml`. `fork-ci-flags.ts` now also emits the `base=` output that step reads. ## Scope and approval Closes #1554. - [ ] **`fork:ci`:** refuses a fixup that does not fold - [ ] **Check job:** runs the same proof - [ ] **Refusal:** names the fixup and its owner ## Verification | check | result | | --- | --- | | Fold, squash suffix included | passes | | Fixup that applies only at tip | refused, names both | | Fixup naming no fork commit | refused | | Stack without fixups | replay skipped | | command | exit | | --- | --- | | `vp test run`, 4 touched files, 77 tests | 0 | | scripts `tsc --noEmit` | 0 | | `vp run fork:fixup-fold` on this head | 0 | | `vp run fork:ci`, scripts 735 tests | 0 | Claude Opus 5.5 in Claude Code, inside T3 Code; implemented by a Pi child agent. ## Fork trailers Fork-Domain: fork-meta Fork-Tier: core Fork-Upstreamable: no <!-- gh-bot:attest {"v":2,"repo":"RSI-Software/t3code-hyprws","ref":"fix/fork-ci-fixup-fold-proof@24899d1","build":"252611418","agents":[{"role":"host","iface":"claude","provider":"anthropic","model":"claude-opus-5-5","effort":"high","harness":"[email protected]","session":"da5d3d04239a"}],"ts":"2026-10-04T03:05:16Z"} -->
1 parent ae15e93 commit 26889fd

10 files changed

Lines changed: 314 additions & 17 deletions

File tree

‎.github/workflows/hyprws-ci.yml‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -78,6 +78,17 @@ jobs:
7878
SINCE: ${{ steps.fork_ledger.outputs.since }}
7979
run: vp run fork:stale-delete --base "$SINCE" --head "$HEAD_SHA"
8080

81+
# A fixup! the sync would fold must fold now: the sync folds each one
82+
# during its rebase, so a fixup that only applies at the branch tip
83+
# would land green here and then block the next sync. The replay runs
84+
# the trunk-plus-branch stack from the upstream base, the same commit
85+
# the sync rebase starts from.
86+
- name: Fork fixup fold check
87+
env:
88+
HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
89+
BASE: ${{ steps.fork_ledger.outputs.base }}
90+
run: vp run fork:fixup-fold --base "$BASE" --head "$HEAD_SHA"
91+
8192
# Pin to the fork's own base: the rebase-scan table check judges this
8293
# head against the upstream base it sits on, not live upstream/main.
8394
# The argv comes from the shared helper; this step only replays it.

‎docs/fork/internals/fork-development.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -167,6 +167,7 @@ Fork-only paths need no granularity curation.
167167
Fold the ahead commits to one PR-sized intent each: a feature absorbs its fixes and resolutions, so a rebase conflict is solved once.
168168
The [`fork-fold`](../../../.agents/skills/fork-fold/SKILL.md) skill runs it.
169169
Replay sees each commit, not the net, so an upstream line one commit deletes and a later one restores conflicts on every rebase; [`fork:stale-delete`](../../../scripts/lib/fork-stale-delete.ts) refuses that pair in `fork:ci`.
170+
A `fixup!` that only applies at the branch tip lands green and blocks the next sync; [`fork:fixup-fold`](../../../scripts/fork-fixup-fold.ts) proves each fixup folds at its owner in `fork:ci`.
170171
A fold is tree-equal but rewrites commit boundaries: the release delta revision changes, and a nightly may republish the same tree.
171172

172173
| Gate | Detail |

‎package.json‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,7 @@
6060
"fork:fold": "node scripts/fork-fold.ts",
6161
"fork:scan": "node scripts/fork-scan.ts",
6262
"fork:stale-delete": "node scripts/lib/fork-stale-delete.ts",
63+
"fork:fixup-fold": "node scripts/fork-fixup-fold.ts",
6364
"fork:ci": "node scripts/fork-ci.ts",
6465
"fork:sync": "node scripts/fork-sync.ts",
6566
"fork:regenerate-route-tree": "node scripts/lib/regenerate-route-tree.ts",

‎scripts/fork-ci.test.ts‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -82,6 +82,7 @@ it("runs delta, stale-delete, scan, check, and suite in order when every step pa
8282
assert.deepStrictEqual(calls, [
8383
["vp", "run", "fork:delta", "--check", "--head", head],
8484
["vp", "run", "fork:stale-delete", "--base", `${head}^`, "--head", head],
85+
["vp", "run", "fork:fixup-fold", "--base", base, "--head", head],
8586
[
8687
"vp",
8788
"run",
@@ -115,10 +116,11 @@ it("fails a misformatted file through vp check, reformatting nothing", () => {
115116
return command === "vp" && args.length === 1 && args[0] === "check" ? 1 : 0;
116117
};
117118
assert.strictEqual(run([], root, step), 1);
118-
const [delta, staleDelete, scan, check] = calls;
119-
assert.strictEqual(calls.length, 4);
119+
const [delta, staleDelete, fixupFold, scan, check] = calls;
120+
assert.strictEqual(calls.length, 5);
120121
assert.deepStrictEqual(delta?.slice(0, 2), ["vp", "run"]);
121122
assert.deepStrictEqual(staleDelete?.slice(0, 2), ["vp", "run"]);
123+
assert.deepStrictEqual(fixupFold?.slice(0, 2), ["vp", "run"]);
122124
assert.deepStrictEqual(scan?.slice(0, 2), ["vp", "run"]);
123125
assert.deepStrictEqual(check, ["vp", "check"]);
124126
} finally {

‎scripts/fork-ci.ts‎

Lines changed: 26 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -11,11 +11,11 @@
1111
// and the scripts workspace suite runs whole, the way the Test Scripts job
1212
// does, so a local green run cannot be greener than CI
1313
// (RSI-Software/t3code-hyprws#1148). Scope: the Fork ledger delta check,
14-
// the Fork stale-delete check, the Fork rebase scan, the `vp check` step,
15-
// and the Test Scripts job of hyprws-ci.yml. The advisory Body job's
16-
// squash-body check needs the pull-request body, and knip, typecheck, the
17-
// desktop build, the product test jobs, and the release and sync workflows
18-
// run separately.
14+
// the Fork stale-delete check, the Fork fixup fold check, the Fork rebase
15+
// scan, the `vp check` step, and the Test Scripts job of hyprws-ci.yml. The
16+
// advisory Body job's squash-body check needs the pull-request body, and
17+
// knip, typecheck, the desktop build, the product test jobs, and the release
18+
// and sync workflows run separately.
1919

2020
import { deriveForkCiFlags, forkScanArguments, systemForkCiGit } from "./lib/fork-ci-flags.ts";
2121
import { runCommand, SystemGit } from "./lib/fork-command.ts";
@@ -30,16 +30,19 @@ Runs what the fork's pull-request CI jobs run, in CI's own shape:
3030
3. vp run fork:stale-delete --base <since> --head <head>: no branch
3131
commit deletes an upstream line a later one restores
3232
(scripts/lib/fork-stale-delete.ts); skipped under --since
33-
4. vp run fork:scan with exactly those flags (--no-typecheck included),
33+
4. vp run fork:fixup-fold --base <upstream base> --head <head>: every
34+
fixup! commit folds into the commit it names, proved by a replay
35+
from the upstream base in a throwaway worktree (scripts/fork-fixup-fold.ts)
36+
5. vp run fork:scan with exactly those flags (--no-typecheck included),
3437
which carries the additive gate: files, migrations, tests
3538
intact (scripts/lib/fork-additive-gate.ts), the hook guard (marked
3639
insertions only, scripts/lib/fork-hook-guard.ts) and the
3740
replaced-export / upstream-test authoring findings
3841
(scripts/fork-scan-authoring.ts)
39-
5. vp check, the exact form the workflow's Check step runs
42+
6. vp check, the exact form the workflow's Check step runs
4043
(scripts/fork-ci.ts never passes --fix: the fixer reformats files
4144
outside branch scope on this trunk)
42-
6. the whole @t3tools/scripts test suite
45+
7. the whole @t3tools/scripts test suite
4346
4447
Stops at the first failing step. Never runs the Body job's squash-body
4548
check, nor the release or sync workflows.
@@ -116,6 +119,20 @@ export const run = (
116119
return 1;
117120
}
118121

122+
// The sync folds each fixup! into the commit it names during its rebase, so
123+
// a fixup that only applies at the branch tip would land green here and
124+
// then block the next sync (RSI-Software/t3code-hyprws#1554); the replay
125+
// proves the folds from the same upstream base the sync rebase starts from.
126+
const fixupFold = step(
127+
"vp",
128+
["run", "fork:fixup-fold", "--base", flags.base, "--head", flags.head],
129+
root,
130+
);
131+
if (fixupFold !== 0) {
132+
process.stderr.write("fork:ci: fixup fold check failed; fix above before pushing\n");
133+
return 1;
134+
}
135+
119136
const scan = step("vp", ["run", "fork:scan", ...forkScanArguments(flags)], root);
120137
if (scan !== 0) {
121138
process.stderr.write("fork:ci: rebase scan failed; fix above before pushing\n");
@@ -135,7 +152,7 @@ export const run = (
135152
}
136153

137154
process.stdout.write(
138-
"fork:ci: ok; the delta check, stale-delete check, rebase scan, vp check, and scripts suite are green on this head\n",
155+
"fork:ci: ok; the delta check, stale-delete check, fixup fold check, rebase scan, vp check, and scripts suite are green on this head\n",
139156
);
140157
return 0;
141158
};

‎scripts/fork-fixup-fold.test.ts‎

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
// @effect-diagnostics nodeBuiltinImport:off - The fixup fold check is Git plumbing; fixtures need real repositories.
2+
3+
import * as NodeChildProcess from "node:child_process";
4+
import * as NodeFS from "node:fs";
5+
import * as NodeOS from "node:os";
6+
7+
import { assert, it } from "@effect/vitest";
8+
9+
import { fixupFoldFailures } from "./fork-fixup-fold.ts";
10+
11+
const git = (root: string, args: ReadonlyArray<string>): string =>
12+
NodeChildProcess.execFileSync("git", args, { cwd: root, encoding: "utf8" }).trim();
13+
14+
/** Repo-local identity, so the replayed rebase commits without ambient global config. */
15+
const identity = (root: string): void => {
16+
git(root, ["config", "user.name", "Fixup Fold Test"]);
17+
git(root, ["config", "user.email", "[email protected]"]);
18+
git(root, ["config", "commit.gpgsign", "false"]);
19+
};
20+
21+
const commit = (root: string, subject: string, files: Record<string, string>): void => {
22+
for (const [file, text] of Object.entries(files)) NodeFS.writeFileSync(`${root}/${file}`, text);
23+
git(root, ["add", "."]);
24+
git(root, ["commit", "--quiet", "--allow-empty", "-m", subject]);
25+
};
26+
27+
const worktreeCount = (root: string): number =>
28+
git(root, ["worktree", "list", "--porcelain"])
29+
.split("\n")
30+
.filter((line) => line.startsWith("worktree ")).length;
31+
32+
it("passes a stack whose fixups fold at their owners, squash suffix included", () => {
33+
const root = NodeFS.mkdtempSync(NodeOS.tmpdir() + "/fork-fixup-fold-");
34+
try {
35+
git(root, ["init", "--quiet", "--initial-branch", "main"]);
36+
identity(root);
37+
commit(root, "upstream base", { "file.txt": "one\ntwo\nthree\n" });
38+
git(root, ["update-ref", "refs/remotes/upstream/main", "main"]);
39+
const base = git(root, ["rev-parse", "main"]);
40+
commit(root, "owner edit", { "file.txt": "ONE\ntwo\nthree\n" });
41+
commit(root, "later edit", { "file.txt": "ONE\ntwo\nTHREE\n" });
42+
commit(root, "fixup! owner edit (#2)", { "file.txt": "ONE!\ntwo\nTHREE\n" });
43+
assert.deepStrictEqual(fixupFoldFailures(root, base, "HEAD"), []);
44+
// The throwaway replay worktree is gone again.
45+
assert.strictEqual(worktreeCount(root), 1);
46+
} finally {
47+
NodeFS.rmSync(root, { recursive: true, force: true });
48+
}
49+
});
50+
51+
it("refuses a fixup that only folds at the tip, naming fixup and owner", () => {
52+
const root = NodeFS.mkdtempSync(NodeOS.tmpdir() + "/fork-fixup-fold-");
53+
try {
54+
git(root, ["init", "--quiet", "--initial-branch", "main"]);
55+
identity(root);
56+
commit(root, "upstream base", { "file.txt": "a\ntail\n" });
57+
git(root, ["update-ref", "refs/remotes/upstream/main", "main"]);
58+
const base = git(root, ["rev-parse", "main"]);
59+
commit(root, "owner edit", { "file.txt": "b\ntail\n" });
60+
commit(root, "later edit", { "file.txt": "c\ntail\n" });
61+
// The fixup edit builds on the later commit's content, so it applies at
62+
// the tip and nowhere near its owner: the proof must stop there.
63+
commit(root, "fixup! owner edit", { "file.txt": "c!\ntail\n" });
64+
const [failure] = fixupFoldFailures(root, base, "HEAD");
65+
assert.ok(failure?.includes('fixup "fixup! owner edit"'), failure);
66+
assert.ok(failure?.includes('owner "owner edit"'), failure);
67+
// The live checkout is untouched: the tip stands and the replay worktree is gone.
68+
assert.strictEqual(git(root, ["rev-parse", "HEAD"]), git(root, ["rev-parse", "main"]));
69+
assert.strictEqual(worktreeCount(root), 1);
70+
} finally {
71+
NodeFS.rmSync(root, { recursive: true, force: true });
72+
}
73+
});
74+
75+
it("refuses a fixup that names no fork commit", () => {
76+
const root = NodeFS.mkdtempSync(NodeOS.tmpdir() + "/fork-fixup-fold-");
77+
try {
78+
git(root, ["init", "--quiet", "--initial-branch", "main"]);
79+
identity(root);
80+
commit(root, "upstream base", { "file.txt": "a\n" });
81+
git(root, ["update-ref", "refs/remotes/upstream/main", "main"]);
82+
const base = git(root, ["rev-parse", "main"]);
83+
commit(root, "fixup! nothing names this", { "file.txt": "b\n" });
84+
assert.deepStrictEqual(fixupFoldFailures(root, base, "HEAD"), [
85+
'fixup "fixup! nothing names this" names no fork commit above the target',
86+
]);
87+
} finally {
88+
NodeFS.rmSync(root, { recursive: true, force: true });
89+
}
90+
});
91+
92+
it("skips the replay when the stack has no fixups", () => {
93+
const root = NodeFS.mkdtempSync(NodeOS.tmpdir() + "/fork-fixup-fold-");
94+
try {
95+
git(root, ["init", "--quiet", "--initial-branch", "main"]);
96+
identity(root);
97+
commit(root, "upstream base", { "file.txt": "a\n" });
98+
git(root, ["update-ref", "refs/remotes/upstream/main", "main"]);
99+
const base = git(root, ["rev-parse", "main"]);
100+
commit(root, "plain fork commit", { "file.txt": "b\n" });
101+
assert.deepStrictEqual(fixupFoldFailures(root, base, "HEAD"), []);
102+
assert.strictEqual(worktreeCount(root), 1);
103+
} finally {
104+
NodeFS.rmSync(root, { recursive: true, force: true });
105+
}
106+
});

‎scripts/fork-fixup-fold.ts‎

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,154 @@
1+
#!/usr/bin/env node
2+
// @effect-diagnostics nodeBuiltinImport:off - This pre-pull-request check runs before an Effect runtime exists.
3+
4+
// The sync folds every `fixup! <owner subject>` into the commit it names
5+
// during its rebase, so a fixup that only applies at the branch tip lands
6+
// green in pull-request CI and then blocks the next sync
7+
// (RSI-Software/t3code-hyprws#1554). This check proves the folds before
8+
// landing: it replays the trunk-plus-branch stack from the upstream base with
9+
// the sync's own fixup placement (`resolveFixups` and the sequence editor),
10+
// in a throwaway worktree, and requires a stop-free replay whose tree equals
11+
// the unfolded tip. Rerere stays off: a recorded resolution would mask a stop
12+
// the replay must report. A stack without fixups skips the worktree entirely.
13+
14+
import * as NodeFS from "node:fs";
15+
import * as NodeOS from "node:os";
16+
import * as NodePath from "node:path";
17+
18+
import { FIXUP_PREFIX } from "./fork-delta.ts";
19+
import { resolveFixups, type SubjectCommit } from "./fork-sync.ts";
20+
import { parseArgs, UsageError } from "./lib/fork-cli.ts";
21+
import { runCommand, SystemGit } from "./lib/fork-command.ts";
22+
import { FIXUP_OWNERS_ENV, sequenceEditor } from "./lib/fork-sync-todo.ts";
23+
24+
const HELP = `Usage: vp run fork:fixup-fold [--base <ref>] [--head <ref>]
25+
26+
Proves every fixup! commit in <base>..<head> folds into the commit it names.
27+
The sync rebase folds each fixup into its owner, so a fixup that only applies
28+
at the branch tip lands green in pull-request CI and then blocks the next
29+
sync (RSI-Software/t3code-hyprws#1554). The replay runs the stack from
30+
<base> in a throwaway worktree with the sync's own fixup placement and
31+
requires no stops and a tree equal to the unfolded tip. A stack without
32+
fixups skips the replay.
33+
`;
34+
35+
/** The sync rebase's config, minus rerere: the proof must see the raw fold, never a recorded resolution. */
36+
const REPLAY_CONFIG = [
37+
"-c",
38+
"core.commentChar=auto",
39+
"-c",
40+
"diff.algorithm=histogram",
41+
"-c",
42+
"rerere.enabled=false",
43+
"-c",
44+
"maintenance.auto=false",
45+
];
46+
47+
const shortSha = (sha: string): string => sha.slice(0, 7);
48+
49+
const stackSubjects = (git: SystemGit, base: string, head: string): ReadonlyArray<SubjectCommit> =>
50+
git
51+
.run(["log", "--reverse", "--format=%H%x1f%s", `${base}..${head}`])
52+
.split("\n")
53+
.filter(Boolean)
54+
.map((line) => {
55+
const [sha = "", subject = ""] = line.split("\u001f");
56+
return { sha, subject };
57+
});
58+
59+
/** Abort a mid-stop rebase, then claim the worktree and its admin entry; a leaked replay must not outlive the check. */
60+
const removeReplayWorktree = (git: SystemGit, worktree: string): void => {
61+
const rebaseMerge = new SystemGit(worktree).runResult([
62+
"rev-parse",
63+
"--path-format=absolute",
64+
"--git-path",
65+
"rebase-merge",
66+
]);
67+
if (rebaseMerge.status === 0 && NodeFS.existsSync(rebaseMerge.stdout.trim()))
68+
new SystemGit(worktree).runResult(["rebase", "--abort"]);
69+
git.runResult(["worktree", "remove", "--force", worktree]);
70+
NodeFS.rmSync(worktree, { recursive: true, force: true });
71+
git.runResult(["worktree", "prune"]);
72+
};
73+
74+
/**
75+
* Every reason the fixups in `base..head` do not fold at their owners, or an
76+
* empty array when the stack carries no fixup or every fold replays cleanly.
77+
* The replay runs in a throwaway worktree under the system temp dir, removed
78+
* again before this returns.
79+
*/
80+
export const fixupFoldFailures = (
81+
root: string,
82+
base: string,
83+
head: string,
84+
): ReadonlyArray<string> => {
85+
const git = new SystemGit(root);
86+
const subjects = stackSubjects(git, base, head);
87+
if (!subjects.some((commit) => commit.subject.startsWith(FIXUP_PREFIX))) return [];
88+
const fixups = resolveFixups(subjects);
89+
if (fixups.refusals.length > 0) return fixups.refusals;
90+
91+
const nameOf = new Map(subjects.map((commit) => [commit.sha, commit.subject]));
92+
const subjectOf = (sha: string): string => nameOf.get(sha) ?? "unknown";
93+
const name = (sha: string): string => `${subjectOf(sha)} (${shortSha(sha)})`;
94+
const worktree = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "fork-fixup-fold-"));
95+
try {
96+
git.run(["worktree", "add", "--quiet", "--detach", worktree, head]);
97+
const replay = new SystemGit(worktree);
98+
const result = runCommand("git", [...REPLAY_CONFIG, "rebase", "-i", "--autosquash", base], {
99+
cwd: worktree,
100+
env: {
101+
...process.env,
102+
GIT_EDITOR: "true",
103+
GIT_SEQUENCE_EDITOR: sequenceEditor(),
104+
[FIXUP_OWNERS_ENV]: JSON.stringify(fixups.owners),
105+
},
106+
});
107+
if (result.status !== 0) {
108+
const stopped = replay.runResult(["rev-parse", "--verify", "REBASE_HEAD"]);
109+
const stoppedSha = stopped.status === 0 ? stopped.stdout.trim() : "";
110+
const pair = fixups.owners.find(([fixup]) => stoppedSha.startsWith(fixup));
111+
return pair === undefined
112+
? [`the replay stopped at ${name(stoppedSha)}`]
113+
: [
114+
`fixup "${subjectOf(pair[0])}" (${shortSha(pair[0])}) does not fold into its owner "${subjectOf(pair[1])}" (${shortSha(pair[1])}): the replay stopped applying it there`,
115+
];
116+
}
117+
const replayedTree = replay.run(["rev-parse", "HEAD^{tree}"]).trim();
118+
const tipTree = git.run(["rev-parse", `${head}^{tree}`]).trim();
119+
if (replayedTree !== tipTree)
120+
return [
121+
`the replayed tip tree ${shortSha(replayedTree)} differs from the unfolded tip tree ${shortSha(tipTree)}: a fixup did not fold`,
122+
];
123+
return [];
124+
} finally {
125+
removeReplayWorktree(git, worktree);
126+
}
127+
};
128+
129+
export const run = (argv: ReadonlyArray<string>, cwd = process.cwd()): number => {
130+
if (argv.some((argument) => argument === "-h" || argument === "--help")) {
131+
process.stdout.write(HELP);
132+
return 0;
133+
}
134+
let base: string;
135+
let head: string;
136+
try {
137+
const { values } = parseArgs(argv, { values: ["--base", "--head"] });
138+
base = values.get("--base") ?? "upstream/main";
139+
head = values.get("--head") ?? "HEAD";
140+
} catch (error) {
141+
if (!(error instanceof UsageError)) throw error;
142+
process.stderr.write(`usage: ${error.message}\nTry --help.\n`);
143+
return 2;
144+
}
145+
const failures = fixupFoldFailures(cwd, base, head);
146+
if (failures.length === 0) return 0;
147+
process.stderr.write(
148+
`${failures.join("\n")}\n` +
149+
"a fixup! commit must fold into the commit it names: the sync folds each one during its rebase, so a fixup that only applies at the branch tip blocks the next sync; fold it into its owner (fork-fold) or reword it\n",
150+
);
151+
return 1;
152+
};
153+
154+
if (import.meta.main) process.exitCode = run(process.argv.slice(2));

‎scripts/fork-sync.test.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2314,6 +2314,7 @@ it("runs every single-command step of the CI Check job before a direct trunk pus
23142314
const coveredElsewhere = new Set([
23152315
"vp run --filter @t3tools/desktop ensure:electron",
23162316
"vp run fork:stale-delete",
2317+
"vp run fork:fixup-fold",
23172318
"vp check",
23182319
]);
23192320
const workflow = NodeFS.readFileSync(

0 commit comments

Comments
 (0)