@mgsoftwarebv/mg-dashboard-mcp 7.4.8 → 7.4.10

package/dist/index.js

@@ -20,7 +20,7 @@ import { sql } from 'drizzle-orm';
 import { once } from 'events';
 import { lookup } from 'dns/promises';
 import { connect } from 'tls';
-import { pgTable, timestamp, jsonb, uuid, boolean, text, pgEnum, integer, uniqueIndex, index, check, bigint, doublePrecision, foreignKey } from 'drizzle-orm/pg-core';
+import { pgTable, timestamp, uuid, jsonb, boolean, text, pgEnum, integer, uniqueIndex, index, check, bigint, doublePrecision, primaryKey, foreignKey, date, real } from 'drizzle-orm/pg-core';
 import { HeadObjectCommand, ListObjectsV2Command, DeleteObjectsCommand, S3Client, DeleteObjectCommand, CreateMultipartUploadCommand, UploadPartCommand, CompleteMultipartUploadCommand, AbortMultipartUploadCommand, PutObjectCommand, GetObjectCommand, CopyObjectCommand } from '@aws-sdk/client-s3';
 
 var __defProp = Object.defineProperty;
@@ -703,10 +703,10 @@ var TRIGGER_TOOL_MODULE_MAP = {
   "trigger-env": "settings"
 };
 async function discoverInstance(projectSlug, conn, proxy, sshExec2) {
-  const sql28 = `SELECT re.\\"apiKey\\" || '~~' || p.\\"externalRef\\" FROM \\"RuntimeEnvironment\\" re JOIN \\"Project\\" p ON re.\\"projectId\\" = p.id WHERE p.slug='${projectSlug}' AND re.slug='prod' LIMIT 1`;
+  const sql29 = `SELECT re.\\"apiKey\\" || '~~' || p.\\"externalRef\\" FROM \\"RuntimeEnvironment\\" re JOIN \\"Project\\" p ON re.\\"projectId\\" = p.id WHERE p.slug='${projectSlug}' AND re.slug='prod' LIMIT 1`;
   const cmd = [
     `PORT=$(docker port "${WA_CONTAINER}" 3000/tcp 2>/dev/null | head -1 | sed 's/.*://')`,
-    `ROW=$(docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql28}" 2>/dev/null | tr -d '[:space:]')`,
+    `ROW=$(docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql29}" 2>/dev/null | tr -d '[:space:]')`,
     'echo "$PORT|$ROW"'
   ].join(" && ");
   const result = await sshExec2(conn, cmd, proxy);
@@ -728,8 +728,8 @@ async function discoverInstance(projectSlug, conn, proxy, sshExec2) {
   return { port, apiKey: apiKey2, projectRef: projectRef || "" };
 }
 async function fetchRunLogs(runId, conn, proxy, sshExec2) {
-  const sql28 = `SELECT level, message, \\"isError\\", \\"createdAt\\" FROM \\"TaskEvent\\" WHERE \\"runId\\" = '${runId}' AND level IN ('INFO','WARN','ERROR','DEBUG','LOG','TRACE') ORDER BY \\"startTime\\" ASC LIMIT 200`;
-  const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql28}" 2>/dev/null`;
+  const sql29 = `SELECT level, message, \\"isError\\", \\"createdAt\\" FROM \\"TaskEvent\\" WHERE \\"runId\\" = '${runId}' AND level IN ('INFO','WARN','ERROR','DEBUG','LOG','TRACE') ORDER BY \\"startTime\\" ASC LIMIT 200`;
+  const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql29}" 2>/dev/null`;
   const result = await sshExec2(conn, cmd, proxy);
   const output = result.stdout.trim();
   if (!output) return "";
