@haaaiawd/second-nature 0.1.1 → 0.1.3

package/runtime/storage/memory/workspace/paths.d.ts

@@ -0,0 +1,62 @@
+export declare const ASSET_CONFIG: {
+    readonly workspaceRoot: "./workspace";
+    readonly journalsDir: "memory";
+    readonly reportsDir: "memory/reports";
+    readonly curatedDir: "memory/curated";
+    readonly proposalsDir: "memory/proposals";
+    readonly anchorAssets: readonly ["SOUL.md", "USER.md", "IDENTITY.md", "MEMORY.md", "AGENTS.md"];
+};
+export declare function ensureDirectory(dirPath: string): Promise<void>;
+export declare function resolveDailyJournalPath(timestamp: string): string;
+export declare function resolveDailyReportPath(day: string): string;
+export declare function resolveCuratedPath(id: string): string;
+export declare function resolveProposalPath(proposalId: string): string;
+export declare function resolveAnchorPath(assetName: string): string;
+export declare function writeCanonicalArtifact(filePath: string, content: string): Promise<void>;
+export declare function appendLine(filePath: string, line: string): Promise<void>;
+export declare function readText(filePath: string): Promise<string>;
+export declare function hashFile(filePath: string): Promise<string>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function buildJournalAssetId(filePath: string): string;
+export declare function buildReportAssetId(day: string): string;
+export declare function serializeActivityLog(entry: {
+    id: string;
+    timestamp: string;
+    platform?: string;
+    kind: string;
+    content: string;
+    sourceRefs: string[];
+}): string;
+export declare function serializeObservation(entry: {
+    id: string;
+    timestamp: string;
+    summary: string;
+    mood?: string;
+    sourceRefs: string[];
+}): string;
+export declare function renderDailyReport(input: {
+    day: string;
+    summary: string;
+    highlights: string[];
+    activityRefs: string[];
+    observationRefs: string[];
+}): string;
+export declare function renderCuratedMemory(item: {
+    id: string;
+    title: string;
+    summary: string;
+    confidence: number;
+    ttlClass: string;
+    sourceRefs: string[];
+}): string;
+export declare function renderProposal(proposal: {
+    id: string;
+    targetAssetId: string;
+    proposedDiff: string;
+    reason: string;
+    supportingSources: string[];
+    status: string;
+}): string;
+export declare function applyDiff(original: string, diff: string): string;
+export declare function buildCuratedAssetId(id: string): string;
+export declare function buildAnchorAssetId(name: string): string;

package/runtime/storage/memory/workspace/paths.js

