@shapeshift-labs/frontier-swarm 0.1.0

package/dist/index.js

@@ -0,0 +1,622 @@
+export const FRONTIER_SWARM_MANIFEST_KIND = 'frontier.swarm.manifest';
+export const FRONTIER_SWARM_MANIFEST_VERSION = 1;
+export const FRONTIER_SWARM_TASK_KIND = 'frontier.swarm.task';
+export const FRONTIER_SWARM_TASK_VERSION = 1;
+export const FRONTIER_SWARM_PLAN_KIND = 'frontier.swarm.plan';
+export const FRONTIER_SWARM_PLAN_VERSION = 1;
+export const FRONTIER_SWARM_RUN_KIND = 'frontier.swarm.run';
+export const FRONTIER_SWARM_RUN_VERSION = 1;
+export const FRONTIER_SWARM_EVENT_KIND = 'frontier.swarm.event';
+export const FRONTIER_SWARM_EVENT_VERSION = 1;
+export const FRONTIER_SWARM_PROOF_KIND = 'frontier.swarm.proof';
+export const FRONTIER_SWARM_PROOF_VERSION = 1;
+export const FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID = 'codex.gpt-5.5.xhigh';
+export const FRONTIER_SWARM_DEFAULT_MODEL = 'gpt-5.5';
+export const FRONTIER_SWARM_DEFAULT_REASONING_EFFORT = 'xhigh';
+const DEFAULT_COMPLETED_STATUSES = ['completed', 'verified', 'done', 'verified-local-harness'];
+export function defineSwarmManifest(input = {}) {
+    return createSwarmManifest(input);
+}
+export function createSwarmManifest(input = {}) {
+    const compute = normalizeComputeList(input.compute);
+    const defaultCompute = input.policy?.defaultCompute ?? compute[0]?.id ?? FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID;
+    const layers = (input.layers ?? []).map(normalizeLayer);
+    const lanes = (input.lanes ?? []).map(normalizeLane);
+    const policy = normalizePolicy(input.policy, defaultCompute);
+    return {
+        kind: FRONTIER_SWARM_MANIFEST_KIND,
+        version: FRONTIER_SWARM_MANIFEST_VERSION,
+        id: normalizeId(input.id ?? 'frontier-swarm', 'manifest id'),
+        title: input.title ?? titleFromId(input.id ?? 'frontier swarm'),
+        ...(input.description ? { description: input.description } : {}),
+        ...(input.package ? { package: input.package } : {}),
+        ...(input.feature ? { feature: input.feature } : {}),
+        ...(input.owner ? { owner: input.owner } : {}),
+        compute,
+        layers,
+        lanes,
+        policy,
+        resources: uniqueStrings(input.resources ?? []),
+        tags: uniqueStrings(input.tags ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {}),
+        summary: {
+            computeCount: compute.length,
+            layerCount: layers.length,
+            laneCount: lanes.length
+        }
+    };
+}
+export function defineSwarmTasks(input = []) {
+    const raw = Array.isArray(input) ? input : (input.tasks ?? input.items ?? []);
+    return raw.map(normalizeTask);
+}
+export function compileSwarm(input) {
+    const manifest = isSwarmManifest(input) ? cloneJsonValue(input) : createSwarmManifest(input);
+    const computeById = new Map(manifest.compute.map((compute) => [compute.id, compute]));
+    const layersById = new Map(manifest.layers.map((layer) => [layer.id, layer]));
+    const lanesById = new Map(manifest.lanes.map((lane) => [lane.id, lane]));
+    return {
+        manifest,
+        computeById,
+        layersById,
+        lanesById,
+        validation: validateSwarmManifest(manifest)
+    };
+}
+export function validateSwarmManifest(input) {
+    const manifest = isSwarmManifest(input) ? input : createSwarmManifest(input);
+    const issues = [];
+    const computeIds = new Set();
+    const layerIds = new Set();
+    const laneIds = new Set();
+    for (const compute of manifest.compute) {
+        if (computeIds.has(compute.id))
+            addIssue(issues, 'duplicate-compute', 'error', `compute.${compute.id}`, `Duplicate compute id: ${compute.id}`);
+        computeIds.add(compute.id);
+    }
+    if (!computeIds.has(manifest.policy.defaultCompute)) {
+        addIssue(issues, 'missing-default-compute', 'error', 'policy.defaultCompute', `Default compute is not declared: ${manifest.policy.defaultCompute}`);
+    }
+    for (const layer of manifest.layers) {
+        if (layerIds.has(layer.id))
+            addIssue(issues, 'duplicate-layer', 'error', `layers.${layer.id}`, `Duplicate layer id: ${layer.id}`);
+        layerIds.add(layer.id);
+    }
+    for (const layer of manifest.layers) {
+        if (layer.parentId && !layerIds.has(layer.parentId)) {
+            addIssue(issues, 'missing-parent-layer', 'error', `layers.${layer.id}.parentId`, `Layer parent is not declared: ${layer.parentId}`);
+        }
+        for (const [childLayer, compute] of Object.entries(layer.childCompute)) {
+            if (childLayer !== '*' && !layerIds.has(childLayer)) {
+                addIssue(issues, 'missing-child-layer', 'error', `layers.${layer.id}.childCompute.${childLayer}`, `Child layer is not declared: ${childLayer}`);
+            }
+            if (!computeIds.has(compute)) {
+                addIssue(issues, 'missing-child-compute', 'error', `layers.${layer.id}.childCompute.${childLayer}`, `Child compute is not declared: ${compute}`);
+            }
+        }
+        for (const field of ['compute', 'defaultCompute']) {
+            const compute = layer[field];
+            if (compute && !computeIds.has(compute)) {
+                addIssue(issues, 'missing-layer-compute', 'error', `layers.${layer.id}.${field}`, `Layer compute is not declared: ${compute}`);
+            }
+        }
+        if (hasLayerCycle(layer.id, manifest.layers)) {
+            addIssue(issues, 'layer-cycle', 'error', `layers.${layer.id}`, `Layer parent chain contains a cycle at ${layer.id}`);
+        }
+    }
+    for (const lane of manifest.lanes) {
+        if (laneIds.has(lane.id))
+            addIssue(issues, 'duplicate-lane', 'error', `lanes.${lane.id}`, `Duplicate lane id: ${lane.id}`);
+        laneIds.add(lane.id);
+        if (lane.layer && !layerIds.has(lane.layer)) {
+            addIssue(issues, 'missing-lane-layer', 'error', `lanes.${lane.id}.layer`, `Lane layer is not declared: ${lane.layer}`);
+        }
+        if (lane.compute && !computeIds.has(lane.compute)) {
+            addIssue(issues, 'missing-lane-compute', 'error', `lanes.${lane.id}.compute`, `Lane compute is not declared: ${lane.compute}`);
+        }
+    }
+    return { valid: issues.every((issue) => issue.severity !== 'error'), issues };
+}
+export function createSwarmPlan(manifestInput, taskInput, options = {}) {
+    const compiled = compileSwarm(manifestInput);
+    const tasks = normalizeTaskList(taskInput);
+    const jobs = selectSwarmTasks(compiled.manifest, tasks, options).map((task) => createJob(compiled, task, options));
+    const id = options.id ?? 'swarm-plan:' + stableHash([compiled.manifest.id, jobs.map((job) => job.id), options]);
+    return {
+        kind: FRONTIER_SWARM_PLAN_KIND,
+        version: FRONTIER_SWARM_PLAN_VERSION,
+        id,
+        runId: options.runId ?? id.replace(/^swarm-plan:/, 'swarm-run:'),
+        manifestId: compiled.manifest.id,
+        createdAt: options.now ?? Date.now(),
+        filters: {
+            lanes: options.lanes ? [...options.lanes] : undefined,
+            layers: options.layers ? [...options.layers] : undefined,
+            statuses: options.statuses ? [...options.statuses] : undefined,
+            selectors: options.selectors ? [...options.selectors] : undefined,
+            includeCompleted: options.includeCompleted,
+            limit: options.limit,
+            compute: options.compute
+        },
+        validation: validateTasksForManifest(compiled, tasks),
+        jobs,
+        summary: summarizeJobs(jobs),
+        ...(toJsonObject(options.metadata) ? { metadata: toJsonObject(options.metadata) } : {})
+    };
+}
+export function createSwarmRun(input) {
+    const results = (input.results ?? []).map(normalizeResult);
+    const events = (input.events ?? []).map((event) => normalizeEvent({ ...event, runId: event.runId ?? input.id ?? input.plan.runId }));
+    const run = {
+        kind: FRONTIER_SWARM_RUN_KIND,
+        version: FRONTIER_SWARM_RUN_VERSION,
+        id: input.id ?? input.plan.runId,
+        planId: input.plan.id,
+        manifestId: input.plan.manifestId,
+        startedAt: input.startedAt ?? Date.now(),
+        status: input.status ?? 'planned',
+        jobs: input.plan.jobs.map((job) => cloneJsonValue(job)),
+        events,
+        results,
+        summary: summarizeRun(input.plan.jobs, results),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+    return run;
+}
+export function recordSwarmEvent(runInput, eventInput) {
+    const run = cloneJsonValue(runInput);
+    run.events = run.events.concat(normalizeEvent({ ...eventInput, runId: eventInput.runId ?? run.id }));
+    return run;
+}
+export function completeSwarmJob(runInput, resultInput) {
+    const run = cloneJsonValue(runInput);
+    const result = normalizeResult(resultInput);
+    const resultIndex = run.results.findIndex((entry) => entry.jobId === result.jobId);
+    if (resultIndex >= 0)
+        run.results[resultIndex] = result;
+    else
+        run.results.push(result);
+    run.jobs = run.jobs.map((job) => job.id === result.jobId ? { ...job, status: result.status } : job);
+    run.summary = summarizeRun(run.jobs, run.results);
+    if (run.results.length >= run.jobs.length && run.summary.failedCount === 0 && run.summary.blockedCount === 0) {
+        run.status = 'completed';
+        run.finishedAt = result.finishedAt ?? Date.now();
+    }
+    else if (run.summary.failedCount && run.summary.failedCount > 0) {
+        run.status = 'failed';
+    }
+    return run;
+}
+export function checkSwarmOwnership(job, changedPaths) {
+    const changed = uniqueStrings(changedPaths);
+    const violations = changed.filter((file) => !job.allowedWrites.some((glob) => matchesGlob(file, glob)));
+    return {
+        ok: violations.length === 0,
+        changedPaths: changed,
+        allowedWrites: [...job.allowedWrites],
+        violations
+    };
+}
+export function resolveSwarmCompute(manifestInput, taskInput) {
+    const compiled = compileSwarm(manifestInput);
+    const task = isSwarmTask(taskInput) ? taskInput : normalizeTask(taskInput);
+    return resolveTaskCompute(compiled, task);
+}
+export function createSwarmProof(input, options = {}) {
+    const manifestId = 'manifestId' in input ? input.manifestId : input.id;
+    const summary = input.summary;
+    const generatedAt = options.generatedAt ?? Date.now();
+    return {
+        kind: FRONTIER_SWARM_PROOF_KIND,
+        version: FRONTIER_SWARM_PROOF_VERSION,
+        id: 'swarm-proof:' + stableHash([manifestId, summary, generatedAt]),
+        manifestId,
+        generatedAt,
+        hash: stableHash([input, options.validation, options.metadata]),
+        summary,
+        ...(options.validation ? { validation: options.validation } : {}),
+        ...(toJsonObject(options.metadata) ? { metadata: toJsonObject(options.metadata) } : {})
+    };
+}
+export function encodeSwarmJsonl(records) {
+    return records.map((record) => JSON.stringify(record)).join('\n') + (records.length ? '\n' : '');
+}
+export function decodeSwarmJsonl(jsonl) {
+    return jsonl.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+}
+export function matchesGlob(file, glob) {
+    const escaped = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '\u0000')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\u0000/g, '.*');
+    return new RegExp('^' + escaped + '$').test(file);
+}
+function normalizeComputeList(input) {
+    const values = input && input.length > 0 ? input : [{
+            id: FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID,
+            kind: 'codex',
+            model: FRONTIER_SWARM_DEFAULT_MODEL,
+            reasoningEffort: FRONTIER_SWARM_DEFAULT_REASONING_EFFORT
+        }];
+    return values.map((compute) => ({
+        id: normalizeId(compute.id, 'compute id'),
+        kind: compute.kind ?? 'external',
+        ...(compute.title ? { title: compute.title } : {}),
+        ...(compute.model ? { model: compute.model } : {}),
+        ...(compute.reasoningEffort ? { reasoningEffort: compute.reasoningEffort } : {}),
+        ...(compute.serviceTier ? { serviceTier: compute.serviceTier } : {}),
+        ...(compute.profile ? { profile: compute.profile } : {}),
+        ...(compute.sandbox ? { sandbox: compute.sandbox } : {}),
+        ...(compute.approval ? { approval: compute.approval } : {}),
+        ...(positiveNumber(compute.maxConcurrency) ? { maxConcurrency: Math.floor(compute.maxConcurrency) } : {}),
+        ...(positiveNumber(compute.timeoutMs) ? { timeoutMs: Math.floor(compute.timeoutMs) } : {}),
+        ...(toJsonObject(compute.metadata) ? { metadata: toJsonObject(compute.metadata) } : {})
+    }));
+}
+function normalizeLayer(input) {
+    return {
+        id: normalizeId(input.id, 'layer id'),
+        title: input.title ?? titleFromId(input.id),
+        ...(input.description ? { description: input.description } : {}),
+        ...(input.parentId ? { parentId: normalizeId(input.parentId, 'parent layer id') } : {}),
+        ...(input.compute ? { compute: input.compute } : {}),
+        ...(input.defaultCompute ? { defaultCompute: input.defaultCompute } : {}),
+        childCompute: { ...(input.childCompute ?? {}) },
+        tags: uniqueStrings(input.tags ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeLane(input) {
+    const allowedWrites = uniqueStrings([...(input.allowedWrites ?? []), ...(input.allowedGlobs ?? [])]);
+    return {
+        id: normalizeId(input.id, 'lane id'),
+        title: input.title ?? titleFromId(input.id),
+        ...(input.description ? { description: input.description } : {}),
+        ...(input.layer ? { layer: input.layer } : {}),
+        ...(input.compute ? { compute: input.compute } : {}),
+        allowedWrites,
+        sharedReadOnly: uniqueStrings(input.sharedReadOnly ?? []),
+        neverEdit: uniqueStrings(input.neverEdit ?? []),
+        ...(input.worktreePath ? { worktreePath: input.worktreePath } : {}),
+        ...(input.evidencePrefix || input.evidenceOutDirPrefix ? { evidencePrefix: input.evidencePrefix ?? input.evidenceOutDirPrefix } : {}),
+        concurrencyKey: input.concurrencyKey ?? input.id,
+        ...(positiveNumber(input.maxConcurrency) ? { maxConcurrency: Math.floor(input.maxConcurrency) } : {}),
+        handoffCommands: normalizeCommands(input.handoffCommands ?? []),
+        tags: uniqueStrings(input.tags ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizePolicy(input, defaultCompute) {
+    return {
+        mode: input?.mode ?? 'hard-file-ownership',
+        defaultConcurrency: Math.max(1, Math.floor(input?.defaultConcurrency ?? 1)),
+        defaultCompute: input?.defaultCompute ?? defaultCompute,
+        ...(input?.defaultLayer ? { defaultLayer: input.defaultLayer } : {}),
+        completedStatuses: uniqueStrings(input?.completedStatuses ?? DEFAULT_COMPLETED_STATUSES),
+        sharedReadOnly: uniqueStrings(input?.sharedReadOnly ?? []),
+        neverEditWithoutParent: uniqueStrings(input?.neverEditWithoutParent ?? []),
+        requireCleanWorktree: input?.requireCleanWorktree ?? true,
+        ...(toJsonObject(input?.metadata) ? { metadata: toJsonObject(input?.metadata) } : {})
+    };
+}
+function normalizeTask(input) {
+    const targetRefs = uniqueStrings([...(input.targetRefs ?? []), ...(input.ownedFiles ?? [])]);
+    return {
+        kind: FRONTIER_SWARM_TASK_KIND,
+        version: FRONTIER_SWARM_TASK_VERSION,
+        id: normalizeId(input.id, 'task id'),
+        title: input.title ?? titleFromId(input.id),
+        objective: input.objective ?? input.description ?? input.title ?? input.id,
+        ...(input.description ? { description: input.description } : {}),
+        workKind: input.kind ?? 'agent-task',
+        status: input.status ?? 'open',
+        ...(input.lane ? { lane: input.lane } : {}),
+        ...(input.layer ? { layer: input.layer } : {}),
+        ...(input.compute ? { compute: input.compute } : {}),
+        ...(input.parentTaskId ? { parentTaskId: input.parentTaskId } : {}),
+        priority: Number.isFinite(input.priority) ? Number(input.priority) : 100,
+        sourceRefs: uniqueStrings(input.sourceRefs ?? []),
+        targetRefs,
+        allowedWrites: uniqueStrings([...(input.allowedWrites ?? []), ...targetRefs]),
+        acceptance: normalizeAcceptance(input),
+        verification: normalizeCommands(input.verification ?? []),
+        ...(input.evidenceCommand ? { evidenceCommand: input.evidenceCommand } : {}),
+        ...(input.shardCommand ? { shardCommand: input.shardCommand } : {}),
+        tags: uniqueStrings(input.tags ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeTaskList(input) {
+    if (Array.isArray(input))
+        return input.map((task) => isSwarmTask(task) ? cloneJsonValue(task) : normalizeTask(task));
+    return defineSwarmTasks(input);
+}
+function normalizeAcceptance(input) {
+    const checks = (input.acceptanceChecks ?? []).map((check) => typeof check === 'string' ? check : check.description ?? check.id ?? '').filter(Boolean);
+    return uniqueStrings([...(input.acceptance ?? []), ...checks]);
+}
+function normalizeCommands(input) {
+    return input.map((entry) => {
+        if (typeof entry === 'string') {
+            return { name: entry, command: entry, args: [], required: true };
+        }
+        return {
+            name: entry.name ?? [entry.command, ...(entry.args ?? [])].join(' '),
+            command: entry.command,
+            args: [...(entry.args ?? [])],
+            required: entry.required ?? true,
+            ...(entry.cwd ? { cwd: entry.cwd } : {}),
+            ...(toJsonObject(entry.metadata) ? { metadata: toJsonObject(entry.metadata) } : {})
+        };
+    });
+}
+function selectSwarmTasks(manifest, tasks, options) {
+    const lanes = new Set(options.lanes ?? []);
+    const layers = new Set(options.layers ?? []);
+    const statuses = new Set(options.statuses ?? []);
+    const selectors = (options.selectors ?? []).map((selector) => selector.toLowerCase());
+    const completed = new Set(manifest.policy.completedStatuses);
+    const limit = options.limit === undefined ? tasks.length : Math.max(0, Math.floor(options.limit));
+    return tasks
+        .filter((task) => !task.lane || manifest.lanes.some((lane) => lane.id === task.lane))
+        .filter((task) => lanes.size === 0 || (task.lane !== undefined && lanes.has(task.lane)))
+        .filter((task) => layers.size === 0 || taskLayer(manifest, task) !== undefined && layers.has(taskLayer(manifest, task)))
+        .filter((task) => statuses.size === 0 || statuses.has(task.status))
+        .filter((task) => options.includeCompleted || !completed.has(task.status))
+        .filter((task) => selectors.length === 0 || selectors.some((selector) => searchableTask(task).includes(selector)))
+        .sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id))
+        .slice(0, limit);
+}
+function createJob(compiled, task, options) {
+    const lane = task.lane ? compiled.lanesById.get(task.lane) : undefined;
+    const layer = task.layer ?? lane?.layer ?? compiled.manifest.policy.defaultLayer;
+    const compute = options.compute
+        ? readCompute(compiled, options.compute)
+        : resolveTaskCompute(compiled, task);
+    const evidencePrefix = lane?.evidencePrefix ? lane.evidencePrefix.replace(/\/?$/, '/') + slug(task.id) + '/' : undefined;
+    const allowedWrites = uniqueStrings([
+        ...(lane?.allowedWrites ?? []),
+        ...task.allowedWrites,
+        ...(evidencePrefix ? [evidencePrefix + '**'] : [])
+    ]);
+    const ownershipWarnings = task.targetRefs
+        .filter((file) => allowedWrites.length > 0 && !allowedWrites.some((glob) => matchesGlob(file, glob)))
+        .map((file) => `${file} is outside allowed write globs for ${lane?.id ?? 'unassigned'}`);
+    return {
+        id: `${lane?.id ?? 'unassigned'}-${slug(task.id)}`,
+        taskId: task.id,
+        title: task.title,
+        lane: lane?.id ?? 'unassigned',
+        ...(layer ? { layer } : {}),
+        compute,
+        status: 'planned',
+        priority: task.priority,
+        task,
+        allowedWrites,
+        sharedReadOnly: uniqueStrings([...(compiled.manifest.policy.sharedReadOnly ?? []), ...(lane?.sharedReadOnly ?? [])]),
+        neverEdit: uniqueStrings([...(compiled.manifest.policy.neverEditWithoutParent ?? []), ...(lane?.neverEdit ?? [])]),
+        ...(lane?.worktreePath ? { worktreePath: lane.worktreePath } : {}),
+        ...(evidencePrefix ? { evidencePrefix } : {}),
+        concurrencyKey: lane?.concurrencyKey ?? task.lane ?? compute.id,
+        ownershipWarnings,
+        verification: task.verification.length ? task.verification : (lane?.handoffCommands ?? []),
+        acceptance: [...task.acceptance],
+        tags: uniqueStrings([...task.tags, ...(lane?.tags ?? []), ...(layer ? [layer] : []), compute.id]),
+        ...(task.metadata ? { metadata: task.metadata } : {})
+    };
+}
+function resolveTaskCompute(compiled, task) {
+    if (task.compute)
+        return readCompute(compiled, task.compute);
+    const lane = task.lane ? compiled.lanesById.get(task.lane) : undefined;
+    if (lane?.compute)
+        return readCompute(compiled, lane.compute);
+    const layerId = task.layer ?? lane?.layer ?? compiled.manifest.policy.defaultLayer;
+    const layered = layerId ? resolveLayerCompute(compiled, layerId) : undefined;
+    return layered ?? readCompute(compiled, compiled.manifest.policy.defaultCompute);
+}
+function resolveLayerCompute(compiled, layerId) {
+    const layer = compiled.layersById.get(layerId);
+    if (!layer)
+        return undefined;
+    let childId = layer.id;
+    let parentId = layer.parentId;
+    while (parentId) {
+        const parent = compiled.layersById.get(parentId);
+        if (!parent)
+            break;
+        const selected = parent.childCompute[childId] ?? parent.childCompute['*'];
+        if (selected)
+            return readCompute(compiled, selected);
+        childId = parent.id;
+        parentId = parent.parentId;
+    }
+    const own = layer.compute ?? layer.defaultCompute;
+    return own ? readCompute(compiled, own) : undefined;
+}
+function readCompute(compiled, id) {
+    return compiled.computeById.get(id) ?? compiled.computeById.get(compiled.manifest.policy.defaultCompute) ?? compiled.manifest.compute[0];
+}
+function validateTasksForManifest(compiled, tasks) {
+    const issues = [...compiled.validation.issues];
+    for (const task of tasks) {
+        if (task.lane && !compiled.lanesById.has(task.lane)) {
+            addIssue(issues, 'missing-task-lane', 'error', `tasks.${task.id}.lane`, `Task lane is not declared: ${task.lane}`);
+        }
+        if (task.layer && !compiled.layersById.has(task.layer)) {
+            addIssue(issues, 'missing-task-layer', 'error', `tasks.${task.id}.layer`, `Task layer is not declared: ${task.layer}`);
+        }
+        if (task.compute && !compiled.computeById.has(task.compute)) {
+            addIssue(issues, 'missing-task-compute', 'error', `tasks.${task.id}.compute`, `Task compute is not declared: ${task.compute}`);
+        }
+    }
+    return { valid: issues.every((issue) => issue.severity !== 'error'), issues };
+}
+function normalizeEvent(input) {
+    const at = input.at ?? Date.now();
+    return {
+        kind: FRONTIER_SWARM_EVENT_KIND,
+        version: FRONTIER_SWARM_EVENT_VERSION,
+        id: input.id ?? 'swarm-event:' + stableHash([input.type, input.runId, input.jobId, at, input.data]),
+        type: input.type,
+        ...(input.runId ? { runId: input.runId } : {}),
+        ...(input.jobId ? { jobId: input.jobId } : {}),
+        ...(input.taskId ? { taskId: input.taskId } : {}),
+        ...(input.lane ? { lane: input.lane } : {}),
+        ...(input.layer ? { layer: input.layer } : {}),
+        ...(input.compute ? { compute: input.compute } : {}),
+        at,
+        ...(input.message ? { message: input.message } : {}),
+        ...(input.data !== undefined ? { data: toJsonValue(input.data) } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeResult(input) {
+    const startedAt = input.startedAt;
+    const finishedAt = input.finishedAt;
+    return {
+        jobId: input.jobId,
+        status: input.status ?? (input.exitCode === 0 || input.exitCode === undefined ? 'completed' : 'failed'),
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(finishedAt !== undefined ? { finishedAt } : {}),
+        ...(startedAt !== undefined && finishedAt !== undefined ? { durationMs: Math.max(0, finishedAt - startedAt) } : {}),
+        ...(input.exitCode !== undefined ? { exitCode: input.exitCode } : {}),
+        ...(input.signal ? { signal: input.signal } : {}),
+        changedPaths: uniqueStrings(input.changedPaths ?? []),
+        ownershipViolations: uniqueStrings(input.ownershipViolations ?? []),
+        evidencePaths: uniqueStrings(input.evidencePaths ?? []),
+        verification: (input.verification ?? []).map(normalizeVerificationResult),
+        ...(input.lastMessage ? { lastMessage: input.lastMessage } : {}),
+        ...(input.error !== undefined ? { error: stringifyError(input.error) } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeVerificationResult(input) {
+    return {
+        name: input.name ?? ((input.command ?? []).join(' ') || 'verification'),
+        command: [...(input.command ?? [])],
+        ...(input.status !== undefined ? { status: input.status } : {}),
+        ...(input.durationMs !== undefined ? { durationMs: input.durationMs } : {}),
+        stdoutTail: [...(input.stdoutTail ?? [])],
+        stderrTail: [...(input.stderrTail ?? [])],
+        required: input.required ?? true,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function summarizeJobs(jobs) {
+    return {
+        computeCount: new Set(jobs.map((job) => job.compute.id)).size,
+        layerCount: new Set(jobs.map((job) => job.layer).filter((layer) => !!layer)).size,
+        laneCount: new Set(jobs.map((job) => job.lane)).size,
+        taskCount: jobs.length,
+        jobCount: jobs.length,
+        ownershipViolationCount: jobs.reduce((total, job) => total + job.ownershipWarnings.length, 0)
+    };
+}
+function summarizeRun(jobs, results) {
+    const ownershipViolationCount = results.reduce((total, result) => total + result.ownershipViolations.length, 0);
+    return {
+        ...summarizeJobs(jobs),
+        completedCount: results.filter((result) => result.status === 'completed' || result.status === 'verified').length,
+        blockedCount: results.filter((result) => result.status === 'blocked').length,
+        failedCount: results.filter((result) => result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0).length,
+        ownershipViolationCount
+    };
+}
+function taskLayer(manifest, task) {
+    if (task.layer)
+        return task.layer;
+    const lane = task.lane ? manifest.lanes.find((entry) => entry.id === task.lane) : undefined;
+    return lane?.layer ?? manifest.policy.defaultLayer;
+}
+function searchableTask(task) {
+    return [
+        task.id,
+        task.title,
+        task.objective,
+        task.description,
+        task.workKind,
+        task.status,
+        task.lane,
+        task.layer,
+        task.compute,
+        ...task.sourceRefs,
+        ...task.targetRefs,
+        ...task.tags
+    ].filter(Boolean).join(' ').toLowerCase();
+}
+function addIssue(issues, code, severity, path, message) {
+    issues.push({ code, severity, path, message });
+}
+function hasLayerCycle(layerId, layers) {
+    const byId = new Map(layers.map((layer) => [layer.id, layer]));
+    const seen = new Set();
+    let cursor = layerId;
+    while (cursor) {
+        if (seen.has(cursor))
+            return true;
+        seen.add(cursor);
+        cursor = byId.get(cursor)?.parentId;
+    }
+    return false;
+}
+function isSwarmManifest(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_MANIFEST_KIND;
+}
+function isSwarmTask(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_TASK_KIND;
+}
+function normalizeId(value, label) {
+    const id = String(value || '').trim();
+    if (!id)
+        throw new Error(`Missing ${label}`);
+    return id;
+}
+function titleFromId(id) {
+    const parts = String(id).split(/[.:/_-]+/).filter(Boolean);
+    return parts.length ? parts.map((part) => part[0]?.toUpperCase() + part.slice(1)).join(' ') : String(id);
+}
+function slug(value) {
+    return String(value).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'item';
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.map((value) => String(value ?? '').trim()).filter(Boolean)));
+}
+function positiveNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+function toJsonObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return cloneJsonValue(value);
+}
+function toJsonValue(value) {
+    if (value === undefined)
+        return null;
+    return cloneJsonValue(value);
+}
+function cloneJsonValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function stringifyError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function stableHash(value) {
+    const text = stableStringify(value);
+    let hash = 2166136261;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return 'fnv1a32:' + (hash >>> 0).toString(16).padStart(8, '0');
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return '[' + value.map(stableStringify).join(',') + ']';
+    const object = value;
+    return '{' + Object.keys(object).sort().map((key) => JSON.stringify(key) + ':' + stableStringify(object[key])).join(',') + '}';
+}
+//# sourceMappingURL=index.js.map