@haaaiawd/second-nature 0.1.1 → 0.1.3

package/runtime/cli/read-models/index.js

@@ -0,0 +1,161 @@
+import { createQuietInputLoader } from "../../storage/services/quiet-input-loader.js";
+import { AssetRepository } from "../../storage/repositories/asset-repository.js";
+import { CredentialRepository } from "../../storage/repositories/credential-repository.js";
+import { EvidenceQueryEngine } from "../../observability/query/evidence-query-engine.js";
+import { executionAttempts } from "../../observability/db/schema/index.js";
+import { desc } from "drizzle-orm";
+function buildCredentialNextStep(status) {
+    if (status === "pending_verification")
+        return "submit_verification_answer";
+    if (status === "expired" || status === "revoked" || status === "failed")
+        return "refresh_credential_context";
+    return undefined;
+}
+export function createCliReadModels(deps) {
+    const assetRepository = new AssetRepository(deps.stateDb);
+    const credentialRepository = new CredentialRepository(deps.stateDb);
+    const quietLoader = createQuietInputLoader(assetRepository);
+    const evidenceQuery = new EvidenceQueryEngine(deps.observabilityDb);
+    return {
+        async loadStatus(_scope) {
+            let latestAttempt;
+            let credentials = [];
+            try {
+                latestAttempt = await deps.observabilityDb.db.query.executionAttempts.findFirst({
+                    orderBy: [desc(executionAttempts.startedAt)],
+                });
+            }
+            catch {
+                latestAttempt = undefined;
+            }
+            try {
+                credentials = await deps.stateDb.db.query.credentialRecords.findMany();
+            }
+            catch {
+                credentials = [];
+            }
+            const connectorSummary = latestAttempt
+                ? [{
+                        platformId: latestAttempt.platformId,
+                        status: latestAttempt.failureClass ? "degraded" : "healthy",
+                        channel: latestAttempt.channel,
+                        failureClass: latestAttempt.failureClass ?? undefined,
+                    }]
+                : [];
+            return {
+                runtime: {
+                    host: "openclaw-plugin",
+                    serviceStatus: latestAttempt ? (latestAttempt.failureClass ? "degraded" : "running") : "unknown",
+                    updatedAt: new Date().toISOString(),
+                },
+                rhythm: {
+                    mode: "unknown",
+                    windowId: undefined,
+                },
+                quiet: {
+                    mode: "unknown",
+                    lastEvent: undefined,
+                    interrupted: undefined,
+                },
+                connectors: connectorSummary,
+                credentials: credentials.map((item) => ({
+                    platformId: item.platformId,
+                    status: item.status,
+                    nextStep: buildCredentialNextStep(item.status),
+                })),
+                risk: {
+                    level: latestAttempt?.failureClass ? "medium" : "low",
+                    flags: latestAttempt?.failureClass ? [latestAttempt.failureClass] : [],
+                },
+            };
+        },
+        async loadDailyReport(day) {
+            let bundle;
+            try {
+                bundle = await quietLoader.loadQuietInputs({
+                    dateRange: { start: `${day}T00:00:00.000Z`, end: `${day}T23:59:59.999Z` },
+                    assetFilters: { includeJournal: false, includeReports: true, includeCurated: false },
+                });
+            }
+            catch {
+                bundle = { dailyReports: [], journalEntries: [], sourceCount: 0 };
+            }
+            const report = bundle.dailyReports[0];
+            return {
+                day,
+                summary: report?.summary ?? "",
+                highlights: report?.highlights ?? [],
+                sourceRefs: report?.sources ?? [],
+            };
+        },
+        async loadQuiet(scope) {
+            const now = new Date();
+            const start = new Date(now);
+            start.setDate(now.getDate() - 1);
+            let bundle;
+            try {
+                bundle = await quietLoader.loadQuietInputs({
+                    dateRange: { start: start.toISOString(), end: now.toISOString() },
+                });
+            }
+            catch {
+                bundle = { dailyReports: [], journalEntries: [], sourceCount: 0 };
+            }
+            return {
+                scope,
+                mode: bundle.sourceCount > 0 ? "quiet" : "unknown",
+                sourceCount: bundle.sourceCount,
+                reportCount: bundle.dailyReports.length,
+                recentJournalCount: bundle.journalEntries.length,
+            };
+        },
+        async loadSession(sessionId) {
+            const traceId = sessionId;
+            const bundle = await evidenceQuery.queryEvidence({ traceId });
+            return {
+                requestedSessionId: sessionId,
+                traceId,
+                decisionCount: bundle.decisions.length,
+                attemptCount: bundle.attempts.length,
+                governanceCount: bundle.governance.length,
+                keyFactors: bundle.explanation.keyFactors,
+                evidenceRefs: bundle.explanation.evidenceRefs,
+            };
+        },
+        async loadCredential(platformId) {
+            let record;
+            try {
+                record = await credentialRepository.findByPlatformId(platformId);
+            }
+            catch {
+                record = undefined;
+            }
+            if (!record) {
+                return {
+                    platformId,
+                    status: "missing",
+                    nextStep: "provide_credential_context",
+                };
+            }
+            return {
+                platformId: record.platformId,
+                status: record.status,
+                verificationDeadline: record.expiresAt ?? undefined,
+                attemptsRemaining: record.attemptsRemaining ?? undefined,
+                nextStep: buildCredentialNextStep(record.status),
+            };
+        },
+        async explain(subject) {
+            const query = subject.kind === "decision" || subject.kind === "platform-selection" || subject.kind === "outreach"
+                ? { decisionId: subject.id }
+                : { assetId: subject.id };
+            const bundle = await evidenceQuery.queryEvidence(query);
+            return {
+                subjectType: subject.kind,
+                conclusion: bundle.explanation.conclusion,
+                keyFactors: bundle.explanation.keyFactors,
+                evidenceRefs: bundle.explanation.evidenceRefs,
+            };
+        },
+    };
+}

