Your AI must work
continuously, governed
by your rules, not
prompts

Event Source (calendar / email / API trigger)
       │
       ▼
Perception Layer  ──→  normalize to EventSchema
       │
       ▼
Memory Layer  ──→  enrich with context + history
       │
       ▼
Governance Engine  ──→  evaluate against PolicyRules
       │
       ├── APPROVED  ──→  Execution Layer  ──→  Action
       ├── DEFERRED  ──→  Queue for human review
       └── BLOCKED   ──→  Audit log + notification

// server/routers.ts — tRPC procedure example
export const appRouter = router({
  // Public procedures — no auth required
  waitlist: router({
    join: publicProcedure
      .input(z.object({ email: z.string().email() }))
      .mutation(async ({ input }) => { /* ... */ }),
  }),

  // Protected procedures — requires valid session
  memory: router({
    getContext: protectedProcedure
      .query(async ({ ctx }) => {
        return await getConstitutionalMemory(ctx.user.id);
      }),
  }),
});

interface ConstitutionalMemory {
  // Tier 1: Constitutional — immutable core
  constitution: {
    values: string[];          // "privacy-first", "async-by-default"
    goals: Goal[];             // long-term objectives with deadlines
    constraints: Constraint[]; // hard limits that cannot be overridden
  };

  // Tier 2: Episodic — interaction history
  episodes: Episode[];         // timestamped interaction records
  
  // Tier 3: Semantic — extracted knowledge
  facts: Fact[];               // subject-predicate-object triples
  relationships: Relation[];   // entity graph

  // Metadata
  version: number;             // monotonically increasing
  checksum: string;            // SHA-256 of canonical JSON
  createdAt: Date;
  updatedAt: Date;
}

// Writing to memory — creates new version
const newVersion = await memory.write({
  type: "goal",
  content: {
    id: "goal_001",
    title: "Ship Zero AI v1.0",
    deadline: new Date("2026-06-30"),
    priority: "high",
  },
  source: "user_input",
  confidence: 1.0,
});

// Reading — always returns latest unless version specified
const current = await memory.read({ type: "goals" });
const historical = await memory.read({ type: "goals", version: 12 });

// Rollback to previous version
await memory.rollback({ targetVersion: 12, reason: "Incorrect goal added" });

// Policy definition example
const emailPolicy: Policy = {
  id: "pol_email_001",
  name: "Email Response Governance",
  version: 3,
  
  // Conditions that trigger this policy
  triggers: [
    { event: "email.received", filter: { from: "!internal" } }
  ],
  
  // Rules evaluated in order — first match wins
  rules: [
    {
      condition: "email.priority === 'urgent' && email.from.isKnownContact",
      action: "respond",
      template: "urgent_response",
      requireApproval: false,   // auto-execute
    },
    {
      condition: "email.containsLegalLanguage",
      action: "defer",
      reason: "Legal review required",
      notifyOwner: true,
    },
    {
      condition: "true",         // default fallback
      action: "queue",
      reviewWithin: "24h",
    },
  ],
  
  // Audit configuration
  audit: {
    logLevel: "full",
    retentionDays: 90,
  },
};

// Governance decision types
type GovernanceDecision =
  | { outcome: "APPROVED"; action: ExecutableAction; confidence: number }
  | { outcome: "DEFERRED"; reason: string; reviewBy: Date }
  | { outcome: "BLOCKED"; reason: string; policyId: string }
  | { outcome: "MODIFIED"; original: Action; modified: ExecutableAction };

// Evaluating an action
const decision = await governanceEngine.evaluate({
  proposedAction: {
    type: "send_message",
    channel: "email",
    recipient: "[email protected]",
    content: draftContent,
  },
  context: await memory.read({ type: "current_context" }),
  userId: ctx.user.id,
});

if (decision.outcome === "APPROVED") {
  await executionLayer.run(decision.action);
  await auditLog.record(decision);
}

interface AuditEntry {
  id: string;                    // UUID v4
  timestamp: Date;               // UTC
  eventId: string;               // source event reference
  policyId: string;              // policy that was applied
  decision: GovernanceDecision;  // full decision object
  executionResult?: ActionResult; // if APPROVED and executed
  receipt: string;               // SHA-256(id + timestamp + decision)
  userId: string;
}

-- Users table (managed by Manus OAuth)
CREATE TABLE users (
  id          INT PRIMARY KEY AUTO_INCREMENT,
  open_id     VARCHAR(255) UNIQUE NOT NULL,
  name        VARCHAR(255),
  avatar      TEXT,
  role        ENUM('admin', 'user') DEFAULT 'user',
  created_at  BIGINT NOT NULL  -- UTC milliseconds
);

-- Waitlist table
CREATE TABLE waitlist (
  id          INT PRIMARY KEY AUTO_INCREMENT,
  email       VARCHAR(255) UNIQUE NOT NULL,
  name        VARCHAR(128),
  role        ENUM('Founder','Operator','Creator','Builder'),
  message     TEXT,
  status      ENUM('pending','approved','rejected') DEFAULT 'pending',
  created_at  BIGINT NOT NULL
);

-- Memory entries (Phase 2)
CREATE TABLE memory_entries (
  id          INT PRIMARY KEY AUTO_INCREMENT,
  user_id     INT NOT NULL REFERENCES users(id),
  tier        ENUM('constitutional','episodic','semantic') NOT NULL,
  type        VARCHAR(64) NOT NULL,
  content     JSON NOT NULL,
  version     INT NOT NULL DEFAULT 1,
  checksum    VARCHAR(64) NOT NULL,
  source      VARCHAR(128),
  confidence  FLOAT DEFAULT 1.0,
  created_at  BIGINT NOT NULL
);

// Client-side: get login URL
import { getLoginUrl } from "@/const";
window.location.href = getLoginUrl("/dashboard");

// Server-side: access authenticated user
// In any protectedProcedure:
const user = ctx.user; // { id, openId, name, avatar, role }

// Logout
const logout = trpc.auth.logout.useMutation({
  onSuccess: () => window.location.href = "/",
});

// Send a message to Zero AI persona
const chat = trpc.ai.chat.useMutation();

await chat.mutateAsync({
  messages: [
    { role: "user", content: "What is Constitutional Memory?" },
    { role: "assistant", content: "Constitutional Memory is..." },
    { role: "user", content: "How does versioning work?" },
  ],
});
// Returns: { content: string }