diff --git a/apps/aevatar-console-web/src/pages/studio/components/StudioBuildPanels.tsx b/apps/aevatar-console-web/src/pages/studio/components/StudioBuildPanels.tsx
index 4e72ea5f8..3ab9742da 100644
--- a/apps/aevatar-console-web/src/pages/studio/components/StudioBuildPanels.tsx
+++ b/apps/aevatar-console-web/src/pages/studio/components/StudioBuildPanels.tsx
@@ -1716,6 +1716,19 @@ export type StudioScriptBuildPanelProps = {
   readonly onRefreshScripts?: () => Promise<unknown> | unknown;
   readonly onContinueToBind: () => void;
   readonly onRegisterLeaveGuard?: (guard: (() => Promise<boolean>) | null) => void;
+  readonly onScriptBuildStateChange?: (state: StudioScriptBuildState | null) => void;
+};
+
+export type StudioScriptBuildState = {
+  readonly scriptId: string;
+  readonly displayName: string;
+  readonly scriptRevision: string;
+  readonly revisionId?: string;
+  readonly sourceHash?: string;
+  readonly definitionActorId?: string;
+  readonly dirty: boolean;
+  readonly validationStatus: 'unknown' | 'valid' | 'invalid';
+  readonly saveStatus: 'idle' | 'accepted' | 'applied' | 'failed';
 };
 
 export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
@@ -1726,6 +1739,7 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
   onRefreshScripts,
   onContinueToBind,
   onRegisterLeaveGuard,
+  onScriptBuildStateChange,
 }) => {
   const [scriptPackage, setScriptPackage] = React.useState(() =>
     deserializePersistedSource(''),
@@ -1737,6 +1751,8 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
   const [validationError, setValidationError] = React.useState('');
   const [savePending, setSavePending] = React.useState(false);
   const [saveNotice, setSaveNotice] = React.useState('');
+  const [saveStatus, setSaveStatus] =
+    React.useState<StudioScriptBuildState['saveStatus']>('idle');
   const [runPending, setRunPending] = React.useState(false);
   const [runInput, setRunInput] = React.useState(
     JSON.stringify(
@@ -1804,6 +1820,7 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
     setValidationResult(null);
     setValidationError('');
     setSaveNotice('');
+    setSaveStatus('idle');
   }, [activeScript?.script?.scriptId, activeScript?.source?.sourceText]);
 
   React.useEffect(() => {
@@ -1833,6 +1850,84 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
     };
   }, [isDirty, onRegisterLeaveGuard]);
 
+  const validationStatus: StudioScriptBuildState['validationStatus'] =
+    validationResult
+      ? validationResult.success
+        ? 'valid'
+        : 'invalid'
+      : validationError
+        ? 'invalid'
+        : 'unknown';
+  const effectiveSaveStatus: StudioScriptBuildState['saveStatus'] =
+    isDirty
+      ? saveStatus === 'failed'
+        ? 'failed'
+        : 'idle'
+      : saveStatus === 'accepted' || saveStatus === 'failed'
+        ? saveStatus
+        : activeScript?.script?.activeRevision
+          ? 'applied'
+          : saveStatus;
+  const scriptReadyToBind = Boolean(
+    activeScript?.script?.scriptId &&
+      !isDirty &&
+      effectiveSaveStatus === 'applied',
+  );
+  const primaryActionLabel =
+    !activeScript?.script?.scriptId
+      ? 'Select Script'
+      : isDirty || validationStatus === 'unknown' || validationStatus === 'invalid'
+        ? 'Validate'
+        : effectiveSaveStatus === 'accepted'
+          ? 'Waiting for catalog'
+          : effectiveSaveStatus === 'applied'
+            ? 'Continue to Bind'
+            : 'Save revision';
+
+  React.useEffect(() => {
+    if (!activeScript?.script?.scriptId) {
+      onScriptBuildStateChange?.(null);
+      return;
+    }
+
+    onScriptBuildStateChange?.({
+      scriptId: activeScript.script.scriptId,
+      displayName: activeScript.script.scriptId,
+      scriptRevision:
+        activeScript.source?.revision ||
+        activeScript.script.activeRevision ||
+        currentRevision,
+      revisionId:
+        activeScript.source?.revision ||
+        activeScript.script.activeRevision ||
+        currentRevision,
+      sourceHash:
+        activeScript.source?.sourceHash ||
+        activeScript.script.activeSourceHash ||
+        '',
+      definitionActorId:
+        activeScript.source?.definitionActorId ||
+        activeScript.script.definitionActorId ||
+        '',
+      dirty: isDirty,
+      validationStatus,
+      saveStatus: effectiveSaveStatus,
+    });
+  }, [
+    activeScript?.script?.activeRevision,
+    activeScript?.script?.activeSourceHash,
+    activeScript?.script?.definitionActorId,
+    activeScript?.script?.scriptId,
+    activeScript?.source?.definitionActorId,
+    activeScript?.source?.revision,
+    activeScript?.source?.sourceHash,
+    currentRevision,
+    effectiveSaveStatus,
+    isDirty,
+    onScriptBuildStateChange,
+    validationStatus,
+  ]);
+
   const resolveLeave = React.useCallback((value: boolean) => {
     leaveResolverRef.current?.(value);
     leaveResolverRef.current = null;
@@ -1854,13 +1949,16 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
         package: scriptPackage,
       });
       setValidationResult(result);
+      if (result.success && isDirty) {
+        setSaveStatus('idle');
+      }
     } catch (error) {
       setValidationError(describeError(error));
       setValidationResult(null);
     } finally {
       setValidationPending(false);
     }
