Two Patterns That Govern Everything Your Bot Does (Grace Window, Verify-Before-Use)

// The two patterns as small reusable primitives.

// -- 1) Grace window: schedule a send, allow override during the window.
type GraceJob = {
  id: string;
  draft: string;
  target: string;
  scheduledFor: Date;
  status: "pending" | "sent" | "canceled" | "edited";
};

const queue = new Map<string, GraceJob>();

function scheduleGraceSend(job: Omit<GraceJob, "id" | "status">) {
  const id = crypto.randomUUID();
  const fullJob: GraceJob = { ...job, id, status: "pending" };
  queue.set(id, fullJob);
  const delayMs = job.scheduledFor.getTime() - Date.now();
  setTimeout(async () => {
    const current = queue.get(id);
    if (!current || current.status !== "pending") return; // overridden
    await sendMessage(current.target, current.draft);
    current.status = "sent";
  }, delayMs);
  return id;
}

function overrideGraceJob(id: string, action: "cancel" | "edit", newDraft?: string) {
  const job = queue.get(id);
  if (!job || job.status !== "pending") throw new Error("Not overridable");
  if (action === "cancel") job.status = "canceled";
  if (action === "edit" && newDraft) { job.draft = newDraft; job.status = "edited"; }
}

// -- 2) Verify-before-use: mark memory authoritative only after explicit accept.
type Memory = {
  id: string;
  content: string;
  source: string;
  verified: boolean;
  verifiedAt?: Date;
};

async function proposeMemory(content: string, source: string): Promise<Memory> {
  const mem: Memory = { id: crypto.randomUUID(), content, source, verified: false };
  await db.memories.insert(mem);
  await notifyForApproval(mem);
  return mem;
}

async function acceptMemory(id: string, edited?: string) {
  await db.memories.update(id, {
    content: edited ?? undefined,
    verified: true,
    verifiedAt: new Date(),
  });
}

// Retrieval later prefers verified memory; falls back to unverified with a hedge.
async function retrieve(query: string) {
  const results = await db.memories.search(query);
  return results.map(r => ({
    ...r,
    confidence: r.verified ? "high" : "hedge",
  }));
}

async function sendMessage(target: string, draft: string): Promise<void> {}
async function notifyForApproval(mem: Memory): Promise<void> {}
declare const db: any;