@@ -811,8 +811,8 @@ async function handleTriggerTool(name, args2, deps) {
   switch (name) {
     // -----------------------------------------------------------------
     case "trigger-list": {
-      const sql28 = 'SELECT slug, name FROM \\"Project\\" ORDER BY name';
-      const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql28}" 2>/dev/null`;
+      const sql29 = 'SELECT slug, name FROM \\"Project\\" ORDER BY name';
+      const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql29}" 2>/dev/null`;
       const result = await sshExec2(conn, cmd, proxy);
       const output = result.stdout.trim();
       if (!output) {
@@ -990,9 +990,9 @@ ${raw2.substring(0, 500)}` }] };
           return { content: [{ type: "text", text: `No environment variables for ${project}/${env}.` }] };
         }
         const lines = vars.map((v) => `${v.isSecret ? "[secret]" : "        "}  ${v.name}`).sort();
-        const text13 = `Env vars for ${project}/${env} (${vars.length}) \u2014 values hidden, use action="get" with a key:
+        const text16 = `Env vars for ${project}/${env} (${vars.length}) \u2014 values hidden, use action="get" with a key:
 ` + "-".repeat(50) + "\n" + lines.join("\n");
-        return { content: [{ type: "text", text: text13 }] };
+        return { content: [{ type: "text", text: text16 }] };
       }
       if (action === "get") {
         const key2 = String(args2.key ?? "");
@@ -1079,9 +1079,9 @@ async function fetchAndFormatRun(conn, proxy, sshExec2, instance, runId) {
     return { content: [{ type: "text", text: `Invalid API response:
 ${rawJson.substring(0, 500)}` }] };
   }
-  let text13 = formatRunDetail(run);
-  if (logs) text13 += "\n\n--- Logs ---\n" + logs;
-  return { content: [{ type: "text", text: text13 }] };
+  let text16 = formatRunDetail(run);
+  if (logs) text16 += "\n\n--- Logs ---\n" + logs;
+  return { content: [{ type: "text", text: text16 }] };
 }
 async function waitForCompletion(conn, proxy, sshExec2, instance, runId, waitSeconds) {
   const pollInterval = 3e3;
@@ -1103,10 +1103,10 @@ async function waitForCompletion(conn, proxy, sshExec2, instance, runId, waitSec
       continue;
     }
     if (TERMINAL_STATUSES.has(run.status)) {
-      let text13 = formatRunDetail(run);
+      let text16 = formatRunDetail(run);
       const logs = await fetchRunLogs(runId, conn, proxy, sshExec2);
-      if (logs) text13 += "\n\n--- Logs ---\n" + logs;
-      return { content: [{ type: "text", text: text13 }] };
+      if (logs) text16 += "\n\n--- Logs ---\n" + logs;
+      return { content: [{ type: "text", text: text16 }] };
     }
   }
   return {
@@ -3793,10 +3793,10 @@ var ZodObject = class _ZodObject extends ZodType {
   //   }) as any;
   //   return merged;
   // }
-  catchall(index10) {
+  catchall(index13) {
     return new _ZodObject({
       ...this._def,
-      catchall: index10
+      catchall: index13
     });
   }
   pick(mask) {
@@ -4114,9 +4114,9 @@ function mergeValues(a, b) {
       return { valid: false };
     }
     const newArray = [];
-    for (let index10 = 0; index10 < a.length; index10++) {
-      const itemA = a[index10];
-      const itemB = b[index10];
+    for (let index13 = 0; index13 < a.length; index13++) {
+      const itemA = a[index13];
+      const itemB = b[index13];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
         return { valid: false };
@@ -4322,10 +4322,10 @@ var ZodMap = class extends ZodType {
     }
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
-    const pairs = [...ctx.data.entries()].map(([key, value], index10) => {
+    const pairs = [...ctx.data.entries()].map(([key, value], index13) => {
       return {
-        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index10, "key"])),
-        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index10, "value"]))
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index13, "key"])),
+        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index13, "value"]))
       };
     });
     if (ctx.common.async) {
@@ -5247,6 +5247,8 @@ var users = pgTable("user", {
   emailVerified: boolean("email_verified").notNull().default(false),
   roleId: uuid("role_id"),
   permissions: jsonb("permissions"),
+  /** Linked Refront user id (matched by email during refront-crm-sync). */
+  refrontUserId: uuid("refront_user_id"),
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
   updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
 });
@@ -6150,7 +6152,8 @@ var directorySubmissionStatus = pgEnum(
     "live",
     "rejected",
     "failed",
-    "manual"
+    "manual",
+    "captcha"
   ]
 );
 var directoryAccountStatus = pgEnum("directory_account_status", [
@@ -6194,6 +6197,8 @@ var linkBuildingClient = pgTable(
     refrontMailAccountId: text("refront_mail_account_id"),
     profile: jsonb("profile").$type().notNull().default({}),
     weeklyPace: integer("weekly_pace").notNull().default(12),
+    /** Target package size (number of directory backlinks sold). */
+    packageSize: integer("package_size").notNull().default(100),
     autoSubmit: boolean("auto_submit").notNull().default(false),
     startingDr: doublePrecision("starting_dr"),
     currentDr: doublePrecision("current_dr"),
@@ -6206,7 +6211,7 @@ var linkBuildingClient = pgTable(
     index("link_building_client_active_idx").on(table.isActive)
   ]
 );
-pgTable(
+var directorySubmission = pgTable(
   "directory_submission",
   {
     id: uuid("id").primaryKey().defaultRandom(),
@@ -6221,6 +6226,7 @@ pgTable(
     submittedAt: timestamp("submitted_at", { withTimezone: true }),
     verifiedAt: timestamp("verified_at", { withTimezone: true }),
     lastError: text("last_error"),
+    fixAttempts: integer("fix_attempts").notNull().default(0),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
   },
@@ -6277,6 +6283,78 @@ pgTable(
     index("directory_account_status_idx").on(table.status)
   ]
 );
+pgTable(
+  "link_building_agent_job",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    submissionId: uuid("submission_id").references(
+      () => directorySubmission.id,
+      { onDelete: "set null" }
+    ),
+    hostId: uuid("host_id").notNull(),
+    commandId: uuid("command_id"),
+    status: text("status").$type().notNull().default("pending"),
+    requestJson: jsonb("request_json").$type().notNull().default({}),
+    resultJson: jsonb("result_json").$type(),
+    browserSessionId: text("browser_session_id"),
+    hostName: text("host_name"),
+    errorMessage: text("error_message"),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index("idx_link_building_agent_job_status_created").on(
+      table.status,
+      table.createdAt
+    ),
+    index("idx_link_building_agent_job_submission").on(table.submissionId),
+    index("idx_link_building_agent_job_host_status").on(
+      table.hostId,
+      table.status
+    )
+  ]
+);
+pgTable("github_api_budget", {
+  tokenKey: text("token_key").primaryKey(),
+  windowStartedAt: timestamp("window_started_at", { withTimezone: true }).notNull().defaultNow(),
+  requestCount: integer("request_count").notNull().default(0),
+  blockedUntil: timestamp("blocked_until", { withTimezone: true }),
+  lastRemaining: integer("last_remaining"),
+  lastResetAt: timestamp("last_reset_at", { withTimezone: true }),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+});
+pgTable("github_api_cache", {
+  cacheKey: text("cache_key").primaryKey(),
+  etag: text("etag"),
+  body: text("body"),
+  status: integer("status").notNull().default(200),
+  contentType: text("content_type"),
+  expiresAt: timestamp("expires_at", { withTimezone: true }),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+});
+pgTable(
+  "github_api_stat",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    tokenKey: text("token_key").notNull(),
+    jobId: text("job_id").notNull().default("unknown"),
+    hourBucket: timestamp("hour_bucket", { withTimezone: true }).notNull(),
+    requestCount: integer("request_count").notNull().default(0),
+    errorCount: integer("error_count").notNull().default(0),
+    cacheHitCount: integer("cache_hit_count").notNull().default(0),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex("github_api_stat_token_job_hour_key").on(
+      table.tokenKey,
+      table.jobId,
+      table.hourBucket
+    ),
+    index("idx_github_api_stat_hour").on(table.hourBucket)
+  ]
+);
 var githubToken = pgTable(
   "github_token",
   {
@@ -6448,6 +6526,34 @@ pgTable(
     index("idx_refront_project_code").on(table.code)
   ]
 );
+var refrontMember = pgTable(
+  "refront_member",
+  {
+    /** Refront user id. */
+    id: uuid("id").primaryKey(),
+    name: text("name"),
+    role: text("role"),
+    teamId: text("team_id"),
+    teamName: text("team_name"),
+    /** True when the member has no explicit project assignments in Refront. */
+    unrestricted: boolean("unrestricted").notNull().default(true),
+    /** Derived wiki customer folder prefixes (empty when unrestricted). */
+    wikiFolders: text("wiki_folders").array().notNull().default([]),
+    syncedAt: timestamp("synced_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [index("idx_refront_member_team").on(table.teamId)]
+);
+pgTable(
+  "refront_member_project_access",
+  {
+    memberId: uuid("member_id").notNull().references(() => refrontMember.id, { onDelete: "cascade" }),
+    projectId: uuid("project_id").notNull(),
+    syncedAt: timestamp("synced_at", { withTimezone: true }).notNull()
+  },
+  (table) => [primaryKey({ columns: [table.memberId, table.projectId] })]
+);
 pgTable(
   "refront_source_sync_state",
   {
@@ -6538,7 +6644,587 @@ pgTable(
     }).onDelete("cascade")
   ]
 );
+pgTable(
+  "wiki_page",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    slug: text("slug").notNull().unique(),
+    title: text("title").notNull().default(""),
+    summary: text("summary"),
+    content: text("content").notNull().default(""),
+    status: text("status").notNull().default("draft"),
+    pageUpdatedOn: date("page_updated_on"),
+    reviewedBy: text("reviewed_by"),
+    reviewedOn: date("reviewed_on"),
+    lastVerifiedOn: date("last_verified_on"),
+    verifyCount: integer("verify_count").notNull().default(0),
+    verifyNote: text("verify_note"),
+    dirty: boolean("dirty").notNull().default(false),
+    vaultSyncedAt: timestamp("vault_synced_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index("idx_wiki_page_status").on(table.status),
+    index("idx_wiki_page_last_verified").on(table.lastVerifiedOn),
+    index("idx_wiki_page_dirty").on(table.dirty)
+  ]
+);
+pgTable(
+  "wiki_change_log",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    authorJob: text("author_job").notNull(),
+    summary: text("summary").notNull().default(""),
+    slugs: text("slugs").array().notNull().default([]),
+    syncedAt: timestamp("synced_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [index("idx_wiki_change_log_created").on(table.createdAt)]
+);
+pgTable(
+  "wiki_page_flag",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    pageSlug: text("page_slug").notNull(),
+    kind: text("kind").notNull(),
+    detail: text("detail").notNull().default(""),
+    sourceRef: text("source_ref"),
+    createdBy: text("created_by"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+    resolvedBy: text("resolved_by")
+  },
+  (table) => [index("idx_wiki_page_flag_created").on(table.createdAt)]
+);
+pgTable(
+  "wiki_page_evidence",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    pageSlug: text("page_slug").notNull(),
+    evidenceType: text("evidence_type").notNull(),
+    evidenceRef: text("evidence_ref").notNull(),
+    matchScore: real("match_score"),
+    matchReason: text("match_reason"),
+    snippet: text("snippet"),
+    status: text("status").notNull().default("pending"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true })
+  },
+  (table) => [
+    uniqueIndex("wiki_page_evidence_page_slug_evidence_type_evidence_ref_key").on(
+      table.pageSlug,
+      table.evidenceType,
+      table.evidenceRef
+    ),
+    index("idx_wiki_page_evidence_created").on(table.createdAt)
+  ]
+);
+pgTable(
+  "wiki_page_read",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    slug: text("slug").notNull(),
+    caller: text("caller"),
+    includedArchive: boolean("included_archive").notNull().default(false),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index("idx_wiki_page_read_slug").on(table.slug, table.createdAt),
+    index("idx_wiki_page_read_created").on(table.createdAt)
+  ]
+);
+pgTable(
+  "wiki_verify_event",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    pageSlug: text("page_slug").notNull(),
+    outcome: text("outcome").notNull(),
+    runMode: text("run_mode"),
+    note: text("note"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index("idx_wiki_verify_event_created").on(table.createdAt),
+    index("idx_wiki_verify_event_outcome_created").on(
+      table.outcome,
+      table.createdAt
+    )
+  ]
+);
+var wikiActor = pgTable(
+  "wiki_actor",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    displayName: text("display_name").notNull(),
+    kind: text("kind").notNull().default("external"),
+    notes: text("notes"),
+    wikiPageSlug: text("wiki_page_slug"),
+    refrontCustomerId: uuid("refront_customer_id"),
+    refrontMemberId: uuid("refront_member_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index("idx_wiki_actor_kind").on(table.kind),
+    index("idx_wiki_actor_wiki_page_slug").on(table.wikiPageSlug)
+  ]
+);
+pgTable(
+  "wiki_actor_identity",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    actorId: uuid("actor_id").notNull().references(() => wikiActor.id, { onDelete: "cascade" }),
+    identityHash: text("identity_hash").notNull(),
+    kind: text("kind").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex("wiki_actor_identity_kind_hash").on(
+      table.kind,
+      table.identityHash
+    ),
+    index("idx_wiki_actor_identity_actor").on(table.actorId)
+  ]
+);
+pgTable(
+  "wiki_actor_affiliation",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    actorId: uuid("actor_id").notNull().references(() => wikiActor.id, { onDelete: "cascade" }),
+    customerFolder: text("customer_folder"),
+    refrontCustomerId: uuid("refront_customer_id"),
+    refrontProjectId: uuid("refront_project_id"),
+    affiliationKey: text("affiliation_key").notNull().unique(),
+    signalCount: integer("signal_count").notNull().default(1),
+    firstSeen: timestamp("first_seen", { withTimezone: true }).notNull().defaultNow(),
+    lastSeen: timestamp("last_seen", { withTimezone: true }).notNull().defaultNow(),
+    sampleSources: text("sample_sources").array().notNull().default([]),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    index("idx_wiki_actor_affiliation_actor").on(table.actorId),
+    index("idx_wiki_actor_affiliation_customer_folder").on(
+      table.customerFolder
+    )
+  ]
+);
+pgTable(
+  "intake_identity_unresolved",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    identityHash: text("identity_hash").notNull(),
+    kind: text("kind").notNull(),
+    seenCount: integer("seen_count").notNull().default(1),
+    sampleSignalIds: uuid("sample_signal_ids").array().notNull().default([]),
+    sampleContext: text("sample_context").array().notNull().default([]),
+    sampleSources: text("sample_sources").array().notNull().default([]),
+    lastSeen: timestamp("last_seen", { withTimezone: true }).notNull().defaultNow(),
+    insightFiledAt: timestamp("insight_filed_at", { withTimezone: true }),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+    resolvedActorId: uuid("resolved_actor_id").references(() => wikiActor.id, {
+      onDelete: "set null"
+    }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex("intake_identity_unresolved_kind_hash").on(
+      table.kind,
+      table.identityHash
+    )
+  ]
+);
 var GITHUB_API = "https://api.github.com";
