oh-my-codex 0.21.47 → 0.22.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/Cargo.lock +6 -6
- package/Cargo.toml +1 -1
- package/README.md +15 -0
- package/crates/omx-mux/src/herdr.rs +481 -0
- package/crates/omx-mux/src/lib.rs +5 -0
- package/dist/cli/__tests__/plugin-cache-live-pin-3790.test.js +707 -47
- package/dist/cli/__tests__/plugin-cache-live-pin-3790.test.js.map +1 -1
- package/dist/cli/__tests__/session-compare.test.d.ts +2 -0
- package/dist/cli/__tests__/session-compare.test.d.ts.map +1 -0
- package/dist/cli/__tests__/session-compare.test.js +183 -0
- package/dist/cli/__tests__/session-compare.test.js.map +1 -0
- package/dist/cli/__tests__/setup-install-mode.test.js +7 -1
- package/dist/cli/__tests__/setup-install-mode.test.js.map +1 -1
- package/dist/cli/__tests__/team.test.js +8 -0
- package/dist/cli/__tests__/team.test.js.map +1 -1
- package/dist/cli/plugin-marketplace.d.ts.map +1 -1
- package/dist/cli/plugin-marketplace.js +328 -142
- package/dist/cli/plugin-marketplace.js.map +1 -1
- package/dist/cli/session-compare.d.ts +11 -0
- package/dist/cli/session-compare.d.ts.map +1 -0
- package/dist/cli/session-compare.js +172 -0
- package/dist/cli/session-compare.js.map +1 -0
- package/dist/cli/session-search.d.ts.map +1 -1
- package/dist/cli/session-search.js +7 -0
- package/dist/cli/session-search.js.map +1 -1
- package/dist/cli/team.d.ts.map +1 -1
- package/dist/cli/team.js +2 -0
- package/dist/cli/team.js.map +1 -1
- package/dist/config/__tests__/multiplexer.test.d.ts +2 -0
- package/dist/config/__tests__/multiplexer.test.d.ts.map +1 -0
- package/dist/config/__tests__/multiplexer.test.js +118 -0
- package/dist/config/__tests__/multiplexer.test.js.map +1 -0
- package/dist/config/multiplexer.d.ts +29 -0
- package/dist/config/multiplexer.d.ts.map +1 -0
- package/dist/config/multiplexer.js +91 -0
- package/dist/config/multiplexer.js.map +1 -0
- package/dist/hooks/__tests__/sunset-routing-contract.test.js +4 -2
- package/dist/hooks/__tests__/sunset-routing-contract.test.js.map +1 -1
- package/dist/scripts/__tests__/codex-native-hook.test.js +281 -1
- package/dist/scripts/__tests__/codex-native-hook.test.js.map +1 -1
- package/dist/scripts/__tests__/generate-release-body.test.js +142 -5
- package/dist/scripts/__tests__/generate-release-body.test.js.map +1 -1
- package/dist/scripts/codex-native-hook.d.ts.map +1 -1
- package/dist/scripts/codex-native-hook.js +8 -2
- package/dist/scripts/codex-native-hook.js.map +1 -1
- package/dist/scripts/generate-release-body.d.ts.map +1 -1
- package/dist/scripts/generate-release-body.js +14 -0
- package/dist/scripts/generate-release-body.js.map +1 -1
- package/dist/scripts/notify-hook/team-worker-lease.d.ts +15 -0
- package/dist/scripts/notify-hook/team-worker-lease.d.ts.map +1 -0
- package/dist/scripts/notify-hook/team-worker-lease.js +63 -0
- package/dist/scripts/notify-hook/team-worker-lease.js.map +1 -0
- package/dist/scripts/notify-hook/team-worker-posttooluse.d.ts +1 -0
- package/dist/scripts/notify-hook/team-worker-posttooluse.d.ts.map +1 -1
- package/dist/scripts/notify-hook/team-worker-posttooluse.js +16 -5
- package/dist/scripts/notify-hook/team-worker-posttooluse.js.map +1 -1
- package/dist/scripts/notify-hook/team-worker.d.ts +12 -1
- package/dist/scripts/notify-hook/team-worker.d.ts.map +1 -1
- package/dist/scripts/notify-hook/team-worker.js +16 -4
- package/dist/scripts/notify-hook/team-worker.js.map +1 -1
- package/dist/session-history/__tests__/compare.test.d.ts +2 -0
- package/dist/session-history/__tests__/compare.test.d.ts.map +1 -0
- package/dist/session-history/__tests__/compare.test.js +257 -0
- package/dist/session-history/__tests__/compare.test.js.map +1 -0
- package/dist/session-history/compare.d.ts +74 -0
- package/dist/session-history/compare.d.ts.map +1 -0
- package/dist/session-history/compare.js +165 -0
- package/dist/session-history/compare.js.map +1 -0
- package/dist/team/__tests__/api-interop.test.js +3 -3
- package/dist/team/__tests__/cross-rebase-smoke.test.js +263 -31
- package/dist/team/__tests__/cross-rebase-smoke.test.js.map +1 -1
- package/dist/team/__tests__/herdr-session-realherdr.test.d.ts +2 -0
- package/dist/team/__tests__/herdr-session-realherdr.test.d.ts.map +1 -0
- package/dist/team/__tests__/herdr-session-realherdr.test.js +68 -0
- package/dist/team/__tests__/herdr-session-realherdr.test.js.map +1 -0
- package/dist/team/__tests__/herdr-session.test.d.ts +2 -0
- package/dist/team/__tests__/herdr-session.test.d.ts.map +1 -0
- package/dist/team/__tests__/herdr-session.test.js +228 -0
- package/dist/team/__tests__/herdr-session.test.js.map +1 -0
- package/dist/team/__tests__/idle-nudge.test.js +84 -0
- package/dist/team/__tests__/idle-nudge.test.js.map +1 -1
- package/dist/team/__tests__/rebalance-policy.test.js +27 -9
- package/dist/team/__tests__/rebalance-policy.test.js.map +1 -1
- package/dist/team/__tests__/runtime-delivery.test.d.ts +2 -0
- package/dist/team/__tests__/runtime-delivery.test.d.ts.map +1 -0
- package/dist/team/__tests__/runtime-delivery.test.js +570 -0
- package/dist/team/__tests__/runtime-delivery.test.js.map +1 -0
- package/dist/team/__tests__/runtime.test.js +332 -18
- package/dist/team/__tests__/runtime.test.js.map +1 -1
- package/dist/team/__tests__/scaling.test.js +293 -0
- package/dist/team/__tests__/scaling.test.js.map +1 -1
- package/dist/team/__tests__/state-renewal.test.d.ts +2 -0
- package/dist/team/__tests__/state-renewal.test.d.ts.map +1 -0
- package/dist/team/__tests__/state-renewal.test.js +555 -0
- package/dist/team/__tests__/state-renewal.test.js.map +1 -0
- package/dist/team/__tests__/task-lease.test.d.ts +2 -0
- package/dist/team/__tests__/task-lease.test.d.ts.map +1 -0
- package/dist/team/__tests__/task-lease.test.js +179 -0
- package/dist/team/__tests__/task-lease.test.js.map +1 -0
- package/dist/team/__tests__/team-ops-contract.test.js +1 -0
- package/dist/team/__tests__/team-ops-contract.test.js.map +1 -1
- package/dist/team/__tests__/worker-bootstrap.test.js +2 -0
- package/dist/team/__tests__/worker-bootstrap.test.js.map +1 -1
- package/dist/team/api-interop.d.ts +1 -1
- package/dist/team/api-interop.d.ts.map +1 -1
- package/dist/team/api-interop.js +13 -1
- package/dist/team/api-interop.js.map +1 -1
- package/dist/team/goal-workflow.js +1 -1
- package/dist/team/herdr-session.d.ts +234 -0
- package/dist/team/herdr-session.d.ts.map +1 -0
- package/dist/team/herdr-session.js +489 -0
- package/dist/team/herdr-session.js.map +1 -0
- package/dist/team/idle-nudge.d.ts +16 -4
- package/dist/team/idle-nudge.d.ts.map +1 -1
- package/dist/team/idle-nudge.js +51 -19
- package/dist/team/idle-nudge.js.map +1 -1
- package/dist/team/mcp-comm.d.ts +1 -1
- package/dist/team/mcp-comm.d.ts.map +1 -1
- package/dist/team/rebalance-policy.d.ts.map +1 -1
- package/dist/team/rebalance-policy.js +5 -2
- package/dist/team/rebalance-policy.js.map +1 -1
- package/dist/team/runtime.d.ts.map +1 -1
- package/dist/team/runtime.js +356 -81
- package/dist/team/runtime.js.map +1 -1
- package/dist/team/scaling.d.ts.map +1 -1
- package/dist/team/scaling.js +332 -143
- package/dist/team/scaling.js.map +1 -1
- package/dist/team/state/monitor.d.ts +3 -0
- package/dist/team/state/monitor.d.ts.map +1 -1
- package/dist/team/state/monitor.js +3 -0
- package/dist/team/state/monitor.js.map +1 -1
- package/dist/team/state/tasks.d.ts +2 -1
- package/dist/team/state/tasks.d.ts.map +1 -1
- package/dist/team/state/tasks.js +28 -0
- package/dist/team/state/tasks.js.map +1 -1
- package/dist/team/state/types.d.ts +8 -0
- package/dist/team/state/types.d.ts.map +1 -1
- package/dist/team/state/types.js.map +1 -1
- package/dist/team/state.d.ts +14 -2
- package/dist/team/state.d.ts.map +1 -1
- package/dist/team/state.js +29 -5
- package/dist/team/state.js.map +1 -1
- package/dist/team/task-lease.d.ts +4 -0
- package/dist/team/task-lease.d.ts.map +1 -0
- package/dist/team/task-lease.js +74 -0
- package/dist/team/task-lease.js.map +1 -0
- package/dist/team/team-ops.d.ts +2 -1
- package/dist/team/team-ops.d.ts.map +1 -1
- package/dist/team/team-ops.js +1 -0
- package/dist/team/team-ops.js.map +1 -1
- package/dist/team/tmux-session.d.ts +1 -1
- package/dist/team/tmux-session.d.ts.map +1 -1
- package/dist/team/tmux-session.js +10 -2
- package/dist/team/tmux-session.js.map +1 -1
- package/dist/team/worker-bootstrap.d.ts.map +1 -1
- package/dist/team/worker-bootstrap.js +14 -1
- package/dist/team/worker-bootstrap.js.map +1 -1
- package/package.json +1 -1
- package/plugins/oh-my-codex/.codex-plugin/plugin.json +1 -1
- package/plugins/oh-my-codex/hooks/codex-native-hook.mjs +208 -25
- package/plugins/oh-my-codex/skills/worker/SKILL.md +7 -1
- package/prompts/build-fixer.md +2 -1
- package/prompts/debugger.md +2 -1
- package/prompts/git-master.md +2 -1
- package/prompts/style-reviewer.md +2 -1
- package/prompts/team-executor.md +3 -2
- package/prompts/vision.md +2 -1
- package/prompts/writer.md +2 -1
- package/skills/worker/SKILL.md +7 -1
- package/src/scripts/__tests__/codex-native-hook.test.ts +279 -0
- package/src/scripts/__tests__/generate-release-body.test.ts +151 -5
- package/src/scripts/codex-native-hook.ts +8 -2
- package/src/scripts/generate-release-body.ts +16 -0
- package/src/scripts/notify-hook/team-worker-lease.ts +69 -0
- package/src/scripts/notify-hook/team-worker-posttooluse.ts +16 -4
- package/src/scripts/notify-hook/team-worker.ts +15 -4
|
@@ -0,0 +1,570 @@
|
|
|
1
|
+
import { afterEach, beforeEach, describe, it } from 'node:test';
|
|
2
|
+
import assert from 'node:assert/strict';
|
|
3
|
+
import { execFileSync } from 'node:child_process';
|
|
4
|
+
import { createHash } from 'node:crypto';
|
|
5
|
+
import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
|
|
6
|
+
import { existsSync } from 'node:fs';
|
|
7
|
+
import { tmpdir } from 'node:os';
|
|
8
|
+
import { join } from 'node:path';
|
|
9
|
+
import { monitorTeam } from '../runtime.js';
|
|
10
|
+
import { initTeamState, createTask, readTeamConfig, saveTeamConfig, claimTask, transitionTaskStatus, readMonitorSnapshot, writeMonitorSnapshot, writeWorkerStatus, updateTask, readTask, } from '../state.js';
|
|
11
|
+
const team = 'delivery-gate';
|
|
12
|
+
describe('monitorTeam code delivery success gate', () => {
|
|
13
|
+
let repo;
|
|
14
|
+
let worker;
|
|
15
|
+
let previousRoot;
|
|
16
|
+
const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
|
|
17
|
+
async function commit(cwd, file) {
|
|
18
|
+
await writeFile(join(cwd, file), `${file}\n`);
|
|
19
|
+
git(cwd, 'add', file);
|
|
20
|
+
git(cwd, 'commit', '-m', file);
|
|
21
|
+
}
|
|
22
|
+
beforeEach(async () => {
|
|
23
|
+
previousRoot = process.env.OMX_TEAM_STATE_ROOT;
|
|
24
|
+
delete process.env.OMX_TEAM_STATE_ROOT;
|
|
25
|
+
repo = await mkdtemp(join(tmpdir(), 'omx-runtime-delivery-'));
|
|
26
|
+
worker = await mkdtemp(join(tmpdir(), 'omx-runtime-delivery-worker-'));
|
|
27
|
+
git(repo, 'init');
|
|
28
|
+
git(repo, 'config', 'user.email', 'test@example.com');
|
|
29
|
+
git(repo, 'config', 'user.name', 'Test');
|
|
30
|
+
await writeFile(join(repo, '.git/info/exclude'), '.omx/\n');
|
|
31
|
+
await commit(repo, 'README.md');
|
|
32
|
+
git(repo, 'worktree', 'add', '-b', 'worker-delivery', worker, 'HEAD');
|
|
33
|
+
await initTeamState(team, 'code delivery', 'executor', 1, repo);
|
|
34
|
+
const config = (await readTeamConfig(team, repo));
|
|
35
|
+
config.workers[0] = { ...config.workers[0], assigned_tasks: ['1'], working_dir: worker, worktree_path: worker, worktree_repo_root: repo };
|
|
36
|
+
await saveTeamConfig(config, repo);
|
|
37
|
+
await createTask(team, {
|
|
38
|
+
subject: 'delivered work', description: 'work', status: 'pending', owner: 'worker-1',
|
|
39
|
+
}, repo);
|
|
40
|
+
await writeFile(join(repo, '.omx/state/team-state.json'), JSON.stringify({ active: true, current_phase: 'team-exec', team_name: team }));
|
|
41
|
+
});
|
|
42
|
+
afterEach(async () => {
|
|
43
|
+
if (previousRoot === undefined)
|
|
44
|
+
delete process.env.OMX_TEAM_STATE_ROOT;
|
|
45
|
+
else
|
|
46
|
+
process.env.OMX_TEAM_STATE_ROOT = previousRoot;
|
|
47
|
+
await rm(worker, { recursive: true, force: true });
|
|
48
|
+
await rm(repo, { recursive: true, force: true });
|
|
49
|
+
});
|
|
50
|
+
async function rootState() {
|
|
51
|
+
return JSON.parse(await readFile(join(repo, '.omx/state/team-state.json'), 'utf8'));
|
|
52
|
+
}
|
|
53
|
+
async function rebaseMetadata(path) {
|
|
54
|
+
return Promise.all((await readdir(path)).sort().map(async (name) => [name, await readFile(join(path, name), 'utf8')]));
|
|
55
|
+
}
|
|
56
|
+
async function completeTask(taskId = '1', requiresCodeChange = true) {
|
|
57
|
+
await updateTask(team, taskId, { requires_code_change: requiresCodeChange }, repo);
|
|
58
|
+
const claim = await claimTask(team, taskId, 'worker-1', null, repo);
|
|
59
|
+
assert.ok(claim.ok, JSON.stringify(claim));
|
|
60
|
+
assert.equal(git(worker, 'status', '--porcelain', '--untracked-files=all'), '');
|
|
61
|
+
let result = 'Verification: PASS `git status --porcelain --untracked-files=all` for no-change research.';
|
|
62
|
+
if (requiresCodeChange) {
|
|
63
|
+
const verifiedHead = git(worker, 'rev-parse', 'HEAD');
|
|
64
|
+
await mkdir(join(worker, '.omx/evidence'), { recursive: true });
|
|
65
|
+
const evidencePath = `.omx/evidence/task-${taskId}.json`;
|
|
66
|
+
await writeFile(join(worker, evidencePath), JSON.stringify({
|
|
67
|
+
teamName: team, taskId, claimTokenSha256: createHash('sha256').update(claim.claimToken).digest('hex'),
|
|
68
|
+
verifiedHead, summary: 'Verified committed worker output',
|
|
69
|
+
verification: [{ command: 'git status --porcelain --untracked-files=all', result: 'passed', output: 'Clean worktree' }],
|
|
70
|
+
unverified: [],
|
|
71
|
+
}));
|
|
72
|
+
result = `Verification: PASS \`git status --porcelain --untracked-files=all\` for committed worker output.\nEVIDENCE_RECORDED: ${evidencePath}`;
|
|
73
|
+
}
|
|
74
|
+
const completed = await transitionTaskStatus(team, taskId, 'in_progress', 'completed', claim.claimToken, repo, { result });
|
|
75
|
+
assert.ok(completed.ok, JSON.stringify(completed));
|
|
76
|
+
await writeWorkerStatus(team, 'worker-1', { state: 'done', updated_at: new Date().toISOString() }, repo);
|
|
77
|
+
}
|
|
78
|
+
it('keeps unverified pending delivery nonterminal on read-only monitor without mutating state', async () => {
|
|
79
|
+
await commit(worker, 'feature.txt');
|
|
80
|
+
const head = git(repo, 'rev-parse', 'HEAD');
|
|
81
|
+
const snapshot = await monitorTeam(team, repo, { readOnly: true });
|
|
82
|
+
assert.equal(snapshot?.phase, 'team-exec');
|
|
83
|
+
assert.equal((await readTask(team, '1', repo))?.status, 'pending');
|
|
84
|
+
assert.equal((await rootState()).active, true);
|
|
85
|
+
assert.equal(git(repo, 'rev-parse', 'HEAD'), head);
|
|
86
|
+
assert.equal(await readMonitorSnapshot(team, repo), null);
|
|
87
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD') === head, false);
|
|
88
|
+
});
|
|
89
|
+
it('completes after successful integration and on subsequent contained read-only delivery', async () => {
|
|
90
|
+
await commit(worker, 'feature.txt');
|
|
91
|
+
await completeTask();
|
|
92
|
+
const snapshot = await monitorTeam(team, repo);
|
|
93
|
+
assert.equal(snapshot?.phase, 'complete');
|
|
94
|
+
assert.equal(await readFile(join(repo, 'feature.txt'), 'utf8'), 'feature.txt\n');
|
|
95
|
+
assert.equal((await rootState()).active, false);
|
|
96
|
+
assert.equal((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'complete');
|
|
97
|
+
});
|
|
98
|
+
it('accepts recorded cherry-pick delivery even when source HEAD is not an ancestor', async () => {
|
|
99
|
+
await commit(worker, 'feature.txt');
|
|
100
|
+
const workerHead = git(worker, 'rev-parse', 'HEAD');
|
|
101
|
+
await commit(repo, 'leader.txt');
|
|
102
|
+
await completeTask();
|
|
103
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'complete');
|
|
104
|
+
const delivery = (await readMonitorSnapshot(team, repo))?.integrationByWorker?.['worker-1'];
|
|
105
|
+
assert.equal(delivery?.last_integrated_head, workerHead);
|
|
106
|
+
assert.throws(() => git(repo, 'merge-base', '--is-ancestor', workerHead, 'HEAD'));
|
|
107
|
+
assert.equal((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'complete');
|
|
108
|
+
});
|
|
109
|
+
it('invalidates rewritten-away cherry-pick delivery even after an intervening nonterminal poll', async () => {
|
|
110
|
+
await commit(worker, 'feature.txt');
|
|
111
|
+
await commit(repo, 'leader.txt');
|
|
112
|
+
const beforeDelivery = git(repo, 'rev-parse', 'HEAD');
|
|
113
|
+
await completeTask();
|
|
114
|
+
const sentinel = await createTask(team, {
|
|
115
|
+
subject: 'final delivery verification', description: 'Keep the team active during the history rewrite', status: 'pending',
|
|
116
|
+
}, repo);
|
|
117
|
+
await monitorTeam(team, repo);
|
|
118
|
+
assert.equal((await readTask(team, sentinel.id, repo))?.owner, undefined);
|
|
119
|
+
const proof = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'].delivery_leader_commit;
|
|
120
|
+
assert.equal(proof, git(repo, 'rev-parse', 'HEAD'));
|
|
121
|
+
assert.equal(await readFile(join(repo, 'feature.txt'), 'utf8'), 'feature.txt\n');
|
|
122
|
+
assert.equal((await rootState()).active, true);
|
|
123
|
+
git(repo, 'reset', '--hard', beforeDelivery);
|
|
124
|
+
// The unowned sentinel keeps the team nonterminal without blocking worker handoff.
|
|
125
|
+
assert.notEqual((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'complete');
|
|
126
|
+
assert.equal((await rootState()).active, true);
|
|
127
|
+
await assert.rejects(readFile(join(repo, 'feature.txt')), { code: 'ENOENT' });
|
|
128
|
+
// An intervening poll must restore delivery or leave honest debt, never reuse the lost receipt.
|
|
129
|
+
assert.notEqual((await monitorTeam(team, repo))?.phase, 'complete');
|
|
130
|
+
assert.equal((await rootState()).active, true);
|
|
131
|
+
// Verify the current source again if cross-rebase changed it during the first delivery.
|
|
132
|
+
await completeTask(sentinel.id);
|
|
133
|
+
const readOnly = await monitorTeam(team, repo, { readOnly: true });
|
|
134
|
+
if (readOnly?.phase === 'complete')
|
|
135
|
+
assert.equal(await readFile(join(repo, 'feature.txt'), 'utf8'), 'feature.txt\n');
|
|
136
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'complete');
|
|
137
|
+
assert.equal(await readFile(join(repo, 'feature.txt'), 'utf8'), 'feature.txt\n');
|
|
138
|
+
});
|
|
139
|
+
it('observes a clean initial-break manual rebase as undelivered without changing the operation', async () => {
|
|
140
|
+
const base = git(repo, 'rev-parse', 'HEAD');
|
|
141
|
+
await commit(worker, 'feature.txt');
|
|
142
|
+
const source = git(worker, 'rev-parse', 'HEAD');
|
|
143
|
+
await commit(repo, 'leader.txt');
|
|
144
|
+
await completeTask();
|
|
145
|
+
const editor = join(repo, '.git', 'initial-break.cjs');
|
|
146
|
+
await writeFile(editor, 'const fs=require("node:fs");const p=process.argv[2];fs.writeFileSync(p,"break\\n"+fs.readFileSync(p,"utf8"));');
|
|
147
|
+
execFileSync('git', ['rebase', '-i', '--onto', git(repo, 'rev-parse', 'HEAD'), base], {
|
|
148
|
+
cwd: worker, env: { ...process.env, GIT_SEQUENCE_EDITOR: `${process.execPath} ${editor}` }, stdio: 'pipe',
|
|
149
|
+
});
|
|
150
|
+
const metadataPath = git(worker, 'rev-parse', '--git-path', 'rebase-merge');
|
|
151
|
+
assert.equal(await readFile(join(metadataPath, 'orig-head'), 'utf8'), `${source}\n`);
|
|
152
|
+
assert.match(await readFile(join(metadataPath, 'git-rebase-todo'), 'utf8'), new RegExp(`pick ${source.slice(0, 7)}`));
|
|
153
|
+
assert.throws(() => git(repo, 'merge-base', '--is-ancestor', source, 'HEAD'));
|
|
154
|
+
const head = git(worker, 'rev-parse', 'HEAD');
|
|
155
|
+
git(repo, 'merge-base', '--is-ancestor', head, 'HEAD');
|
|
156
|
+
assert.equal(git(worker, 'status', '--porcelain', '--untracked-files=all'), '');
|
|
157
|
+
const snapshotBefore = await readMonitorSnapshot(team, repo);
|
|
158
|
+
assert.deepEqual(snapshotBefore?.integrationByWorker, {});
|
|
159
|
+
const metadata = await rebaseMetadata(metadataPath);
|
|
160
|
+
const phasePath = join(repo, '.omx/state/team', team, 'phase.json');
|
|
161
|
+
const phaseBefore = await readFile(phasePath, 'utf8');
|
|
162
|
+
const rootBefore = await rootState();
|
|
163
|
+
const readOnly = await monitorTeam(team, repo, { readOnly: true });
|
|
164
|
+
assert.notEqual(readOnly?.phase, 'complete');
|
|
165
|
+
assert.deepEqual(await readMonitorSnapshot(team, repo), snapshotBefore);
|
|
166
|
+
assert.equal(await readFile(phasePath, 'utf8'), phaseBefore);
|
|
167
|
+
assert.deepEqual(await rootState(), rootBefore);
|
|
168
|
+
assert.deepEqual(await rebaseMetadata(metadataPath), metadata);
|
|
169
|
+
assert.notEqual((await monitorTeam(team, repo))?.phase, 'complete');
|
|
170
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD'), head);
|
|
171
|
+
assert.deepEqual(await rebaseMetadata(metadataPath), metadata);
|
|
172
|
+
assert.match((await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'].rebase_error, /Finish or abort it manually/);
|
|
173
|
+
});
|
|
174
|
+
for (const rootOwner of ['matching', 'already-reopened', 'unrelated', 'epoch-fenced', 'stopped']) {
|
|
175
|
+
it(`reconciles rewritten delivery debt only for an ordinary completed ${rootOwner} root`, async () => {
|
|
176
|
+
await commit(worker, 'feature.txt');
|
|
177
|
+
const verifiedHead = git(worker, 'rev-parse', 'HEAD');
|
|
178
|
+
await commit(repo, 'leader.txt');
|
|
179
|
+
const beforeDelivery = git(repo, 'rev-parse', 'HEAD');
|
|
180
|
+
await completeTask();
|
|
181
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'complete');
|
|
182
|
+
const sealed = await rootState();
|
|
183
|
+
assert.equal(sealed.active, false);
|
|
184
|
+
assert.equal(sealed.current_phase, 'complete');
|
|
185
|
+
assert.ok(sealed.completed_at);
|
|
186
|
+
assert.notEqual(git(worker, 'rev-parse', 'HEAD'), verifiedHead, 'initial diverged delivery cross-rebased the source');
|
|
187
|
+
if (rootOwner === 'unrelated') {
|
|
188
|
+
await writeFile(join(repo, '.omx/state/team-state.json'), JSON.stringify({ ...sealed, team_name: 'another-team' }));
|
|
189
|
+
}
|
|
190
|
+
if (rootOwner === 'stopped') {
|
|
191
|
+
await writeFile(join(repo, '.omx/state/team-state.json'), JSON.stringify({ ...sealed, current_phase: 'cancelled' }));
|
|
192
|
+
}
|
|
193
|
+
if (rootOwner === 'epoch-fenced' || rootOwner === 'already-reopened' || rootOwner === 'stopped') {
|
|
194
|
+
const phasePath = join(repo, '.omx/state/team', team, 'phase.json');
|
|
195
|
+
const phase = JSON.parse(await readFile(phasePath, 'utf8'));
|
|
196
|
+
await writeFile(phasePath, JSON.stringify(rootOwner === 'epoch-fenced' || rootOwner === 'stopped'
|
|
197
|
+
? { ...phase, current_phase: rootOwner === 'stopped' ? 'cancelled' : 'complete', terminal_epoch: new Date().toISOString(), terminal_reason: 'forced_shutdown' }
|
|
198
|
+
: { ...phase, current_phase: 'team-verify' }));
|
|
199
|
+
}
|
|
200
|
+
const rootBefore = await readFile(join(repo, '.omx/state/team-state.json'), 'utf8');
|
|
201
|
+
git(repo, 'reset', '--hard', beforeDelivery);
|
|
202
|
+
await commit(repo, 'independent.txt');
|
|
203
|
+
const lock = git(worker, 'rev-parse', '--git-path', 'index.lock');
|
|
204
|
+
await writeFile(lock, 'hold cross-rebase after invalidation');
|
|
205
|
+
try {
|
|
206
|
+
const readOnly = await monitorTeam(team, repo, { readOnly: true });
|
|
207
|
+
if (rootOwner !== 'epoch-fenced')
|
|
208
|
+
assert.notEqual(readOnly?.phase, 'complete');
|
|
209
|
+
assert.equal(await readFile(join(repo, '.omx/state/team-state.json'), 'utf8'), rootBefore);
|
|
210
|
+
const snapshot = await monitorTeam(team, repo);
|
|
211
|
+
if (rootOwner === 'epoch-fenced')
|
|
212
|
+
assert.equal(snapshot?.phase, 'complete');
|
|
213
|
+
else if (rootOwner === 'stopped')
|
|
214
|
+
assert.equal(snapshot?.phase, 'cancelled');
|
|
215
|
+
else
|
|
216
|
+
assert.notEqual(snapshot?.phase, 'complete');
|
|
217
|
+
if (rootOwner === 'matching' || rootOwner === 'already-reopened') {
|
|
218
|
+
const reopened = await rootState();
|
|
219
|
+
assert.equal(reopened.active, true);
|
|
220
|
+
assert.equal(reopened.current_phase, snapshot?.phase);
|
|
221
|
+
assert.equal(reopened.completed_at, undefined);
|
|
222
|
+
assert.equal(reopened.team_name, team);
|
|
223
|
+
}
|
|
224
|
+
else {
|
|
225
|
+
assert.equal(await readFile(join(repo, '.omx/state/team-state.json'), 'utf8'), rootBefore);
|
|
226
|
+
}
|
|
227
|
+
}
|
|
228
|
+
finally {
|
|
229
|
+
await rm(lock, { force: true });
|
|
230
|
+
}
|
|
231
|
+
});
|
|
232
|
+
}
|
|
233
|
+
it('refreshes the source/receipt pair when externally contained follow-up output replaces an older delivery', async () => {
|
|
234
|
+
await commit(worker, 'feature.txt');
|
|
235
|
+
await commit(repo, 'leader.txt');
|
|
236
|
+
await completeTask();
|
|
237
|
+
const followup = await createTask(team, { subject: 'follow-up output', description: 'Keep delivery active', status: 'pending' }, repo);
|
|
238
|
+
await monitorTeam(team, repo);
|
|
239
|
+
const receipt = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'].delivery_leader_commit;
|
|
240
|
+
await commit(worker, 'followup.txt');
|
|
241
|
+
const followupHead = git(worker, 'rev-parse', 'HEAD');
|
|
242
|
+
await completeTask(followup.id);
|
|
243
|
+
const sentinel = await createTask(team, { subject: 'final research check', description: 'Keep the team active', status: 'pending' }, repo);
|
|
244
|
+
git(repo, 'merge', '--ff-only', followupHead);
|
|
245
|
+
await monitorTeam(team, repo);
|
|
246
|
+
const contained = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
247
|
+
git(repo, 'reset', '--hard', receipt);
|
|
248
|
+
await commit(repo, 'independent.txt');
|
|
249
|
+
git(repo, 'merge-base', '--is-ancestor', receipt, 'HEAD');
|
|
250
|
+
await assert.rejects(readFile(join(repo, 'followup.txt')), { code: 'ENOENT' });
|
|
251
|
+
await completeTask(sentinel.id, false);
|
|
252
|
+
assert.notEqual((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'complete');
|
|
253
|
+
assert.equal((await rootState()).active, true);
|
|
254
|
+
assert.equal(contained.last_integrated_head, followupHead);
|
|
255
|
+
assert.equal(contained.delivery_leader_commit, followupHead);
|
|
256
|
+
const writable = await monitorTeam(team, repo);
|
|
257
|
+
if (writable?.phase === 'complete')
|
|
258
|
+
assert.equal(await readFile(join(repo, 'followup.txt'), 'utf8'), 'followup.txt\n');
|
|
259
|
+
else
|
|
260
|
+
assert.equal((await rootState()).active, true);
|
|
261
|
+
});
|
|
262
|
+
for (const readOnly of [true, false]) {
|
|
263
|
+
it(`vetoes configured-hidden untracked output on ${readOnly ? 'read-only' : 'normal'} monitoring`, async () => {
|
|
264
|
+
await commit(worker, 'feature.txt');
|
|
265
|
+
await completeTask();
|
|
266
|
+
const sentinel = await createTask(team, { subject: 'final check', description: 'Keep the team active', status: 'pending' }, repo);
|
|
267
|
+
await monitorTeam(team, repo);
|
|
268
|
+
await completeTask(sentinel.id, false);
|
|
269
|
+
git(worker, 'config', 'status.showUntrackedFiles', 'no');
|
|
270
|
+
const head = git(worker, 'rev-parse', 'HEAD');
|
|
271
|
+
await writeFile(join(worker, 'hidden.txt'), 'unverified hidden output');
|
|
272
|
+
assert.equal(git(worker, 'status', '--porcelain'), '');
|
|
273
|
+
assert.notEqual((await monitorTeam(team, repo, { readOnly }))?.phase, 'complete');
|
|
274
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD'), head);
|
|
275
|
+
assert.equal((await rootState()).active, true);
|
|
276
|
+
await assert.rejects(readFile(join(repo, 'hidden.txt')), { code: 'ENOENT' });
|
|
277
|
+
});
|
|
278
|
+
}
|
|
279
|
+
for (const readOnly of [true, false]) {
|
|
280
|
+
it(`vetoes configured-hidden submodule dirt on ${readOnly ? 'read-only' : 'normal'} monitoring`, async () => {
|
|
281
|
+
const submodule = await mkdtemp(join(tmpdir(), 'omx-delivery-submodule-'));
|
|
282
|
+
try {
|
|
283
|
+
git(submodule, 'init');
|
|
284
|
+
git(submodule, 'config', 'user.email', 'test@example.com');
|
|
285
|
+
git(submodule, 'config', 'user.name', 'Test');
|
|
286
|
+
await commit(submodule, 'nested.txt');
|
|
287
|
+
git(worker, '-c', 'protocol.file.allow=always', 'submodule', 'add', submodule, 'nested');
|
|
288
|
+
git(worker, 'commit', '-am', 'add submodule');
|
|
289
|
+
await completeTask();
|
|
290
|
+
const sentinel = await createTask(team, { subject: 'final check', description: 'Keep the team active', status: 'pending' }, repo);
|
|
291
|
+
await monitorTeam(team, repo);
|
|
292
|
+
await completeTask(sentinel.id, false);
|
|
293
|
+
git(worker, 'config', 'submodule.nested.ignore', 'all');
|
|
294
|
+
const head = git(worker, 'rev-parse', 'HEAD');
|
|
295
|
+
await writeFile(join(worker, 'nested/unverified.txt'), 'unverified nested output');
|
|
296
|
+
assert.equal(git(worker, 'status', '--porcelain'), '');
|
|
297
|
+
assert.notEqual((await monitorTeam(team, repo, { readOnly }))?.phase, 'complete');
|
|
298
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD'), head);
|
|
299
|
+
assert.equal((await rootState()).active, true);
|
|
300
|
+
assert.equal(await readFile(join(worker, 'nested/unverified.txt'), 'utf8'), 'unverified nested output');
|
|
301
|
+
}
|
|
302
|
+
finally {
|
|
303
|
+
await rm(submodule, { recursive: true, force: true });
|
|
304
|
+
}
|
|
305
|
+
});
|
|
306
|
+
}
|
|
307
|
+
it('does not alias a clean late commit onto the earlier delivery receipt after cross-rebase', async () => {
|
|
308
|
+
await commit(worker, 'feature.txt');
|
|
309
|
+
const deliveredSource = git(worker, 'rev-parse', 'HEAD');
|
|
310
|
+
await commit(repo, 'leader.txt');
|
|
311
|
+
await completeTask();
|
|
312
|
+
const realGit = execFileSync('which', ['git'], { encoding: 'utf8' }).trim();
|
|
313
|
+
const bin = await mkdtemp(join(tmpdir(), 'omx-delivery-git-shim-'));
|
|
314
|
+
const previousPath = process.env.PATH;
|
|
315
|
+
const injected = join(bin, 'injected');
|
|
316
|
+
try {
|
|
317
|
+
await writeFile(join(bin, 'git'), `#!${process.execPath}
|
|
318
|
+
const fs = require('node:fs');
|
|
319
|
+
const { spawnSync } = require('node:child_process');
|
|
320
|
+
const args = process.argv.slice(2);
|
|
321
|
+
function git(args) {
|
|
322
|
+
const result = spawnSync(${JSON.stringify(realGit)}, args, { stdio: 'inherit' });
|
|
323
|
+
if (result.status !== 0) process.exit(result.status ?? 1);
|
|
324
|
+
}
|
|
325
|
+
if (process.cwd() === fs.realpathSync(${JSON.stringify(worker)}) && args[0] === 'rebase' && args[1] !== '--abort' && !fs.existsSync(${JSON.stringify(injected)})) {
|
|
326
|
+
fs.writeFileSync(${JSON.stringify(join(worker, 'late.txt'))}, 'late unpublished output\\n');
|
|
327
|
+
git(['add', 'late.txt']);
|
|
328
|
+
git(['commit', '-m', 'late clean commit before actual rebase']);
|
|
329
|
+
fs.writeFileSync(${JSON.stringify(injected)}, 'injected');
|
|
330
|
+
}
|
|
331
|
+
git(args);
|
|
332
|
+
`, { mode: 0o755 });
|
|
333
|
+
process.env.PATH = `${bin}:${previousPath}`;
|
|
334
|
+
const snapshot = await monitorTeam(team, repo);
|
|
335
|
+
assert.equal(existsSync(injected), true);
|
|
336
|
+
assert.notEqual(snapshot?.phase, 'complete');
|
|
337
|
+
const delivery = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
338
|
+
assert.equal(delivery.last_integrated_head, deliveredSource);
|
|
339
|
+
assert.notEqual(git(worker, 'rev-parse', 'HEAD'), deliveredSource);
|
|
340
|
+
assert.equal(git(worker, 'status', '--porcelain', '--untracked-files=all'), '');
|
|
341
|
+
assert.equal(await readFile(join(worker, 'late.txt'), 'utf8'), 'late unpublished output\n');
|
|
342
|
+
await assert.rejects(readFile(join(repo, 'late.txt')), { code: 'ENOENT' });
|
|
343
|
+
assert.notEqual((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'complete');
|
|
344
|
+
assert.equal((await rootState()).active, true);
|
|
345
|
+
}
|
|
346
|
+
finally {
|
|
347
|
+
if (previousPath === undefined)
|
|
348
|
+
delete process.env.PATH;
|
|
349
|
+
else
|
|
350
|
+
process.env.PATH = previousPath;
|
|
351
|
+
await rm(bin, { recursive: true, force: true });
|
|
352
|
+
}
|
|
353
|
+
});
|
|
354
|
+
it('vetoes terminal success on cross-rebase index.lock failure and retries on a quiet second poll', async () => {
|
|
355
|
+
await commit(worker, 'feature.txt');
|
|
356
|
+
await commit(repo, 'leader.txt');
|
|
357
|
+
await completeTask();
|
|
358
|
+
const lock = git(worker, 'rev-parse', '--git-path', 'index.lock');
|
|
359
|
+
await writeFile(lock, 'held by regression test');
|
|
360
|
+
const first = await monitorTeam(team, repo);
|
|
361
|
+
assert.equal(first?.phase, 'team-fix');
|
|
362
|
+
const failed = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
363
|
+
assert.equal(failed.status, 'rebase_conflict');
|
|
364
|
+
assert.ok(failed.pending_rebase_leader_head);
|
|
365
|
+
assert.match(failed.rebase_error, /index.lock/);
|
|
366
|
+
assert.equal((await rootState()).active, true);
|
|
367
|
+
assert.equal((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'team-fix');
|
|
368
|
+
const leaderHead = git(repo, 'rev-parse', 'HEAD');
|
|
369
|
+
await rm(lock);
|
|
370
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'complete');
|
|
371
|
+
assert.equal(git(repo, 'rev-parse', 'HEAD'), leaderHead, 'retry does not require fresh leader advancement');
|
|
372
|
+
const resolved = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
373
|
+
assert.equal(resolved.pending_rebase_leader_head, undefined);
|
|
374
|
+
assert.equal(resolved.rebase_error, undefined);
|
|
375
|
+
assert.equal(resolved.last_rebased_leader_head, leaderHead);
|
|
376
|
+
assert.equal(resolved.delivery_leader_commit, leaderHead);
|
|
377
|
+
assert.equal((await rootState()).active, false);
|
|
378
|
+
});
|
|
379
|
+
for (const lateChange of ['committed', 'hidden-untracked']) {
|
|
380
|
+
it(`does not cross-rebase ${lateChange} undelivered work on a pending retry with a live receipt`, async () => {
|
|
381
|
+
await commit(worker, 'feature.txt');
|
|
382
|
+
await commit(repo, 'leader.txt');
|
|
383
|
+
await completeTask();
|
|
384
|
+
const lock = git(worker, 'rev-parse', '--git-path', 'index.lock');
|
|
385
|
+
await writeFile(lock, 'held by regression test');
|
|
386
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
387
|
+
await rm(lock);
|
|
388
|
+
const pending = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
389
|
+
git(worker, 'config', 'status.showUntrackedFiles', 'no');
|
|
390
|
+
await writeFile(join(worker, 'unpublished.txt'), 'unverified output');
|
|
391
|
+
if (lateChange === 'committed') {
|
|
392
|
+
git(worker, 'add', 'unpublished.txt');
|
|
393
|
+
git(worker, 'commit', '-m', 'unverified follow-up');
|
|
394
|
+
}
|
|
395
|
+
const head = git(worker, 'rev-parse', 'HEAD');
|
|
396
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
397
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD'), head);
|
|
398
|
+
assert.equal((await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'].pending_rebase_leader_head, pending.pending_rebase_leader_head);
|
|
399
|
+
assert.equal(await readFile(join(worker, 'unpublished.txt'), 'utf8'), 'unverified output');
|
|
400
|
+
await assert.rejects(readFile(join(repo, 'unpublished.txt')), { code: 'ENOENT' });
|
|
401
|
+
assert.equal((await rootState()).active, true);
|
|
402
|
+
});
|
|
403
|
+
}
|
|
404
|
+
for (const unfinishedRebase of [false, true]) {
|
|
405
|
+
it(`redelivers lost pending-rebase receipts on a quiet poll${unfinishedRebase ? ' only after operator cleanup of an unfinished rebase' : ''}`, async () => {
|
|
406
|
+
await commit(worker, 'feature.txt');
|
|
407
|
+
const sourceHead = git(worker, 'rev-parse', 'HEAD');
|
|
408
|
+
await commit(repo, 'leader.txt');
|
|
409
|
+
const beforeDelivery = git(repo, 'rev-parse', 'HEAD');
|
|
410
|
+
await completeTask();
|
|
411
|
+
const lock = git(worker, 'rev-parse', '--git-path', 'index.lock');
|
|
412
|
+
await writeFile(lock, 'held by regression test');
|
|
413
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
414
|
+
const failed = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
415
|
+
assert.equal(failed.last_integrated_head, sourceHead);
|
|
416
|
+
assert.ok(failed.pending_rebase_leader_head);
|
|
417
|
+
assert.match(failed.rebase_error, /index.lock/);
|
|
418
|
+
await rm(lock);
|
|
419
|
+
let unfinishedHead;
|
|
420
|
+
let unfinishedMetadata;
|
|
421
|
+
let unfinishedMetadataBefore;
|
|
422
|
+
if (unfinishedRebase) {
|
|
423
|
+
// Identical orig-head/onto can be manually recreated; they do not prove operation ownership.
|
|
424
|
+
assert.throws(() => git(worker, 'rebase', '--reapply-cherry-picks', '--empty=keep', '--exec', 'false', failed.pending_rebase_leader_head));
|
|
425
|
+
unfinishedHead = git(worker, 'rev-parse', 'HEAD');
|
|
426
|
+
unfinishedMetadata = git(worker, 'rev-parse', '--git-path', 'rebase-merge');
|
|
427
|
+
unfinishedMetadataBefore = await rebaseMetadata(unfinishedMetadata);
|
|
428
|
+
assert.notEqual(unfinishedHead, sourceHead);
|
|
429
|
+
await writeFile(join(worker, 'manual-resolution.txt'), 'preserve this manual work');
|
|
430
|
+
}
|
|
431
|
+
git(repo, 'reset', '--hard', beforeDelivery);
|
|
432
|
+
await assert.rejects(readFile(join(repo, 'feature.txt')), { code: 'ENOENT' });
|
|
433
|
+
assert.equal((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'team-fix');
|
|
434
|
+
if (unfinishedRebase) {
|
|
435
|
+
for (let poll = 0; poll < 2; poll++) {
|
|
436
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
437
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD'), unfinishedHead);
|
|
438
|
+
assert.deepEqual(await rebaseMetadata(unfinishedMetadata), unfinishedMetadataBefore);
|
|
439
|
+
assert.equal(await readFile(join(worker, 'manual-resolution.txt'), 'utf8'), 'preserve this manual work');
|
|
440
|
+
assert.equal(git(repo, 'rev-parse', 'HEAD'), beforeDelivery);
|
|
441
|
+
assert.match((await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'].rebase_error, /Finish or abort it manually/);
|
|
442
|
+
}
|
|
443
|
+
// Only the operator may discard this operation; clean, metadata-free recovery can then resume.
|
|
444
|
+
git(worker, 'rebase', '--abort');
|
|
445
|
+
await rm(join(worker, 'manual-resolution.txt'));
|
|
446
|
+
}
|
|
447
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'complete');
|
|
448
|
+
assert.equal(await readFile(join(repo, 'feature.txt'), 'utf8'), 'feature.txt\n');
|
|
449
|
+
const resolved = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
450
|
+
assert.equal(resolved.pending_rebase_leader_head, undefined);
|
|
451
|
+
assert.equal(resolved.rebase_error, undefined);
|
|
452
|
+
assert.equal(resolved.last_integrated_head, sourceHead);
|
|
453
|
+
assert.equal(resolved.delivery_leader_commit, git(repo, 'rev-parse', 'HEAD'));
|
|
454
|
+
assert.equal(git(worker, 'status', '--porcelain'), '');
|
|
455
|
+
assert.equal((await rootState()).active, false);
|
|
456
|
+
});
|
|
457
|
+
}
|
|
458
|
+
it('preserves an unrelated conflicting manual rebase and staged resolution while the old receipt remains live', async () => {
|
|
459
|
+
const base = git(repo, 'rev-parse', 'HEAD');
|
|
460
|
+
await commit(worker, 'feature.txt');
|
|
461
|
+
await commit(repo, 'leader.txt');
|
|
462
|
+
await completeTask();
|
|
463
|
+
const lock = git(worker, 'rev-parse', '--git-path', 'index.lock');
|
|
464
|
+
await writeFile(lock, 'held by regression test');
|
|
465
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
466
|
+
await rm(lock);
|
|
467
|
+
const pending = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
468
|
+
git(repo, 'merge-base', '--is-ancestor', pending.delivery_leader_commit, 'HEAD');
|
|
469
|
+
git(worker, 'checkout', '-b', 'manual-target', base);
|
|
470
|
+
await writeFile(join(worker, 'README.md'), 'unrelated target\n');
|
|
471
|
+
git(worker, 'commit', '-am', 'manual target');
|
|
472
|
+
git(worker, 'checkout', 'worker-delivery');
|
|
473
|
+
await writeFile(join(worker, 'README.md'), 'unrelated source\n');
|
|
474
|
+
git(worker, 'commit', '-am', 'manual source');
|
|
475
|
+
assert.throws(() => git(worker, 'rebase', 'manual-target'));
|
|
476
|
+
await writeFile(join(worker, 'README.md'), 'operator conflict resolution\n');
|
|
477
|
+
git(worker, 'add', 'README.md');
|
|
478
|
+
const metadataPath = git(worker, 'rev-parse', '--git-path', 'rebase-merge');
|
|
479
|
+
const metadata = await rebaseMetadata(metadataPath);
|
|
480
|
+
const head = git(worker, 'rev-parse', 'HEAD');
|
|
481
|
+
const index = git(worker, 'diff', '--cached');
|
|
482
|
+
for (let poll = 0; poll < 2; poll++) {
|
|
483
|
+
const snapshot = await monitorTeam(team, repo);
|
|
484
|
+
assert.deepEqual(await rebaseMetadata(metadataPath), metadata);
|
|
485
|
+
assert.equal(snapshot?.phase, 'team-fix');
|
|
486
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD'), head);
|
|
487
|
+
assert.equal(git(worker, 'diff', '--cached'), index);
|
|
488
|
+
assert.equal(await readFile(join(worker, 'README.md'), 'utf8'), 'operator conflict resolution\n');
|
|
489
|
+
assert.equal((await rootState()).active, true);
|
|
490
|
+
const preserved = (await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'];
|
|
491
|
+
assert.equal(preserved.pending_rebase_leader_head, pending.pending_rebase_leader_head);
|
|
492
|
+
assert.equal(preserved.delivery_leader_commit, pending.delivery_leader_commit);
|
|
493
|
+
assert.match(preserved.rebase_error, /Finish or abort it manually/);
|
|
494
|
+
}
|
|
495
|
+
});
|
|
496
|
+
it('keeps lost-receipt pending state sticky while the worker is active or dirty, without checkpointing', async () => {
|
|
497
|
+
await commit(worker, 'feature.txt');
|
|
498
|
+
const sourceHead = git(worker, 'rev-parse', 'HEAD');
|
|
499
|
+
await commit(repo, 'leader.txt');
|
|
500
|
+
const beforeDelivery = git(repo, 'rev-parse', 'HEAD');
|
|
501
|
+
await completeTask();
|
|
502
|
+
const lock = git(worker, 'rev-parse', '--git-path', 'index.lock');
|
|
503
|
+
await writeFile(lock, 'held by regression test');
|
|
504
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
505
|
+
await rm(lock);
|
|
506
|
+
git(repo, 'reset', '--hard', beforeDelivery);
|
|
507
|
+
await writeWorkerStatus(team, 'worker-1', { state: 'working', updated_at: new Date().toISOString() }, repo);
|
|
508
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
509
|
+
assert.equal(git(repo, 'rev-parse', 'HEAD'), beforeDelivery);
|
|
510
|
+
await writeWorkerStatus(team, 'worker-1', { state: 'done', updated_at: new Date().toISOString() }, repo);
|
|
511
|
+
await writeFile(join(worker, 'unverified.txt'), 'do not publish');
|
|
512
|
+
git(worker, 'config', 'status.showUntrackedFiles', 'no');
|
|
513
|
+
for (let poll = 0; poll < 2; poll++) {
|
|
514
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'team-fix');
|
|
515
|
+
assert.equal(git(worker, 'rev-parse', 'HEAD'), sourceHead);
|
|
516
|
+
assert.equal(git(repo, 'rev-parse', 'HEAD'), beforeDelivery);
|
|
517
|
+
assert.ok((await readMonitorSnapshot(team, repo)).integrationByWorker['worker-1'].pending_rebase_leader_head);
|
|
518
|
+
}
|
|
519
|
+
await rm(join(worker, 'unverified.txt'));
|
|
520
|
+
assert.equal((await monitorTeam(team, repo))?.phase, 'complete');
|
|
521
|
+
await assert.rejects(readFile(join(repo, 'unverified.txt')), { code: 'ENOENT' });
|
|
522
|
+
assert.equal(await readFile(join(repo, 'feature.txt'), 'utf8'), 'feature.txt\n');
|
|
523
|
+
});
|
|
524
|
+
it('allows genuinely no-change research worktrees to complete', async () => {
|
|
525
|
+
await completeTask('1', false);
|
|
526
|
+
assert.equal((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'complete');
|
|
527
|
+
});
|
|
528
|
+
it('preserves a diverged merge-commit integration failure through rebase and never seals root success', async () => {
|
|
529
|
+
await commit(worker, 'feature.txt');
|
|
530
|
+
git(worker, 'checkout', '-b', 'worker-side');
|
|
531
|
+
await commit(worker, 'side.txt');
|
|
532
|
+
git(worker, 'checkout', 'worker-delivery');
|
|
533
|
+
await commit(worker, 'other.txt');
|
|
534
|
+
git(worker, 'merge', '--no-ff', '-m', 'worker merge commit', 'worker-side');
|
|
535
|
+
await commit(repo, 'leader.txt');
|
|
536
|
+
await completeTask();
|
|
537
|
+
const snapshot = await monitorTeam(team, repo);
|
|
538
|
+
assert.equal(snapshot?.phase, 'team-fix');
|
|
539
|
+
const persisted = (await readMonitorSnapshot(team, repo));
|
|
540
|
+
assert.equal(persisted.integrationByWorker?.['worker-1']?.status, 'cherry_pick_conflict');
|
|
541
|
+
assert.equal((await rootState()).active, true);
|
|
542
|
+
const phasePath = join(repo, '.omx/state/team', team, 'phase.json');
|
|
543
|
+
const beforePhase = await readFile(phasePath, 'utf8');
|
|
544
|
+
const beforeSnapshot = JSON.stringify(persisted);
|
|
545
|
+
assert.equal((await monitorTeam(team, repo, { readOnly: true }))?.phase, 'team-fix');
|
|
546
|
+
assert.equal(await readFile(phasePath, 'utf8'), beforePhase);
|
|
547
|
+
assert.equal(JSON.stringify(await readMonitorSnapshot(team, repo)), beforeSnapshot);
|
|
548
|
+
assert.equal((await rootState()).active, true);
|
|
549
|
+
});
|
|
550
|
+
it('persisted integration_failed vetoes read-only success even when worker head is contained', async () => {
|
|
551
|
+
await commit(worker, 'feature.txt');
|
|
552
|
+
await completeTask();
|
|
553
|
+
const sentinel = await createTask(team, {
|
|
554
|
+
subject: 'final research check', description: 'Keep the team active before the persisted failure',
|
|
555
|
+
status: 'pending', requires_code_change: false,
|
|
556
|
+
}, repo);
|
|
557
|
+
assert.notEqual((await monitorTeam(team, repo))?.phase, 'complete');
|
|
558
|
+
assert.equal((await rootState()).active, true);
|
|
559
|
+
git(repo, 'merge-base', '--is-ancestor', git(worker, 'rev-parse', 'HEAD'), 'HEAD');
|
|
560
|
+
const persisted = (await readMonitorSnapshot(team, repo));
|
|
561
|
+
persisted.integrationByWorker['worker-1'].status = 'integration_failed';
|
|
562
|
+
await writeMonitorSnapshot(team, persisted, repo);
|
|
563
|
+
await completeTask(sentinel.id, false);
|
|
564
|
+
const result = await monitorTeam(team, repo, { readOnly: true });
|
|
565
|
+
assert.equal(result?.phase, 'team-fix');
|
|
566
|
+
assert.equal((await rootState()).active, true);
|
|
567
|
+
assert.equal((await readMonitorSnapshot(team, repo))?.integrationByWorker?.['worker-1']?.status, 'integration_failed');
|
|
568
|
+
});
|
|
569
|
+
});
|
|
570
|
+
//# sourceMappingURL=runtime-delivery.test.js.map
|