@haaaiawd/second-nature 0.1.26 → 0.1.29

package/runtime/storage/db/schema/agent-goal.d.ts

@@ -190,6 +190,44 @@ export declare const agentGoal: import("drizzle-orm/sqlite-core").SQLiteTableWit
         }, {}, {
             length: number | undefined;
         }>;
+        scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "expires_at";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "created_at";
             tableName: "agent_goal";

package/runtime/storage/db/schema/agent-goal.js

@@ -10,6 +10,8 @@ export const agentGoal = sqliteTable("agent_goal", {
     priorityHint: integer("priority_hint").notNull().default(0),
     sourceRefsJson: text("source_refs_json").notNull(),
     acceptedBy: text("accepted_by"),
+    scope: text("scope"),
+    expiresAt: text("expires_at"),
     createdAt: text("created_at").notNull(),
     updatedAt: text("updated_at").notNull(),
 }, (table) => [

package/runtime/storage/db/transaction-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Transaction utilities for SQLite exclusive writes (DR-019).
+ *
+ * Core logic:
+ * - Provides `runExclusive` for one-off transactional writes outside the queue.
+ * - Uses `BEGIN EXCLUSIVE` for write isolation.
+ * - Automatically rolls back on error.
+ *
+ * Dependencies: sql.js Database.
+ * Boundary: Stateless helper; for queued writes prefer WriteQueue.
+ * Test coverage: tests/unit/storage/write-queue.test.ts (indirect via queue)
+ */
+import type { Database } from "sql.js";
+export declare function runExclusive<T>(sqlite: Database, fn: (sqlite: Database) => T): T;

package/runtime/storage/db/transaction-utils.js

@@ -0,0 +1,29 @@
+/**
+ * Transaction utilities for SQLite exclusive writes (DR-019).
+ *
+ * Core logic:
+ * - Provides `runExclusive` for one-off transactional writes outside the queue.
+ * - Uses `BEGIN EXCLUSIVE` for write isolation.
+ * - Automatically rolls back on error.
+ *
+ * Dependencies: sql.js Database.
+ * Boundary: Stateless helper; for queued writes prefer WriteQueue.
+ * Test coverage: tests/unit/storage/write-queue.test.ts (indirect via queue)
+ */
+export function runExclusive(sqlite, fn) {
+    sqlite.exec("BEGIN EXCLUSIVE");
+    try {
+        const result = fn(sqlite);
+        sqlite.exec("COMMIT");
+        return result;
+    }
+    catch (err) {
+        try {
+            sqlite.exec("ROLLBACK");
+        }
+        catch {
+            // rollback may fail if no transaction active
+        }
+        throw err;
+    }
+}

package/runtime/storage/db/write-queue.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Serial write queue with concurrency protection (DR-019).
+ *
+ * Core logic:
+ * - All DB writes are funneled through a single serial queue.
+ * - Each write executes inside a `BEGIN EXCLUSIVE` transaction.
+ * - On SQLITE_BUSY or equivalent, retries up to 3 times with 50ms backoff.
+ * - Flush failure writes to stderr without blocking read paths.
+ * - `triggerSource` is preserved through the write pipeline.
+ *
+ * Dependencies: sql.js Database.
+ * Boundary: Wraps raw SQL execution; callers enqueue write operations.
+ * Test coverage: tests/unit/storage/write-queue.test.ts
+ */
+import type { Database } from "sql.js";
+export type TriggerSource = "heartbeat" | "manual_run" | "probe" | "idle_curiosity";
+export interface WriteRequest<T = unknown> {
+    label: string;
+    triggerSource: TriggerSource;
+    execute: (sqlite: Database) => T;
+}
+export interface WriteResult<T = unknown> {
+    ok: boolean;
+    value?: T;
+    error?: string;
+    triggerSource: TriggerSource;
+}
+export declare class WriteQueue {
+    private readonly sqlite;
+    private queue;
+    private processing;
+    constructor(sqlite: Database);
+    enqueue<T>(request: WriteRequest<T>): Promise<WriteResult<T>>;
+    private drain;
+    private executeWithRetry;
+    get pending(): number;
+}
+export declare function createWriteQueue(sqlite: Database): WriteQueue;

package/runtime/storage/db/write-queue.js

@@ -0,0 +1,97 @@
+/**
+ * Serial write queue with concurrency protection (DR-019).
+ *
+ * Core logic:
+ * - All DB writes are funneled through a single serial queue.
+ * - Each write executes inside a `BEGIN EXCLUSIVE` transaction.
+ * - On SQLITE_BUSY or equivalent, retries up to 3 times with 50ms backoff.
+ * - Flush failure writes to stderr without blocking read paths.
+ * - `triggerSource` is preserved through the write pipeline.
+ *
+ * Dependencies: sql.js Database.
+ * Boundary: Wraps raw SQL execution; callers enqueue write operations.
+ * Test coverage: tests/unit/storage/write-queue.test.ts
+ */
+const MAX_RETRIES = 3;
+const BACKOFF_MS = 50;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isBusyError(err) {
+    if (err instanceof Error) {
+        const msg = err.message.toLowerCase();
+        return msg.includes("busy") || msg.includes("locked") || msg.includes("database is locked");
+    }
+    return false;
+}
+export class WriteQueue {
+    sqlite;
+    queue = [];
+    processing = false;
+    constructor(sqlite) {
+        this.sqlite = sqlite;
+    }
+    enqueue(request) {
+        return new Promise((resolve) => {
+            this.queue.push({
+                request: request,
+                resolve: resolve,
+            });
+            this.drain();
+        });
+    }
+    async drain() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        while (this.queue.length > 0) {
+            const item = this.queue.shift();
+            const result = await this.executeWithRetry(item.request);
+            item.resolve(result);
+        }
+        this.processing = false;
+    }
+    async executeWithRetry(request) {
+        let lastError;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                this.sqlite.exec("BEGIN EXCLUSIVE");
+                const value = request.execute(this.sqlite);
+                this.sqlite.exec("COMMIT");
+                return {
+                    ok: true,
+                    value,
+                    triggerSource: request.triggerSource,
+                };
+            }
+            catch (err) {
+                try {
+                    this.sqlite.exec("ROLLBACK");
+                }
+                catch {
+                    // rollback may fail if no transaction active
+                }
+                const message = err instanceof Error ? err.message : String(err);
+                lastError = message;
+                if (isBusyError(err) && attempt < MAX_RETRIES) {
+                    await sleep(BACKOFF_MS * (attempt + 1));
+                    continue;
+                }
+                break;
+            }
+        }
+        process.stderr.write(`write_queue_flush_failed: ${request.label} [${request.triggerSource}] — ${lastError}\n`);
+        return {
+            ok: false,
+            error: lastError,
+            triggerSource: request.triggerSource,
+        };
+    }
+    get pending() {
+        return this.queue.length;
+    }
+}
+export function createWriteQueue(sqlite) {
+    return new WriteQueue(sqlite);
+}