+var TRANSIENT_GITHUB_STATUSES = /* @__PURE__ */ new Set([
+  429,
+  502,
+  503,
+  504,
+  520,
+  521,
+  522,
+  523,
+  524
+]);
+var DEFAULT_BUDGET_PER_MINUTE = 75;
+var BUDGET_STATE_KEY = "github_api_budget_per_minute";
+var DEFAULT_BLOCK_MS = 15 * 60 * 1e3;
+var MAX_ATTEMPTS = 4;
+var BASE_DELAY_MS = 750;
+var RATE_LIMIT_FLOOR = 50;
+var BUDGET_WAIT_ATTEMPTS = 4;
+var BUDGET_WAIT_CAP_MS = 15e3;
+var GitHubGatewayBlockedError = class extends Error {
+  blockedUntil;
+  constructor(blockedUntil, message) {
+    super(
+      message ?? `GitHub API circuit breaker open until ${blockedUntil.toISOString()}`
+    );
+    this.name = "GitHubGatewayBlockedError";
+    this.blockedUntil = blockedUntil;
+  }
+};
+var GitHubGatewayPausedError = class extends Error {
+  constructor() {
+    super("GitHub sync is paused (github_sync_paused app_setting)");
+    this.name = "GitHubGatewayPausedError";
+  }
+};
+var GitHubGatewayBudgetError = class extends Error {
+  constructor(tokenKey) {
+    super(`GitHub API budget exhausted for token ${tokenKey}`);
+    this.name = "GitHubGatewayBudgetError";
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function summarizeGitHubErrorBody(body, maxLen = 240) {
+  const trimmed = body.trim();
+  if (!trimmed) return "";
+  const looksLikeHtml = trimmed.startsWith("<!") || trimmed.startsWith("<html") || /<title>\s*Unicorn!/i.test(trimmed);
+  if (looksLikeHtml) return "[GitHub HTML error page truncated]";
+  if (trimmed.length <= maxLen) return trimmed;
+  return `${trimmed.slice(0, maxLen)}\u2026`;
+}
+function isTransientGitHubStatus(status) {
+  return TRANSIENT_GITHUB_STATUSES.has(status);
+}
+function hourBucket(now = /* @__PURE__ */ new Date()) {
+  return new Date(
+    Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      now.getUTCDate(),
+      now.getUTCHours(),
+      0,
+      0,
+      0
+    )
+  );
+}
+function cacheKeyFor(url, tokenKey) {
+  return createHash("sha256").update(`${tokenKey}:${url}`).digest("hex");
+}
+async function isGithubSyncPaused() {
+  try {
+    const rows = await getDb().execute(sql`
+      SELECT value FROM wiki_sync_state
+      WHERE key = 'github_sync_paused'
+      LIMIT 1
+    `);
+    return Boolean(rows[0]?.value?.paused);
+  } catch {
+    return false;
+  }
+}
+async function getBlockedUntil(tokenKey) {
+  const rows = await getDb().execute(
+    sql`
+      SELECT blocked_until FROM github_api_budget
+      WHERE token_key = ${tokenKey}
+      LIMIT 1
+    `
+  );
+  const raw = rows[0]?.blocked_until;
+  if (!raw) return null;
+  const date2 = typeof raw === "string" ? new Date(raw) : raw;
+  if (Number.isNaN(date2.getTime()) || date2.getTime() <= Date.now()) return null;
+  return date2;
+}
+async function setGithubCircuitBreaker(tokenKey, blockedUntil) {
+  await getDb().execute(sql`
+    INSERT INTO github_api_budget (token_key, blocked_until, updated_at)
+    VALUES (${tokenKey}, ${blockedUntil.toISOString()}::timestamptz, now())
+    ON CONFLICT (token_key) DO UPDATE SET
+      blocked_until = EXCLUDED.blocked_until,
+      updated_at = now()
+  `);
+}
+async function tryConsumeBudget(tokenKey, budgetPerMinute) {
+  const updated = await getDb().execute(sql`
+    UPDATE github_api_budget
+    SET
+      window_started_at = CASE
+        WHEN window_started_at < now() - interval '60 seconds'
+        THEN now()
+        ELSE window_started_at
+      END,
+      request_count = CASE
+        WHEN window_started_at < now() - interval '60 seconds'
+        THEN 1
+        ELSE request_count + 1
+      END,
+      updated_at = now()
+    WHERE token_key = ${tokenKey}
+      AND (
+        window_started_at < now() - interval '60 seconds'
+        OR request_count < ${budgetPerMinute}
+      )
+    RETURNING request_count
+  `);
+  if (updated[0]) return true;
+  const inserted = await getDb().execute(sql`
+    INSERT INTO github_api_budget (token_key, window_started_at, request_count, updated_at)
+    VALUES (${tokenKey}, now(), 1, now())
+    ON CONFLICT (token_key) DO NOTHING
+    RETURNING request_count
+  `);
+  if (inserted[0]) return true;
+  return false;
+}
+async function msUntilBudgetWindowReset(tokenKey) {
+  const rows = await getDb().execute(sql`
+    SELECT window_started_at FROM github_api_budget
+    WHERE token_key = ${tokenKey}
+    LIMIT 1
+  `);
+  const raw = rows[0]?.window_started_at;
+  if (!raw) return 1e3;
+  const started = typeof raw === "string" ? new Date(raw).getTime() : raw.getTime();
+  if (!Number.isFinite(started)) return 1e3;
+  const resetAt = started + 6e4;
+  return Math.max(250, resetAt - Date.now());
+}
+async function resolveGithubBudgetPerMinute(override) {
+  if (typeof override === "number" && override > 0) return Math.floor(override);
+  const fromEnv = Number(process.env.GITHUB_API_BUDGET_PER_MINUTE);
+  if (Number.isFinite(fromEnv) && fromEnv > 0) return Math.floor(fromEnv);
+  try {
+    const rows = await getDb().execute(sql`
+      SELECT value FROM wiki_sync_state
+      WHERE key = ${BUDGET_STATE_KEY}
+      LIMIT 1
+    `);
+    const perMinute = rows[0]?.value?.perMinute;
+    if (typeof perMinute === "number" && perMinute > 0) {
+      return Math.floor(perMinute);
+    }
+  } catch {
+  }
+  return DEFAULT_BUDGET_PER_MINUTE;
+}
+async function consumeBudgetOrWait(input) {
+  for (let attempt = 1; attempt <= BUDGET_WAIT_ATTEMPTS; attempt++) {
+    if (await tryConsumeBudget(input.tokenKey, input.budgetPerMinute)) {
+      return;
+    }
+    if (input.priority === "interactive") {
+      await sleep(BASE_DELAY_MS);
+      continue;
+    }
+    if (attempt === BUDGET_WAIT_ATTEMPTS) {
+      throw new GitHubGatewayBudgetError(input.tokenKey);
+    }
+    const waitMs = Math.min(
+      await msUntilBudgetWindowReset(input.tokenKey),
+      BUDGET_WAIT_CAP_MS
+    );
+    await sleep(waitMs);
+  }
+  throw new GitHubGatewayBudgetError(input.tokenKey);
+}
+async function recordStat(input) {
+  const bucket = hourBucket().toISOString();
+  await getDb().execute(sql`
+    INSERT INTO github_api_stat (
+      token_key, job_id, hour_bucket, request_count, error_count, cache_hit_count, updated_at
+    )
+    VALUES (
+      ${input.tokenKey},
+      ${input.jobId},
+      ${bucket}::timestamptz,
+      1,
+      ${input.error ? 1 : 0},
+      ${input.cacheHit ? 1 : 0},
+      now()
+    )
+    ON CONFLICT (token_key, job_id, hour_bucket) DO UPDATE SET
+      request_count = github_api_stat.request_count + 1,
+      error_count = github_api_stat.error_count + ${input.error ? 1 : 0},
+      cache_hit_count = github_api_stat.cache_hit_count + ${input.cacheHit ? 1 : 0},
+      updated_at = now()
+  `);
+}
+async function loadEtagCache(key) {
+  const rows = await getDb().execute(sql`
+    SELECT etag, body, status FROM github_api_cache
+    WHERE cache_key = ${key}
+    LIMIT 1
+  `);
+  return rows[0] ?? null;
+}
+async function saveEtagCache(input) {
+  await getDb().execute(sql`
+    INSERT INTO github_api_cache (
+      cache_key, etag, body, status, content_type, updated_at
+    )
+    VALUES (
+      ${input.key},
+      ${input.etag},
+      ${input.body},
+      ${input.status},
+      ${input.contentType},
+      now()
+    )
+    ON CONFLICT (cache_key) DO UPDATE SET
+      etag = EXCLUDED.etag,
+      body = EXCLUDED.body,
+      status = EXCLUDED.status,
+      content_type = EXCLUDED.content_type,
+      updated_at = now()
+  `);
+}
+async function updateRateLimitHeaders(tokenKey, response) {
+  const remaining = Number(response.headers.get("x-ratelimit-remaining"));
+  const reset = Number(response.headers.get("x-ratelimit-reset"));
+  if (!Number.isFinite(remaining) && !Number.isFinite(reset)) return;
+  await getDb().execute(sql`
+    INSERT INTO github_api_budget (
+      token_key, last_remaining, last_reset_at, updated_at
+    )
+    VALUES (
+      ${tokenKey},
+      ${Number.isFinite(remaining) ? remaining : null},
+      ${Number.isFinite(reset) ? sql`to_timestamp(${reset})` : sql`NULL`},
+      now()
+    )
+    ON CONFLICT (token_key) DO UPDATE SET
+      last_remaining = COALESCE(EXCLUDED.last_remaining, github_api_budget.last_remaining),
+      last_reset_at = COALESCE(EXCLUDED.last_reset_at, github_api_budget.last_reset_at),
+      updated_at = now()
+  `);
+  if (Number.isFinite(remaining) && remaining < RATE_LIMIT_FLOOR) {
+    const until = Number.isFinite(reset) ? new Date(reset * 1e3) : new Date(Date.now() + DEFAULT_BLOCK_MS);
+    if (until.getTime() > Date.now()) {
+      await setGithubCircuitBreaker(tokenKey, until);
+    }
+  }
+}
+function tripBreakerFromResponse(response) {
+  const retryAfter = Number(response.headers.get("retry-after"));
+  if (Number.isFinite(retryAfter) && retryAfter > 0) {
+    return new Date(Date.now() + retryAfter * 1e3);
+  }
+  const reset = Number(response.headers.get("x-ratelimit-reset"));
+  if (Number.isFinite(reset) && reset * 1e3 > Date.now()) {
+    return new Date(reset * 1e3);
+  }
+  return new Date(Date.now() + DEFAULT_BLOCK_MS);
+}
+async function githubGatewayFetch(url, init, options) {
+  const priority = options.priority ?? "background";
+  const budgetPerMinute = await resolveGithubBudgetPerMinute(
+    options.budgetPerMinute
+  );
+  const method = (init.method ?? "GET").toUpperCase();
+  const useCache = options.useEtagCache !== false && method === "GET";
+  if (priority !== "interactive" && await isGithubSyncPaused()) {
+    throw new GitHubGatewayPausedError();
+  }
+  const blocked = await getBlockedUntil(options.tokenKey);
+  if (blocked) {
+    if (priority === "interactive") {
+      if (blocked.getTime() - Date.now() > 6e4) {
+        throw new GitHubGatewayBlockedError(blocked);
+      }
+    } else {
+      throw new GitHubGatewayBlockedError(blocked);
+    }
+  }
+  await consumeBudgetOrWait({
+    tokenKey: options.tokenKey,
+    budgetPerMinute,
+    priority
+  });
+  const headers = new Headers(init.headers);
+  if (!headers.has("Authorization")) {
+    headers.set("Authorization", `Bearer ${options.token}`);
+  }
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "application/vnd.github+json");
+  }
+  if (!headers.has("X-GitHub-Api-Version")) {
+    headers.set("X-GitHub-Api-Version", "2022-11-28");
+  }
+  const key = useCache ? cacheKeyFor(url, options.tokenKey) : null;
+  if (key) {
+    const cached = await loadEtagCache(key);
+    if (cached?.etag) headers.set("If-None-Match", cached.etag);
+  }
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    const response = await fetch(url, { ...init, headers });
+    await updateRateLimitHeaders(options.tokenKey, response);
+    if (response.status === 304 && key) {
+      const cached = await loadEtagCache(key);
+      await recordStat({
+        tokenKey: options.tokenKey,
+        jobId: options.jobId,
+        cacheHit: true
+      });
+      return new Response(cached?.body ?? "", {
+        status: cached?.status ?? 200,
+        headers: {
+          "x-github-gateway-cache": "hit",
+          "content-type": "application/json"
+        }
+      });
+    }
+    if (response.status === 403 || response.status === 429 || isTransientGitHubStatus(response.status)) {
+      const bodyText = summarizeGitHubErrorBody(
+        await response.clone().text().catch(() => "")
+      );
+      const secondary = response.status === 403 && /secondary rate limit|abuse detection/i.test(bodyText);
+      if (response.status === 429 || secondary || isTransientGitHubStatus(response.status)) {
+        const until = tripBreakerFromResponse(response);
+        await setGithubCircuitBreaker(options.tokenKey, until);
+        lastError = new Error(
+          `GitHub ${response.status}${bodyText ? `: ${bodyText}` : ""}`
+        );
+        await recordStat({
+          tokenKey: options.tokenKey,
+          jobId: options.jobId,
+          error: true
+        });
+        if (attempt === MAX_ATTEMPTS || secondary) {
+          throw new GitHubGatewayBlockedError(until, lastError.message);
+        }
+        const retryAfter = Number(response.headers.get("retry-after"));
+        const delayMs = Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1e3 : BASE_DELAY_MS * 2 ** (attempt - 1);
+        await sleep(delayMs);
+        continue;
+      }
+    }
+    if (key && response.ok) {
+      const etag = response.headers.get("etag");
+      const body = await response.clone().text();
+      await saveEtagCache({
+        key,
+        etag,
+        body,
+        status: response.status,
+        contentType: response.headers.get("content-type")
+      });
+    }
+    await recordStat({
+      tokenKey: options.tokenKey,
+      jobId: options.jobId,
+      error: !response.ok
+    });
+    return response;
+  }
+  throw lastError ?? new Error("GitHub request failed after retries");
+}
+function gatewayOptions(token) {
+  return {
+    tokenKey: "default",
+    token,
+    jobId: "release-profile-quick-create",
+    priority: "background"
+  };
+}
 var ReleaseProfileQuickCreateError = class extends Error {
   constructor(message, code = "INTERNAL_SERVER_ERROR") {
     super(message);
@@ -6565,18 +7251,20 @@ async function scanRepoForApps(repoFullName, githubToken2, ref = "main") {
     "Content-Type": "application/json"
   };
   async function fetchContents(path) {
-    const res = await fetch(
+    const res = await githubGatewayFetch(
       `${GITHUB_API}/repos/${repoFullName}/contents/${path}?ref=${ref}`,
-      { headers }
+      { headers },
+      gatewayOptions(githubToken2)
     );
     if (!res.ok) return null;
     const data = await res.json();
     return Array.isArray(data) ? data : null;
   }
   async function fileExists(path) {
-    const res = await fetch(
+    const res = await githubGatewayFetch(
       `${GITHUB_API}/repos/${repoFullName}/contents/${path}?ref=${ref}`,
-      { headers, method: "HEAD" }
+      { headers, method: "HEAD" },
+      gatewayOptions(githubToken2)
     );
     return res.ok;
   }
@@ -6713,31 +7401,36 @@ async function ensureGitHubBranchExists(repoFullName, branchName, fromBranch, gi
     Authorization: `Bearer ${githubToken2}`,
     "Content-Type": "application/json"
   };
-  const checkRes = await fetch(
+  const checkRes = await githubGatewayFetch(
     `${GITHUB_API}/repos/${repoFullName}/git/ref/heads/${branchName}`,
-    { headers }
+    { headers },
+    gatewayOptions(githubToken2)
   );
   if (checkRes.ok) return;
   let sha;
-  const sourceRes = await fetch(
+  const sourceRes = await githubGatewayFetch(
     `${GITHUB_API}/repos/${repoFullName}/git/ref/heads/${fromBranch}`,
-    { headers }
+    { headers },
+    gatewayOptions(githubToken2)
   );
   if (sourceRes.ok) {
     const data = await sourceRes.json();
     sha = data.object?.sha;
   } else {
-    const repoRes = await fetch(`${GITHUB_API}/repos/${repoFullName}`, {
-      headers
-    });
+    const repoRes = await githubGatewayFetch(
+      `${GITHUB_API}/repos/${repoFullName}`,
+      { headers },
+      gatewayOptions(githubToken2)
+    );
     if (!repoRes.ok) {
       throw new Error(`Could not access repository ${repoFullName}`);
     }
     const repo = await repoRes.json();
     const defaultBranch = repo.default_branch ?? "main";
-    const defaultRes = await fetch(
+    const defaultRes = await githubGatewayFetch(
       `${GITHUB_API}/repos/${repoFullName}/git/ref/heads/${defaultBranch}`,
-      { headers }
+      { headers },
+      gatewayOptions(githubToken2)
     );
     if (!defaultRes.ok) {
       throw new Error(`Could not resolve a source branch for ${repoFullName}`);
@@ -6748,13 +7441,14 @@ async function ensureGitHubBranchExists(repoFullName, branchName, fromBranch, gi
   if (!sha) {
     throw new Error(`Could not determine SHA to create branch ${branchName}`);
   }
-  const createRes = await fetch(
+  const createRes = await githubGatewayFetch(
     `${GITHUB_API}/repos/${repoFullName}/git/refs`,
     {
       method: "POST",
       headers,
       body: JSON.stringify({ ref: `refs/heads/${branchName}`, sha })
-    }
+    },
+    gatewayOptions(githubToken2)
   );
   if (!createRes.ok && createRes.status !== 422) {
     const body = await createRes.text().catch(() => "");
@@ -7941,7 +8635,7 @@ function getEncryptionKey() {
     throw new Error("ENCRYPTION_KEY must be a 64-character hex string");
   return buf;
 }
-function encrypt(text13) {
+function encrypt(text16) {
   const key = getEncryptionKey();
   const iv = randomBytes(ENC_IV_LENGTH);
   const cipher = createCipheriv(
@@ -7949,7 +8643,7 @@ function encrypt(text13) {
     new Uint8Array(key),
     new Uint8Array(iv)
   );
-  let encrypted = cipher.update(text13, "utf8", "hex");
+  let encrypted = cipher.update(text16, "utf8", "hex");
   encrypted += cipher.final("hex");
   const authTag = cipher.getAuthTag();
   return Buffer.concat([
@@ -8669,10 +9363,10 @@ async function r2GetObjectRange(bucket, key, range) {
     const body = result.Body;
     if (!body?.transformToString)
       throw new Error("R2 returned no readable body");
-    const text13 = await body.transformToString();
+    const text16 = await body.transformToString();
     const header = `# range: bytes ${range.offset}-${end} of ${size} (${effectiveLen} bytes)`;
     return `${header}
-${text13}`;
+${text16}`;
   } catch (e) {
     throw r2WrapError(bucket, key, e);
   }
@@ -9035,15 +9729,15 @@ async function sftpRead(opts, filePath, proxy, options) {
             clearTimeout(timer);
             cleanup?.();
             cleanup = void 0;
-            const text13 = Buffer.concat(
+            const text16 = Buffer.concat(
               chunks.map((ch) => new Uint8Array(ch))
             ).toString("utf-8");
             if (!isWholeFileRequest) {
               const header = `# range: bytes ${offset}-${offset + effectiveLen - 1} of ${total} (${effectiveLen} bytes)`;
               resolve(`${header}
-${text13}`);
+${text16}`);
             } else {
-              resolve(text13);
+              resolve(text16);
             }
           });
           rs.on("error", (e) => {
@@ -9096,7 +9790,7 @@ var TOOL_CACHE_TTL_MS = {
   "docker-list": 3e4
 };
 var TOOL_CACHE = /* @__PURE__ */ new Map();
-function cacheKeyFor(name, args2) {
+function cacheKeyFor2(name, args2) {
   const { noCache: _ignored, ...rest } = args2;
   const sorted = Object.fromEntries(
     Object.entries(rest).sort(([a], [b]) => a.localeCompare(b))
@@ -9107,7 +9801,7 @@ function getCachedTool(name, args2) {
   const ttl = TOOL_CACHE_TTL_MS[name];
   if (!ttl || ttl <= 0) return void 0;
   if (args2.noCache === true) return void 0;
-  const k = cacheKeyFor(name, args2);
+  const k = cacheKeyFor2(name, args2);
   const e = TOOL_CACHE.get(k);
   if (!e) return void 0;
   if (e.expiresAt < Date.now()) {
@@ -9120,7 +9814,7 @@ function setCachedTool(name, args2, value) {
   const ttl = TOOL_CACHE_TTL_MS[name];
   if (!ttl || ttl <= 0) return;
   if (args2.noCache === true) return;
-  TOOL_CACHE.set(cacheKeyFor(name, args2), {
+  TOOL_CACHE.set(cacheKeyFor2(name, args2), {
     value,
     expiresAt: Date.now() + ttl
   });
@@ -9190,11 +9884,11 @@ function getKnownContainers(serverId, maxAgeMs = 5 * 6e4) {
   if (Date.now() - e.capturedAt > maxAgeMs) return void 0;
   return e.names;
 }
-function truncateForLLM(text13, maxBytes) {
-  const totalBytes = Buffer.byteLength(text13, "utf8");
+function truncateForLLM(text16, maxBytes) {
+  const totalBytes = Buffer.byteLength(text16, "utf8");
   if (totalBytes <= maxBytes)
-    return { text: text13, truncated: false, totalBytes, shownBytes: totalBytes };
-  const buf = Buffer.from(text13, "utf8");
+    return { text: text16, truncated: false, totalBytes, shownBytes: totalBytes };
+  const buf = Buffer.from(text16, "utf8");
   let cut = maxBytes;
   while (cut > 0 && (buf[cut] & 192) === 128) cut--;
   const head = buf.subarray(0, cut).toString("utf8");
@@ -9225,10 +9919,10 @@ function postprocessResult(result, meta) {
   if (!result.content?.length) return result;
   if (RAW_JSON_TOOLS.has(meta.toolName)) return result;
   const block = result.content[0];
-  let text13 = String(block.text ?? "");
-  const trunc = truncateForLLM(text13, RESPONSE_MAX_BYTES);
+  let text16 = String(block.text ?? "");
+  const trunc = truncateForLLM(text16, RESPONSE_MAX_BYTES);
   if (trunc.truncated) {
-    text13 = trunc.text + "\n\n... " + buildTruncationHint(
+    text16 = trunc.text + "\n\n... " + buildTruncationHint(
       meta.toolName,
       meta.args,
       trunc.totalBytes,
@@ -9242,11 +9936,11 @@ function postprocessResult(result, meta) {
     const parts = [`took ${tookStr}`, sizeStr];
     if (meta.serverIdLabel) parts.push(`server: ${meta.serverIdLabel}`);
     if (meta.cached) parts.push("cached");
-    text13 = `${text13}
+    text16 = `${text16}
 
 [${parts.join(", ")}]`;
   }
-  return { ...result, content: [{ ...block, text: text13 }] };
+  return { ...result, content: [{ ...block, text: text16 }] };
 }
 function buildPipelineScript(commands, shell, marker, stopOnError) {
   if (shell === "powershell") {
@@ -10032,11 +10726,11 @@ CREATE TABLE IF NOT EXISTS _mcp_migrations (
   applied_by  TEXT
 );
 `.trim();
-function normaliseMigrationSql(sql28) {
-  return sql28.replace(/\r\n/g, "\n").trim() + "\n";
+function normaliseMigrationSql(sql29) {
+  return sql29.replace(/\r\n/g, "\n").trim() + "\n";
 }
-function migrationSha256(sql28) {
-  return createHash("sha256").update(sql28.replace(/\r\n/g, "\n"), "utf8").digest("hex");
+function migrationSha256(sql29) {
+  return createHash("sha256").update(sql29.replace(/\r\n/g, "\n"), "utf8").digest("hex");
 }
 function dollarQuoteTag(value) {
   let tag = "_mcp";
@@ -10302,7 +10996,7 @@ var DNS_MIN_INTERVAL_MS = 750;
 var DNS_RETRY_BACKOFF_MS = 1500;
 var dnsZoneQueue = /* @__PURE__ */ new Map();
 var dnsLastPutAt = /* @__PURE__ */ new Map();
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function withDnsZoneLock(domain, fn) {
@@ -10311,7 +11005,7 @@ async function withDnsZoneLock(domain, fn) {
   const run = previous.then(async () => {
     const last = dnsLastPutAt.get(key) ?? 0;
     const wait = DNS_MIN_INTERVAL_MS - (Date.now() - last);
-    if (wait > 0) await sleep(wait);
+    if (wait > 0) await sleep2(wait);
     return fn();
   });
   const queued = run.finally(() => {
@@ -11753,6 +12447,32 @@ var TOOLS = [
       }
     }
   },
+  {
+    name: "submit-team-memory",
+    description: "Manually push a curated problem\u2192solution note into the team's searchable memory (agent_memory). Use ONLY when the user explicitly asks to push/share context to team memory (e.g. no agent-host daemon). Do NOT auto-submit. Do NOT dump raw chat. English; no secrets/PII. Pass repo for the current project. Distinct from wiki intake \u2014 this is searchable via search-team-memory.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Short English title for the note (max 300 chars)."
+        },
+        content: {
+          type: "string",
+          description: "Problem / root cause / solution / context markdown (min ~40 chars, max ~24k stored)."
+        },
+        repo: {
+          type: "string",
+          description: "Git repository, e.g. 'github.com/MGSoftwareBV/fenicks' or 'github.com/MGSoftwareBV/mg-boiler'."
+        },
+        externalRef: {
+          type: "string",
+          description: "Optional client dedupe key; re-submitting the same ref upserts the row."
+        }
+      },
+      required: ["title", "content", "repo"]
+    }
+  },
   {
     name: "search-wiki",
     description: "Search the team's curated knowledge wiki (the distilled layer ABOVE team memory): compiled pages about how systems actually work, customer setups/quirks, and known recurring issues with their standard fixes. Check this BEFORE search-team-memory \u2014 it is smaller, curated, and deduplicated, so a hit here is usually the complete answer. Every page lists its `sources` (team-memory ids, ticket numbers, commits): follow those with get-team-memory for full raw detail instead of broad searches. Fall back to search-team-memory when nothing relevant comes back or the page's `updated` date looks stale.",
@@ -11777,13 +12497,17 @@ var TOOLS = [
   },
   {
     name: "get-wiki-page",
-    description: "Fetch one full knowledge-wiki page (markdown + frontmatter + sources) by the `slug` from a search-wiki result. The `sources` list is the provenance: team-memory ids (fetch via get-team-memory), ticket numbers, and commits.",
+    description: "Fetch one full knowledge-wiki page (markdown + frontmatter + sources) by the `slug` from a search-wiki result. Active sources are capped (~10) and enriched with title/date for team-memory refs so you can pick 1\u20132 relevant transcripts via get-team-memory instead of fetching blindly. If the page itself does not answer your question, call again with `include_all_sources: true` to see the full active list plus the archive, then fetch only the refs you need. If an archived source held the real answer, flag the page with kind `archive-solution` + that `source_ref` so the reviewer can promote it.",
     inputSchema: {
       type: "object",
       properties: {
         slug: {
           type: "string",
           description: "Page slug from a search-wiki hit, e.g. 'wiki/engineering/team-memory'."
+        },
+        include_all_sources: {
+          type: "boolean",
+          description: "Return every active source plus the archived history (also enriched). Default false \u2014 compact active list only."
         }
       },
       required: ["slug"]
@@ -11791,7 +12515,7 @@ var TOOLS = [
   },
   {
     name: "flag-wiki-page",
-    description: "Report that a knowledge-wiki page was WRONG, outdated or incomplete when you actually used it during real work. This is the wiki's feedback loop: open flags jump the daily reviewer queue and show in the backoffice review panel, so the page gets fixed instead of misleading the next agent. Call it right after discovering the mismatch, with a concrete `detail` of what was wrong and what turned out to be true.",
+    description: "Report that a knowledge-wiki page was WRONG, outdated or incomplete when you actually used it during real work. This is the wiki's feedback loop: open flags jump the daily reviewer queue and show in the backoffice review panel, so the page gets fixed instead of misleading the next agent. Call it right after discovering the mismatch, with a concrete `detail` of what was wrong and what turned out to be true. Use kind `archive-solution` (with `source_ref`) when the page itself missed the answer but an archived source had it \u2014 the reviewer will promote that source and update the page.",
     inputSchema: {
       type: "object",
       properties: {
@@ -11806,13 +12530,18 @@ var TOOLS = [
             "stale",
             "duplicate",
             "unverified",
-            "obsolete-candidate"
+            "obsolete-candidate",
+            "archive-solution"
           ],
-          description: "feedback (default) = wrong/incomplete in practice; stale = outdated vs current reality; duplicate = covers the same thing as another page; obsolete-candidate = the described system/practice appears no longer in use."
+          description: "feedback (default) = wrong/incomplete in practice; stale = outdated vs current reality; duplicate = covers the same thing as another page; obsolete-candidate = the described system/practice appears no longer in use; archive-solution = answer was found in an archived source (pass source_ref)."
         },
         detail: {
           type: "string",
           description: "What was wrong and what is actually true (be concrete: the claim, the observed reality, ticket/commit refs if any). Min 5 chars."
+        },
+        source_ref: {
+          type: "string",
+          description: "For archive-solution: the archived source that held the answer, e.g. 'team-memory:<uuid>' or 'ticket:2026-DASMG-032'."
         }
       },
       required: ["slug", "detail"]
@@ -12127,7 +12856,7 @@ async function executeToolCall(name, a, _serverId) {
             ]
           };
         }
-        const lines = data.hits.map((hit, index10) => {
+        const lines = data.hits.map((hit, index13) => {
           const when = hit.lastMessageAt ? new Date(hit.lastMessageAt).toISOString().slice(0, 10) : "unknown date";
           const repo = hit.repo ?? "unknown repo";
           const sim = hit.similarity !== null ? ` \xB7 ${(hit.similarity * 100).toFixed(0)}% match` : "";
@@ -12137,7 +12866,7 @@ async function executeToolCall(name, a, _serverId) {
             ...Array.isArray(hit.tech) ? hit.tech.slice(0, 4) : []
           ].filter(Boolean);
           const tags = facets.length > 0 ? ` \xB7 ${facets.join(", ")}` : "";
-          return `${index10 + 1}. [${repo} \xB7 ${when}${sim}${tags}] ${hit.title}
+          return `${index13 + 1}. [${repo} \xB7 ${when}${sim}${tags}] ${hit.title}
    id: ${hit.id}
    ${(hit.summary ?? hit.snippet).replace(/\s+/g, " ").slice(0, 500)}`;
         });
@@ -12239,6 +12968,71 @@ ${facets.join(", ")}` : ""),
           ]
         };
       }
+      // ----- Team memory: manual curated submit (no daemon) -----
+      case "submit-team-memory": {
+        const title = typeof a.title === "string" ? a.title.trim() : "";
+        const content = typeof a.content === "string" ? a.content.trim() : "";
+        const repo = typeof a.repo === "string" ? a.repo.trim() : "";
+        const externalRef = typeof a.externalRef === "string" ? a.externalRef.trim() : void 0;
+        if (!title || !content || !repo) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: title, content, and repo are required."
+              }
+            ]
+          };
+        }
+        if (content.length < 40) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: content must be at least 40 characters (curated problem\u2192solution, not a one-liner)."
+              }
+            ]
+          };
+        }
+        const res = await fetch(`${dashboardBaseUrl}/api/team-memory/submit`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            title,
+            content,
+            gitRepository: repo,
+            ...externalRef ? { externalRef } : {}
+          })
+        });
+        if (!res.ok) {
+          const detail = await res.text().catch(() => "");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: team-memory submit failed (${res.status}). ${detail.slice(0, 400)}`
+              }
+            ]
+          };
+        }
+        const data = await res.json();
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Submitted to team memory${data.upserted ? "" : " (unchanged \u2014 identical content)"}.
+id: ${data.id}
+localConversationId: ${data.localConversationId}
+repo: ${repo}
+summarized: ${data.summarized}, embedded: ${data.embedded}
+Searchable via search-team-memory once indexing completes (usually immediate).`
+            }
+          ]
+        };
+      }
       // ----- Knowledge wiki: search -----
       case "search-wiki": {
         const query = typeof a.query === "string" ? a.query.trim() : "";
@@ -12279,12 +13073,12 @@ ${facets.join(", ")}` : ""),
             ]
           };
         }
-        const lines = data.hits.map((hit, index10) => {
+        const lines = data.hits.map((hit, index13) => {
           const sim = hit.similarity !== null ? ` \xB7 ${Math.round(hit.similarity * 100)}% match` : "";
           const tags = hit.tags.length ? ` \xB7 ${hit.tags.slice(0, 5).join(", ")}` : "";
           const sources = hit.sources.length ? `
    sources: ${hit.sources.slice(0, 6).map((s) => `${s.type}:${s.ref}`).join(", ")}` : "";
-          return `${index10 + 1}. [${hit.status} \xB7 updated ${hit.pageUpdatedOn ?? "unknown"}${sim}${tags}] ${hit.title}
+          return `${index13 + 1}. [${hit.status} \xB7 updated ${hit.pageUpdatedOn ?? "unknown"}${sim}${tags}] ${hit.title}
    slug: ${hit.slug}${sources}
    ${(hit.summary ?? hit.snippet).replace(/\s+/g, " ").slice(0, 400)}`;
         });
@@ -12306,13 +13100,17 @@ Call get-wiki-page with a slug for the full page; follow its sources (team-memor
         if (!slug) {
           return { content: [{ type: "text", text: "Error: slug is required" }] };
         }
+        const includeAllSources = a.include_all_sources === true;
         const res = await fetch(`${dashboardBaseUrl}/api/wiki/page`, {
           method: "POST",
           headers: {
             "content-type": "application/json",
             authorization: `Bearer ${apiKey}`
           },
-          body: JSON.stringify({ slug })
+          body: JSON.stringify({
+            slug,
+            include_all_sources: includeAllSources
+          })
         });
         if (!res.ok) {
           const detail = await res.text().catch(() => "");
@@ -12334,14 +13132,52 @@ Call get-wiki-page with a slug for the full page; follow its sources (team-memor
           };
         }
         const page = data.page;
-        const sources = page.sources.length ? `
-Sources: ${page.sources.map((s) => `${s.type}:${s.ref}`).join(", ")}` : "";
+        const formatSource = (s) => {
+          const base = `${s.type}:${s.ref}`;
+          if (s.title) {
+            const date2 = s.date ? ` (${s.date})` : "";
+            return `${base} \u2014 "${s.title}"${date2}`;
+          }
+          return base;
+        };
+        const totalActive = page.sourcesTotalActive ?? page.sources.length;
+        const totalArchived = page.sourcesTotalArchived ?? 0;
+        const sourceLines = page.sources.map(formatSource);
+        let sourcesBlock = "";
+        if (sourceLines.length > 0) {
+          const header = page.sourcesTruncated ? `Sources (${sourceLines.length} of ${totalActive} active):` : `Sources (${totalActive} active):`;
+          sourcesBlock = `
+${header}
+${sourceLines.map((l) => `- ${l}`).join("\n")}`;
+          if (page.sourcesTruncated || !includeAllSources && totalArchived > 0) {
+            const moreActive = Math.max(0, totalActive - sourceLines.length);
+            const parts = [];
+            if (moreActive > 0) parts.push(`+${moreActive} more active`);
+            if (totalArchived > 0) parts.push(`+${totalArchived} archived`);
+            sourcesBlock += `
+\u2026 ${parts.join(", ")} (call again with include_all_sources=true). If an archived source answers your question, flag-wiki-page kind=archive-solution with that source_ref.`;
+          }
+        } else if (totalArchived > 0 && !includeAllSources) {
+          sourcesBlock = `
+Sources: none active, ${totalArchived} archived (call with include_all_sources=true to list them).`;
+        }
+        const activeKeys = new Set(
+          page.sources.map((s) => `${s.type}:${s.ref}`)
+        );
+        const archiveOnly = (page.sourcesArchive ?? []).filter(
+          (s) => !activeKeys.has(`${s.type}:${s.ref}`)
+        );
+        if (includeAllSources && archiveOnly.length > 0) {
+          sourcesBlock += `
+Archived sources (${archiveOnly.length}):
+` + archiveOnly.map((s) => `- ${formatSource(s)}`).join("\n");
+        }
         return {
           content: [
             {
               type: "text",
               text: `# ${page.title}
-[${page.slug} \xB7 ${page.status} \xB7 updated ${page.pageUpdatedOn ?? "unknown"}` + (page.tags.length ? ` \xB7 ${page.tags.join(", ")}` : "") + `]${sources}
+[${page.slug} \xB7 ${page.status} \xB7 updated ${page.pageUpdatedOn ?? "unknown"}` + (page.tags.length ? ` \xB7 ${page.tags.join(", ")}` : "") + `]${sourcesBlock}
 
 ` + page.content
             }
@@ -12367,15 +13203,22 @@ Sources: ${page.sources.map((s) => `${s.type}:${s.ref}`).join(", ")}` : "";
           "stale",
           "duplicate",
           "unverified",
-          "obsolete-candidate"
+          "obsolete-candidate",
+          "archive-solution"
         ].includes(a.kind) ? a.kind : "feedback";
+        const sourceRef = typeof a.source_ref === "string" ? a.source_ref.trim() : "";
         const res = await fetch(`${dashboardBaseUrl}/api/wiki/flag`, {
           method: "POST",
           headers: {
             "content-type": "application/json",
             authorization: `Bearer ${apiKey}`
           },
-          body: JSON.stringify({ slug, kind, detail })
+          body: JSON.stringify({
+            slug,
+            kind,
+            detail,
+            ...sourceRef ? { source_ref: sourceRef } : {}
+          })
         });
         if (!res.ok) {
           const errDetail = await res.text().catch(() => "");
@@ -12399,11 +13242,12 @@ Sources: ${page.sources.map((s) => `${s.type}:${s.ref}`).join(", ")}` : "";
             ]
           };
         }
+        const dedupeNote = data.flag.deduped ? " (already had an open flag for this source \u2014 reused)" : "";
         return {
           content: [
             {
               type: "text",
-              text: `Flagged ${data.flag.slug} (${kind}). The daily wiki reviewer will pick it up next run; it also shows in the backoffice review queue.`
+              text: `Flagged ${data.flag.slug} (${kind}${sourceRef ? `, ${sourceRef}` : ""})${dedupeNote}. The daily wiki reviewer will pick it up next run; it also shows in the backoffice review queue.`
             }
           ]
         };
@@ -13491,8 +14335,8 @@ ${sample.join("\n")}${files.length > 5 ? `
             };
           const filtered = sortRows(applyFilter(only.rows));
           if (format === "json") {
-            const text14 = filtered.map((c) => JSON.stringify(c)).join("\n") || "(no containers)";
-            return { content: [{ type: "text", text: text14 }] };
+            const text17 = filtered.map((c) => JSON.stringify(c)).join("\n") || "(no containers)";
+            return { content: [{ type: "text", text: text17 }] };
           }
           if (groupByProject) {
             const groups = /* @__PURE__ */ new Map();
@@ -13519,8 +14363,8 @@ ${sample.join("\n")}${files.length > 5 ? `
           }
           const header = `${"NAMES".padEnd(36)}  ${"IMAGE".padEnd(40)}  ${"STATUS".padEnd(24)}  ${"HEALTH".padEnd(10)}  ${"PORTS".padEnd(40)}  PROJECT`;
           const body = filtered.map((r) => `${fmtRow(r)}  ${r.Project || ""}`);
-          const text13 = filtered.length === 0 ? "(no containers match)" : [header, ...body].join("\n");
-          return { content: [{ type: "text", text: text13 }] };
+          const text16 = filtered.length === 0 ? "(no containers match)" : [header, ...body].join("\n");
+          return { content: [{ type: "text", text: text16 }] };
         }
         if (format === "json") {
           const lines = [];
@@ -15044,7 +15888,7 @@ ${lines.join("\n")}`
           );
           let current = await fetchZone();
           if (current.data.records.length === 0) {
-            await sleep(DNS_RETRY_BACKOFF_MS);
+            await sleep2(DNS_RETRY_BACKOFF_MS);
             current = await fetchZone();
           }
           let nextRecords;
@@ -15138,7 +15982,7 @@ ${lines.join("\n")}`
             );
           } catch (err) {
             if (!isTransientMijnhostError(err)) throw err;
-            await sleep(DNS_RETRY_BACKOFF_MS);
+            await sleep2(DNS_RETRY_BACKOFF_MS);
             const refetched = await fetchZone();
             const stillNeedsApply = action === "create" ? !refetched.data.records.some(
               (r) => r.type === type && r.name === dnsName && r.value === (typeof a.value === "string" ? a.value : "")