@saadnvd1/agent-os 0.3.567 → 0.3.570

package/README.md

@@ -20,7 +20,7 @@ and check on all of it from your phone.
 - **Built for your phone.** The whole app works on a phone; pair it with a QR code. [More](docs/guides/phone.md)
 - **Agents that talk to each other.** Sessions message each other with `aos`, and you see every conversation in Messages. [More](docs/guides/agent-network.md)
 - **Chat or terminal, same conversation.** Streaming replies, steps and diffs, plan mode, slash commands, `@file`, undo. [More](docs/guides/chat.md)
-- **Share a chat or a page.** A read-only snapshot link with secrets, home paths and machine names masked, and a preview before anything leaves your machine. [More](docs/guides/sharing.md)
+- **Share a chat or a page.** A read-only snapshot link with secrets, home paths and machine names masked, a preview before anything leaves your machine, and a Markdown copy to hand to an agent. [More](docs/guides/sharing.md)
 - **Project config.** `agentos.json` gives each session its own ports, environment, files and a private Postgres copy. [More](docs/reference/project-config.md)
 - **Schedules and recipes.** Start work on a timer, or save a job that comes up again. [More](docs/guides/schedules.md)
 - **Plans in pieces and stacks.** A plan splits into several PRs only for a real reason; a board can run as stacked PRs. [More](docs/guides/tasks.md#plans-in-pieces)

package/app/api/shares/preview/route.ts

@@ -15,6 +15,7 @@ export async function POST(request: Request) {
     const page = await buildPage(req);
     return NextResponse.json({
       html: page.html,
+      markdown: page.markdown,
       title: page.title,
       bytes: page.bytes,
       hash: page.hash,

package/app/api/shares/route.test.ts

@@ -184,6 +184,13 @@ describe("preview", () => {
     expect(p.html).not.toContain(tailnet);
     expect(p.html).toContain("[secret]");
     expect(p.hits).toMatchObject({ secret: 1, path: 1, host: 1 });
+    expect(p.markdown).toContain("**User:**");
+    expect(p.bytes).toBe(
+      Buffer.byteLength(p.html) + Buffer.byteLength(p.markdown)
+    );
+    expect(p.markdown).toContain("[secret]");
+    for (const leak of [secret, home, tailnet])
+      expect(p.markdown).not.toContain(leak);
     expect(p.items.map((i: { id: string }) => i.id)).toEqual(["u1", "a1"]);
     expect(seen).toHaveLength(0);
   });
@@ -254,6 +261,7 @@ describe("create", () => {
       title: "Share me",
       expires_in: "7d",
       html: p.html,
+      markdown: p.markdown,
     });
     for (const leak of [secret, home, tailnet])
       expect(upload.body).not.toContain(leak);

package/app/api/shares/route.ts

@@ -40,6 +40,7 @@ export async function POST(request: Request) {
       kind: req.kind,
       title: page.title,
       html: page.html,
+      markdown: page.markdown,
       expiresIn,
     });
     insertSharedLink({

package/components/Share/ShareDialog.tsx

@@ -75,6 +75,7 @@ function ShareBody({
   const [error, setError] = useState<string | null>(null);
   const [created, setCreated] = useState<string | null>(null);
   const [copied, setCopied] = useState(false);
+  const [tab, setTab] = useState<"page" | "markdown">("page");
   const previewReq = useSharePreview();
   const create = useCreateShare();
   const seq = useRef(0);
@@ -131,14 +132,16 @@ function ShareBody({
     }
   };
 
-  const download = () => {
+  const download = (what: "html" | "md") => {
     if (!preview) return;
     const url = URL.createObjectURL(
-      new Blob([preview.html], { type: "text/html" })
+      new Blob([what === "md" ? preview.markdown : preview.html], {
+        type: what === "md" ? "text/markdown" : "text/html",
+      })
     );
     const a = document.createElement("a");
     a.href = url;
-    a.download = fileName(target.title);
+    a.download = fileName(target.title, what);
     a.click();
     URL.revokeObjectURL(url);
   };
@@ -172,20 +175,40 @@ function ShareBody({
       </div>
 
       <div className="flex min-h-0 flex-1 flex-col gap-3 overflow-y-auto md:flex-row md:overflow-hidden">
-        <div className="bg-background min-h-[45vh] flex-1 overflow-hidden rounded-lg border md:min-h-0">
-          {preview ? (
-            <iframe
-              title="Preview of what will be shared"
-              sandbox="allow-scripts"
-              referrerPolicy="no-referrer"
-              srcDoc={preview.html}
-              className="h-full min-h-[45vh] w-full md:min-h-0"
-            />
-          ) : (
-            <p className="text-muted-foreground p-4 text-sm">
-              {error ?? "Preparing the preview…"}
-            </p>
-          )}
+        <div className="flex min-h-[45vh] flex-1 flex-col gap-2 md:min-h-0">
+          <div className="flex gap-2" role="group" aria-label="Preview format">
+            {(["page", "markdown"] as const).map((t) => (
+              <Button
+                key={t}
+                size="sm"
+                variant={tab === t ? "default" : "outline"}
+                className="min-h-11"
+                aria-pressed={tab === t}
+                onClick={() => setTab(t)}
+              >
+                {t === "page" ? "Page" : "Markdown"}
+              </Button>
+            ))}
+          </div>
+          <div className="bg-background min-h-0 flex-1 overflow-hidden rounded-lg border">
+            {preview && tab === "markdown" ? (
+              <pre className="h-full overflow-auto p-4 font-mono text-xs break-words whitespace-pre-wrap">
+                {preview.markdown}
+              </pre>
+            ) : preview ? (
+              <iframe
+                title="Preview of what will be shared"
+                sandbox="allow-scripts"
+                referrerPolicy="no-referrer"
+                srcDoc={preview.html}
+                className="h-full min-h-[45vh] w-full md:min-h-0"
+              />
+            ) : (
+              <p className="text-muted-foreground p-4 text-sm">
+                {error ?? "Preparing the preview…"}
+              </p>
+            )}
+          </div>
         </div>
 
         <div className="flex shrink-0 flex-col gap-4 md:w-80 md:overflow-y-auto">
@@ -304,11 +327,20 @@ function ShareBody({
             variant="outline"
             className="min-h-11"
             disabled={!preview || preview.tooBig || empty}
-            onClick={download}
+            onClick={() => download("html")}
           >
             <Download className="h-4 w-4" />
             Download HTML
           </Button>
+          <Button
+            variant="outline"
+            className="min-h-11"
+            disabled={!preview || preview.tooBig || empty}
+            onClick={() => download("md")}
+          >
+            <Download className="h-4 w-4" />
+            Download Markdown
+          </Button>
           {linked && (
             <Button
               className="min-h-11"

package/components/Usage/WindowCard.tsx

@@ -19,29 +19,40 @@ export function WindowCard({
   window: WindowView | null | undefined;
 }) {
   const level = w ? meterLevel(w.pct) : "ok";
+  const stale = !!w?.stale;
   return (
     <div className="bg-foreground/[0.03] space-y-2 rounded-xl p-3">
       <div className="flex items-baseline justify-between gap-2">
         <span className="text-muted-foreground text-xs">{label}</span>
-        <span className="text-lg font-semibold tabular-nums">
+        <span
+          className={cn(
+            "text-lg font-semibold tabular-nums",
+            stale && "text-muted-foreground"
+          )}
+        >
           {w ? `${w.estimated ? "~" : ""}${w.pct}%` : "–"}
         </span>
       </div>
       <div className="bg-foreground/10 h-1.5 overflow-hidden rounded-full">
         <div
-          className={cn("h-full rounded-full", BAR[level])}
+          className={cn(
+            "h-full rounded-full",
+            stale ? "bg-foreground/30" : BAR[level]
+          )}
           style={{ width: `${Math.min(w?.pct ?? 0, 100)}%` }}
         />
       </div>
       <p className="text-muted-foreground text-[11px]">
         {w?.estimated && "Estimate from recorded usage · "}
         {!w
-          ? "Not available"
-          : w.capsIn
-            ? `Runs out in ${formatDuration(w.capsIn)} at this rate`
-            : w.resetsIn !== null
-              ? `Resets in ${formatDuration(w.resetsIn)}`
-              : "Used"}
+          ? "Not sampled"
+          : w.stale
+            ? `Last seen ${w.ageSec !== undefined ? `${formatDuration(w.ageSec)} ago` : "a while ago"}${w.resetsIn !== null ? ` · resets in ${formatDuration(w.resetsIn)}` : ""}`
+            : w.capsIn
+              ? `Runs out in ${formatDuration(w.capsIn)} at this rate`
+              : w.resetsIn !== null
+                ? `Resets in ${formatDuration(w.resetsIn)}`
+                : "Used"}
       </p>
     </div>
   );

package/lib/connect/control-api.ts

@@ -297,6 +297,7 @@ export async function uploadShare(
     kind: "chat" | "artifact";
     title: string;
     html: string;
+    markdown: string;
     expiresIn: ShareExpiry;
   }
 ): Promise<RemoteShare & { url: string }> {
@@ -307,6 +308,7 @@ export async function uploadShare(
       kind: share.kind,
       title: share.title,
       html: share.html,
+      markdown: share.markdown,
       expires_in: share.expiresIn,
     }
   );

package/lib/git-remote.ts

@@ -0,0 +1,47 @@
+// Which GitHub repository a folder is a clone of ("owner/repo", lower
+// case), read from its origin's URL as configured, with no gh call. Kept free
+// of the task and orchestrator modules so plan checks can use it.
+
+import { git, gitSync } from "./git-exec";
+
+const GITHUB_REMOTE =
+  /^(?:https?:\/\/(?:[^@/]+@)?|ssh:\/\/(?:[^@/]+@)?|[^@/:]+@)github\.com[:/]([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/i;
+
+export function slugOfRemote(url: string | null | undefined): string | null {
+  const m = GITHUB_REMOTE.exec((url ?? "").trim());
+  return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
+}
+
+// A remote's URL doesn't change under a running server often enough to ask
+// git on every lookup.
+const SLUG_TTL_MS = 5 * 60 * 1000;
+const slugs = new Map<string, { at: number; slug: string | null }>();
+
+export async function repoSlug(dir: string): Promise<string | null> {
+  const hit = slugs.get(dir);
+  if (hit && Date.now() - hit.at < SLUG_TTL_MS) return hit.slug;
+  const url = await git(dir, ["config", "--get", "remote.origin.url"], {
+    timeout: 10000,
+  }).catch(() => "");
+  const slug = slugOfRemote(url);
+  slugs.set(dir, { at: Date.now(), slug });
+  return slug;
+}
+
+// The same, without waiting: a cached local `git config` read for callers that
+// can't be async. Null when the folder isn't a GitHub clone.
+export function repoSlugSync(dir: string): string | null {
+  const hit = slugs.get(dir);
+  if (hit && Date.now() - hit.at < SLUG_TTL_MS) return hit.slug;
+  let url = "";
+  try {
+    url = gitSync(dir, ["config", "--get", "remote.origin.url"], {
+      timeout: 5000,
+    });
+  } catch {
+    url = "";
+  }
+  const slug = slugOfRemote(url);
+  slugs.set(dir, { at: Date.now(), slug });
+  return slug;
+}

package/lib/orchestrator/brief.ts

@@ -8,7 +8,7 @@ import { mergeApprovalsOn } from "./merge-approvals";
 import { noApprovalsOn } from "../approvals/no-approvals";
 import { buildDigest } from "./digest";
 
-const BRAKES_ON = `Starting work (\`start_task\`, \`start_session\`, \`stack\`) is braked: at most a set number of sessions running in this workspace (4 by default), at most a set number of starts an hour (6 by default), and nothing new once the account's usage window would run out before it resets, or can't be read at all. Each card of a stack you start counts as a start of its own; a braked card waits in the stack. A brake refuses the start with its reason and writes one note; running work carries on. Don't retry a braked start in a loop: carry on with reviews, answers and merges, and start again when a later event gives you reason to.`;
+const BRAKES_ON = `Starting work (\`start_task\`, \`start_session\`, \`stack\`) is braked: at most a set number of sessions running in this workspace (4 by default), at most a set number of starts an hour (6 by default), and nothing new once the account's usage window would run out before it resets, or isn't being sampled and was near its cap when last seen. Each card of a stack you start counts as a start of its own; a braked card waits in the stack. A brake refuses the start with its reason and writes one note; running work carries on. Don't retry a braked start in a loop: carry on with reviews, answers and merges, and start again when a later event gives you reason to.`;
 
 const BRAKES_OFF = `Starting work has no limits right now: no cap on running sessions or starts, and no usage-window check. Saad's Pause still stops new starts; the start tools say so when it's on.`;
 

package/lib/orchestrator/repo-slug.ts

@@ -4,33 +4,11 @@
 // of its projects'.
 
 import type { Project } from "../db";
-import { git } from "../git-exec";
 import { expandHome } from "../tasks/session";
 import { workspaceProjects } from "./brief";
+import { repoSlug } from "../git-remote";
 
-const GITHUB_REMOTE =
-  /^(?:https?:\/\/(?:[^@/]+@)?|ssh:\/\/(?:[^@/]+@)?|[^@/:]+@)github\.com[:/]([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/i;
-
-export function slugOfRemote(url: string | null | undefined): string | null {
-  const m = GITHUB_REMOTE.exec((url ?? "").trim());
-  return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
-}
-
-// A remote's URL doesn't change under a running server often enough to ask
-// git on every lookup.
-const SLUG_TTL_MS = 5 * 60 * 1000;
-const slugs = new Map<string, { at: number; slug: string | null }>();
-
-export async function repoSlug(dir: string): Promise<string | null> {
-  const hit = slugs.get(dir);
-  if (hit && Date.now() - hit.at < SLUG_TTL_MS) return hit.slug;
-  const url = await git(dir, ["config", "--get", "remote.origin.url"], {
-    timeout: 10000,
-  }).catch(() => "");
-  const slug = slugOfRemote(url);
-  slugs.set(dir, { at: Date.now(), slug });
-  return slug;
-}
+export { repoSlug, repoSlugSync, slugOfRemote } from "../git-remote";
 
 export interface WorkspaceRepo {
   project: Project;

package/lib/orchestrator/usage.ts

@@ -1,17 +1,20 @@
 /**
  * Where the account's 5-hour usage window stands, ported from dispatch's
- * `account_limit`. The statusline in ~/dev/dev-settings samples the window's
- * used percentage into limits.json, keyed on when it resets; this only reads
- * it. A sample that's a little stale or about a window that already reset
- * says nothing about the burn rate, so the projection is skipped. But a
- * file that's missing, unreadable or not sampled for 15 minutes means the
- * window can't be checked at all, and then starts are refused: the brake
- * fails closed.
+ * `account_limit`. Two things sample it: AgentOS's own agents (every
+ * rate-limit event a chat worker sees is stored in `rate_limit_readings`) and
+ * the terminal statusline, which writes limits.json. This reads both and uses
+ * whichever was sampled last, never mixing their samples. A sample that's a
+ * little stale or about a window that already reset says nothing about the
+ * burn rate, so the projection is skipped. Past 15 minutes without a sample
+ * the window is unknown: that is said plainly, with the last value seen, and
+ * a start is refused only when nothing was ever sampled or the last value was
+ * near the cap and its window hasn't reset.
  */
 
 import fs from "fs";
 import os from "os";
 import path from "path";
+import { lastAgentActivity, windowSamples } from "../usage/rate-limits";
 
 export const LIMITS_FILE =
   process.env.AGENTOS_LIMITS_FILE ??
@@ -72,31 +75,110 @@ export function usageWindow(
 
 // Past this the window can't be vouched for at all (seconds).
 const UNKNOWN_AFTER = 15 * 60;
+// A start is refused on an unknown window only when it was this full.
+const STALE_REFUSE_PCT = 90;
 
-export type UsageState = { window: UsageWindow | null } | { unknown: string };
+// What was last seen of the window, however long ago (seconds).
+export interface LastSeen {
+  pct: number;
+  resetsAt: number | null;
+  sampledAt: number;
+}
 
-export function readUsage(
-  file = LIMITS_FILE,
-  nowSec = Date.now() / 1000
-): UsageState {
-  let state: LimitsFile;
+export type UsageState =
+  | { window: UsageWindow | null }
+  | { unknown: string; last?: LastSeen | null };
+
+export interface Series {
+  window: number | null;
+  samples: [number, number][];
+}
+
+function readLimitsFile(file: string): LimitsFile | null {
   try {
-    state = JSON.parse(fs.readFileSync(file, "utf8")) as LimitsFile;
+    return JSON.parse(fs.readFileSync(file, "utf8")) as LimitsFile;
   } catch {
-    return { unknown: `the usage window can't be read (${file})` };
+    return null;
   }
-  const samples = Array.isArray(state.samples)
+}
+
+function toSeries(state: LimitsFile | null): Series | null {
+  const samples = Array.isArray(state?.samples)
     ? (state.samples as unknown[][])
+        .map((s) => [Number(s[0]), Number(s[1])] as [number, number])
+        .filter(([at, pct]) => Number.isFinite(at) && Number.isFinite(pct))
     : [];
-  const newest = Number(samples.at(-1)?.[0]);
-  if (!Number.isFinite(newest))
-    return { unknown: "the usage window has no samples" };
-  const age = nowSec - newest;
-  if (age > UNKNOWN_AFTER)
-    return {
-      unknown: `the usage window was last sampled ${minutes(age)} ago, so it can't be checked`,
-    };
-  return { window: usageWindow(state, nowSec) };
+  if (!samples.length) return null;
+  return {
+    window: typeof state?.window === "number" ? state.window : null,
+    samples,
+  };
+}
+
+function storedSeries(): Series | null {
+  const { resetsAt, samples } = windowSamples("five_hour");
+  return samples.length
+    ? { window: resetsAt === null ? null : resetsAt / 1000, samples }
+    : null;
+}
+
+// A ledger that can't be read is a source with nothing in it.
+const quietly = <T>(read: () => T | null): T | null => {
+  try {
+    return read();
+  } catch {
+    return null;
+  }
+};
+
+const clock = (sec: number, nowSec: number): string => {
+  const d = new Date(sec * 1000);
+  const time = d.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+  });
+  return d.toDateString() === new Date(nowSec * 1000).toDateString()
+    ? time
+    : `${d.toLocaleDateString("en-US", { month: "short", day: "numeric" })}, ${time}`;
+};
+
+// Why the window isn't known: nothing was ever sampled, no agent has run
+// since the last sample, or agents ran without reporting it.
+export function unknownText(
+  sampledAt: number | null,
+  activityAt: number | null,
+  nowSec: number
+): string {
+  if (sampledAt === null)
+    return "No agent has reported the usage window yet, so usage isn't sampled";
+  if (activityAt === null || activityAt / 1000 <= sampledAt + 60)
+    return `No agent has run since ${clock(sampledAt, nowSec)}, so usage isn't sampled`;
+  return `Agents ran at ${clock(activityAt / 1000, nowSec)} but didn't report the usage window; it was last sampled at ${clock(sampledAt, nowSec)}`;
+}
+
+export function readUsage(
+  file = LIMITS_FILE,
+  nowSec = Date.now() / 1000,
+  stored: () => Series | null = storedSeries,
+  activity: () => number | null = lastAgentActivity
+): UsageState {
+  const newestAt = (s: Series) => s.samples[s.samples.length - 1][0];
+  const sources = [toSeries(readLimitsFile(file)), quietly(stored)].filter(
+    (s): s is Series => s !== null
+  );
+  const chosen = sources.sort((a, b) => newestAt(b) - newestAt(a))[0] ?? null;
+  const sampledAt = chosen ? newestAt(chosen) : null;
+  if (chosen && sampledAt !== null && nowSec - sampledAt <= UNKNOWN_AFTER)
+    return { window: usageWindow(chosen, nowSec) };
+  const activityAt = quietly(activity);
+  const newest = chosen && chosen.samples[chosen.samples.length - 1];
+  return {
+    unknown: unknownText(sampledAt, activityAt, nowSec),
+    last:
+      chosen && newest && sampledAt !== null
+        ? { pct: Math.trunc(newest[1]), resetsAt: chosen.window, sampledAt }
+        : null,
+  };
 }
 
 function minutes(seconds: number): string {
@@ -104,11 +186,21 @@ function minutes(seconds: number): string {
   return m >= 60 ? `${Math.floor(m / 60)}h${m % 60}m` : `${m}m`;
 }
 
-// Why the window refuses a new start, or null.
+// Why the window refuses a new start, or null. An unknown window refuses
+// unless it was last seen low or its window has since reset: nothing is
+// sampling, so the figure can't have moved, and the next start's own run
+// samples it again.
 export function windowRefusal(
-  state: UsageState | UsageWindow | null
+  state: UsageState | UsageWindow | null,
+  nowSec = Date.now() / 1000
 ): string | null {
-  if (state && "unknown" in state) return state.unknown;
+  if (state && "unknown" in state) {
+    const last = state.last;
+    if (!last) return state.unknown;
+    if (last.resetsAt !== null && last.resetsAt <= nowSec) return null;
+    if (last.pct < STALE_REFUSE_PCT) return null;
+    return `${state.unknown}; it was ${last.pct}% used when last seen${last.resetsAt === null ? "" : ` and resets at ${clock(last.resetsAt, nowSec)}`}`;
+  }
   const w = state && "window" in state ? state.window : state;
   if (!w) return null;
   if (w.pct >= 100)

package/lib/plans/features.ts

@@ -7,6 +7,7 @@ import path from "path";
 import { randomUUID } from "crypto";
 import { db, type Session } from "../db";
 import { loadProjectConfig } from "../project-config";
+import { repoSlugSync, slugOfRemote } from "../git-remote";
 import {
   applyEdits,
   checkPieces,
@@ -77,6 +78,33 @@ function ref(id: string): ProjectRef | null {
   return { id: p.id, name: p.name, deploys: !!deploy?.deployed };
 }
 
+// A repo named in a plan resolves by project name, then by the repo's folder
+// name, then by its GitHub owner/name (or just the name part), ignoring case.
+// A folder or GitHub match must be a single project: two would be a guess.
+export function resolveRepo<
+  T extends { id: string; name: string; working_directory: string },
+>(rows: T[], token: string): T | null {
+  const want = token
+    .trim()
+    .replace(/^https?:\/\/github\.com\//i, "")
+    .replace(/\.git$/i, "")
+    .replace(/\/+$/, "")
+    .toLowerCase();
+  if (!want) return null;
+  const named = rows.filter((r) => r.name.toLowerCase() === want);
+  if (named.length) return named.length === 1 ? named[0] : null;
+  const folder = (r: T) =>
+    path.basename(expandHome(r.working_directory)).toLowerCase();
+  const byFolder = rows.filter((r) => folder(r) === want);
+  if (byFolder.length) return byFolder.length === 1 ? byFolder[0] : null;
+  const asSlug = slugOfRemote(`https://github.com/${want}`) ?? null;
+  const bySlug = rows.filter((r) => {
+    const slug = repoSlugSync(expandHome(r.working_directory));
+    return slug && (slug === asSlug || slug.split("/")[1] === want);
+  });
+  return bySlug.length === 1 ? bySlug[0] : null;
+}
+
 export function checkContext(
   s: Pick<Session, "project_id">
 ): CheckContext | null {
@@ -84,16 +112,14 @@ export function checkContext(
   if (!own) return null;
   const rows = db
     .prepare(
-      `SELECT id, name FROM projects
+      `SELECT id, name, working_directory FROM projects
        WHERE workspace_id = (SELECT workspace_id FROM projects WHERE id = ?)`
     )
-    .all(own.id) as { id: string; name: string }[];
+    .all(own.id) as { id: string; name: string; working_directory: string }[];
   return {
     own,
     find: (name) => {
-      const hit = rows.find(
-        (r) => r.name.toLowerCase() === name.trim().toLowerCase()
-      );
+      const hit = resolveRepo(rows, name);
       return hit ? ref(hit.id) : null;
     },
   };
@@ -122,10 +148,25 @@ export function piecesOf(featureId: string): FeaturePiece[] {
 
 export function pieceOfSession(sessionId: string): FeaturePiece | undefined {
   return db
-    .prepare(`SELECT * FROM feature_pieces WHERE session_id = ?`)
+    .prepare(
+      `SELECT * FROM feature_pieces WHERE session_id = ? ORDER BY position`
+    )
     .get(sessionId) as FeaturePiece | undefined;
 }
 
+// The PR a piece's task merged, when it is in the piece's own repository: a
+// session's PR is always in its project's repo, so another project's merge is
+// not this piece's work.
+export function prOf(p: FeaturePiece): number | null {
+  if (!p.session_id) return null;
+  const s = db
+    .prepare(`SELECT pr_number, project_id FROM sessions WHERE id = ?`)
+    .get(p.session_id) as
+    | { pr_number: number | null; project_id: string | null }
+    | undefined;
+  return s && s.project_id === p.project_id ? s.pr_number : null;
+}
+
 export function featureOfPlan(sessionId: string): Feature | undefined {
   return db
     .prepare(`SELECT * FROM features WHERE plan_session_id = ?`)

package/lib/plans/pieces.ts

@@ -208,7 +208,7 @@ export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
     const found = ctx.find(r.repo);
     if (!found)
       errors.push(
-        `"${r.name}": (repo: ${r.repo}) is not a project of this workspace`
+        `"${r.name}": (repo: ${r.repo}) doesn't match one project of this workspace (by name, folder or GitHub repo)`
       );
     return found ?? ctx.own;
   });