@@ -0,0 +1,160 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as crypto from "crypto";
+export const ASSET_CONFIG = {
+    workspaceRoot: "./workspace",
+    journalsDir: "memory",
+    reportsDir: "memory/reports",
+    curatedDir: "memory/curated",
+    proposalsDir: "memory/proposals",
+    anchorAssets: ["SOUL.md", "USER.md", "IDENTITY.md", "MEMORY.md", "AGENTS.md"],
+};
+export async function ensureDirectory(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+export function resolveDailyJournalPath(timestamp) {
+    const date = timestamp.split("T")[0];
+    return path.join(ASSET_CONFIG.workspaceRoot, ASSET_CONFIG.journalsDir, `${date}.md`);
+}
+export function resolveDailyReportPath(day) {
+    return path.join(ASSET_CONFIG.workspaceRoot, ASSET_CONFIG.reportsDir, `${day}.md`);
+}
+export function resolveCuratedPath(id) {
+    return path.join(ASSET_CONFIG.workspaceRoot, ASSET_CONFIG.curatedDir, `${id}.md`);
+}
+export function resolveProposalPath(proposalId) {
+    return path.join(ASSET_CONFIG.workspaceRoot, ASSET_CONFIG.proposalsDir, `${proposalId}.md`);
+}
+export function resolveAnchorPath(assetName) {
+    return path.join(ASSET_CONFIG.workspaceRoot, assetName);
+}
+export async function writeCanonicalArtifact(filePath, content) {
+    await ensureDirectory(path.dirname(filePath));
+    const tempPath = `${filePath}.tmp`;
+    await fs.writeFile(tempPath, content, "utf-8");
+    await fs.rename(tempPath, filePath);
+}
+export async function appendLine(filePath, line) {
+    await ensureDirectory(path.dirname(filePath));
+    const exists = await fileExists(filePath);
+    const prefix = exists ? "\n" : "";
+    await fs.appendFile(filePath, `${prefix}${line}`, "utf-8");
+}
+export async function readText(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+export async function hashFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath);
+        return crypto.createHash("sha256").update(content).digest("hex");
+    }
+    catch {
+        return "";
+    }
+}
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function buildJournalAssetId(filePath) {
+    return `journal:${path.basename(filePath, ".md")}`;
+}
+export function buildReportAssetId(day) {
+    return `report:${day}`;
+}
+export function serializeActivityLog(entry) {
+    const meta = entry.platform ? `[${entry.platform}] ` : "";
+    const sources = entry.sourceRefs.length > 0 ? ` (refs: ${entry.sourceRefs.join(", ")})` : "";
+    return `- [${entry.timestamp}] ${meta}${entry.kind}: ${entry.content}${sources}`;
+}
+export function serializeObservation(entry) {
+    const mood = entry.mood ? ` (${entry.mood})` : "";
+    const sources = entry.sourceRefs.length > 0 ? ` [${entry.sourceRefs.join(", ")}]` : "";
+    return `- [${entry.timestamp}] ${entry.summary}${mood}${sources}`;
+}
+export function renderDailyReport(input) {
+    const lines = [
+        `# Daily Report — ${input.day}`,
+        "",
+        "## Summary",
+        input.summary,
+        "",
+        "## Highlights",
+    ];
+    for (const h of input.highlights) {
+        lines.push(`- ${h}`);
+    }
+    lines.push("");
+    lines.push("## Sources");
+    lines.push(`- Activities: ${input.activityRefs.join(", ")}`);
+    lines.push(`- Observations: ${input.observationRefs.join(", ")}`);
+    return lines.join("\n");
+}
+export function renderCuratedMemory(item) {
+    const lines = [
+        `# ${item.title}`,
+        "",
+        item.summary,
+        "",
+        `**Confidence**: ${item.confidence.toFixed(2)} | **TTL**: ${item.ttlClass}`,
+        "",
+        "## Sources",
+    ];
+    for (const ref of item.sourceRefs) {
+        lines.push(`- ${ref}`);
+    }
+    return lines.join("\n");
+}
+export function renderProposal(proposal) {
+    const lines = [
+        `# Anchor Proposal — ${proposal.id}`,
+        "",
+        `**Target**: ${proposal.targetAssetId}`,
+        `**Status**: ${proposal.status}`,
+        "",
+        "## Reason",
+        proposal.reason,
+        "",
+        "## Diff",
+        "```diff",
+        proposal.proposedDiff,
+        "```",
+        "",
+        "## Supporting Sources",
+    ];
+    for (const src of proposal.supportingSources) {
+        lines.push(`- ${src}`);
+    }
+    return lines.join("\n");
+}
+export function applyDiff(original, diff) {
+    const lines = original.split("\n");
+    const diffLines = diff.split("\n").filter((l) => l.startsWith("+") || l.startsWith("-")).map((l) => l.substring(1));
+    for (const d of diffLines) {
+        if (d.startsWith("+")) {
+            lines.push(d.substring(1));
+        }
+        else if (d.startsWith("-")) {
+            const idx = lines.indexOf(d.substring(1));
+            if (idx !== -1)
+                lines.splice(idx, 1);
+        }
+    }
+    return lines.join("\n");
+}
+export function buildCuratedAssetId(id) {
+    return `curated:${id}`;
+}
+export function buildAnchorAssetId(name) {
+    return `anchor:${name}`;
+}

package/runtime/storage/memory/workspace/store.d.ts