-  }, [activeScript?.script?.scriptId, currentRevision, scriptPackage]);
+  }, [activeScript?.script?.scriptId, currentRevision, isDirty, scriptPackage]);
 
   const handleSave = React.useCallback(async () => {
     if (!scopeId || !activeScript?.script?.scriptId) {
@@ -1877,11 +1975,38 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
         expectedBaseRevision: activeScript.script.activeRevision || undefined,
         sourceText: serializePersistedSource(scriptPackage),
       });
-      await onRefreshScripts?.();
-      setSaveNotice(
-        `Save accepted for ${accepted.acceptedScript.scriptId} · revision ${accepted.acceptedScript.revisionId}.`,
+      setSaveStatus('accepted');
+      const observation = await scriptsApi.observeSaveScript(
+        scopeId,
+        activeScript.script.scriptId,
+        {
+          revisionId: accepted.acceptedScript.revisionId,
+          definitionActorId: accepted.acceptedScript.definitionActorId,
+          sourceHash: accepted.acceptedScript.sourceHash,
+          proposalId: accepted.acceptedScript.proposalId,
+          expectedBaseRevision: accepted.acceptedScript.expectedBaseRevision,
+          acceptedAt: accepted.acceptedScript.acceptedAt,
+        },
       );
+      await onRefreshScripts?.();
+      if (observation.status === 'applied') {
+        setSaveStatus('applied');
+        setSaveNotice(
+          `Save applied for ${accepted.acceptedScript.scriptId} · revision ${accepted.acceptedScript.revisionId}.`,
+        );
+      } else if (observation.status === 'rejected') {
+        setSaveStatus('failed');
+        setSaveNotice(
+          observation.message ||
+            `Save rejected for ${accepted.acceptedScript.scriptId} · revision ${accepted.acceptedScript.revisionId}.`,
+        );
+      } else {
+        setSaveNotice(
+          `Save accepted for ${accepted.acceptedScript.scriptId} · revision ${accepted.acceptedScript.revisionId}. Waiting for catalog.`,
+        );
+      }
     } catch (error) {
+      setSaveStatus('failed');
       setSaveNotice(describeError(error));
     } finally {
       setSavePending(false);
@@ -1966,6 +2091,9 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
           <div style={{ alignItems: 'center', display: 'flex', gap: 8, justifyContent: 'space-between' }}>
             <Space wrap size={[8, 8]}>
               <Tag color="gold">lints · partial</Tag>
+              <Tag color={scriptReadyToBind ? 'green' : 'default'}>
+                {primaryActionLabel}
+              </Tag>
               <Select
                 aria-label="Script ID"
                 style={{ minWidth: 220 }}
@@ -1991,7 +2119,7 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
                 loading={savePending}
                 onClick={() => void handleSave()}
               >
-                Save draft
+                Save revision
               </Button>
             </Space>
           </div>
@@ -2050,11 +2178,15 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
                   language={selectedPackageEntry.kind === 'csharp' ? 'csharp' : 'plaintext'}
                   markers={editorMarkers}
                   value={selectedPackageEntry.content}
-                  onChange={(value) =>
+                  onChange={(value) => {
+                    setValidationResult(null);
+                    setValidationError('');
+                    setSaveNotice('');
+                    setSaveStatus('idle');
                     setScriptPackage((current) =>
                       updatePackageFileContent(current, selectedPackageEntry.path, value),
-                    )
-                  }
+                    );
+                  }}
                 />
               </div>
               <div
@@ -2101,10 +2233,11 @@ export const StudioScriptBuildPanel: React.FC<StudioScriptBuildPanelProps> = ({
           </Typography.Text>
           <Button
             className={AEVATAR_INTERACTIVE_BUTTON_CLASS}
+            disabled={!scriptReadyToBind}
             type="primary"
             onClick={onContinueToBind}
           >
-            Continue to Bind
+            {scriptReadyToBind ? 'Continue to Bind' : primaryActionLabel}
           </Button>
         </div>
 
diff --git a/apps/aevatar-console-web/src/pages/studio/index.test.tsx b/apps/aevatar-console-web/src/pages/studio/index.test.tsx
index a45826629..bba234f9f 100644
--- a/apps/aevatar-console-web/src/pages/studio/index.test.tsx
+++ b/apps/aevatar-console-web/src/pages/studio/index.test.tsx
@@ -7,6 +7,7 @@ import { runtimeQueryApi } from "@/shared/api/runtimeQueryApi";
 import { scopeRuntimeApi } from "@/shared/api/scopeRuntimeApi";
 import { servicesApi } from "@/shared/api/servicesApi";
 import { studioApi } from "@/shared/studio/api";
+import { scriptsApi } from "@/shared/studio/scriptsApi";
 import { renderWithQueryClient } from "../../../tests/reactQueryTestUtils";
 import StudioPage from "./index";
 
@@ -774,6 +775,26 @@ jest.mock("@/shared/studio/api", () => ({
       definitionActorIdPrefix: "scope-workflow:scope-1:default",
       expectedActorId: "scope-workflow:scope-1:default:dep-1",
     })),
+    bindScopeScript: jest.fn(async (input: {
+      scopeId: string;
+      displayName?: string;
+      scriptId: string;
+      scriptRevision: string;
+      revisionId?: string;
+    }) => ({
+      scopeId: input.scopeId,
+      serviceId: input.scriptId,
+      displayName: input.displayName || input.scriptId,
+      targetKind: "script",
+      targetName: input.scriptId,
+      revisionId: input.revisionId || "rev-script-binding",
+      script: {
+        scriptId: input.scriptId,
+        scriptRevision: input.scriptRevision,
+        definitionActorId: "definition-1",
+      },
+      expectedActorId: `scope-script:${input.scopeId}:${input.scriptId}:dep-1`,
+    })),
     bindScopeGAgent: jest.fn(async (input: {
       scopeId: string;
       displayName?: string;
@@ -1118,6 +1139,14 @@ jest.mock("@/shared/studio/scriptsApi", () => ({
       diagnostics: [],
     })),
     saveScript: jest.fn(),
+    observeSaveScript: jest.fn(async () => ({
+      scopeId: "scope-1",
+      scriptId: "script-1",
+      status: "applied",
+      message: "applied",
+      currentScript: null,
+      isTerminal: true,
+    })),
     runDraftScript: jest.fn(),
     proposeEvolution: jest.fn(),
     generateScript: jest.fn(),
@@ -1362,6 +1391,7 @@ jest.mock("./components/StudioBuildPanels", () => {
   const StudioScriptBuildPanel = (props: any) => {
     const [value, setValue] = mockReact.useState("using System;");
     const [dirty, setDirty] = mockReact.useState(false);
+    const selectedScriptId = props.selectedScriptId || "script-1";
 
     mockReact.useEffect(() => {
       props.onRegisterLeaveGuard?.(
@@ -1369,7 +1399,21 @@ jest.mock("./components/StudioBuildPanels", () => {
       );
 
       return () => props.onRegisterLeaveGuard?.(null);
-    }, [dirty, props]);
+    }, [dirty, props.onRegisterLeaveGuard]);
+
+    mockReact.useEffect(() => {
+      props.onScriptBuildStateChange?.({
+        scriptId: selectedScriptId,
+        displayName: selectedScriptId,
+        scriptRevision: "rev-1",
+        revisionId: "rev-1",
+        sourceHash: "hash-1",
+        definitionActorId: "definition-1",
+        dirty,
+        validationStatus: dirty ? "unknown" : "valid",
+        saveStatus: dirty ? "idle" : "applied",
+      });
+    }, [dirty, props.onScriptBuildStateChange, selectedScriptId]);
 
     return mockReact.createElement("div", { "data-testid": "studio-script-build-panel" }, [
       mockReact.createElement("div", { key: "title" }, "Script source"),
@@ -1377,7 +1421,7 @@ jest.mock("./components/StudioBuildPanels", () => {
       mockReact.createElement("input", {
         key: "script-id",
         "aria-label": "Script ID",
-        value: props.selectedScriptId || "script-1",
+        value: selectedScriptId,
         onChange: (event: MockValueEvent) => props.onSelectScriptId?.(event.target.value),
       }),
       mockReact.createElement("textarea", {
@@ -2440,6 +2484,17 @@ describe("StudioPage", () => {
     (studioApi.authorWorkflow as jest.Mock).mockImplementation(
       mockAuthorWorkflowSuccess
     );
+    (scriptsApi.listScripts as jest.Mock).mockReset();
+    (scriptsApi.listScripts as jest.Mock).mockResolvedValue([]);
+    (scriptsApi.observeSaveScript as jest.Mock).mockReset();
+    (scriptsApi.observeSaveScript as jest.Mock).mockResolvedValue({
+      scopeId: "scope-1",
+      scriptId: "script-1",
+      status: "applied",
+      message: "applied",
+      currentScript: null,
+      isTerminal: true,
+    });
   });
 
   it("loads workspace data and shows the workflow build workbench by default", async () => {
@@ -2964,10 +3019,21 @@ describe("StudioPage", () => {
   });
 
   it("shows script and gagent as member kinds before their create APIs land", async () => {
+    (studioApi.getAppContext as jest.Mock).mockResolvedValueOnce({
+      ...defaultStudioAppContext,
+      scopeId: "scope-1",
+      scopeResolved: true,
+      scriptStorageMode: "scope",
+      features: {
+        ...defaultStudioAppContext.features,
+        scripts: true,
+      },
+    });
+
     renderStudioPage("/studio?focus=workflow%3Aworkflow-1&tab=studio");
 
-    fireEvent.click(await screen.findByLabelText("Create member"));
-    const createDialog = await screen.findByRole("dialog", { name: "Create member" });
+    fireEvent.click(await screen.findByRole("button", { name: "Create member" }));
+    let createDialog = await screen.findByRole("dialog", { name: "Create member" });
 
     const scriptChip = within(createDialog).getByRole("button", {
       name: "Create Script member",
@@ -2975,12 +3041,25 @@ describe("StudioPage", () => {
     fireEvent.click(scriptChip);
 
     expect(scriptChip).toHaveAttribute("aria-pressed", "true");
+    expect(within(createDialog).queryByLabelText("Member name")).toBeNull();
     expect(
       screen.getByText(
-        "Script member creation still relies on the upcoming member API. For now, continue in Build > Script to inspect or edit script implementations.",
+        "Script member creation still relies on the upcoming member API. Open Build > Script to inspect, edit, save, and prepare script implementations for binding.",
       ),
     ).toBeTruthy();
-    expect(within(createDialog).getByRole("button", { name: "Create member" })).toBeDisabled();
+    fireEvent.click(
+      within(createDialog).getByRole("button", { name: "Open Script builder" }),
+    );
+
+    expect(await screen.findByTestId("studio-script-build-panel")).toBeTruthy();
+    await waitFor(() => {
+      const searchParams = new URLSearchParams(window.location.search);
+      expect(searchParams.get("tab")).toBe("scripts");
+      expect(searchParams.get("step")).toBe("build");
+    });
+
+    fireEvent.click(await screen.findByRole("button", { name: "Create member" }));
+    createDialog = await screen.findByRole("dialog", { name: "Create member" });
 
     const gagentChip = within(createDialog).getByRole("button", {
       name: "Create GAgent member",
@@ -2988,11 +3067,22 @@ describe("StudioPage", () => {
     fireEvent.click(gagentChip);
 
     expect(gagentChip).toHaveAttribute("aria-pressed", "true");
+    expect(within(createDialog).queryByLabelText("Member name")).toBeNull();
     expect(
       screen.getByText(
-        "GAgent member creation still relies on the upcoming member API. For now, continue in Build > GAgent to inspect or edit GAgent implementations.",
+        "GAgent member creation still relies on the upcoming member API. Open Build > GAgent to select, inspect, and prepare GAgent implementations for binding.",
       ),
     ).toBeTruthy();
+    fireEvent.click(
+      within(createDialog).getByRole("button", { name: "Open GAgent builder" }),
+    );
+
+    expect(await screen.findByTestId("studio-gagent-build-panel")).toBeTruthy();
+    await waitFor(() => {
+      const searchParams = new URLSearchParams(window.location.search);
+      expect(searchParams.get("tab")).toBe("gagents");
+      expect(searchParams.get("step")).toBe("build");
+    });
   });
 
   it("renames a workflow member from the inventory actions", async () => {
@@ -4669,6 +4759,90 @@ describe("StudioPage", () => {
     expect(screen.getByText("Script source")).toBeTruthy();
   });
 
+  it("binds a catalog-applied Script build candidate through the script binding API", async () => {
+    (studioApi.getAppContext as jest.Mock).mockResolvedValueOnce({
+      ...defaultStudioAppContext,
+      features: {
+        ...defaultStudioAppContext.features,
+        scripts: true,
+      },
+      scopeId: "scope-1",
+      scopeResolved: true,
+    });
+    (scriptsApi.listScripts as jest.Mock).mockResolvedValue([
+      {
+        available: true,
+        scopeId: "scope-1",
+        script: {
+          scopeId: "scope-1",
+          scriptId: "script-alpha",
+          catalogActorId: "catalog-1",
+          definitionActorId: "definition-1",
+          activeRevision: "rev-1",
+          activeSourceHash: "hash-1",
+          updatedAt: "2026-03-18T00:00:00Z",
+        },
+        source: {
+          sourceText: "using System;",
+          definitionActorId: "definition-1",
+          revision: "rev-1",
+          sourceHash: "hash-1",
+        },
+      },
+    ]);
+    mockServicesApi.listServices.mockResolvedValue([
+      {
+        serviceId: "script-alpha",
+        displayName: "script-alpha",
+        deploymentStatus: "Active",
+        primaryActorId: "actor-script-alpha",
+        endpoints: [
+          {
+            endpointId: "script-command",
+            displayName: "Script command",
+            kind: "command",
+            description: "Invoke the script command.",
+            requestTypeUrl: "type.googleapis.com/example.ScriptCommand",
+            responseTypeUrl: "type.googleapis.com/example.ScriptResult",
+          },
+        ],
+      },
+    ]);
+    (studioApi.getScopeBinding as jest.Mock).mockResolvedValueOnce(null);
+    mockScopeRuntimeApi.getServiceRevisions.mockImplementation(
+      async (_scopeId: string, serviceId: string) =>
+        mockBuildServiceRevisionCatalog({
+          serviceId,
+          displayName: "script-alpha",
+          revisionId: "rev-script-binding",
+        })
+    );
+
+    renderStudioPage(
+      "/studio?scopeId=scope-1&member=script%3Ascript-alpha&step=bind&tab=bindings"
+    );
+
+    expect(await screen.findByTestId("studio-bind-surface")).toBeTruthy();
+    await waitFor(() => {
+      expect(screen.getByText("candidate:script-alpha")).toBeTruthy();
+      expect(screen.getByText("service:no-service")).toBeTruthy();
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "Bind current member" }));
+
+    await waitFor(() => {
+      expect(studioApi.bindScopeScript).toHaveBeenCalledWith(
+        expect.objectContaining({
+          scopeId: "scope-1",
+          displayName: "script-alpha",
+          scriptId: "script-alpha",
+          scriptRevision: "rev-1",
+          revisionId: "rev-1",
+        })
+      );
+    });
+  });
+
   it("loads discovered GAgent types and the resolved scope binding", async () => {
     (studioApi.getAppContext as jest.Mock).mockResolvedValueOnce({
       ...defaultStudioAppContext,
diff --git a/apps/aevatar-console-web/src/pages/studio/index.tsx b/apps/aevatar-console-web/src/pages/studio/index.tsx
index 329f3948e..2ef861846 100644
--- a/apps/aevatar-console-web/src/pages/studio/index.tsx
+++ b/apps/aevatar-console-web/src/pages/studio/index.tsx
@@ -116,6 +116,7 @@ import {
   getDefaultBuildModeCards,
   StudioGAgentBuildPanel,
   StudioScriptBuildPanel,
+  type StudioScriptBuildState,
   StudioWorkflowBuildPanel,
 } from './components/StudioBuildPanels';
 import StudioShell, {
@@ -1316,6 +1317,8 @@ const StudioPage: React.FC = () => {
           ? initialSelectedMember.value
           : '',
   );
+  const [scriptBuildState, setScriptBuildState] =
+    useState<StudioScriptBuildState | null>(null);
   const [selectedGAgentTypeName, setSelectedGAgentTypeName] = useState('');
   const [selectedExecutionId, setSelectedExecutionId] = useState(
     () => initialRouteState.executionId,
@@ -2699,49 +2702,109 @@ const StudioPage: React.FC = () => {
         ? 'gagent'
         : 'workflow';
   const buildPendingBindCandidate = useMemo(() => {
-    if (
-      activeBuildMode !== 'workflow' ||
-      !resolvedStudioScopeId ||
-      !trimOptional(draftYaml)
-    ) {
+    if (!resolvedStudioScopeId) {
       return null;
     }
 
-    const displayName =
-      trimOptional(activeWorkflowName) ||
-      trimOptional(draftWorkflowName) ||
-      'draft';
+    const shouldBuildScriptCandidate =
+      activeBuildMode === 'script' ||
+      (isBindSurface && Boolean(trimOptional(selectedScriptId)));
 
-    return {
-      kind: 'workflow' as const,
-      displayName,
-      description:
-        'Publish the current workflow revision first, then Studio can reveal the invoke URL and endpoint contract for this member.',
-      actionLabel: 'Bind current revision',
-    };
+    if (shouldBuildScriptCandidate) {
+      const selectedId = trimOptional(selectedScriptId);
+      const catalogScriptState =
+        selectedId
+          ? availableScopeScripts.find(
+              (detail) => trimOptional(detail.script?.scriptId) === selectedId,
+            ) ?? null
+          : null;
+      const effectiveScriptState =
+        scriptBuildState?.scriptId ? scriptBuildState : catalogScriptState
+          ? {
+              scriptId: trimOptional(catalogScriptState.script?.scriptId),
+              displayName: trimOptional(catalogScriptState.script?.scriptId),
+              scriptRevision:
+                trimOptional(catalogScriptState.source?.revision) ||
+                trimOptional(catalogScriptState.script?.activeRevision),
+              revisionId:
+                trimOptional(catalogScriptState.source?.revision) ||
+                trimOptional(catalogScriptState.script?.activeRevision),
+              dirty: false,
+              saveStatus: 'applied' as const,
+            }
+          : null;
+      const scriptId = trimOptional(effectiveScriptState?.scriptId);
+      if (
+        scriptId &&
+        (!selectedId || scriptId === selectedId) &&
+        !effectiveScriptState?.dirty &&
+        effectiveScriptState?.saveStatus === 'applied'
+      ) {
+        return {
+          kind: 'script' as const,
+          displayName: trimOptional(effectiveScriptState.displayName) || scriptId,
+          description:
+            'Bind the catalog-applied Script revision as a callable member service. Draft-run remains a Build-only source test.',
+          actionLabel: 'Bind Script member',
+          scriptId,
+          scriptRevision:
+            trimOptional(effectiveScriptState.scriptRevision) ||
+            trimOptional(effectiveScriptState.revisionId),
+          revisionId: trimOptional(effectiveScriptState.revisionId),
+        };
+      }
+    }
+
+    if (activeBuildMode === 'workflow') {
+      if (!trimOptional(draftYaml)) {
+        return null;
+      }
+
+      const displayName =
+        trimOptional(activeWorkflowName) ||
+        trimOptional(draftWorkflowName) ||
+        'draft';
+
+      return {
+        kind: 'workflow' as const,
+        displayName,
+        description:
+          'Publish the current workflow revision first, then Studio can reveal the invoke URL and endpoint contract for this member.',
+        actionLabel: 'Bind current revision',
+      };
+    }
+
+    return null;
   }, [
     activeBuildMode,
     activeWorkflowName,
     draftWorkflowName,
     draftYaml,
     resolvedStudioScopeId,
+    scriptBuildState,
+    selectedScriptId,
+    availableScopeScripts,
+    isBindSurface,
   ]);
   const handleBindPendingCandidate = useCallback(async () => {
     if (!buildPendingBindCandidate || !resolvedStudioScopeId) {
       throw new Error('Resolve the current scope before binding this member.');
     }
 
-    if (buildPendingBindCandidate.kind !== 'workflow') {
-      throw new Error(
-        'Studio can only publish workflow revisions from this surface right now.',
-      );
-    }
-
-    const result = await studioApi.bindScopeWorkflow({
-      scopeId: resolvedStudioScopeId,
-      displayName: buildPendingBindCandidate.displayName,
-      workflowYamls: await buildWorkflowYamlBundle(),
-    });
+    const result =
+      buildPendingBindCandidate.kind === 'workflow'
+        ? await studioApi.bindScopeWorkflow({
+            scopeId: resolvedStudioScopeId,
+            displayName: buildPendingBindCandidate.displayName,
+            workflowYamls: await buildWorkflowYamlBundle(),
+          })
+        : await studioApi.bindScopeScript({
+            scopeId: resolvedStudioScopeId,
+            displayName: buildPendingBindCandidate.displayName,
+            scriptId: buildPendingBindCandidate.scriptId,
+            scriptRevision: buildPendingBindCandidate.scriptRevision,
+            revisionId: buildPendingBindCandidate.revisionId,
+          });
     const servicesResult = await scopeServicesQuery.refetch();
     void scopeBindingQuery.refetch();
     const optimisticBoundServiceId =
@@ -2755,9 +2818,13 @@ const StudioPage: React.FC = () => {
         services: servicesResult.data ?? [],
         candidates: [
           buildPendingBindCandidate.displayName,
+          buildPendingBindCandidate.kind === 'script'
+            ? buildPendingBindCandidate.scriptId
+            : '',
           result.displayName,
           result.targetName,
           result.workflowName,
+          result.script?.scriptId,
         ],
       }) ||
       optimisticBoundServiceId;
@@ -3085,13 +3152,41 @@ const StudioPage: React.FC = () => {
     setCreateMemberModalOpen(false);
   }, [inventoryBusyKey]);
 
-  const handleCreateMember = useCallback(async () => {
-    if (createMemberKind !== 'workflow') {
-      void message.info(
-        createMemberKind === 'script'
-          ? 'Script member creation will move into this modal after the member API lands. For now, continue in Build > Script.'
-          : 'GAgent member creation will move into this modal after the member API lands. For now, continue in Build > GAgent.',
+  const handleCreateMember = useCallback(async (selectedCreateMemberKind: BuildMode) => {
+    if (selectedCreateMemberKind !== 'workflow') {
+      if (selectedCreateMemberKind === 'script' && !appContextQuery.data?.features.scripts) {
+        void message.warning('Script builder is not enabled for this workspace.');
+        return;
+      }
+
+      if (!(await confirmScriptsStudioLeave())) {
+        return;
+      }
+
+      setCreateMemberModalOpen(false);
+      if (selectedCreateMemberKind === 'script') {
+        history.push(
+          buildStudioRoute({
+            scopeId: resolvedStudioScopeId || undefined,
+            step: 'build',
+            tab: 'scripts',
+          }),
+        );
+        setBuildSurface('scripts');
+        setStudioSurface('build');
+        return;
+      }
+
+      history.push(
+        buildStudioRoute({
+          scopeId: resolvedStudioScopeId || undefined,
+          step: 'build',
+          tab: 'gagents',
+        }),
       );
+      setBuildSurface('gagent');
+      setStudioSurface('build');
+      void message.info('Opened GAgent builder.');
       return;
     }
 
@@ -3146,9 +3241,11 @@ const StudioPage: React.FC = () => {
     }
   }, [
     applySavedWorkflowSelection,
-    createMemberKind,
+    appContextQuery.data?.features.scripts,
+    confirmScriptsStudioLeave,
     createMemberDirectoryId,
     createMemberName,
+    history,
     inventoryDirectoryId,
     resolvedStudioScopeId,
     visibleWorkflowSummaries,
@@ -4572,7 +4669,10 @@ const StudioPage: React.FC = () => {
   );
   const bindPendingCandidate =
     bindSelectedMemberServiceId ||
-    !workbenchMemberKey.startsWith('workflow:')
+    !(
+      workbenchMemberKey.startsWith('workflow:') ||
+      workbenchMemberKey.startsWith('script:')
+    )
       ? null
       : buildPendingBindCandidate;
   const bindInitialEndpointId = bindSelectedMemberServiceId
@@ -5188,7 +5288,12 @@ const StudioPage: React.FC = () => {
     Boolean(workbenchMemberKey) &&
     Boolean(
       selectedWorkflowId ||
-        selectedScriptId ||
+        (selectedScriptId
+          ? activeScriptPublishedServiceId ||
+            (scriptBuildState?.scriptId === selectedScriptId &&
+              !scriptBuildState.dirty &&
+              scriptBuildState.saveStatus === 'applied')
+          : false) ||
         workbenchPublishedService ||
         (isBuildGAgentSurface && trimOptional(selectedGAgentTypeName))
     );
@@ -5787,8 +5892,19 @@ const StudioPage: React.FC = () => {
       selectedScriptId={selectedScriptId}
       onSelectScriptId={setSelectedScriptId}
       onRefreshScripts={() => scopeScriptsQuery.refetch()}
-      onContinueToBind={() => applyStudioTarget('bind')}
+      onContinueToBind={() => {
+        history.push(
+          buildStudioRoute({
+            scopeId: resolvedStudioScopeId || undefined,
+            memberKey: selectedScriptId ? `script:${selectedScriptId}` : undefined,
+            step: 'bind',
+            tab: 'bindings',
+          }),
+        );
+        applyStudioTarget('bind');
+      }}
       onRegisterLeaveGuard={handleRegisterScriptLeaveGuard}
+      onScriptBuildStateChange={setScriptBuildState}
     />
   ) : (
     <div
@@ -5984,16 +6100,22 @@ const StudioPage: React.FC = () => {
               open={createMemberModalOpen}
               title="Create member"
               onCancel={closeCreateMemberFlow}
-              onOk={() => void handleCreateMember()}
-              okText="Create member"
+              onOk={() => void handleCreateMember(createMemberKind)}
+              okText={
+                createMemberKind === 'workflow'
+                  ? 'Create member'
+                  : createMemberKind === 'script'
+                    ? 'Open Script builder'
+                    : 'Open GAgent builder'
+              }
               okButtonProps={{
                 disabled:
                   inventoryBusyAction === 'create' ||
-                  !trimOptional(createMemberName) ||
-                  createMemberKind !== 'workflow' ||
-                  !trimOptional(
-                    trimOptional(createMemberDirectoryId) || inventoryDirectoryId,
-                  ),
+                  (createMemberKind === 'workflow' &&
+                    (!trimOptional(createMemberName) ||
+                      !trimOptional(
+                        trimOptional(createMemberDirectoryId) || inventoryDirectoryId,
+                      ))),
                 loading: inventoryBusyAction === 'create',
               }}
               cancelButtonProps={{
@@ -6035,29 +6157,31 @@ const StudioPage: React.FC = () => {
                     ))}
                   </div>
                   <div style={inventoryCreateHintStyle}>
-                    Choose the implementation kind first. Workflow entry is
-                    available now; Script and GAgent member creation will move into
-                    this modal when the member API lands.
+                    Choose the implementation kind first. Workflow creates a blank
+                    draft here; Script and GAgent open their Build workspaces until
+                    their member creation APIs land.
                   </div>
                 </div>
-                <label style={inventoryCreateFieldStackStyle}>
-                  <span style={inventoryCreateFieldLabelStyle}>Member name</span>
-                  <input
-                    aria-label="Member name"
-                    autoFocus
-                    onChange={(event) => setCreateMemberName(event.target.value)}
-                    placeholder={suggestedCreateWorkflowName}
-                    style={inventoryCreateInputStyle}
-                    type="text"
-                    value={createMemberName}
-                  />
-                </label>
+                {createMemberKind === 'workflow' ? (
+                  <label style={inventoryCreateFieldStackStyle}>
+                    <span style={inventoryCreateFieldLabelStyle}>Member name</span>
+                    <input
+                      aria-label="Member name"
+                      autoFocus
+                      onChange={(event) => setCreateMemberName(event.target.value)}
+                      placeholder={suggestedCreateWorkflowName}
+                      style={inventoryCreateInputStyle}
+                      type="text"
+                      value={createMemberName}
+                    />
+                  </label>
+                ) : null}
                 <div style={inventoryCreateHintStyle}>
                   {createMemberKind === 'workflow'
                     ? 'Workflow members currently start from a blank workflow draft with an empty canvas, so you can name it first and then continue editing inside Build.'
                     : createMemberKind === 'script'
-                      ? 'Script member creation still relies on the upcoming member API. For now, continue in Build > Script to inspect or edit script implementations.'
-                      : 'GAgent member creation still relies on the upcoming member API. For now, continue in Build > GAgent to inspect or edit GAgent implementations.'}
+                      ? 'Script member creation still relies on the upcoming member API. Open Build > Script to inspect, edit, save, and prepare script implementations for binding.'
+                      : 'GAgent member creation still relies on the upcoming member API. Open Build > GAgent to select, inspect, and prepare GAgent implementations for binding.'}
                 </div>
                 {createMemberKind === 'workflow' ? (
                   <label style={inventoryCreateFieldStackStyle}>
diff --git a/docs/design/2026-04-27-studio-script-member-flow-implementation-plan.md b/docs/design/2026-04-27-studio-script-member-flow-implementation-plan.md
new file mode 100644
index 000000000..b097e091e
--- /dev/null
+++ b/docs/design/2026-04-27-studio-script-member-flow-implementation-plan.md
@@ -0,0 +1,422 @@
+# Studio Script Member Flow Implementation Plan
+
+Date: 2026-04-27
+Branch: `feat/2026-04-27_complete-studio-script-flow`
+Related issues:
+- https://github.com/aevatarAI/aevatar/issues/441
+- https://github.com/aevatarAI/aevatar/issues/442
+
+## Problem
+
+Studio already exposes parts of the Script implementation workflow, but the user-facing member lifecycle is still uneven.
+
+Today a user can edit and draft-run a Script in Build. They cannot yet trust Studio to move that Script through the same member loop as Workflow: save, observe applied revision, bind as a service, invoke through the bound endpoint contract, and observe runtime facts.
+
+There is also a smaller UX problem in the Create member modal. Script and GAgent are shown as member types, but the modal currently makes their `Member name` input look meaningful even though their direct member create APIs are not available yet.
+
+## Goals
+
+- Keep Script and GAgent visible as member type choices.
+- Make Create member honest: only Workflow creates a member immediately.
+- Treat Script as a first-class member lifecycle participant once a saved revision is observed as applied.
+- Preserve Draft-run as a Build-only action.
+- Bind only catalog-observed Script revisions.
+- Invoke only through the bound service endpoint contract.
+- Avoid a broad frontend adapter rewrite in this branch.
+
+## Non-Goals
+
+- No backend Script runtime protocol redesign.
+- No generic frontend typed command form builder unless the existing endpoint metadata already supports it.
+- No new `StudioMemberTypeAdapter` abstraction in this iteration.
+- No GAgent direct member creation API work.
+- No query-time replay, projection priming, or frontend-owned fact registry.
+
+## UX Structure
+
+Script should read as a member implementation workbench, not as a loose code editor tab. The core structure is:
+
+```text
+Create member
+  -> choose Script
+  -> Open Script builder
+  -> Build > Script
+  -> validate source
+  -> optional draft-run
+  -> save revision
+  -> observe catalog applied
+  -> continue to Bind
+  -> invoke through bound service contract
+  -> observe member facts
+```
+
+The Create member modal stays small and honest:
+
+- Workflow is the only type that asks for `Member name` and creates a draft member immediately.
+- Script and GAgent are visible member types, but they act as builder entries until their member APIs are available.
+- Script action label is `Open Script builder`.
+- GAgent action label is `Open GAgent builder`.
+- The modal should not imply that a Script or GAgent member has been created before the builder and binding lifecycle actually completes.
+
+Build > Script should have a stable three-part layout:
+
+```text
++--------------------------------------------------------------------------------+
+| Script member implementation                                                    |
+| Status: Dirty / Validation failed / Save accepted / Catalog applied / Bound      |
++----------------------------------------------+---------------------------------+
+| Source editor                                 | Readiness checklist             |
+|                                              | [ ] Source selected             |
+|                                              | [ ] Validation clean            |
+|                                              | [ ] Draft-run tested, optional  |
+|                                              | [ ] Save accepted               |
+|                                              | [ ] Catalog applied             |
+|                                              |                                 |
+|                                              | Primary action                  |
+|                                              | Validate / Save revision /      |
+|                                              | Waiting for catalog / Bind      |
++----------------------------------------------+---------------------------------+
+| Draft-run input/output, clearly marked as unsaved-source testing                 |
++--------------------------------------------------------------------------------+
+```
+
+Primary actions should be state-driven:
+
+| State | Primary action | Bind availability |
+| --- | --- | --- |
+| No script selected | Select Script | Hidden |
+| Dirty or unknown | Validate | Hidden |
+| Validation clean | Save revision | Hidden |
+| Save accepted | Waiting for catalog | Hidden |
+| Catalog applied | Continue to Bind | Visible |
+| Bound | Invoke member | Uses the bound service contract |
+
+Key UX rules:
+
+- `Continue to Bind` is not a generic footer action. It appears only after Studio observes the applied Script revision through the catalog or equivalent read model state.
+- Draft-run is explicitly labeled as testing the current editor source. It must not imply that the Script is saved, catalog-applied, or callable as a member service.
+- Bind shows Script as a pending candidate only when the applied revision is clean and not dirty.
+- Invoke is contract-first. If the bound Script exposes a chat-compatible endpoint, Studio can show chat-style invocation. Otherwise it should show the endpoint contract or a clear unsupported state.
+- Observe should prioritize member facts: selected Script revision, binding status, service id, endpoint, actor ids, and latest observed version. Runtime debug details can remain secondary or collapsible.
+
+## Delivery Slices
+
+### Slice 1: Create Member Modal UX
+
+Issue: https://github.com/aevatarAI/aevatar/issues/441
+Milestone: `Create Team / Studio Entry Follow-up`
+
+This is a narrow UI behavior change.
+
+Workflow keeps the current create path:
+
+```text
+Create member
+  -> select Workflow
+  -> enter Member name
+  -> select Workflow directory
+  -> Create member
+  -> blank workflow draft opens in Build
+```
+
+Script and GAgent become builder entry points:
+
+```text
+Create member
+  -> select Script
+  -> Member name is hidden
+  -> Open Script builder
+  -> Build > Script
+
+Create member
+  -> select GAgent
+  -> Member name is hidden
+  -> Open GAgent builder
+  -> Build > GAgent
+```
+
+Implementation scope:
+
+- Update `apps/aevatar-console-web/src/pages/studio/index.tsx`.
+- Keep the existing `Create member` modal.
+- Change modal OK text by selected kind:
+  - Workflow: `Create member`
+  - Script: `Open Script builder`
+  - GAgent: `Open GAgent builder`
+- Render `Member name` and `Workflow directory` only for Workflow.
+- On Script, close the modal and navigate to Build > Script.
+- On GAgent, close the modal and navigate to Build > GAgent.
+- Respect the existing Script leave guard before changing build surfaces.
+- If Script is disabled by workspace features, show a clear warning instead of navigating.
+
+Tests:
+
+- Workflow create still calls the existing workflow save path.
+- Script selection hides `Member name`.
+- Script action opens the Script build panel.
+- GAgent selection hides `Member name`.
+- GAgent action opens the GAgent build panel.
+
+## Slice 2: Script Member Lifecycle
+
+Issue: https://github.com/aevatarAI/aevatar/issues/442
+Milestone: `Studio Script Lifecycle Follow-up`
+
+This is the actual Script member loop.
+
+```text
+Build > Script
+  -> edit source
+  -> validate
+  -> draft-run, optional
+  -> save accepted
+  -> observe catalog applied
+  -> parent Studio receives applied script state
+  -> Bind shows Script pending candidate
+  -> bindScopeScript
+  -> service catalog refetch
+  -> Invoke uses bound service endpoint contract
+  -> Observe shows member/service/runtime facts
+```
+
+### State Model
+
+The parent Studio page should only know lifecycle-ready Script facts. It should not own the editor source as durable state.
+
+Suggested parent state shape:
+
+```ts
+type StudioScriptBuildState = {
+  scriptId: string;
+  displayName: string;
+  scriptRevision: string;
+  revisionId?: string;
+  sourceHash?: string;
+  definitionActorId?: string;
+  dirty: boolean;
+  validationStatus: 'unknown' | 'valid' | 'invalid';
+  saveStatus: 'idle' | 'accepted' | 'applied' | 'failed';
+};
+```
+
+Important rule:
+
+```text
+dirty source          -> no bind candidate
+save accepted only   -> no bind candidate
+save applied/catalog -> bind candidate allowed
+```
+
+### Build Handoff
+
+Add a callback from `StudioScriptBuildPanel` to the Studio parent:
+
+```ts
+onScriptBuildStateChange?: (state: StudioScriptBuildState | null) => void;
+```
+
+`StudioScriptBuildPanel` should emit:
+
+- selected script id
+- display name
+- active or accepted revision
+- dirty state
+- validation status
+- save observation status
+- definition actor id and source hash for display only
+
+It must not ask the parent to infer readiness from UI text like `saveNotice`.
+
+### Bind Candidate
+
+Extend `buildPendingBindCandidate` in `apps/aevatar-console-web/src/pages/studio/index.tsx`.
+
+Current behavior:
+
+```text
+activeBuildMode == workflow
+  -> workflow pending candidate
+otherwise
+  -> null
+```
+
+Target behavior:
+
+```text
+activeBuildMode == workflow
+  -> workflow pending candidate
+
+activeBuildMode == script
+  -> if script build state is applied and not dirty
+       Script pending candidate
+     else
+       null
+
+activeBuildMode == gagent
+  -> no direct candidate in this issue
+```
+
+Script candidate:
+
+```ts
+{
+  kind: 'script',
+  displayName,
+  description: 'Bind the applied Script revision as a callable member service.',
+  actionLabel: 'Bind Script member',
+  scriptId,
+  scriptRevision,
+  revisionId,
+}
+```
+
+### Bind Handler
+
+Extend `handleBindPendingCandidate` to support Script:
+
+```text
+workflow candidate -> studioApi.bindScopeWorkflow
+script candidate   -> studioApi.bindScopeScript
+```
+
+After binding:
+
+- refetch scope services
+- refetch scope binding
+- resolve the bound service id from the response or refreshed catalog
+- select the bound service and default endpoint
+- keep the user on Bind or move to Invoke only through the existing lifecycle action
+
+Do not bind local editor source. Do not bind a merely accepted save.
+
+### Invoke Contract
+
+Script invocation must use the bound service endpoint contract.
+
+Do not assume every Script exposes chat stream. The backend may create Script endpoints from declared command messages. A Script that declares `AppScriptCommand` is not automatically a chat endpoint.
+
+UI behavior:
+
+```text
+bound Script service has chat-compatible endpoint
+  -> allow chat smoke test
+
+bound Script service has non-chat command endpoint
+  -> show endpoint contract
+  -> block chat smoke test with clear copy
+  -> optionally allow typed invoke if existing metadata supports it
+
+no bound Script service
+  -> show "Bind this Script member before invoking it."
+```
+
+### Observe
+
+Observe should lead with member facts, not runtime internals.
+
+Recommended layers:
+
+1. Binding facts:
+   - service id
+   - implementation kind
+   - active revision
+   - script id
+   - script revision
+2. Latest invocation:
+   - run id
+   - endpoint
+   - status
+   - timestamp
+   - error
+3. Runtime debug:
+   - runtime actor id
+   - definition actor id
+   - source hash
+   - state version
+
+Raw actor ids should be secondary or collapsible.
+
+## Failure Modes
+
+| Failure | Expected handling |
+| --- | --- |
+| Script feature disabled | Create modal warns and stays in place. |
+| User has unsaved Script edits | Leave guard blocks navigation unless confirmed. |
+| Save accepted but projection/catalog not applied | Bind candidate remains hidden. |
+| Save observation fails or times out | Show warning, do not allow bind. |
+| Bind API fails | Bind panel shows error notice. |
+| Bound Script has no chat endpoint | Invoke shows endpoint contract and honest blocked state. |
+| Refetched service catalog does not include returned service id yet | Keep current selection stable and show eventual consistency copy. |
+
+## Test Plan
+
+### Unit / Component Tests
+
+Target file:
+
+- `apps/aevatar-console-web/src/pages/studio/index.test.tsx`
+
+Required cases:
+
+- Workflow create path remains unchanged.
+- Script create entry hides `Member name`.
+- Script create action opens Build > Script.
+- GAgent create entry hides `Member name`.
+- GAgent create action opens Build > GAgent.
+- Dirty Script source does not create a bind candidate.
+- Save accepted but not applied does not create a bind candidate.
+- Applied Script revision creates a Script pending bind candidate.
+- Script pending bind calls `studioApi.bindScopeScript`.
+- Script pending bind does not call `studioApi.bindScopeWorkflow`.
+- Non-chat Script endpoint does not render chat smoke test as available.
+
+### API Tests
+
+Existing shared API tests should remain valid:
+
+- `apps/aevatar-console-web/src/shared/studio/api.test.ts`
+- `apps/aevatar-console-web/src/shared/studio/scriptsApi.test.ts`
+
+Add coverage only if request payload shape changes.
+
+### Commands
+
+Run focused UI tests:
+
+```bash
+npm --prefix apps/aevatar-console-web run test:ui -- --runTestsByPath src/pages/studio/index.test.tsx --runInBand
+```
+
+Run type check before handoff:
+
+```bash
+npm --prefix apps/aevatar-console-web run tsc
+```
+
+## Parallelization
+
+Sequential implementation is preferred for this branch.
+
+Both slices touch `apps/aevatar-console-web/src/pages/studio/index.tsx`, and Slice 2 depends on the Create member modal semantics being settled. Splitting into parallel worktrees would create avoidable merge conflicts.
+
+Recommended order:
+
+```text
+1. Finish Create member modal UX
+2. Verify focused Studio page tests
+3. Add Script build state handoff
+4. Add Script bind candidate and bind handler
+5. Add Invoke contract honesty
+6. Verify focused tests and typecheck
+```
+
+## Acceptance Criteria
+
+- Create member modal does not ask for Script/GAgent member names until those APIs exist.
+- Workflow create behavior is unchanged.
+- Script Build can produce a parent-visible applied revision state.
+- Script Bind is gated on catalog-applied revision.
+- Script Bind uses `studioApi.bindScopeScript`.
+- Script Invoke is based on bound endpoint contract.
+- Non-chat Script endpoints are not misrepresented as chat.
+- Tests cover both UI entry behavior and Script lifecycle gates.