agent-relay-server 0.57.1 → 0.58.0

package/src/maintenance.ts

@@ -45,7 +45,7 @@ import { workspaceActiveClaim } from "./workspace-claim";
 import { reapOrphanedWorktrees } from "./workspace-orphans";
 import { deriveBranchState, DIRTY_WORKTREE_LAND_SKIP_REASON, READY_TO_LAND_STATUSES, TERMINAL_WORKSPACE_STATUSES } from "./workspace-phase";
 import { errMessage, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
-import { getStewardConfig } from "./config-store";
+import { getStewardConfig, getLandingConfig } from "./config-store";
 import { ensureRepoSteward } from "./steward";
 import { emitRelayEvent } from "./events";
 import { getLifecycleManager } from "./lifecycle-manager";
@@ -809,7 +809,14 @@ async function autoMergeCleanFastForwards(): Promise<Record<string, unknown>> {
       continue;
     }
 
-    const result = requestWorkspaceMerge(ws, { strategy: "rebase-ff", requestedBy: "auto-merge" });
+    // Honor the operator's instance landing.strategy (#419-followup): when PR mode is on
+    // (`landing.strategy = "pr"`), autonomous worker lands must open a PR too — not silently
+    // direct-merge. Passing an explicit "rebase-ff" here SHADOWS the instance config inside
+    // requestWorkspaceMerge (explicit wins over instanceStrategy), which is the bug that made
+    // PR mode never engage for spawned workers. For "pr" we OMIT the explicit strategy so
+    // requestWorkspaceMerge resolves it from the config and defaults autoMerge to "on-green";
+    // the default "direct" keeps the historical deterministic rebase-ff (no behavior change).
+    const result = requestWorkspaceMerge(ws, getLandingConfig().strategy === "pr" ? { requestedBy: "auto-merge" } : { strategy: "rebase-ff", requestedBy: "auto-merge" });
     if (!result.ok) {
       // 409 = another merge holds this repo's lease this tick; retry next sweep.
       heldByLease.push(ws.id);

package/src/mcp-project-tools.ts

@@ -0,0 +1,352 @@
+import {
+  addEdge,
+  addProjectRoot,
+  edgesFor,
+  ensureProject,
+  getAgent,
+  getProject,
+  getProjectEntry,
+  listProjects,
+  promoteBlackboardEntry,
+  removeEdge,
+  resolveProject,
+  resolveProjectEntries,
+  resolveProjectForCwd,
+  retractProjectEntry,
+  rootsForProject,
+  searchProjectEntries,
+  ValidationError,
+  writeProjectEntry,
+} from "./db";
+import { McpNotFoundError } from "./mcp-errors";
+import { ingestClaudeMd } from "./project-ingest";
+import { authContextFromMcp, type AuthContext } from "./services/auth-context";
+import { cleanString, cleanStringArray, optionalEnum } from "./validation";
+import { PROJECT_EDGE_KINDS, PROJECT_ENTRY_KINDS, PROJECT_ENTRY_SOURCES, type ProjectEdgeKind, type ProjectEntryKind, type ProjectEntrySource } from "./types";
+
+// MCP tools for the durable Projects knowledge scope (#405). Mirrors
+// src/mcp-blackboard-tools.ts: same cleanString/cleanStringArray validation and
+// scope-gating shape. Unlike the blackboard (purely caller-team-scoped), a project
+// is durable and cross-cutting and must be addressable: entry verbs take an OPTIONAL
+// `project` ref (id or slug) and fall back to callerProject(auth) — the project
+// resolved from the caller's spawn cwd. That fallback is the blackboard parallel.
+
+export const PROJECT_TOOLS = [
+  {
+    name: "relay_project_list",
+    description: "List the durable projects (the cross-repo knowledge scopes).",
+    requiredScopes: ["project:read"],
+    inputSchema: {
+      type: "object",
+      properties: { includeArchived: { type: "boolean" } },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_get",
+    description: "Fetch one project and its registered roots. Defaults to the caller's resolved project (from its spawn cwd) when `project` is omitted.",
+    requiredScopes: ["project:read"],
+    inputSchema: {
+      type: "object",
+      properties: { project: { type: "string", description: "Project id or slug; defaults to the caller's project." } },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_add_root",
+    description: "Create-or-update a project by slug and register a repo root path. The create-on-first-use entry point for a new project.",
+    requiredScopes: ["project:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        slug: { type: "string" },
+        rootPath: { type: "string" },
+        title: { type: "string" },
+        description: { type: "string" },
+        tenantId: { type: "string" },
+      },
+      required: ["slug", "rootPath"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_write_entry",
+    description: "Create a project-scoped entry (rule/fact/decision/memory). Targets `project` if given, else the caller's resolved project.",
+    requiredScopes: ["project:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project id or slug; defaults to the caller's project." },
+        kind: { type: "string", enum: PROJECT_ENTRY_KINDS },
+        title: { type: "string" },
+        body: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        supersedes: { type: "string" },
+        source: { type: "string", enum: PROJECT_ENTRY_SOURCES },
+        originRef: { type: "string" },
+      },
+      required: ["kind", "title"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_read",
+    description: "Read a project's active entries, optionally filtered by kind. Includes entries inherited from transitive `contains` ancestors (each tagged `inherited:true`) unless `includeInherited:false`. `depends_on` targets are never folded in — read them explicitly via their own `project` ref. Targets `project` if given, else the caller's resolved project.",
+    requiredScopes: ["project:read"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string" },
+        kind: { type: "string", enum: PROJECT_ENTRY_KINDS },
+        includeInactive: { type: "boolean" },
+        includeInherited: { type: "boolean", description: "Default true: merge in contains-ancestor entries. Set false for only this project's own." },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_search",
+    description: "Search a project's active entries by title, body, or tags. Targets `project` if given, else the caller's resolved project.",
+    requiredScopes: ["project:read"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string" },
+        query: { type: "string" },
+        kind: { type: "string", enum: PROJECT_ENTRY_KINDS },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_retract",
+    description: "Retract a project entry without deleting its ledger row. Targets `project` if given, else the caller's resolved project.",
+    requiredScopes: ["project:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string" },
+        id: { type: "string" },
+      },
+      required: ["id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_add_edge",
+    description: "Add a composition-graph edge between two projects. `contains` (umbrella→sub-project) INHERITS — the sub-project's reads pull in the umbrella's entries. `depends_on` is reference-only and never inherits. Cycles are rejected. `from`/`to` are project ids or slugs.",
+    requiredScopes: ["project:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: "Source project id or slug (the umbrella for `contains`, the consumer for `depends_on`)." },
+        to: { type: "string", description: "Target project id or slug (the contained sub-project, or the dependency)." },
+        kind: { type: "string", enum: PROJECT_EDGE_KINDS },
+      },
+      required: ["from", "to", "kind"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_remove_edge",
+    description: "Remove a composition-graph edge between two projects. `from`/`to` are project ids or slugs.",
+    requiredScopes: ["project:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string" },
+        to: { type: "string" },
+        kind: { type: "string", enum: PROJECT_EDGE_KINDS },
+      },
+      required: ["from", "to", "kind"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_promote_entry",
+    description: "Promote an active blackboard finding (`bb_…`) into durable project knowledge. Copies its content as a `promoted` project entry whose `origin_ref` back-references the blackboard id (kinds: decision→decision, fact→fact, ruled_out→rule). Explicit only — nothing is auto-promoted. Re-promoting the same finding supersedes the prior copy rather than duplicating it. Targets `project` if given, else the caller's resolved project.",
+    requiredScopes: ["project:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        blackboardEntryId: { type: "string", description: "The bb_… blackboard entry to promote." },
+        project: { type: "string", description: "Project id or slug; defaults to the caller's project." },
+      },
+      required: ["blackboardEntryId"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_project_ingest_claudemd",
+    description: "Ingest CLAUDE.md from each registered root of a project into project_entries (source:'ingested'), splitting by heading into one entry per section. Idempotent: re-running supersedes prior ingested entries from the same file/section, retracts sections that vanished, and never touches manual/promoted entries. Targets `project` if given, else the caller's resolved project.",
+    requiredScopes: ["project:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project id or slug; defaults to the caller's project." },
+      },
+      additionalProperties: false,
+    },
+  },
+] satisfies Array<{ name: string; description: string; requiredScopes: string[]; inputSchema: Record<string, unknown> }>;
+
+type McpAuthLike = Parameters<typeof authContextFromMcp>[0];
+
+/** The project resolved from the caller's identity: the projectId stamped on the
+ * token at spawn (cwd→root binding), else a live resolution from the caller agent's
+ * cwd. Analogous to callerTeam(auth); returns undefined gracefully when the caller
+ * is in no registered root. */
+function callerProjectId(ctx: AuthContext): string | undefined {
+  if (ctx.constraints?.projectId) return ctx.constraints.projectId;
+  if (!ctx.callerAgentId) return undefined;
+  const agent = getAgent(ctx.callerAgentId);
+  const cwd = typeof agent?.meta?.cwd === "string" ? agent.meta.cwd : undefined;
+  const project = cwd ? resolveProjectForCwd(cwd) : null;
+  return project?.id;
+}
+
+/** Resolve the project an entry verb operates on: the explicit `project` ref (id or
+ * slug) when given, else the caller's resolved project. Throws when neither yields one. */
+function targetProjectId(ctx: AuthContext, explicit: string | undefined): string {
+  if (explicit) {
+    const project = resolveProject(explicit);
+    if (!project) throw new McpNotFoundError("project not found");
+    return project.id;
+  }
+  const id = callerProjectId(ctx);
+  if (!id) throw new ValidationError("no project: pass `project`, or spawn inside a registered project root");
+  return id;
+}
+
+function authorId(ctx: AuthContext): string {
+  return ctx.callerAgentId ?? ctx.actor.id;
+}
+
+function cleanKind(value: unknown): ProjectEntryKind | undefined {
+  return optionalEnum(value, "kind", PROJECT_ENTRY_KINDS) as ProjectEntryKind | undefined;
+}
+
+function cleanEdgeKind(value: unknown): ProjectEdgeKind {
+  const kind = optionalEnum(value, "kind", PROJECT_EDGE_KINDS) as ProjectEdgeKind | undefined;
+  if (!kind) throw new ValidationError(`kind must be one of: ${PROJECT_EDGE_KINDS.join(", ")}`);
+  return kind;
+}
+
+/** Resolve an explicit project ref (id or slug) to its id, or throw not-found. The
+ * graph edges address projects directly, never via caller-cwd fallback. */
+function requireProjectId(ref: unknown, field: string): string {
+  const explicit = cleanString(ref, field, { required: true, max: 200 })!;
+  const project = resolveProject(explicit);
+  if (!project) throw new McpNotFoundError(`project not found: ${explicit}`);
+  return project.id;
+}
+
+function ensureSameProject(entryId: string, projectId: string): void {
+  const entry = getProjectEntry(entryId);
+  if (!entry) throw new McpNotFoundError("project entry not found");
+  if (entry.projectId !== projectId) throw new McpNotFoundError("project entry not found");
+}
+
+export function relayProjectTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Record<string, unknown> {
+  const ctx = authContextFromMcp(auth);
+
+  if (name === "relay_project_list") {
+    return { projects: listProjects({ includeArchived: args.includeArchived === true }) };
+  }
+
+  if (name === "relay_project_get") {
+    const explicit = cleanString(args.project, "project", { max: 200 });
+    const id = explicit
+      ? (resolveProject(explicit)?.id ?? (() => { throw new McpNotFoundError("project not found"); })())
+      : callerProjectId(ctx);
+    if (!id) throw new McpNotFoundError("project not found");
+    const project = getProject(id);
+    if (!project) throw new McpNotFoundError("project not found");
+    return { project, roots: rootsForProject(id), edges: edgesFor(id) };
+  }
+
+  if (name === "relay_project_add_root") {
+    const slug = cleanString(args.slug, "slug", { required: true, max: 200 })!;
+    const rootPath = cleanString(args.rootPath, "rootPath", { required: true, max: 4000 })!;
+    const project = ensureProject({
+      slug,
+      title: cleanString(args.title, "title", { max: 240 }),
+      description: cleanString(args.description, "description", { max: 16_000 }),
+      tenantId: cleanString(args.tenantId, "tenantId", { max: 200 }),
+    });
+    const roots = addProjectRoot(project.id, rootPath);
+    return { project, roots };
+  }
+
+  if (name === "relay_project_write_entry") {
+    const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
+    const kind = cleanKind(args.kind);
+    if (!kind) throw new ValidationError("kind required");
+    const supersedes = cleanString(args.supersedes, "supersedes", { max: 120 });
+    if (supersedes) ensureSameProject(supersedes, projectId);
+    return writeProjectEntry({
+      projectId,
+      authorId: authorId(ctx),
+      kind,
+      title: cleanString(args.title, "title", { required: true, max: 240 })!,
+      body: cleanString(args.body, "body", { max: 16_000 }),
+      tags: cleanStringArray(args.tags, "tags", { itemMax: 80, maxItems: 32 }),
+      supersedes,
+      source: optionalEnum(args.source, "source", PROJECT_ENTRY_SOURCES) as ProjectEntrySource | undefined,
+      originRef: cleanString(args.originRef, "originRef", { max: 200 }),
+    }) as unknown as Record<string, unknown>;
+  }
+
+  if (name === "relay_project_read") {
+    const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
+    return {
+      entries: resolveProjectEntries(projectId, {
+        kind: cleanKind(args.kind),
+        includeInactive: args.includeInactive === true,
+        includeInherited: args.includeInherited !== false,
+      }),
+    };
+  }
+
+  if (name === "relay_project_search") {
+    const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
+    return { entries: searchProjectEntries(projectId, cleanString(args.query, "query", { required: true, max: 240 })!, { kind: cleanKind(args.kind) }) };
+  }
+
+  if (name === "relay_project_retract") {
+    const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
+    const id = cleanString(args.id, "id", { required: true, max: 120 })!;
+    ensureSameProject(id, projectId);
+    const entry = retractProjectEntry(id);
+    if (!entry) throw new McpNotFoundError("project entry not found");
+    return entry as unknown as Record<string, unknown>;
+  }
+
+  if (name === "relay_project_add_edge") {
+    const from = requireProjectId(args.from, "from");
+    const to = requireProjectId(args.to, "to");
+    const edge = addEdge(from, to, cleanEdgeKind(args.kind));
+    return { edge: edge as unknown as Record<string, unknown> };
+  }
+
+  if (name === "relay_project_remove_edge") {
+    const from = requireProjectId(args.from, "from");
+    const to = requireProjectId(args.to, "to");
+    const removed = removeEdge(from, to, cleanEdgeKind(args.kind));
+    return { removed };
+  }
+
+  if (name === "relay_project_promote_entry") {
+    const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
+    const blackboardEntryId = cleanString(args.blackboardEntryId, "blackboardEntryId", { required: true, max: 120 })!;
+    return promoteBlackboardEntry({ blackboardEntryId, projectId }) as unknown as Record<string, unknown>;
+  }
+
+  if (name === "relay_project_ingest_claudemd") {
+    const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
+    return ingestClaudeMd(projectId, authorId(ctx)) as unknown as Record<string, unknown>;
+  }
+
+  throw new ValidationError(`unknown tool: ${name}`);
+}

package/src/mcp.ts

@@ -49,6 +49,7 @@ import { ServiceAuthError } from "./services/errors";
 import { PLAN_TOOLS, relayPlanTool } from "./mcp-plan-tools";
 import { TEAM_TOOLS, relayTeamTool } from "./mcp-team-tools";
 import { BLACKBOARD_TOOLS, relayBlackboardTool } from "./mcp-blackboard-tools";
+import { PROJECT_TOOLS, relayProjectTool } from "./mcp-project-tools";
 import { AGENT_ACTION_TOOL, relayAgentAction } from "./mcp-agent-action";
 import type { ActivityKind, AgentLifecycle, ArtifactKind, ArtifactSensitivity, AttachmentRef, Command, SendMessageInput, Message, SpawnApprovalMode, SpawnProvider, WorkspaceAutoMergePolicy, WorkspaceMergeStrategy, WorkspaceMode, WorkspaceRecord } from "./types";
 import { LAND_STRATEGIES, applyWorkspaceAction, waitForWorkspaceStatus, type WorkspaceAction } from "./workspace-actions";
@@ -459,6 +460,7 @@ const TOOLS: ToolDefinition[] = [
   ...TEAM_TOOLS,
   ...PLAN_TOOLS,
   ...BLACKBOARD_TOOLS,
+  ...PROJECT_TOOLS,
 ];
 
 export async function postMcp(req: Request): Promise<Response> {
@@ -574,6 +576,7 @@ async function callTool(auth: McpAuthContext, params: unknown): Promise<Record<s
     else if (name.startsWith("relay_team_")) result = await relayTeamTool(auth, name, args);
     else if (name.startsWith("relay_plan_")) result = relayPlanTool(auth, name, args);
     else if (name.startsWith("relay_blackboard_")) result = relayBlackboardTool(auth, name, args);
+    else if (name.startsWith("relay_project_")) result = relayProjectTool(auth, name, args);
     else throw new ValidationError(`unknown tool: ${name}`);
 
     auditToolCall(auth, name, "ok", result);

package/src/project-ingest.ts

@@ -0,0 +1,186 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { listProjectEntries, rootsForProject, retractProjectEntry, writeProjectEntry } from "./db";
+import type { ProjectEntry } from "./types";
+
+// CLAUDE.md ingest on-ramp (#407, part of epic #403). Makes git a *feeder* of
+// project knowledge: read CLAUDE.md from each registered root and project its
+// headings into project_entries with source:'ingested'. The parse is deliberately
+// dumb and predictable — split by heading, one entry per heading — not clever.
+//
+// IDEMPOTENT re-ingest is the core invariant: re-running reconciles against the
+// prior 'ingested' entries keyed on origin_ref (file path + section anchor) —
+// unchanged sections are left alone, changed sections supersede their prior entry,
+// and sections that vanished from the file are retracted. `manual` and `promoted`
+// entries are NEVER read or touched by ingest — only source:'ingested' is.
+
+const INGEST_FILENAME = "CLAUDE.md";
+
+export interface ParsedSection {
+  /** Heading text (the entry title). For pre-heading preamble content: "(preamble)". */
+  title: string;
+  /** Section body — lines under the heading up to the next heading, trimmed. May be "". */
+  body: string;
+  /** GitHub-style heading slug, deduped within the file. "" for the preamble section. */
+  anchor: string;
+}
+
+export interface IngestRootResult {
+  rootPath: string;
+  filePath: string;
+  found: boolean;
+  sections: number;
+}
+
+export interface IngestResult {
+  projectId: string;
+  created: number;
+  updated: number;
+  unchanged: number;
+  retracted: number;
+  roots: IngestRootResult[];
+}
+
+const HEADING_RE = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
+
+/** GitHub-style heading slug: lowercase, spaces→hyphens, drop non-word/-/space. */
+function slugify(heading: string): string {
+  return heading
+    .trim()
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+/** Split a CLAUDE.md document into sections by heading. One section per heading
+ * line (any level), body = the lines until the next heading. Content before the
+ * first heading becomes a "(preamble)" section only when it has real content.
+ * Anchors are deduped (`-1`, `-2`, …) so each section gets a stable, unique ref. */
+export function parseClaudeMdSections(content: string): ParsedSection[] {
+  const lines = content.split("\n");
+  const sections: ParsedSection[] = [];
+  const anchorCounts = new Map<string, number>();
+
+  let title: string | null = null; // null until the first heading; preamble accumulates meanwhile
+  let bodyLines: string[] = [];
+
+  const dedupeAnchor = (base: string): string => {
+    const slug = base || "section";
+    const seen = anchorCounts.get(slug) ?? 0;
+    anchorCounts.set(slug, seen + 1);
+    return seen === 0 ? slug : `${slug}-${seen}`;
+  };
+
+  const flush = () => {
+    const body = bodyLines.join("\n").trim();
+    if (title === null) {
+      // Preamble: emit only if it carries real content.
+      if (body) sections.push({ title: "(preamble)", body, anchor: "" });
+    } else {
+      sections.push({ title, body, anchor: dedupeAnchor(slugify(title)) });
+    }
+    bodyLines = [];
+  };
+
+  for (const raw of lines) {
+    const m = raw.match(HEADING_RE);
+    if (m) {
+      flush();
+      title = m[2]!.trim();
+    } else {
+      bodyLines.push(raw);
+    }
+  }
+  flush();
+
+  return sections;
+}
+
+/** The origin_ref for an ingested section: the absolute file path, plus the
+ * section anchor as a fragment when the section came from a heading. */
+function originRefFor(filePath: string, anchor: string): string {
+  return anchor ? `${filePath}#${anchor}` : filePath;
+}
+
+/** Ingest CLAUDE.md from every registered root of a project into project_entries
+ * (source:'ingested'). Idempotent — see the module header. Returns a summary of
+ * what changed. Reads files synchronously; missing CLAUDE.md in a root is skipped
+ * gracefully (found:false), it is not an error. */
+export function ingestClaudeMd(projectId: string, authorId: string): IngestResult {
+  // Index prior *ingested* entries by origin_ref (newest active wins). We only ever
+  // read source:'ingested' here — manual/promoted are invisible to ingest by design.
+  const byOrigin = new Map<string, ProjectEntry>();
+  for (const entry of listProjectEntries(projectId)) {
+    if (entry.source !== "ingested" || !entry.originRef) continue;
+    if (!byOrigin.has(entry.originRef)) byOrigin.set(entry.originRef, entry);
+  }
+
+  const seen = new Set<string>();
+  const roots: IngestRootResult[] = [];
+  let created = 0;
+  let updated = 0;
+  let unchanged = 0;
+
+  for (const root of rootsForProject(projectId)) {
+    const filePath = join(root.rootPath, INGEST_FILENAME);
+    let content: string;
+    try {
+      content = readFileSync(filePath, "utf8");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        roots.push({ rootPath: root.rootPath, filePath, found: false, sections: 0 });
+        continue;
+      }
+      throw err;
+    }
+
+    const sections = parseClaudeMdSections(content);
+    for (const section of sections) {
+      const originRef = originRefFor(filePath, section.anchor);
+      seen.add(originRef);
+      const prior = byOrigin.get(originRef);
+      if (prior) {
+        if (prior.title === section.title && (prior.body ?? "") === section.body) {
+          unchanged++;
+          continue;
+        }
+        writeProjectEntry({
+          projectId,
+          authorId,
+          kind: "rule",
+          title: section.title,
+          body: section.body || undefined,
+          source: "ingested",
+          originRef,
+          supersedes: prior.id,
+        });
+        updated++;
+      } else {
+        writeProjectEntry({
+          projectId,
+          authorId,
+          kind: "rule",
+          title: section.title,
+          body: section.body || undefined,
+          source: "ingested",
+          originRef,
+        });
+        created++;
+      }
+    }
+    roots.push({ rootPath: root.rootPath, filePath, found: true, sections: sections.length });
+  }
+
+  // Retract ingested entries whose section disappeared from the file (or whose
+  // file is gone) — they were not re-seen this pass. Never touches manual/promoted.
+  let retracted = 0;
+  for (const [originRef, entry] of byOrigin) {
+    if (seen.has(originRef)) continue;
+    retractProjectEntry(entry.id);
+    retracted++;
+  }
+
+  return { projectId, created, updated, unchanged, retracted, roots };
+}

package/src/routes/index.ts

@@ -28,6 +28,7 @@ import { getOrchestratorDirectories, getOrchestratorFileRead, getOrchestratorFil
 import { getPairById, getPairs, postAcceptPair, postHangupPair, postPair, postPairMessage, postRejectPair } from "./pairs";
 import { getPlanByIdRoute, getPlansRoute } from "./plans";
 import { getBlackboardEntryRoute, getBlackboardRoute } from "./blackboard";
+import { getProjectEntriesRoute, getProjectEntryRoute, getProjectRoute, getProjectsRoute } from "./projects";
 import { getRecipeByName, getRecipeInstanceArtifacts, getRecipeInstanceById, getRecipeInstances, getRecipes, postRecipeInstanceArtifacts, postRecipeStart, postRecipeStop } from "./recipes";
 import { getStewardConfigRoute, getWorkspaceConfigRoute, putStewardConfigRoute, putWorkspaceConfigRoute } from "./steward";
 import { getTaskById, getTaskEvents, getTasks, patchTaskStatus, postClaimTask, postRenewTaskClaim } from "./tasks";
@@ -280,6 +281,10 @@ const routes: Route[] = [
   route("GET", "/api/plans/:id", getPlanByIdRoute),
   route("GET", "/api/blackboard", getBlackboardRoute),
   route("GET", "/api/blackboard/:id", getBlackboardEntryRoute),
+  route("GET", "/api/projects", getProjectsRoute),
+  route("GET", "/api/projects/:id", getProjectRoute),
+  route("GET", "/api/projects/:id/entries", getProjectEntriesRoute),
+  route("GET", "/api/projects/:id/entries/:entryId", getProjectEntryRoute),
 
   route("GET", "/api/spec", getApiSpec),
   route("GET", "/api/docs", getApiDocs),

package/src/routes/projects.ts

@@ -0,0 +1,55 @@
+import { getProjectEntry, getProjectEntryChain, listProjectEntries, listProjects, resolveProject, rootsForProject } from "../db";
+import { cleanString, optionalEnum } from "../validation";
+import { error, json, type Handler } from "./_shared";
+import { PROJECT_ENTRY_KINDS, type ProjectEntryKind } from "../types";
+
+// Read routes for the durable Projects scope (#405), templated on routes/blackboard.ts.
+// Writes go through MCP (relay_project_*), mirroring the blackboard precedent where the
+// HTTP surface is read-only. Scope-gated /api/projects → project:read in src/security.ts.
+
+function routeKind(req: Request): ProjectEntryKind | undefined {
+  return optionalEnum(new URL(req.url).searchParams.get("kind") ?? undefined, "kind", PROJECT_ENTRY_KINDS) as ProjectEntryKind | undefined;
+}
+
+export const getProjectsRoute: Handler = (req) => {
+  try {
+    const includeArchived = new URL(req.url).searchParams.get("includeArchived") === "true";
+    return json({ projects: listProjects({ includeArchived }) });
+  } catch (err) {
+    return error(err instanceof Error ? err.message : "projects route failed");
+  }
+};
+
+export const getProjectRoute: Handler = (req, params) => {
+  try {
+    const ref = cleanString(params.id, "id", { required: true, max: 200 })!;
+    const project = resolveProject(ref);
+    if (!project) return error("project not found", 404);
+    return json({ project, roots: rootsForProject(project.id) });
+  } catch (err) {
+    return error(err instanceof Error ? err.message : "projects route failed");
+  }
+};
+
+export const getProjectEntriesRoute: Handler = (req, params) => {
+  try {
+    const ref = cleanString(params.id, "id", { required: true, max: 200 })!;
+    const project = resolveProject(ref);
+    if (!project) return error("project not found", 404);
+    const includeInactive = new URL(req.url).searchParams.get("includeInactive") === "true";
+    return json({ entries: listProjectEntries(project.id, { kind: routeKind(req), includeInactive }) });
+  } catch (err) {
+    return error(err instanceof Error ? err.message : "projects route failed");
+  }
+};
+
+export const getProjectEntryRoute: Handler = (req, params) => {
+  try {
+    const id = cleanString(params.entryId, "entryId", { required: true, max: 120 })!;
+    const entry = getProjectEntry(id);
+    if (!entry) return error("project entry not found", 404);
+    return json({ entry, chain: getProjectEntryChain(id) });
+  } catch (err) {
+    return error(err instanceof Error ? err.message : "projects route failed");
+  }
+};