package/runtime/cli/read-models/types.d.ts

@@ -0,0 +1,75 @@
+export interface RuntimeSummary {
+    host: "openclaw-plugin";
+    serviceStatus: "idle" | "running" | "degraded" | "unknown";
+    updatedAt: string;
+}
+export interface RhythmSummary {
+    mode: "active" | "quiet" | "maintenance_only" | "paused_for_interrupt" | "unknown";
+    windowId?: string;
+}
+export interface QuietSummary {
+    mode: "active" | "quiet" | "maintenance_only" | "paused_for_interrupt" | "unknown";
+    lastEvent?: string;
+    interrupted?: boolean;
+}
+export interface ConnectorSummary {
+    platformId: string;
+    status: "healthy" | "degraded" | "blocked" | "unknown";
+    channel?: string;
+    failureClass?: string;
+}
+export interface CredentialSummary {
+    platformId: string;
+    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed";
+    nextStep?: string;
+}
+export interface RiskSummary {
+    level: "low" | "medium" | "high";
+    flags: string[];
+}
+export interface StatusReadModel {
+    runtime: RuntimeSummary;
+    rhythm: RhythmSummary;
+    quiet: QuietSummary;
+    connectors: ConnectorSummary[];
+    credentials: CredentialSummary[];
+    risk: RiskSummary;
+}
+export interface DailyReportReadModel {
+    day: string;
+    summary: string;
+    highlights: string[];
+    sourceRefs: string[];
+}
+export interface QuietReadModel {
+    scope?: string;
+    mode: "active" | "quiet" | "maintenance_only" | "paused_for_interrupt" | "unknown";
+    sourceCount: number;
+    reportCount: number;
+    recentJournalCount: number;
+}
+export interface SessionDetailReadModel {
+    requestedSessionId: string;
+    traceId: string;
+    decisionCount: number;
+    attemptCount: number;
+    governanceCount: number;
+    keyFactors: string[];
+    evidenceRefs: string[];
+}
+export interface CredentialReadModel {
+    platformId: string;
+    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed";
+    verificationDeadline?: string;
+    attemptsRemaining?: number;
+    nextStep?: string;
+}
+export interface ExplainReadModel {
+    subjectType: "decision" | "platform-selection" | "outreach" | "soul-change";
+    conclusion: string;
+    keyFactors: string[];
+    evidenceRefs: string[];
+    policyRefs?: string[];
+    requiredUserInput?: string[];
+    nextStep?: string;
+}

package/runtime/cli/read-models/types.js

@@ -0,0 +1 @@
+export {};

package/runtime/connectors/agent-network/evomap/adapter.d.ts