@@ -0,0 +1,26 @@
+import type { ActivityLogWrite, ObservationWrite, DailyReportInput, CuratedMemoryWrite, AnchorWriteProposal } from "./types.js";
+import type { StateDatabase } from "../../db/index.js";
+export interface WorkspaceArtifactStore {
+    appendActivityLog(entry: ActivityLogWrite): Promise<{
+        assetPath: string;
+        hash: string;
+    }>;
+    appendObservation(entry: ObservationWrite): Promise<{
+        assetPath: string;
+        hash: string;
+    }>;
+    generateDailyReport(input: DailyReportInput): Promise<{
+        assetPath: string;
+        hash: string;
+    }>;
+    upsertCuratedMemory(candidate: CuratedMemoryWrite): Promise<{
+        assetPath: string;
+        hash: string;
+    }>;
+    proposeAnchorWrite(proposal: AnchorWriteProposal): Promise<{
+        proposalPath: string;
+        status: string;
+    }>;
+    loadAnchorSnapshot(): Promise<Record<string, string>>;
+}
+export declare function createWorkspaceArtifactStore(db: StateDatabase["db"]): WorkspaceArtifactStore;

package/runtime/storage/memory/workspace/store.js

@@ -0,0 +1,153 @@
+import { resolveDailyJournalPath, resolveDailyReportPath, resolveCuratedPath, resolveProposalPath, resolveAnchorPath, appendLine, readText, hashFile, writeCanonicalArtifact, buildJournalAssetId, buildReportAssetId, buildCuratedAssetId, ASSET_CONFIG } from "./paths.js";
+import { assetRegistry } from "../../db/schema/index.js";
+export function createWorkspaceArtifactStore(db) {
+    const indexStore = {
+        async upsertAsset(record) {
+            await db.insert(assetRegistry).values(record).onConflictDoUpdate({
+                target: assetRegistry.id,
+                set: record,
+            });
+        },
+        async findSimilarCuratedMemory(candidate) {
+            return undefined;
+        },
+        async upsertCurated(_candidate) { },
+        async registerProposal(_proposal) { },
+        async markProposalApplied(_proposalId, _afterHash) { },
+        async bumpAssetVersion(_assetId, _hash) { },
+    };
+    return {
+        async appendActivityLog(entry) {
+            const journalPath = resolveDailyJournalPath(entry.timestamp);
+            const serialized = `- [${entry.timestamp}] ${entry.platform ? `[${entry.platform}] ` : ""}${entry.kind}: ${entry.content}${entry.sourceRefs.length > 0 ? ` (refs: ${entry.sourceRefs.join(", ")})` : ""}`;
+            await appendLine(journalPath, serialized);
+            const hashVal = await hashFile(journalPath);
+            const assetRecord = {
+                id: buildJournalAssetId(journalPath),
+                kind: "daily_journal",
+                path: journalPath,
+                hash: hashVal,
+                version: 1,
+                layer: "daily_journal",
+                lastIndexedAt: new Date().toISOString(),
+            };
+            await indexStore.upsertAsset(assetRecord);
+            return { assetPath: journalPath, hash: hashVal };
+        },
+        async appendObservation(entry) {
+            const journalPath = resolveDailyJournalPath(entry.timestamp);
+            const serialized = `- [${entry.timestamp}] ${entry.summary}${entry.mood ? ` (${entry.mood})` : ""}${entry.sourceRefs.length > 0 ? ` [${entry.sourceRefs.join(", ")}]` : ""}`;
+            await appendLine(journalPath, serialized);
+            const hashVal = await hashFile(journalPath);
+            const assetRecord = {
+                id: buildJournalAssetId(journalPath),
+                kind: "daily_journal",
+                path: journalPath,
+                hash: hashVal,
+                version: 1,
+                layer: "daily_journal",
+                lastIndexedAt: new Date().toISOString(),
+            };
+            await indexStore.upsertAsset(assetRecord);
+            return { assetPath: journalPath, hash: hashVal };
+        },
+        async generateDailyReport(input) {
+            const reportPath = resolveDailyReportPath(input.day);
+            const lines = [
+                `# Daily Report — ${input.day}`,
+                "",
+                "## Summary",
+                input.summary,
+                "",
+                "## Highlights",
+            ];
+            for (const h of input.highlights)
+                lines.push(`- ${h}`);
+            lines.push("");
+            lines.push("## Sources");
+            lines.push(`- Activities: ${input.activityRefs.join(", ")}`);
+            lines.push(`- Observations: ${input.observationRefs.join(", ")}`);
+            const content = lines.join("\n");
+            await writeCanonicalArtifact(reportPath, content);
+            const hashVal = await hashFile(reportPath);
+            const assetRecord = {
+                id: buildReportAssetId(input.day),
+                kind: "daily_report",
+                path: reportPath,
+                hash: hashVal,
+                version: 1,
+                layer: "daily_journal",
+                lastIndexedAt: new Date().toISOString(),
+            };
+            await indexStore.upsertAsset(assetRecord);
+            return { assetPath: reportPath, hash: hashVal };
+        },
+        async upsertCuratedMemory(candidate) {
+            const curatedPath = resolveCuratedPath(candidate.id);
+            const lines = [
+                `# ${candidate.title}`,
+                "",
+                candidate.summary,
+                "",
+                `**Confidence**: ${candidate.confidence.toFixed(2)} | **TTL**: ${candidate.ttlClass}`,
+                "",
+                "## Sources",
+            ];
+            for (const ref of candidate.sourceRefs)
+                lines.push(`- ${ref}`);
+            const content = lines.join("\n");
+            await writeCanonicalArtifact(curatedPath, content);
+            const hashVal = await hashFile(curatedPath);
+            const assetRecord = {
+                id: buildCuratedAssetId(candidate.id),
+                kind: "curated_memory",
+                path: curatedPath,
+                hash: hashVal,
+                version: 1,
+                layer: "curated_memory",
+                lastIndexedAt: new Date().toISOString(),
+            };
+            await indexStore.upsertAsset(assetRecord);
+            return { assetPath: curatedPath, hash: hashVal };
+        },
+        async proposeAnchorWrite(proposal) {
+            if (!proposal.supportingSources.length) {
+                throw new Error("anchor_proposal_requires_sources");
+            }
+            if (proposal.confidence < 0.8) {
+                throw new Error("anchor_proposal_confidence_too_low");
+            }
+            const proposalPath = resolveProposalPath(proposal.id);
+            const lines = [
+                `# Anchor Proposal — ${proposal.id}`,
+                "",
+                `**Target**: ${proposal.targetAssetId}`,
+                `**Status**: ${proposal.status}`,
+                "",
+                "## Reason",
+                proposal.reason,
+                "",
+                "## Diff",
+                "```diff",
+                proposal.proposedDiff,
+                "```",
+                "",
+                "## Supporting Sources",
+            ];
+            for (const src of proposal.supportingSources)
+                lines.push(`- ${src}`);
+            const content = lines.join("\n");
+            await writeCanonicalArtifact(proposalPath, content);
+            await indexStore.registerProposal({ ...proposal, status: "draft" });
+            return { proposalPath, status: proposal.status };
+        },
+        async loadAnchorSnapshot() {
+            const snapshot = {};
+            for (const name of ASSET_CONFIG.anchorAssets) {
+                const anchorPath = resolveAnchorPath(name);
+                snapshot[name] = await readText(anchorPath);
+            }
+            return snapshot;
+        },
+    };
+}

