Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { afterEach, describe, expect, it, vi } from 'vitest';
import * as fs from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createMaintenanceAdmission } from '../lib/maintenanceAdmission.js';
import { reconcileDeadOwnerReservations } from './deadOwnerReservations.js';
const roots = [];
const DEAD_PID = 2147483646;
const gate = () => {
const root = fs.mkdtempSync(join(tmpdir(), 'dead-owner-reservations-'));
roots.push(root);
return { root, admission: createMaintenanceAdmission(root) };
};
const readOps = (admission) => JSON.parse(fs.readFileSync(join(admission.directory, 'state.json'), 'utf8')).operations;
const rewritePid = (admission, id, pid) => {
const file = join(admission.directory, 'state.json');
const state = JSON.parse(fs.readFileSync(file, 'utf8'));
state.operations.find(op => op.id === id).pid = pid;
fs.writeFileSync(file, JSON.stringify(state));
};
afterEach(() => { for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true }); });
describe('reconcileDeadOwnerReservations', () => {
const reconcile = (admission, extra = {}) => reconcileDeadOwnerReservations({
admission,
pidAlive: (pid) => pid === process.pid,
cliRunEnded: () => false,
mindTurnIdle: () => false,
...extra,
});
it('marks a dead-owner settled publication unsettled so receipt recovery can drain it, and leaves a live owner', () => {
const { admission } = gate();
const dead = admission.admit('settlement', 'Output publication');
const live = admission.admit('settlement', 'Output publication');
rewritePid(admission, dead.id, DEAD_PID);
const before = readOps(admission).find(op => op.id === dead.id);
const hold = admission.begin({ reason: 'Inspect refused publication', owner: 'Operator' }).hold;
const receipt = { disposition: 'operator-reconciled' };
const publish = vi.fn(() => receipt);
const replay = vi.fn(() => receipt);
// Settled residue is invisible to the receipt path. Skipping the stamp leaves this refusal in place.
expect(() => admission.reconcilePublicationRefusal({ hold, expected: before, publish, replay })).toThrow(/uncertain publication/);
expect(publish).not.toHaveBeenCalled();
expect(reconcile(admission)).toMatchObject({ marked: 1, released: 0 });
const stamped = readOps(admission).find(op => op.id === dead.id);
expect(stamped).toMatchObject({ unsettled: true, pid: DEAD_PID, resource: 'Output publication' });
expect(stamped.uncertaintyStamp).toMatch(/^[0-9a-f-]{36}$/i);
expect(readOps(admission).find(op => op.id === live.id).unsettled).toBeUndefined();
expect(admission.reconcilePublicationRefusal({ hold, expected: stamped, publish, replay })).toBe(receipt);
expect(publish).toHaveBeenCalledOnce();
expect(replay).not.toHaveBeenCalled();
expect(readOps(admission).some(op => op.id === dead.id)).toBe(false);
expect(readOps(admission).some(op => op.id === live.id)).toBe(true);
});
it('does not rotate an uncertainty stamp or stamp a non-publication settlement', () => {
const { admission } = gate();
const stamped = admission.admit('settlement', 'Output publication');
stamped.markUnsettled();
const other = admission.admit('settlement', 'Saving');
rewritePid(admission, stamped.id, DEAD_PID);
rewritePid(admission, other.id, DEAD_PID);
const stamp = readOps(admission).find(op => op.id === stamped.id).uncertaintyStamp;
expect(reconcile(admission)).toEqual({ marked: 0, released: 0 });
expect(readOps(admission).find(op => op.id === stamped.id).uncertaintyStamp).toBe(stamp);
expect(readOps(admission).find(op => op.id === other.id).unsettled).toBeUndefined();
});
it('releases only the dead-owner kinds whose owning record proves completion', () => {
const { admission } = gate();
const ended = admission.admit('cli-run', 'fixture-run-ended');
const open = admission.admit('cli-run', 'fixture-run-open');
const liveRun = admission.admit('cli-run', 'fixture-run-live');
const idleTurn = admission.admit('mind-turn', 'persistent-mind');
const provider = admission.admit('provider', 'fixture-source');
const media = admission.admit('media', 'fixture-render');
for (const op of [ended, open, idleTurn, provider, media]) rewritePid(admission, op.id, DEAD_PID);
expect(reconcile(admission, {
cliRunEnded: (runId) => runId === 'fixture-run-ended',
mindTurnIdle: () => true,
})).toEqual({ marked: 0, released: 2 });
const resources = admission.operations().map(op => op.resource).sort();
expect(resources).toEqual(['fixture-render', 'fixture-run-live', 'fixture-run-open', 'fixture-source']);
expect(admission.operations().find(op => op.id === liveRun.id)).toMatchObject({
resource: 'fixture-run-live',
pid: process.pid,
});
});
it('keeps a dead mind-turn while a turn is still active, and an unsettled cli-run even after it ended', () => {
const { admission } = gate();
const turn = admission.admit('mind-turn', 'persistent-mind');
const run = admission.admit('cli-run', 'fixture-run-ended');
run.markUnsettled();
rewritePid(admission, turn.id, DEAD_PID);
rewritePid(admission, run.id, DEAD_PID);
expect(reconcile(admission, {
cliRunEnded: () => true,
mindTurnIdle: () => false,
})).toEqual({ marked: 0, released: 0 });
expect(admission.operations().map(op => op.resource).sort()).toEqual(['fixture-run-ended', 'persistent-mind']);
});
it('skips quietly when the journal needs recovery', () => {
const { admission } = gate();
admission.admit('settlement', 'Output publication');
fs.writeFileSync(join(admission.directory, 'state.json'), '{not json');
expect(reconcile(admission)).toEqual({ marked: 0, released: 0 });
});
});
describe('owning-record proofs', () => {
it('treats a non-empty end time as a finished cli run and ignores escapes', () => {
const { admission } = gate();
const root = fs.mkdtempSync(join(tmpdir(), 'dead-owner-runs-'));
roots.push(root);
const write = (id, endTime) => {
fs.mkdirSync(join(root, id));
fs.writeFileSync(join(root, id, 'metadata.json'), JSON.stringify({ endTime }));
};
write('fixture-run-ended', '2026-01-01T00:00:00.000Z');
write('fixture-run-open', null);
for (const id of ['fixture-run-ended', 'fixture-run-open', 'fixture-run-missing', '../fixture-run-ended', '']) {
rewritePid(admission, admission.admit('cli-run', id).id, DEAD_PID);
}
expect(reconcileDeadOwnerReservations({
admission,
pidAlive: (pid) => pid === process.pid,
runsDir: root,
mindTurnIdle: () => false,
})).toEqual({ marked: 0, released: 1 });
expect(admission.operations().map(op => op.resource).sort()).toEqual(
['', '../fixture-run-ended', 'fixture-run-missing', 'fixture-run-open'],
);
});
it('requires a mind object with no active turn', () => {
const { admission } = gate();
const root = fs.mkdtempSync(join(tmpdir(), 'dead-owner-mind-'));
roots.push(root);
const file = join(root, 'state.json');
const turn = admission.admit('mind-turn', 'persistent-mind');
rewritePid(admission, turn.id, DEAD_PID);
const kept = (state) => {
fs.writeFileSync(file, JSON.stringify(state));
expect(reconcileDeadOwnerReservations({
admission,
pidAlive: (pid) => pid === process.pid,
cliRunEnded: () => false,
mindStatePath: file,
})).toEqual({ marked: 0, released: 0 });
expect(admission.operations().some(op => op.id === turn.id)).toBe(true);
};
kept(null);
kept({});
kept({ persistentMind: [] });
kept({ persistentMind: { activeTurn: { id: 'fixture-turn' } } });
fs.writeFileSync(file, JSON.stringify({ persistentMind: {} }));
expect(reconcileDeadOwnerReservations({
admission,
pidAlive: (pid) => pid === process.pid,
cliRunEnded: () => false,
mindStatePath: file,
})).toEqual({ marked: 0, released: 1 });
expect(admission.operations().some(op => op.id === turn.id)).toBe(false);
const again = admission.admit('mind-turn', 'persistent-mind');
rewritePid(admission, again.id, DEAD_PID);
fs.writeFileSync(file, JSON.stringify({ persistentMind: { activeTurn: null } }));
expect(reconcileDeadOwnerReservations({
admission,
pidAlive: (pid) => pid === process.pid,
cliRunEnded: () => false,
mindStatePath: file,
})).toEqual({ marked: 0, released: 1 });
});
});