@yannelli/paseo-linear-plugin 1.1.0-beta.2 → 1.1.0-beta.3

package/server/live.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 import type { PluginServerContext } from "@getpaseo/plugin/server";
 import { z } from "zod";
 import { relativePath } from "../shared/activity";
+import { knowledgeLines, liveProjectRpc, type ProjectKnowledge, resolvePaths, toAreaRef } from "../shared/knowledge";
 import { type IssueDetail, ISSUE_CARD_KIND } from "../shared/linear";
 import {
   ExploreResultSchema,
@@ -29,6 +30,7 @@ import {
   startInternalRun,
 } from "./agent-runs";
 import type { LinearAccess } from "./handlers";
+import { type KnowledgeService, knowledgeFor } from "./knowledge";
 import { fileLinks } from "./links";
 import { subagentLogs } from "./subagent-logs";
 import type { LaunchQueue, MapStore } from "./stores";
@@ -97,8 +99,9 @@ export async function listDirectories(cwd: string, dirs: readonly string[]) {
   return results;
 }
 
-export function explorePrompt(issue: IssueDetail): string {
+export function explorePrompt(issue: IssueDetail, knowledge: ProjectKnowledge | null = null): string {
   const keys = [issue.identifier, ...issue.children.map((child) => child.identifier)];
+  const map = knowledgeLines(knowledge);
   return [
     `Map this repository for Linear issue ${issue.identifier}: ${issue.title}`,
     "",
@@ -106,6 +109,7 @@ export function explorePrompt(issue: IssueDetail): string {
     "",
     issueSnapshot(issue, { includeComments: false }),
     "",
+    ...(map.length > 0 ? [...map, ""] : []),
     "List the files an engineer will most likely read or change for this issue and each sub-issue.",
     `Include files that will probably be created, at their expected path. List at most ${MAX_EXPLORE_FILES} files.`,
     `Set "issue" to the sub-issue key the file belongs to, or ${issue.identifier} for the whole issue.`,
@@ -138,6 +142,7 @@ export interface LiveDependencies {
   access: LinearAccess;
   maps: MapStore;
   launches: LaunchQueue;
+  knowledge: KnowledgeService;
   readSettings(): Promise<LinearSettings | null>;
 }
 
@@ -159,7 +164,7 @@ export async function startLaunch(workspace: WorkspaceHandle, launch: LaunchInpu
 }
 
 export function registerLive(server: PluginServerContext, dependencies: LiveDependencies) {
-  const { access, maps, launches, readSettings } = dependencies;
+  const { access, maps, launches, knowledge, readSettings } = dependencies;
   const jobs = createJobStore<IssueMap>();
   const recovering = new Map<string, Promise<Job | null>>();
   const recoveredAt = new Map<string, number>();
@@ -230,6 +235,14 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
     return { links: await fileLinks(agent.cwd, files) };
   });
 
+  server.handle(liveProjectRpc, async ({ agentId, paths }, { paseo }) => {
+    const agent = await agentInfo(paseo, agentId);
+    const known = await knowledgeFor(paseo, knowledge, agent.projectId);
+    if (!known) return { areas: [], resolved: [] };
+    const resolved = [...resolvePaths(paths, known.files)].map(([from, to]) => ({ from, to }));
+    return { areas: known.areas.map(toAreaRef), resolved };
+  });
+
   server.handle(clearMapRpc, async ({ agentId }, { paseo }) => {
     const agent = await agentInfo(paseo, agentId);
     const identifier = agent.labels[AGENT_LABELS.issue];
@@ -267,6 +280,8 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
   interface ExploreTarget {
     identifier: string;
     keyScope: string | null;
+    /** Paseo project whose saved knowledge goes into the prompt. */
+    projectId: string | null;
     cwd: string;
     /** Opened only when a new run starts. */
     workspace: () => Promise<WorkspaceHandle>;
@@ -293,6 +308,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
       const issue = await linear.getIssue(identifier);
       const labels: Record<string, string> = { [AGENT_LABELS.explore]: identifier };
       if (target.keyScope) labels[AGENT_LABELS.project] = target.keyScope;
+      const known = await knowledgeFor(paseo, knowledge, target.projectId);
       const run = await startInternalRun({
         paseo,
         workspace: await target.workspace(),
@@ -300,7 +316,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
         provider: target.provider,
         effort: target.effort,
         title: `Explore ${identifier}`,
-        prompt: explorePrompt(issue),
+        prompt: explorePrompt(issue, known),
         labels,
         schema: ExploreResultSchema,
         timeoutMs: EXPLORE_TIMEOUT_MS,
@@ -326,6 +342,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
     const job = await ensureExplore(paseo, {
       identifier,
       keyScope: agent.labels[AGENT_LABELS.project] ?? null,
+      projectId: agent.projectId,
       cwd,
       workspace: async () =>
         workspaceId ? paseo.workspaces.ref(workspaceId) : paseo.workspaces.open(cwd),
@@ -344,6 +361,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
     const job = await ensureExplore(paseo, {
       identifier: input.identifier,
       keyScope: input.keyScope,
+      projectId: info.projectId,
       cwd: info.workspaceDirectory ?? info.projectRootPath,
       workspace: async () => workspace,
       provider: settings?.live.exploreProvider || input.agent.config.provider,

package/server/stores.ts

@@ -7,7 +7,7 @@ const MAX_MAPS = 200;
 /** A launch still waiting after this long is dropped, so a stale one never starts by surprise. */
 export const PENDING_LAUNCH_MAX_AGE_MS = 60 * 60_000;
 
-interface JsonFile<T> {
+export interface JsonFile<T> {
   read(): Promise<T>;
   /** Changes run one at a time, so a read, change, and write never interleave. */
   update<R>(change: (current: T) => { next: T; result: R }): Promise<R>;

package/shared/knowledge.ts

@@ -0,0 +1,255 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+// Project knowledge: what the daemon learns about a project's files without an agent. It is
+// kept on disk, so explore and setup prompts, ticket-text maps, and Linear Live can use it.
+
+export const AREA_KINDS = ["service", "package", "folder"] as const;
+export type AreaKind = (typeof AREA_KINDS)[number];
+
+export const AreaSchema = z.object({
+  /** Folder with a trailing slash; "" is the repository root. */
+  path: z.string(),
+  name: z.string(),
+  kind: z.enum(AREA_KINDS),
+  /** What the folder holds, from its name, such as "backend" or "tests"; "" when unknown. */
+  role: z.string(),
+  /** Files that define it, such as package.json or Dockerfile. */
+  manifests: z.array(z.string()),
+  /** Files under the folder, at any depth. */
+  files: z.number(),
+  languages: z.array(z.string()),
+  /** One line from the setup agent; "" until it writes one. */
+  summary: z.string(),
+});
+export type Area = z.infer<typeof AreaSchema>;
+
+/** The part of an area the app needs to label files. */
+export const AreaRefSchema = AreaSchema.pick({
+  path: true,
+  name: true,
+  kind: true,
+  role: true,
+  summary: true,
+});
+export type AreaRef = z.infer<typeof AreaRefSchema>;
+
+const CountSchema = z.object({ name: z.string(), files: z.number() });
+
+export const ProjectKnowledgeSchema = z.object({
+  projectId: z.string(),
+  rootPath: z.string(),
+  inspectedAt: z.string(),
+  source: z.enum(["git", "walk"]),
+  /** Repo-relative file paths, sorted, at most MAX_KNOWLEDGE_FILES. */
+  files: z.array(z.string()),
+  fileCount: z.number(),
+  truncated: z.boolean(),
+  areas: z.array(AreaSchema),
+  languages: z.array(CountSchema),
+  /** Files that guide agents and contributors, such as AGENTS.md and CI workflows. */
+  guides: z.array(z.string()),
+  /** Commands the repository defines, such as "npm run check". */
+  commands: z.array(z.string()),
+  /** One line from the setup agent about the project; "" until it writes one. */
+  summary: z.string(),
+  summarizedAt: z.string().nullable(),
+});
+export type ProjectKnowledge = z.infer<typeof ProjectKnowledgeSchema>;
+
+/** What the app gets: everything but the file list, plus file counts per top folder. */
+export const ProjectBriefSchema = ProjectKnowledgeSchema.omit({ files: true }).extend({
+  folders: z.array(CountSchema),
+});
+export type ProjectBrief = z.infer<typeof ProjectBriefSchema>;
+
+export const MAX_KNOWLEDGE_FILES = 20_000;
+export const MAX_RESOLVE_PATHS = 200;
+
+/** Saved knowledge of a project; the daemon inspects the project first when it has none. */
+export const knowledgeGetRpc = defineRpc({
+  name: "linear.knowledge.get",
+  input: z.object({ projectId: z.string().min(1) }),
+  output: z.object({ knowledge: ProjectBriefSchema }),
+});
+
+export const knowledgeInspectRpc = defineRpc({
+  name: "linear.knowledge.inspect",
+  input: z.object({ projectId: z.string().min(1) }),
+  output: z.object({ knowledge: ProjectBriefSchema }),
+});
+
+/** The areas of an agent's project, and ticket paths matched to the project's real files. */
+export const liveProjectRpc = defineRpc({
+  name: "linear.live.project",
+  input: z.object({
+    agentId: z.string().min(1),
+    paths: z.array(z.string()).max(MAX_RESOLVE_PATHS),
+  }),
+  output: z.object({
+    areas: z.array(AreaRefSchema),
+    resolved: z.array(z.object({ from: z.string(), to: z.string() })),
+  }),
+});
+
+export function toAreaRef(area: Area): AreaRef {
+  return { path: area.path, name: area.name, kind: area.kind, role: area.role, summary: area.summary };
+}
+
+/** The deepest area whose folder holds the path. */
+export function areaOf<A extends { path: string }>(path: string, areas: readonly A[]): A | null {
+  let best: A | null = null;
+  for (const area of areas) {
+    if (path.startsWith(area.path) && (!best || area.path.length > best.path.length)) best = area;
+  }
+  return best;
+}
+
+/** Such as "billing-api · service", "server · backend", or "docs". */
+export function areaLabel(area: AreaRef): string {
+  const what = area.role || (area.kind === "folder" ? "" : area.kind);
+  return what && what.toLowerCase() !== area.name.toLowerCase() ? `${area.name} · ${what}` : area.name;
+}
+
+function topFolder(path: string): string {
+  const index = path.indexOf("/");
+  return index < 0 ? "./" : path.slice(0, index + 1);
+}
+
+/** File counts per top folder; "./" counts files at the root. */
+export function topFolders(files: readonly string[]): { name: string; files: number }[] {
+  const counts = new Map<string, number>();
+  for (const file of files) counts.set(topFolder(file), (counts.get(topFolder(file)) ?? 0) + 1);
+  return [...counts]
+    .map(([name, count]) => ({ name, files: count }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Where an off-map file is: its area, or its top folder when the project has no knowledge. */
+export function whereLabel(path: string, areas: readonly AreaRef[]): string {
+  const area = areaOf(path, areas);
+  return area && area.path !== "" ? areaLabel(area) : topFolder(path);
+}
+
+/** Folders to the given depth with their file counts, indented, for prompts. */
+export function folderLines(files: readonly string[], depth = 2, limit = 60): string[] {
+  const counts = new Map<string, number>();
+  for (const file of files) {
+    const parts = file.split("/").slice(0, -1);
+    for (let level = 1; level <= Math.min(depth, parts.length); level += 1) {
+      const dir = `${parts.slice(0, level).join("/")}/`;
+      counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+  }
+  const dirs = [...counts.keys()].sort();
+  if (dirs.length > limit && depth > 1) return folderLines(files, depth - 1, limit);
+  const lines = dirs.slice(0, limit).map((dir) => {
+    const indent = "  ".repeat(dir.split("/").length - 2);
+    return `${indent}${dir} (${counts.get(dir)})`;
+  });
+  if (dirs.length > limit) lines.push(`... ${dirs.length - limit} more folders`);
+  return lines;
+}
+
+function countLine(entries: readonly { name: string; files: number }[]): string {
+  return entries.map((entry) => `${entry.name} ${entry.files}`).join(", ");
+}
+
+/** The project map an agent prompt starts from. Empty without knowledge. */
+export function knowledgeLines(knowledge: ProjectKnowledge | null): string[] {
+  if (!knowledge) return [];
+  const source = knowledge.source === "git" ? "git ls-files" : "a folder walk";
+  const lines = [
+    `Project map from the plugin's inspection (${knowledge.inspectedAt}, by ${source}). Start from`,
+    "it instead of listing the whole repository; files may have changed since.",
+  ];
+  if (knowledge.summary) lines.push(`- Project: ${knowledge.summary}`);
+  const truncated = knowledge.truncated ? ", list truncated" : "";
+  lines.push(`- ${knowledge.fileCount} files${truncated}. Languages: ${countLine(knowledge.languages) || "unknown"}.`);
+  if (knowledge.guides.length > 0) lines.push(`- Guides: ${knowledge.guides.join(", ")}`);
+  if (knowledge.commands.length > 0) lines.push(`- Commands: ${knowledge.commands.join(", ")}`);
+  if (knowledge.areas.length > 0) {
+    lines.push("Areas (services, packages, and main folders):");
+    for (const area of knowledge.areas) {
+      const manifests = area.manifests.length > 0 ? ` [${area.manifests.join(", ")}]` : "";
+      const languages = area.languages.length > 0 ? `, ${area.languages.join("/")}` : "";
+      const summary = area.summary ? `: ${area.summary}` : "";
+      const files = `${area.files} ${area.files === 1 ? "file" : "files"}`;
+      lines.push(`- ${area.path || "./"} ${areaLabel(area)}${manifests}, ${files}${languages}${summary}`);
+    }
+  }
+  lines.push("Folders (file count):", ...folderLines(knowledge.files));
+  return lines;
+}
+
+function byName(files: readonly string[]): Map<string, string[]> {
+  const index = new Map<string, string[]>();
+  for (const file of files) {
+    const name = file.slice(file.lastIndexOf("/") + 1);
+    const known = index.get(name);
+    if (known) known.push(file);
+    else index.set(name, [file]);
+  }
+  return index;
+}
+
+function dirsOf(files: readonly string[]): Set<string> {
+  const dirs = new Set<string>();
+  for (const file of files) {
+    let index = file.indexOf("/");
+    while (index >= 0) {
+      dirs.add(file.slice(0, index + 1));
+      index = file.indexOf("/", index + 1);
+    }
+  }
+  return dirs;
+}
+
+/** Ticket paths matched to real files: "linear.ts" to "server/linear.ts" when only one fits. */
+export function resolvePaths(paths: readonly string[], files: readonly string[]): Map<string, string> {
+  const known = new Set(files);
+  const names = byName(files);
+  let dirs: Set<string> | null = null;
+  const resolved = new Map<string, string>();
+  for (const path of paths) {
+    let matches: string[];
+    if (path.endsWith("/")) {
+      dirs ??= dirsOf(files);
+      if (dirs.has(path)) continue;
+      matches = [...dirs].filter((dir) => dir.endsWith(`/${path}`));
+    } else {
+      if (known.has(path)) continue;
+      const name = path.slice(path.lastIndexOf("/") + 1);
+      matches = (names.get(name) ?? []).filter((file) => file === name || file.endsWith(`/${path}`));
+    }
+    if (matches.length === 1 && matches[0]) resolved.set(path, matches[0]);
+  }
+  return resolved;
+}
+
+const KINDS_SAID = "(?:service|package|app|module|library|lib|worker|folder|directory|dir)";
+
+function escapeRegex(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function aliases(area: AreaRef): string[] {
+  const folder = area.path.replace(/\/$/, "").split("/").pop() ?? "";
+  return [...new Set([area.name, folder])].filter((alias) => alias.length >= 3);
+}
+
+// A service or package counts when its name appears; a plain folder only when the text says
+// "the docs folder" or similar, since folder names like "server" are common words.
+function mentions(text: string, alias: string, plain: boolean): boolean {
+  const word = `(?:^|[^\\w@/.-])${escapeRegex(alias)}(?![\\w@/-])`;
+  if (plain && alias.length >= 4 && new RegExp(word, "i").test(text)) return true;
+  return new RegExp(`${word}\\s+${KINDS_SAID}\\b`, "i").test(text);
+}
+
+/** Areas the text names, other than the whole repository. */
+export function areasIn(text: string, areas: readonly AreaRef[]): AreaRef[] {
+  return areas.filter(
+    (area) =>
+      area.path !== "" && aliases(area).some((alias) => mentions(text, alias, area.kind !== "folder")),
+  );
+}

package/shared/live.ts

@@ -1,6 +1,7 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
 import { McpHttpServerSchema, ToolPolicySchema } from "./agent-tools";
+import { type AreaRef, areasIn } from "./knowledge";
 import { IssueCardSchema, WorkflowStateSchema } from "./linear";
 
 // Contracts for Linear Live, todo sync, and project setup. Agents the plugin starts for itself
@@ -40,6 +41,9 @@ export const InitProposalSchema = z.object({
   steps: z.array(z.string()).default([]),
   implement: z.string().default(""),
   review: z.string().default(""),
+  /** Saved to the project knowledge at once; not part of the prompt proposal. */
+  summary: z.string().default(""),
+  areas: z.array(z.object({ path: z.string(), summary: z.string() })).max(80).default([]),
 });
 export type InitProposal = z.infer<typeof InitProposalSchema>;
 
@@ -194,18 +198,30 @@ export interface SemanticIssue {
   children: readonly { identifier: string; title: string }[];
 }
 
+/** What project knowledge adds to a ticket-text map. */
+export interface MapHints {
+  /** Ticket paths matched to real files, such as "linear.ts" to "server/linear.ts". */
+  resolved?: ReadonlyMap<string, string>;
+  /** A service or package the text names puts its folder on the map. */
+  areas?: readonly AreaRef[];
+}
+
 // Linear sends sub-issue titles but not their descriptions, so a path in the parent's text
 // belongs to the sub-issue its line names and otherwise to the parent.
-export function semanticMap(issue: SemanticIssue, now = new Date()): IssueMap {
+export function semanticMap(issue: SemanticIssue, now = new Date(), hints: MapHints = {}): IssueMap {
   const owners = new Map<string, string>();
   const childKeys = new Set(issue.children.map((child) => child.identifier.toUpperCase()));
+  const found = (text: string) => [
+    ...pathsIn(text).map((path) => hints.resolved?.get(path) ?? path),
+    ...areasIn(text, hints.areas ?? []).map((area) => area.path),
+  ];
   for (const child of issue.children) {
-    for (const path of pathsIn(child.title)) owners.set(path, child.identifier);
+    for (const path of found(child.title)) owners.set(path, child.identifier);
   }
   const lines = `${issue.title}\n${issue.description ?? ""}`.split("\n");
   for (const line of lines) {
     const named = (line.match(ISSUE_KEY) ?? []).find((key) => childKeys.has(key));
-    for (const path of pathsIn(line)) {
+    for (const path of found(line)) {
       if (!owners.has(path)) owners.set(path, named ?? issue.identifier);
     }
   }

package/shared/map-model.ts

@@ -1,4 +1,5 @@
 import type { DirTouch, FileTouch } from "./activity";
+import { type AreaRef, areaLabel, areaOf, whereLabel } from "./knowledge";
 import { dirOf, type MapFile } from "./live";
 
 // The Linear Live map: predicted files and touched files grouped into folder zones, and the
@@ -31,12 +32,21 @@ export interface MapZone {
   /** Touched files that are on the map. */
   hits: number;
   explored: ZoneExplored;
+  /** The service, package, or main folder the zone is in, from the project knowledge. */
+  area: AreaRef | null;
+}
+
+/** Touched files the map did not predict, grouped by where they are. */
+export interface OffMapGroup {
+  where: string;
+  files: number;
 }
 
 export interface MapModel {
   zones: MapZone[];
   touched: number;
   hits: number;
+  offMap: OffMapGroup[];
 }
 
 // Search hits alone do not count: one broad search would flood the map with off-map tiles.
@@ -98,6 +108,7 @@ export function buildMapModel(
   touches: readonly FileTouch[],
   listing: ReadonlyMap<string, readonly string[]>,
   dirs: readonly DirTouch[] = [],
+  areas: readonly AreaRef[] = [],
 ): MapModel {
   const predicted = predictions(files);
   const touched = new Map(touches.filter(isTouched).map((file) => [file.path, file]));
@@ -134,11 +145,19 @@ export function buildMapModel(
       touched: tiles.filter((tile) => tile.touch !== "none").length,
       hits: tiles.filter((tile) => tile.touch !== "none" && tile.onMap).length,
       explored: exploredState(dir, dirs),
+      area: areaOf(dir, areas),
     };
   });
   let hits = 0;
-  for (const path of touched.keys()) if (ownerOf(path, predicted)) hits += 1;
-  return { zones, touched: touched.size, hits };
+  const off = new Map<string, number>();
+  for (const path of touched.keys()) {
+    if (ownerOf(path, predicted)) hits += 1;
+    else off.set(whereLabel(path, areas), (off.get(whereLabel(path, areas)) ?? 0) + 1);
+  }
+  const offMap = [...off]
+    .map(([where, count]) => ({ where, files: count }))
+    .sort((a, b) => b.files - a.files || a.where.localeCompare(b.where));
+  return { zones, touched: touched.size, hits, offMap };
 }
 
 export function hitRateLine(model: MapModel): string {
@@ -147,6 +166,35 @@ export function hitRateLine(model: MapModel): string {
   return `${model.touched} ${noun} touched, ${model.hits} on the map`;
 }
 
+const OFF_MAP_SHOWN = 4;
+
+/** Such as "Off the map: billing-api · service (3), docs (1)"; null when all are on it. */
+export function offMapLine(model: MapModel): string | null {
+  if (model.offMap.length === 0) return null;
+  const shown = model.offMap.slice(0, OFF_MAP_SHOWN).map((group) => `${group.where} (${group.files})`);
+  const more = model.offMap.length - OFF_MAP_SHOWN;
+  return `Off the map: ${shown.join(", ")}${more > 0 ? `, ${more} more` : ""}`;
+}
+
+/** Where the file is when the agent touched it off the map; null on the map or untouched. */
+export function offMapWhere(model: MapModel, path: string | null, areas: readonly AreaRef[]): string | null {
+  if (!path) return null;
+  for (const zone of model.zones) {
+    const tile = zone.tiles.find((entry) => entry.path === path && !entry.ghost);
+    if (tile) return tile.touch !== "none" && !tile.onMap ? whereLabel(path, areas) : null;
+  }
+  return null;
+}
+
+/** The area a zone header names; only the part its folder name does not already say. */
+export function zoneAreaLabel(zone: MapZone): string | null {
+  const area = zone.area;
+  if (!area || area.path === "") return null;
+  const folder = area.path.replace(/\/$/, "").split("/").pop();
+  if (zone.dir !== area.path || area.name !== folder) return areaLabel(area);
+  return area.role || (area.kind === "folder" ? null : area.kind);
+}
+
 export const ZONE_GAP = 10;
 
 // Rough zone height from its tiles, so zones can go to the shortest column. Tiles wrap, so

package/shared/project-setup.ts

@@ -3,6 +3,7 @@ import type { ProjectConfig } from "./settings";
 
 // A setup proposal shows only fields that change; accepted fields append to the prompts.
 export type ProposalField = "instructions" | "steps" | "implement" | "review";
+type PromptProposal = Pick<InitProposal, ProposalField>;
 
 export interface FieldDiff {
   field: ProposalField;
@@ -11,7 +12,7 @@ export interface FieldDiff {
   proposed: string;
 }
 
-export function proposalDiffs(config: ProjectConfig, proposal: InitProposal): FieldDiff[] {
+export function proposalDiffs(config: ProjectConfig, proposal: PromptProposal): FieldDiff[] {
   const steps = proposal.steps.map((step) => step.trim()).filter(Boolean);
   const rows: FieldDiff[] = [
     {
@@ -43,7 +44,7 @@ export function proposalDiffs(config: ProjectConfig, proposal: InitProposal): Fi
 }
 
 export function applyProposal(
-  proposal: InitProposal,
+  proposal: PromptProposal,
   fields: ReadonlySet<ProposalField>,
 ): Partial<ProjectConfig> {
   const patch: Partial<ProjectConfig> = {};