package/runtime/storage/memory/workspace/types.d.ts

@@ -0,0 +1,45 @@
+export interface ActivityLogWrite {
+    id: string;
+    timestamp: string;
+    platform?: string;
+    kind: "browse" | "action" | "failure" | "task" | "heartbeat";
+    content: string;
+    sourceRefs: string[];
+}
+export interface ObservationWrite {
+    id: string;
+    timestamp: string;
+    summary: string;
+    mood?: string;
+    sourceRefs: string[];
+}
+export interface DailyReportInput {
+    day: string;
+    activityRefs: string[];
+    observationRefs: string[];
+    reflectionSummary: string;
+    summary: string;
+    highlights: string[];
+}
+export interface CuratedMemoryWrite {
+    id: string;
+    title: string;
+    summary: string;
+    confidence: number;
+    ttlClass: "short" | "medium" | "long";
+    sourceRefs: string[];
+    supersedes?: string[];
+}
+export interface AnchorWriteProposal {
+    id: string;
+    targetAssetId: string;
+    beforeHash?: string;
+    afterHash?: string;
+    status: "draft" | "requires_review" | "approved" | "rejected" | "applied" | "conflicted";
+    proposedDiff: string;
+    reason: string;
+    supportingSources: string[];
+    confidence: number;
+    riskFlags: string[];
+    createdAt: string;
+}

