@monster-orange/den 0.2.7 → 0.2.8

package/src/ui/mcp/tools.ts

@@ -33,12 +33,27 @@ import {
   type ServiceEntryLike,
   type SecurityPlanLike,
 } from "./guards.js";
+import {
+  ScopeRefusal,
+  assertPathInScope,
+  assertScopeExists,
+  assertScopeFocused,
+  assertServicesInScope,
+  filterWorkspacesBody,
+  pinWorkspace,
+  type McpScope,
+} from "./scope.js";
 
 export interface ToolContext {
   api: DenApi;
   cfg: ResolvedMcpConfig;
   /** The CLI name, for messages (`<cli> web up`). */
   cli: string;
+  /**
+   * A scoped server's workspace and actor (AG-2a-core); absent, every tool
+   * behaves as it always has.
+   */
+  scope?: McpScope;
 }
 
 type Args = Record<string, unknown>;
@@ -193,7 +208,10 @@ const READ_TOOLS: DenTool[] = [
     "Workspaces",
     "Workspaces, which are active and which is focused.",
     {},
-    (_a, { api }) => api.get("/api/workspaces"),
+    async (_a, { api, scope }) => {
+      const body = await api.get("/api/workspaces");
+      return scope ? filterWorkspacesBody(body, scope) : body;
+    },
   ),
   read(
     "environments",
@@ -215,9 +233,19 @@ const READ_TOOLS: DenTool[] = [
         .describe("repo/service names"),
       env: envArg,
     },
-    async (a, { api, cfg }) => {
+    async (a, { api, cfg, scope }) => {
       const env = envOf(a);
       assertLogsEnv(env, cfg);
+      if (scope)
+        await assertServicesInScope(
+          "logs_search",
+          api,
+          scope,
+          (a.targets as string[]).map((t) => {
+            const slash = t.lastIndexOf("/");
+            return { repo: t.slice(0, slash), service: t.slice(slash + 1) };
+          }),
+        );
       return api.get("/api/logs/search", {
         q: String(a.q),
         env,
@@ -241,9 +269,13 @@ const READ_TOOLS: DenTool[] = [
         .describe("Lines to return (default 200)"),
       env: envArg,
     },
-    async (a, { api, cfg }) => {
+    async (a, { api, cfg, scope }) => {
       const env = envOf(a);
       assertLogsEnv(env, cfg);
+      if (scope)
+        await assertServicesInScope("logs_tail", api, scope, [
+          { repo: String(a.repo), service: String(a.service) },
+        ]);
       const n = (a.lines as number | undefined) ?? 200;
       const query: Query = { repo: String(a.repo), service: String(a.service) };
       const r =
@@ -270,11 +302,17 @@ const READ_TOOLS: DenTool[] = [
     "Available tests",
     "The test modules of a pillar, and which repos (branch + SHA) they come from.",
     { pillar: z.enum(PILLARS) },
-    async (a, { api }) => ({
-      modules: await api.get("/api/modules", { pillar: String(a.pillar) }),
-      sources: await api.get("/api/test-sources", { pillar: String(a.pillar) }),
-    }),
+    async (a, { api, scope }) => {
+      if (scope) await assertScopeFocused("tests_available", api, scope);
+      return {
+        modules: await api.get("/api/modules", { pillar: String(a.pillar) }),
+        sources: await api.get("/api/test-sources", {
+          pillar: String(a.pillar),
+        }),
+      };
+    },
   ),
+
   read(
     "security_latest",
     "Latest security scans",
@@ -307,13 +345,20 @@ const READ_TOOLS: DenTool[] = [
       path: z.string().optional().describe("Repo directory or manifest file"),
       content: z.string().optional().describe("Manifest YAML to validate"),
     },
-    async (a, { api }) => {
+    async (a, { api, scope }) => {
       if (str(a.content) !== undefined)
         return api.get("/api/manifest/validate", {}, "POST", {
           content: a.content,
         });
       if (str(a.path) === undefined)
         throw new Refusal("give a path or the manifest content.");
+      if (scope)
+        await assertPathInScope(
+          "manifest_validate",
+          api,
+          scope,
+          String(a.path),
+        );
       return api.get("/api/manifest/validate", { path: str(a.path) });
     },
   ),
@@ -447,19 +492,27 @@ const ACTION_TOOLS: Record<McpAction, DenTool> = {
     shape: {
       repo: z.string().optional().describe("One managed repo (default: all)"),
     },
-    async run(a, { api }) {
+    async run(a, { api, scope }) {
       const repo = str(a.repo);
+      // Scoped: the sync names the scoped workspace (the web server's own
+      // default is the focused one).
+      const ws = scope ? { workspace: scope.workspace } : {};
       if (repo) {
         const services = (await api.get("/api/services", {
           env: "local",
+          ...ws,
         })) as ServiceEntryLike[];
         assertSyncableRepo(repo, services);
       }
-      const r = await api.stream("/api/workspace/sync", repo ? { repo } : {}, {
-        method: "POST",
-        maxLines: 5000,
-        timeoutMs: 15 * 60_000,
-      });
+      const r = await api.stream(
+        "/api/workspace/sync",
+        repo ? { repo, ...ws } : { ...ws },
+        {
+          method: "POST",
+          maxLines: 5000,
+          timeoutMs: 15 * 60_000,
+        },
+      );
       return actionResult(r, 300);
     },
   },
@@ -478,13 +531,14 @@ const ACTION_TOOLS: Record<McpAction, DenTool> = {
         .optional()
         .describe("Security scan mode (default baseline)"),
     },
-    async run(a, { api, cfg }) {
+    async run(a, { api, cfg, scope }) {
       const pillar = String(a.pillar);
       const env = envOf(a);
       const modules = (a.modules as string[] | undefined) ?? [];
       const mode =
         pillar === "security" ? (str(a.mode) ?? "baseline") : undefined;
       assertRunTestsAllowed({ pillar, env, mode }, cfg);
+      if (scope) await assertScopeFocused("run_tests", api, scope);
       if (pillar === "security") {
         for (const service of modules.length ? modules : [undefined]) {
           const plan = (await api.get("/api/security/plan", {
@@ -599,6 +653,10 @@ async function reportRefusal(
       tool,
       ...(typeof args.repo === "string" ? { repo: args.repo } : {}),
       ...(typeof args.service === "string" ? { service: args.service } : {}),
+      ...(Array.isArray(args.targets) ? { targets: args.targets } : {}),
+      // A path (manifest_validate): the server records it under the catalog
+      // repo it is inside, never as the path itself.
+      ...(typeof args.path === "string" ? { path: args.path } : {}),
       reason,
     });
   } catch {
@@ -606,6 +664,27 @@ async function reportRefusal(
   }
 }
 
+/**
+ * A scoped server's arguments: the workspace exists (checked once per
+ * server), and a tool that takes a workspace gets the scoped one; naming
+ * another is refused.
+ */
+const verifiedScopes = new WeakSet<McpScope>();
+async function scopeArgs(
+  tool: DenTool,
+  args: Args,
+  ctx: ToolContext,
+  scope: McpScope,
+): Promise<Args> {
+  if (!verifiedScopes.has(scope)) {
+    await assertScopeExists(ctx.api, scope);
+    verifiedScopes.add(scope);
+  }
+  return "workspace" in tool.shape
+    ? pinWorkspace(tool.name, args, scope)
+    : args;
+}
+
 export async function callTool(
   name: string,
   args: Args,
@@ -618,7 +697,10 @@ export async function callTool(
       isError: true,
     };
   try {
-    const out = await tool.run(args, ctx);
+    const out = await tool.run(
+      ctx.scope ? await scopeArgs(tool, args, ctx, ctx.scope) : args,
+      ctx,
+    );
     const text = typeof out === "string" ? out : JSON.stringify(out, null, 2);
     return { text: redactSecrets(text), isError: false };
   } catch (e) {
@@ -633,7 +715,9 @@ export async function callTool(
       );
       return { text: redactSecrets(text), isError: true };
     }
-    if (e instanceof Refusal && tool.action)
+    // A call outside a scoped server's workspace is recorded whatever the
+    // tool: it is an attempt to cross the boundary (AG-2a-core).
+    if (e instanceof Refusal && (tool.action || e instanceof ScopeRefusal))
       await reportRefusal(ctx, name, args, e.message);
     const msg =
       e instanceof Refusal

package/src/ui/server/audit.ts

@@ -5,6 +5,7 @@
  * as the web-server log, so agent actions sit beside the UI's own; the
  * structured entries are kept in a small in-memory ring.
  */
+import * as path from "path";
 import {
   actorLabel,
   type Actor,
@@ -20,6 +21,10 @@ export interface AuditEntry {
   clientVersion?: string;
   mcpPid?: number | null;
   session?: string;
+  /** A scoped MCP server's actor, `agent:<id>` (AG-2a-core). */
+  agent?: string;
+  /** The workspace that scoped server is pinned to. */
+  workspace?: string;
   /** exec | run | sync, or the MCP tool name for a refused non-lifecycle call */
   verb: string;
   detail: string;
@@ -27,6 +32,11 @@ export interface AuditEntry {
   outcome?: "refused";
   /** Why it was refused (first line). */
   reason?: string;
+  /**
+   * The services (`repo/service`) or repos a refused non-lifecycle call
+   * named, so each one's activity list shows it (`GET /api/activity`).
+   */
+  addresses?: string[];
 }
 
 type Sink = (line: string, actor: AgentActor | null) => void;
@@ -52,6 +62,7 @@ export function recordAction(
     detail: string;
     outcome?: "refused";
     reason?: string;
+    addresses?: string[];
   },
 ): AuditEntry {
   const entry: AuditEntry = {
@@ -63,19 +74,28 @@ export function recordAction(
           clientVersion: actor.clientVersion,
           mcpPid: actor.mcpPid,
           session: actor.session,
+          ...(actor.agent ? { agent: actor.agent } : {}),
+          ...(actor.workspace ? { workspace: actor.workspace } : {}),
         }
       : {}),
     verb: action.verb,
     detail: action.detail,
     ...(action.outcome ? { outcome: action.outcome } : {}),
     ...(action.reason ? { reason: clean(action.reason, 300) } : {}),
+    ...(action.addresses?.length ? { addresses: action.addresses } : {}),
   };
   ring.push(entry);
   if (ring.length > RING_MAX) ring.shift();
   const mark = entry.outcome === "refused" ? "✗" : "▶";
   const why = entry.reason ? ` — refused: ${entry.reason}` : "";
+  // A refusal whose detail is its reason names what it touched instead.
+  const what = entry.addresses
+    ? entry.addresses.join(", ")
+    : entry.reason && action.detail === entry.reason
+      ? ""
+      : action.detail;
   sink?.(
-    `${mark} ${action.verb} ${action.detail}${why}${actorSuffix(actor)}`,
+    `${mark} ${action.verb}${what ? ` ${what}` : ""}${why}${actorSuffix(actor)}`,
     actor,
   );
   return entry;
@@ -92,12 +112,51 @@ function clean(v: unknown, max: number): string {
 
 const SAFE_PART = /^[A-Za-z0-9._-]{1,128}$/;
 const LIFECYCLE_TOOL = /^service_(up|down|restart)$/;
+/** At most this many targets of one refused call are recorded. */
+const MAX_ADDRESSES = 40;
+
+/** `repo/service` (or `repo`) when every part is a safe name, else "". */
+function safeAddress(repo: string, service = ""): string {
+  if (!SAFE_PART.test(repo)) return "";
+  return service && SAFE_PART.test(service) ? `${repo}/${service}` : repo;
+}
+
+/**
+ * What a refused call named: its `repo` (with `service`), else each of its
+ * `targets` (`repo/service`, as logs_search takes them), deduplicated.
+ */
+function refusedAddresses(report: {
+  repo?: unknown;
+  service?: unknown;
+  targets?: unknown;
+}): string[] {
+  const out: string[] = [];
+  if (typeof report.repo === "string") {
+    const a = safeAddress(
+      report.repo,
+      typeof report.service === "string" ? report.service : "",
+    );
+    if (a) out.push(a);
+  }
+  if (Array.isArray(report.targets))
+    for (const t of report.targets.slice(0, MAX_ADDRESSES)) {
+      if (typeof t !== "string") continue;
+      const slash = t.lastIndexOf("/");
+      const a =
+        slash > 0
+          ? safeAddress(t.slice(0, slash), t.slice(slash + 1))
+          : safeAddress(t);
+      if (a && !out.includes(a)) out.push(a);
+    }
+  return out;
+}
 
 /**
  * An MCP guard refused an agent's call before it reached an action route.
  * The agent's own report, so every field is sanitised: a lifecycle tool with
  * a valid repo becomes an "exec" entry for that service (what the panel's
- * activity list shows); anything else is recorded under the tool's name.
+ * activity list shows); anything else is recorded under the tool's name,
+ * with the refusal as its detail and the services it named as `addresses`.
  */
 export function recordAgentRefusal(
   actor: Actor,
@@ -105,6 +164,7 @@ export function recordAgentRefusal(
     tool?: unknown;
     repo?: unknown;
     service?: unknown;
+    targets?: unknown;
     reason?: unknown;
   },
 ): AuditEntry {
@@ -123,14 +183,41 @@ export function recordAgentRefusal(
       reason,
     });
   }
+  // Any other tool: the refusal is the detail, under every service or repo
+  // the call named (all of a logs_search's targets, in one entry).
   return recordAction(actor, {
     verb: tool,
-    detail: "",
+    detail: reason,
     outcome: "refused",
     reason,
+    addresses: refusedAddresses(report),
   });
 }
 
+/**
+ * The catalog repo a refused call's `path` is inside (manifest_validate), so
+ * the refusal shows in that repo's activity: the repo whose checkout is the
+ * path or holds it, the deepest when checkouts nest. Null for a relative
+ * path or one inside no repo. The path itself is never recorded.
+ */
+export function repoAtPath(
+  p: unknown,
+  repos: readonly { repoName: string; repoPath: string }[],
+): string | null {
+  if (typeof p !== "string" || p.length > 4096 || !path.isAbsolute(p))
+    return null;
+  const target = path.resolve(p);
+  let best: { repoName: string; depth: number } | null = null;
+  for (const r of repos) {
+    if (!r.repoPath || !path.isAbsolute(r.repoPath)) continue;
+    const root = path.resolve(r.repoPath);
+    if (target !== root && !target.startsWith(root + path.sep)) continue;
+    if (!best || root.length > best.depth)
+      best = { repoName: r.repoName, depth: root.length };
+  }
+  return best && SAFE_PART.test(best.repoName) ? best.repoName : null;
+}
+
 /** The most recent actions, oldest first. */
 export function recentActions(): AuditEntry[] {
   return ring.slice();

package/src/ui/server/github-service.ts

@@ -9,6 +9,7 @@ import { execFileSync, execSync } from "child_process";
 import * as path from "path";
 import { readDenConfig } from "../../shared/den-config.js";
 import { readCatalog } from "../../shared/environment-manager/catalog.js";
+import { githubOwnersOf } from "../../shared/org-sources.js";
 import {
   GH_API_TIMEOUT_MS,
   GIT_REMOTE_TIMEOUT_MS,
@@ -183,7 +184,11 @@ export class GitHubService {
     const config = readDenConfig();
     const orgs = new Set<string>();
     if (config.github_org) orgs.add(config.github_org);
-    for (const id of Object.keys(config.orgs ?? {})) orgs.add(id);
+    // A legacy `orgs:` key is a GitHub owner; an ORG-1d org lists its GitHub
+    // sources' owners, and one with no GitHub source adds none (discovery is
+    // hidden for it).
+    for (const id of Object.keys(config.orgs ?? {}))
+      for (const owner of githubOwnersOf(id, config.orgs)) orgs.add(owner);
     for (const entry of Object.values(readCatalog() ?? {})) {
       if (entry?.gh && entry.gh.includes("/")) {
         orgs.add(entry.gh.slice(0, entry.gh.indexOf("/")));

package/src/ui/server/index.ts

@@ -50,6 +50,7 @@ import {
   getWorkspaceByName,
   isWorkspaceActive,
   listWorkspaceServices,
+  readWorkspacesFile,
   resolveDepAddress,
   parseAddress,
   readManifestAnyBranch,
@@ -96,6 +97,7 @@ import {
   getServiceLogPath,
 } from "../../shared/process/spawn-streaming.js";
 import {
+  assertDenConfigValid,
   readDenConfig,
   isProductionEnv,
   isLocalEnabled,
@@ -106,6 +108,11 @@ import {
   writeUserReleaseConfig,
   type ReleaseConfig,
 } from "../../shared/den-config.js";
+import {
+  CONFIG_ERROR_STATUS,
+  configErrorBody,
+  isConfigError,
+} from "../../shared/config-error.js";
 import { readOrg } from "../../shared/org.js";
 import { engineVersion, getDistRoot } from "../../shared/paths.js";
 import { enginePath } from "../../shared/engine.js";
@@ -143,6 +150,7 @@ import {
   actorSuffix,
   recordAction,
   recordAgentRefusal,
+  repoAtPath,
   setAuditSink,
 } from "./audit.js";
 import { handleReadonlyRoutes } from "./readonly-routes.js";
@@ -417,6 +425,26 @@ const STATIC_EXTS = new Set([
   ".woff2",
 ]);
 
+/** Every workspace's checkouts (active or not), for repoAtPath. */
+function allWorkspaceCheckouts(): ResolvedService[] {
+  const catalog = readCatalog();
+  return Object.entries(readWorkspacesFile().workspaces).flatMap(
+    ([name, config]) => listWorkspaceServices(config, catalog, name),
+  );
+}
+
+/**
+ * API routes that answer whatever the config holds: the identity probe the
+ * CLI and MCP use to find this server, its own log (where a config error is
+ * also written), the changelog, and restarting it.
+ */
+const CONFIG_FREE_ROUTES = new Set([
+  "/api/server-info",
+  "/api/server-log",
+  "/api/changelog",
+  "/api/web/restart",
+]);
+
 // ── Sudo password store ───────────────────────────────────────────────────────
 import {
   setSudoPassword,
@@ -609,6 +637,13 @@ async function handleRequest(
     }
   }
 
+  // ── Config validation ──────────────────────────────────────────────────────
+  // A config that fails validation answers every API route that reads it as
+  // the ConfigError the handler below maps to 422 JSON, before any route's own
+  // catch can turn it into a 400, a 500 or an empty list. Pages still load.
+  if (pathname.startsWith("/api/") && !CONFIG_FREE_ROUTES.has(pathname))
+    assertDenConfigValid();
+
   // ── Static UI ──────────────────────────────────────────────────────────────
   // Local Dev is the default page when local environment is enabled.
   if (
@@ -690,6 +725,9 @@ async function handleRequest(
 
   // ── API: environments ──────────────────────────────────────────────────────
   // Orgs the catalog's repos belong to, with config/den.yml display names.
+  // ORG-1d: a repo's org is an org listing it, else one whose source claims
+  // its owner, else its GitHub owner; a claimed owner is not listed. Service
+  // rows keep `org` as the repo's GitHub owner (C3).
   // Each entry also says whether it is the default org (`github_org`) and
   // which workspaces on this machine belong to it (ORG-1a). Nothing else
   // changes: same entries, order and fields (ORG-SPEC C3).
@@ -704,7 +742,7 @@ async function handleRequest(
     );
     if (url.searchParams.get("repos") !== "1") return sendJson(res, orgs);
     const repos = Object.fromEntries(
-      Object.keys(catalog).map((r) => [r, orgOf(r, catalog)]),
+      Object.keys(catalog).map((r) => [r, orgOf(r, catalog, ctx.config.orgs)]),
     );
     return sendJson(res, { orgs, repos });
   }
@@ -809,6 +847,17 @@ async function handleRequest(
     } catch {
       return send400(res, "invalid JSON");
     }
+    // A call that named a path (manifest_validate) is recorded under the
+    // catalog repo that path is inside, across every workspace's checkouts.
+    if (typeof report.repo !== "string" && report.path !== undefined) {
+      let repo: string | null = null;
+      try {
+        repo = repoAtPath(report.path, allWorkspaceCheckouts());
+      } catch {
+        /* unresolvable workspaces: recorded under the tool only */
+      }
+      if (repo) report = { ...report, repo };
+    }
     const entry = recordAgentRefusal(actor, report);
     return sendJson(res, { recorded: true, ts: entry.ts });
   }
@@ -3152,6 +3201,21 @@ const server = http.createServer((req, res) => {
   // rejection — which CRASHES the whole server on modern Node (freezing every
   // health dot) and leaves the request hanging. Fail the one request instead.
   handleRequest(req, res).catch((err) => {
+    // A config that fails validation is the user's to fix: name it to the
+    // caller as JSON (the {ok, error, code} frame), not a bare 500.
+    if (isConfigError(err)) {
+      serverLog(
+        `  ⚠ ${req.method} ${(req.url ?? "").split("?")[0]}: ${err.message}`,
+      );
+      try {
+        if (!res.headersSent)
+          return sendJson(res, configErrorBody(err), CONFIG_ERROR_STATUS);
+        res.end();
+      } catch {
+        /* socket already gone */
+      }
+      return;
+    }
     console.error(`[server] ${req.method} ${req.url} failed:`, err);
     try {
       if (!res.headersSent) {

package/src/ui/server/public/panel.js

@@ -781,7 +781,7 @@ function activityList(x) {
     .then(({ entries = [] }) => {
       if (!live) return;
       el.innerHTML = entries.length
-        ? `<ol class="act">${entries.map((a) => `<li><time datetime="${esc(a.ts)}">${esc(hhmm(a.ts))}</time><span class="dg-who ${a.actor === "agent" ? "agent" : ""}">${esc(a.actor === "agent" ? "[agent]" + (a.client ? " " + a.client : "") : "you")}</span><span>${esc(a.verb)} ${esc(a.detail)}${a.outcome === "refused" ? ` <em class="refused">refused: ${esc(a.reason || "")}</em>` : ""}</span></li>`).join("")}</ol>`
+        ? `<ol class="act">${entries.map((a) => `<li><time datetime="${esc(a.ts)}">${esc(hhmm(a.ts))}</time><span class="dg-who ${a.actor === "agent" ? "agent" : ""}">${esc(a.actor === "agent" ? (a.agent ? "[" + a.agent + "]" : "[agent]") + (a.client ? " " + a.client : "") : "you")}</span><span>${esc(a.verb)} ${esc(a.detail)}${a.outcome === "refused" ? ` <em class="refused">refused: ${esc(a.reason || "")}</em>` : ""}</span></li>`).join("")}</ol>`
         : none(
             "No actions yet. Starts, restarts and syncs, yours and agents', show here.",
           );

package/src/ui/server/readonly-routes.ts

@@ -96,13 +96,22 @@ export function activityFor(
   // and for each of its services.
   const repoLevel = (e: AuditEntry, repo: string): boolean =>
     e.verb === "exec" && e.detail.startsWith(repo + " ");
+  // A refused non-lifecycle call (logs_tail, logs_search, …) is listed under
+  // each service or repo it named.
+  const named = (e: AuditEntry, hit: (a: string) => boolean): boolean =>
+    (e.addresses ?? []).some(hit);
   const matches = (e: AuditEntry): boolean => {
-    if (target.address)
+    if (target.address) {
+      const address = target.address;
+      const repo = address.split("/")[0];
       return (
-        (e.verb === "exec" && e.detail.startsWith(target.address + " ")) ||
-        repoLevel(e, target.address.split("/")[0])
+        (e.verb === "exec" && e.detail.startsWith(address + " ")) ||
+        repoLevel(e, repo) ||
+        named(e, (a) => a === address || a === repo)
       );
+    }
     const repo = target.repo ?? "";
+    if (named(e, (a) => a === repo || a.startsWith(repo + "/"))) return true;
     if (e.verb === "exec")
       return e.detail.startsWith(repo + "/") || repoLevel(e, repo);
     if (e.verb === "sync") return e.detail.split(" ").includes(`repo=${repo}`);

package/src/ui/server/release-service.ts

@@ -19,6 +19,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { GH_API_TIMEOUT_MS } from "../../shared/constants.js";
 import {
+  readDenConfig,
   readExplicitReleaseOrg,
   readReleaseConfig,
   releaseOwnerFor,
@@ -29,6 +30,11 @@ import {
 } from "../../shared/den-config.js";
 import { readCatalog } from "../../shared/environment-manager/catalog.js";
 import { orgOf } from "../../shared/manifest/service-links.js";
+import {
+  ghOwnerOf,
+  isSourcedOrg,
+  orgHasGithub,
+} from "../../shared/org-sources.js";
 import { listReposWithManifests } from "../../shared/manifest/workspace-manifests.js";
 
 import { product } from "../../shared/product.js";
@@ -258,10 +264,10 @@ export class ReleaseService {
     const known = new Set(cfg.repos.map((r) => r.name));
     return {
       ...cfg,
-      repos: [
+      repos: releasableOnGithub([
         ...cfg.repos,
         ...manifestReleaseRepos().filter((r) => !known.has(r.name)),
-      ],
+      ]),
     };
   }
 
@@ -274,7 +280,8 @@ export class ReleaseService {
   private ownerFor(repo: string, cfg: ReleaseConfig): string {
     return releaseOwnerFor({
       explicitOrg: readExplicitReleaseOrg(),
-      catalogOwner: orgOf(repo, readCatalog()),
+      // The repo's GitHub owner, never its ORG-1d org id (which needn't be one).
+      catalogOwner: ghOwnerOf(readCatalog()[repo]),
       githubOrg: cfg.org,
     });
   }
@@ -1122,6 +1129,21 @@ export async function readVersionSha(
   }
 }
 
+/**
+ * Release repos less those of an org with no GitHub source (ORG-1d): their
+ * release flow needs GitHub, so the Release page hides them rather than
+ * failing. With no ORG-1d keys every repo stays.
+ */
+export function releasableOnGithub(repos: ReleaseRepo[]): ReleaseRepo[] {
+  const orgs = readDenConfig().orgs ?? {};
+  if (!Object.values(orgs).some(isSourcedOrg)) return repos;
+  const catalog = readCatalog();
+  return repos.filter((r) => {
+    const org = orgOf(r.name, catalog, orgs);
+    return !org || orgHasGithub(org, orgs);
+  });
+}
+
 /** Workspace repos whose manifest has a `release:` block, as release repos. */
 export function manifestReleaseRepos(): ReleaseRepo[] {
   const catalog = readCatalog();