sdd-agent-platform 0.3.0 → 0.4.1

package/packages/core/dist/storage/json-io.d.ts

@@ -0,0 +1 @@
+export declare function exists(filePath: string): Promise<boolean>;

package/packages/core/dist/storage/json-io.js

@@ -0,0 +1,11 @@
+import { stat } from 'node:fs/promises';
+export async function exists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=json-io.js.map

package/packages/core/dist/storage/json-io.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-io.js","sourceRoot":"","sources":["../../src/storage/json-io.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,QAAgB;IAC3C,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC"}

package/packages/core/dist/storage/runtime-store.d.ts

@@ -0,0 +1,305 @@
+import type { InvocationLedgerEntry, RuntimeEvent, RunState } from '../run-state/model.js';
+import { type RuntimeProjectionEnvelope, type RuntimeProjectionStaleness } from '../contracts.js';
+import type { AgentExecutionRecord, TeamSessionRecord } from '../router/agent-runtime.js';
+import type { ResidentWorkerRuntimeRecord } from '../execution/resident-worker.js';
+import { type FanInEvidenceSetRecord, type LlmAdvisorAssessmentRecord, type StageRoleResultRecord, type StageTeamSessionRecord } from '../execution/stage-team-runtime.js';
+import type { WorkflowGateDecision, WorkflowGateDecisionKind } from '../workflow-gate/types.js';
+export declare const RUNTIME_STORE_SCHEMA_VERSION = 6;
+export declare const RUNTIME_STORE_CONTRACT_VERSION = "phase-8.17-validation-wave-runtime-v6";
+export type RuntimeStoreIssueCode = 'STORE_UNAVAILABLE' | 'SCHEMA_MISMATCH' | 'LEGACY_IMPORT_FAILED';
+export type RuntimeStoreDatabase = {
+    exec(sql: string): unknown;
+    prepare(sql: string): {
+        run: (...params: unknown[]) => unknown;
+        get: (...params: unknown[]) => unknown;
+        all: (...params: unknown[]) => unknown[];
+    };
+    close: () => void;
+};
+export type RuntimeStoreConstructor = new (filename: string) => RuntimeStoreDatabase;
+export interface RuntimeStoreHandle {
+    path: string;
+    db: RuntimeStoreDatabase;
+}
+export declare class RuntimeStoreError extends Error {
+    readonly code: RuntimeStoreIssueCode;
+    constructor(code: RuntimeStoreIssueCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface RuntimeStoreDoctorCheck {
+    level: 'PASS' | 'WARN' | 'FAIL';
+    check: string;
+    message: string;
+    action?: string;
+}
+export type RuntimeArtifactPayloadStatus = 'active' | 'candidate' | 'rejected' | 'superseded';
+export interface RuntimeArtifactPayloadRecord {
+    payloadId: string;
+    runId: string;
+    sourceRunId: string;
+    branchSlug: string;
+    taskId: string | null;
+    logicalRef: string;
+    physicalPayloadPath: string;
+    artifactRole: string;
+    digest: string;
+    sequence: number;
+    status: RuntimeArtifactPayloadStatus;
+    supersedes: string | null;
+    createdAt: string;
+    payload: unknown;
+}
+export interface RuntimeSyncBackDecisionRecord {
+    decisionId: string;
+    runId: string;
+    branch: string;
+    taskId: string | null;
+    status: string;
+    proposalPath: string | null;
+    proposalDigest: string | null;
+    proposalPayloadId: string | null;
+    reasons: string[];
+    createdAt: string;
+    updatedAt: string;
+    payload: unknown;
+}
+export type RuntimeDurableGapSeverity = 'info' | 'warning' | 'blocking';
+export type RuntimeDurableGapStatus = 'open' | 'acknowledged' | 'resolved' | 'waived' | 'superseded';
+export type RuntimeDurableGapSource = 'runtime' | 'gate_policy' | 'doctor' | 'validator' | 'agent' | 'team' | 'llm_advisor' | 'import';
+export interface RuntimeDurableGapRecord {
+    gapId: string;
+    partition: string;
+    taskId: string | null;
+    runId: string | null;
+    stage: string | null;
+    gate: string | null;
+    source: RuntimeDurableGapSource;
+    category: string;
+    severity: RuntimeDurableGapSeverity;
+    status: RuntimeDurableGapStatus;
+    message: string;
+    recommendation: string | null;
+    evidenceRefs: string[];
+    proposalRefs: string[];
+    sourceRefs: string[];
+    createdAt: string;
+    updatedAt: string;
+    closedAt: string | null;
+    payload: unknown;
+}
+export type RuntimeValidationWaveStatus = 'RUNNING' | 'PASS' | 'FAIL' | 'BLOCKED';
+export type RuntimeValidationEnvironmentStatus = 'active' | 'completed' | 'failed' | 'blocked';
+export interface RuntimeValidationEnvironmentSessionRecord {
+    sessionId: string;
+    partition: string;
+    runId: string | null;
+    waveRunId: string | null;
+    status: RuntimeValidationEnvironmentStatus;
+    reuseKey: string;
+    createdAt: string;
+    updatedAt: string;
+    payload: unknown;
+}
+export interface RuntimeValidationWaveRunRecord {
+    waveRunId: string;
+    partition: string;
+    runId: string | null;
+    taskIds: string[];
+    status: RuntimeValidationWaveStatus;
+    environmentSessionId: string;
+    startedAt: string;
+    completedAt: string;
+    payload: unknown;
+}
+export interface RuntimeAcceptanceEvidenceMapRecord {
+    mapId: string;
+    waveRunId: string;
+    testRunId: string;
+    partition: string;
+    runId: string;
+    taskId: string;
+    acceptanceRef: string;
+    status: string;
+    evidenceRefs: string[];
+    gaps: string[];
+    createdAt: string;
+    payload: unknown;
+}
+export declare function withRuntimeStore<T>(projectRoot: string, fn: (store: RuntimeStoreHandle) => T | Promise<T>): Promise<T>;
+export declare function recordRuntimeEvent(projectRoot: string, event: RuntimeEvent, source?: string): Promise<void>;
+export declare function importLegacyRunEventsIfNeeded(projectRoot: string, runId: string, eventPath: string): Promise<void>;
+export declare function readRuntimeRunEvents(projectRoot: string, runId: string): Promise<RuntimeEvent[]>;
+export declare function upsertRuntimeRunState(projectRoot: string, state: RunState, serializedState: string): Promise<void>;
+export declare function readRuntimeRunState(projectRoot: string, runId: string): Promise<RunState | null>;
+export declare function listRuntimeRunStates(projectRoot: string): Promise<RunState[]>;
+export declare function recordRuntimeAgentExecution(projectRoot: string, record: AgentExecutionRecord): Promise<void>;
+export declare function listRuntimeAgentExecutions(projectRoot: string, runId: string): Promise<AgentExecutionRecord[]>;
+export declare function recordRuntimeTeamSession(projectRoot: string, record: TeamSessionRecord): Promise<void>;
+export declare function listRuntimeTeamSessions(projectRoot: string, runId: string): Promise<TeamSessionRecord[]>;
+export declare function recordRuntimeStageTeamSession(projectRoot: string, record: StageTeamSessionRecord): Promise<void>;
+export declare function listRuntimeStageTeamSessions(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    taskId?: string | null;
+}): Promise<StageTeamSessionRecord[]>;
+export declare function recordRuntimeStageRoleResult(projectRoot: string, record: StageRoleResultRecord): Promise<void>;
+export declare function listRuntimeStageRoleResults(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    taskId?: string | null;
+    sessionId?: string | null;
+}): Promise<StageRoleResultRecord[]>;
+export declare function recordRuntimeLlmAdvisorAssessment(projectRoot: string, record: LlmAdvisorAssessmentRecord): Promise<void>;
+export declare function listRuntimeLlmAdvisorAssessments(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    taskId?: string | null;
+    sessionId?: string | null;
+}): Promise<LlmAdvisorAssessmentRecord[]>;
+export declare function recordRuntimeFanInEvidenceSet(projectRoot: string, record: FanInEvidenceSetRecord): Promise<void>;
+export declare function listRuntimeFanInEvidenceSets(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    taskId?: string | null;
+}): Promise<FanInEvidenceSetRecord[]>;
+export declare function recordRuntimeWorkflowGateDecision(projectRoot: string, decision: WorkflowGateDecision): Promise<void>;
+export declare function listRuntimeWorkflowGateDecisions(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    taskId?: string | null;
+    decisionKind?: WorkflowGateDecisionKind | null;
+}): Promise<WorkflowGateDecision[]>;
+export declare function recordRuntimeWorkerRuntime(projectRoot: string, record: ResidentWorkerRuntimeRecord): Promise<void>;
+export declare function readRuntimeWorkerRuntime(projectRoot: string, runId: string, runtimeId: string): Promise<ResidentWorkerRuntimeRecord | null>;
+export declare function listRuntimeWorkerRuntimes(projectRoot: string, runId: string): Promise<ResidentWorkerRuntimeRecord[]>;
+export declare function recordRuntimeActivity(projectRoot: string, entry: InvocationLedgerEntry): Promise<void>;
+export declare function readRuntimeActivities(projectRoot: string, runId: string): Promise<InvocationLedgerEntry[]>;
+export declare function recordRuntimeEvidenceAttachment(projectRoot: string, input: {
+    branchSlug: string;
+    runId?: string | null;
+    taskId?: string | null;
+    kind: string;
+    relativePath: string;
+    contentHash: string;
+    bytes: number;
+    payload?: unknown;
+}): Promise<void>;
+export declare function recordRuntimeArtifactPayload(projectRoot: string, input: Omit<RuntimeArtifactPayloadRecord, 'sequence' | 'supersedes' | 'createdAt'> & {
+    sequence?: number;
+    supersedes?: string | null;
+    createdAt?: string;
+}): Promise<RuntimeArtifactPayloadRecord>;
+export declare function resolveRuntimeArtifactPayload(projectRoot: string, runId: string, logicalRef: string): Promise<RuntimeArtifactPayloadRecord | null>;
+export declare function listRuntimeArtifactPayloads(projectRoot: string, input?: {
+    runId?: string | null;
+    branchSlug?: string | null;
+    taskId?: string | null;
+    logicalRef?: string | null;
+    status?: RuntimeArtifactPayloadStatus | null;
+}): Promise<RuntimeArtifactPayloadRecord[]>;
+export declare function recordRuntimeSyncBackDecision(projectRoot: string, record: RuntimeSyncBackDecisionRecord): Promise<void>;
+export declare function readRuntimeSyncBackDecision(projectRoot: string, runId: string, taskId?: string | null): Promise<RuntimeSyncBackDecisionRecord | null>;
+export declare function listRuntimeSyncBackDecisions(projectRoot: string, runId: string): Promise<RuntimeSyncBackDecisionRecord[]>;
+export declare function recordRuntimeDurableGap(projectRoot: string, input: Omit<RuntimeDurableGapRecord, 'createdAt' | 'updatedAt' | 'closedAt'> & {
+    createdAt?: string;
+    updatedAt?: string;
+    closedAt?: string | null;
+}): Promise<RuntimeDurableGapRecord>;
+export declare function updateRuntimeDurableGapStatus(projectRoot: string, input: {
+    gapId: string;
+    status: RuntimeDurableGapStatus;
+    source: RuntimeDurableGapSource;
+    payload?: unknown;
+    updatedAt?: string;
+}): Promise<RuntimeDurableGapRecord | null>;
+export declare function listRuntimeDurableGaps(projectRoot: string, input?: {
+    partition?: string | null;
+    taskId?: string | null;
+    runId?: string | null;
+    status?: RuntimeDurableGapStatus | 'open_terminal' | null;
+    severity?: RuntimeDurableGapSeverity | null;
+}): Promise<RuntimeDurableGapRecord[]>;
+export declare function recordRuntimeProjection(projectRoot: string, projectionType: string, scopeKey: string, payload: unknown): Promise<void>;
+export type RuntimeProjectionEnvelopeWriteStatus = 'created' | 'updated' | 'unchanged';
+export interface RuntimeProjectionEnvelopeInput<TPayload> {
+    projectionType: string;
+    scopeKey: string;
+    inputHash: string;
+    producer: string;
+    producerVersion: string;
+    payload: TPayload;
+    generatedAt?: string;
+}
+export interface RuntimeProjectionEnvelopeWriteResult<TPayload> {
+    envelope: RuntimeProjectionEnvelope<TPayload>;
+    previous: RuntimeProjectionRecord | null;
+    staleness: RuntimeProjectionStaleness;
+    status: RuntimeProjectionEnvelopeWriteStatus;
+}
+export interface RuntimeProjectionFreshnessInput {
+    inputHash: string;
+    producerVersion: string;
+}
+export declare function buildRuntimeProjectionEnvelope<TPayload>(input: RuntimeProjectionEnvelopeInput<TPayload>): RuntimeProjectionEnvelope<TPayload>;
+export declare function recordRuntimeProjectionEnvelope<TPayload>(projectRoot: string, input: RuntimeProjectionEnvelopeInput<TPayload>): Promise<RuntimeProjectionEnvelopeWriteResult<TPayload>>;
+export interface RuntimeProjectionRecord {
+    projectionType: string;
+    scopeKey: string;
+    generatedAt: string;
+    payload: unknown;
+}
+export declare function readRuntimeProjection(projectRoot: string, projectionType: string, scopeKey: string): Promise<RuntimeProjectionRecord | null>;
+export declare function readRuntimeProjectionEnvelope<TPayload>(projectRoot: string, projectionType: string, scopeKey: string): Promise<RuntimeProjectionEnvelope<TPayload> | null>;
+export declare function runtimeProjectionStaleness(envelope: RuntimeProjectionEnvelope<unknown> | null, freshness: RuntimeProjectionFreshnessInput): RuntimeProjectionStaleness;
+export declare function listRuntimeProjections(projectRoot: string, projectionTypes: string[]): Promise<RuntimeProjectionRecord[]>;
+export interface RuntimeTestRunRecord {
+    testRunId: string;
+    runId: string;
+    partition: string | null;
+    taskId: string;
+    status: string;
+    startedAt: string;
+    completedAt: string;
+    payload: unknown;
+}
+export interface RuntimeTestStepRecord {
+    stepId: string;
+    testRunId: string;
+    runId: string;
+    taskId: string;
+    command: string;
+    status: string;
+    exitCode: number | null;
+    durationMs: number;
+    outputArtifact: string;
+    payload: unknown;
+}
+export declare function recordRuntimeTestRun(projectRoot: string, record: RuntimeTestRunRecord): Promise<void>;
+export declare function recordRuntimeTestStep(projectRoot: string, record: RuntimeTestStepRecord): Promise<void>;
+export declare function listRuntimeTestRuns(projectRoot: string, runId?: string | null): Promise<RuntimeTestRunRecord[]>;
+export declare function recordRuntimeValidationEnvironmentSession(projectRoot: string, record: RuntimeValidationEnvironmentSessionRecord): Promise<void>;
+export declare function listRuntimeValidationEnvironmentSessions(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    waveRunId?: string | null;
+}): Promise<RuntimeValidationEnvironmentSessionRecord[]>;
+export declare function recordRuntimeValidationWaveRun(projectRoot: string, record: RuntimeValidationWaveRunRecord): Promise<void>;
+export declare function listRuntimeValidationWaveRuns(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    taskId?: string | null;
+    waveRunId?: string | null;
+}): Promise<RuntimeValidationWaveRunRecord[]>;
+export declare function recordRuntimeAcceptanceEvidenceMap(projectRoot: string, record: RuntimeAcceptanceEvidenceMapRecord): Promise<void>;
+export declare function listRuntimeAcceptanceEvidenceMaps(projectRoot: string, input?: {
+    partition?: string | null;
+    runId?: string | null;
+    taskId?: string | null;
+    waveRunId?: string | null;
+    testRunId?: string | null;
+}): Promise<RuntimeAcceptanceEvidenceMapRecord[]>;
+export declare function recordLegacyImportFailure(projectRoot: string, runId: string, entityType: string, error: unknown): Promise<void>;
+export declare function inspectRuntimeStoreEvidence(projectRoot: string): Promise<RuntimeStoreDoctorCheck[]>;
+export declare function runtimeScopedId(...parts: string[]): string;
+export declare function legacyImportId(runId: string, entityType: string): string;