Remove AI config approval flow

platform/api/log_events_handlers.go

@@ -25,7 +25,8 @@ func (h *coreHandlers) serverLogEvents(w http.ResponseWriter, r *http.Request) {
 		writeMethodNotAllowed(w, http.MethodGet)
 		return
 	}
-	instance, streams, subscription, err := h.openLogEventSubscription(r)
+	jobID := strings.TrimSpace(r.URL.Query().Get("jobId"))
+	instance, streams, subscription, err := h.openLogEventSubscription(r, jobID)
 	if err != nil {
 		writeServiceError(w, err)
 		return
@@ -45,7 +46,9 @@ func (h *coreHandlers) serverLogEvents(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 
 	active := supervisedLogSession{}
-	if isComponentLogRequest(r) {
+	if jobID != "" {
+		active = activeJobLogSession(jobID, streams)
+	} else if isComponentLogRequest(r) {
 		active = activeComponentLogSession(streams)
 	} else {
 		active = activeSupervisedLogSession(streams)
@@ -72,6 +75,9 @@ func (h *coreHandlers) serverLogEvents(w http.ResponseWriter, r *http.Request) {
 				return
 			}
 			if subscriptionEvent.Kind == service.LogEventSubscriptionEventProcessState {
+				if jobID != "" {
+					continue
+				}
 				if isComponentLogRequest(r) {
 					continue
 				}
@@ -90,7 +96,7 @@ func (h *coreHandlers) serverLogEvents(w http.ResponseWriter, r *http.Request) {
 					flusher.Flush()
 					continue
 				}
-				streams, err = h.loadLiveLogSnapshot(instance.ID, isComponentLogRequest(r))
+				streams, err = h.loadLiveLogSnapshot(instance.ID, isComponentLogRequest(r), jobID)
 				if err != nil {
 					return
 				}
@@ -111,10 +117,16 @@ func (h *coreHandlers) serverLogEvents(w http.ResponseWriter, r *http.Request) {
 			}
 			event := subscriptionEvent.LogEvent
 			candidate := activeSupervisedLogSession([]domain.LogStream{event.Stream})
+			if jobID != "" {
+				if !strings.HasPrefix(event.Stream.ID, "job."+jobID+".") {
+					continue
+				}
+				candidate = activeJobLogSession(jobID, []domain.LogStream{event.Stream})
+			}
 			if active.allStreams {
 				candidate = supervisedLogSession{}
 			}
-			if candidate.sessionID != "" && newerLogSession(candidate, active) {
+			if jobID == "" && candidate.sessionID != "" && newerLogSession(candidate, active) {
 				next := candidate
 				if !sameSupervisedLogSession(active, next) {
 					active = next
@@ -129,7 +141,11 @@ func (h *coreHandlers) serverLogEvents(w http.ResponseWriter, r *http.Request) {
 				}
 			}
 			if !active.contains(event.Stream) {
-				if !active.allStreams || event.Stream.ServerInstanceID != instance.ID {
+				if jobID == "" {
+					if !active.allStreams || event.Stream.ServerInstanceID != instance.ID {
+						continue
+					}
+				} else if !strings.HasPrefix(event.Stream.ID, "job."+jobID+".") {
 					continue
 				}
 				active.streams = append(active.streams, event.Stream)
@@ -161,6 +177,7 @@ func (h *coreHandlers) serverLogEvents(w http.ResponseWriter, r *http.Request) {
 }
 
 type supervisedLogSession struct {
+	jobID      string
 	sessionID  string
 	startedAt  time.Time
 	streams    []domain.LogStream
@@ -193,6 +210,11 @@ func activeSupervisedLogSession(streams []domain.LogStream) supervisedLogSession
 	return active
 }
 
+func activeJobLogSession(jobID string, streams []domain.LogStream) supervisedLogSession {
+	active := supervisedLogSession{jobID: jobID, sessionID: "job:" + jobID, streams: append([]domain.LogStream(nil), streams...)}
+	return active
+}
+
 func newerLogSession(candidate supervisedLogSession, current supervisedLogSession) bool {
 	if candidate.sessionID == "" || candidate.sessionID == current.sessionID {
 		return false
@@ -207,10 +229,13 @@ func newerLogSession(candidate supervisedLogSession, current supervisedLogSessio
 }
 
 func sameSupervisedLogSession(left supervisedLogSession, right supervisedLogSession) bool {
-	return left.sessionID == right.sessionID && left.startedAt.Equal(right.startedAt)
+	return left.jobID == right.jobID && left.sessionID == right.sessionID && left.startedAt.Equal(right.startedAt)
 }
 
 func (session supervisedLogSession) contains(stream domain.LogStream) bool {
+	if session.jobID != "" {
+		return strings.HasPrefix(stream.ID, "job."+session.jobID+".") && session.hasStream(stream.ID)
+	}
 	if session.allStreams {
 		return session.hasStream(stream.ID)
 	}
@@ -240,7 +265,7 @@ func (h *coreHandlers) writeCurrentLogSession(w http.ResponseWriter, serverInsta
 	return emittedThrough, nil
 }
 
-func (h *coreHandlers) openLogEventSubscription(r *http.Request) (domain.ServerInstance, []domain.LogStream, service.LogEventSubscription, error) {
+func (h *coreHandlers) openLogEventSubscription(r *http.Request, jobID string) (domain.ServerInstance, []domain.LogStream, service.LogEventSubscription, error) {
 	var instance domain.ServerInstance
 	var streams []domain.LogStream
 	var subscription service.LogEventSubscription
@@ -270,8 +295,23 @@ func (h *coreHandlers) openLogEventSubscription(r *http.Request) (domain.ServerI
 			return domain.ServerInstance{}, nil, subscription, err
 		}
 	}
+	if err == nil && jobID != "" {
+		if h.enforceAuthorization && isComponentLogRequest(r) {
+			err = fmt.Errorf("job log streams require session authorization")
+		} else {
+			var job domain.Job
+			if h.enforceAuthorization {
+				job, err = h.core.GetJobForSession(bearerToken(r), jobID)
+			} else {
+				job, err = h.core.GetJob(jobID)
+			}
+			if err == nil && job.ServerInstanceID != instance.ID {
+				err = service.ErrForbidden
+			}
+		}
+	}
 	if err == nil {
-		streams, err = h.loadLiveLogSnapshot(instance.ID, isComponentLogRequest(r))
+		streams, err = h.loadLiveLogSnapshot(instance.ID, isComponentLogRequest(r), jobID)
 	}
 	if err != nil && subscription.Close != nil {
 		subscription.Close()
@@ -288,23 +328,25 @@ func isComponentLogRequest(r *http.Request) bool {
 	return ok
 }
 
-func (h *coreHandlers) loadLiveLogSnapshot(serverInstanceID string, includeDeclaredStreams bool) ([]domain.LogStream, error) {
+func (h *coreHandlers) loadLiveLogSnapshot(serverInstanceID string, includeDeclaredStreams bool, jobID string) ([]domain.LogStream, error) {
 	instance, err := h.core.GetServerInstance(serverInstanceID)
 	if err != nil {
 		return nil, err
 	}
-	if strings.TrimSpace(instance.RunEndpointID) == "" {
-		return nil, nil
-	}
-	if !includeDeclaredStreams && instance.State != domain.ServerInstanceStateRunning {
-		return nil, nil
-	}
-	endpoint, err := h.core.GetRunEndpoint(instance.RunEndpointID)
-	if err != nil {
-		return nil, err
-	}
-	if endpoint.Status != domain.RunEndpointStatusOnline {
-		return nil, nil
+	if jobID == "" {
+		if strings.TrimSpace(instance.RunEndpointID) == "" {
+			return nil, nil
+		}
+		if !includeDeclaredStreams && instance.State != domain.ServerInstanceStateRunning {
+			return nil, nil
+		}
+		endpoint, err := h.core.GetRunEndpoint(instance.RunEndpointID)
+		if err != nil {
+			return nil, err
+		}
+		if endpoint.Status != domain.RunEndpointStatusOnline {
+			return nil, nil
+		}
 	}
 	streams, err := h.core.ListLogStreams(domain.LogStreamFilter{ServerInstanceID: instance.ID})
 	if err != nil {
@@ -312,6 +354,12 @@ func (h *coreHandlers) loadLiveLogSnapshot(serverInstanceID string, includeDecla
 	}
 	current := make([]domain.LogStream, 0, len(streams))
 	for _, stream := range streams {
+		if jobID != "" {
+			if strings.HasPrefix(stream.ID, "job."+jobID+".") {
+				current = append(current, stream)
+			}
+			continue
+		}
 		if includeDeclaredStreams {
 			if stream.Source != domain.LogStreamSourceProcess && stream.Source != domain.LogStreamSourceFile && stream.Source != domain.LogStreamSourceManagementProgram {
 				continue

platform/api/log_ingest_handlers_test.go

@@ -189,6 +189,56 @@ func TestLogEventsSSEStreamsBufferedAppendAfterOpen(t *testing.T) {
 	assertSSEEvent(t, reader, "log", `"seq":3`)
 }
 
+func TestLogEventsSSEStreamsScopedJobLogsWhenServerIsStopped(t *testing.T) {
+	router := newTestRouter()
+	hello := createLogIngestAPIFixtures(t, router)
+	job := postJSON[dto.JobResponse](t, router, "/api/v1/jobs", dto.JobCreateRequest{
+		ID: "job-scoped-log", ServerInstanceID: "server-1", RunEndpointID: "run-local", Capability: "process.start", IdempotencyKey: "idem-scoped-log",
+	})
+	assertStatus(t, performJSON(t, router, http.MethodPost, "/api/v1/run/lifecycle/report", dto.RunLifecycleReportRequest{
+		RunEndpointID: "run-local", SessionToken: hello.SessionToken, ServerInstanceID: "server-1", Capability: domain.LifecycleCapabilityStatus, State: domain.JobStateSucceeded,
+		Progress: dto.JobProgressBody{Percent: 100}, ExecutionResult: dto.RunJobExecutionResultBody{Kind: "process", ProcessState: "stopped", ExitClassification: "requested-stop"},
+	}), http.StatusOK)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	request := httptest.NewRequest(http.MethodGet, "/api/v1/server-instances/server-1/logs/events?jobId="+job.ID, nil).WithContext(ctx)
+	streamWriter, streamReader := newSSEPipeResponseWriter()
+	done := make(chan struct{})
+	go func() {
+		router.ServeHTTP(streamWriter, request)
+		_ = streamWriter.Close()
+		close(done)
+	}()
+	t.Cleanup(func() {
+		cancel()
+		_ = streamReader.Close()
+		<-done
+	})
+	if status := <-streamWriter.status; status != http.StatusOK {
+		t.Fatalf("unexpected scoped job SSE status: %d", status)
+	}
+	reader := bufio.NewReader(streamReader)
+	assertSSEEvent(t, reader, "session", `"logSessionId":"job:`+job.ID+`"`)
+	streamOne, streamOneData := readSSEEvent(t, reader)
+	streamTwo, streamTwoData := readSSEEvent(t, reader)
+	if streamOne != "stream" || streamTwo != "stream" || !strings.Contains(streamOneData, `"id":"job.`+job.ID+`.stdout"`) && !strings.Contains(streamTwoData, `"id":"job.`+job.ID+`.stdout"`) || !strings.Contains(streamOneData, `"id":"job.`+job.ID+`.stderr"`) && !strings.Contains(streamTwoData, `"id":"job.`+job.ID+`.stderr"`) {
+		t.Fatalf("unexpected scoped job stream snapshot: %q %s; %q %s", streamOne, streamOneData, streamTwo, streamTwoData)
+	}
+	assertSSEEvent(t, reader, "ready", `"streamCount":2`)
+
+	batch := validLogBatchRequestForStream(t, hello.SessionToken, "job."+job.ID+".stdout", "stdout", 1, 1, 0)
+	batch.LogSessionID = ""
+	batch.SessionStartedAt = time.Time{}
+	batch.Entries[0].Line = "JOB-SCOPED-LIVE-OUTPUT"
+	checksum, err := validator.LogEntriesChecksum([]domain.LogEntry{{Seq: batch.Entries[0].Seq, Timestamp: batch.Entries[0].Timestamp, Level: batch.Entries[0].Level, Line: batch.Entries[0].Line}})
+	if err != nil {
+		t.Fatalf("checksum scoped job log: %v", err)
+	}
+	batch.Checksum = checksum
+	assertStatus(t, performJSON(t, router, http.MethodPost, "/api/v1/run/logs/batches", batch), http.StatusOK)
+	assertSSEEvent(t, reader, "log", `"line":"JOB-SCOPED-LIVE-OUTPUT"`)
+}
+
 func TestLogEventsSSEExcludesOlderSupervisedSessions(t *testing.T) {
 	router := newTestRouter()
 	hello := createLogIngestAPIFixtures(t, router)

platform/api/resource_handlers.go

@@ -54,8 +54,6 @@ func (h *coreHandlers) register(mux *http.ServeMux) {
 	mux.HandleFunc("/api/v1/metrics/server-instances", h.serverInstanceMetrics)
 	mux.HandleFunc("/api/v1/plugin-lifecycles", h.pluginLifecycles)
 	mux.HandleFunc("/api/v1/plugin-lifecycles/{pluginId}/actions", h.pluginLifecycleAction)
-	mux.HandleFunc("/api/v1/ai/config-diffs", h.aiConfigDiffs)
-	mux.HandleFunc("/api/v1/ai/config-diffs/{id}/approve", h.aiConfigDiffApprove)
 	mux.HandleFunc("/api/v1/metrics/server-instances/history", h.metricHistory)
 	mux.HandleFunc("/api/v1/run/metrics/batches", h.requireRunSignature(h.runMetricBatchIngest))
 	mux.HandleFunc("/api/v1/backups", h.backups)
@@ -201,60 +199,6 @@ func (h *coreHandlers) pluginLifecycleAction(w http.ResponseWriter, r *http.Requ
 	writeJSON(w, http.StatusAccepted, dto.PluginLifecycleResultFromDomain(result))
 }
 
-// aiConfigDiffs godoc
-// @Summary List reviewable AI config diffs
-// @Description Lists persisted AI recommendations visible to the current operator without provider credentials or transport configuration.
-// @Tags plugin-operations
-// @Produce json
-// @Success 200 {object} dto.AIConfigDiffListResponse
-// @Failure 401 {object} dto.ErrorResponse
-// @Failure 405 {object} dto.ErrorResponse
-// @Router /api/v1/ai/config-diffs [get]
-func (h *coreHandlers) aiConfigDiffs(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
-		writeMethodNotAllowed(w, http.MethodGet)
-		return
-	}
-	items, err := h.core.ListAIConfigDiffsForSession(bearerToken(r), domain.AIConfigDiffFilter{ServerInstanceID: r.URL.Query().Get("serverInstanceId"), PluginID: r.URL.Query().Get("pluginId"), State: domain.AIConfigDiffState(r.URL.Query().Get("state"))})
-	if err != nil {
-		writeServiceError(w, err)
-		return
-	}
-	writeJSON(w, http.StatusOK, dto.AIConfigDiffListFromDomain(items))
-}
-
-// aiConfigDiffApprove godoc
-// @Summary Approve one reviewable AI config diff
-// @Description Revalidates actor/server/config revision fences before dispatching one bounded config write job.
-// @Tags plugin-operations
-// @Accept json
-// @Produce json
-// @Param id path string true "AI config diff ID"
-// @Param body body dto.AIConfigDiffApprovalRequest true "AI config diff approval"
-// @Success 202 {object} dto.AIConfigDiffApprovalResponse
-// @Failure 400 {object} dto.ErrorResponse
-// @Failure 401 {object} dto.ErrorResponse
-// @Failure 403 {object} dto.ErrorResponse
-// @Failure 405 {object} dto.ErrorResponse
-// @Router /api/v1/ai/config-diffs/{id}/approve [post]
-func (h *coreHandlers) aiConfigDiffApprove(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		writeMethodNotAllowed(w, http.MethodPost)
-		return
-	}
-	request, err := decodeJSON[dto.AIConfigDiffApprovalRequest](r)
-	if err != nil {
-		writeDecodeError(w, err)
-		return
-	}
-	result, err := h.core.ApproveAIConfigDiffForSession(bearerToken(r), request.ToDomain(r.PathValue("id")))
-	if err != nil {
-		writeServiceError(w, err)
-		return
-	}
-	writeJSON(w, http.StatusAccepted, dto.AIConfigDiffApprovalFromDomain(result))
-}
-
 // authRegister godoc
 // @Summary Register a platform account
 // @Description Creates a pending low-privilege platform account without granting platform administrator rights.
@@ -865,7 +809,7 @@ func (h *coreHandlers) aiConfigSuggestion(w http.ResponseWriter, r *http.Request
 		return
 	}
 	response, err := h.core.InvokeAIForSession(bearerToken(r), domain.AIInvocationRequest{
-		RequestID:        "config-suggestion:" + request.ServerInstanceID,
+		RequestID:        fmt.Sprintf("config-suggestion:%s:%d", request.ServerInstanceID, time.Now().UnixNano()),
 		ServerInstanceID: request.ServerInstanceID,
 		Purpose:          "config.suggest",
 		Prompt:           request.Prompt,
@@ -888,7 +832,11 @@ func (h *coreHandlers) aiConfigSuggestion(w http.ResponseWriter, r *http.Request
 	if response.ConfigRecommendation != nil {
 		suggested = response.ConfigRecommendation.SuggestedConfig
 	}
-	writeJSON(w, http.StatusOK, dto.LlmConfigSuggestionResponse{ServerInstanceID: request.ServerInstanceID, Recommendation: response.Recommendation, SuggestedConfig: suggested})
+	var execution *dto.AIConfigExecutionResponse
+	if response.ConfigExecution != nil {
+		execution = &dto.AIConfigExecutionResponse{Status: response.ConfigExecution.Status, Job: dto.JobFromDomain(response.ConfigExecution.Job)}
+	}
+	writeJSON(w, http.StatusOK, dto.LlmConfigSuggestionResponse{ServerInstanceID: request.ServerInstanceID, Recommendation: response.Recommendation, SuggestedConfig: suggested, ConfigExecution: execution})
 }
 
 // gamePlugins godoc

platform/api/resource_handlers_test.go

@@ -1072,6 +1072,7 @@ func TestAIInvocationAPIIsMediatedAndSafe(t *testing.T) {
 	adminSession := createAdminSession(t, router)
 	createAIProviderFixture(t, router, adminSession)
 	registration := validGamePluginManifestRegistrationRequest()
+	registration.Manifest.Capabilities = append(registration.Manifest.Capabilities, domain.JobCapabilityConfigWrite)
 	registration.Manifest.Pages[0].Permissions = []string{"server.read", "server.logs.read", "ai.invoke"}
 	registration.Manifest.Pages[0].BridgeActions = []string{string(domain.PluginBridgeActionServerInstancesRead), string(domain.PluginBridgeActionLogsQuery), string(domain.PluginBridgeActionAIInvoke)}
 	postJSON[dto.GamePluginResponse](t, router, "/api/v1/game-plugins/register-manifest", registration)
@@ -1117,19 +1118,20 @@ func TestAIInvocationAPIIsMediatedAndSafe(t *testing.T) {
 	}, adminSession)
 	assertErrorResponse(t, unsafe, http.StatusBadRequest, errorCodeValidation)
 
+	putJSONWithAuth[dto.RuntimeBindingResponse](t, router, "/api/v1/server-instances/"+instance.ID+"/runtime-binding", dto.RuntimeBindingUpdateRequest{ProfileKey: "local", Bindings: map[string]string{}}, adminSession)
 	configRecorder := requestJSONWithAuth(t, router, http.MethodPost, "/api/v1/ai/config-suggestions", dto.LlmConfigSuggestionRequest{
 		ServerInstanceID: instance.ID,
-		Prompt:           "Turn off pvp and keep this reviewable",
+		Prompt:           "Turn off pvp and apply it now",
 		CurrentConfig:    "server.name=AI API Server\n",
 	}, adminSession)
 	assertStatus(t, configRecorder, http.StatusOK)
 	config := decodeBody[dto.LlmConfigSuggestionResponse](t, configRecorder)
-	if config.SuggestedConfig == "" || !strings.Contains(config.SuggestedConfig, "ai.recommendation=review-required") {
-		t.Fatalf("expected reviewable config suggestion, got %+v", config)
+	if config.SuggestedConfig == "" || config.ConfigExecution == nil || config.ConfigExecution.Job.Capability != domain.JobCapabilityConfigWrite {
+		t.Fatalf("expected immediately dispatched config suggestion, got %+v", config)
 	}
 	jobs := getJSONWithAuth[dto.JobListResponse](t, router, "/api/v1/jobs?serverInstanceId=server-ai-api", adminSession)
-	if jobs.Count != 0 {
-		t.Fatalf("AI suggestion must not dispatch config writes, got %+v", jobs)
+	if jobs.Count != 1 || !containsJobID(jobs.Items, config.ConfigExecution.Job.ID) {
+		t.Fatalf("AI suggestion must dispatch one config write, got %+v", jobs)
 	}
 
 	bridge := postOKJSONWithAuth[dto.PluginBridgeExecuteResponse](t, router, "/api/v1/plugin-bridge/execute", dto.PluginBridgeExecuteRequest{
@@ -1597,22 +1599,16 @@ func TestPluginLifecycleAndAIConfigRoutesAreDurableAndRedacted(t *testing.T) {
 		t.Fatalf("expected persisted plugin lifecycle, got %+v", lifecycles)
 	}
 
-	invocation := postOKJSONWithAuth[dto.AIInvocationResponse](t, router, "/api/v1/ai/invocations", dto.AIInvocationRequest{RequestID: "api-ai-config-diff", ServerInstanceID: serverID, Purpose: "config.suggest", ProviderID: "ai.openai", Prompt: "disable pvp"}, adminSession)
-	if invocation.ConfigRecommendation == nil || invocation.ConfigRecommendation.DiffID == "" {
-		t.Fatalf("expected persisted AI config diff, got %+v", invocation)
+	invocation := postOKJSONWithAuth[dto.AIInvocationResponse](t, router, "/api/v1/ai/invocations", dto.AIInvocationRequest{RequestID: "api-ai-config-direct", ServerInstanceID: serverID, Purpose: "config.suggest", ProviderID: "ai.openai", Prompt: "disable pvp"}, adminSession)
+	if invocation.ConfigRecommendation == nil || invocation.ConfigExecution == nil || invocation.ConfigExecution.Job.Capability != domain.JobCapabilityConfigWrite {
+		t.Fatalf("expected direct AI config write dispatch, got %+v", invocation)
 	}
-	diffs := getJSONWithAuth[dto.AIConfigDiffListResponse](t, router, "/api/v1/ai/config-diffs?serverInstanceId="+serverID, adminSession)
-	if diffs.Count != 1 || diffs.Items[0].State != string(domain.AIConfigDiffStatePending) {
-		t.Fatalf("expected one pending AI diff, got %+v", diffs)
-	}
-	approvalRecorder := requestJSONWithAuth(t, router, http.MethodPost, "/api/v1/ai/config-diffs/"+invocation.ConfigRecommendation.DiffID+"/approve", dto.AIConfigDiffApprovalRequest{IdempotencyKey: "api-ai-diff-approve"}, adminSession)
-	assertStatus(t, approvalRecorder, http.StatusAccepted)
-	approval := decodeBody[dto.AIConfigDiffApprovalResponse](t, approvalRecorder)
-	if approval.Preview.State != string(domain.AIConfigDiffStateApproved) || approval.Dispatch.Job.Capability != domain.JobCapabilityConfigWrite {
-		t.Fatalf("expected approved diff with config write job, got %+v", approval)
+	jobs := getJSONWithAuth[dto.JobListResponse](t, router, "/api/v1/jobs?serverInstanceId="+serverID, adminSession)
+	if jobs.Count < 2 || !containsJobID(jobs.Items, invocation.ConfigExecution.Job.ID) {
+		t.Fatalf("expected AI config write job in durable job list, got %+v", jobs)
 	}
 
-	evidence := fmt.Sprintf("%+v %+v %+v %+v", lifecycle, lifecycles, diffs, approval)
+	evidence := fmt.Sprintf("%+v %+v %+v", lifecycle, lifecycles, invocation)
 	for _, forbidden := range []string{"/Users/", "/private/", "unix://", "tcp://", "Bearer ", "sk-", "password=", "apiKeyRef", "rawApiKey", "https://api.openai.com"} {
 		if strings.Contains(evidence, forbidden) {
 			t.Fatalf("plugin operations response leaked forbidden fragment %q: %s", forbidden, evidence)
@@ -1992,7 +1988,7 @@ func validGamePluginManifestRegistrationRequest() dto.GamePluginManifestRegistra
 					BridgeActions: []string{string(domain.PluginBridgeActionLogsQuery), string(domain.PluginBridgeActionFilesRequest), string(domain.PluginBridgeActionAIInvoke)},
 				},
 			},
-			AI:                  dto.GamePluginManifestAIBody{Purposes: []string{"logs.diagnose"}, Mediation: "platform", ConfigWritePolicy: "review-required"},
+			AI:                  dto.GamePluginManifestAIBody{Purposes: []string{"logs.diagnose"}, Mediation: "platform"},
 			ProductionLifecycle: dto.GamePluginProductionLifecycleBody{Operations: []string{"install", "enable", "disable", "upgrade", "rollback", "retire", "dependency-check"}, DependencyPolicy: "optional"},
 			RuntimeProfiles:     dto.GamePluginRuntimeProfilesBody{LifecycleProfiles: []dto.RuntimeLifecycleProfileBody{{Key: "local", Mode: "local-process", Capabilities: []string{"process.install", "process.start", "process.stop"}}}},
 		},
@@ -2010,3 +2006,12 @@ func validRunEndpointRequest() dto.RunEndpointCreateRequest {
 		},
 	}
 }
+
+func containsJobID(items []dto.JobResponse, id string) bool {
+	for _, item := range items {
+		if item.ID == id {
+			return true
+		}
+	}
+	return false
+}

platform/api/routes.md

@@ -70,7 +70,7 @@ Server owner membership actions hide and reject platform administrators. Server
 
 - `GET /api/v1/metrics/platform`: returns bounded platform CPU, memory, disk, source, and timestamp metadata for platform administrators.
 - `GET /api/v1/metrics/server-instances`: returns bounded per-server metrics only for server instances visible to the authenticated user.
-Server-scoped raw config routes are intentionally not registered as product APIs. AI config assistance returns reviewable typed diff metadata through AI config-diff approval flows rather than raw config text.
+Server-scoped raw config routes are intentionally not registered as product APIs. AI config assistance returns typed recommendation and execution metadata; Platform validates and dispatches the bounded config.write job immediately rather than exposing a separate approval queue.
 
 Observability responses are read-only. They do not expose host filesystem paths, raw credentials, direct run sockets, storage backend credentials, raw AI provider keys, or run session tokens.
 
@@ -85,10 +85,10 @@ File dispatch responses expose only logical target keys, scoped input/artifact r
 - `POST /api/v1/ai-providers/{id}/status`: enable or disable one provider using `AIProviderStatusRequest`.
 - `POST /api/v1/ai-providers/{id}/test`: invoke the configured provider client with a bounded health request and return only a redacted `AIProviderTestResponse`.
 - `GET /api/v1/ai-providers/{id}/models`: return configured model names using `AIProviderModelsResponse`.
-- `POST /api/v1/ai/invocations`: accept `AIInvocationRequest`, authorize explicit purposes, select an active provider, invoke a mockable provider client, and return `AIInvocationResponse` with bounded recommendation text, usage metadata, optional reviewable config recommendation, and safe errors.
-- `POST /api/v1/ai/config-suggestions`: compatibility route for console config assistance. It uses the mediated invocation service with `purpose=config.suggest` and returns `LlmConfigSuggestionResponse` for the existing review/approval workflow.
+- `POST /api/v1/ai/invocations`: accept `AIInvocationRequest`, authorize explicit purposes, select an active provider, invoke a mockable provider client, and return `AIInvocationResponse` with bounded recommendation text, usage metadata, optional config recommendation, direct `configExecution.job` metadata, and safe errors.
+- `POST /api/v1/ai/config-suggestions`: compatibility route for console config assistance. It uses the mediated invocation service with `purpose=config.suggest` and returns `LlmConfigSuggestionResponse` after the bounded config.write job is queued.
 
-AI invocation is platform-mediated. `PLATFORM_AI_PROVIDER_MODE=live` uses the Platform-owned HTTP client and environment secret resolver; local verification explicitly uses `mock`. Invocation responses do not expose provider base URLs, API key refs, raw keys, bearer tokens, host paths, run sockets, or storage credentials. Config suggestions persist an expiring diff and never dispatch run-side writes before separate approval.
+AI invocation is platform-mediated. `PLATFORM_AI_PROVIDER_MODE=live` uses the Platform-owned HTTP client and environment secret resolver; local verification explicitly uses `mock`. Invocation responses do not expose provider base URLs, API key refs, raw keys, bearer tokens, host paths, run sockets, or storage credentials. Config suggestions validate the current config revision/checksum, permissions, runtime binding, endpoint/plugin capability, and content safety before dispatching one bounded run-side write job.
 AI Provider management responses also return only `baseUrlConfigured` and `apiKeyConfigured`; an empty base URL or secret reference in an update preserves the Platform-owned value instead of round-tripping it through the browser.
 
 AI provider management responses expose `apiKeyConfigured` only. Create/update requests may carry a scoped secret reference, and a blank update preserves an existing configured secret; the stored reference is not returned to the browser.
@@ -115,8 +115,6 @@ Marketplace catalog state remains separate from production lifecycle installatio
 
 - `GET /api/v1/plugin-lifecycles`: list server-bound plugin lifecycle installations.
 - `POST /api/v1/plugin-lifecycles/{pluginId}/actions`: validate manifest declaration, compatibility, confirmation, and idempotency before creating one durable Run job.
-- `GET /api/v1/ai/config-diffs`: list reviewable AI config recommendations visible to the session.
-- `POST /api/v1/ai/config-diffs/{id}/approve`: revalidate actor/server/config revision/checksum/expiry and dispatch exactly one bounded `config.write` job.
 
 These responses expose logical IDs, states, safe diagnostics, and job links only. They never project raw credentials, provider transport configuration, Run sessions/endpoints, host paths, PIDs, sockets, DSNs, or RCON material.
 
@@ -152,7 +150,7 @@ Lifecycle workflow responses include accepted status, action, bounded server ins
 - `GET /api/v1/server-instances/{id}/dependencies`: returns the target-matched plugin/profile dependency catalog, current safe probe status/evidence, typed plan summaries, and deterministic immutable plan digests.
 - `POST /api/v1/server-instances/{id}/dependencies/check`: accepts `DependencyJobRequest` and queues a `dependencies.check` run job for a declared logical probe key.
 - `POST /api/v1/server-instances/{id}/dependencies/install`: accepts `DependencyJobRequest` with an install plan key and the exact catalog `planDigest`; stale/missing digests are denied before job creation.
-Server-scoped terminal log streaming (`GET /api/v1/server-instances/{id}/logs/events`) is registered for the server detail terminal drawer and emits platform-accepted live log SSE events only. It does not replay retained log entries or interpret their body; the raw log list/backfill routes (`logs/live` and `logs/backfill`) remain unavailable as product APIs, and internal log ingest and cursor query remain available for run/platform maintenance flows.
+Server-scoped terminal log streaming (`GET /api/v1/server-instances/{id}/logs/events`) is registered for the server detail terminal drawer and emits platform-accepted live log SSE events, or a scoped durable job log stream when `jobId` is supplied. It does not interpret log bodies; the raw log list/backfill routes (`logs/live` and `logs/backfill`) remain unavailable as product APIs, and internal log ingest and cursor query remain available for run/platform maintenance flows.
 
 Runtime distribution APIs require the current bearer session, server visibility, plugin-declared permissions, complete runtime bindings only for actions that truly depend on external logical bindings, and platform-builder readiness. Run-side lifecycle commands separately require run endpoint capability support and use plugin-declared lifecycle actions without making manual runtime-profile binding a user prerequisite. Responses and summaries expose artifact IDs, job IDs, checksums, key generations, fingerprints, status, and redacted `secret://runtime-keys/.../current` refs only. They do not expose raw run keys, FTP passwords, database DSNs, RCON passwords, host paths, direct sockets, run endpoint private addresses, build workspace paths, or large inline logs.