@@ -0,0 +1,23 @@
+import type { ConnectorRequest, ExecutionPlan, RawAttempt } from "../../base/contract.js";
+export interface EvoMapApiClient {
+    heartbeat(payload: Record<string, unknown>, nodeSecret: string): Promise<unknown>;
+    claimTask(payload: Record<string, unknown>, nodeSecret: string): Promise<unknown>;
+}
+export interface EvoMapA2AClient {
+    helloOrRegister(payload: Record<string, unknown>): Promise<{
+        your_node_id: string;
+        node_secret: string;
+    }>;
+    discoverWork(payload: Record<string, unknown>, nodeSecret: string): Promise<unknown>;
+}
+export interface EvoMapSecretPort {
+    loadNodeSecret(platformId: string): Promise<string | null>;
+    saveNodeSecret(platformId: string, nodeSecret: string): Promise<void>;
+}
+export declare function createEvoMapRunner(input: {
+    apiClient: EvoMapApiClient;
+    a2aClient: EvoMapA2AClient;
+    secretPort: EvoMapSecretPort;
+}): {
+    run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
+};

package/runtime/connectors/agent-network/evomap/adapter.js

@@ -0,0 +1,69 @@
+export function createEvoMapRunner(input) {
+    const { apiClient, a2aClient, secretPort } = input;
+    return {
+        async run(plan, request) {
+            const started = Date.now();
+            try {
+                const payload = await executeEvoMap(plan, request, apiClient, a2aClient, secretPort);
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill",
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: plan.channel,
+                        data: payload,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill",
+                    success: false,
+                    error,
+                };
+            }
+        },
+    };
+}
+async function executeEvoMap(plan, request, apiClient, a2aClient, secretPort) {
+    if (plan.channel !== "api_rest" && plan.channel !== "a2a") {
+        throw { code: "protocol_mismatch", detail: `unsupported evomap channel: ${plan.channel}` };
+    }
+    if (plan.intent === "agent.register") {
+        if (plan.channel !== "a2a") {
+            throw { code: "protocol_mismatch", detail: "evomap register requires a2a envelope channel" };
+        }
+        const registration = await a2aClient.helloOrRegister(request.payload);
+        await secretPort.saveNodeSecret(request.platformId, registration.node_secret);
+        return registration;
+    }
+    const nodeSecret = await secretPort.loadNodeSecret(request.platformId);
+    if (!nodeSecret) {
+        throw { code: "verification_required", detail: "node_secret_required" };
+    }
+    if (plan.intent === "agent.heartbeat") {
+        if (plan.channel !== "api_rest") {
+            throw { code: "protocol_mismatch", detail: "evomap heartbeat requires api_rest channel" };
+        }
+        return apiClient.heartbeat(request.payload, nodeSecret);
+    }
+    if (plan.intent === "work.discover") {
+        if (plan.channel !== "a2a") {
+            throw { code: "protocol_mismatch", detail: "evomap work.discover requires a2a envelope channel" };
+        }
+        return a2aClient.discoverWork(request.payload, nodeSecret);
+    }
+    if (plan.intent === "task.claim") {
+        if (plan.channel !== "api_rest") {
+            throw { code: "protocol_mismatch", detail: "evomap task.claim requires api_rest channel" };
+        }
+        return apiClient.claimTask(request.payload, nodeSecret);
+    }
+    throw { code: "protocol_mismatch", detail: `unsupported evomap intent: ${plan.intent}` };
+}

package/runtime/connectors/agent-network/evomap/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./manifest.js";
+export * from "./adapter.js";

package/runtime/connectors/agent-network/evomap/index.js

@@ -0,0 +1,2 @@
+export * from "./manifest.js";
+export * from "./adapter.js";

package/runtime/connectors/agent-network/evomap/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectorManifest } from "../../base/manifest.js";
+export declare const evomapManifest: ConnectorManifest;

package/runtime/connectors/agent-network/evomap/manifest.js

@@ -0,0 +1,7 @@
+export const evomapManifest = {
+    platformId: "evomap",
+    supportedCapabilities: ["agent.register", "agent.heartbeat", "work.discover", "task.claim"],
+    channelPriority: ["api_rest", "a2a", "skill"],
+    credentialTypes: ["node_secret", "api_key"],
+    degradedChannels: ["skill"],
+};

package/runtime/connectors/base/channel-health.d.ts

