@agent-native/core 0.164.4 → 0.164.12

package/corpus/templates/slides/app/routes/access-request.approve.tsx

@@ -0,0 +1,250 @@
+import { callAction, useSession } from "@agent-native/core/client/hooks";
+import { useT } from "@agent-native/core/client/i18n";
+import { buildSignInReturnHref } from "@agent-native/core/client/ui";
+import { IconAlertTriangle, IconCheck, IconLock } from "@tabler/icons-react";
+import { useEffect, useMemo, useState } from "react";
+import { Link, useSearchParams } from "react-router";
+
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Skeleton } from "@/components/ui/skeleton";
+import enMessages from "@/i18n/en-US";
+
+import {
+  deckAccessApprovalContinuationPath,
+  deckAccessApprovalSessionKey,
+} from "../../shared/deck-access";
+
+interface ApprovalResult {
+  ok: true;
+  alreadyAllowed: boolean;
+  requesterEmail: string;
+  deckId: string;
+  deckTitle: string;
+  shareId: string;
+  message: string;
+}
+
+type ApprovalState =
+  | { kind: "loading" }
+  | { kind: "sign-in" }
+  | { kind: "success"; result: ApprovalResult }
+  | { kind: "error"; message: string };
+
+export function meta() {
+  return [{ title: enMessages.deckEditor.privateDeckTitle }];
+}
+
+export default function ApproveDeckAccessRequestRoute() {
+  const t = useT();
+  const [searchParams] = useSearchParams();
+  const { session, isLoading: sessionLoading } = useSession();
+  const deckId = searchParams.get("deckId") ?? "";
+  const approvalTokenFromUrl = searchParams.get("token") ?? "";
+  const approvalTokenStorageKey = deckAccessApprovalSessionKey(deckId);
+  const [approvalToken, setApprovalToken] = useState(() => {
+    if (approvalTokenFromUrl) return approvalTokenFromUrl;
+    if (typeof window === "undefined" || !deckId) return "";
+    try {
+      return sessionStorage.getItem(approvalTokenStorageKey) ?? "";
+    } catch {
+      // coercion-ok: unavailable tab storage is an absent continuation.
+      return "";
+    }
+  });
+  const [state, setState] = useState<ApprovalState>({ kind: "loading" });
+
+  useEffect(() => {
+    if (!deckId) {
+      setApprovalToken("");
+      return;
+    }
+    if (!approvalTokenFromUrl) {
+      try {
+        setApprovalToken(sessionStorage.getItem(approvalTokenStorageKey) ?? "");
+      } catch {
+        setApprovalToken("");
+      }
+      return;
+    }
+    try {
+      sessionStorage.setItem(approvalTokenStorageKey, approvalTokenFromUrl);
+    } catch {
+      // coercion-ok: never fall back to putting the bearer token in the URL.
+      // Session storage may be unavailable in hardened browser contexts.
+    }
+    setApprovalToken(approvalTokenFromUrl);
+
+    // The email link must contain the capability, but it should not remain in
+    // the address bar or be copied into the sign-in continuation URL.
+    const params = new URLSearchParams(window.location.search);
+    params.delete("token");
+    const nextSearch = params.toString();
+    window.history.replaceState(
+      window.history.state,
+      "",
+      `${window.location.pathname}${nextSearch ? `?${nextSearch}` : ""}${window.location.hash}`,
+    );
+  }, [approvalTokenFromUrl, approvalTokenStorageKey, deckId]);
+
+  const signInReturnTo = useMemo(
+    () => deckAccessApprovalContinuationPath(deckId),
+    [deckId],
+  );
+
+  useEffect(() => {
+    if (sessionLoading) return;
+
+    let cancelled = false;
+    if (!session?.email) {
+      setState({ kind: "sign-in" });
+      return () => {
+        cancelled = true;
+      };
+    }
+    if (!deckId || !approvalToken) {
+      setState({
+        kind: "error",
+        message: t("deckEditor.accessApprovalInvalid"),
+      });
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    setState({ kind: "loading" });
+    void callAction<ApprovalResult>("approve-deck-access-request", {
+      deckId,
+      approvalToken,
+    })
+      .then((result) => {
+        try {
+          sessionStorage.removeItem(approvalTokenStorageKey);
+        } catch {
+          // coercion-ok: cleanup failure cannot authorize or expose the token.
+          // Session storage may be unavailable in hardened browser contexts.
+        }
+        if (!cancelled) setState({ kind: "success", result });
+      })
+      .catch((error: unknown) => {
+        if (cancelled) return;
+        setState({
+          kind: "error",
+          message:
+            error instanceof Error
+              ? error.message
+              : t("deckEditor.accessApprovalInvalid"),
+        });
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    approvalToken,
+    approvalTokenStorageKey,
+    deckId,
+    session?.email,
+    sessionLoading,
+    t,
+  ]);
+
+  const signInHref = buildSignInReturnHref({ returnTo: signInReturnTo });
+
+  return (
+    <div className="flex min-h-screen items-center justify-center bg-background px-6 py-12 text-foreground">
+      <Card className="w-full max-w-md">
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2">
+            <IconLock
+              className="size-5 text-muted-foreground"
+              aria-hidden="true"
+            />
+            {state.kind === "success"
+              ? state.result.alreadyAllowed
+                ? t("deckEditor.accessApprovalAlreadyTitle")
+                : t("deckEditor.accessApprovalTitle")
+              : state.kind === "error"
+                ? t("deckEditor.accessApprovalErrorTitle")
+                : state.kind === "sign-in"
+                  ? t("deckEditor.accessApprovalSignInTitle")
+                  : t("deckEditor.accessApprovalLoading")}
+          </CardTitle>
+        </CardHeader>
+        <CardContent aria-live="polite">
+          {state.kind === "loading" ? (
+            <div className="space-y-3 py-2">
+              <Skeleton className="h-4 w-full" />
+              <Skeleton className="h-4 w-4/5" />
+            </div>
+          ) : state.kind === "sign-in" ? (
+            <div className="space-y-4">
+              <p className="text-sm text-muted-foreground">
+                {t("deckEditor.accessApprovalSignInMessage")}
+              </p>
+              <Button asChild>
+                <a
+                  href={signInHref}
+                  onClick={() => {
+                    if (!approvalToken) return;
+                    try {
+                      sessionStorage.setItem(
+                        approvalTokenStorageKey,
+                        approvalToken,
+                      );
+                    } catch {
+                      // coercion-ok: never fall back to putting the bearer token in the URL.
+                      // Session storage may be unavailable in hardened browser contexts.
+                    }
+                  }}
+                >
+                  {t("deckEditor.accessApprovalSignIn")}
+                </a>
+              </Button>
+            </div>
+          ) : state.kind === "error" ? (
+            <div className="space-y-4">
+              <div className="flex items-start gap-3 rounded-md border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+                <IconAlertTriangle
+                  className="mt-0.5 size-4 shrink-0"
+                  aria-hidden="true"
+                />
+                <span>{state.message}</span>
+              </div>
+              {deckId ? (
+                <Button asChild variant="outline">
+                  <Link to={`/deck/${encodeURIComponent(deckId)}`}>
+                    {t("deckEditor.accessApprovalOpenDeck")}
+                  </Link>
+                </Button>
+              ) : null}
+            </div>
+          ) : (
+            <div className="space-y-4">
+              <div className="flex items-start gap-3 rounded-md border border-primary/30 bg-primary/10 p-3 text-sm">
+                <IconCheck
+                  className="mt-0.5 size-4 shrink-0 text-primary"
+                  aria-hidden="true"
+                />
+                <span>
+                  {state.result.alreadyAllowed
+                    ? t("deckEditor.accessApprovalAlreadyMessage", {
+                        email: state.result.requesterEmail,
+                      })
+                    : t("deckEditor.accessApprovalMessage", {
+                        email: state.result.requesterEmail,
+                      })}
+                </span>
+              </div>
+              <Button asChild variant="outline">
+                <Link to={`/deck/${encodeURIComponent(state.result.deckId)}`}>
+                  {t("deckEditor.accessApprovalOpenDeck")}
+                </Link>
+              </Button>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

package/corpus/templates/slides/server/db/schema.ts

@@ -93,3 +93,11 @@ export const deckEvents = table("deck_events", {
   createdBy: text("created_by").notNull().default("human"),
   createdAt: text("created_at").notNull().default(now()),
 });
+
+// One durable bucket per deck keeps anonymous access-request throttling
+// consistent across serverless instances and cold starts.
+export const deckAccessRequestLimits = table("deck_access_request_limits", {
+  deckId: text("deck_id").primaryKey(),
+  windowStartedAt: text("window_started_at").notNull(),
+  requestCount: integer("request_count").notNull().default(0),
+});

package/corpus/templates/slides/server/lib/access-request-email.ts

@@ -0,0 +1,36 @@
+import { emailStrong, renderEmail } from "@agent-native/core/server";
+
+export const SLIDES_DECK_ACCESS_REQUEST_EMAIL_ID = "slides.deck-access-request";
+
+function cleanSubjectPart(value: string): string {
+  return value.replace(/[\r\n]+/g, " ").trim();
+}
+
+export function renderDeckAccessRequestEmail(input: {
+  requesterName: string;
+  requesterEmail: string;
+  deckTitle: string;
+  url: string;
+  allowAccessUrl: string;
+}) {
+  const subject = `Access request for "${cleanSubjectPart(input.deckTitle)}"`;
+  return {
+    subject,
+    ...renderEmail({
+      brandName: "Slides",
+      preheader: subject,
+      heading: "Access requested",
+      paragraphs: [
+        `${emailStrong(input.requesterName)} (${emailStrong(input.requesterEmail)}) requested access to ${emailStrong(input.deckTitle)}.`,
+        "Select Allow access to add them to this deck's sharing list. You can also open the deck to review sharing first.",
+      ],
+      cta: { label: "Allow access", url: input.allowAccessUrl },
+      secondaryCta: { label: "Open deck", url: input.url },
+      closingParagraphs: [
+        "This approval link expires in 7 days and requires you to be signed in as a deck owner or admin.",
+      ],
+      footer:
+        "You received this because you own this deck. If you do not recognize the requester, you can ignore this email.",
+    }),
+  };
+}

package/corpus/templates/slides/server/lib/emails.ts

@@ -10,6 +10,10 @@ import {
   getTransactionalEmail,
 } from "@agent-native/core/email-catalog";
 
+import {
+  renderDeckAccessRequestEmail,
+  SLIDES_DECK_ACCESS_REQUEST_EMAIL_ID,
+} from "./access-request-email.js";
 import { renderDeckCommentEmail } from "./comment-notifications.js";
 
 export const SLIDES_DECK_COMMENT_EMAIL_ID = "slides.deck-comment";
@@ -42,4 +46,26 @@ export function registerSlidesEmails(): void {
         isReply: false,
       }),
   });
+
+  defineTransactionalEmail({
+    id: SLIDES_DECK_ACCESS_REQUEST_EMAIL_ID,
+    name: "Deck access request",
+    trigger:
+      "A signed-in viewer requests access to a private Slides deck. One request is recorded per viewer and deck.",
+    recipientLabel: "Deck owner",
+    recipient:
+      "The owner of the private deck. The in-app notification is stored even when email delivery is unavailable.",
+    senderLabel: "Agent-Native Slides",
+    sender:
+      "The configured default sender. This call site sets no custom from or app sender.",
+    preview: () =>
+      renderDeckAccessRequestEmail({
+        requesterName: "Sam Rivera",
+        requesterEmail: "sam.rivera@example.com",
+        deckTitle: "Quarterly review",
+        url: "https://example.com/deck/deck_sample",
+        allowAccessUrl:
+          "https://example.com/access-request/approve?deckId=deck_sample&token=preview-token",
+      }),
+  });
 }

package/corpus/templates/slides/server/plugins/agent-chat.ts

@@ -56,6 +56,13 @@ export default createAgentChatPlugin({
     const authContext = await resolveSlidesRequestAuthContext(event);
     return authContext.orgId === undefined ? null : authContext.orgId;
   },
+  // Guest access requests authenticate with a signed deck capability and the
+  // requester email, so this action must reach its own validation without a
+  // browser session.
+  actionRoutePublicPaths: [
+    "/_agent-native/actions/get-deck-access-status",
+    "/_agent-native/actions/request-deck-access",
+  ],
   prepareRequest: prepareSlidesChatAttachments,
   systemPrompt: `You are an AI deck assistant. You create, edit, import, export, style, share, and navigate decks through actions and shared application state. For a newly created presentation, use create-deck with slides: [] only when you are creating the deck yourself, then add-slide sequentially with full rendered HTML. The legacy generate-slides-ai action returns Markdown drafts and is not part of the persisted presentation workflow. When speaker notes are requested, keep presenter-only text in each slide's notes field rather than the slide HTML, and preserve notes during source-preserving edits.
 

package/corpus/templates/slides/server/plugins/db.ts

@@ -252,6 +252,56 @@ export const runSlidesMigrations = runMigrations(
   );
   CREATE INDEX IF NOT EXISTS deck_events_deck_created_idx ON deck_events (deck_id, created_at)`,
     },
+    {
+      version: 23,
+      name: "slides-deck-access-request-rate-limits",
+      sql: `CREATE TABLE IF NOT EXISTS deck_access_request_limits (
+    deck_id TEXT PRIMARY KEY,
+    window_started_at TEXT NOT NULL,
+    request_count INTEGER NOT NULL DEFAULT 0
+  )`,
+    },
+    {
+      version: 24,
+      name: "slides-deck-shares-user-principal-unique",
+      // Reconcile legacy rows before adding the constraint. Older databases
+      // could contain case variants or concurrent duplicate user shares, and
+      // CREATE UNIQUE INDEX would otherwise fail before this migration is
+      // recorded. Keep the strongest grant; id/created_at make equal-role
+      // survivors deterministic, and lower the retained principal so the
+      // repaired row is canonical as well as uniquely indexed.
+      sql: `DELETE FROM deck_shares
+WHERE principal_type = 'user'
+  AND id NOT IN (
+    SELECT id
+    FROM (
+      SELECT id,
+        ROW_NUMBER() OVER (
+          PARTITION BY resource_id, LOWER(principal_id)
+          ORDER BY CASE LOWER(role)
+            WHEN 'owner' THEN 5
+            WHEN 'admin' THEN 4
+            WHEN 'editor' THEN 3
+            WHEN 'commenter' THEN 2
+            WHEN 'viewer' THEN 1
+            ELSE 0
+          END DESC,
+          created_at ASC,
+          id ASC
+        ) AS row_number
+      FROM deck_shares
+      WHERE principal_type = 'user'
+    ) AS ranked
+    WHERE row_number = 1
+  );
+UPDATE deck_shares
+SET principal_id = LOWER(principal_id)
+WHERE principal_type = 'user'
+  AND principal_id <> LOWER(principal_id);
+CREATE UNIQUE INDEX IF NOT EXISTS deck_shares_resource_user_principal_uidx
+ON deck_shares (resource_id, LOWER(principal_id))
+WHERE principal_type = 'user'`,
+    },
   ],
   { table: "slides_migrations" },
 );

package/corpus/templates/slides/shared/deck-access.ts

@@ -0,0 +1,31 @@
+/** Short-lived capability used by a private deck viewer to request access. */
+export const SLIDES_ACCESS_REQUEST_TOKEN_PREFIX = "slides-access-request";
+/** Capability used when the private-deck access probe is unavailable. */
+export const SLIDES_ACCESS_REQUEST_FALLBACK_TOKEN_PREFIX =
+  "slides-access-request-fallback";
+export const SLIDES_ACCESS_REQUEST_TOKEN_TTL_SECONDS = 10 * 60;
+
+/** Signed capability used by an owner to approve a private deck access request. */
+export const SLIDES_ACCESS_APPROVAL_TOKEN_PREFIX = "slides-access-approval";
+export const SLIDES_ACCESS_APPROVAL_TOKEN_TTL_SECONDS = 7 * 24 * 60 * 60;
+export const SLIDES_ACCESS_APPROVAL_SESSION_KEY_PREFIX =
+  "slides-access-approval-token:";
+
+/** Owner-only route used by the one-click approval button in access emails. */
+export function deckAccessApprovalPath(
+  deckId: string,
+  approvalToken: string,
+): string {
+  const params = new URLSearchParams({ deckId, token: approvalToken });
+  return `/access-request/approve?${params.toString()}`;
+}
+
+/** Token-free continuation used after the approver signs in. */
+export function deckAccessApprovalContinuationPath(deckId: string): string {
+  return `/access-request/approve?${new URLSearchParams({ deckId }).toString()}`;
+}
+
+/** Tab-scoped key for carrying an approval token across the sign-in redirect. */
+export function deckAccessApprovalSessionKey(deckId: string): string {
+  return `${SLIDES_ACCESS_APPROVAL_SESSION_KEY_PREFIX}${encodeURIComponent(deckId)}`;
+}

package/dist/a2a/task-store.d.ts

@@ -1,6 +1,7 @@
 import type { Task, Message, TaskState, Artifact } from "./types.js";
 export declare const MAX_A2A_IDEMPOTENCY_KEY_CHARS = 128;
 export declare const A2A_PERSONAL_OWNER_SCOPE = "__personal__";
+export declare function ensureTable(): Promise<void>;
 export interface A2AApprovalRecord {
     id: string;
     taskId: string;

package/dist/a2a/task-store.js

@@ -5,7 +5,7 @@ let _initPromise;
 export const MAX_A2A_IDEMPOTENCY_KEY_CHARS = 128;
 const A2A_IDEMPOTENCY_INDEX = "idx_a2a_tasks_owner_scope_idempotency";
 export const A2A_PERSONAL_OWNER_SCOPE = "__personal__";
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/agent/observational-memory/store.d.ts

@@ -12,6 +12,7 @@
  * runtime even before the migration plugin is registered.
  */
 import type { ObservationalMemoryEntry, ObservationalMemoryOwner, ObservationalMemoryTier } from "./types.js";
+export declare function ensureTable(): Promise<void>;
 /** Reset the cached ensureTable promise — test-only seam. */
 export declare function __resetObservationalMemoryTableCache(): void;
 export interface InsertObservationalMemoryInput extends ObservationalMemoryOwner {

package/dist/agent/observational-memory/store.js

@@ -14,7 +14,7 @@
 import { getDbExec, isPostgres } from "../../db/client.js";
 import { ensureTableExists, ensureIndexExists } from "../../db/ddl-guard.js";
 let tableReady = null;
-async function ensureTable() {
+export async function ensureTable() {
     if (tableReady)
         return tableReady;
     tableReady = (async () => {

package/dist/agent/run-store.d.ts

@@ -217,6 +217,7 @@ export declare const IN_FLIGHT_RUN_STALE_GRACE_MS: number;
  * is reaped like any other stale run.
  */
 export declare const IN_FLIGHT_GRACE_MAX_LIVENESS_GAP_MS = 120000;
+export declare function ensureRunTables(): Promise<void>;
 /**
  * Persist a zombie tool-call completion to the ledger. Called by the detached
  * promise continuation after `Promise.race` abandons it. Best-effort — never

package/dist/agent/run-store.js

@@ -294,7 +294,7 @@ export const IN_FLIGHT_RUN_STALE_GRACE_MS = 14.5 * 60_000; // 870_000
  * is reaped like any other stale run.
  */
 export const IN_FLIGHT_GRACE_MAX_LIVENESS_GAP_MS = 120_000;
-async function ensureRunTables() {
+export async function ensureRunTables() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/agent/tool-approval-store.d.ts

@@ -1,3 +1,4 @@
+export declare function ensureAgentToolApprovalTable(): Promise<void>;
 export interface AgentToolApprovalBinding {
     ownerEmail: string;
     orgId?: string | null;

package/dist/agent/tool-approval-store.js

@@ -11,7 +11,7 @@ import { AGENT_TOOL_APPROVAL_INDEX_SQL, AGENT_TOOL_APPROVAL_LOGICAL_INDEX_SQL, A
 const APPROVAL_TTL_MS = 60 * 60_000;
 const APPROVAL_CLEANUP_AGE_MS = 24 * 60 * 60_000;
 let initPromise;
-async function ensureAgentToolApprovalTable() {
+export async function ensureAgentToolApprovalTable() {
     if (!initPromise) {
         initPromise = (async () => {
             const createSql = AGENT_TOOL_APPROVAL_TABLE_SQL[isPostgres() ? "postgres" : "sqlite"];

package/dist/application-state/store.d.ts

@@ -1,4 +1,5 @@
 import type { StoreWriteOptions } from "../settings/store.js";
+export declare function ensureTable(): Promise<void>;
 export declare function appStateGet(sessionId: string, key: string): Promise<Record<string, unknown> | null>;
 /**
  * Read several application-state keys for one session in a single SQL query,

package/dist/application-state/store.js

@@ -11,7 +11,7 @@ const MAX_HOSTED_APP_STATE_VALUE_BYTES = 1024 * 1024;
 function escapeLike(s) {
     return s.replace(/[!%_]/g, (match) => `!${match}`);
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/browser-sessions/store.d.ts

@@ -2,6 +2,7 @@ import type { AgentNativeBrowserSessionRecord, AgentNativeBrowserSessionRequest,
 export declare const DEFAULT_BROWSER_SESSION_TTL_MS = 45000;
 export declare const DEFAULT_BROWSER_SESSION_REQUEST_TIMEOUT_MS = 30000;
 export declare const DEFAULT_BROWSER_SESSION_REQUEST_POLL_MS = 250;
+export declare function ensureTables(): Promise<void>;
 export declare function registerBrowserSession(ownerEmailInput: string, input: RegisterAgentNativeBrowserSessionInput): Promise<AgentNativeBrowserSessionRecord>;
 export declare function listBrowserSessions(ownerEmailInput: string, options?: {
     includeExpired?: boolean;

package/dist/browser-sessions/store.js

@@ -13,7 +13,7 @@ function nowMs() {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function ensureTables() {
+export async function ensureTables() {
     if (!initPromise) {
         initPromise = (async () => {
             const client = getDbExec();

package/dist/checkpoints/store.d.ts

@@ -1,3 +1,4 @@
+export declare function ensureCheckpointTable(): Promise<void>;
 export declare function insertCheckpoint(id: string, threadId: string, runId: string | null, commitSha: string, message: string): Promise<void>;
 export declare function getCheckpointsByThread(threadId: string): Promise<Array<{
     id: string;

package/dist/checkpoints/store.js

@@ -1,7 +1,7 @@
 import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 let _initPromise;
-async function ensureCheckpointTable() {
+export async function ensureCheckpointTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/cli/code-agent-schedules.d.ts

@@ -52,3 +52,14 @@ export declare function deleteCodeAgentSchedule(scheduleId: string): boolean;
 export declare function markCodeAgentScheduleRun(scheduleId: string, patch: CodeAgentScheduleRunPatch): CodeAgentScheduleRecord | null;
 export declare function isCodeAgentScheduleDue(schedule: CodeAgentScheduleRecord, now?: Date): boolean;
 export declare function nextCodeAgentScheduleRunAt(schedule: CodeAgentScheduleRecord, now?: Date): string;
+/**
+ * A schedules file that exists but cannot be understood. Every mutation
+ * rewrites the whole file, so treating this as an empty list would delete every
+ * stored schedule; callers must fail instead.
+ */
+export declare class CodeAgentSchedulesUnreadableError extends Error {
+    readonly filePath: string;
+    constructor(filePath: string, detail: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/cli/code-agent-schedules.js

@@ -136,16 +136,55 @@ export function nextCodeAgentScheduleRunAt(schedule, now = new Date()) {
         next += intervalMs;
     return new Date(next).toISOString();
 }
+/**
+ * A schedules file that exists but cannot be understood. Every mutation
+ * rewrites the whole file, so treating this as an empty list would delete every
+ * stored schedule; callers must fail instead.
+ */
+export class CodeAgentSchedulesUnreadableError extends Error {
+    filePath;
+    constructor(filePath, detail, options) {
+        super(`Code agent schedules at ${filePath} could not be read (${detail}). ` +
+            `Refusing to continue so the existing schedules are not overwritten. ` +
+            `Repair or remove the file, then retry.`, options);
+        this.name = "CodeAgentSchedulesUnreadableError";
+        this.filePath = filePath;
+    }
+}
 function readScheduleFile() {
+    const filePath = codeAgentSchedulesPath();
+    let contents;
     try {
-        const raw = JSON.parse(fs.readFileSync(codeAgentSchedulesPath(), "utf8"));
-        if (!Array.isArray(raw))
+        contents = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        // Only a genuinely absent file is an empty schedule list. A permission
+        // error or transient I/O failure is unknown, not empty.
+        if (error?.code === "ENOENT")
             return [];
-        return raw.filter(isScheduleRecord);
+        throw new CodeAgentSchedulesUnreadableError(filePath, "read failed", {
+            cause: error,
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new CodeAgentSchedulesUnreadableError(filePath, "invalid JSON", {
+            cause: error,
+        });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new CodeAgentSchedulesUnreadableError(filePath, `expected an array, found ${parsed === null ? "null" : typeof parsed}`);
     }
-    catch {
-        return [];
+    const records = parsed.filter(isScheduleRecord);
+    if (records.length !== parsed.length) {
+        // Dropping the entries we cannot parse and writing the rest back is the
+        // same data loss by a quieter route — a newer schemaVersion included.
+        throw new CodeAgentSchedulesUnreadableError(filePath, `${parsed.length - records.length} of ${parsed.length} entries are not valid schedule records`);
     }
+    return records;
 }
 function writeScheduleFile(records) {
     const filePath = codeAgentSchedulesPath();