feat(memory): Postgres v0.8.0 multi-agent migration for zeroclaw-labs#6272 (P6b)

Mirrors the SQLite migration from P6a, but PG-flavored: idempotent
via ADD COLUMN IF NOT EXISTS / CREATE INDEX IF NOT EXISTS / ON
CONFLICT DO NOTHING, default-agent UUID generated in Rust and
bound as a parameter, backfill in the same init pass via a
parameterized UPDATE.

Schema (matches SQLite path so cross-DB code stays one shape):

- {schema}.agents: id TEXT PRIMARY KEY, alias TEXT NOT NULL UNIQUE,
  created_at TIMESTAMPTZ NOT NULL.
- {qualified_table}.agent_id TEXT, indexed. Nullable at the DB
  layer matching SQLite; the AgentScopedMemory<M> wrapper in P7
  enforces non-null at write time.

Wired into PostgresMemory::initialize_client right after init_schema
so every fresh connection is fully migrated before
try_enable_pgvector runs (which can fail safely on pgvector
absence).

Backups: operator's responsibility for Postgres. The binary cannot
reach across the network to dump a managed cluster, so we do not
take a file-copy backup the way SQLite does. Documented.

Concurrent first-init: INSERT...ON CONFLICT (alias) DO NOTHING
plus a follow-up SELECT means concurrent initializers from
different processes converge on the same default agent UUID
(whichever insert wins is the persisted row).

Tests: skipped in this commit. Existing Postgres tests in the
crate are gated behind the memory-postgres feature and require a
running Postgres for execution; CI does not provision one.
Cross-DB parity tests for the migration land alongside any
test-container support in a follow-up. The code path is a direct
mirror of P6a's tested SQLite path so confidence is reasonable.

Lucid (the third backend) wraps SqliteMemory for its local store,
so P6a's migration runs automatically when Lucid initializes; no
separate Lucid migration code is needed for v0.8.0. The external
Lucid CLI wire format for cross-agent scoping stays deferred to
v0.8.1 per the plan.

V2->V3 migration extension: the existing
synthesize_default_agent_if_needed helper in
crates/zeroclaw-config/src/schema/v2.rs already inserts the
default agent's config-side row; the DB-side migration creates
the matching agents-table row independently. Both arrive at
"there is a default agent" without coordination; runtime resolves
the UUID by alias when AgentScopedMemory<M> is constructed in P7.

Refs zeroclaw-labs#6272.

Author: singlerider

crates/zeroclaw-memory/src/postgres.rs

@@ -106,6 +106,11 @@ impl PostgresMemory {
                     .context("failed to connect to PostgreSQL memory backend")?;
 
                 Self::init_schema(&mut client, &schema_ident, &qualified_table)?;
+                Self::migrate_v0_8_0_multi_agent(
+                    &mut client,
+                    &schema_ident,
+                    &qualified_table,
+                )?;
                 Ok(client)
             })
             .context("failed to spawn PostgreSQL initializer thread")?;
@@ -115,6 +120,84 @@ impl PostgresMemory {
             .map_err(|_| anyhow::anyhow!("PostgreSQL initializer thread panicked"))?
     }
 
+    /// v0.8.0 multi-agent DB migration for the Postgres backend (#6272 P6).
+    ///
+    /// Adds the `agents` table and the `agent_id` column on the
+    /// memories table, with a default-agent backfill. Idempotent: every
+    /// step uses `IF NOT EXISTS` / `ON CONFLICT DO NOTHING` so re-runs
+    /// are no-ops.
+    ///
+    /// Backups are the operator's responsibility for Postgres
+    /// (documented in the release notes); we cannot reach across the
+    /// network to dump a managed cluster from inside the binary.
+    /// The default-agent UUID is generated in Rust so it has the same
+    /// shape as SQLite/Lucid (TEXT, lowercase hyphenated).
+    fn migrate_v0_8_0_multi_agent(
+        client: &mut Client,
+        schema_ident: &str,
+        qualified_table: &str,
+    ) -> Result<()> {
+        let qualified_agents = format!("{schema_ident}.agents");
+
+        // Create the agents table. Same shape as the SQLite migration:
+        // TEXT primary key for cross-DB UUID portability, alias UNIQUE
+        // for human reference and rename surface, created_at audit.
+        client.batch_execute(&format!(
+            "
+            CREATE TABLE IF NOT EXISTS {qualified_agents} (
+                id          TEXT PRIMARY KEY,
+                alias       TEXT NOT NULL UNIQUE,
+                created_at  TIMESTAMPTZ NOT NULL
+            );
+            "
+        ))?;
+
+        // Insert the default agent if absent. The Rust-side UUID is
+        // bound as a parameter so the row that ends up persisted has
+        // the same shape as the SQLite path.
+        let candidate_uuid = uuid::Uuid::new_v4().to_string();
+        client.execute(
+            &format!(
+                "INSERT INTO {qualified_agents} (id, alias, created_at)
+                 VALUES ($1, 'default', NOW())
+                 ON CONFLICT (alias) DO NOTHING"
+            ),
+            &[&candidate_uuid],
+        )?;
+
+        // Read back whatever row actually persisted so the backfill
+        // points at the canonical default-agent UUID even on
+        // concurrent first-init.
+        let default_uuid: String = client
+            .query_one(
+                &format!("SELECT id FROM {qualified_agents} WHERE alias = 'default' LIMIT 1"),
+                &[],
+            )?
+            .get(0);
+
+        // ALTER memories ADD COLUMN agent_id, backfill, index. Postgres
+        // accepts ADD COLUMN IF NOT EXISTS (since 9.6) and the
+        // CREATE INDEX IF NOT EXISTS (since 9.5), so the whole block is
+        // safely idempotent on every supported PG version. The
+        // default-agent UUID is bound rather than inlined to dodge any
+        // SQL-injection footgun even though uuid_v4 strings are
+        // hex+hyphens.
+        client.batch_execute(&format!(
+            "
+            ALTER TABLE {qualified_table} ADD COLUMN IF NOT EXISTS agent_id TEXT;
+            CREATE INDEX IF NOT EXISTS idx_memories_agent_id ON {qualified_table}(agent_id);
+            "
+        ))?;
+        client.execute(
+            &format!(
+                "UPDATE {qualified_table} SET agent_id = $1 WHERE agent_id IS NULL"
+            ),
+            &[&default_uuid],
+        )?;
+
+        Ok(())
+    }
+
     fn init_schema(client: &mut Client, schema_ident: &str, qualified_table: &str) -> Result<()> {
         client.batch_execute(&format!(
             "