@@ -0,0 +1,29 @@
+import type { CapabilityIntent, ChannelType } from "./contract.js";
+export interface ChannelHealthSnapshot {
+    platformId: string;
+    channel: ChannelType;
+    healthy: boolean;
+    degraded: boolean;
+    lastFailureAt?: string;
+    failureClass?: string;
+    retryAfterMs?: number;
+    updatedAt: string;
+}
+export interface AttemptContext {
+    traceId: string;
+    platformId: string;
+    intent: CapabilityIntent;
+    channel: ChannelType;
+    startedAt: string;
+    idempotencyKey?: string;
+}
+export declare class ChannelHealthStore {
+    private readonly byKey;
+    private readonly attempts;
+    upsert(snapshot: ChannelHealthSnapshot): void;
+    get(platformId: string, channel: ChannelType): ChannelHealthSnapshot | undefined;
+    markAttempt(context: AttemptContext): void;
+    getAttempt(traceId: string): AttemptContext | undefined;
+    clearAttempt(traceId: string): void;
+    private key;
+}

package/runtime/connectors/base/channel-health.js

@@ -0,0 +1,23 @@
+export class ChannelHealthStore {
+    byKey = new Map();
+    attempts = new Map();
+    upsert(snapshot) {
+        const key = this.key(snapshot.platformId, snapshot.channel);
+        this.byKey.set(key, snapshot);
+    }
+    get(platformId, channel) {
+        return this.byKey.get(this.key(platformId, channel));
+    }
+    markAttempt(context) {
+        this.attempts.set(context.traceId, context);
+    }
+    getAttempt(traceId) {
+        return this.attempts.get(traceId);
+    }
+    clearAttempt(traceId) {
+        this.attempts.delete(traceId);
+    }
+    key(platformId, channel) {
+        return `${platformId}::${channel}`;
+    }
+}

package/runtime/connectors/base/contract.d.ts