package/runtime/storage/memory/workspace/types.js

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

package/runtime/storage/repositories/asset-repository.d.ts

@@ -0,0 +1,8 @@
+import type { StateDatabase } from "../db/index.js";
+import { type AssetRegistryRecord, type NewAssetRegistryRecord } from "../db/schema/index.js";
+export declare class AssetRepository {
+    private readonly database;
+    constructor(database: StateDatabase);
+    upsert(record: NewAssetRegistryRecord): Promise<void>;
+    findById(id: string): Promise<AssetRegistryRecord | undefined>;
+}

package/runtime/storage/repositories/asset-repository.js

@@ -0,0 +1,19 @@
+import { eq } from "drizzle-orm";
+import { assetRegistry } from "../db/schema/index.js";
+export class AssetRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async upsert(record) {
+        await this.database.db.insert(assetRegistry).values(record).onConflictDoUpdate({
+            target: assetRegistry.id,
+            set: record,
+        });
+    }
+    async findById(id) {
+        return this.database.db.query.assetRegistry.findFirst({
+            where: eq(assetRegistry.id, id),
+        });
+    }
+}

package/runtime/storage/repositories/credential-repository.d.ts

@@ -0,0 +1,8 @@
+import type { StateDatabase } from "../db/index.js";
+import { type CredentialRecord, type NewCredentialRecord } from "../db/schema/index.js";
+export declare class CredentialRepository {
+    private readonly database;
+    constructor(database: StateDatabase);
+    upsert(record: NewCredentialRecord): Promise<void>;
+    findByPlatformId(platformId: string): Promise<CredentialRecord | undefined>;
+}

package/runtime/storage/repositories/credential-repository.js

@@ -0,0 +1,19 @@
+import { eq } from "drizzle-orm";
+import { credentialRecords } from "../db/schema/index.js";
+export class CredentialRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async upsert(record) {
+        await this.database.db.insert(credentialRecords).values(record).onConflictDoUpdate({
+            target: credentialRecords.platformId,
+            set: record,
+        });
+    }
+    async findByPlatformId(platformId) {
+        return this.database.db.query.credentialRecords.findFirst({
+            where: eq(credentialRecords.platformId, platformId),
+        });
+    }
+}

package/runtime/storage/repositories/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./asset-repository.js";
+export * from "./credential-repository.js";
+export * from "./intent-commit-repository.js";
+export * from "./policy-repository.js";
+export * from "./proposal-repository.js";
+export * from "./provenance-repository.js";

package/runtime/storage/repositories/index.js

@@ -0,0 +1,6 @@
+export * from "./asset-repository.js";
+export * from "./credential-repository.js";
+export * from "./intent-commit-repository.js";
+export * from "./policy-repository.js";
+export * from "./proposal-repository.js";
+export * from "./provenance-repository.js";

package/runtime/storage/repositories/intent-commit-repository.d.ts

@@ -0,0 +1,10 @@
+import type { IntentCommitRecord } from "../../shared/types/index.js";
+import type { StateDatabase } from "../db/index.js";
+import { type NewIntentCommitDbRecord } from "../db/schema/index.js";
+export declare class IntentCommitRepository {
+    private readonly database;
+    constructor(database: StateDatabase);
+    create(record: NewIntentCommitDbRecord): Promise<void>;
+    update(record: NewIntentCommitDbRecord): Promise<void>;
+    findByIntentId(intentId: string): Promise<IntentCommitRecord | undefined>;
+}

package/runtime/storage/repositories/intent-commit-repository.js

