@stigmer/react 3.6.0 → 3.7.0

package/src/schedule/__tests__/scheduleCreation.test.tsx

@@ -10,8 +10,12 @@ import { renderHook, act } from "@testing-library/react";
 import { useState, type ReactNode } from "react";
 import { create } from "@bufbuild/protobuf";
 import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { StigmerContext } from "../../context";
 import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { ModelRegistryContext } from "../../models/ModelRegistryContext";
+import type { ModelInfo } from "../../models/registry";
 import { useCreateSchedule } from "../useCreateSchedule";
 import { CadenceField } from "../CadenceField";
 import { ScheduleForm } from "../ScheduleForm";
@@ -294,6 +298,199 @@ describe("ScheduleForm", () => {
     });
   });
 
+  it("submits the budget as runConfig.maxCostUsd, dropping the blank model", async () => {
+    const apply = vi.fn().mockResolvedValue(CREATED);
+    const client = createClient({ apply });
+    const onComplete = vi.fn();
+
+    render(<ScheduleForm org="isc" onComplete={onComplete} />, {
+      wrapper: wrapper(client),
+    });
+
+    fireEvent.change(screen.getByLabelText("Name"), {
+      target: { value: "daily-fee-reminders" },
+    });
+    fireEvent.change(screen.getByLabelText("Message"), {
+      target: { value: "Send today's reminders." },
+    });
+    await pickAgent();
+    fireEvent.change(screen.getByLabelText(/Budget per run/), {
+      target: { value: "0.50" },
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "Create schedule" }));
+
+    await waitFor(() => expect(onComplete).toHaveBeenCalledWith(CREATED));
+    const input = apply.mock.calls[0][0];
+    expect(input.agent.runConfig).toEqual({ maxCostUsd: 0.5 });
+    // No model picked: neither a model nor a harness is pinned.
+    expect(input.agent.harness).toBeUndefined();
+  });
+
+  it("submits git workspace entries added through the manual URL input", async () => {
+    const apply = vi.fn().mockResolvedValue(CREATED);
+    const client = createClient({ apply });
+    const onComplete = vi.fn();
+
+    render(<ScheduleForm org="isc" onComplete={onComplete} />, {
+      wrapper: wrapper(client),
+    });
+
+    fireEvent.change(screen.getByLabelText("Name"), {
+      target: { value: "daily-fee-reminders" },
+    });
+    fireEvent.change(screen.getByLabelText("Message"), {
+      target: { value: "Send today's reminders." },
+    });
+    await pickAgent();
+
+    // No GitHub connection in this client, so the workspace editor's
+    // GitHub action drills into the manual URL panel — no OAuth flow.
+    fireEvent.click(screen.getByRole("button", { name: /Connect GitHub/ }));
+    fireEvent.change(screen.getByLabelText("Git repository URL"), {
+      target: { value: "https://github.com/isc/fee-data.git" },
+    });
+    fireEvent.change(screen.getByLabelText("Branch (optional)"), {
+      target: { value: "main" },
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Add" }));
+
+    fireEvent.click(screen.getByRole("button", { name: "Create schedule" }));
+
+    await waitFor(() => expect(onComplete).toHaveBeenCalledWith(CREATED));
+    const input = apply.mock.calls[0][0];
+    expect(input.agent.workspaceEntries).toEqual([
+      {
+        name: "isc/fee-data",
+        source: {
+          gitRepo: { url: "https://github.com/isc/fee-data.git", branch: "main" },
+        },
+      },
+    ]);
+  });
+
+  it("picking a model pins the engine it belongs to (harness + model travel together)", async () => {
+    const apply = vi.fn().mockResolvedValue(CREATED);
+    const client = createClient({ apply });
+    const onComplete = vi.fn();
+
+    const registryModel: ModelInfo = {
+      modelId: "claude-sonnet-4-6",
+      provider: "anthropic",
+      displayName: "Claude Sonnet 4.6",
+      shortDescription: "Balanced default",
+      speedTier: "balanced",
+      costTier: "standard",
+      harness: "cursor",
+      featured: true,
+      serviceTiers: [],
+    };
+
+    function RegistryWrapper({ children }: { children: ReactNode }) {
+      const Base = wrapper(client);
+      return (
+        <ModelRegistryContext.Provider
+          value={{
+            models: [registryModel],
+            isLoading: false,
+            error: null,
+            refetch: () => {},
+          }}
+        >
+          <Base>{children}</Base>
+        </ModelRegistryContext.Provider>
+      );
+    }
+
+    render(<ScheduleForm org="isc" onComplete={onComplete} />, {
+      wrapper: RegistryWrapper,
+    });
+
+    fireEvent.change(screen.getByLabelText("Name"), {
+      target: { value: "daily-fee-reminders" },
+    });
+    fireEvent.change(screen.getByLabelText("Message"), {
+      target: { value: "Send today's reminders." },
+    });
+    await pickAgent();
+
+    // Nothing pinned yet: the trigger shows the placeholder.
+    fireEvent.click(screen.getByRole("button", { name: /Platform default/ }));
+    fireEvent.click(
+      await screen.findByRole("option", { name: /Claude Sonnet 4\.6/ }),
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Create schedule" }));
+
+    await waitFor(() => expect(onComplete).toHaveBeenCalledWith(CREATED));
+    const input = apply.mock.calls[0][0];
+    expect(input.agent.runConfig).toEqual({ modelName: "claude-sonnet-4-6" });
+    expect(input.agent.harness).toBe(Harness.CURSOR);
+  });
+
+  it("toggling the fast tier on a capable model lands service_tier on run_config (#357)", async () => {
+    const apply = vi.fn().mockResolvedValue(CREATED);
+    const client = createClient({ apply });
+    const onComplete = vi.fn();
+
+    const fastCapable: ModelInfo = {
+      modelId: "composer-2.5",
+      provider: "cursor",
+      displayName: "Composer 2.5",
+      shortDescription: "Fast agentic model",
+      speedTier: "fastest",
+      costTier: "economy",
+      harness: "cursor",
+      featured: true,
+      serviceTiers: ["fast"],
+    };
+
+    function RegistryWrapper({ children }: { children: ReactNode }) {
+      const Base = wrapper(client);
+      return (
+        <ModelRegistryContext.Provider
+          value={{
+            models: [fastCapable],
+            isLoading: false,
+            error: null,
+            refetch: () => {},
+          }}
+        >
+          <Base>{children}</Base>
+        </ModelRegistryContext.Provider>
+      );
+    }
+
+    render(<ScheduleForm org="isc" onComplete={onComplete} />, {
+      wrapper: RegistryWrapper,
+    });
+
+    fireEvent.change(screen.getByLabelText("Name"), {
+      target: { value: "daily-fee-reminders" },
+    });
+    fireEvent.change(screen.getByLabelText("Message"), {
+      target: { value: "Send today's reminders." },
+    });
+    await pickAgent();
+
+    fireEvent.click(screen.getByRole("button", { name: /Platform default/ }));
+    fireEvent.click(await screen.findByRole("option", { name: /Composer 2\.5/ }));
+
+    // The popover closed on selection; reopen it — the toggle renders only
+    // for the now-selected fast-capable model.
+    fireEvent.click(screen.getByRole("button", { name: /Composer 2\.5/ }));
+    fireEvent.click(await screen.findByRole("switch", { name: "Fast tier" }));
+
+    fireEvent.click(screen.getByRole("button", { name: "Create schedule" }));
+
+    await waitFor(() => expect(onComplete).toHaveBeenCalledWith(CREATED));
+    const input = apply.mock.calls[0][0];
+    expect(input.agent.runConfig).toEqual({
+      modelName: "composer-2.5",
+      serviceTier: ServiceTier.FAST,
+    });
+  });
+
   it("surfaces the server error verbatim and stays editable", async () => {
     const apply = vi
       .fn()

package/src/schedule/__tests__/scheduleHooks.test.tsx

@@ -3,7 +3,14 @@ import { renderHook, waitFor } from "@testing-library/react";
 import type { ReactNode } from "react";
 import { clone, create, equals } from "@bufbuild/protobuf";
 import { ScheduleSchema, type Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
-import { ScheduleListSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
+import {
+  ScheduleListSchema,
+  ScheduleTriggerResultSchema,
+  ScheduleRunListSchema,
+  ScheduleRunSchema,
+  ScheduleRunOutcome,
+  ScheduleRunOrigin,
+} from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { StigmerError } from "@stigmer/sdk";
 import { StigmerContext } from "../../context";
@@ -13,6 +20,7 @@ import { useScheduleList } from "../useScheduleList";
 import { useScheduleCount } from "../useScheduleCount";
 import { useResumeSchedule } from "../useResumeSchedule";
 import { useTriggerSchedule } from "../useTriggerSchedule";
+import { useScheduleRuns } from "../useScheduleRuns";
 import { useSetScheduleEnabled } from "../useSetScheduleEnabled";
 
 vi.mock("../../feedback/toast", () => ({
@@ -196,23 +204,56 @@ describe("useResumeSchedule", () => {
 });
 
 describe("useTriggerSchedule", () => {
-  it("triggers by id and toasts success", async () => {
-    const trigger = vi.fn().mockResolvedValue(SCHEDULE);
+  it("resolves a STARTED result and toasts success", async () => {
+    const started = create(ScheduleTriggerResultSchema, {
+      outcome: ScheduleRunOutcome.STARTED,
+      executionId: "aex_01run",
+      schedule: SCHEDULE,
+    });
+    const trigger = vi.fn().mockResolvedValue(started);
     const client = { schedule: { trigger } };
 
     const { result } = renderHook(() => useTriggerSchedule(), {
       wrapper: wrapper(client),
     });
 
-    await result.current.triggerSchedule("sch_01example");
+    const res = await result.current.triggerSchedule("sch_01example");
 
     expect(trigger).toHaveBeenCalledWith("sch_01example");
+    expect(res.outcome).toBe(ScheduleRunOutcome.STARTED);
+    expect(res.executionId).toBe("aex_01run");
     expect(toast.success).toHaveBeenCalledWith("Run started");
   });
 
-  it("relays the server's refusal copy verbatim", async () => {
-    // The backend's refusal matrix copy is byte-identical across editions
-    // and names the remedy — the UI must not paraphrase it.
+  it("resolves a REFUSED result and toasts the gate's reason verbatim", async () => {
+    // A refused run is a SUCCESSFUL trigger honestly reported (DD-017
+    // D-6): the promise resolves, and the gate's own copy is surfaced,
+    // never paraphrased.
+    const refused = create(ScheduleTriggerResultSchema, {
+      outcome: ScheduleRunOutcome.REFUSED,
+      refusalReason:
+        "run refused: The organization cannot fund a scheduled run right now.",
+      schedule: SCHEDULE,
+    });
+    const trigger = vi.fn().mockResolvedValue(refused);
+    const client = { schedule: { trigger } };
+
+    const { result } = renderHook(() => useTriggerSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    const res = await result.current.triggerSchedule("sch_01example");
+
+    expect(res.outcome).toBe(ScheduleRunOutcome.REFUSED);
+    expect(toast.error).toHaveBeenCalledWith(
+      "run refused: The organization cannot fund a scheduled run right now.",
+    );
+    expect(toast.success).not.toHaveBeenCalled();
+  });
+
+  it("relays a trigger-level gRPC refusal (disabled) verbatim and rejects", async () => {
+    // A disabled schedule is refused at the trigger itself — a gRPC
+    // error, not a result. Copy is byte-identical across editions.
     const refusal = new StigmerError(
       "failed-precondition",
       "schedule is disabled (spec.enabled=false) — enable it before triggering",
@@ -231,6 +272,52 @@ describe("useTriggerSchedule", () => {
   });
 });
 
+describe("useScheduleRuns", () => {
+  it("fetches a schedule's run history, newest first", async () => {
+    const listRuns = vi.fn().mockResolvedValue(
+      create(ScheduleRunListSchema, {
+        totalCount: 2,
+        items: [
+          create(ScheduleRunSchema, {
+            scheduleId: "sch_01example",
+            origin: ScheduleRunOrigin.MANUAL,
+            outcome: ScheduleRunOutcome.STARTED,
+            executionId: "aex_01run",
+          }),
+          create(ScheduleRunSchema, {
+            scheduleId: "sch_01example",
+            origin: ScheduleRunOrigin.CRON,
+            outcome: ScheduleRunOutcome.REFUSED,
+            reason: "run refused: missing credential",
+          }),
+        ],
+      }),
+    );
+    const client = { schedule: { listRuns } };
+
+    const { result } = renderHook(() => useScheduleRuns("sch_01example"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.runs).toHaveLength(2);
+    expect(result.current.totalCount).toBe(2);
+    expect(result.current.runs[1].reason).toBe("run refused: missing credential");
+  });
+
+  it("skips fetching when scheduleId is null", () => {
+    const listRuns = vi.fn();
+    const client = { schedule: { listRuns } };
+
+    const { result } = renderHook(() => useScheduleRuns(null), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.runs).toEqual([]);
+    expect(listRuns).not.toHaveBeenCalled();
+  });
+});
+
 describe("useSetScheduleEnabled", () => {
   it("re-applies the full proto with only spec.enabled flipped", async () => {
     const apply = vi.fn(async (doc: { message: unknown }) => ({

package/src/schedule/index.ts

@@ -7,6 +7,12 @@ export type { ScheduleListClient, SchedulePage } from "./scheduleListFn.js";
 export { useSchedule } from "./useSchedule.js";
 export type { UseScheduleReturn } from "./useSchedule.js";
 
+export { useScheduleRuns } from "./useScheduleRuns.js";
+export type {
+  UseScheduleRunsOptions,
+  UseScheduleRunsReturn,
+} from "./useScheduleRuns.js";
+
 export { useScheduleList } from "./useScheduleList.js";
 export type {
   UseScheduleListOptions,
@@ -28,6 +34,9 @@ export type { UseTriggerScheduleReturn } from "./useTriggerSchedule.js";
 export { useSetScheduleEnabled } from "./useSetScheduleEnabled.js";
 export type { UseSetScheduleEnabledReturn } from "./useSetScheduleEnabled.js";
 
+export { useUpdateScheduleSpec } from "./useUpdateScheduleSpec.js";
+export type { UseUpdateScheduleSpecReturn } from "./useUpdateScheduleSpec.js";
+
 export { createScheduleColumns } from "./scheduleColumns.js";
 export type { ScheduleColumnsOptions } from "./scheduleColumns.js";
 
@@ -37,6 +46,9 @@ export type { ScheduleRowActionsProps } from "./ScheduleRowActions.js";
 export { ScheduleDetailView, ScheduleIcon } from "./ScheduleDetailView.js";
 export type { ScheduleDetailViewProps } from "./ScheduleDetailView.js";
 
+export { ScheduleRunsTable } from "./ScheduleRunsTable.js";
+export type { ScheduleRunsTableProps } from "./ScheduleRunsTable.js";
+
 export {
   cadenceToCron,
   cronToCadence,

package/src/schedule/useScheduleRuns.ts

@@ -0,0 +1,93 @@
+"use client";
+
+import { create } from "@bufbuild/protobuf";
+import {
+  ListScheduleRunsRequestSchema,
+  type ScheduleRun,
+} from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
+import { useStigmer } from "../hooks.js";
+import { useFetch } from "../internal/useFetch.js";
+
+/** Options for {@link useScheduleRuns}. */
+export interface UseScheduleRunsOptions {
+  /** Maximum runs per page. @default 25 */
+  readonly pageSize?: number;
+  /** Page number (1-indexed). @default 1 */
+  readonly page?: number;
+}
+
+/** Return value of {@link useScheduleRuns}. */
+export interface UseScheduleRunsReturn {
+  /** Recorded fires for the current page, newest first. */
+  readonly runs: readonly ScheduleRun[];
+  /** Total number of recorded runs for the schedule. */
+  readonly totalCount: number;
+  /** `true` while the initial fetch is in flight. */
+  readonly isLoading: boolean;
+  /** `true` while a background refetch is in flight. */
+  readonly isRefetching: boolean;
+  /** Error from the last failed request, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Discard cached data and re-fetch the current page from the server. */
+  readonly refetch: () => void;
+}
+
+interface RunsPage {
+  readonly runs: readonly ScheduleRun[];
+  readonly totalCount: number;
+}
+
+const INITIAL_PAGE: RunsPage = { runs: [], totalCount: 0 };
+
+/**
+ * Data hook that fetches a schedule's run history, newest first — the
+ * fire ledger (project DD-017 D-7).
+ *
+ * Every fire leaves a row, INCLUDING the fires that created no execution
+ * (a refused launch gate, a missing target agent), carrying the refusing
+ * gate's copy verbatim. This is the surface that finally explains
+ * `status.consecutive_failures`: the reason is one row away instead of
+ * buried in server logs. Rows for in-flight runs are enriched server-side
+ * with the execution's live phase, so outcomes never lie.
+ *
+ * Pass `null` as `scheduleId` to skip fetching (stable no-op) — the
+ * detail view does this while the schedule itself is still loading.
+ *
+ * @example
+ * ```tsx
+ * const { runs, totalCount, isLoading } = useScheduleRuns(schedule?.metadata?.id ?? null);
+ * ```
+ */
+export function useScheduleRuns(
+  scheduleId: string | null,
+  options?: UseScheduleRunsOptions,
+): UseScheduleRunsReturn {
+  const stigmer = useStigmer();
+  const pageSize = options?.pageSize ?? 25;
+  const page = options?.page ?? 1;
+
+  const { data, isLoading, isRefetching, error, refetch } = useFetch<RunsPage>(
+    scheduleId
+      ? async () => {
+          const result = await stigmer.schedule.listRuns(
+            create(ListScheduleRunsRequestSchema, {
+              scheduleId,
+              pageInfo: { num: page, size: pageSize },
+            }),
+          );
+          return { runs: result.items, totalCount: result.totalCount };
+        }
+      : null,
+    [stigmer, scheduleId, page, pageSize],
+    INITIAL_PAGE,
+  );
+
+  return {
+    runs: data.runs,
+    totalCount: data.totalCount,
+    isLoading,
+    isRefetching,
+    error,
+    refetch,
+  };
+}

package/src/schedule/useTriggerSchedule.ts

@@ -1,7 +1,10 @@
 "use client";
 
 import { useCallback, useMemo, useState } from "react";
-import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import {
+  ScheduleRunOutcome,
+  type ScheduleTriggerResult,
+} from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
 import { getUserMessage } from "@stigmer/sdk";
 import { useStigmer } from "../hooks.js";
 import { toast } from "../feedback/toast.js";
@@ -11,10 +14,13 @@ import { toError } from "../internal/toError.js";
 export interface UseTriggerScheduleReturn {
   /**
    * Fire the schedule once, now — a real agent execution, outside the
-   * cron cadence. Resolves with the post-trigger schedule; refetch to
-   * pick up the new `status.last_execution_id`.
+   * cron cadence. Resolves with the {@link ScheduleTriggerResult}: the
+   * run's REAL outcome (started with an execution id, or refused with the
+   * gate's copy), so a caller can navigate to the execution or surface
+   * the refusal. Refetch the schedule afterwards to pick up the freshly
+   * stamped `status.last_fire_at` / `status.last_execution_id`.
    */
-  readonly triggerSchedule: (scheduleId: string) => Promise<Schedule>;
+  readonly triggerSchedule: (scheduleId: string) => Promise<ScheduleTriggerResult>;
   /** `true` while the trigger request is in flight. */
   readonly isTriggering: boolean;
   /** Error from the last failed or refused trigger, or `null` when healthy. */
@@ -22,13 +28,23 @@ export interface UseTriggerScheduleReturn {
 }
 
 /**
- * Behavior hook that fires a schedule once, immediately.
+ * Behavior hook that fires a schedule once, immediately, and reports the
+ * run's real outcome (project DD-017 D-5/D-6).
  *
- * The server enforces a refusal matrix — a disabled schedule refuses
- * first, then a paused one — both as `FAILED_PRECONDITION` with copy
- * that names the remedy ("enable it before triggering" / "resume it
- * before triggering"). Error toasts relay that copy verbatim; the copy
- * is byte-identical across editions.
+ * The trigger is a two-level contract, and this hook honors both levels:
+ *
+ * - A **gRPC error** means the trigger itself was refused — a disabled
+ *   schedule answers `FAILED_PRECONDITION` with copy that names the
+ *   remedy ("enable it before triggering"). The error toast relays that
+ *   copy verbatim (byte-identical across editions) and the promise
+ *   rejects.
+ * - A **success** means the fire happened. The result's `outcome` then
+ *   says what the RUN did: `STARTED` (an execution was created — a
+ *   success toast), or `REFUSED` / `TARGET_MISSING` (a launch gate said
+ *   no — an error toast carrying the gate's `refusalReason` verbatim).
+ *   The promise RESOLVES in every one of these cases: a refused run is a
+ *   successful trigger honestly reported, and the caller decides what to
+ *   do with it (navigate to the execution, show the reason).
  *
  * Triggering starts a real, billable execution — gate the call behind a
  * confirmation (the detail view uses `ConfirmDialog`).
@@ -39,13 +55,22 @@ export function useTriggerSchedule(): UseTriggerScheduleReturn {
   const [error, setError] = useState<Error | null>(null);
 
   const triggerSchedule = useCallback(
-    async (scheduleId: string): Promise<Schedule> => {
+    async (scheduleId: string): Promise<ScheduleTriggerResult> => {
       setIsTriggering(true);
       setError(null);
       try {
-        const triggered = await stigmer.schedule.trigger(scheduleId);
-        toast.success("Run started");
-        return triggered;
+        const result = await stigmer.schedule.trigger(scheduleId);
+        if (result.outcome === ScheduleRunOutcome.STARTED) {
+          toast.success("Run started");
+        } else {
+          // The fire happened but the run was refused — surface the
+          // gate's own copy, never a generic message. The promise still
+          // resolves; the caller renders the reason inline too.
+          toast.error(
+            result.refusalReason || "The run was refused by a launch gate",
+          );
+        }
+        return result;
       } catch (err) {
         const wrapped = toError(err);
         setError(wrapped);

package/src/schedule/useUpdateScheduleSpec.ts

@@ -0,0 +1,108 @@
+"use client";
+
+import { useCallback, useMemo, useState } from "react";
+import { clone } from "@bufbuild/protobuf";
+import {
+  ScheduleSchema,
+  type Schedule,
+} from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import type { ScheduleSpec } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/spec_pb";
+import { getUserMessage, manifestDocumentForResource } from "@stigmer/sdk";
+import { useStigmer } from "../hooks.js";
+import { toast } from "../feedback/toast.js";
+
+/** Return value of {@link useUpdateScheduleSpec}. */
+export interface UseUpdateScheduleSpecReturn {
+  /**
+   * Apply one spec mutation to the schedule. Takes the full fetched
+   * schedule (not just an id) because the write re-applies the whole
+   * resource. Resolves with the post-apply schedule; the caller
+   * refetches or replaces its local copy from it.
+   */
+  readonly updateSpec: (
+    schedule: Schedule,
+    mutate: (spec: ScheduleSpec) => void,
+  ) => Promise<Schedule>;
+  /** `true` while the apply is in flight. */
+  readonly isUpdating: boolean;
+  /** Error from the last failed apply, or `null` when healthy. */
+  readonly error: Error | null;
+}
+
+/**
+ * Behavior hook behind the schedule detail view's inline editing: apply
+ * a single spec mutation losslessly.
+ *
+ * The write path is deliberate, and it is NOT the agent detail view's
+ * input-based one: clone the fetched proto, let the caller mutate the
+ * spec in place, and re-apply the WHOLE resource through the manifest
+ * engine (`stigmer.manifest.apply`) — never down-convert to the curated
+ * `ScheduleInput` shape. The server replaces spec and mutable metadata
+ * wholesale on update, and `ScheduleInput` cannot express every
+ * metadata field (tags, description), so the input route would silently
+ * wipe them. The full-proto route is lossless by construction; the
+ * server ignores client-provided status, and re-applying never clears a
+ * platform pause (Resume is the one clearing path — see
+ * `useResumeSchedule`). Same mechanics as {@link useSetScheduleEnabled},
+ * generalized from one hardcoded field to any spec edit.
+ *
+ * Errors are NOT toasted here: inline editors surface the server's
+ * message next to the field that was edited (DD-006), and a toast on
+ * top would say the same thing twice.
+ *
+ * @example
+ * ```tsx
+ * const { updateSpec, isUpdating } = useUpdateScheduleSpec();
+ *
+ * await updateSpec(schedule, (spec) => {
+ *   spec.cron = "0 9 * * 1-5";
+ *   spec.timeZone = "Asia/Kolkata";
+ * });
+ * ```
+ */
+export function useUpdateScheduleSpec(): UseUpdateScheduleSpecReturn {
+  const stigmer = useStigmer();
+  const [isUpdating, setIsUpdating] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const updateSpec = useCallback(
+    async (
+      schedule: Schedule,
+      mutate: (spec: ScheduleSpec) => void,
+    ): Promise<Schedule> => {
+      if (!schedule.spec) {
+        throw new Error(
+          "Cannot edit this schedule: it has no spec. Pass a schedule " +
+            "as returned by the server (get/getByReference).",
+        );
+      }
+
+      setIsUpdating(true);
+      setError(null);
+      try {
+        const updated = clone(ScheduleSchema, schedule);
+        mutate(updated.spec!);
+
+        const applied = await stigmer.manifest.apply(
+          manifestDocumentForResource(updated),
+        );
+        toast.success("Schedule updated");
+        return applied.message as Schedule;
+      } catch (err) {
+        // Rethrow with the user-facing message: the inline editors render
+        // `message` verbatim next to the edited field.
+        const wrapped = new Error(getUserMessage(err));
+        setError(wrapped);
+        throw wrapped;
+      } finally {
+        setIsUpdating(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return useMemo(
+    () => ({ updateSpec, isUpdating, error }),
+    [updateSpec, isUpdating, error],
+  );
+}

package/src/session/useNewSessionFlow.ts

@@ -389,6 +389,7 @@ export function useNewSessionFlow(
           runtimeEnv,
           attachments: context?.attachments,
           interactionMode: context?.interactionMode,
+          serviceTier: context?.serviceTier,
           workspaceFileRefs: context?.workspaceFileRefs,
         };