@@ -0,0 +1,81 @@
+import type { CredentialContext, CredentialState } from "../../shared/types/credential.js";
+import { type FailureClass } from "./failure-taxonomy.js";
+export declare const CHANNEL_TYPES: readonly ["api_rest", "api_rpc", "a2a", "mcp", "cli", "skill", "browser"];
+export type ChannelType = (typeof CHANNEL_TYPES)[number];
+export declare const CAPABILITY_INTENTS: readonly ["feed.read", "post.publish", "comment.reply", "notification.list", "message.send", "agent.register", "agent.heartbeat", "work.discover", "task.claim"];
+export type CapabilityIntent = (typeof CAPABILITY_INTENTS)[number];
+export interface ConnectorRequest {
+    platformId: string;
+    intent: CapabilityIntent;
+    payload: Record<string, unknown>;
+    preferredChannel?: ChannelType;
+    timeoutMs?: number;
+    idempotencyKey?: string;
+    decisionId?: string;
+    intentId?: string;
+}
+export interface ExecutionPlan {
+    platformId: string;
+    intent: CapabilityIntent;
+    channel: ChannelType;
+    endpointMode: "rest_json" | "a2a_envelope" | "cli_stdout" | "skill_call";
+    idempotencyKey?: string;
+}
+export interface ConnectorResult<T> {
+    status: "success" | "retryable_failure" | "terminal_failure";
+    data?: T;
+    failureClass?: FailureClass;
+    retryAfterMs?: number;
+    metadata: {
+        platformId: string;
+        channel: ChannelType;
+        latencyMs: number;
+        degraded?: boolean;
+    };
+}
+export interface RawAttempt {
+    platformId: string;
+    channel: ChannelType;
+    latencyMs: number;
+    degraded?: boolean;
+    success: boolean;
+    payload?: unknown;
+    error?: unknown;
+}
+export interface CredentialContextPort {
+    loadCredentialState(platformId: string): Promise<CredentialContext>;
+}
+export interface CooldownLedgerPort {
+    loadCooldownState(platformId: string, intent: CapabilityIntent): Promise<{
+        blocked: boolean;
+        retryAfterMs?: number;
+    }>;
+}
+export interface RouteContextPort extends CredentialContextPort, CooldownLedgerPort {
+}
+export interface ConnectorManifestLike {
+    platformId: string;
+    supportedCapabilities: CapabilityIntent[];
+    channelPriority: ChannelType[];
+    credentialTypes: string[];
+    degradedChannels?: ChannelType[];
+}
+export interface ConnectorManifestLoader {
+    loadManifest(platformId: string): ConnectorManifestLike;
+}
+export interface RoutePlanner {
+    planRoute(intent: CapabilityIntent, request: ConnectorRequest): Promise<ExecutionPlan>;
+}
+export interface ExecutionRunner {
+    run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
+}
+export interface ConnectorExecutionPort {
+    executeCapability(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;
+}
+export declare function normalizeOutcome(attempt: RawAttempt): ConnectorResult<unknown>;
+export declare function createConnectorContractCore(input: {
+    manifestLoader: ConnectorManifestLoader;
+    routePlanner: RoutePlanner;
+    executionRunner: ExecutionRunner;
+}): ConnectorExecutionPort;
+export declare function isCredentialActive(state: CredentialState): boolean;

package/runtime/connectors/base/contract.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { classifyFailure, ConnectorPolicyError } from "./failure-taxonomy.js";
+export const CHANNEL_TYPES = ["api_rest", "api_rpc", "a2a", "mcp", "cli", "skill", "browser"];
+export const CAPABILITY_INTENTS = [
+    "feed.read",
+    "post.publish",
+    "comment.reply",
+    "notification.list",
+    "message.send",
+    "agent.register",
+    "agent.heartbeat",
+    "work.discover",
+    "task.claim",
+];
+const connectorRequestSchema = z.object({
+    platformId: z.string().min(1),
+    intent: z.enum(CAPABILITY_INTENTS),
+    payload: z.record(z.string(), z.unknown()),
+    preferredChannel: z.enum(CHANNEL_TYPES).optional(),
+    timeoutMs: z.number().int().positive().optional(),
+    idempotencyKey: z.string().min(1).optional(),
+    decisionId: z.string().min(1).optional(),
+    intentId: z.string().min(1).optional(),
+});
+export function normalizeOutcome(attempt) {
+    if (attempt.success) {
+        return {
+            status: "success",
+            data: attempt.payload,
+            metadata: {
+                platformId: attempt.platformId,
+                channel: attempt.channel,
+                latencyMs: attempt.latencyMs,
+                degraded: attempt.degraded,
+            },
+        };
+    }
+    const failure = classifyFailure(attempt.error);
+    return {
+        status: failure.retryable ? "retryable_failure" : "terminal_failure",
+        failureClass: failure.class,
+        retryAfterMs: failure.retryAfterMs,
+        metadata: {
+            platformId: attempt.platformId,
+            channel: attempt.channel,
+            latencyMs: attempt.latencyMs,
+            degraded: attempt.degraded,
+        },
+    };
+}
+export function createConnectorContractCore(input) {
+    const { manifestLoader, routePlanner, executionRunner } = input;
+    return {
+        async executeCapability(intent, request) {
+            connectorRequestSchema.parse(request);
+            if (intent !== request.intent) {
+                throw new Error("connector_intent_mismatch");
+            }
+            const manifest = manifestLoader.loadManifest(request.platformId);
+            if (!manifest.supportedCapabilities.includes(intent)) {
+                throw new ConnectorPolicyError("protocol_mismatch", "capability_not_supported_by_manifest");
+            }
+            const plan = await routePlanner.planRoute(intent, request);
+            const attempt = await executionRunner.run(plan, request);
+            return normalizeOutcome(attempt);
+        },
+    };
+}
+export function isCredentialActive(state) {
+    return state === "active";
+}

package/runtime/connectors/base/failure-taxonomy.d.ts

@@ -0,0 +1,13 @@
+export declare const FAILURE_CLASSES: readonly ["transport_failure", "auth_failure", "credential_expired", "verification_required", "rate_limited", "cooldown_blocked", "parse_failure", "protocol_mismatch", "semantic_rejection", "idempotency_conflict", "concurrency_conflict", "permanent_input_error", "unknown_platform_change"];
+export type FailureClass = (typeof FAILURE_CLASSES)[number];
+export interface FailureClassification {
+    class: FailureClass;
+    retryable: boolean;
+    retryAfterMs?: number;
+}
+export declare class ConnectorPolicyError extends Error {
+    readonly failureClass: FailureClass;
+    readonly retryAfterMs?: number | undefined;
+    constructor(failureClass: FailureClass, message: string, retryAfterMs?: number | undefined);
+}
+export declare function classifyFailure(error: unknown): FailureClassification;