@inflexa-ai/harness 0.36.4 → 0.37.0

package/dist/contracts/message.d.ts

@@ -74,4 +74,19 @@ export interface CortexMessage {
      * zero is a figure, thus it stays a value and it never reads as an absence.
      */
     durationMs?: number;
+    /**
+     * Who sent this message — the identity the host named at the append site.
+     * Carried on a `user` message only: `role` already names the sender of a
+     * reply, and the harness holds no per-turn model name at the store boundary.
+     * Absent means that nothing recorded a sender.
+     */
+    author?: string;
+    /**
+     * When the store wrote this message: the START time of the append
+     * transaction, thus every message of one append carries the same value and
+     * no order holds between two appends. An ISO 8601 string rather than a
+     * `Date`, because the wire shape is JSON. Absent means that no stored row
+     * backs the message — a live surface builds one before anything is written.
+     */
+    createdAt?: string;
 }

package/dist/memory/conversation-display-replay.js

@@ -23,7 +23,20 @@ export function storedMessagesToCortex(messages) {
     let append = null;
     for (const row of messages) {
         if (row.displayEnvelope) {
-            append = conversationUIToCortexMessages(row.displayEnvelope.messages);
+            // The author and the creation time are facts about the ROW, the same as
+            // the rollup below, and the projection holds neither. Both ride the row
+            // that opens the append, and the author reaches the `user` messages
+            // alone, because `role` already names the sender of a reply. Spread
+            // conditionally: an absent value must leave no key, or a consumer that
+            // spreads the message acquires one that overwrites a real value. `Date`
+            // does not survive the JSON crossing typed, hence the ISO string here.
+            const createdAt = row.createdAt === undefined ? {} : { createdAt: row.createdAt.toISOString() };
+            const author = row.author === undefined ? {} : { author: row.author };
+            append = conversationUIToCortexMessages(row.displayEnvelope.messages).map((message) => ({
+                ...message,
+                ...createdAt,
+                ...(message.role === "user" ? author : {}),
+            }));
             out.push(...append);
         }
         // The reported rollup of the turn and its duration both ride the model row that

package/dist/memory/thread-history.d.ts

@@ -55,6 +55,20 @@ export interface StoredMessage {
      * reported no quantity still reads back with the duration that it took.
      */
     readonly durationMs?: number;
+    /**
+     * Who sent the user message of the append this row OPENED — present only on a
+     * genuine-user-start row of a turn appended with one. A row written before the
+     * column existed carries none, because no sender was ever recorded for it.
+     */
+    readonly author?: string;
+    /**
+     * When the store wrote this row: the START time of the append transaction,
+     * thus every row of one append holds the same value, and `seq` alone orders
+     * rows. The read sets it on every row, because the column is `NOT NULL`. It is
+     * optional because a fake or a fixture builds a `StoredMessage` with no row
+     * behind it.
+     */
+    readonly createdAt?: Date;
 }
 /**
  * One atomic append: the exact provider-facing history, the display projection of
@@ -86,6 +100,16 @@ export interface ConversationTurn {
      * reported no quantity still keeps the duration that it took.
      */
     readonly turnDurationMs?: number;
+    /**
+     * Who sent the user message of this turn — the identity the host holds at the
+     * append site. Stored on the FIRST row of the append, and only when that row
+     * is a genuine user start: that row also carries the display projection, thus
+     * the write and the transcript replay read one row under one rule. A record
+     * append opens on a synthetic row, so it stores no author however a caller
+     * spreads one in. The value is NUL-stripped on the way in, the same as the
+     * envelope, because a `text` parameter carrying 0x00 fails the statement.
+     */
+    readonly author?: string;
 }
 /**
  * The append a host uses to record out-of-band work in a thread — an analysis

package/dist/memory/thread-history.js

@@ -181,7 +181,7 @@ export const EVICTION_BLOCK_TURNS = 4;
  */
 export function createThreadHistory(pool, logger) {
     function appendTurn(threadId, turn) {
-        const { modelMessages: messages, displayMessages, turnUsage, turnDurationMs } = turn;
+        const { modelMessages: messages, displayMessages, turnUsage, turnDurationMs, author } = turn;
         if (messages.length === 0)
             return okVoid();
         // The display projection rides the append's FIRST row, so one SELECT of a
@@ -206,6 +206,13 @@ export function createThreadHistory(pool, logger) {
         // the turn. -1 (a turn that persisted no reply — an abort before any output)
         // matches no index below, so nothing is written and the append still succeeds.
         const lastAssistantRow = messages.reduce((last, m, i) => (m.role === "assistant" ? i : last), -1);
+        // The author rides the row the display projection rides, and only when that
+        // row is a message a person actually sent — an assistant row, a tool row,
+        // and the synthetic opening row of a record append are not. NUL is dropped
+        // rather than refused: a 0x00 byte in a `text` parameter fails the
+        // statement, and one byte in a label would roll the whole turn back.
+        const turnAuthor = author === undefined ? null : stripNulCharacters(author);
+        const authorRow = messages[0] !== undefined && isGenuineUserStart(messages[0]) ? 0 : -1;
         return withTransaction(pool, "thread-history.appendTurn", (client) => 
         // Serialize concurrent appends on this thread — without the lock, two
         // transactions can both read the same MAX(seq) and collide on the
@@ -224,14 +231,15 @@ export function createThreadHistory(pool, logger) {
         // `message_envelope::json`, never `::jsonb`; `display_envelope` and
         // `reported_usage::jsonb`, never `::json` — see the column comments
         // in the state-init DDL.
-        `INSERT INTO messages (thread_id, seq, message_envelope, display_envelope, tokens, reported_usage, turn_duration_ms)
-                     VALUES ($1, $2, $3::json, $4::jsonb, $5, $6::jsonb, $7)
+        `INSERT INTO messages (thread_id, seq, message_envelope, display_envelope, tokens, reported_usage, turn_duration_ms, author)
+                     VALUES ($1, $2, $3::json, $4::jsonb, $5, $6::jsonb, $7, $8)
                      ON CONFLICT (thread_id, seq) DO UPDATE
                        SET message_envelope = EXCLUDED.message_envelope,
                            display_envelope = EXCLUDED.display_envelope,
                            tokens = EXCLUDED.tokens,
                            reported_usage = EXCLUDED.reported_usage,
-                           turn_duration_ms = EXCLUDED.turn_duration_ms`, [
+                           turn_duration_ms = EXCLUDED.turn_duration_ms,
+                           author = EXCLUDED.author`, [
             threadId,
             startSeq + i,
             serializeEnvelope(message),
@@ -239,6 +247,7 @@ export function createThreadHistory(pool, logger) {
             countTokens(message.content),
             i === lastAssistantRow ? rollup : null,
             i === lastAssistantRow ? duration : null,
+            i === authorRow ? turnAuthor : null,
         ])).map(() => undefined)), okVoid()))
             .andThen(() => 
         // Thread listings sort on `cortex_analysis_threads.updated_at`, and
@@ -368,12 +377,14 @@ export function createThreadHistory(pool, logger) {
         // `seq::text AS seq` output alias (Postgres resolves an unqualified
         // ORDER BY name to the output column), sorting the bigint as text:
         // "10" before "2". The qualified name forces the bigint column.
-        `SELECT seq::text AS seq, message_envelope, display_envelope, reported_usage, turn_duration_ms::text AS turn_duration_ms
+        `SELECT seq::text AS seq, message_envelope, display_envelope, reported_usage, turn_duration_ms::text AS turn_duration_ms, author, created_at
          FROM messages WHERE thread_id = $1
          ORDER BY messages.seq ASC`, [threadId]);
         // Spread rather than `usage: r.reported_usage ?? undefined`, so a row with
         // no rollup carries no `usage` KEY at all — absent, not present-and-undefined.
-        // The duration obeys the same rule, and it reads from its own column.
+        // The duration and the author obey the same rule, each from its own column.
+        // The creation time is unconditional: its column is NOT NULL, thus it has no
+        // absence to represent.
         const stored = await Promise.all(rows.map(async (r) => {
             const envelope = parseStoredMessageEnvelope(r.message_envelope, `${threadId}/${r.seq}`);
             const displayEnvelope = r.display_envelope == null ? undefined : await parseStoredDisplayEnvelope(r.display_envelope, `${threadId}/${r.seq}/display`, logger);
@@ -384,6 +395,8 @@ export function createThreadHistory(pool, logger) {
                 ...(displayEnvelope ? { displayEnvelope } : {}),
                 ...(r.reported_usage === null ? {} : { usage: r.reported_usage }),
                 ...(r.turn_duration_ms === null ? {} : { durationMs: Number(r.turn_duration_ms) }),
+                ...(r.author === null ? {} : { author: r.author }),
+                createdAt: r.created_at,
             };
         }));
         return groupTurns(stored, (row) => isGenuineUserStart(row.message));

package/dist/state/init.js

@@ -270,6 +270,13 @@ CREATE INDEX IF NOT EXISTS idx_cortex_regulatory_chunks_metadata
 -- Nullable with no default: absent means that nobody measured the turn, and a
 -- zero would claim that a turn took no time. A row written before this column
 -- existed is absent for the same reason, thus the migration needs no backfill.
+--
+-- author names the identity that sent the user message of a turn, as the host
+-- knew it at the append site. It is written on the genuine-user-start row of an
+-- append only -- the row that carries display_envelope -- and never on an
+-- assistant, tool, or synthetic row. Nullable with no default and no backfill:
+-- absent means that no sender was recorded, which is the honest value both for a
+-- row that predates the column and for a turn appended without one.
 CREATE TABLE IF NOT EXISTS messages (
   thread_id     TEXT NOT NULL,
   seq           BIGINT NOT NULL,
@@ -282,6 +289,7 @@ CREATE TABLE IF NOT EXISTS messages (
   tokens        INTEGER NOT NULL,
   reported_usage JSONB,
   turn_duration_ms BIGINT,
+  author        TEXT,
   created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
   PRIMARY KEY (thread_id, seq)
 );
@@ -547,6 +555,9 @@ export async function initCortexState(pool, injected) {
                 // and every earlier message reads back with no duration — which is the
                 // honest value, because nobody measured those turns.
                 "ALTER TABLE messages ADD COLUMN IF NOT EXISTS turn_duration_ms BIGINT",
+                // Who sent the user message of the turn (see the CREATE TABLE comment).
+                // Purely additive: nullable with no default, thus the column rewrites no row.
+                "ALTER TABLE messages ADD COLUMN IF NOT EXISTS author TEXT",
                 // Demote an existing JSONB envelope column to JSON (see the CREATE
                 // TABLE comment). Type-guarded because ALTER ... TYPE rewrites the
                 // whole table and this runs at every boot; scoped to

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.36.4",
+    "version": "0.37.0",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",