package/runtime/storage/quiet/persist-quiet-artifact.js

@@ -6,7 +6,8 @@ import * as path from "node:path";
 export async function persistQuietArtifactToWorkspace(workspaceRoot, ack, input) {
     const dir = path.join(workspaceRoot, ".second-nature", "quiet", input.day);
     await fs.mkdir(dir, { recursive: true });
-    const file = path.join(dir, `${ack.artifactId}.json`);
+    const fileName = input.kind === "empty_state" ? "empty_state.json" : `${ack.artifactId}.json`;
+    const file = path.join(dir, fileName);
     const payload = {
         artifactId: ack.artifactId,
         artifactRef: ack.artifactRef,

package/runtime/storage/services/credential-vault.js

@@ -8,6 +8,11 @@ import * as crypto from "crypto";
 import { eq } from "drizzle-orm";
 import { credentialRecords } from "../db/schema/index.js";
 const ALGORITHM = "aes-256-gcm";
+function normalizeCredentialRecord(record) {
+    return record && typeof record === "object"
+        ? record
+        : {};
+}
 function resolveKeyBuffer() {
     const raw = process.env.SECOND_NATURE_ENCRYPTION_KEY?.trim();
     if (!raw || raw.length < 32) {
@@ -140,24 +145,32 @@ export function createCredentialVault(db) {
             });
             if (!record)
                 return null;
+            const row = normalizeCredentialRecord(record);
+            const resolvedPlatformId = row.platformId ?? row.platform_id ?? platformId;
+            const credentialType = row.credentialType ?? row.credential_type ?? "api_key";
+            const encryptedValue = row.encryptedValue ?? row.encrypted_value ?? "";
+            const verificationCode = row.verificationCode ?? row.verification_code ?? undefined;
+            const challengeText = row.challengeText ?? row.challenge_text ?? undefined;
+            const expiresAt = row.expiresAt ?? row.expires_at ?? undefined;
+            const attemptsRemaining = row.attemptsRemaining ?? row.attempts_remaining ?? undefined;
             let plain;
-            let status = record.status;
-            if (record.encryptedValue) {
-                if (!isCredentialCiphertext(record.encryptedValue)) {
+            let status = (row.status ?? "missing");
+            if (encryptedValue) {
+                if (!isCredentialCiphertext(encryptedValue)) {
                     // Fail-closed: return decrypt_failed so callers do not crash.
                     return {
-                        platformId: record.platformId,
-                        credentialType: record.credentialType,
+                        platformId: resolvedPlatformId,
+                        credentialType: credentialType,
                         status: "decrypt_failed",
                         encryptedValue: undefined,
-                        verificationCode: record.verificationCode ?? undefined,
-                        challengeText: record.challengeText ?? undefined,
-                        verificationDeadline: record.expiresAt ?? undefined,
-                        attemptsRemaining: record.attemptsRemaining ?? undefined,
+                        verificationCode,
+                        challengeText,
+                        verificationDeadline: expiresAt,
+                        attemptsRemaining,
                     };
                 }
                 try {
-                    plain = decryptCredentialAtRest(record.encryptedValue);
+                    plain = decryptCredentialAtRest(encryptedValue);
                 }
                 catch {
                     // Decryption failure must not break the whole state load.
@@ -166,21 +179,22 @@ export function createCredentialVault(db) {
                 }
             }
             return {
-                platformId: record.platformId,
-                credentialType: record.credentialType,
+                platformId: resolvedPlatformId,
+                credentialType: credentialType,
                 status,
                 encryptedValue: plain,
-                verificationCode: record.verificationCode ?? undefined,
-                challengeText: record.challengeText ?? undefined,
-                verificationDeadline: record.expiresAt ?? undefined,
-                attemptsRemaining: record.attemptsRemaining ?? undefined,
+                verificationCode,
+                challengeText,
+                verificationDeadline: expiresAt,
+                attemptsRemaining,
             };
         },
         async getCredentialState(platformId) {
             const record = await db.query.credentialRecords.findFirst({
                 where: (tbl) => eq(tbl.platformId, platformId),
             });
-            return record?.status || "missing";
+            const row = normalizeCredentialRecord(record);
+            return row.status || "missing";
         },
     };
 }

package/runtime/storage/services/diary-dream-store.d.ts

@@ -0,0 +1,35 @@
+/**
+ * DiaryDreamStore — T-SMS.C.7
+ *
+ * Core logic:
+ * - DailyDiary artifact ref + index (observedToday, notableSignals,
+ *   tomorrowDirection, sourceRefs)
+ * - DreamOutput lifecycle: candidate -> accepted -> archived
+ *   (partial is a terminal state, not a lifecycle stage)
+ * - `transitionDreamOutputLifecycle` enforces VALID_TRANSITIONS.
+ * - Read path `loadAcceptedDreamProjection` only exposes accepted outputs.
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../db/index.js`
+ * - `DailyDiary`, `DreamOutput`, `DreamOutputStatus` from
+ *   `../../shared/types/v7-entities.js`
+ * - `validateWritePayload` from `./write-validation-gate.js`
+ *
+ * Boundary:
+ * - Candidate outputs are stored but filtered from active read paths.
+ * - Accepted transition is initiated by dream-quiet (DR-023).
+ * - Write paths pass through WriteValidationGate.
+ *
+ * Test coverage: tests/unit/storage/diary-dream-store.test.ts
+ */
+import type { StateDatabase } from "../db/index.js";
+import type { DailyDiary, DreamOutput, DreamOutputStatus } from "../../shared/types/v7-entities.js";
+export interface DiaryDreamStore {
+    writeDailyDiary(diary: DailyDiary): Promise<void>;
+    loadDailyDiary(day: string): Promise<DailyDiary | undefined>;
+    appendDreamOutput(output: DreamOutput): Promise<void>;
+    transitionDreamOutputLifecycle(outputId: string, newStatus: Exclude<DreamOutputStatus, "candidate" | "partial">): Promise<void>;
+    loadAcceptedDreamProjection(limit?: number): Promise<DreamOutput[]>;
+    listDreamOutputs(limit?: number): Promise<DreamOutput[]>;
+}
+export declare function createDiaryDreamStore(database: StateDatabase): DiaryDreamStore;

package/runtime/storage/services/diary-dream-store.js

@@ -0,0 +1,165 @@
+/**
+ * DiaryDreamStore — T-SMS.C.7
+ *
+ * Core logic:
+ * - DailyDiary artifact ref + index (observedToday, notableSignals,
+ *   tomorrowDirection, sourceRefs)
+ * - DreamOutput lifecycle: candidate -> accepted -> archived
+ *   (partial is a terminal state, not a lifecycle stage)
+ * - `transitionDreamOutputLifecycle` enforces VALID_TRANSITIONS.
+ * - Read path `loadAcceptedDreamProjection` only exposes accepted outputs.
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../db/index.js`
+ * - `DailyDiary`, `DreamOutput`, `DreamOutputStatus` from
+ *   `../../shared/types/v7-entities.js`
+ * - `validateWritePayload` from `./write-validation-gate.js`
+ *
+ * Boundary:
+ * - Candidate outputs are stored but filtered from active read paths.
+ * - Accepted transition is initiated by dream-quiet (DR-023).
+ * - Write paths pass through WriteValidationGate.
+ *
+ * Test coverage: tests/unit/storage/diary-dream-store.test.ts
+ */
+import { validateWritePayload } from "./write-validation-gate.js";
+const VALID_TRANSITIONS = {
+    candidate: ["accepted", "archived"],
+    accepted: ["archived"],
+    archived: [],
+    partial: [],
+};
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function createDiaryDreamStore(database) {
+    const { sqlite } = database;
+    return {
+        async writeDailyDiary(diary) {
+            const gate = validateWritePayload({
+                ...diary,
+                sourceRefs: diary.sourceRefs,
+            });
+            if (!gate.ok)
+                throw new Error(gate.reason ?? "write_validation_failed");
+            sqlite.run(`INSERT INTO daily_diary_index
+         (diary_id, day, observed_today_json, notable_signals_json, tomorrow_direction, source_refs_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(day) DO UPDATE SET
+           observed_today_json = excluded.observed_today_json,
+           notable_signals_json = excluded.notable_signals_json,
+           tomorrow_direction = excluded.tomorrow_direction,
+           source_refs_json = excluded.source_refs_json,
+           created_at = excluded.created_at`, [
+                diary.diaryId,
+                diary.day,
+                JSON.stringify(diary.observedToday),
+                JSON.stringify(diary.notableSignals),
+                diary.tomorrowDirection,
+                JSON.stringify(diary.sourceRefs),
+                diary.createdAt,
+            ]);
+        },
+        async loadDailyDiary(day) {
+            const result = sqlite.exec(`SELECT * FROM daily_diary_index WHERE day = ?`, [day]);
+            if (result.length === 0 || result[0].values.length === 0) {
+                return undefined;
+            }
+            const cols = result[0].columns;
+            const get = (row, name) => row[cols.indexOf(name)];
+            const row = result[0].values[0];
+            return {
+                diaryId: get(row, "diary_id"),
+                day: get(row, "day"),
+                observedToday: safeParseJson(get(row, "observed_today_json") ?? "[]", []),
+                notableSignals: safeParseJson(get(row, "notable_signals_json") ?? "[]", []),
+                tomorrowDirection: get(row, "tomorrow_direction") ?? "",
+                sourceRefs: safeParseJson(get(row, "source_refs_json") ?? "[]", ["store:default"]),
+                createdAt: get(row, "created_at"),
+            };
+        },
+        async appendDreamOutput(output) {
+            const gate = validateWritePayload({
+                ...output,
+                sourceRefs: ["dream:run"],
+            });
+            if (!gate.ok)
+                throw new Error(gate.reason ?? "write_validation_failed");
+            sqlite.run(`INSERT INTO dream_output_index
+         (output_id, run_id, status, canonical_entries_json, insights_json,
+          narrative_update_json, relationship_update_json, validation_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                output.outputId,
+                output.runId,
+                output.status,
+                JSON.stringify(output.canonicalEntries),
+                JSON.stringify(output.insights),
+                output.narrativeUpdate ? JSON.stringify(output.narrativeUpdate) : null,
+                output.relationshipUpdate ? JSON.stringify(output.relationshipUpdate) : null,
+                JSON.stringify(output.validation),
+                output.createdAt ?? new Date().toISOString(),
+            ]);
+        },
+        async transitionDreamOutputLifecycle(outputId, newStatus) {
+            const currentResult = sqlite.exec(`SELECT status FROM dream_output_index WHERE output_id = ?`, [outputId]);
+            if (currentResult.length === 0 ||
+                currentResult[0].values.length === 0) {
+                throw new Error(`dream_output_not_found:${outputId}`);
+            }
+            const currentStatus = currentResult[0].values[0][0];
+            const allowed = VALID_TRANSITIONS[currentStatus];
+            if (!allowed.includes(newStatus)) {
+                throw new Error(`invalid_transition:${currentStatus}->${newStatus}`);
+            }
+            sqlite.run(`UPDATE dream_output_index SET status = ? WHERE output_id = ?`, [newStatus, outputId]);
+        },
+        async loadAcceptedDreamProjection(limit = 10) {
+            const result = sqlite.exec(`SELECT * FROM dream_output_index
+         WHERE status = 'accepted'
+         ORDER BY created_at DESC
+         LIMIT ${limit}`);
+            if (result.length === 0 || result[0].values.length === 0) {
+                return [];
+            }
+            const cols = result[0].columns;
+            const get = (row, name) => row[cols.indexOf(name)];
+            return result[0].values.map((row) => rowToDreamOutput(row, cols));
+        },
+        async listDreamOutputs(limit = 10) {
+            const result = sqlite.exec(`SELECT * FROM dream_output_index
+         ORDER BY created_at DESC
+         LIMIT ${limit}`);
+            if (result.length === 0 || result[0].values.length === 0) {
+                return [];
+            }
+            const cols = result[0].columns;
+            return result[0].values.map((row) => rowToDreamOutput(row, cols));
+        },
+    };
+}
+function rowToDreamOutput(row, cols) {
+    const get = (name) => row[cols.indexOf(name)];
+    return {
+        outputId: get("output_id"),
+        runId: get("run_id"),
+        status: get("status"),
+        canonicalEntries: safeParseJson(get("canonical_entries_json") ?? "[]", []),
+        insights: safeParseJson(get("insights_json") ?? "[]", []),
+        narrativeUpdate: safeParseJson(get("narrative_update_json") ?? "null", undefined),
+        relationshipUpdate: safeParseJson(get("relationship_update_json") ?? "null", undefined),
+        validation: safeParseJson(get("validation_json") ?? "{}", {
+            schemaValid: false,
+            sourceGrounded: false,
+            sensitivityClean: false,
+            unsupportedClaims: [],
+            errors: [],
+            checkedAt: new Date().toISOString(),
+        }),
+        createdAt: get("created_at") ?? new Date().toISOString(),
+    };
+}

package/runtime/storage/services/embodied-context-state-port.d.ts

@@ -0,0 +1,77 @@
+/**
+ * EmbodiedContextStatePort — T-SMS.C.2
+ *
+ * Core logic: 5 read methods for assembling EmbodiedContext slices.
+ * Each method supports bounded query (limit/window).
+ * Affordance and self-health slices are sourced from body-tool-system
+ * and observability-health-system respectively, NOT read directly here.
+ * DR-011: loadAcceptedDreamProjection returns accepted projection only.
+ * DR-013: bounded context, degraded reason codes on failure.
+ * DR-024: empty accepted dream → context_degraded:dream_projection_unavailable.
+ *
+ * Dependencies:
+ * - GoalLifecycleStore from `./goal-lifecycle-store.js`
+ * - IdentityProfileStore from `./identity-profile-store.js`
+ * - InteractionSnapshotProjector from `./interaction-snapshot-projector.js`
+ * - ToolExperienceStore from `./tool-experience-store.js`
+ * - dream_output_index table (v7-001 migration)
+ *
+ * Boundary:
+ * - This port ONLY reads state-memory tables.
+ * - Affordance map and self-health are injected by caller (control-plane)
+ *   from their respective systems.
+ * - All methods return empty array + reason on missing data, never throw.
+ */
+import type { IdentityProfile, RecentInteractionSnapshot, ToolExperience, DreamOutput } from "../../shared/types/v7-entities.js";
+import type { AgentGoal } from "../../shared/types/goal.js";
+import type { GoalLifecycleStore } from "./goal-lifecycle-store.js";
+import type { IdentityProfileStore } from "./identity-profile-store.js";
+import type { InteractionSnapshotProjector } from "./interaction-snapshot-projector.js";
+import type { ToolExperienceStore } from "./tool-experience-store.js";
+import type { StateDatabase } from "../db/index.js";
+export interface EmbodiedContextStatePort {
+    loadIdentityProfile(profileId: string): Promise<{
+        status: "loaded";
+        data: IdentityProfile;
+    } | {
+        status: "degraded";
+        data?: IdentityProfile;
+        reason: string;
+    }>;
+    listActiveGoals(limit?: number): Promise<{
+        status: "loaded";
+        data: AgentGoal[];
+    } | {
+        status: "degraded";
+        reason: string;
+    }>;
+    loadRecentInteractionSnapshot(limit?: number): Promise<{
+        status: "loaded";
+        data: RecentInteractionSnapshot[];
+    } | {
+        status: "degraded";
+        reason: string;
+    }>;
+    loadToolExperienceSlice(limit?: number): Promise<{
+        status: "loaded";
+        data: ToolExperience[];
+    } | {
+        status: "degraded";
+        reason: string;
+    }>;
+    loadAcceptedDreamProjection(limit?: number): Promise<{
+        status: "loaded";
+        data: DreamOutput[];
+    } | {
+        status: "degraded";
+        reason: string;
+    }>;
+}
+export interface EmbodiedContextStatePortDeps {
+    database: StateDatabase;
+    goalStore: GoalLifecycleStore;
+    identityStore: IdentityProfileStore;
+    interactionProjector: InteractionSnapshotProjector;
+    experienceStore: ToolExperienceStore;
+}
+export declare function createEmbodiedContextStatePort(deps: EmbodiedContextStatePortDeps): EmbodiedContextStatePort;