@@ -0,0 +1,35 @@
+import { eq } from "drizzle-orm";
+import { intentCommitRecords } from "../db/schema/index.js";
+function mapToDomain(record) {
+    return {
+        id: record.id,
+        intentId: record.intentId,
+        decisionId: record.decisionId,
+        checkpointId: record.checkpointId ?? undefined,
+        state: record.state,
+        outcomeRef: record.outcomeRef ?? undefined,
+        metadata: record.metadataJson ? JSON.parse(record.metadataJson) : undefined,
+        updatedAt: record.updatedAt,
+    };
+}
+export class IntentCommitRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async create(record) {
+        await this.database.db.insert(intentCommitRecords).values(record);
+    }
+    async update(record) {
+        await this.database.db.insert(intentCommitRecords).values(record).onConflictDoUpdate({
+            target: intentCommitRecords.id,
+            set: record,
+        });
+    }
+    async findByIntentId(intentId) {
+        const record = await this.database.db.query.intentCommitRecords.findFirst({
+            where: eq(intentCommitRecords.intentId, intentId),
+        });
+        return record ? mapToDomain(record) : undefined;
+    }
+}

package/runtime/storage/repositories/policy-repository.d.ts

@@ -0,0 +1,8 @@
+import type { StateDatabase } from "../db/index.js";
+import { type NewPolicyRecord, type PolicyRecord } from "../db/schema/index.js";
+export declare class PolicyRepository {
+    private readonly database;
+    constructor(database: StateDatabase);
+    upsert(record: NewPolicyRecord): Promise<void>;
+    findByPlatformId(platformId: string): Promise<PolicyRecord | undefined>;
+}

package/runtime/storage/repositories/policy-repository.js

@@ -0,0 +1,19 @@
+import { eq } from "drizzle-orm";
+import { policyRecords } from "../db/schema/index.js";
+export class PolicyRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async upsert(record) {
+        await this.database.db.insert(policyRecords).values(record).onConflictDoUpdate({
+            target: policyRecords.platformId,
+            set: record,
+        });
+    }
+    async findByPlatformId(platformId) {
+        return this.database.db.query.policyRecords.findFirst({
+            where: eq(policyRecords.platformId, platformId),
+        });
+    }
+}

package/runtime/storage/repositories/proposal-repository.d.ts

@@ -0,0 +1,9 @@
+import type { StateDatabase } from "../db/index.js";
+import { type NewProposalRecord, type ProposalRecord } from "../db/schema/index.js";
+export declare class ProposalRepository {
+    private readonly database;
+    constructor(database: StateDatabase);
+    create(record: NewProposalRecord): Promise<void>;
+    findById(id: string): Promise<ProposalRecord | undefined>;
+    updateStatus(id: string, status: string, afterHash?: string): Promise<void>;
+}

package/runtime/storage/repositories/proposal-repository.js

@@ -0,0 +1,26 @@
+import { eq } from "drizzle-orm";
+import { proposalRecords } from "../db/schema/index.js";
+export class ProposalRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async create(record) {
+        await this.database.db.insert(proposalRecords).values(record);
+    }
+    async findById(id) {
+        return this.database.db.query.proposalRecords.findFirst({
+            where: eq(proposalRecords.id, id),
+        });
+    }
+    async updateStatus(id, status, afterHash) {
+        await this.database.db
+            .update(proposalRecords)
+            .set({
+            status,
+            afterHash: afterHash ?? undefined,
+            appliedAt: status === "applied" ? new Date().toISOString() : undefined,
+        })
+            .where(eq(proposalRecords.id, id));
+    }
+}

package/runtime/storage/repositories/provenance-repository.d.ts

@@ -0,0 +1,20 @@
+import type { StateDatabase } from "../db/index.js";
+import { type NewProvenanceEdgeRecord, type ProvenanceEdgeRecord } from "../db/schema/index.js";
+export declare class ProvenanceRepository {
+    private readonly database;
+    constructor(database: StateDatabase);
+    create(record: NewProvenanceEdgeRecord): Promise<void>;
+    listByTarget(toId: string): Promise<ProvenanceEdgeRecord[]>;
+    linkEntrySources(entryId: string, sourceRefs: string[]): Promise<void>;
+    traceAsset(assetId: string): Promise<{
+        assetId: string;
+        upstreamSources: string[];
+        proposalIds: string[];
+        applyIds: string[];
+    }>;
+    recordApply(proposalId: string, assetId: string, info: {
+        beforeHash: string;
+        afterHash: string;
+        diff: string;
+    }): Promise<void>;
+}