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 { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
import { join } from 'node:path';
const fixture = vi.hoisted(() => ({ records: new Map(), tasks: [], trace: [], quality: [], serial: 0, completions: 0, retirements: [] }));
vi.mock('../lib/fileUtils.js', async importOriginal => {
const { makePathsProxy, lazyTempDataRoot } = await import('../lib/mockPathsDataRoot.js');
return makePathsProxy(await importOriginal(), {
dataRoot: () => lazyTempDataRoot('portos-recovered-audit-'),
extraOverrides: root => ({ root: join(root, 'primary') }),
});
});
vi.mock('../lib/maintenanceAdmission.js', () => ({ maintenance: {
continueSettlement: fn => fn(), recoverOwned: vi.fn(), withResource: (_kind, _id, fn) => fn(), finishResource: vi.fn(), markResourceUnsettled: vi.fn(),
} }));
vi.mock('./cosRunnerClient.js', () => ({
getActiveAgentsFromRunner: vi.fn(), connectTuiSessionViaRunner: vi.fn(),
spawnAgentViaRunner: vi.fn(), getRunnerHealth: vi.fn(), classifyRunnerSpawnFailure: vi.fn(),
}));
vi.mock('./shell.js', () => ({ getSession: vi.fn(() => ({})) }));
vi.mock('./cosAgentLifecycle.js', async importOriginal => ({
...(await importOriginal()),
readAgentRecordOrUnreadable: vi.fn(),
getAgent: vi.fn(async id => fixture.records.get(id)),
getAgentRecord: vi.fn(async id => fixture.records.get(id)),
updateAgent: vi.fn(async (id, update) => {
const record = fixture.records.get(id);
Object.assign(record, { ...update, metadata: { ...record.metadata, ...update.metadata } });
if (update.metadata?.auditFindings) fixture.trace.push('findings');
return record;
}),
recordCompletionCleanup: async (id, startedAt, patch) => {
const record = fixture.records.get(id);
if (record?.status !== 'completed' || record.startedAt !== startedAt) return false;
const prior = record.metadata.completionCleanup || {};
record.metadata.completionCleanup = { ...prior, ...patch, stages: { ...prior.stages, ...patch.stages } };
return true;
},
completeAgent: vi.fn(async (id, result) => {
fixture.trace.push('complete');
Object.assign(fixture.records.get(id), { status: 'completed', result });
}),
}));
vi.mock('./cosTaskStore.js', () => ({
getAllTasks: vi.fn(async () => ({ user: { grouped: {} }, cos: { grouped: { active: fixture.tasks } } })),
getTaskById: vi.fn(async id => fixture.tasks.find(t => t.id === id)),
updateTask: vi.fn(async (id, update) => Object.assign(fixture.tasks.find(t => t.id === id), update)),
addTask: vi.fn(), reviveBlockedTask: vi.fn(),
}));
vi.mock('./cosTaskGenerator.js', () => ({ checkStagePrecondition: vi.fn() }));
vi.mock('./agentWorktreeCleanup.js', () => ({
cleanupAgentWorktree: vi.fn(async id => {
fixture.trace.push('cleanup');
const record = fixture.records.get(id);
// Model the destructive boundary only; real finalization must save both
// receipts before the checkout disappears.
expect(record.metadata.auditFindings.status).toBe('complete');
expect(record.metadata.auditAssessment.status).toBe('recorded');
await rm(record.metadata.workspacePath, { recursive: true, force: true });
return [];
}),
releaseRetryHold: vi.fn(async () => ({})), spawnMergeRecoveryTask: vi.fn(),
}));
vi.mock('../lib/db.js', () => ({ ensureSchema: vi.fn(), query: vi.fn(async (_sql, values) => {
fixture.trace.push('quality');
fixture.quality.push({ category: values[1], agentId: values[2], report: JSON.parse(values[4]) });
return { rows: [] };
}) }));
vi.mock('./appQualityFederation.js', () => ({
collectAppQuality: vi.fn(), qualityRecord: vi.fn(), readQualityRecords: vi.fn(), readReleaseQuality: vi.fn(),
}));
vi.mock('./apps.js', () => ({ getAppById: vi.fn(async () => null) }));
vi.mock('./codeReview.js', () => ({
getGoalFidelityConfig: vi.fn(async () => null), runLocalGoalFidelityReview: vi.fn(),
resolveReviewLoopOptions: vi.fn(async () => ({})),
}));
vi.mock('../lib/primaryCheckoutGuard.js', async importOriginal => ({
...(await importOriginal()), detectPrimaryCheckoutDrift: vi.fn(async () => ({})),
}));
vi.mock('../lib/gitCommitProbe.js', async importOriginal => ({
...(await importOriginal()), committedDuringRun: vi.fn(async () => false),
}));
vi.mock('./agentErrorAnalysis.js', async importOriginal => ({
...(await importOriginal()), resolveFailedTaskUpdate: vi.fn(async () => ({ status: 'blocked' })),
}));
vi.mock('./cosEvents.js', () => ({ emitLog: vi.fn(), cosEvents: { emit: vi.fn(), on: vi.fn() } }));
vi.mock('./agentRunEventLog.js', () => ({ appendRunEvent: vi.fn() }));
vi.mock('./agentRunTracking.js', () => ({ completeAgentRun: vi.fn() }));
vi.mock('./agentCompletion.js', () => ({ processAgentCompletion: vi.fn() }));
vi.mock('./taskSchedule.js', () => ({ recordTaskTypeSuccess: vi.fn(async () => null), recordTaskTypeFailure: vi.fn(async () => null) }));
vi.mock('./agentSpawnPreparation.js', () => ({ createAgentSpawnContext: vi.fn(), prepareAgentSpawn: vi.fn() }));
vi.mock('./agentSpawnDispatch.js', () => ({ dispatchAgentRun: vi.fn() }));
vi.mock('./agentManagement.js', () => ({ handleOrphanedTask: vi.fn() }));
vi.mock('./agentCliSpawning.js', () => ({ isClaudeCliProvider: vi.fn(), getClaudeSettingsEnv: vi.fn() }));
vi.mock('./forgeAuth.js', () => ({ resolveForgeTokenEnv: vi.fn() }));
vi.mock('./agentApiAuth.js', () => ({ resolveAgentApiEnv: vi.fn() }));
vi.mock('./providers.js', () => ({ getActiveProvider: vi.fn() }));
vi.mock('./providerStatus.js', () => ({ markProviderUsageLimit: vi.fn(), markProviderUnavailable: vi.fn() }));
vi.mock('./toolStateMachine.js', () => ({ completeExecution: vi.fn(), errorExecution: vi.fn() }));
vi.mock('./executionLanes.js', () => ({ release: vi.fn() }));
vi.mock('./updateChecker.js', () => ({ isUpdateInProgress: vi.fn(() => false) }));
vi.mock('./jira.js', () => ({}));
vi.mock('./git.js', () => ({}));
vi.mock('./brainTaskThreads.js', () => ({ ensureTaskThread: vi.fn() }));
vi.mock('./issueReconcile.js', () => ({ issueNumberFromRef: vi.fn() }));
// handleAgentCompletion launches retirement from its finally block without
// returning it; keep the real work but own the promise so teardown can drain it.
vi.mock('./agentRepoStateVerification.js', async importOriginal => {
const actual = await importOriginal();
return { ...actual, resumeAgentCompletionRetirement: vi.fn(agentId => {
const run = actual.resumeAgentCompletionRetirement(agentId);
fixture.retirements.push(run);
return run;
}) };
});
import { PATHS } from '../lib/fileUtils.js';
import { cleanupTempDataRoots } from '../lib/mockPathsDataRoot.js';
import { AGENT_RECORD_UNREADABLE, readAgentRecordOrUnreadable } from './cosAgentLifecycle.js';
import { getActiveAgentsFromRunner } from './cosRunnerClient.js';
import { cleanupAgentWorktree } from './agentWorktreeCleanup.js';
import { activeAgents, runnerAgents } from './agentState.js';
import { syncRunnerAgents } from './agentRunnerSync.js';
import { handleAgentCompletion } from './agentLifecycle.js';
const report = { version: 1, findings: [{ key: 'example-candidate', title: 'Reviewed example candidate',
path: 'server/example.js', severity: 2, confidence: 'high', evidence: 'Synthetic caller already handles this case.',
classification: 'dismissed', disposition: { kind: 'not-actionable', reason: 'Existing caller preserves the contract.' } }] };
const quality = score => ({ version: 1, category: 'observability', score, worstSeverity: 0,
coverage: 'partial', confidence: 'high', summary: 'Synthetic category review.', scannedFiles: 1, totalFiles: 2 });
const sentinel = (findings = report, score = 82) => JSON.stringify({ summary:
`Reviewed synthetic source.\nAUDIT_FINDINGS_JSON: ${JSON.stringify(findings)}\nQUALITY_AUDIT_JSON: ${JSON.stringify(quality(score))}` });
beforeEach(async () => {
vi.clearAllMocks();
fixture.records.clear();
fixture.tasks.length = 0;
fixture.trace.length = 0;
fixture.quality.length = 0;
runnerAgents.clear();
activeAgents.clear();
await mkdir(PATHS.cosAgents, { recursive: true });
});
afterEach(async () => {
// The deferred retirement is scheduled through a dynamic import, so wait for
// each completion's launch before awaiting the launched work: resetting the
// shared records or removing the temp root underneath it is what made a
// published completion payload vanish mid-read (#13461).
await vi.waitFor(() => expect(fixture.retirements).toHaveLength(fixture.completions));
await Promise.allSettled(fixture.retirements);
fixture.completions = 0;
fixture.retirements.length = 0;
});
afterAll(cleanupTempDataRoots);
const complete = agentId => {
fixture.completions++;
return handleAgentCompletion(agentId, 0, true, 1000);
};
async function recoveredRun({ primary = false, missingPath = false, unreadable = false } = {}) {
const agentId = `agent-example-${++fixture.serial}`;
const primaryPath = join(PATHS.data, `primary-${fixture.serial}`);
const workspacePath = primary ? primaryPath : join(PATHS.data, `worktree-${fixture.serial}`);
await mkdir(primaryPath, { recursive: true });
await mkdir(workspacePath, { recursive: true });
const task = { id: `app-improve-example-${fixture.serial}`, taskType: 'internal', status: 'in_progress',
metadata: { analysisType: 'observability', auditDispositionVersion: '1', app: 'example-app', repoPath: primaryPath, openPR: false } };
const record = { id: agentId, taskId: task.id, status: 'running', startedAt: '2026-10-01T12:00:00.000Z',
metadata: { auditDispositionVersion: 1, runId: `run-example-${fixture.serial}`,
...(!missingPath && !unreadable ? { workspacePath } : {}) } };
fixture.records.set(agentId, record);
fixture.tasks.push(task);
readAgentRecordOrUnreadable.mockResolvedValue(unreadable ? AGENT_RECORD_UNREADABLE : record);
getActiveAgentsFromRunner.mockResolvedValue([{ id: agentId, taskId: task.id, kind: 'tui',
processActive: true, liveness: 'pty', startedAt: Date.parse(record.startedAt),
...(!missingPath ? { workspacePath } : {}) }]);
await writeFile(join(primaryPath, `.agent-done-${agentId}`), sentinel({ version: 1, findings: [] }, 12));
await writeFile(join(workspacePath, `.agent-done-${agentId}`), sentinel());
await writeFile(join(workspacePath, `.agent-audit-findings-${agentId}.json`), JSON.stringify(report));
await syncRunnerAgents();
return { agentId, task, record, primaryPath, workspacePath };
}
describe('recovered runner audit completion (#11526)', () => {
// This drives the real recovery -> finalizer -> audit/quality -> cleanup
// sequence. The primary checkout's valid but different report is a decoy.
it.each(['rehydrated', 'old entry without cwd', 'stale primary cwd'])('records worktree evidence before cleanup for a %s entry', async mode => {
const run = await recoveredRun();
if (mode === 'old entry without cwd') delete runnerAgents.get(run.agentId).workspacePath;
if (mode === 'stale primary cwd') runnerAgents.get(run.agentId).workspacePath = run.primaryPath;
await complete(run.agentId);
expect(run.record.metadata.auditFindings).toMatchObject({ status: 'complete', report });
expect(run.record.result).toMatchObject({ success: true, executionSuccess: true, taskOutcome: null, auditAssessment: { status: 'recorded' } });
expect(fixture.quality).toEqual([{ category: 'observability', agentId: run.agentId, report: quality(82) }]);
expect(fixture.trace.indexOf('findings')).toBeLessThan(fixture.trace.indexOf('quality'));
expect(fixture.trace.indexOf('quality')).toBeLessThan(fixture.trace.indexOf('complete'));
expect(fixture.trace.indexOf('complete')).toBeLessThan(fixture.trace.indexOf('cleanup'));
expect(runnerAgents.has(run.agentId)).toBe(false);
await expect(readFile(join(run.workspacePath, `.agent-done-${run.agentId}`))).rejects.toMatchObject({ code: 'ENOENT' });
expect(await readFile(join(run.primaryPath, `.agent-done-${run.agentId}`), 'utf8')).toBe(sentinel({ version: 1, findings: [] }, 12));
});
it('also records an explicitly registered primary-checkout audit', async () => {
const run = await recoveredRun({ primary: true });
await complete(run.agentId);
expect(run.record.metadata.auditFindings).toMatchObject({ status: 'complete', report });
expect(fixture.quality[0].report.score).toBe(82);
});
it('retains the runner cwd when the registration read is temporarily unavailable', async () => {
const run = await recoveredRun({ unreadable: true });
expect(runnerAgents.get(run.agentId).workspacePath).toBe(run.workspacePath);
// The durable registration becomes readable again before completion.
run.record.metadata.workspacePath = run.workspacePath;
await complete(run.agentId);
expect(run.record.metadata.auditFindings).toMatchObject({ status: 'complete', report });
});
it('does not borrow primary artifacts when neither registration nor runner knows the workspace', async () => {
const run = await recoveredRun({ missingPath: true });
await complete(run.agentId);
expect(run.record.result).toMatchObject({ success: false, completionReason: 'audit-disposition-incomplete' });
expect(run.record.metadata.auditFindings).toMatchObject({ status: 'incomplete', finalReportReceived: false, report: { version: 1, findings: [] } });
expect(fixture.quality).toEqual([]);
expect(cleanupAgentWorktree).not.toHaveBeenCalled();
expect(await readFile(join(run.workspacePath, `.agent-done-${run.agentId}`), 'utf8')).toBe(sentinel());
expect(await readFile(join(run.primaryPath, `.agent-done-${run.agentId}`), 'utf8')).toBe(sentinel({ version: 1, findings: [] }, 12));
});
it.each(['malformed', 'missing'])('keeps the checkout and checkpoint after a %s final report', async kind => {
const run = await recoveredRun();
const donePath = join(run.workspacePath, `.agent-done-${run.agentId}`);
if (kind === 'missing') await rm(donePath);
else await writeFile(donePath, sentinel({ version: 1, findings: [{ invalid: true }] }));
await complete(run.agentId);
expect(run.record.result).toMatchObject({ success: false, completionReason: 'audit-disposition-incomplete' });
expect(run.record.metadata.auditFindings).toMatchObject({ status: 'incomplete', finalReportReceived: false, report });
expect(cleanupAgentWorktree).not.toHaveBeenCalled();
expect(await readFile(join(run.workspacePath, `.agent-audit-findings-${run.agentId}.json`), 'utf8')).toBe(JSON.stringify(report));
if (kind === 'malformed') expect(await readFile(donePath, 'utf8')).toBe(sentinel({ version: 1, findings: [{ invalid: true }] }));
});
});