agent-mockingbird 0.0.1

package/packages/agent-mockingbird-installer/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@waffleophagus/agent-mockingbird-installer",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "description": "Compatibility wrapper for installing and running Agent Mockingbird from npm.",
+  "homepage": "https://github.com/waffleophagus/agent-mockingbird",
+  "bugs": {
+    "url": "https://github.com/waffleophagus/agent-mockingbird/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/waffleophagus/agent-mockingbird.git"
+  },
+  "bin": {
+    "agent-mockingbird-installer": "bin/agent-mockingbird-installer.mjs"
+  },
+  "files": [
+    "bin",
+    "opencode.lock.json",
+    "README.md"
+  ]
+}

package/packages/contracts/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@agent-mockingbird/contracts",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./agentTypes": "./src/agentTypes.ts",
+    "./cron": "./src/cron.ts",
+    "./dashboard": "./src/dashboard.ts"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
+}

package/packages/contracts/src/agentTypes.ts

@@ -0,0 +1,122 @@
+export type AgentTypeMode = "subagent" | "primary" | "all";
+export type LegacySpecialistStatus = "available" | "busy" | "offline";
+
+export interface LegacySpecialistAgentLike {
+  id: string;
+  name: string;
+  specialty: string;
+  summary: string;
+  model: string;
+  status: LegacySpecialistStatus;
+}
+
+export interface AgentTypeDefinitionLike {
+  id: string;
+  name?: string;
+  description?: string;
+  prompt?: string;
+  model?: string;
+  variant?: string;
+  mode: AgentTypeMode;
+  hidden: boolean;
+  disable: boolean;
+  temperature?: number;
+  topP?: number;
+  steps?: number;
+  permission?: Record<string, unknown>;
+  options: Record<string, unknown>;
+}
+
+const LEGACY_DEFAULT_SPECIALTY = "General";
+const LEGACY_DEFAULT_SUMMARY = "General assistant tasks.";
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function normalizeAgentTypeMode(value: unknown): AgentTypeMode {
+  if (value === "subagent" || value === "primary" || value === "all") {
+    return value;
+  }
+  return "subagent";
+}
+
+export function normalizeLegacySpecialistStatus(value: unknown): LegacySpecialistStatus {
+  if (value === "available" || value === "busy" || value === "offline") {
+    return value;
+  }
+  return "available";
+}
+
+export function normalizeAgentTypeDraft(agentType: AgentTypeDefinitionLike): AgentTypeDefinitionLike {
+  return {
+    ...agentType,
+    id: agentType.id.trim(),
+    name: agentType.name?.trim() || undefined,
+    description: agentType.description?.trim() || undefined,
+    prompt: agentType.prompt?.trim() || undefined,
+    model: agentType.model?.trim() || undefined,
+    variant: agentType.variant?.trim() || undefined,
+    mode: normalizeAgentTypeMode(agentType.mode),
+    hidden: agentType.hidden === true,
+    disable: agentType.disable === true,
+    options: isPlainObject(agentType.options) ? { ...agentType.options } : {},
+  };
+}
+
+export function normalizeAgentTypeList(agentTypes: AgentTypeDefinitionLike[]) {
+  const deduped = new Map<string, AgentTypeDefinitionLike>();
+  for (const rawType of agentTypes) {
+    const normalized = normalizeAgentTypeDraft(rawType);
+    if (!normalized.id) continue;
+    deduped.set(normalized.id, normalized);
+  }
+  return [...deduped.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export function normalizeLegacySpecialistAgents(agents: LegacySpecialistAgentLike[]) {
+  const deduped = new Map<string, LegacySpecialistAgentLike>();
+  for (const rawAgent of agents) {
+    const id = rawAgent.id.trim();
+    if (!id) continue;
+    deduped.set(id, {
+      id,
+      name: rawAgent.name.trim() || id,
+      specialty: rawAgent.specialty.trim() || LEGACY_DEFAULT_SPECIALTY,
+      summary: rawAgent.summary.trim() || LEGACY_DEFAULT_SUMMARY,
+      model: rawAgent.model.trim(),
+      status: normalizeLegacySpecialistStatus(rawAgent.status),
+    });
+  }
+  return [...deduped.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export function legacySpecialistToAgentType(agent: LegacySpecialistAgentLike): AgentTypeDefinitionLike {
+  return {
+    id: agent.id.trim(),
+    name: agent.name.trim() || undefined,
+    description: agent.specialty.trim() || undefined,
+    prompt: agent.summary.trim() || undefined,
+    model: agent.model.trim() || undefined,
+    mode: "subagent",
+    hidden: false,
+    disable: agent.status === "offline",
+    options: {
+      agentMockingbirdManagedLegacy: true,
+      agentMockingbirdDisplayName: agent.name.trim(),
+      agentMockingbirdStatus: agent.status,
+    },
+  };
+}
+
+export function agentTypeToLegacySpecialist(agentType: AgentTypeDefinitionLike): LegacySpecialistAgentLike {
+  const normalized = normalizeAgentTypeDraft(agentType);
+  return {
+    id: normalized.id,
+    name: normalized.name || normalized.id,
+    specialty: normalized.description || LEGACY_DEFAULT_SPECIALTY,
+    summary: normalized.prompt || LEGACY_DEFAULT_SUMMARY,
+    model: normalized.model || "",
+    status: normalized.disable ? "offline" : "available",
+  };
+}

package/packages/contracts/src/cron.ts

@@ -0,0 +1,146 @@
+export type CronScheduleKind = "at" | "every" | "cron";
+export type CronRunMode = "background" | "conditional_agent" | "agent";
+
+export type CronJobState = "queued" | "leased" | "running" | "completed" | "failed" | "dead";
+export type CronStepStatus = "pending" | "running" | "completed" | "failed" | "skipped";
+export type CronStepKind = "background" | "conditional_agent" | "agent";
+
+export interface CronJobDefinition {
+  id: string;
+  name: string;
+  enabled: boolean;
+  scheduleKind: CronScheduleKind;
+  scheduleExpr: string | null;
+  everyMs: number | null;
+  atIso: string | null;
+  timezone: string | null;
+  runMode: CronRunMode;
+  conditionModulePath: string | null;
+  conditionDescription: string | null;
+  agentPromptTemplate: string | null;
+  agentModelOverride: string | null;
+  maxAttempts: number;
+  retryBackoffMs: number;
+  payload: Record<string, unknown>;
+  lastEnqueuedFor: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CronJobInstance {
+  id: string;
+  jobDefinitionId: string;
+  scheduledFor: string;
+  agentInvoked: boolean;
+  state: CronJobState;
+  attempt: number;
+  nextAttemptAt: string | null;
+  leaseOwner: string | null;
+  leaseExpiresAt: string | null;
+  lastHeartbeatAt: string | null;
+  resultSummary: string | null;
+  error: unknown;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CronJobStep {
+  id: string;
+  jobInstanceId: string;
+  stepKind: CronStepKind;
+  status: CronStepStatus;
+  input: unknown;
+  output: unknown;
+  error: unknown;
+  startedAt: string | null;
+  finishedAt: string | null;
+  createdAt: string;
+}
+
+export interface CronHealthSnapshot {
+  enabled: boolean;
+  schedulerPollMs: number;
+  workerPollMs: number;
+  leaseMs: number;
+  jobs: {
+    total: number;
+    enabled: number;
+  };
+  instances: {
+    queued: number;
+    leased: number;
+    running: number;
+    completed: number;
+    failed: number;
+    dead: number;
+  };
+}
+
+export interface CronJobCreateInput {
+  id?: string;
+  name: string;
+  enabled?: boolean;
+  scheduleKind: CronScheduleKind;
+  scheduleExpr?: string | null;
+  everyMs?: number | null;
+  atIso?: string | null;
+  timezone?: string | null;
+  runMode: CronRunMode;
+  conditionModulePath?: string | null;
+  conditionDescription?: string | null;
+  agentPromptTemplate?: string | null;
+  agentModelOverride?: string | null;
+  maxAttempts?: number;
+  retryBackoffMs?: number;
+  payload?: Record<string, unknown>;
+}
+
+export interface CronJobPatchInput {
+  name?: string;
+  enabled?: boolean;
+  scheduleKind?: CronScheduleKind;
+  scheduleExpr?: string | null;
+  everyMs?: number | null;
+  atIso?: string | null;
+  timezone?: string | null;
+  runMode?: CronRunMode;
+  conditionModulePath?: string | null;
+  conditionDescription?: string | null;
+  agentPromptTemplate?: string | null;
+  agentModelOverride?: string | null;
+  maxAttempts?: number;
+  retryBackoffMs?: number;
+  payload?: Record<string, unknown>;
+}
+
+export interface CronHandlerContext {
+  nowMs: number;
+  payload: Record<string, unknown>;
+  job: CronJobDefinition;
+  instance: CronJobInstance;
+}
+
+export interface CronHandlerResult {
+  status: "ok" | "error";
+  summary?: string;
+  data?: unknown;
+  invokeAgent?: {
+    shouldInvoke: boolean;
+    prompt?: string;
+    context?: Record<string, unknown>;
+    severity?: "info" | "warn" | "critical";
+  };
+}
+
+export type CronHandler = (ctx: CronHandlerContext) => Promise<CronHandlerResult> | CronHandlerResult;
+
+export interface CronConditionalModuleContext {
+  nowMs: number;
+  payload: Record<string, unknown>;
+  job: CronJobDefinition;
+  instance: CronJobInstance;
+}
+
+export type CronConditionalModule = (
+  ctx: CronConditionalModuleContext,
+) => Promise<CronHandlerResult> | CronHandlerResult;

package/packages/contracts/src/dashboard.ts

@@ -0,0 +1,378 @@
+export type ChatRole = "user" | "assistant";
+
+export interface MemoryToolCallTrace {
+  tool: string;
+  status: "pending" | "running" | "completed" | "error";
+  summary?: string;
+  error?: string;
+}
+
+export interface MessageMemoryTrace {
+  mode: "hybrid" | "inject_only" | "tool_only";
+  injectedContextResults: number;
+  retrievedContextResults?: number;
+  suppressedAsAlreadyInContext?: number;
+  suppressedAsIrrelevant?: number;
+  toolCalls: MemoryToolCallTrace[];
+  createdAt: string;
+}
+
+export type ChatToolCallStatus = "pending" | "running" | "completed" | "error";
+
+export interface ChatThinkingPart {
+  id: string;
+  type: "thinking";
+  text: string;
+  startedAt?: string;
+  endedAt?: string;
+  observedAt?: string;
+}
+
+export interface ChatToolCallPart {
+  id: string;
+  type: "tool_call";
+  toolCallId: string;
+  tool: string;
+  status: ChatToolCallStatus;
+  input?: Record<string, unknown>;
+  output?: string;
+  error?: string;
+  startedAt?: string;
+  endedAt?: string;
+  observedAt?: string;
+}
+
+export type ChatMessagePart = ChatThinkingPart | ChatToolCallPart;
+
+export interface ChatMessage {
+  id: string;
+  role: ChatRole;
+  content: string;
+  at: string;
+  memoryTrace?: MessageMemoryTrace;
+  parts?: ChatMessagePart[];
+}
+
+export interface SessionMessageCheckpoint {
+  lastMessageAt: string;
+  lastMessageId: string;
+}
+
+export interface SessionMessageCursor {
+  at: string;
+  role: ChatRole;
+  id: string;
+}
+
+export interface SessionMessageWindowMeta {
+  oldestLoaded: SessionMessageCursor | null;
+  newestLoaded: SessionMessageCursor | null;
+  hasOlder: boolean;
+  totalMessages: number;
+  isWindowed: boolean;
+}
+
+export interface SessionMessagesDeltaResponse {
+  messages: ChatMessage[];
+  checkpoint: SessionMessageCheckpoint | null;
+  requiresReset?: boolean;
+}
+
+export interface SessionMessagesWindowResponse {
+  messages: ChatMessage[];
+  meta: SessionMessageWindowMeta;
+}
+
+export interface SessionSummary {
+  id: string;
+  title: string;
+  model: string;
+  status: "active" | "idle";
+  lastActiveAt: string;
+  messageCount: number;
+}
+
+export interface ModelOption {
+  id: string;
+  label: string;
+  providerId: string;
+  modelId: string;
+  supportsImageInput?: boolean;
+}
+
+export interface SpecialistAgent {
+  id: string;
+  name: string;
+  specialty: string;
+  summary: string;
+  model: string;
+  status: "available" | "busy" | "offline";
+}
+
+export interface AgentTypeDefinition {
+  id: string;
+  name?: string;
+  description?: string;
+  prompt?: string;
+  model?: string;
+  variant?: string;
+  mode: "subagent" | "primary" | "all";
+  hidden: boolean;
+  disable: boolean;
+  temperature?: number;
+  topP?: number;
+  steps?: number;
+  permission?: Record<string, unknown>;
+  options: Record<string, unknown>;
+}
+
+export interface RuntimeSkill {
+  id: string;
+  name: string;
+  description: string;
+  location: string;
+  enabled: boolean;
+  managed: boolean;
+}
+
+export interface RuntimeSkillIssue {
+  id?: string;
+  location: string;
+  reason: string;
+}
+
+export type RuntimeMcpStatus =
+  | "connected"
+  | "disabled"
+  | "failed"
+  | "needs_auth"
+  | "needs_client_registration"
+  | "unknown";
+
+export interface RuntimeMcp {
+  id: string;
+  enabled: boolean;
+  status: RuntimeMcpStatus;
+  error?: string;
+}
+
+export interface RuntimeAgent {
+  id: string;
+  mode: "subagent" | "primary" | "all";
+  description?: string;
+  model?: string;
+  native: boolean;
+  hidden: boolean;
+  enabled: boolean;
+}
+
+export type ConfiguredMcpServer =
+  | {
+      id: string;
+      type: "remote";
+      enabled: boolean;
+      url: string;
+      headers: Record<string, string>;
+      oauth: "auto" | "off";
+      timeoutMs?: number;
+    }
+  | {
+      id: string;
+      type: "local";
+      enabled: boolean;
+      command: string[];
+      environment: Record<string, string>;
+      timeoutMs?: number;
+    };
+
+export interface UsageSnapshot {
+  requestCount: number;
+  inputTokens: number;
+  outputTokens: number;
+  estimatedCostUsd: number;
+}
+
+export interface SessionRunStatusSnapshot {
+  sessionId: string;
+  status: "idle" | "busy" | "retry";
+  attempt?: number;
+  message?: string;
+  nextAt?: string;
+}
+
+export interface SessionCompactedSnapshot {
+  sessionId: string;
+}
+
+export interface SessionRunErrorSnapshot {
+  sessionId: string | null;
+  name?: string;
+  message: string;
+}
+
+export interface PermissionPromptRequest {
+  id: string;
+  sessionId: string;
+  permission: string;
+  patterns: string[];
+  metadata: Record<string, unknown>;
+  always: string[];
+}
+
+export interface PermissionPromptResolved {
+  sessionId: string;
+  requestId: string;
+  reply: "once" | "always" | "reject";
+}
+
+export interface QuestionPromptOption {
+  label: string;
+  description: string;
+}
+
+export interface QuestionPromptInfo {
+  question: string;
+  header: string;
+  options: QuestionPromptOption[];
+  multiple?: boolean;
+  custom?: boolean;
+}
+
+export interface QuestionPromptRequest {
+  id: string;
+  sessionId: string;
+  questions: QuestionPromptInfo[];
+}
+
+export interface QuestionPromptResolved {
+  sessionId: string;
+  requestId: string;
+  outcome: "replied" | "rejected";
+}
+
+export interface SessionMessageDeltaSnapshot {
+  sessionId: string;
+  messageId: string;
+  text: string;
+  mode: "append" | "replace";
+  observedAt: string;
+}
+
+export interface BackgroundRunSnapshot {
+  runId: string;
+  parentSessionId: string;
+  parentExternalSessionId: string;
+  childExternalSessionId: string;
+  childSessionId: string | null;
+  requestedBy: string;
+  prompt: string;
+  status: "created" | "running" | "retrying" | "idle" | "completed" | "failed" | "aborted";
+  resultSummary: string | null;
+  error: string | null;
+  createdAt: string;
+  updatedAt: string;
+  startedAt: string | null;
+  completedAt: string | null;
+}
+
+export type SessionMessagePartPhase = "start" | "update" | "final";
+
+export interface HeartbeatSnapshot {
+  online: boolean;
+  at: string;
+}
+
+export interface MemoryStatusSnapshot {
+  enabled: boolean;
+  workspaceDir: string;
+  provider: string;
+  model: string;
+  toolMode: "hybrid" | "inject_only" | "tool_only";
+  files: number;
+  chunks: number;
+  records: number;
+  cacheEntries: number;
+  indexedAt: string | null;
+}
+
+export interface MemoryWriteEvent {
+  id: string;
+  status: "accepted" | "rejected";
+  reason: string;
+  source: "user" | "assistant" | "system";
+  content: string;
+  confidence: number;
+  sessionId: string | null;
+  topic: string | null;
+  recordId: string | null;
+  path: string | null;
+  createdAt: string;
+}
+
+export interface DashboardBootstrap {
+  sessions: SessionSummary[];
+  skills: string[];
+  mcps: string[];
+  agents: SpecialistAgent[];
+  usage: UsageSnapshot;
+  heartbeat: HeartbeatSnapshot;
+}
+
+export interface SessionScreenBootstrapResponse {
+  sessions: SessionSummary[];
+  activeSessionId: string;
+  activeSession: SessionSummary | null;
+  messages: ChatMessage[];
+  messagesMeta?: SessionMessageWindowMeta;
+  usage: UsageSnapshot;
+  heartbeat: HeartbeatSnapshot;
+  models: ModelOption[];
+  backgroundRuns: BackgroundRunSnapshot[];
+  pendingPermissions?: PermissionPromptRequest[];
+  pendingQuestions?: QuestionPromptRequest[];
+  workspaceBootstrap?: {
+    mode?: string;
+    identity?: {
+      name?: string;
+      emoji?: string;
+      theme?: string;
+      creature?: string;
+      vibe?: string;
+      avatar?: string;
+    };
+    files?: Array<{
+      name: string;
+      missing: boolean;
+      truncated: boolean;
+    }>;
+  };
+  featureFlags?: {
+    reviewEnabled?: boolean;
+  };
+}
+
+export type DashboardEvent =
+  | { event: "heartbeat"; payload: HeartbeatSnapshot }
+  | { event: "usage"; payload: UsageSnapshot }
+  | { event: "session-updated"; payload: SessionSummary }
+  | { event: "session-message"; payload: { sessionId: string; message: ChatMessage } }
+  | {
+      event: "session-message-part";
+      payload: {
+        sessionId: string;
+        messageId: string;
+        part: ChatMessagePart;
+        phase: SessionMessagePartPhase;
+        observedAt: string;
+      };
+    }
+  | { event: "session-message-delta"; payload: SessionMessageDeltaSnapshot }
+  | { event: "session-status"; payload: SessionRunStatusSnapshot }
+  | { event: "session-compacted"; payload: SessionCompactedSnapshot }
+  | { event: "session-error"; payload: SessionRunErrorSnapshot }
+  | { event: "permission-requested"; payload: PermissionPromptRequest }
+  | { event: "permission-resolved"; payload: PermissionPromptResolved }
+  | { event: "question-requested"; payload: QuestionPromptRequest }
+  | { event: "question-resolved"; payload: QuestionPromptResolved }
+  | { event: "background-run"; payload: BackgroundRunSnapshot }
+  | { event: "skills-catalog-updated"; payload: { revision: string } };

package/packages/contracts/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./agentTypes";
+export * from "./cron";
+export * from "./dashboard";

package/packages/contracts/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}