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 { NOTIFICATION_ACTION_POLICY } from '../lib/notificationTypes.js';
const CONTEXT_ONLY_REVIEW_CATEGORIES = new Set([
'client-error',
'health-issue',
'warning',
]);
const toText = (value) => (typeof value === 'string' ? value.trim() : '');
const toReference = (value) => {
if (typeof value === 'number' && Number.isFinite(value)) return String(value);
return toText(value);
};
const severityFor = (value) => {
const normalized = toText(value).toLowerCase();
if (['critical', 'high', 'medium', 'low'].includes(normalized)) return normalized;
if (value === 1 || value === '1') return 'high';
if (value === 2 || value === '2') return 'medium';
return 'normal';
};
const operation = (id, label, available = true) => ({
id,
label,
available,
});
export const canonicalActionId = (source, sourceRef) => `${source}:${sourceRef}`;
const reviewItemBase = (item, values) => ({
...values,
title: toText(item?.title) || 'Review obligation',
summary: toText(item?.description) || toText(item?.title),
timestamp: item?.createdAt,
severity: severityFor(item?.metadata?.severity ?? item?.metadata?.priority),
meta: {
reviewItemId: item?.id,
...values.meta,
},
});
export function adaptStoredReviewItem(item) {
if (!item || item.status !== 'pending') return null;
const metadata = item.metadata && typeof item.metadata === 'object' ? item.metadata : {};
const category = toText(metadata.category);
const referenceId = toReference(metadata.referenceId);
const link = toText(metadata.link) || toText(metadata.reportUrl);
if (category === 'memory-approval' || toReference(metadata.memoryId)) {
const sourceRef = toReference(metadata.memoryId) || referenceId;
if (!sourceRef) return null;
return reviewItemBase(item, {
id: canonicalActionId('memory', sourceRef),
sourceRef,
actionKind: 'memory.approval',
required: true,
sourceOwned: true,
drillTo: link || '/cos/memory',
operations: [operation('approve', 'Approve'), operation('reject', 'Reject')],
meta: { category: 'memory-approval' },
});
}
if (category === 'goal-fidelity') {
const sourceRef = toReference(metadata.agentId) || referenceId;
if (!sourceRef) return null;
return reviewItemBase(item, {
id: canonicalActionId('goal-fidelity', sourceRef),
sourceRef,
actionKind: 'goal-fidelity.review',
required: true,
sourceOwned: true,
drillTo: link || `/cos/agents/${encodeURIComponent(sourceRef)}`,
operations: [operation('complete', 'Mark resolved')],
meta: { category: 'goal-fidelity' },
});
}
if (category === 'task-approval' || item.type === 'cos') {
const sourceRef = toReference(metadata.taskId) || referenceId;
if (!sourceRef) return null;
return reviewItemBase(item, {
id: canonicalActionId('cos', sourceRef),
sourceRef,
actionKind: 'task.approval',
required: true,
sourceOwned: true,
drillTo: link || '/cos',
operations: [operation('approve', 'Approve')],
meta: { category: 'task-approval' },
});
}
if (category === 'plan-question') {
const sourceRef = toReference(metadata.agentId) || toReference(metadata.appId) || referenceId;
if (!sourceRef) return null;
return reviewItemBase(item, {
id: canonicalActionId('plan', sourceRef),
sourceRef,
actionKind: 'plan.question',
required: true,
sourceOwned: true,
drillTo: link || '/cos',
operations: [operation('complete', 'Mark resolved')],
meta: { category: 'plan-question' },
});
}
if (category === 'autopilot-paused') {
const seriesId = toReference(metadata.autopilotPauseSeriesId) || toReference(metadata.seriesId);
const runId = toReference(metadata.runId);
if (!seriesId) return null;
const sourceRef = [seriesId, runId].filter(Boolean).join(':');
return reviewItemBase(item, {
id: canonicalActionId('autopilot', sourceRef),
sourceRef,
actionKind: 'autopilot.resume',
required: true,
sourceOwned: true,
drillTo: link || `/pipeline/series/${encodeURIComponent(seriesId)}`,
operations: [operation('complete', 'Mark resolved')],
meta: { category: 'autopilot-paused' },
});
}
if (CONTEXT_ONLY_REVIEW_CATEGORIES.has(category)) return null;
if (category === 'content-review' || metadata.contentReview === true) {
if (!referenceId) return null;
return reviewItemBase(item, {
id: canonicalActionId('content', referenceId),
sourceRef: referenceId,
actionKind: 'content.review',
required: true,
sourceOwned: true,
drillTo: link || '/review',
operations: [operation('complete', 'Mark resolved')],
meta: { category: 'content-review' },
});
}
if (item.type !== 'alert') return null;
const legacyReference = toReference(item.id);
if (!legacyReference) return null;
return reviewItemBase(item, {
id: canonicalActionId('review', legacyReference),
sourceRef: legacyReference,
actionKind: 'review.triage',
required: true,
sourceOwned: true,
triageOnly: true,
drillTo: link || '/review',
operations: [operation('complete', 'Mark resolved')],
meta: { category: 'legacy-review-triage', triage: true },
});
}
export const notificationReference = (notification, policy) => {
const metadata = notification?.metadata && typeof notification.metadata === 'object'
? notification.metadata
: {};
const fields = policy.referenceFields ?? [];
const values = fields.map((field) => toReference(metadata[field])).filter(Boolean);
if (policy.compoundReference) return values.join(':');
return values[0] || '';
};
export function adaptNotification(notification) {
// Read and clear apply to event history, never to the source obligation.
if (!notification) return null;
const policy = NOTIFICATION_ACTION_POLICY[notification.type];
if (!policy) return null;
const sourceRef = notificationReference(notification, policy);
const drillTo = toText(notification.link) || toText(policy.fallbackDrillTo);
if (!sourceRef || !drillTo) return null;
const operations = policy.operations.map(({ id, label, available }) => operation(id, label, available));
return {
id: canonicalActionId(policy.actionSource, sourceRef),
sourceRef,
actionKind: policy.actionKind,
required: policy.required,
sourceOwned: true,
title: toText(notification.title) || policy.label,
summary: toText(notification.description) || toText(notification.message) || toText(notification.title),
timestamp: notification.timestamp || notification.createdAt,
severity: severityFor(notification.priority ?? notification.severity),
drillTo,
operations,
meta: {
notificationId: notification.id,
category: policy.category,
actionSource: policy.actionSource,
},
};
}